Mail
[ class tree: Mail ] [ index: Mail ] [ all elements ]

Source for file smtp.php

Documentation is available at smtp.php

  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($errorPEAR_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($errorPEAR_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($errorPEAR_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($errorPEAR_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($errorPEAR_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. }

Documentation generated on Mon, 11 Mar 2019 14:46:47 -0400 by phpDocumentor 1.4.4. PEAR Logo Copyright © PHP Group 2004.