| 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)) { |
| 67229a | 130 | list($code,) = $this->conn->getResponse(); |
| AM | 131 | $this->error = array('label' => 'smtpconnerror', 'vars' => array('code' => $code)); |
| 9945f2 | 132 | $this->conn = null; |
| 67229a | 133 | |
| 9945f2 | 134 | return false; |
| AM | 135 | } |
| 136 | ||
| 137 | // workaround for timeout bug in Net_SMTP 1.5.[0-1] (#1487843) | |
| 138 | if (method_exists($this->conn, 'setTimeout') | |
| 139 | && ($timeout = ini_get('default_socket_timeout')) | |
| 140 | ) { | |
| 141 | $this->conn->setTimeout($timeout); | |
| 142 | } | |
| 143 | ||
| 144 | $smtp_user = str_replace('%u', $rcube->get_user_name(), $CONFIG['smtp_user']); | |
| 145 | $smtp_pass = str_replace('%p', $rcube->get_user_password(), $CONFIG['smtp_pass']); | |
| 146 | $smtp_auth_type = empty($CONFIG['smtp_auth_type']) ? NULL : $CONFIG['smtp_auth_type']; | |
| 147 | ||
| 148 | if (!empty($CONFIG['smtp_auth_cid'])) { | |
| 149 | $smtp_authz = $smtp_user; | |
| 150 | $smtp_user = $CONFIG['smtp_auth_cid']; | |
| 151 | $smtp_pass = $CONFIG['smtp_auth_pw']; | |
| 152 | } | |
| 153 | ||
| 154 | // attempt to authenticate to the SMTP server | |
| 155 | if ($smtp_user && $smtp_pass) { | |
| 156 | // IDNA Support | |
| 157 | if (strpos($smtp_user, '@')) { | |
| 158 | $smtp_user = rcube_utils::idn_to_ascii($smtp_user); | |
| 159 | } | |
| 160 | ||
| 161 | $result = $this->conn->auth($smtp_user, $smtp_pass, $smtp_auth_type, $use_tls, $smtp_authz); | |
| 162 | ||
| 163 | if (PEAR::isError($result)) { | |
| 67229a | 164 | list($code,) = $this->conn->getResponse(); |
| AM | 165 | $this->error = array('label' => 'smtpautherror', 'vars' => array('code' => $code)); |
| 166 | $this->response[] = 'Authentication failure: ' . $result->getMessage() | |
| 167 | . ' (Code: ' . $result->getCode() . ')'; | |
| 168 | ||
| 9945f2 | 169 | $this->reset(); |
| AM | 170 | $this->disconnect(); |
| 67229a | 171 | |
| 9945f2 | 172 | return false; |
| AM | 173 | } |
| 174 | } | |
| 175 | ||
| 176 | return true; | |
| 2c3d81 | 177 | } |
| 6d0ada | 178 | |
| 9945f2 | 179 | /** |
| AM | 180 | * Function for sending mail |
| 181 | * | |
| 182 | * @param string Sender e-Mail address | |
| 183 | * | |
| 184 | * @param mixed Either a comma-seperated list of recipients | |
| 185 | * (RFC822 compliant), or an array of recipients, | |
| 186 | * each RFC822 valid. This may contain recipients not | |
| 187 | * specified in the headers, for Bcc:, resending | |
| 188 | * messages, etc. | |
| 189 | * @param mixed The message headers to send with the mail | |
| 190 | * Either as an associative array or a finally | |
| 191 | * formatted string | |
| 192 | * @param mixed The full text of the message body, including any Mime parts | |
| 193 | * or file handle | |
| 194 | * @param array Delivery options (e.g. DSN request) | |
| 195 | * | |
| 196 | * @return bool Returns true on success, or false on error | |
| 197 | */ | |
| 198 | public function send_mail($from, $recipients, &$headers, &$body, $opts=null) | |
| 199 | { | |
| 200 | if (!is_object($this->conn)) { | |
| 201 | return false; | |
| 202 | } | |
| 2c3d81 | 203 | |
| 9945f2 | 204 | // prepare message headers as string |
| AM | 205 | if (is_array($headers)) { |
| 206 | if (!($headerElements = $this->_prepare_headers($headers))) { | |
| 207 | $this->reset(); | |
| 208 | return false; | |
| 209 | } | |
| 210 | ||
| 211 | list($from, $text_headers) = $headerElements; | |
| 212 | } | |
| 213 | else if (is_string($headers)) { | |
| 214 | $text_headers = $headers; | |
| 215 | } | |
| 216 | else { | |
| 217 | $this->reset(); | |
| 218 | $this->response[] = "Invalid message headers"; | |
| 219 | return false; | |
| 220 | } | |
| 221 | ||
| 222 | // exit if no from address is given | |
| 223 | if (!isset($from)) { | |
| 224 | $this->reset(); | |
| 225 | $this->response[] = "No From address has been provided"; | |
| 226 | return false; | |
| 227 | } | |
| 228 | ||
| 229 | // RFC3461: Delivery Status Notification | |
| 230 | if ($opts['dsn']) { | |
| 231 | $exts = $this->conn->getServiceExtensions(); | |
| 232 | ||
| 233 | if (isset($exts['DSN'])) { | |
| 234 | $from_params = 'RET=HDRS'; | |
| 235 | $recipient_params = 'NOTIFY=SUCCESS,FAILURE'; | |
| 236 | } | |
| 237 | } | |
| 238 | ||
| 239 | // RFC2298.3: remove envelope sender address | |
| 232535 | 240 | if (empty($opts['mdn_use_from']) |
| AM | 241 | && preg_match('/Content-Type: multipart\/report/', $text_headers) |
| 9945f2 | 242 | && preg_match('/report-type=disposition-notification/', $text_headers) |
| AM | 243 | ) { |
| 244 | $from = ''; | |
| 245 | } | |
| 246 | ||
| 247 | // set From: address | |
| 248 | if (PEAR::isError($this->conn->mailFrom($from, $from_params))) { | |
| 249 | $err = $this->conn->getResponse(); | |
| 250 | $this->error = array('label' => 'smtpfromerror', 'vars' => array( | |
| 78f948 | 251 | 'from' => $from, 'code' => $err[0], 'msg' => $err[1])); |
| AM | 252 | $this->response[] = "Failed to set sender '$from'. " |
| 253 | . $err[1] . ' (Code: ' . $err[0] . ')'; | |
| 9945f2 | 254 | $this->reset(); |
| AM | 255 | return false; |
| 256 | } | |
| 257 | ||
| 258 | // prepare list of recipients | |
| 259 | $recipients = $this->_parse_rfc822($recipients); | |
| 260 | if (PEAR::isError($recipients)) { | |
| 261 | $this->error = array('label' => 'smtprecipientserror'); | |
| 262 | $this->reset(); | |
| 263 | return false; | |
| 264 | } | |
| 265 | ||
| 266 | // set mail recipients | |
| 267 | foreach ($recipients as $recipient) { | |
| 268 | if (PEAR::isError($this->conn->rcptTo($recipient, $recipient_params))) { | |
| 269 | $err = $this->conn->getResponse(); | |
| 270 | $this->error = array('label' => 'smtptoerror', 'vars' => array( | |
| 78f948 | 271 | 'to' => $recipient, 'code' => $err[0], 'msg' => $err[1])); |
| AM | 272 | $this->response[] = "Failed to add recipient '$recipient'. " |
| 273 | . $err[1] . ' (Code: ' . $err[0] . ')'; | |
| 9945f2 | 274 | $this->reset(); |
| AM | 275 | return false; |
| 276 | } | |
| 277 | } | |
| 278 | ||
| 279 | if (is_resource($body)) { | |
| 280 | // file handle | |
| 281 | $data = $body; | |
| 282 | $text_headers = preg_replace('/[\r\n]+$/', '', $text_headers); | |
| 283 | } | |
| 284 | else { | |
| 285 | // Concatenate headers and body so it can be passed by reference to SMTP_CONN->data | |
| 286 | // so preg_replace in SMTP_CONN->quotedata will store a reference instead of a copy. | |
| 287 | // We are still forced to make another copy here for a couple ticks so we don't really | |
| 288 | // get to save a copy in the method call. | |
| 289 | $data = $text_headers . "\r\n" . $body; | |
| 290 | ||
| 291 | // unset old vars to save data and so we can pass into SMTP_CONN->data by reference. | |
| 292 | unset($text_headers, $body); | |
| 293 | } | |
| 294 | ||
| 295 | // Send the message's headers and the body as SMTP data. | |
| 997ff7 | 296 | $result = $this->conn->data($data, $text_headers); |
| AM | 297 | if (PEAR::isError($result)) { |
| 9945f2 | 298 | $err = $this->conn->getResponse(); |
| AM | 299 | if (!in_array($err[0], array(354, 250, 221))) { |
| 300 | $msg = sprintf('[%d] %s', $err[0], $err[1]); | |
| 301 | } | |
| 302 | else { | |
| 303 | $msg = $result->getMessage(); | |
| 304 | } | |
| 305 | ||
| 306 | $this->error = array('label' => 'smtperror', 'vars' => array('msg' => $msg)); | |
| 78f948 | 307 | $this->response[] = "Failed to send data. " . $msg; |
| 9945f2 | 308 | $this->reset(); |
| AM | 309 | return false; |
| 310 | } | |
| 311 | ||
| 312 | $this->response[] = join(': ', $this->conn->getResponse()); | |
| 313 | return true; | |
| 314 | } | |
| 315 | ||
| 316 | /** | |
| 317 | * Reset the global SMTP connection | |
| 318 | */ | |
| 319 | public function reset() | |
| 320 | { | |
| 321 | if (is_object($this->conn)) { | |
| 322 | $this->conn->rset(); | |
| 323 | } | |
| 324 | } | |
| 325 | ||
| 326 | /** | |
| 327 | * Disconnect the global SMTP connection | |
| 328 | */ | |
| 329 | public function disconnect() | |
| 330 | { | |
| 331 | if (is_object($this->conn)) { | |
| 332 | $this->conn->disconnect(); | |
| 333 | $this->conn = null; | |
| 334 | } | |
| 335 | } | |
| 336 | ||
| 337 | ||
| 338 | /** | |
| 339 | * This is our own debug handler for the SMTP connection | |
| 340 | */ | |
| 341 | public function debug_handler(&$smtp, $message) | |
| 342 | { | |
| 0d9ccf | 343 | // catch AUTH commands and set anonymization flag for subsequent sends |
| TB | 344 | if (preg_match('/^Send: AUTH ([A-Z]+)/', $message, $m)) { |
| 345 | $this->anonymize_log = $m[1] == 'LOGIN' ? 2 : 1; | |
| 346 | } | |
| 347 | // anonymize this log entry | |
| 348 | else if ($this->anonymize_log > 0 && strpos($message, 'Send:') === 0 && --$this->anonymize_log == 0) { | |
| 349 | $message = sprintf('Send: ****** [%d]', strlen($message) - 8); | |
| 350 | } | |
| 351 | ||
| 9b8d22 | 352 | if (($len = strlen($message)) > self::DEBUG_LINE_LENGTH) { |
| 43079d | 353 | $diff = $len - self::DEBUG_LINE_LENGTH; |
| AM | 354 | $message = substr($message, 0, self::DEBUG_LINE_LENGTH) |
| 355 | . "... [truncated $diff bytes]"; | |
| 9b8d22 | 356 | } |
| AM | 357 | |
| 9945f2 | 358 | rcube::write_log('smtp', preg_replace('/\r\n$/', '', $message)); |
| AM | 359 | } |
| 360 | ||
| 361 | /** | |
| 362 | * Get error message | |
| 363 | */ | |
| 364 | public function get_error() | |
| 365 | { | |
| 366 | return $this->error; | |
| 367 | } | |
| 368 | ||
| 369 | /** | |
| 370 | * Get server response messages array | |
| 371 | */ | |
| 372 | public function get_response() | |
| 373 | { | |
| 374 | return $this->response; | |
| 375 | } | |
| 376 | ||
| 377 | /** | |
| 378 | * Take an array of mail headers and return a string containing | |
| 379 | * text usable in sending a message. | |
| 380 | * | |
| 381 | * @param array $headers The array of headers to prepare, in an associative | |
| 382 | * array, where the array key is the header name (ie, | |
| 383 | * 'Subject'), and the array value is the header | |
| 384 | * value (ie, 'test'). The header produced from those | |
| 385 | * values would be 'Subject: test'. | |
| 386 | * | |
| 387 | * @return mixed Returns false if it encounters a bad address, | |
| 388 | * otherwise returns an array containing two | |
| 389 | * elements: Any From: address found in the headers, | |
| 390 | * and the plain text version of the headers. | |
| 391 | */ | |
| 392 | private function _prepare_headers($headers) | |
| 393 | { | |
| 394 | $lines = array(); | |
| 395 | $from = null; | |
| 396 | ||
| 397 | foreach ($headers as $key => $value) { | |
| 398 | if (strcasecmp($key, 'From') === 0) { | |
| 399 | $addresses = $this->_parse_rfc822($value); | |
| 400 | ||
| 401 | if (is_array($addresses)) { | |
| 402 | $from = $addresses[0]; | |
| 403 | } | |
| 404 | ||
| 405 | // Reject envelope From: addresses with spaces. | |
| 406 | if (strpos($from, ' ') !== false) { | |
| 407 | return false; | |
| 408 | } | |
| 409 | ||
| 410 | $lines[] = $key . ': ' . $value; | |
| 411 | } | |
| 412 | else if (strcasecmp($key, 'Received') === 0) { | |
| 413 | $received = array(); | |
| 414 | if (is_array($value)) { | |
| 415 | foreach ($value as $line) { | |
| 416 | $received[] = $key . ': ' . $line; | |
| 417 | } | |
| 418 | } | |
| 419 | else { | |
| 420 | $received[] = $key . ': ' . $value; | |
| 421 | } | |
| 422 | ||
| 423 | // Put Received: headers at the top. Spam detectors often | |
| 424 | // flag messages with Received: headers after the Subject: | |
| 425 | // as spam. | |
| 426 | $lines = array_merge($received, $lines); | |
| 427 | } | |
| 428 | else { | |
| 429 | // If $value is an array (i.e., a list of addresses), convert | |
| 430 | // it to a comma-delimited string of its elements (addresses). | |
| 431 | if (is_array($value)) { | |
| 432 | $value = implode(', ', $value); | |
| 433 | } | |
| 434 | ||
| 435 | $lines[] = $key . ': ' . $value; | |
| 436 | } | |
| 437 | } | |
| 438 | ||
| 439 | return array($from, join(self::SMTP_MIME_CRLF, $lines) . self::SMTP_MIME_CRLF); | |
| 440 | } | |
| 441 | ||
| 442 | /** | |
| 443 | * Take a set of recipients and parse them, returning an array of | |
| 444 | * bare addresses (forward paths) that can be passed to sendmail | |
| 445 | * or an smtp server with the rcpt to: command. | |
| 446 | * | |
| 447 | * @param mixed Either a comma-seperated list of recipients | |
| 448 | * (RFC822 compliant), or an array of recipients, | |
| 449 | * each RFC822 valid. | |
| 450 | * | |
| 451 | * @return array An array of forward paths (bare addresses). | |
| 452 | */ | |
| 453 | private function _parse_rfc822($recipients) | |
| 454 | { | |
| 455 | // if we're passed an array, assume addresses are valid and implode them before parsing. | |
| 456 | if (is_array($recipients)) { | |
| 457 | $recipients = implode(', ', $recipients); | |
| 458 | } | |
| 459 | ||
| 460 | $addresses = array(); | |
| 461 | $recipients = rcube_utils::explode_quoted_string(',', $recipients); | |
| 462 | ||
| 463 | reset($recipients); | |
| 3725cf | 464 | foreach ($recipients as $recipient) { |
| 9945f2 | 465 | $a = rcube_utils::explode_quoted_string(' ', $recipient); |
| 3725cf | 466 | foreach ($a as $word) { |
| 9945f2 | 467 | if (strpos($word, "@") > 0 && $word[strlen($word)-1] != '"') { |
| AM | 468 | $word = preg_replace('/^<|>$/', '', trim($word)); |
| 469 | if (in_array($word, $addresses) === false) { | |
| 470 | array_push($addresses, $word); | |
| 471 | } | |
| 472 | } | |
| 473 | } | |
| 474 | } | |
| 475 | ||
| 476 | return $addresses; | |
| 477 | } | |
| 2c3d81 | 478 | } |
