extlib/Mail/smtp.php

   1 <?php
   2 /**
   3  * SMTP implementation of the PEAR Mail interface. Requires the Net_SMTP class.
   4  *
   5  * PHP versions 4 and 5
   6  *
   7  * LICENSE:
   8  *
   9  * Copyright (c) 2010, Chuck Hagenbuch
  10  * All rights reserved.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  *
  16  * o Redistributions of source code must retain the above copyright
  17  *   notice, this list of conditions and the following disclaimer.
  18  * o Redistributions in binary form must reproduce the above copyright
  19  *   notice, this list of conditions and the following disclaimer in the
  20  *   documentation and/or other materials provided with the distribution.
  21  * o The names of the authors may not be used to endorse or promote
  22  *   products derived from this software without specific prior written
  23  *   permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  28  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  29  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  30  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  31  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  35  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  *
  37  * @category    HTTP
  38  * @package     HTTP_Request
  39  * @author      Jon Parise <jon@php.net>
  40  * @author      Chuck Hagenbuch <chuck@horde.org>
  41  * @copyright   2010 Chuck Hagenbuch
  42  * @license     http://opensource.org/licenses/bsd-license.php New BSD License
  43  * @version     CVS: $Id: smtp.php 294747 2010-02-08 08:18:33Z clockwerx $
  44  * @link        http://pear.php.net/package/Mail/
  45  */
  46
  47 /** Error: Failed to create a Net_SMTP object */
  48 define('PEAR_MAIL_SMTP_ERROR_CREATE', 10000);
  49
  50 /** Error: Failed to connect to SMTP server */
  51 define('PEAR_MAIL_SMTP_ERROR_CONNECT', 10001);
  52
  53 /** Error: SMTP authentication failure */
  54 define('PEAR_MAIL_SMTP_ERROR_AUTH', 10002);
  55
  56 /** Error: No From: address has been provided */
  57 define('PEAR_MAIL_SMTP_ERROR_FROM', 10003);
  58
  59 /** Error: Failed to set sender */
  60 define('PEAR_MAIL_SMTP_ERROR_SENDER', 10004);
  61
  62 /** Error: Failed to add recipient */
  63 define('PEAR_MAIL_SMTP_ERROR_RECIPIENT', 10005);
  64
  65 /** Error: Failed to send data */
  66 define('PEAR_MAIL_SMTP_ERROR_DATA', 10006);
  67
  68 /**
  69  * SMTP implementation of the PEAR Mail interface. Requires the Net_SMTP class.
  70  * @access public
  71  * @package Mail
  72  * @version $Revision: 294747 $
  73  */
  74 class Mail_smtp extends Mail {
  75
  76     /**
  77      * SMTP connection object.
  78      *
  79      * @var object
  80      * @access private
  81      */
  82     var $_smtp = null;
  83
  84     /**
  85      * The list of service extension parameters to pass to the Net_SMTP
  86      * mailFrom() command.
  87      * @var array
  88      */
  89     var $_extparams = array();
  90
  91     /**
  92      * The SMTP host to connect to.
  93      * @var string
  94      */
  95     var $host = 'localhost';
  96
  97     /**
  98      * The port the SMTP server is on.
  99      * @var integer
 100      */
 101     var $port = 25;
 102
 103     /**
 104      * Should SMTP authentication be used?
 105      *
 106      * This value may be set to true, false or the name of a specific
 107      * authentication method.
 108      *
 109      * If the value is set to true, the Net_SMTP package will attempt to use
 110      * the best authentication method advertised by the remote SMTP server.
 111      *
 112      * @var mixed
 113      */
 114     var $auth = false;
 115
 116     /**
 117      * The username to use if the SMTP server requires authentication.
 118      * @var string
 119      */
 120     var $username = '';
 121
 122     /**
 123      * The password to use if the SMTP server requires authentication.
 124      * @var string
 125      */
 126     var $password = '';
 127
 128     /**
 129      * Hostname or domain that will be sent to the remote SMTP server in the
 130      * HELO / EHLO message.
 131      *
 132      * @var string
 133      */
 134     var $localhost = 'localhost';
 135
 136     /**
 137      * SMTP connection timeout value.  NULL indicates no timeout.
 138      *
 139      * @var integer
 140      */
 141     var $timeout = null;
 142
 143     /**
 144      * Turn on Net_SMTP debugging?
 145      *
 146      * @var boolean $debug
 147      */
 148     var $debug = false;
 149
 150     /**
 151      * Indicates whether or not the SMTP connection should persist over
 152      * multiple calls to the send() method.
 153      *
 154      * @var boolean
 155      */
 156     var $persist = false;
 157
 158     /**
 159      * Use SMTP command pipelining (specified in RFC 2920) if the SMTP server
 160      * supports it. This speeds up delivery over high-latency connections. By
 161      * default, use the default value supplied by Net_SMTP.
 162      * @var bool
 163      */
 164     var $pipelining;
 165
 166     /**
 167      * Constructor.
 168      *
 169      * Instantiates a new Mail_smtp:: object based on the parameters
 170      * passed in. It looks for the following parameters:
 171      *     host        The server to connect to. Defaults to localhost.
 172      *     port        The port to connect to. Defaults to 25.
 173      *     auth        SMTP authentication.  Defaults to none.
 174      *     username    The username to use for SMTP auth. No default.
 175      *     password    The password to use for SMTP auth. No default.
 176      *     localhost   The local hostname / domain. Defaults to localhost.
 177      *     timeout     The SMTP connection timeout. Defaults to none.
 178      *     verp        Whether to use VERP or not. Defaults to false.
 179      *                 DEPRECATED as of 1.2.0 (use setMailParams()).
 180      *     debug       Activate SMTP debug mode? Defaults to false.
 181      *     persist     Should the SMTP connection persist?
 182      *     pipelining  Use SMTP command pipelining
 183      *
 184      * If a parameter is present in the $params array, it replaces the
 185      * default.
 186      *
 187      * @param array Hash containing any parameters different from the
 188      *              defaults.
 189      * @access public
 190      */
 191     function Mail_smtp($params)
 192     {
 193         if (isset($params['host'])) $this->host = $params['host'];
 194         if (isset($params['port'])) $this->port = $params['port'];
 195         if (isset($params['auth'])) $this->auth = $params['auth'];
 196         if (isset($params['username'])) $this->username = $params['username'];
 197         if (isset($params['password'])) $this->password = $params['password'];
 198         if (isset($params['localhost'])) $this->localhost = $params['localhost'];
 199         if (isset($params['timeout'])) $this->timeout = $params['timeout'];
 200         if (isset($params['debug'])) $this->debug = (bool)$params['debug'];
 201         if (isset($params['persist'])) $this->persist = (bool)$params['persist'];
 202         if (isset($params['pipelining'])) $this->pipelining = (bool)$params['pipelining'];
 203
 204         // Deprecated options
 205         if (isset($params['verp'])) {
 206             $this->addServiceExtensionParameter('XVERP', is_bool($params['verp']) ? null : $params['verp']);
 207         }
 208
 209         register_shutdown_function(array(&$this, '_Mail_smtp'));
 210     }
 211
 212     /**
 213      * Destructor implementation to ensure that we disconnect from any
 214      * potentially-alive persistent SMTP connections.
 215      */
 216     function _Mail_smtp()
 217     {
 218         $this->disconnect();
 219     }
 220
 221     /**
 222      * Implements Mail::send() function using SMTP.
 223      *
 224      * @param mixed $recipients Either a comma-seperated list of recipients
 225      *              (RFC822 compliant), or an array of recipients,
 226      *              each RFC822 valid. This may contain recipients not
 227      *              specified in the headers, for Bcc:, resending
 228      *              messages, etc.
 229      *
 230      * @param array $headers The array of headers to send with the mail, in an
 231      *              associative array, where the array key is the
 232      *              header name (e.g., 'Subject'), and the array value
 233      *              is the header value (e.g., 'test'). The header
 234      *              produced from those values would be 'Subject:
 235      *              test'.
 236      *
 237      * @param string $body The full text of the message body, including any
 238      *               MIME parts, etc.
 239      *
 240      * @return mixed Returns true on success, or a PEAR_Error
 241      *               containing a descriptive error message on
 242      *               failure.
 243      * @access public
 244      */
 245     function send($recipients, $headers, $body)
 246     {
 247         /* If we don't already have an SMTP object, create one. */
 248         $result = &$this->getSMTPObject();
 249         if (PEAR::isError($result)) {
 250             return $result;
 251         }
 252
 253         if (!is_array($headers)) {
 254             return PEAR::raiseError('$headers must be an array');
 255         }
 256
 257         $this->_sanitizeHeaders($headers);
 258
 259         $headerElements = $this->prepareHeaders($headers);
 260         if (is_a($headerElements, 'PEAR_Error')) {
 261             $this->_smtp->rset();
 262             return $headerElements;
 263         }
 264         list($from, $textHeaders) = $headerElements;
 265
 266         /* Since few MTAs are going to allow this header to be forged
 267          * unless it's in the MAIL FROM: exchange, we'll use
 268          * Return-Path instead of From: if it's set. */
 269         if (!empty($headers['Return-Path'])) {
 270             $from = $headers['Return-Path'];
 271         }
 272
 273         if (!isset($from)) {
 274             $this->_smtp->rset();
 275             return PEAR::raiseError('No From: address has been provided',
 276                                     PEAR_MAIL_SMTP_ERROR_FROM);
 277         }
 278
 279         $params = null;
 280         if (!empty($this->_extparams)) {
 281             foreach ($this->_extparams as $key => $val) {
 282                 $params .= ' ' . $key . (is_null($val) ? '' : '=' . $val);
 283             }
 284         }
 285         if (PEAR::isError($res = $this->_smtp->mailFrom($from, ltrim($params)))) {
 286             $error = $this->_error("Failed to set sender: $from", $res);
 287             $this->_smtp->rset();
 288             return PEAR::raiseError($error, PEAR_MAIL_SMTP_ERROR_SENDER);
 289         }
 290
 291         $recipients = $this->parseRecipients($recipients);
 292         if (is_a($recipients, 'PEAR_Error')) {
 293             $this->_smtp->rset();
 294             return $recipients;
 295         }
 296
 297         foreach ($recipients as $recipient) {
 298             $res = $this->_smtp->rcptTo($recipient);
 299             if (is_a($res, 'PEAR_Error')) {
 300                 $error = $this->_error("Failed to add recipient: $recipient", $res);
 301                 $this->_smtp->rset();
 302                 return PEAR::raiseError($error, PEAR_MAIL_SMTP_ERROR_RECIPIENT);
 303             }
 304         }
 305
 306         /* Send the message's headers and the body as SMTP data. */
 307         $res = $this->_smtp->data($textHeaders . "\r\n\r\n" . $body);
 308                 list(,$args) = $this->_smtp->getResponse();
 309
 310                 if (preg_match("/Ok: queued as (.*)/", $args, $queued)) {
 311                         $this->queued_as = $queued[1];
 312                 }
 313
 314                 /* we need the greeting; from it we can extract the authorative name of the mail server we've really connected to.
 315                  * ideal if we're connecting to a round-robin of relay servers and need to track which exact one took the email */
 316                 $this->greeting = $this->_smtp->getGreeting();
 317
 318         if (is_a($res, 'PEAR_Error')) {
 319             $error = $this->_error('Failed to send data', $res);
 320             $this->_smtp->rset();
 321             return PEAR::raiseError($error, PEAR_MAIL_SMTP_ERROR_DATA);
 322         }
 323
 324         /* If persistent connections are disabled, destroy our SMTP object. */
 325         if ($this->persist === false) {
 326             $this->disconnect();
 327         }
 328
 329         return true;
 330     }
 331
 332     /**
 333      * Connect to the SMTP server by instantiating a Net_SMTP object.
 334      *
 335      * @return mixed Returns a reference to the Net_SMTP object on success, or
 336      *               a PEAR_Error containing a descriptive error message on
 337      *               failure.
 338      *
 339      * @since  1.2.0
 340      * @access public
 341      */
 342     function &getSMTPObject()
 343     {
 344         if (is_object($this->_smtp) !== false) {
 345             return $this->_smtp;
 346         }
 347
 348         include_once 'Net/SMTP.php';
 349         $this->_smtp = &new Net_SMTP($this->host,
 350                                      $this->port,
 351                                      $this->localhost);
 352
 353         /* If we still don't have an SMTP object at this point, fail. */
 354         if (is_object($this->_smtp) === false) {
 355             return PEAR::raiseError('Failed to create a Net_SMTP object',
 356                                     PEAR_MAIL_SMTP_ERROR_CREATE);
 357         }
 358
 359         /* Configure the SMTP connection. */
 360         if ($this->debug) {
 361             $this->_smtp->setDebug(true);
 362         }
 363
 364         /* Attempt to connect to the configured SMTP server. */
 365         if (PEAR::isError($res = $this->_smtp->connect($this->timeout))) {
 366             $error = $this->_error('Failed to connect to ' .
 367                                    $this->host . ':' . $this->port,
 368                                    $res);
 369             return PEAR::raiseError($error, PEAR_MAIL_SMTP_ERROR_CONNECT);
 370         }
 371
 372         /* Attempt to authenticate if authentication has been enabled. */
 373         if ($this->auth) {
 374             $method = is_string($this->auth) ? $this->auth : '';
 375
 376             if (PEAR::isError($res = $this->_smtp->auth($this->username,
 377                                                         $this->password,
 378                                                         $method))) {
 379                 $error = $this->_error("$method authentication failure",
 380                                        $res);
 381                 $this->_smtp->rset();
 382                 return PEAR::raiseError($error, PEAR_MAIL_SMTP_ERROR_AUTH);
 383             }
 384         }
 385
 386         return $this->_smtp;
 387     }
 388
 389     /**
 390      * Add parameter associated with a SMTP service extension.
 391      *
 392      * @param string Extension keyword.
 393      * @param string Any value the keyword needs.
 394      *
 395      * @since 1.2.0
 396      * @access public
 397      */
 398     function addServiceExtensionParameter($keyword, $value = null)
 399     {
 400         $this->_extparams[$keyword] = $value;
 401     }
 402
 403     /**
 404      * Disconnect and destroy the current SMTP connection.
 405      *
 406      * @return boolean True if the SMTP connection no longer exists.
 407      *
 408      * @since  1.1.9
 409      * @access public
 410      */
 411     function disconnect()
 412     {
 413         /* If we have an SMTP object, disconnect and destroy it. */
 414         if (is_object($this->_smtp) && $this->_smtp->disconnect()) {
 415             $this->_smtp = null;
 416         }
 417
 418         /* We are disconnected if we no longer have an SMTP object. */
 419         return ($this->_smtp === null);
 420     }
 421
 422     /**
 423      * Build a standardized string describing the current SMTP error.
 424      *
 425      * @param string $text  Custom string describing the error context.
 426      * @param object $error Reference to the current PEAR_Error object.
 427      *
 428      * @return string       A string describing the current SMTP error.
 429      *
 430      * @since  1.1.7
 431      * @access private
 432      */
 433     function _error($text, &$error)
 434     {
 435         /* Split the SMTP response into a code and a response string. */
 436         list($code, $response) = $this->_smtp->getResponse();
 437
 438         /* Build our standardized error string. */
 439         return $text
 440             . ' [SMTP: ' . $error->getMessage()
 441             . " (code: $code, response: $response)]";
 442     }
 443
 444 }