| commit | author | age | ||
| 2c3d81 | 1 | <?php |
| A | 2 | |
| 3 | /* | |
| 4 | +-----------------------------------------------------------------------+ | |
| e019f2 | 5 | | This file is part of the Roundcube Webmail client | |
| 9945f2 | 6 | | Copyright (C) 2005-2012, The Roundcube Dev Team | |
| 7fe381 | 7 | | | |
| T | 8 | | Licensed under the GNU General Public License version 3 or | |
| 9 | | any later version with exceptions for skins & plugins. | | |
| 10 | | See the README file for a full license statement. | | |
| 2c3d81 | 11 | | | |
| A | 12 | | PURPOSE: | |
| 13 | | Provide SMTP functionality using socket connections | | |
| 14 | +-----------------------------------------------------------------------+ | |
| 15 | | Author: Thomas Bruederli <roundcube@gmail.com> | | |
| 16 | +-----------------------------------------------------------------------+ | |
| 17 | */ | |
| 18 | ||
| d062db | 19 | /** |
| T | 20 | * Class to provide SMTP functionality using PEAR Net_SMTP |
| 21 | * | |
| 9ab346 | 22 | * @package Framework |
| AM | 23 | * @subpackage Mail |
| d062db | 24 | * @author Thomas Bruederli <roundcube@gmail.com> |
| T | 25 | * @author Aleksander Machniak <alec@alec.pl> |
| 26 | */ | |
| 27 | class rcube_smtp | |
| 28 | { | |
| 9945f2 | 29 | private $conn = null; |
| AM | 30 | private $response; |
| 31 | private $error; | |
| 0d9ccf | 32 | private $anonymize_log = 0; |
| 2c3d81 | 33 | |
| 9945f2 | 34 | // define headers delimiter |
| AM | 35 | const SMTP_MIME_CRLF = "\r\n"; |
| 2c3d81 | 36 | |
| 43079d | 37 | const DEBUG_LINE_LENGTH = 4098; // 4KB + 2B for \r\n |
| 9b8d22 | 38 | |
| 2c3d81 | 39 | |
| 9945f2 | 40 | /** |
| AM | 41 | * SMTP Connection and authentication |
| 42 | * | |
| 43 | * @param string Server host | |
| 44 | * @param string Server port | |
| 45 | * @param string User name | |
| 46 | * @param string Password | |
| 47 | * | |
| 48 | * @return bool Returns true on success, or false on error | |
| 49 | */ | |
| 50 | public function connect($host=null, $port=null, $user=null, $pass=null) | |
| 2c3d81 | 51 | { |
| 9945f2 | 52 | $rcube = rcube::get_instance(); |
| 2c3d81 | 53 | |
| 9945f2 | 54 | // disconnect/destroy $this->conn |
| d062db | 55 | $this->disconnect(); |
| 2c3d81 | 56 | |
| 9945f2 | 57 | // reset error/response var |
| AM | 58 | $this->error = $this->response = null; |
| 2c3d81 | 59 | |
| 9945f2 | 60 | // let plugins alter smtp connection config |
| AM | 61 | $CONFIG = $rcube->plugins->exec_hook('smtp_connect', array( |
| 62 | 'smtp_server' => $host ? $host : $rcube->config->get('smtp_server'), | |
| 63 | 'smtp_port' => $port ? $port : $rcube->config->get('smtp_port', 25), | |
| 64 | 'smtp_user' => $user ? $user : $rcube->config->get('smtp_user'), | |
| 65 | 'smtp_pass' => $pass ? $pass : $rcube->config->get('smtp_pass'), | |
| 66 | 'smtp_auth_cid' => $rcube->config->get('smtp_auth_cid'), | |
| 67 | 'smtp_auth_pw' => $rcube->config->get('smtp_auth_pw'), | |
| 68 | 'smtp_auth_type' => $rcube->config->get('smtp_auth_type'), | |
| 69 | 'smtp_helo_host' => $rcube->config->get('smtp_helo_host'), | |
| 70 | 'smtp_timeout' => $rcube->config->get('smtp_timeout'), | |
| 357f9c | 71 | 'smtp_conn_options' => $rcube->config->get('smtp_conn_options'), |
| 9945f2 | 72 | 'smtp_auth_callbacks' => array(), |
| AM | 73 | )); |
| 2c3d81 | 74 | |
| 9945f2 | 75 | $smtp_host = rcube_utils::parse_host($CONFIG['smtp_server']); |
| AM | 76 | // when called from Installer it's possible to have empty $smtp_host here |
| 77 | if (!$smtp_host) $smtp_host = 'localhost'; | |
| 78 | $smtp_port = is_numeric($CONFIG['smtp_port']) ? $CONFIG['smtp_port'] : 25; | |
| 79 | $smtp_host_url = parse_url($smtp_host); | |
| 2c3d81 | 80 | |
| 9945f2 | 81 | // overwrite port |
| AM | 82 | if (isset($smtp_host_url['host']) && isset($smtp_host_url['port'])) { |
| 83 | $smtp_host = $smtp_host_url['host']; | |
| 84 | $smtp_port = $smtp_host_url['port']; | |
| 2c3d81 | 85 | } |
| A | 86 | |
| 9945f2 | 87 | // re-write smtp host |
| AM | 88 | if (isset($smtp_host_url['host']) && isset($smtp_host_url['scheme'])) { |
| 89 | $smtp_host = sprintf('%s://%s', $smtp_host_url['scheme'], $smtp_host_url['host']); | |
| 2c3d81 | 90 | } |
| 9945f2 | 91 | |
| AM | 92 | // remove TLS prefix and set flag for use in Net_SMTP::auth() |
| 93 | if (preg_match('#^tls://#i', $smtp_host)) { | |
| 94 | $smtp_host = preg_replace('#^tls://#i', '', $smtp_host); | |
| 95 | $use_tls = true; | |
| 96 | } | |
| 97 | ||
| 98 | if (!empty($CONFIG['smtp_helo_host'])) { | |
| 99 | $helo_host = $CONFIG['smtp_helo_host']; | |
| 100 | } | |
| 101 | else if (!empty($_SERVER['SERVER_NAME'])) { | |
| 102 | $helo_host = preg_replace('/:\d+$/', '', $_SERVER['SERVER_NAME']); | |
| 103 | } | |
| 104 | else { | |
| 105 | $helo_host = 'localhost'; | |
| 106 | } | |
| 107 | ||
| 108 | // IDNA Support | |
| 109 | $smtp_host = rcube_utils::idn_to_ascii($smtp_host); | |
| 110 | ||
| 357f9c | 111 | $this->conn = new Net_SMTP($smtp_host, $smtp_port, $helo_host, false, 0, $CONFIG['smtp_conn_options']); |
| 9945f2 | 112 | |
| AM | 113 | if ($rcube->config->get('smtp_debug')) { |
| 114 | $this->conn->setDebug(true, array($this, 'debug_handler')); | |
| 0d9ccf | 115 | $this->anonymize_log = 0; |
| 9945f2 | 116 | } |
| AM | 117 | |
| 118 | // register authentication methods | |
| 119 | if (!empty($CONFIG['smtp_auth_callbacks']) && method_exists($this->conn, 'setAuthMethod')) { | |
| 120 | foreach ($CONFIG['smtp_auth_callbacks'] as $callback) { | |
| 121 | $this->conn->setAuthMethod($callback['name'], $callback['function'], | |
| 122 | isset($callback['prepend']) ? $callback['prepend'] : true); | |
| 123 | } | |
| 124 | } | |
| 125 | ||
| 126 | // try to connect to server and exit on failure | |
| ce89ec | 127 | $result = $this->conn->connect($CONFIG['smtp_timeout']); |
| 9945f2 | 128 | |
| AM | 129 | if (PEAR::isError($result)) { |
| 130 | $this->response[] = "Connection failed: ".$result->getMessage(); | |
| 131 | $this->error = array('label' => 'smtpconnerror', 'vars' => array('code' => $this->conn->_code)); | |
| 132 | $this->conn = null; | |
| 133 | return false; | |
| 134 | } | |
| 135 | ||
| 136 | // workaround for timeout bug in Net_SMTP 1.5.[0-1] (#1487843) | |
| 137 | if (method_exists($this->conn, 'setTimeout') | |
| 138 | && ($timeout = ini_get('default_socket_timeout')) | |
| 139 | ) { | |
| 140 | $this->conn->setTimeout($timeout); | |
| 141 | } | |
| 142 | ||
| 143 | $smtp_user = str_replace('%u', $rcube->get_user_name(), $CONFIG['smtp_user']); | |
| 144 | $smtp_pass = str_replace('%p', $rcube->get_user_password(), $CONFIG['smtp_pass']); | |
| 145 | $smtp_auth_type = empty($CONFIG['smtp_auth_type']) ? NULL : $CONFIG['smtp_auth_type']; | |
| 146 | ||
| 147 | if (!empty($CONFIG['smtp_auth_cid'])) { | |
| 148 | $smtp_authz = $smtp_user; | |
| 149 | $smtp_user = $CONFIG['smtp_auth_cid']; | |
| 150 | $smtp_pass = $CONFIG['smtp_auth_pw']; | |
| 151 | } | |
| 152 | ||
| 153 | // attempt to authenticate to the SMTP server | |
| 154 | if ($smtp_user && $smtp_pass) { | |
| 155 | // IDNA Support | |
| 156 | if (strpos($smtp_user, '@')) { | |
| 157 | $smtp_user = rcube_utils::idn_to_ascii($smtp_user); | |
| 158 | } | |
| 159 | ||
| 160 | $result = $this->conn->auth($smtp_user, $smtp_pass, $smtp_auth_type, $use_tls, $smtp_authz); | |
| 161 | ||
| 162 | if (PEAR::isError($result)) { | |
| 163 | $this->error = array('label' => 'smtpautherror', 'vars' => array('code' => $this->conn->_code)); | |
| 164 | $this->response[] .= 'Authentication failure: ' . $result->getMessage() . ' (Code: ' . $result->getCode() . ')'; | |
| 165 | $this->reset(); | |
| 166 | $this->disconnect(); | |
| 167 | return false; | |
| 168 | } | |
| 169 | } | |
| 170 | ||
| 171 | return true; | |
| 2c3d81 | 172 | } |
| 6d0ada | 173 | |
| 9945f2 | 174 | /** |
| AM | 175 | * Function for sending mail |
| 176 | * | |
| 177 | * @param string Sender e-Mail address | |
| 178 | * | |
| 179 | * @param mixed Either a comma-seperated list of recipients | |
| 180 | * (RFC822 compliant), or an array of recipients, | |
| 181 | * each RFC822 valid. This may contain recipients not | |
| 182 | * specified in the headers, for Bcc:, resending | |
| 183 | * messages, etc. | |
| 184 | * @param mixed The message headers to send with the mail | |
| 185 | * Either as an associative array or a finally | |
| 186 | * formatted string | |
| 187 | * @param mixed The full text of the message body, including any Mime parts | |
| 188 | * or file handle | |
| 189 | * @param array Delivery options (e.g. DSN request) | |
| 190 | * | |
| 191 | * @return bool Returns true on success, or false on error | |
| 192 | */ | |
| 193 | public function send_mail($from, $recipients, &$headers, &$body, $opts=null) | |
| 194 | { | |
| 195 | if (!is_object($this->conn)) { | |
| 196 | return false; | |
| 197 | } | |
| 2c3d81 | 198 | |
| 9945f2 | 199 | // prepare message headers as string |
| AM | 200 | if (is_array($headers)) { |
| 201 | if (!($headerElements = $this->_prepare_headers($headers))) { | |
| 202 | $this->reset(); | |
| 203 | return false; | |
| 204 | } | |
| 205 | ||
| 206 | list($from, $text_headers) = $headerElements; | |
| 207 | } | |
| 208 | else if (is_string($headers)) { | |
| 209 | $text_headers = $headers; | |
| 210 | } | |
| 211 | else { | |
| 212 | $this->reset(); | |
| 213 | $this->response[] = "Invalid message headers"; | |
| 214 | return false; | |
| 215 | } | |
| 216 | ||
| 217 | // exit if no from address is given | |
| 218 | if (!isset($from)) { | |
| 219 | $this->reset(); | |
| 220 | $this->response[] = "No From address has been provided"; | |
| 221 | return false; | |
| 222 | } | |
| 223 | ||
| 224 | // RFC3461: Delivery Status Notification | |
| 225 | if ($opts['dsn']) { | |
| 226 | $exts = $this->conn->getServiceExtensions(); | |
| 227 | ||
| 228 | if (isset($exts['DSN'])) { | |
| 229 | $from_params = 'RET=HDRS'; | |
| 230 | $recipient_params = 'NOTIFY=SUCCESS,FAILURE'; | |
| 231 | } | |
| 232 | } | |
| 233 | ||
| 234 | // RFC2298.3: remove envelope sender address | |
| 232535 | 235 | if (empty($opts['mdn_use_from']) |
| AM | 236 | && preg_match('/Content-Type: multipart\/report/', $text_headers) |
| 9945f2 | 237 | && preg_match('/report-type=disposition-notification/', $text_headers) |
| AM | 238 | ) { |
| 239 | $from = ''; | |
| 240 | } | |
| 241 | ||
| 242 | // set From: address | |
| 243 | if (PEAR::isError($this->conn->mailFrom($from, $from_params))) { | |
| 244 | $err = $this->conn->getResponse(); | |
| 245 | $this->error = array('label' => 'smtpfromerror', 'vars' => array( | |
| 78f948 | 246 | 'from' => $from, 'code' => $err[0], 'msg' => $err[1])); |
| AM | 247 | $this->response[] = "Failed to set sender '$from'. " |
| 248 | . $err[1] . ' (Code: ' . $err[0] . ')'; | |
| 9945f2 | 249 | $this->reset(); |
| AM | 250 | return false; |
| 251 | } | |
| 252 | ||
| 253 | // prepare list of recipients | |
| 254 | $recipients = $this->_parse_rfc822($recipients); | |
| 255 | if (PEAR::isError($recipients)) { | |
| 256 | $this->error = array('label' => 'smtprecipientserror'); | |
| 257 | $this->reset(); | |
| 258 | return false; | |
| 259 | } | |
| 260 | ||
| 261 | // set mail recipients | |
| 262 | foreach ($recipients as $recipient) { | |
| 263 | if (PEAR::isError($this->conn->rcptTo($recipient, $recipient_params))) { | |
| 264 | $err = $this->conn->getResponse(); | |
| 265 | $this->error = array('label' => 'smtptoerror', 'vars' => array( | |
| 78f948 | 266 | 'to' => $recipient, 'code' => $err[0], 'msg' => $err[1])); |
| AM | 267 | $this->response[] = "Failed to add recipient '$recipient'. " |
| 268 | . $err[1] . ' (Code: ' . $err[0] . ')'; | |
| 9945f2 | 269 | $this->reset(); |
| AM | 270 | return false; |
| 271 | } | |
| 272 | } | |
| 273 | ||
| 274 | if (is_resource($body)) { | |
| 275 | // file handle | |
| 276 | $data = $body; | |
| 277 | $text_headers = preg_replace('/[\r\n]+$/', '', $text_headers); | |
| 278 | } | |
| 279 | else { | |
| 280 | // Concatenate headers and body so it can be passed by reference to SMTP_CONN->data | |
| 281 | // so preg_replace in SMTP_CONN->quotedata will store a reference instead of a copy. | |
| 282 | // We are still forced to make another copy here for a couple ticks so we don't really | |
| 283 | // get to save a copy in the method call. | |
| 284 | $data = $text_headers . "\r\n" . $body; | |
| 285 | ||
| 286 | // unset old vars to save data and so we can pass into SMTP_CONN->data by reference. | |
| 287 | unset($text_headers, $body); | |
| 288 | } | |
| 289 | ||
| 290 | // Send the message's headers and the body as SMTP data. | |
| 78f948 | 291 | if (PEAR::isError($this->conn->data($data, $text_headers))) { |
| 9945f2 | 292 | $err = $this->conn->getResponse(); |
| AM | 293 | if (!in_array($err[0], array(354, 250, 221))) { |
| 294 | $msg = sprintf('[%d] %s', $err[0], $err[1]); | |
| 295 | } | |
| 296 | else { | |
| 297 | $msg = $result->getMessage(); | |
| 298 | } | |
| 299 | ||
| 300 | $this->error = array('label' => 'smtperror', 'vars' => array('msg' => $msg)); | |
| 78f948 | 301 | $this->response[] = "Failed to send data. " . $msg; |
| 9945f2 | 302 | $this->reset(); |
| AM | 303 | return false; |
| 304 | } | |
| 305 | ||
| 306 | $this->response[] = join(': ', $this->conn->getResponse()); | |
| 307 | return true; | |
| 308 | } | |
| 309 | ||
| 310 | /** | |
| 311 | * Reset the global SMTP connection | |
| 312 | */ | |
| 313 | public function reset() | |
| 314 | { | |
| 315 | if (is_object($this->conn)) { | |
| 316 | $this->conn->rset(); | |
| 317 | } | |
| 318 | } | |
| 319 | ||
| 320 | /** | |
| 321 | * Disconnect the global SMTP connection | |
| 322 | */ | |
| 323 | public function disconnect() | |
| 324 | { | |
| 325 | if (is_object($this->conn)) { | |
| 326 | $this->conn->disconnect(); | |
| 327 | $this->conn = null; | |
| 328 | } | |
| 329 | } | |
| 330 | ||
| 331 | ||
| 332 | /** | |
| 333 | * This is our own debug handler for the SMTP connection | |
| 334 | */ | |
| 335 | public function debug_handler(&$smtp, $message) | |
| 336 | { | |
| 0d9ccf | 337 | // catch AUTH commands and set anonymization flag for subsequent sends |
| TB | 338 | if (preg_match('/^Send: AUTH ([A-Z]+)/', $message, $m)) { |
| 339 | $this->anonymize_log = $m[1] == 'LOGIN' ? 2 : 1; | |
| 340 | } | |
| 341 | // anonymize this log entry | |
| 342 | else if ($this->anonymize_log > 0 && strpos($message, 'Send:') === 0 && --$this->anonymize_log == 0) { | |
| 343 | $message = sprintf('Send: ****** [%d]', strlen($message) - 8); | |
| 344 | } | |
| 345 | ||
| 9b8d22 | 346 | if (($len = strlen($message)) > self::DEBUG_LINE_LENGTH) { |
| 43079d | 347 | $diff = $len - self::DEBUG_LINE_LENGTH; |
| AM | 348 | $message = substr($message, 0, self::DEBUG_LINE_LENGTH) |
| 349 | . "... [truncated $diff bytes]"; | |
| 9b8d22 | 350 | } |
| AM | 351 | |
| 9945f2 | 352 | rcube::write_log('smtp', preg_replace('/\r\n$/', '', $message)); |
| AM | 353 | } |
| 354 | ||
| 355 | /** | |
| 356 | * Get error message | |
| 357 | */ | |
| 358 | public function get_error() | |
| 359 | { | |
| 360 | return $this->error; | |
| 361 | } | |
| 362 | ||
| 363 | /** | |
| 364 | * Get server response messages array | |
| 365 | */ | |
| 366 | public function get_response() | |
| 367 | { | |
| 368 | return $this->response; | |
| 369 | } | |
| 370 | ||
| 371 | /** | |
| 372 | * Take an array of mail headers and return a string containing | |
| 373 | * text usable in sending a message. | |
| 374 | * | |
| 375 | * @param array $headers The array of headers to prepare, in an associative | |
| 376 | * array, where the array key is the header name (ie, | |
| 377 | * 'Subject'), and the array value is the header | |
| 378 | * value (ie, 'test'). The header produced from those | |
| 379 | * values would be 'Subject: test'. | |
| 380 | * | |
| 381 | * @return mixed Returns false if it encounters a bad address, | |
| 382 | * otherwise returns an array containing two | |
| 383 | * elements: Any From: address found in the headers, | |
| 384 | * and the plain text version of the headers. | |
| 385 | */ | |
| 386 | private function _prepare_headers($headers) | |
| 387 | { | |
| 388 | $lines = array(); | |
| 389 | $from = null; | |
| 390 | ||
| 391 | foreach ($headers as $key => $value) { | |
| 392 | if (strcasecmp($key, 'From') === 0) { | |
| 393 | $addresses = $this->_parse_rfc822($value); | |
| 394 | ||
| 395 | if (is_array($addresses)) { | |
| 396 | $from = $addresses[0]; | |
| 397 | } | |
| 398 | ||
| 399 | // Reject envelope From: addresses with spaces. | |
| 400 | if (strpos($from, ' ') !== false) { | |
| 401 | return false; | |
| 402 | } | |
| 403 | ||
| 404 | $lines[] = $key . ': ' . $value; | |
| 405 | } | |
| 406 | else if (strcasecmp($key, 'Received') === 0) { | |
| 407 | $received = array(); | |
| 408 | if (is_array($value)) { | |
| 409 | foreach ($value as $line) { | |
| 410 | $received[] = $key . ': ' . $line; | |
| 411 | } | |
| 412 | } | |
| 413 | else { | |
| 414 | $received[] = $key . ': ' . $value; | |
| 415 | } | |
| 416 | ||
| 417 | // Put Received: headers at the top. Spam detectors often | |
| 418 | // flag messages with Received: headers after the Subject: | |
| 419 | // as spam. | |
| 420 | $lines = array_merge($received, $lines); | |
| 421 | } | |
| 422 | else { | |
| 423 | // If $value is an array (i.e., a list of addresses), convert | |
| 424 | // it to a comma-delimited string of its elements (addresses). | |
| 425 | if (is_array($value)) { | |
| 426 | $value = implode(', ', $value); | |
| 427 | } | |
| 428 | ||
| 429 | $lines[] = $key . ': ' . $value; | |
| 430 | } | |
| 431 | } | |
| 432 | ||
| 433 | return array($from, join(self::SMTP_MIME_CRLF, $lines) . self::SMTP_MIME_CRLF); | |
| 434 | } | |
| 435 | ||
| 436 | /** | |
| 437 | * Take a set of recipients and parse them, returning an array of | |
| 438 | * bare addresses (forward paths) that can be passed to sendmail | |
| 439 | * or an smtp server with the rcpt to: command. | |
| 440 | * | |
| 441 | * @param mixed Either a comma-seperated list of recipients | |
| 442 | * (RFC822 compliant), or an array of recipients, | |
| 443 | * each RFC822 valid. | |
| 444 | * | |
| 445 | * @return array An array of forward paths (bare addresses). | |
| 446 | */ | |
| 447 | private function _parse_rfc822($recipients) | |
| 448 | { | |
| 449 | // if we're passed an array, assume addresses are valid and implode them before parsing. | |
| 450 | if (is_array($recipients)) { | |
| 451 | $recipients = implode(', ', $recipients); | |
| 452 | } | |
| 453 | ||
| 454 | $addresses = array(); | |
| 455 | $recipients = rcube_utils::explode_quoted_string(',', $recipients); | |
| 456 | ||
| 457 | reset($recipients); | |
| 3725cf | 458 | foreach ($recipients as $recipient) { |
| 9945f2 | 459 | $a = rcube_utils::explode_quoted_string(' ', $recipient); |
| 3725cf | 460 | foreach ($a as $word) { |
| 9945f2 | 461 | if (strpos($word, "@") > 0 && $word[strlen($word)-1] != '"') { |
| AM | 462 | $word = preg_replace('/^<|>$/', '', trim($word)); |
| 463 | if (in_array($word, $addresses) === false) { | |
| 464 | array_push($addresses, $word); | |
| 465 | } | |
| 466 | } | |
| 467 | } | |
| 468 | } | |
| 469 | ||
| 470 | return $addresses; | |
| 471 | } | |
| 2c3d81 | 472 | } |
