[Sommaire] [Imprimer]

   1  <?php
   2  //
   3  // +----------------------------------------------------------------------+
   4  // | PHP Version 4                                                        |
   5  // +----------------------------------------------------------------------+
   6  // | Copyright (c) 1997-2003 The PHP Group                                |
   7  // +----------------------------------------------------------------------+
   8  // | This source file is subject to version 2.02 of the PHP license,      |
   9  // | that is bundled with this package in the file LICENSE, and is        |
  10  // | available at through the world-wide-web at                           |
  11  // | http://www.php.net/license/2_02.txt.                                 |
  12  // | If you did not receive a copy of the PHP license and are unable to   |
  13  // | obtain it through the world-wide-web, please send a note to          |
  14  // | license@php.net so we can mail you a copy immediately.               |
  15  // +----------------------------------------------------------------------+
  16  // | Authors: Chuck Hagenbuch <chuck@horde.org>                           |
  17  // |          Jon Parise <jon@php.net>                                    |
  18  // +----------------------------------------------------------------------+
  19  
  20  /** Error: Failed to create a Net_SMTP object */
  21  define('PEAR_MAIL_SMTP_ERROR_CREATE', 10000);
  22  
  23  /** Error: Failed to connect to SMTP server */
  24  define('PEAR_MAIL_SMTP_ERROR_CONNECT', 10001);
  25  
  26  /** Error: SMTP authentication failure */
  27  define('PEAR_MAIL_SMTP_ERROR_AUTH', 10002);
  28  
  29  /** Error: No From: address has been provided */
  30  define('PEAR_MAIL_SMTP_ERROR_FROM', 10003);
  31  
  32  /** Error: Failed to set sender */
  33  define('PEAR_MAIL_SMTP_ERROR_SENDER', 10004);
  34  
  35  /** Error: Failed to add recipient */
  36  define('PEAR_MAIL_SMTP_ERROR_RECIPIENT', 10005);
  37  
  38  /** Error: Failed to send data */
  39  define('PEAR_MAIL_SMTP_ERROR_DATA', 10006);
  40  
  41  /**
  42   * SMTP implementation of the PEAR Mail interface. Requires the Net_SMTP class.
  43   * @access public
  44   * @package Mail
  45   * @version $Revision: 1.28 $
  46   */
  47  class Mail_smtp extends Mail {
  48  
  49      /**
  50       * SMTP connection object.
  51       *
  52       * @var object
  53       * @access private
  54       */
  55      var $_smtp = null;
  56  
  57      /**
  58       * The SMTP host to connect to.
  59       * @var string
  60       */
  61      var $host = 'localhost';
  62  
  63      /**
  64       * The port the SMTP server is on.
  65       * @var integer
  66       */
  67      var $port = 25;
  68  
  69      /**
  70       * Should SMTP authentication be used?
  71       *
  72       * This value may be set to true, false or the name of a specific
  73       * authentication method.
  74       *
  75       * If the value is set to true, the Net_SMTP package will attempt to use
  76       * the best authentication method advertised by the remote SMTP server.
  77       *
  78       * @var mixed
  79       */
  80      var $auth = false;
  81  
  82      /**
  83       * The username to use if the SMTP server requires authentication.
  84       * @var string
  85       */
  86      var $username = '';
  87  
  88      /**
  89       * The password to use if the SMTP server requires authentication.
  90       * @var string
  91       */
  92      var $password = '';
  93  
  94      /**
  95       * Hostname or domain that will be sent to the remote SMTP server in the
  96       * HELO / EHLO message.
  97       *
  98       * @var string
  99       */
 100      var $localhost = 'localhost';
 101  
 102      /**
 103       * SMTP connection timeout value.  NULL indicates no timeout.
 104       *
 105       * @var integer
 106       */
 107      var $timeout = null;
 108  
 109      /**
 110       * Whether to use VERP or not. If not a boolean, the string value
 111       * will be used as the VERP separators.
 112       *
 113       * @var mixed boolean or string
 114       */
 115      var $verp = false;
 116  
 117      /**
 118       * Turn on Net_SMTP debugging?
 119       *
 120       * @var boolean $debug
 121       */
 122      var $debug = false;
 123  
 124      /**
 125       * Indicates whether or not the SMTP connection should persist over
 126       * multiple calls to the send() method.
 127       *
 128       * @var boolean
 129       */
 130      var $persist = false;
 131  
 132      /**
 133       * Constructor.
 134       *
 135       * Instantiates a new Mail_smtp:: object based on the parameters
 136       * passed in. It looks for the following parameters:
 137       *     host        The server to connect to. Defaults to localhost.
 138       *     port        The port to connect to. Defaults to 25.
 139       *     auth        SMTP authentication.  Defaults to none.
 140       *     username    The username to use for SMTP auth. No default.
 141       *     password    The password to use for SMTP auth. No default.
 142       *     localhost   The local hostname / domain. Defaults to localhost.
 143       *     timeout     The SMTP connection timeout. Defaults to none.
 144       *     verp        Whether to use VERP or not. Defaults to false.
 145       *     debug       Activate SMTP debug mode? Defaults to false.
 146       *     persist     Should the SMTP connection persist?
 147       *
 148       * If a parameter is present in the $params array, it replaces the
 149       * default.
 150       *
 151       * @param array Hash containing any parameters different from the
 152       *              defaults.
 153       * @access public
 154       */
 155      function Mail_smtp($params)
 156      {
 157          if (isset($params['host'])) $this->host = $params['host'];
 158          if (isset($params['port'])) $this->port = $params['port'];
 159          if (isset($params['auth'])) $this->auth = $params['auth'];
 160          if (isset($params['username'])) $this->username = $params['username'];
 161          if (isset($params['password'])) $this->password = $params['password'];
 162          if (isset($params['localhost'])) $this->localhost = $params['localhost'];
 163          if (isset($params['timeout'])) $this->timeout = $params['timeout'];
 164          if (isset($params['verp'])) $this->verp = $params['verp'];
 165          if (isset($params['debug'])) $this->debug = (boolean)$params['debug'];
 166          if (isset($params['persist'])) $this->persist = (boolean)$params['persist'];
 167  
 168          register_shutdown_function(array(&$this, '_Mail_smtp'));
 169      }
 170  
 171      /**
 172       * Destructor implementation to ensure that we disconnect from any
 173       * potentially-alive persistent SMTP connections.
 174       */
 175      function _Mail_smtp()
 176      {
 177          $this->disconnect();
 178      }
 179  
 180      /**
 181       * Implements Mail::send() function using SMTP.
 182       *
 183       * @param mixed $recipients Either a comma-seperated list of recipients
 184       *              (RFC822 compliant), or an array of recipients,
 185       *              each RFC822 valid. This may contain recipients not
 186       *              specified in the headers, for Bcc:, resending
 187       *              messages, etc.
 188       *
 189       * @param array $headers The array of headers to send with the mail, in an
 190       *              associative array, where the array key is the
 191       *              header name (e.g., 'Subject'), and the array value
 192       *              is the header value (e.g., 'test'). The header
 193       *              produced from those values would be 'Subject:
 194       *              test'.
 195       *
 196       * @param string $body The full text of the message body, including any
 197       *               Mime parts, etc.
 198       *
 199       * @return mixed Returns true on success, or a PEAR_Error
 200       *               containing a descriptive error message on
 201       *               failure.
 202       * @access public
 203       */
 204      function send($recipients, $headers, $body)
 205      {
 206          include_once 'Net/SMTP.php';
 207  
 208          /* If we don't already have an SMTP object, create one. */
 209          if (is_object($this->_smtp) === false) {
 210              $this->_smtp =& new Net_SMTP($this->host, $this->port,
 211                                           $this->localhost);
 212  
 213              /* If we still don't have an SMTP object at this point, fail. */
 214              if (is_object($this->_smtp) === false) {
 215                  return PEAR::raiseError('Failed to create a Net_SMTP object',
 216                                          PEAR_MAIL_SMTP_ERROR_CREATE);
 217              }
 218  
 219              /* Configure the SMTP connection. */
 220              if ($this->debug) {
 221                  $this->_smtp->setDebug(true);
 222              }
 223  
 224              /* Attempt to connect to the configured SMTP server. */
 225              if (PEAR::isError($res = $this->_smtp->connect($this->timeout))) {
 226                  $error = $this->_error('Failed to connect to ' .
 227                                         $this->host . ':' . $this->port,
 228                                         $res);
 229                  return PEAR::raiseError($error, PEAR_MAIL_SMTP_ERROR_CONNECT);
 230              }
 231  
 232              /* Attempt to authenticate if authentication has been enabled. */
 233              if ($this->auth) {
 234                  $method = is_string($this->auth) ? $this->auth : '';
 235  
 236                  if (PEAR::isError($res = $this->_smtp->auth($this->username,
 237                                                              $this->password,
 238                                                              $method))) {
 239                      $error = $this->_error("$method authentication failure",
 240                                             $res);
 241                      $this->_smtp->rset();
 242                      return PEAR::raiseError($error, PEAR_MAIL_SMTP_ERROR_AUTH);
 243                  }
 244              }
 245          }
 246  
 247          $this->_sanitizeHeaders($headers);
 248          $headerElements = $this->prepareHeaders($headers);
 249          if (PEAR::isError($headerElements)) {
 250              $this->_smtp->rset();
 251              return $headerElements;
 252          }
 253          list($from, $textHeaders) = $headerElements;
 254  
 255          /* Since few MTAs are going to allow this header to be forged
 256           * unless it's in the MAIL FROM: exchange, we'll use
 257           * Return-Path instead of From: if it's set. */
 258          if (!empty($headers['Return-Path'])) {
 259              $from = $headers['Return-Path'];
 260          }
 261  
 262          if (!isset($from)) {
 263              $this->_smtp->rset();
 264              return PEAR::raiseError('No From: address has been provided',
 265                                      PEAR_MAIL_SMTP_ERROR_FROM);
 266          }
 267  
 268          $args['verp'] = $this->verp;
 269          if (PEAR::isError($res = $this->_smtp->mailFrom($from, $args))) {
 270              $error = $this->_error("Failed to set sender: $from", $res);
 271              $this->_smtp->rset();
 272              return PEAR::raiseError($error, PEAR_MAIL_SMTP_ERROR_SENDER);
 273          }
 274  
 275          $recipients = $this->parseRecipients($recipients);
 276          if (PEAR::isError($recipients)) {
 277              $this->_smtp->rset();
 278              return $recipients;
 279          }
 280  
 281          foreach ($recipients as $recipient) {
 282              if (PEAR::isError($res = $this->_smtp->rcptTo($recipient))) {
 283                  $error = $this->_error("Failed to add recipient: $recipient",
 284                                         $res);
 285                  $this->_smtp->rset();
 286                  return PEAR::raiseError($error, PEAR_MAIL_SMTP_ERROR_RECIPIENT);
 287              }
 288          }
 289  
 290          /* Send the message's headers and the body as SMTP data. */
 291          if (PEAR::isError($res = $this->_smtp->data($textHeaders . "\r\n\r\n" . $body))) {
 292              $error = $this->_error('Failed to send data', $res);
 293              $this->_smtp->rset();
 294              return PEAR::raiseError($error, PEAR_MAIL_SMTP_ERROR_DATA);
 295          }
 296  
 297          /* If persistent connections are disabled, destroy our SMTP object. */
 298          if ($this->persist === false) {
 299              $this->disconnect();
 300          }
 301  
 302          return true;
 303      }
 304  
 305      /**
 306       * Disconnect and destroy the current SMTP connection.
 307       *
 308       * @return boolean True if the SMTP connection no longer exists.
 309       *
 310       * @since  1.1.9
 311       * @access public
 312       */
 313      function disconnect()
 314      {
 315          /* If we have an SMTP object, disconnect and destroy it. */
 316          if (is_object($this->_smtp) && $this->_smtp->disconnect()) {
 317              $this->_smtp = null;
 318          }
 319  
 320          /* We are disconnected if we no longer have an SMTP object. */
 321          return ($this->_smtp === null);
 322      }
 323  
 324      /**
 325       * Build a standardized string describing the current SMTP error.
 326       *
 327       * @param string $text  Custom string describing the error context.
 328       * @param object $error Reference to the current PEAR_Error object.
 329       *
 330       * @return string       A string describing the current SMTP error.
 331       *
 332       * @since  1.1.7
 333       * @access private
 334       */
 335      function _error($text, &$error)
 336      {
 337          /* Split the SMTP response into a code and a response string. */
 338          list($code, $response) = $this->_smtp->getResponse();
 339  
 340          /* Build our standardized error string. */
 341          $msg = $text;
 342          $msg .= ' [SMTP: ' . $error->getMessage();
 343          $msg .= " (code: $code, response: $response)]";
 344  
 345          return $msg;
 346      }
 347  
 348  }