WordPress.org

Make WordPress Core

Ticket #28909: 28909.3.diff

File 28909.3.diff, 126.6 KB (added by MattyRob, 5 years ago)
  • wp-includes/class-smtp.php

     
    11<?php
    22/**
    33 * PHPMailer RFC821 SMTP email transport class.
    4  * Version 5.2.7
    5  * PHP version 5.0.0
    6  * @category  PHP
    7  * @package   PHPMailer
    8  * @link      https://github.com/PHPMailer/PHPMailer/
    9  * @author Marcus Bointon (coolbru) <phpmailer@synchromedia.co.uk>
     4 * PHP Version 5
     5 * @package PHPMailer
     6 * @link https://github.com/PHPMailer/PHPMailer/ The PHPMailer GitHub project
     7 * @author Marcus Bointon (Synchro/coolbru) <phpmailer@synchromedia.co.uk>
    108 * @author Jim Jagielski (jimjag) <jimjag@gmail.com>
    119 * @author Andy Prevost (codeworxtech) <codeworxtech@users.sourceforge.net>
    12  * @copyright 2013 Marcus Bointon
    13  * @copyright 2004 - 2008 Andy Prevost
     10 * @author Brent R. Matzelle (original founder)
     11 * @copyright 2014 Marcus Bointon
    1412 * @copyright 2010 - 2012 Jim Jagielski
    15  * @license   http://www.gnu.org/copyleft/lesser.html Distributed under the Lesser General Public License (LGPL)
     13 * @copyright 2004 - 2009 Andy Prevost
     14 * @license http://www.gnu.org/copyleft/lesser.html GNU Lesser General Public License
     15 * @note This program is distributed in the hope that it will be useful - WITHOUT
     16 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     17 * FITNESS FOR A PARTICULAR PURPOSE.
    1618 */
    1719
    1820/**
    1921 * PHPMailer RFC821 SMTP email transport class.
    20  *
    21  * Implements RFC 821 SMTP commands
    22  * and provides some utility methods for sending mail to an SMTP server.
    23  *
    24  * PHP Version 5.0.0
    25  *
    26  * @category PHP
    27  * @package  PHPMailer
    28  * @link     https://github.com/PHPMailer/PHPMailer/blob/master/class.smtp.php
    29  * @author   Chris Ryan <unknown@example.com>
    30  * @author   Marcus Bointon <phpmailer@synchromedia.co.uk>
    31  * @license  http://www.gnu.org/copyleft/lesser.html Distributed under the Lesser General Public License (LGPL)
     22 * Implements RFC 821 SMTP commands and provides some utility methods for sending mail to an SMTP server.
     23 * @package PHPMailer
     24 * @author Chris Ryan <unknown@example.com>
     25 * @author Marcus Bointon <phpmailer@synchromedia.co.uk>
    3226 */
    33 
    3427class SMTP
    3528{
    3629    /**
    37      * The PHPMailer SMTP Version number.
     30     * The PHPMailer SMTP version number.
     31     * @type string
    3832     */
    39     const VERSION = '5.2.7';
     33    const VERSION = '5.2.9';
    4034
    4135    /**
    4236     * SMTP line break constant.
     37     * @type string
    4338     */
    4439    const CRLF = "\r\n";
    4540
    4641    /**
    4742     * The SMTP port to use if one is not specified.
     43     * @type integer
    4844     */
    4945    const DEFAULT_SMTP_PORT = 25;
    5046
    5147    /**
     48     * The maximum line length allowed by RFC 2822 section 2.1.1
     49     * @type integer
     50     */
     51    const MAX_LINE_LENGTH = 998;
     52
     53    /**
     54     * Debug level for no output
     55     */
     56    const DEBUG_OFF = 0;
     57
     58    /**
     59     * Debug level to show client -> server messages
     60     */
     61    const DEBUG_CLIENT = 1;
     62
     63    /**
     64     * Debug level to show client -> server and server -> client messages
     65     */
     66    const DEBUG_SERVER = 2;
     67
     68    /**
     69     * Debug level to show connection status, client -> server and server -> client messages
     70     */
     71    const DEBUG_CONNECTION = 3;
     72
     73    /**
     74     * Debug level to show all messages
     75     */
     76    const DEBUG_LOWLEVEL = 4;
     77
     78    /**
    5279     * The PHPMailer SMTP Version number.
    5380     * @type string
    54      * @deprecated This should be a constant
     81     * @deprecated Use the `VERSION` constant instead
    5582     * @see SMTP::VERSION
    5683     */
    57     public $Version = '5.2.7';
     84    public $Version = '5.2.9';
    5885
    5986    /**
    6087     * SMTP server port number.
    61      * @type int
    62      * @deprecated This is only ever ued as default value, so should be a constant
     88     * @type integer
     89     * @deprecated This is only ever used as a default value, so use the `DEFAULT_SMTP_PORT` constant instead
    6390     * @see SMTP::DEFAULT_SMTP_PORT
    6491     */
    6592    public $SMTP_PORT = 25;
    6693
    6794    /**
    68      * SMTP reply line ending
     95     * SMTP reply line ending.
    6996     * @type string
    70      * @deprecated Use the class constant instead
     97     * @deprecated Use the `CRLF` constant instead
    7198     * @see SMTP::CRLF
    7299     */
    73100    public $CRLF = "\r\n";
     
    74101
    75102    /**
    76103     * Debug output level.
    77      * Options: 0 for no output, 1 for commands, 2 for data and commands
    78      * @type int
     104     * Options:
     105     * * self::DEBUG_OFF (`0`) No debug output, default
     106     * * self::DEBUG_CLIENT (`1`) Client commands
     107     * * self::DEBUG_SERVER (`2`) Client commands and server responses
     108     * * self::DEBUG_CONNECTION (`3`) As DEBUG_SERVER plus connection status
     109     * * self::DEBUG_LOWLEVEL (`4`) Low-level data output, all messages
     110     * @type integer
    79111     */
    80     public $do_debug = 0;
     112    public $do_debug = self::DEBUG_OFF;
    81113
    82114    /**
    83      * The function/method to use for debugging output.
    84      * Options: 'echo', 'html' or 'error_log'
    85      * @type string
     115     * How to handle debug output.
     116     * Options:
     117     * * `echo` Output plain-text as-is, appropriate for CLI
     118     * * `html` Output escaped, line breaks converted to `<br>`, appropriate for browser output
     119     * * `error_log` Output to error log as configured in php.ini
     120     *
     121     * Alternatively, you can provide a callable expecting two params: a message string and the debug level:
     122     * <code>
     123     * $smtp->Debugoutput = function($str, $level) {echo "debug level $level; message: $str";};
     124     * </code>
     125     * @type string|callable
    86126     */
    87127    public $Debugoutput = 'echo';
    88128
    89129    /**
    90130     * Whether to use VERP.
    91      * @type bool
     131     * @link http://en.wikipedia.org/wiki/Variable_envelope_return_path
     132     * @link http://www.postfix.org/VERP_README.html Info on VERP
     133     * @type boolean
    92134     */
    93135    public $do_verp = false;
    94136
    95137    /**
    96      * The SMTP timeout value for reads, in seconds.
    97      * @type int
     138     * The timeout value for connection, in seconds.
     139     * Default of 5 minutes (300sec) is from RFC2821 section 4.5.3.2
     140     * This needs to be quite high to function correctly with hosts using greetdelay as an anti-spam measure.
     141     * @link http://tools.ietf.org/html/rfc2821#section-4.5.3.2
     142     * @type integer
    98143     */
    99     public $Timeout = 15;
     144    public $Timeout = 300;
    100145
    101146    /**
    102147     * The SMTP timelimit value for reads, in seconds.
    103      * @type int
     148     * @type integer
    104149     */
    105150    public $Timelimit = 30;
    106151
     
    112157
    113158    /**
    114159     * Error message, if any, for the last call.
    115      * @type string
     160     * @type array
    116161     */
    117     protected $error = '';
     162    protected $error = array();
    118163
    119164    /**
    120165     * The reply the server sent to us for HELO.
    121      * @type string
     166     * If null, no HELO string has yet been received.
     167     * @type string|null
    122168     */
    123     protected $helo_rply = '';
     169    protected $helo_rply = null;
    124170
    125171    /**
    126172     * The most recent reply received from the server.
     
    129175    protected $last_reply = '';
    130176
    131177    /**
    132      * Constructor.
    133      * @access public
    134      */
    135     public function __construct()
    136     {
    137         $this->smtp_conn = 0;
    138         $this->error = null;
    139         $this->helo_rply = null;
    140 
    141         $this->do_debug = 0;
    142     }
    143 
    144     /**
    145178     * Output debugging info via a user-selected method.
     179     * @see SMTP::$Debugoutput
     180     * @see SMTP::$do_debug
    146181     * @param string $str Debug string to output
     182     * @param integer $level The debug level of this message; see DEBUG_* constants
    147183     * @return void
    148184     */
    149     protected function edebug($str)
     185    protected function edebug($str, $level = 0)
    150186    {
     187        if ($level > $this->do_debug) {
     188            return;
     189        }
     190        if (is_callable($this->Debugoutput)) {
     191            call_user_func($this->Debugoutput, $str, $this->do_debug);
     192            return;
     193        }
    151194        switch ($this->Debugoutput) {
    152195            case 'error_log':
    153196                //Don't output, just log
     
    164207                break;
    165208            case 'echo':
    166209            default:
    167                 //Just echoes whatever was received
    168                 echo $str;
     210                //Normalize line breaks
     211                $str = preg_replace('/(\r\n|\r|\n)/ms', "\n", $str);
     212                echo gmdate('Y-m-d H:i:s') . "\t" . str_replace(
     213                    "\n",
     214                    "\n                   \t                  ",
     215                    trim($str)
     216                )."\n";
    169217        }
    170218    }
    171219
    172220    /**
    173221     * Connect to an SMTP server.
    174      * @param string $host    SMTP server IP or host name
    175      * @param int $port    The port number to connect to
    176      * @param int $timeout How long to wait for the connection to open
     222     * @param string $host SMTP server IP or host name
     223     * @param integer $port The port number to connect to
     224     * @param integer $timeout How long to wait for the connection to open
    177225     * @param array $options An array of options for stream_context_create()
    178226     * @access public
    179      * @return bool
     227     * @return boolean
    180228     */
    181229    public function connect($host, $port = null, $timeout = 30, $options = array())
    182230    {
     231        static $streamok;
     232        //This is enabled by default since 5.0.0 but some providers disable it
     233        //Check this once and cache the result
     234        if (is_null($streamok)) {
     235            $streamok = function_exists('stream_socket_client');
     236        }
    183237        // Clear errors to avoid confusion
    184         $this->error = null;
    185 
     238        $this->error = array();
    186239        // Make sure we are __not__ connected
    187240        if ($this->connected()) {
    188241            // Already connected, generate error
     
    189242            $this->error = array('error' => 'Already connected to a server');
    190243            return false;
    191244        }
    192 
    193245        if (empty($port)) {
    194246            $port = self::DEFAULT_SMTP_PORT;
    195247        }
    196 
    197248        // Connect to the SMTP server
     249        $this->edebug(
     250            "Connection: opening to $host:$port, t=$timeout, opt=".var_export($options, true),
     251            self::DEBUG_CONNECTION
     252        );
    198253        $errno = 0;
    199254        $errstr = '';
    200         $socket_context = stream_context_create($options);
    201         //Suppress errors; connection failures are handled at a higher level
    202         $this->smtp_conn = @stream_socket_client(
    203             $host . ":" . $port,
    204             $errno,
    205             $errstr,
    206             $timeout,
    207             STREAM_CLIENT_CONNECT,
    208             $socket_context
    209         );
    210 
     255        if ($streamok) {
     256            $socket_context = stream_context_create($options);
     257            //Suppress errors; connection failures are handled at a higher level
     258            $this->smtp_conn = @stream_socket_client(
     259                $host . ":" . $port,
     260                $errno,
     261                $errstr,
     262                $timeout,
     263                STREAM_CLIENT_CONNECT,
     264                $socket_context
     265            );
     266        } else {
     267            //Fall back to fsockopen which should work in more places, but is missing some features
     268            $this->edebug(
     269                "Connection: stream_socket_client not available, falling back to fsockopen",
     270                self::DEBUG_CONNECTION
     271            );
     272            $this->smtp_conn = fsockopen(
     273                $host,
     274                $port,
     275                $errno,
     276                $errstr,
     277                $timeout
     278            );
     279        }
    211280        // Verify we connected properly
    212         if (empty($this->smtp_conn)) {
     281        if (!is_resource($this->smtp_conn)) {
    213282            $this->error = array(
    214283                'error' => 'Failed to connect to server',
    215284                'errno' => $errno,
    216285                'errstr' => $errstr
    217286            );
    218             if ($this->do_debug >= 1) {
    219                 $this->edebug(
    220                     'SMTP -> ERROR: ' . $this->error['error']
    221                     . ": $errstr ($errno)"
    222                 );
    223             }
     287            $this->edebug(
     288                'SMTP ERROR: ' . $this->error['error']
     289                . ": $errstr ($errno)",
     290                self::DEBUG_CLIENT
     291            );
    224292            return false;
    225293        }
    226 
     294        $this->edebug('Connection: opened', self::DEBUG_CONNECTION);
    227295        // SMTP server can take longer to respond, give longer timeout for first read
    228296        // Windows does not have support for this timeout function
    229297        if (substr(PHP_OS, 0, 3) != 'WIN') {
     
    233301            }
    234302            stream_set_timeout($this->smtp_conn, $timeout, 0);
    235303        }
    236 
    237304        // Get any announcement
    238305        $announce = $this->get_lines();
    239 
    240         if ($this->do_debug >= 2) {
    241             $this->edebug('SMTP -> FROM SERVER:' . $announce);
    242         }
    243 
     306        $this->edebug('SERVER -> CLIENT: ' . $announce, self::DEBUG_SERVER);
    244307        return true;
    245308    }
    246309
     
    247310    /**
    248311     * Initiate a TLS (encrypted) session.
    249312     * @access public
    250      * @return bool
     313     * @return boolean
    251314     */
    252315    public function startTLS()
    253316    {
    254         if (!$this->sendCommand("STARTTLS", "STARTTLS", 220)) {
     317        if (!$this->sendCommand('STARTTLS', 'STARTTLS', 220)) {
    255318            return false;
    256319        }
    257320        // Begin encrypted connection
     
    259322            $this->smtp_conn,
    260323            true,
    261324            STREAM_CRYPTO_METHOD_TLS_CLIENT
    262         )
    263         ) {
     325        )) {
    264326            return false;
    265327        }
    266328        return true;
     
    276338     * @param string $realm       The auth realm for NTLM
    277339     * @param string $workstation The auth workstation for NTLM
    278340     * @access public
    279      * @return bool True if successfully authenticated.
     341     * @return boolean True if successfully authenticated.
    280342     */
    281343    public function authenticate(
    282344        $username,
     
    288350        if (empty($authtype)) {
    289351            $authtype = 'LOGIN';
    290352        }
    291 
    292353        switch ($authtype) {
    293354            case 'PLAIN':
    294355                // Start authentication
     
    332393                //Check that functions are available
    333394                if (!$ntlm_client->Initialize($temp)) {
    334395                    $this->error = array('error' => $temp->error);
    335                     if ($this->do_debug >= 1) {
    336                         $this->edebug(
    337                             'You need to enable some modules in your php.ini file: '
    338                             . $this->error['error']
    339                         );
    340                     }
     396                    $this->edebug(
     397                        'You need to enable some modules in your php.ini file: '
     398                        . $this->error['error'],
     399                        self::DEBUG_CLIENT
     400                    );
    341401                    return false;
    342402                }
    343403                //msg1
     
    351411                ) {
    352412                    return false;
    353413                }
    354 
    355414                //Though 0 based, there is a white space after the 3 digit number
    356415                //msg2
    357416                $challenge = substr($this->last_reply, 3);
     
    369428                );
    370429                // send encoded username
    371430                return $this->sendCommand('Username', base64_encode($msg3), 235);
    372                 break;
    373431            case 'CRAM-MD5':
    374432                // Start authentication
    375433                if (!$this->sendCommand('AUTH CRAM-MD5', 'AUTH CRAM-MD5', 334)) {
     
    383441
    384442                // send encoded credentials
    385443                return $this->sendCommand('Username', base64_encode($response), 235);
    386                 break;
    387444        }
    388445        return true;
    389446    }
     
    411468        // Eliminates the need to install mhash to compute a HMAC
    412469        // by Lance Rushing
    413470
    414         $b = 64; // byte length for md5
    415         if (strlen($key) > $b) {
     471        $bytelen = 64; // byte length for md5
     472        if (strlen($key) > $bytelen) {
    416473            $key = pack('H*', md5($key));
    417474        }
    418         $key = str_pad($key, $b, chr(0x00));
    419         $ipad = str_pad('', $b, chr(0x36));
    420         $opad = str_pad('', $b, chr(0x5c));
     475        $key = str_pad($key, $bytelen, chr(0x00));
     476        $ipad = str_pad('', $bytelen, chr(0x36));
     477        $opad = str_pad('', $bytelen, chr(0x5c));
    421478        $k_ipad = $key ^ $ipad;
    422479        $k_opad = $key ^ $opad;
    423480
     
    427484    /**
    428485     * Check connection state.
    429486     * @access public
    430      * @return bool True if connected.
     487     * @return boolean True if connected.
    431488     */
    432489    public function connected()
    433490    {
    434         if (!empty($this->smtp_conn)) {
     491        if (is_resource($this->smtp_conn)) {
    435492            $sock_status = stream_get_meta_data($this->smtp_conn);
    436493            if ($sock_status['eof']) {
    437                 // the socket is valid but we are not connected
    438                 if ($this->do_debug >= 1) {
    439                     $this->edebug(
    440                         'SMTP -> NOTICE: EOF caught while checking if connected'
    441                     );
    442                 }
     494                // The socket is valid but we are not connected
     495                $this->edebug(
     496                    'SMTP NOTICE: EOF caught while checking if connected',
     497                    self::DEBUG_CLIENT
     498                );
    443499                $this->close();
    444500                return false;
    445501            }
     
    457513     */
    458514    public function close()
    459515    {
    460         $this->error = null; // so there is no confusion
     516        $this->error = array();
    461517        $this->helo_rply = null;
    462         if (!empty($this->smtp_conn)) {
     518        if (is_resource($this->smtp_conn)) {
    463519            // close the connection and cleanup
    464520            fclose($this->smtp_conn);
    465             $this->smtp_conn = 0;
     521            $this->smtp_conn = null; //Makes for cleaner serialization
     522            $this->edebug('Connection: closed', self::DEBUG_CONNECTION);
    466523        }
    467524    }
    468525
     
    476533     * Implements rfc 821: DATA <CRLF>
    477534     * @param string $msg_data Message data to send
    478535     * @access public
    479      * @return bool
     536     * @return boolean
    480537     */
    481538    public function data($msg_data)
    482539    {
     
    483540        if (!$this->sendCommand('DATA', 'DATA', 354)) {
    484541            return false;
    485542        }
    486 
    487543        /* The server is ready to accept data!
    488          * according to rfc821 we should not send more than 1000
    489          * including the CRLF
    490          * characters on a single line so we will break the data up
    491          * into lines by \r and/or \n then if needed we will break
    492          * each of those into smaller lines to fit within the limit.
    493          * in addition we will be looking for lines that start with
    494          * a period '.' and append and additional period '.' to that
    495          * line. NOTE: this does not count towards limit.
     544         * According to rfc821 we should not send more than 1000 characters on a single line (including the CRLF)
     545         * so we will break the data up into lines by \r and/or \n then if needed we will break each of those into
     546         * smaller lines to fit within the limit.
     547         * We will also look for lines that start with a '.' and prepend an additional '.'.
     548         * NOTE: this does not count towards line-length limit.
    496549         */
    497550
    498         // Normalize the line breaks before exploding
    499         $msg_data = str_replace("\r\n", "\n", $msg_data);
    500         $msg_data = str_replace("\r", "\n", $msg_data);
    501         $lines = explode("\n", $msg_data);
     551        // Normalize line breaks before exploding
     552        $lines = explode("\n", str_replace(array("\r\n", "\r"), "\n", $msg_data));
    502553
    503         /* We need to find a good way to determine if headers are
    504          * in the msg_data or if it is a straight msg body
    505          * currently I am assuming rfc822 definitions of msg headers
    506          * and if the first field of the first line (':' separated)
    507          * does not contain a space then it _should_ be a header
    508          * and we can process all lines before a blank "" line as
    509          * headers.
     554        /* To distinguish between a complete RFC822 message and a plain message body, we check if the first field
     555         * of the first line (':' separated) does not contain a space then it _should_ be a header and we will
     556         * process all lines before a blank line as headers.
    510557         */
    511558
    512559        $field = substr($lines[0], 0, strpos($lines[0], ':'));
    513560        $in_headers = false;
    514         if (!empty($field) && !strstr($field, ' ')) {
     561        if (!empty($field) && strpos($field, ' ') === false) {
    515562            $in_headers = true;
    516563        }
    517564
    518         //RFC 2822 section 2.1.1 limit
    519         $max_line_length = 998;
    520 
    521565        foreach ($lines as $line) {
    522             $lines_out = null;
    523             if ($line == '' && $in_headers) {
     566            $lines_out = array();
     567            if ($in_headers and $line == '') {
    524568                $in_headers = false;
    525569            }
    526570            // ok we need to break this line up into several smaller lines
    527             while (strlen($line) > $max_line_length) {
    528                 $pos = strrpos(substr($line, 0, $max_line_length), ' ');
    529 
    530                 // Patch to fix DOS attack
    531                 if (!$pos) {
    532                     $pos = $max_line_length - 1;
     571            //This is a small micro-optimisation: isset($str[$len]) is equivalent to (strlen($str) > $len)
     572            while (isset($line[self::MAX_LINE_LENGTH])) {
     573                //Working backwards, try to find a space within the last MAX_LINE_LENGTH chars of the line to break on
     574                //so as to avoid breaking in the middle of a word
     575                $pos = strrpos(substr($line, 0, self::MAX_LINE_LENGTH), ' ');
     576                if (!$pos) { //Deliberately matches both false and 0
     577                    //No nice break found, add a hard break
     578                    $pos = self::MAX_LINE_LENGTH - 1;
    533579                    $lines_out[] = substr($line, 0, $pos);
    534580                    $line = substr($line, $pos);
    535581                } else {
     582                    //Break at the found point
    536583                    $lines_out[] = substr($line, 0, $pos);
     584                    //Move along by the amount we dealt with
    537585                    $line = substr($line, $pos + 1);
    538586                }
    539 
    540587                /* If processing headers add a LWSP-char to the front of new line
    541                  * rfc822 on long msg headers
     588                 * RFC822 section 3.1.1
    542589                 */
    543590                if ($in_headers) {
    544591                    $line = "\t" . $line;
     
    546593            }
    547594            $lines_out[] = $line;
    548595
    549             // send the lines to the server
    550             while (list(, $line_out) = @each($lines_out)) {
    551                 if (strlen($line_out) > 0) {
    552                     if (substr($line_out, 0, 1) == '.') {
    553                         $line_out = '.' . $line_out;
    554                     }
     596            // Send the lines to the server
     597            foreach ($lines_out as $line_out) {
     598                //RFC2821 section 4.5.2
     599                if (!empty($line_out) and $line_out[0] == '.') {
     600                    $line_out = '.' . $line_out;
    555601                }
    556602                $this->client_send($line_out . self::CRLF);
    557603            }
     
    565611     * Send an SMTP HELO or EHLO command.
    566612     * Used to identify the sending server to the receiving server.
    567613     * This makes sure that client and server are in a known state.
    568      * Implements from RFC 821: HELO <SP> <domain> <CRLF>
     614     * Implements RFC 821: HELO <SP> <domain> <CRLF>
    569615     * and RFC 2821 EHLO.
    570616     * @param string $host The host name or IP to connect to
    571617     * @access public
    572      * @return bool
     618     * @return boolean
    573619     */
    574620    public function hello($host = '')
    575621    {
    576622        // Try extended hello first (RFC 2821)
    577         if (!$this->sendHello('EHLO', $host)) {
    578             if (!$this->sendHello('HELO', $host)) {
    579                 return false;
    580             }
    581         }
    582 
    583         return true;
     623        return (boolean)($this->sendHello('EHLO', $host) or $this->sendHello('HELO', $host));
    584624    }
    585625
    586626    /**
     
    588628     * Low-level implementation used by hello()
    589629     * @see hello()
    590630     * @param string $hello The HELO string
    591      * @param string $host  The hostname to say we are
     631     * @param string $host The hostname to say we are
    592632     * @access protected
    593      * @return bool
     633     * @return boolean
    594634     */
    595635    protected function sendHello($hello, $host)
    596636    {
     
    608648     * Implements rfc 821: MAIL <SP> FROM:<reverse-path> <CRLF>
    609649     * @param string $from Source address of this message
    610650     * @access public
    611      * @return bool
     651     * @return boolean
    612652     */
    613653    public function mail($from)
    614654    {
     
    624664     * Send an SMTP QUIT command.
    625665     * Closes the socket if there is no error or the $close_on_error argument is true.
    626666     * Implements from rfc 821: QUIT <CRLF>
    627      * @param bool $close_on_error Should the connection close if an error occurs?
     667     * @param boolean $close_on_error Should the connection close if an error occurs?
    628668     * @access public
    629      * @return bool
     669     * @return boolean
    630670     */
    631671    public function quit($close_on_error = true)
    632672    {
    633673        $noerror = $this->sendCommand('QUIT', 'QUIT', 221);
    634         $e = $this->error; //Save any error
     674        $err = $this->error; //Save any error
    635675        if ($noerror or $close_on_error) {
    636676            $this->close();
    637             $this->error = $e; //Restore any error from the quit command
     677            $this->error = $err; //Restore any error from the quit command
    638678        }
    639679        return $noerror;
    640680    }
     
    641681
    642682    /**
    643683     * Send an SMTP RCPT command.
    644      * Sets the TO argument to $to.
     684     * Sets the TO argument to $toaddr.
    645685     * Returns true if the recipient was accepted false if it was rejected.
    646686     * Implements from rfc 821: RCPT <SP> TO:<forward-path> <CRLF>
    647      * @param string $to The address the message is being sent to
     687     * @param string $toaddr The address the message is being sent to
    648688     * @access public
    649      * @return bool
     689     * @return boolean
    650690     */
    651     public function recipient($to)
     691    public function recipient($toaddr)
    652692    {
    653693        return $this->sendCommand(
    654             'RCPT TO ',
    655             'RCPT TO:<' . $to . '>',
     694            'RCPT TO',
     695            'RCPT TO:<' . $toaddr . '>',
    656696            array(250, 251)
    657697        );
    658698    }
     
    662702     * Abort any transaction that is currently in progress.
    663703     * Implements rfc 821: RSET <CRLF>
    664704     * @access public
    665      * @return bool True on success.
     705     * @return boolean True on success.
    666706     */
    667707    public function reset()
    668708    {
     
    673713     * Send a command to an SMTP server and check its return code.
    674714     * @param string $command       The command name - not sent to the server
    675715     * @param string $commandstring The actual command to send
    676      * @param int|array $expect     One or more expected integer success codes
     716     * @param integer|array $expect     One or more expected integer success codes
    677717     * @access protected
    678      * @return bool True on success.
     718     * @return boolean True on success.
    679719     */
    680720    protected function sendCommand($command, $commandstring, $expect)
    681721    {
    682722        if (!$this->connected()) {
    683723            $this->error = array(
    684                 "error" => "Called $command without being connected"
     724                'error' => "Called $command without being connected"
    685725            );
    686726            return false;
    687727        }
    688728        $this->client_send($commandstring . self::CRLF);
    689729
    690         $reply = $this->get_lines();
    691         $code = substr($reply, 0, 3);
     730        $this->last_reply = $this->get_lines();
     731        $code = substr($this->last_reply, 0, 3);
    692732
    693         if ($this->do_debug >= 2) {
    694             $this->edebug('SMTP -> FROM SERVER:' . $reply);
    695         }
     733        $this->edebug('SERVER -> CLIENT: ' . $this->last_reply, self::DEBUG_SERVER);
    696734
    697735        if (!in_array($code, (array)$expect)) {
    698             $this->last_reply = null;
    699736            $this->error = array(
    700                 "error" => "$command command failed",
    701                 "smtp_code" => $code,
    702                 "detail" => substr($reply, 4)
     737                'error' => "$command command failed",
     738                'smtp_code' => $code,
     739                'detail' => substr($this->last_reply, 4)
    703740            );
    704             if ($this->do_debug >= 1) {
    705                 $this->edebug(
    706                     'SMTP -> ERROR: ' . $this->error['error'] . ': ' . $reply
    707                 );
    708             }
     741            $this->edebug(
     742                'SMTP ERROR: ' . $this->error['error'] . ': ' . $this->last_reply,
     743                self::DEBUG_CLIENT
     744            );
    709745            return false;
    710746        }
    711747
    712         $this->last_reply = $reply;
    713         $this->error = null;
     748        $this->error = array();
    714749        return true;
    715750    }
    716751
     
    725760     * Implements rfc 821: SAML <SP> FROM:<reverse-path> <CRLF>
    726761     * @param string $from The address the message is from
    727762     * @access public
    728      * @return bool
     763     * @return boolean
    729764     */
    730765    public function sendAndMail($from)
    731766    {
    732         return $this->sendCommand("SAML", "SAML FROM:$from", 250);
     767        return $this->sendCommand('SAML', "SAML FROM:$from", 250);
    733768    }
    734769
    735770    /**
     
    736771     * Send an SMTP VRFY command.
    737772     * @param string $name The name to verify
    738773     * @access public
    739      * @return bool
     774     * @return boolean
    740775     */
    741776    public function verify($name)
    742777    {
    743         return $this->sendCommand("VRFY", "VRFY $name", array(250, 251));
     778        return $this->sendCommand('VRFY', "VRFY $name", array(250, 251));
    744779    }
    745780
    746781    /**
     
    747782     * Send an SMTP NOOP command.
    748783     * Used to keep keep-alives alive, doesn't actually do anything
    749784     * @access public
    750      * @return bool
     785     * @return boolean
    751786     */
    752787    public function noop()
    753788    {
    754         return $this->sendCommand("NOOP", "NOOP", 250);
     789        return $this->sendCommand('NOOP', 'NOOP', 250);
    755790    }
    756791
    757792    /**
    758793     * Send an SMTP TURN command.
    759794     * This is an optional command for SMTP that this class does not support.
    760      * This method is here to make the RFC821 Definition
    761      * complete for this class and __may__ be implemented in future
     795     * This method is here to make the RFC821 Definition complete for this class
     796     * and _may_ be implemented in future
    762797     * Implements from rfc 821: TURN <CRLF>
    763798     * @access public
    764      * @return bool
     799     * @return boolean
    765800     */
    766801    public function turn()
    767802    {
     
    768803        $this->error = array(
    769804            'error' => 'The SMTP TURN command is not implemented'
    770805        );
    771         if ($this->do_debug >= 1) {
    772             $this->edebug('SMTP -> NOTICE: ' . $this->error['error']);
    773         }
     806        $this->edebug('SMTP NOTICE: ' . $this->error['error'], self::DEBUG_CLIENT);
    774807        return false;
    775808    }
    776809
     
    778811     * Send raw data to the server.
    779812     * @param string $data The data to send
    780813     * @access public
    781      * @return int|bool The number of bytes sent to the server or FALSE on error
     814     * @return integer|boolean The number of bytes sent to the server or false on error
    782815     */
    783816    public function client_send($data)
    784817    {
    785         if ($this->do_debug >= 1) {
    786             $this->edebug("CLIENT -> SMTP: $data");
    787         }
     818        $this->edebug("CLIENT -> SERVER: $data", self::DEBUG_CLIENT);
    788819        return fwrite($this->smtp_conn, $data);
    789820    }
    790821
     
    819850     */
    820851    protected function get_lines()
    821852    {
     853        // If the connection is bad, give up straight away
     854        if (!is_resource($this->smtp_conn)) {
     855            return '';
     856        }
    822857        $data = '';
    823858        $endtime = 0;
    824         // If the connection is bad, give up now
    825         if (!is_resource($this->smtp_conn)) {
    826             return $data;
    827         }
    828859        stream_set_timeout($this->smtp_conn, $this->Timeout);
    829860        if ($this->Timelimit > 0) {
    830861            $endtime = time() + $this->Timelimit;
     
    831862        }
    832863        while (is_resource($this->smtp_conn) && !feof($this->smtp_conn)) {
    833864            $str = @fgets($this->smtp_conn, 515);
    834             if ($this->do_debug >= 4) {
    835                 $this->edebug("SMTP -> get_lines(): \$data was \"$data\"");
    836                 $this->edebug("SMTP -> get_lines(): \$str is \"$str\"");
    837             }
     865            $this->edebug("SMTP -> get_lines(): \$data was \"$data\"", self::DEBUG_LOWLEVEL);
     866            $this->edebug("SMTP -> get_lines(): \$str is \"$str\"", self::DEBUG_LOWLEVEL);
    838867            $data .= $str;
    839             if ($this->do_debug >= 4) {
    840                 $this->edebug("SMTP -> get_lines(): \$data is \"$data\"");
    841             }
    842             // if 4th character is a space, we are done reading, break the loop
    843             if (substr($str, 3, 1) == ' ') {
     868            $this->edebug("SMTP -> get_lines(): \$data is \"$data\"", self::DEBUG_LOWLEVEL);
     869            // If 4th character is a space, we are done reading, break the loop, micro-optimisation over strlen
     870            if ((isset($str[3]) and $str[3] == ' ')) {
    844871                break;
    845872            }
    846873            // Timed-out? Log and break
    847874            $info = stream_get_meta_data($this->smtp_conn);
    848875            if ($info['timed_out']) {
    849                 if ($this->do_debug >= 4) {
    850                     $this->edebug(
    851                         'SMTP -> get_lines(): timed-out (' . $this->Timeout . ' sec)'
    852                     );
    853                 }
     876                $this->edebug(
     877                    'SMTP -> get_lines(): timed-out (' . $this->Timeout . ' sec)',
     878                    self::DEBUG_LOWLEVEL
     879                );
    854880                break;
    855881            }
    856882            // Now check if reads took too long
    857             if ($endtime) {
    858                 if (time() > $endtime) {
    859                     if ($this->do_debug >= 4) {
    860                         $this->edebug(
    861                             'SMTP -> get_lines(): timelimit reached ('
    862                             . $this->Timelimit . ' sec)'
    863                         );
    864                     }
    865                     break;
    866                 }
     883            if ($endtime and time() > $endtime) {
     884                $this->edebug(
     885                    'SMTP -> get_lines(): timelimit reached ('.
     886                    $this->Timelimit . ' sec)',
     887                    self::DEBUG_LOWLEVEL
     888                );
     889                break;
    867890            }
    868891        }
    869892        return $data;
     
    871894
    872895    /**
    873896     * Enable or disable VERP address generation.
    874      * @param bool $enabled
     897     * @param boolean $enabled
    875898     */
    876899    public function setVerp($enabled = false)
    877900    {
     
    880903
    881904    /**
    882905     * Get VERP address generation mode.
    883      * @return bool
     906     * @return boolean
    884907     */
    885908    public function getVerp()
    886909    {
     
    907930
    908931    /**
    909932     * Set debug output level.
    910      * @param int $level
     933     * @param integer $level
    911934     */
    912935    public function setDebugLevel($level = 0)
    913936    {
     
    916939
    917940    /**
    918941     * Get debug output level.
    919      * @return int
     942     * @return integer
    920943     */
    921944    public function getDebugLevel()
    922945    {
     
    925948
    926949    /**
    927950     * Set SMTP timeout.
    928      * @param int $timeout
     951     * @param integer $timeout
    929952     */
    930953    public function setTimeout($timeout = 0)
    931954    {
     
    934957
    935958    /**
    936959     * Get SMTP timeout.
    937      * @return int
     960     * @return integer
    938961     */
    939962    public function getTimeout()
    940963    {
  • wp-includes/class-phpmailer.php

     
    11<?php
    22/**
    33 * PHPMailer - PHP email creation and transport class.
    4  * PHP Version 5.0.0
    5  * Version 5.2.7
     4 * PHP Version 5
    65 * @package PHPMailer
    7  * @link https://github.com/PHPMailer/PHPMailer/
    8  * @author Marcus Bointon (coolbru) <phpmailer@synchromedia.co.uk>
     6 * @link https://github.com/PHPMailer/PHPMailer/ The PHPMailer GitHub project
     7 * @author Marcus Bointon (Synchro/coolbru) <phpmailer@synchromedia.co.uk>
    98 * @author Jim Jagielski (jimjag) <jimjag@gmail.com>
    109 * @author Andy Prevost (codeworxtech) <codeworxtech@users.sourceforge.net>
    1110 * @author Brent R. Matzelle (original founder)
    12  * @copyright 2013 Marcus Bointon
     11 * @copyright 2012 - 2014 Marcus Bointon
    1312 * @copyright 2010 - 2012 Jim Jagielski
    1413 * @copyright 2004 - 2009 Andy Prevost
    1514 * @license http://www.gnu.org/copyleft/lesser.html GNU Lesser General Public License
     
    1817 * FITNESS FOR A PARTICULAR PURPOSE.
    1918 */
    2019
    21 if (version_compare(PHP_VERSION, '5.0.0', '<')) {
    22     exit("Sorry, PHPMailer will only run on PHP version 5 or greater!\n");
    23 }
    24 
    2520/**
    2621 * PHPMailer - PHP email creation and transport class.
    27  * PHP Version 5.0.0
    2822 * @package PHPMailer
    29  * @author Marcus Bointon (coolbru) <phpmailer@synchromedia.co.uk>
     23 * @author Marcus Bointon (Synchro/coolbru) <phpmailer@synchromedia.co.uk>
    3024 * @author Jim Jagielski (jimjag) <jimjag@gmail.com>
    3125 * @author Andy Prevost (codeworxtech) <codeworxtech@users.sourceforge.net>
    3226 * @author Brent R. Matzelle (original founder)
    33  * @copyright 2013 Marcus Bointon
    34  * @copyright 2010 - 2012 Jim Jagielski
    35  * @copyright 2004 - 2009 Andy Prevost
    3627 */
    3728class PHPMailer
    3829{
     
    4031     * The PHPMailer Version number.
    4132     * @type string
    4233     */
    43     public $Version = '5.2.7';
     34    public $Version = '5.2.9';
    4435
    4536    /**
    4637     * Email priority.
    4738     * Options: 1 = High, 3 = Normal, 5 = low.
    48      * @type int
     39     * @type integer
    4940     */
    5041    public $Priority = 3;
    5142
     
    9788     * The Return-Path of the message.
    9889     * If empty, it will be set to either From or Sender.
    9990     * @type string
     91     * @deprecated Email senders should never set a return-path header;
     92     * it's the receiver's job (RFC5321 section 4.4), so this no longer does anything.
     93     * @link https://tools.ietf.org/html/rfc5321#section-4.4 RFC5321 reference
    10094     */
    10195    public $ReturnPath = '';
    10296
     
    155149
    156150    /**
    157151     * Word-wrap the message body to this number of chars.
    158      * @type int
     152     * @type integer
    159153     */
    160154    public $WordWrap = 0;
    161155
     
    175169    /**
    176170     * Whether mail() uses a fully sendmail-compatible MTA.
    177171     * One which supports sendmail's "-oi -f" options.
    178      * @type bool
     172     * @type boolean
    179173     */
    180174    public $UseSendmailOptions = true;
    181175
     
    222216     * You can also specify a different port
    223217     * for each host by using this format: [hostname:port]
    224218     * (e.g. "smtp1.example.com:25;smtp2.example.com").
     219     * You can also specify encryption type, for example:
     220     * (e.g. "tls://smtp1.example.com:587;ssl://smtp2.example.com:465").
    225221     * Hosts will be tried in order.
    226222     * @type string
    227223     */
     
    229225
    230226    /**
    231227     * The default SMTP server port.
    232      * @type int
    233      * @Todo Why is this needed when the SMTP class takes care of it?
     228     * @type integer
     229     * @TODO Why is this needed when the SMTP class takes care of it?
    234230     */
    235231    public $Port = 25;
    236232
     
    252248    /**
    253249     * Whether to use SMTP authentication.
    254250     * Uses the Username and Password properties.
    255      * @type bool
     251     * @type boolean
    256252     * @see PHPMailer::$Username
    257253     * @see PHPMailer::$Password
    258254     */
     
    293289
    294290    /**
    295291     * The SMTP server timeout in seconds.
    296      * @type int
     292     * @type integer
    297293     */
    298294    public $Timeout = 10;
    299295
    300296    /**
    301297     * SMTP class debug output mode.
    302      * Options: 0 = off, 1 = commands, 2 = commands and data
    303      * @type int
     298     * Debug output level.
     299     * Options:
     300     * * `0` No output
     301     * * `1` Commands
     302     * * `2` Data and commands
     303     * * `3` As 2 plus connection status
     304     * * `4` Low-level data output
     305     * @type integer
    304306     * @see SMTP::$do_debug
    305307     */
    306308    public $SMTPDebug = 0;
    307309
    308310    /**
    309      * The function/method to use for debugging output.
    310      * Options: "echo" or "error_log"
    311      * @type string
     311     * How to handle debug output.
     312     * Options:
     313     * * `echo` Output plain-text as-is, appropriate for CLI
     314     * * `html` Output escaped, line breaks converted to `<br>`, appropriate for browser output
     315     * * `error_log` Output to error log as configured in php.ini
     316     *
     317     * Alternatively, you can provide a callable expecting two params: a message string and the debug level:
     318     * <code>
     319     * $mail->Debugoutput = function($str, $level) {echo "debug level $level; message: $str";};
     320     * </code>
     321     * @type string|callable
    312322     * @see SMTP::$Debugoutput
    313323     */
    314     public $Debugoutput = "echo";
     324    public $Debugoutput = 'echo';
    315325
    316326    /**
    317327     * Whether to keep SMTP connection open after each message.
    318328     * If this is set to true then to close the connection
    319329     * requires an explicit call to smtpClose().
    320      * @type bool
     330     * @type boolean
    321331     */
    322332    public $SMTPKeepAlive = false;
    323333
     
    324334    /**
    325335     * Whether to split multiple to addresses into multiple messages
    326336     * or send them all in one message.
    327      * @type bool
     337     * @type boolean
    328338     */
    329339    public $SingleTo = false;
    330340
     
    331341    /**
    332342     * Storage for addresses when SingleTo is enabled.
    333343     * @type array
    334      * @todo This should really not be public
     344     * @TODO This should really not be public
    335345     */
    336346    public $SingleToArray = array();
    337347
     
    339349     * Whether to generate VERP addresses on send.
    340350     * Only applicable when sending via SMTP.
    341351     * @link http://en.wikipedia.org/wiki/Variable_envelope_return_path
    342      * @type bool
     352     * @link http://www.postfix.org/VERP_README.html Postfix VERP info
     353     * @type boolean
    343354     */
    344355    public $do_verp = false;
    345356
    346357    /**
    347358     * Whether to allow sending messages with an empty body.
    348      * @type bool
     359     * @type boolean
    349360     */
    350361    public $AllowEmpty = false;
    351362
     
    396407     * The function that handles the result of the send email action.
    397408     * It is called out by send() for each email sent.
    398409     *
    399      * Value can be:
    400      * - 'function_name' for function names
    401      * - 'Class::Method' for static method calls
    402      * - array($object, 'Method') for calling methods on $object
    403      * See http://php.net/is_callable manual page for more details.
     410     * Value can be any php callable: http://www.php.net/is_callable
    404411     *
    405412     * Parameters:
    406      *   bool    $result        result of the send action
     413     *   boolean $result        result of the send action
    407414     *   string  $to            email address of the recipient
    408415     *   string  $cc            cc email addresses
    409416     *   string  $bcc           bcc email addresses
     
    410417     *   string  $subject       the subject
    411418     *   string  $body          the email body
    412419     *   string  $from          email address of sender
    413      *
    414420     * @type string
    415421     */
    416422    public $action_function = '';
     
    538544
    539545    /**
    540546     * Whether to throw exceptions for errors.
    541      * @type bool
     547     * @type boolean
    542548     * @access protected
    543549     */
    544550    protected $exceptions = false;
    545551
    546552    /**
    547      * Error severity: message only, continue processing
     553     * Error severity: message only, continue processing.
    548554     */
    549555    const STOP_MESSAGE = 0;
    550556
    551557    /**
    552      * Error severity: message, likely ok to continue processing
     558     * Error severity: message, likely ok to continue processing.
    553559     */
    554560    const STOP_CONTINUE = 1;
    555561
    556562    /**
    557      * Error severity: message, plus full stop, critical error reached
     563     * Error severity: message, plus full stop, critical error reached.
    558564     */
    559565    const STOP_CRITICAL = 2;
    560566
    561567    /**
    562      * SMTP RFC standard line ending
     568     * SMTP RFC standard line ending.
    563569     */
    564570    const CRLF = "\r\n";
    565571
    566572    /**
    567      * Constructor
    568      * @param bool $exceptions Should we throw external exceptions?
     573     * Constructor.
     574     * @param boolean $exceptions Should we throw external exceptions?
    569575     */
    570576    public function __construct($exceptions = false)
    571577    {
     
    593599     * @param string $header Additional Header(s)
    594600     * @param string $params Params
    595601     * @access private
    596      * @return bool
     602     * @return boolean
    597603     */
    598604    private function mailPassthru($to, $subject, $body, $header, $params)
    599605    {
     606        //Check overloading of mail function to avoid double-encoding
     607        if (ini_get('mbstring.func_overload') & 1) {
     608            $subject = $this->secureHeader($subject);
     609        } else {
     610            $subject = $this->encodeHeader($this->secureHeader($subject));
     611        }
    600612        if (ini_get('safe_mode') || !($this->UseSendmailOptions)) {
    601             $rt = @mail($to, $this->encodeHeader($this->secureHeader($subject)), $body, $header);
     613            $result = @mail($to, $subject, $body, $header);
    602614        } else {
    603             $rt = @mail($to, $this->encodeHeader($this->secureHeader($subject)), $body, $header, $params);
     615            $result = @mail($to, $subject, $body, $header, $params);
    604616        }
    605         return $rt;
     617        return $result;
    606618    }
    607619
    608620    /**
    609621     * Output debugging info via user-defined method.
    610      * Only if debug output is enabled.
     622     * Only generates output if SMTP debug output is enabled (@see SMTP::$do_debug).
    611623     * @see PHPMailer::$Debugoutput
    612624     * @see PHPMailer::$SMTPDebug
    613625     * @param string $str
     
    614626     */
    615627    protected function edebug($str)
    616628    {
    617         if (!$this->SMTPDebug) {
     629        if ($this->SMTPDebug <= 0) {
    618630            return;
    619631        }
     632        if (is_callable($this->Debugoutput)) {
     633            call_user_func($this->Debugoutput, $str, $this->SMTPDebug);
     634            return;
     635        }
    620636        switch ($this->Debugoutput) {
    621637            case 'error_log':
     638                //Don't output, just log
    622639                error_log($str);
    623640                break;
    624641            case 'html':
    625                 //Cleans up output a bit for a better looking display that's HTML-safe
    626                 echo htmlentities(preg_replace('/[\r\n]+/', '', $str), ENT_QUOTES, $this->CharSet) . "<br>\n";
     642                //Cleans up output a bit for a better looking, HTML-safe output
     643                echo htmlentities(
     644                    preg_replace('/[\r\n]+/', '', $str),
     645                    ENT_QUOTES,
     646                    'UTF-8'
     647                )
     648                . "<br>\n";
    627649                break;
    628650            case 'echo':
    629651            default:
    630                 //Just echoes exactly what was received
    631                 echo $str;
     652                //Normalize line breaks
     653                $str = preg_replace('/(\r\n|\r|\n)/ms', "\n", $str);
     654                echo gmdate('Y-m-d H:i:s') . "\t" . str_replace(
     655                    "\n",
     656                    "\n                   \t                  ",
     657                    trim($str)
     658                ) . "\n";
    632659        }
    633660    }
    634661
    635662    /**
    636663     * Sets message type to HTML or plain.
    637      * @param bool $ishtml True for HTML mode.
     664     * @param boolean $isHtml True for HTML mode.
    638665     * @return void
    639666     */
    640     public function isHTML($ishtml = true)
     667    public function isHTML($isHtml = true)
    641668    {
    642         if ($ishtml) {
     669        if ($isHtml) {
    643670            $this->ContentType = 'text/html';
    644671        } else {
    645672            $this->ContentType = 'text/plain';
     
    670697     */
    671698    public function isSendmail()
    672699    {
    673         if (!stristr(ini_get('sendmail_path'), 'sendmail')) {
    674             $this->Sendmail = '/var/qmail/bin/sendmail';
     700        $ini_sendmail_path = ini_get('sendmail_path');
     701
     702        if (!stristr($ini_sendmail_path, 'sendmail')) {
     703            $this->Sendmail = '/usr/sbin/sendmail';
     704        } else {
     705            $this->Sendmail = $ini_sendmail_path;
    675706        }
    676707        $this->Mailer = 'sendmail';
    677708    }
     
    682713     */
    683714    public function isQmail()
    684715    {
    685         if (stristr(ini_get('sendmail_path'), 'qmail')) {
    686             $this->Sendmail = '/var/qmail/bin/sendmail';
     716        $ini_sendmail_path = ini_get('sendmail_path');
     717
     718        if (!stristr($ini_sendmail_path, 'qmail')) {
     719            $this->Sendmail = '/var/qmail/bin/qmail-inject';
     720        } else {
     721            $this->Sendmail = $ini_sendmail_path;
    687722        }
    688         $this->Mailer = 'sendmail';
     723        $this->Mailer = 'qmail';
    689724    }
    690725
    691726    /**
     
    692727     * Add a "To" address.
    693728     * @param string $address
    694729     * @param string $name
    695      * @return bool true on success, false if address already used
     730     * @return boolean true on success, false if address already used
    696731     */
    697732    public function addAddress($address, $name = '')
    698733    {
     
    704739     * @note: This function works with the SMTP mailer on win32, not with the "mail" mailer.
    705740     * @param string $address
    706741     * @param string $name
    707      * @return bool true on success, false if address already used
     742     * @return boolean true on success, false if address already used
    708743     */
    709744    public function addCC($address, $name = '')
    710745    {
     
    716751     * @note: This function works with the SMTP mailer on win32, not with the "mail" mailer.
    717752     * @param string $address
    718753     * @param string $name
    719      * @return bool true on success, false if address already used
     754     * @return boolean true on success, false if address already used
    720755     */
    721756    public function addBCC($address, $name = '')
    722757    {
     
    727762     * Add a "Reply-to" address.
    728763     * @param string $address
    729764     * @param string $name
    730      * @return bool
     765     * @return boolean
    731766     */
    732767    public function addReplyTo($address, $name = '')
    733768    {
     
    741776     * @param string $address The email address to send to
    742777     * @param string $name
    743778     * @throws phpmailerException
    744      * @return bool true on success, false if address already used or invalid in some way
     779     * @return boolean true on success, false if address already used or invalid in some way
    745780     * @access protected
    746781     */
    747782    protected function addAnAddress($kind, $address, $name = '')
     
    748783    {
    749784        if (!preg_match('/^(to|cc|bcc|Reply-To)$/', $kind)) {
    750785            $this->setError($this->lang('Invalid recipient array') . ': ' . $kind);
     786            $this->edebug($this->lang('Invalid recipient array') . ': ' . $kind);
    751787            if ($this->exceptions) {
    752788                throw new phpmailerException('Invalid recipient array: ' . $kind);
    753789            }
    754             $this->edebug($this->lang('Invalid recipient array') . ': ' . $kind);
    755790            return false;
    756791        }
    757792        $address = trim($address);
     
    758793        $name = trim(preg_replace('/[\r\n]+/', '', $name)); //Strip breaks and trim
    759794        if (!$this->validateAddress($address)) {
    760795            $this->setError($this->lang('invalid_address') . ': ' . $address);
     796            $this->edebug($this->lang('invalid_address') . ': ' . $address);
    761797            if ($this->exceptions) {
    762798                throw new phpmailerException($this->lang('invalid_address') . ': ' . $address);
    763799            }
    764             $this->edebug($this->lang('invalid_address') . ': ' . $address);
    765800            return false;
    766801        }
    767802        if ($kind != 'Reply-To') {
     
    783818     * Set the From and FromName properties.
    784819     * @param string $address
    785820     * @param string $name
    786      * @param bool $auto Whether to also set the Sender address, defaults to true
     821     * @param boolean $auto Whether to also set the Sender address, defaults to true
    787822     * @throws phpmailerException
    788      * @return bool
     823     * @return boolean
    789824     */
    790825    public function setFrom($address, $name = '', $auto = true)
    791826    {
     
    793828        $name = trim(preg_replace('/[\r\n]+/', '', $name)); //Strip breaks and trim
    794829        if (!$this->validateAddress($address)) {
    795830            $this->setError($this->lang('invalid_address') . ': ' . $address);
     831            $this->edebug($this->lang('invalid_address') . ': ' . $address);
    796832            if ($this->exceptions) {
    797833                throw new phpmailerException($this->lang('invalid_address') . ': ' . $address);
    798834            }
    799             $this->edebug($this->lang('invalid_address') . ': ' . $address);
    800835            return false;
    801836        }
    802837        $this->From = $address;
     
    825860     * Check that a string looks like an email address.
    826861     * @param string $address The email address to check
    827862     * @param string $patternselect A selector for the validation pattern to use :
    828      *   'auto' - pick best one automatically;
    829      *   'pcre8' - use the squiloople.com pattern, requires PCRE > 8.0, PHP >= 5.3.2, 5.2.14;
    830      *   'pcre' - use old PCRE implementation;
    831      *   'php' - use PHP built-in FILTER_VALIDATE_EMAIL; faster, less thorough;
    832      *   'noregex' - super fast, really dumb.
    833      * @return bool
     863     * * `auto` Pick strictest one automatically;
     864     * * `pcre8` Use the squiloople.com pattern, requires PCRE > 8.0, PHP >= 5.3.2, 5.2.14;
     865     * * `pcre` Use old PCRE implementation;
     866     * * `php` Use PHP built-in FILTER_VALIDATE_EMAIL; same as pcre8 but does not allow 'dotless' domains;
     867     * * `html5` Use the pattern given by the HTML5 spec for 'email' type form input elements.
     868     * * `noregex` Don't use a regex: super fast, really dumb.
     869     * @return boolean
    834870     * @static
    835871     * @access public
    836872     */
    837873    public static function validateAddress($address, $patternselect = 'auto')
    838874    {
    839         if ($patternselect == 'auto') {
    840             if (defined(
    841                 'PCRE_VERSION'
    842             )
    843             ) { //Check this instead of extension_loaded so it works when that function is disabled
    844                 if (version_compare(PCRE_VERSION, '8.0') >= 0) {
     875        if (!$patternselect or $patternselect == 'auto') {
     876            //Check this constant first so it works when extension_loaded() is disabled by safe mode
     877            //Constant was added in PHP 5.2.4
     878            if (defined('PCRE_VERSION')) {
     879                //This pattern can get stuck in a recursive loop in PCRE <= 8.0.2
     880                if (version_compare(PCRE_VERSION, '8.0.3') >= 0) {
    845881                    $patternselect = 'pcre8';
    846882                } else {
    847883                    $patternselect = 'pcre';
    848884                }
     885            } elseif (function_exists('extension_loaded') and extension_loaded('pcre')) {
     886                //Fall back to older PCRE
     887                $patternselect = 'pcre';
    849888            } else {
    850889                //Filter_var appeared in PHP 5.2.0 and does not require the PCRE extension
    851890                if (version_compare(PHP_VERSION, '5.2.0') >= 0) {
     
    858897        switch ($patternselect) {
    859898            case 'pcre8':
    860899                /**
    861                  * Conforms to RFC5322: Uses *correct* regex on which FILTER_VALIDATE_EMAIL is
    862                  * based; So why not use FILTER_VALIDATE_EMAIL? Because it was broken to
    863                  * not allow a@b type valid addresses :(
     900                 * Uses the same RFC5322 regex on which FILTER_VALIDATE_EMAIL is based, but allows dotless domains.
    864901                 * @link http://squiloople.com/2009/12/20/email-address-validation/
    865902                 * @copyright 2009-2010 Michael Rushton
    866903                 * Feel free to use and redistribute this code. But please keep this copyright notice.
    867904                 */
    868                 return (bool)preg_match(
     905                return (boolean)preg_match(
    869906                    '/^(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){255,})(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){65,}@)' .
    870907                    '((?>(?>(?>((?>(?>(?>\x0D\x0A)?[\t ])+|(?>[\t ]*\x0D\x0A)?[\t ]+)?)(\((?>(?2)' .
    871908                    '(?>[\x01-\x08\x0B\x0C\x0E-\'*-\[\]-\x7F]|\\\[\x00-\x7F]|(?3)))*(?2)\)))+(?2))|(?2))?)' .
     
    877914                    '|[1-9]?[0-9])(?>\.(?9)){3}))\])(?1)$/isD',
    878915                    $address
    879916                );
    880                 break;
    881917            case 'pcre':
    882918                //An older regex that doesn't need a recent PCRE
    883                 return (bool)preg_match(
     919                return (boolean)preg_match(
    884920                    '/^(?!(?>"?(?>\\\[ -~]|[^"])"?){255,})(?!(?>"?(?>\\\[ -~]|[^"])"?){65,}@)(?>' .
    885921                    '[!#-\'*+\/-9=?^-~-]+|"(?>(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\xFF]))*")' .
    886922                    '(?>\.(?>[!#-\'*+\/-9=?^-~-]+|"(?>(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\xFF]))*"))*' .
     
    893929                    '|[1-9]?[0-9])(?>\.(?>25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}))\])$/isD',
    894930                    $address
    895931                );
    896                 break;
    897             case 'php':
    898             default:
    899                 return (bool)filter_var($address, FILTER_VALIDATE_EMAIL);
    900                 break;
     932            case 'html5':
     933                /**
     934                 * This is the pattern used in the HTML5 spec for validation of 'email' type form input elements.
     935                 * @link http://www.whatwg.org/specs/web-apps/current-work/#e-mail-state-(type=email)
     936                 */
     937                return (boolean)preg_match(
     938                    '/^[a-zA-Z0-9.!#$%&\'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}' .
     939                    '[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/sD',
     940                    $address
     941                );
    901942            case 'noregex':
    902943                //No PCRE! Do something _very_ approximate!
    903944                //Check the address is 3 chars or longer and contains an @ that's not the first or last char
     
    904945                return (strlen($address) >= 3
    905946                    and strpos($address, '@') >= 1
    906947                    and strpos($address, '@') != strlen($address) - 1);
    907                 break;
     948            case 'php':
     949            default:
     950                return (boolean)filter_var($address, FILTER_VALIDATE_EMAIL);
    908951        }
    909952    }
    910953
     
    911954    /**
    912955     * Create a message and send it.
    913956     * Uses the sending method specified by $Mailer.
    914      * Returns false on error - Use the ErrorInfo variable to view description of the error.
    915957     * @throws phpmailerException
    916      * @return bool
     958     * @return boolean false on error - See the ErrorInfo property for details of the error.
    917959     */
    918960    public function send()
    919961    {
     
    922964                return false;
    923965            }
    924966            return $this->postSend();
    925         } catch (phpmailerException $e) {
     967        } catch (phpmailerException $exc) {
    926968            $this->mailHeader = '';
    927             $this->setError($e->getMessage());
     969            $this->setError($exc->getMessage());
    928970            if ($this->exceptions) {
    929                 throw $e;
     971                throw $exc;
    930972            }
    931973            return false;
    932974        }
     
    935977    /**
    936978     * Prepare a message for sending.
    937979     * @throws phpmailerException
    938      * @return bool
     980     * @return boolean
    939981     */
    940982    public function preSend()
    941983    {
    942984        try {
    943             $this->mailHeader = "";
     985            $this->mailHeader = '';
    944986            if ((count($this->to) + count($this->cc) + count($this->bcc)) < 1) {
    945987                throw new phpmailerException($this->lang('provide_address'), self::STOP_CRITICAL);
    946988            }
     
    9641006            // an extra header list which createHeader() doesn't fold in
    9651007            if ($this->Mailer == 'mail') {
    9661008                if (count($this->to) > 0) {
    967                     $this->mailHeader .= $this->addrAppend("To", $this->to);
     1009                    $this->mailHeader .= $this->addrAppend('To', $this->to);
    9681010                } else {
    969                     $this->mailHeader .= $this->headerLine("To", "undisclosed-recipients:;");
     1011                    $this->mailHeader .= $this->headerLine('To', 'undisclosed-recipients:;');
    9701012                }
    9711013                $this->mailHeader .= $this->headerLine(
    9721014                    'Subject',
     
    9901032            }
    9911033            return true;
    9921034
    993         } catch (phpmailerException $e) {
    994             $this->setError($e->getMessage());
     1035        } catch (phpmailerException $exc) {
     1036            $this->setError($exc->getMessage());
    9951037            if ($this->exceptions) {
    996                 throw $e;
     1038                throw $exc;
    9971039            }
    9981040            return false;
    9991041        }
     
    10031045     * Actually send a message.
    10041046     * Send the email via the selected mechanism
    10051047     * @throws phpmailerException
    1006      * @return bool
     1048     * @return boolean
    10071049     */
    10081050    public function postSend()
    10091051    {
     
    10111053            // Choose the mailer and send through it
    10121054            switch ($this->Mailer) {
    10131055                case 'sendmail':
     1056                case 'qmail':
    10141057                    return $this->sendmailSend($this->MIMEHeader, $this->MIMEBody);
    10151058                case 'smtp':
    10161059                    return $this->smtpSend($this->MIMEHeader, $this->MIMEBody);
     
    10171060                case 'mail':
    10181061                    return $this->mailSend($this->MIMEHeader, $this->MIMEBody);
    10191062                default:
     1063                    $sendMethod = $this->Mailer.'Send';
     1064                    if (method_exists($this, $sendMethod)) {
     1065                        return $this->$sendMethod($this->MIMEHeader, $this->MIMEBody);
     1066                    }
     1067
    10201068                    return $this->mailSend($this->MIMEHeader, $this->MIMEBody);
    10211069            }
    1022         } catch (phpmailerException $e) {
    1023             $this->setError($e->getMessage());
     1070        } catch (phpmailerException $exc) {
     1071            $this->setError($exc->getMessage());
     1072            $this->edebug($exc->getMessage());
    10241073            if ($this->exceptions) {
    1025                 throw $e;
     1074                throw $exc;
    10261075            }
    1027             $this->edebug($e->getMessage() . "\n");
    10281076        }
    10291077        return false;
    10301078    }
     
    10361084     * @see PHPMailer::$Sendmail
    10371085     * @throws phpmailerException
    10381086     * @access protected
    1039      * @return bool
     1087     * @return boolean
    10401088     */
    10411089    protected function sendmailSend($header, $body)
    10421090    {
    10431091        if ($this->Sender != '') {
    1044             $sendmail = sprintf("%s -oi -f%s -t", escapeshellcmd($this->Sendmail), escapeshellarg($this->Sender));
     1092            if ($this->Mailer == 'qmail') {
     1093                $sendmail = sprintf('%s -f%s', escapeshellcmd($this->Sendmail), escapeshellarg($this->Sender));
     1094            } else {
     1095                $sendmail = sprintf('%s -oi -f%s -t', escapeshellcmd($this->Sendmail), escapeshellarg($this->Sender));
     1096            }
    10451097        } else {
    1046             $sendmail = sprintf("%s -oi -t", escapeshellcmd($this->Sendmail));
     1098            if ($this->Mailer == 'qmail') {
     1099                $sendmail = sprintf('%s', escapeshellcmd($this->Sendmail));
     1100            } else {
     1101                $sendmail = sprintf('%s -oi -t', escapeshellcmd($this->Sendmail));
     1102            }
    10471103        }
    10481104        if ($this->SingleTo === true) {
    1049             foreach ($this->SingleToArray as $val) {
     1105            foreach ($this->SingleToArray as $toAddr) {
    10501106                if (!@$mail = popen($sendmail, 'w')) {
    10511107                    throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
    10521108                }
    1053                 fputs($mail, "To: " . $val . "\n");
     1109                fputs($mail, 'To: ' . $toAddr . "\n");
    10541110                fputs($mail, $header);
    10551111                fputs($mail, $body);
    10561112                $result = pclose($mail);
    1057                 // implement call back function if it exists
    1058                 $isSent = ($result == 0) ? 1 : 0;
    1059                 $this->doCallback($isSent, $val, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
     1113                $this->doCallback(
     1114                    ($result == 0),
     1115                    array($toAddr),
     1116                    $this->cc,
     1117                    $this->bcc,
     1118                    $this->Subject,
     1119                    $body,
     1120                    $this->From
     1121                );
    10601122                if ($result != 0) {
    10611123                    throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
    10621124                }
     
    10681130            fputs($mail, $header);
    10691131            fputs($mail, $body);
    10701132            $result = pclose($mail);
    1071             // implement call back function if it exists
    1072             $isSent = ($result == 0) ? 1 : 0;
    1073             $this->doCallback($isSent, $this->to, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
     1133            $this->doCallback(($result == 0), $this->to, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
    10741134            if ($result != 0) {
    10751135                throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
    10761136            }
     
    10851145     * @link http://www.php.net/manual/en/book.mail.php
    10861146     * @throws phpmailerException
    10871147     * @access protected
    1088      * @return bool
     1148     * @return boolean
    10891149     */
    10901150    protected function mailSend($header, $body)
    10911151    {
    10921152        $toArr = array();
    1093         foreach ($this->to as $t) {
    1094             $toArr[] = $this->addrFormat($t);
     1153        foreach ($this->to as $toaddr) {
     1154            $toArr[] = $this->addrFormat($toaddr);
    10951155        }
    10961156        $to = implode(', ', $toArr);
    10971157
    10981158        if (empty($this->Sender)) {
    1099             $params = " ";
     1159            $params = ' ';
    11001160        } else {
    1101             $params = sprintf("-f%s", $this->Sender);
     1161            $params = sprintf('-f%s', $this->Sender);
    11021162        }
    11031163        if ($this->Sender != '' and !ini_get('safe_mode')) {
    11041164            $old_from = ini_get('sendmail_from');
    11051165            ini_set('sendmail_from', $this->Sender);
    11061166        }
    1107         $rt = false;
     1167        $result = false;
    11081168        if ($this->SingleTo === true && count($toArr) > 1) {
    1109             foreach ($toArr as $val) {
    1110                 $rt = $this->mailPassthru($val, $this->Subject, $body, $header, $params);
    1111                 // implement call back function if it exists
    1112                 $isSent = ($rt == 1) ? 1 : 0;
    1113                 $this->doCallback($isSent, $val, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
     1169            foreach ($toArr as $toAddr) {
     1170                $result = $this->mailPassthru($toAddr, $this->Subject, $body, $header, $params);
     1171                $this->doCallback($result, array($toAddr), $this->cc, $this->bcc, $this->Subject, $body, $this->From);
    11141172            }
    11151173        } else {
    1116             $rt = $this->mailPassthru($to, $this->Subject, $body, $header, $params);
    1117             // implement call back function if it exists
    1118             $isSent = ($rt == 1) ? 1 : 0;
    1119             $this->doCallback($isSent, $to, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
     1174            $result = $this->mailPassthru($to, $this->Subject, $body, $header, $params);
     1175            $this->doCallback($result, $this->to, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
    11201176        }
    11211177        if (isset($old_from)) {
    11221178            ini_set('sendmail_from', $old_from);
    11231179        }
    1124         if (!$rt) {
     1180        if (!$result) {
    11251181            throw new phpmailerException($this->lang('instantiate'), self::STOP_CRITICAL);
    11261182        }
    11271183        return true;
     
    11351191    public function getSMTPInstance()
    11361192    {
    11371193        if (!is_object($this->smtp)) {
    1138             require_once 'class-smtp.php';
    11391194            $this->smtp = new SMTP;
    11401195        }
    11411196        return $this->smtp;
     
    11511206     * @throws phpmailerException
    11521207     * @uses SMTP
    11531208     * @access protected
    1154      * @return bool
     1209     * @return boolean
    11551210     */
    11561211    protected function smtpSend($header, $body)
    11571212    {
     
    11661221            throw new phpmailerException($this->ErrorInfo, self::STOP_CRITICAL);
    11671222        }
    11681223
    1169         // Attempt to send attach all recipients
     1224        // Attempt to send to all recipients
    11701225        foreach ($this->to as $to) {
    11711226            if (!$this->smtp->recipient($to[0])) {
    11721227                $bad_rcpt[] = $to[0];
    1173                 $isSent = 0;
     1228                $isSent = false;
    11741229            } else {
    1175                 $isSent = 1;
     1230                $isSent = true;
    11761231            }
    1177             $this->doCallback($isSent, $to[0], '', '', $this->Subject, $body, $this->From);
     1232            $this->doCallback($isSent, array($to[0]), array(), array(), $this->Subject, $body, $this->From);
    11781233        }
    11791234        foreach ($this->cc as $cc) {
    11801235            if (!$this->smtp->recipient($cc[0])) {
    11811236                $bad_rcpt[] = $cc[0];
    1182                 $isSent = 0;
     1237                $isSent = false;
    11831238            } else {
    1184                 $isSent = 1;
     1239                $isSent = true;
    11851240            }
    1186             $this->doCallback($isSent, '', $cc[0], '', $this->Subject, $body, $this->From);
     1241            $this->doCallback($isSent, array(), array($cc[0]), array(), $this->Subject, $body, $this->From);
    11871242        }
    11881243        foreach ($this->bcc as $bcc) {
    11891244            if (!$this->smtp->recipient($bcc[0])) {
    11901245                $bad_rcpt[] = $bcc[0];
    1191                 $isSent = 0;
     1246                $isSent = false;
    11921247            } else {
    1193                 $isSent = 1;
     1248                $isSent = true;
    11941249            }
    1195             $this->doCallback($isSent, '', '', $bcc[0], $this->Subject, $body, $this->From);
     1250            $this->doCallback($isSent, array(), array(), array($bcc[0]), $this->Subject, $body, $this->From);
    11961251        }
    11971252
    1198         if (count($bad_rcpt) > 0) { //Create error message for any bad addresses
    1199             throw new phpmailerException($this->lang('recipients_failed') . implode(', ', $bad_rcpt));
    1200         }
    1201         if (!$this->smtp->data($header . $body)) {
     1253        // Only send the DATA command if we have viable recipients
     1254        if ((count($this->all_recipients) > count($bad_rcpt)) and !$this->smtp->data($header . $body)) {
    12021255            throw new phpmailerException($this->lang('data_not_accepted'), self::STOP_CRITICAL);
    12031256        }
    12041257        if ($this->SMTPKeepAlive == true) {
     
    12071260            $this->smtp->quit();
    12081261            $this->smtp->close();
    12091262        }
     1263        if (count($bad_rcpt) > 0) { // Create error message for any bad addresses
     1264            throw new phpmailerException(
     1265                $this->lang('recipients_failed') . implode(', ', $bad_rcpt),
     1266                self::STOP_CONTINUE
     1267            );
     1268        }
    12101269        return true;
    12111270    }
    12121271
     
    12171276     * @uses SMTP
    12181277     * @access public
    12191278     * @throws phpmailerException
    1220      * @return bool
     1279     * @return boolean
    12211280     */
    12221281    public function smtpConnect($options = array())
    12231282    {
     
    12251284            $this->smtp = $this->getSMTPInstance();
    12261285        }
    12271286
    1228         //Already connected?
     1287        // Already connected?
    12291288        if ($this->smtp->connected()) {
    12301289            return true;
    12311290        }
     
    12341293        $this->smtp->setDebugLevel($this->SMTPDebug);
    12351294        $this->smtp->setDebugOutput($this->Debugoutput);
    12361295        $this->smtp->setVerp($this->do_verp);
    1237         $tls = ($this->SMTPSecure == 'tls');
    1238         $ssl = ($this->SMTPSecure == 'ssl');
    12391296        $hosts = explode(';', $this->Host);
    12401297        $lastexception = null;
    12411298
    12421299        foreach ($hosts as $hostentry) {
    12431300            $hostinfo = array();
    1244             $host = $hostentry;
     1301            if (!preg_match('/^((ssl|tls):\/\/)*([a-zA-Z0-9\.-]*):?([0-9]*)$/', trim($hostentry), $hostinfo)) {
     1302                // Not a valid host entry
     1303                continue;
     1304            }
     1305            // $hostinfo[2]: optional ssl or tls prefix
     1306            // $hostinfo[3]: the hostname
     1307            // $hostinfo[4]: optional port number
     1308            // The host string prefix can temporarily override the current setting for SMTPSecure
     1309            // If it's not specified, the default value is used
     1310            $prefix = '';
     1311            $tls = ($this->SMTPSecure == 'tls');
     1312            if ($hostinfo[2] == 'ssl' or ($hostinfo[2] == '' and $this->SMTPSecure == 'ssl')) {
     1313                $prefix = 'ssl://';
     1314                $tls = false; // Can't have SSL and TLS at once
     1315            } elseif ($hostinfo[2] == 'tls') {
     1316                $tls = true;
     1317                // tls doesn't use a prefix
     1318            }
     1319            $host = $hostinfo[3];
    12451320            $port = $this->Port;
    1246             if (preg_match(
    1247                 '/^(.+):([0-9]+)$/',
    1248                 $hostentry,
    1249                 $hostinfo
    1250             )
    1251             ) { //If $hostentry contains 'address:port', override default
    1252                 $host = $hostinfo[1];
    1253                 $port = $hostinfo[2];
     1321            $tport = (integer)$hostinfo[4];
     1322            if ($tport > 0 and $tport < 65536) {
     1323                $port = $tport;
    12541324            }
    1255             if ($this->smtp->connect(($ssl ? 'ssl://' : '') . $host, $port, $this->Timeout, $options)) {
     1325            if ($this->smtp->connect($prefix . $host, $port, $this->Timeout, $options)) {
    12561326                try {
    12571327                    if ($this->Helo) {
    12581328                        $hello = $this->Helo;
     
    12651335                        if (!$this->smtp->startTLS()) {
    12661336                            throw new phpmailerException($this->lang('connect_host'));
    12671337                        }
    1268                         //We must resend HELO after tls negotiation
     1338                        // We must resend HELO after tls negotiation
    12691339                        $this->smtp->hello($hello);
    12701340                    }
    12711341                    if ($this->SMTPAuth) {
     
    12811351                        }
    12821352                    }
    12831353                    return true;
    1284                 } catch (phpmailerException $e) {
    1285                     $lastexception = $e;
    1286                     //We must have connected, but then failed TLS or Auth, so close connection nicely
     1354                } catch (phpmailerException $exc) {
     1355                    $lastexception = $exc;
     1356                    // We must have connected, but then failed TLS or Auth, so close connection nicely
    12871357                    $this->smtp->quit();
    12881358                }
    12891359            }
    12901360        }
    1291         //If we get here, all connection attempts have failed, so close connection hard
     1361        // If we get here, all connection attempts have failed, so close connection hard
    12921362        $this->smtp->close();
    1293         //As we've caught all exceptions, just report whatever the last one was
     1363        // As we've caught all exceptions, just report whatever the last one was
    12941364        if ($this->exceptions and !is_null($lastexception)) {
    12951365            throw $lastexception;
    12961366        }
     
    13171387     * The default language is English.
    13181388     * @param string $langcode ISO 639-1 2-character language code (e.g. French is "fr")
    13191389     * @param string $lang_path Path to the language file directory, with trailing separator (slash)
    1320      * @return bool
     1390     * @return boolean
    13211391     * @access public
    13221392     */
    1323     public function setLanguage($langcode = 'en', $lang_path = 'language/')
     1393    public function setLanguage($langcode = 'en', $lang_path = '')
    13241394    {
    1325         //Define full set of translatable strings
     1395        // Define full set of translatable strings in English
    13261396        $PHPMAILER_LANG = array(
    13271397            'authenticate' => 'SMTP Error: Could not authenticate.',
    13281398            'connect_host' => 'SMTP Error: Could not connect to SMTP host.',
     
    13431413            'smtp_error' => 'SMTP server error: ',
    13441414            'variable_set' => 'Cannot set or reset variable: '
    13451415        );
    1346         //Overwrite language-specific strings.
    1347         //This way we'll never have missing translations - no more "language string failed to load"!
    1348         $l = true;
    1349         if ($langcode != 'en') { //There is no English translation file
    1350             $l = @include $lang_path . 'phpmailer.lang-' . $langcode . '.php';
     1416        if (empty($lang_path)) {
     1417            // Calculate an absolute path so it can work if CWD is not here
     1418            $lang_path = dirname(__FILE__). DIRECTORY_SEPARATOR . 'language'. DIRECTORY_SEPARATOR;
    13511419        }
     1420        $foundlang = true;
     1421        $lang_file = $lang_path . 'phpmailer.lang-' . $langcode . '.php';
     1422        if ($langcode != 'en') { // There is no English translation file
     1423            // Make sure language file path is readable
     1424            if (!is_readable($lang_file)) {
     1425                $foundlang = false;
     1426            } else {
     1427                // Overwrite language-specific strings.
     1428                // This way we'll never have missing translations.
     1429                $foundlang = include $lang_file;
     1430            }
     1431        }
    13521432        $this->language = $PHPMAILER_LANG;
    1353         return ($l == true); //Returns false if language not found
     1433        return ($foundlang == true); // Returns false if language not found
    13541434    }
    13551435
    13561436    /**
     
    13751455    public function addrAppend($type, $addr)
    13761456    {
    13771457        $addresses = array();
    1378         foreach ($addr as $a) {
    1379             $addresses[] = $this->addrFormat($a);
     1458        foreach ($addr as $address) {
     1459            $addresses[] = $this->addrFormat($address);
    13801460        }
    13811461        return $type . ': ' . implode(', ', $addresses) . $this->LE;
    13821462    }
     
    13931473        if (empty($addr[1])) { // No name provided
    13941474            return $this->secureHeader($addr[0]);
    13951475        } else {
    1396             return $this->encodeHeader($this->secureHeader($addr[1]), 'phrase') . " <" . $this->secureHeader(
     1476            return $this->encodeHeader($this->secureHeader($addr[1]), 'phrase') . ' <' . $this->secureHeader(
    13971477                $addr[0]
    1398             ) . ">";
     1478            ) . '>';
    13991479        }
    14001480    }
    14011481
     
    14061486     * Original written by philippe.
    14071487     * @param string $message The message to wrap
    14081488     * @param integer $length The line length to wrap to
    1409      * @param bool $qp_mode Whether to run in Quoted-Printable mode
     1489     * @param boolean $qp_mode Whether to run in Quoted-Printable mode
    14101490     * @access public
    14111491     * @return string
    14121492     */
    14131493    public function wrapText($message, $length, $qp_mode = false)
    14141494    {
    1415         $soft_break = ($qp_mode) ? sprintf(" =%s", $this->LE) : $this->LE;
     1495        $soft_break = ($qp_mode) ? sprintf(' =%s', $this->LE) : $this->LE;
    14161496        // If utf-8 encoding is used, we will need to make sure we don't
    14171497        // split multibyte characters when we wrap
    1418         $is_utf8 = (strtolower($this->CharSet) == "utf-8");
     1498        $is_utf8 = (strtolower($this->CharSet) == 'utf-8');
    14191499        $lelen = strlen($this->LE);
    14201500        $crlflen = strlen(self::CRLF);
    14211501
     
    14381518                            $len = $space_left;
    14391519                            if ($is_utf8) {
    14401520                                $len = $this->utf8CharBoundary($word, $len);
    1441                             } elseif (substr($word, $len - 1, 1) == "=") {
     1521                            } elseif (substr($word, $len - 1, 1) == '=') {
    14421522                                $len--;
    1443                             } elseif (substr($word, $len - 2, 1) == "=") {
     1523                            } elseif (substr($word, $len - 2, 1) == '=') {
    14441524                                $len -= 2;
    14451525                            }
    14461526                            $part = substr($word, 0, $len);
    14471527                            $word = substr($word, $len);
    14481528                            $buf .= ' ' . $part;
    1449                             $message .= $buf . sprintf("=%s", self::CRLF);
     1529                            $message .= $buf . sprintf('=%s', self::CRLF);
    14501530                        } else {
    14511531                            $message .= $buf . $soft_break;
    14521532                        }
     
    14591539                        $len = $length;
    14601540                        if ($is_utf8) {
    14611541                            $len = $this->utf8CharBoundary($word, $len);
    1462                         } elseif (substr($word, $len - 1, 1) == "=") {
     1542                        } elseif (substr($word, $len - 1, 1) == '=') {
    14631543                            $len--;
    1464                         } elseif (substr($word, $len - 2, 1) == "=") {
     1544                        } elseif (substr($word, $len - 2, 1) == '=') {
    14651545                            $len -= 2;
    14661546                        }
    14671547                        $part = substr($word, 0, $len);
     
    14681548                        $word = substr($word, $len);
    14691549
    14701550                        if (strlen($word) > 0) {
    1471                             $message .= $part . sprintf("=%s", self::CRLF);
     1551                            $message .= $part . sprintf('=%s', self::CRLF);
    14721552                        } else {
    14731553                            $buf = $part;
    14741554                        }
     
    14951575     * Original written by Colin Brown.
    14961576     * @access public
    14971577     * @param string $encodedText utf-8 QP text
    1498      * @param int $maxLength   find last character boundary prior to this length
    1499      * @return int
     1578     * @param integer $maxLength   find last character boundary prior to this length
     1579     * @return integer
    15001580     */
    15011581    public function utf8CharBoundary($encodedText, $maxLength)
    15021582    {
     
    15041584        $lookBack = 3;
    15051585        while (!$foundSplitPos) {
    15061586            $lastChunk = substr($encodedText, $maxLength - $lookBack, $lookBack);
    1507             $encodedCharPos = strpos($lastChunk, "=");
     1587            $encodedCharPos = strpos($lastChunk, '=');
    15081588            if ($encodedCharPos !== false) {
    15091589                // Found start of encoded character byte within $lookBack block.
    15101590                // Check the encoded byte value (the 2 chars after the '=')
     
    15311611        return $maxLength;
    15321612    }
    15331613
    1534 
    15351614    /**
    15361615     * Set the body wrapping.
    15371616     * @access public
     
    15721651        $this->boundary[3] = 'b3_' . $uniq_id;
    15731652
    15741653        if ($this->MessageDate == '') {
    1575             $result .= $this->headerLine('Date', self::rfcDate());
    1576         } else {
    1577             $result .= $this->headerLine('Date', $this->MessageDate);
     1654            $this->MessageDate = self::rfcDate();
    15781655        }
     1656        $result .= $this->headerLine('Date', $this->MessageDate);
    15791657
    1580         if ($this->ReturnPath) {
    1581             $result .= $this->headerLine('Return-Path', '<' . trim($this->ReturnPath) . '>');
    1582         } elseif ($this->Sender == '') {
    1583             $result .= $this->headerLine('Return-Path', '<' . trim($this->From) . '>');
    1584         } else {
    1585             $result .= $this->headerLine('Return-Path', '<' . trim($this->Sender) . '>');
    1586         }
    15871658
    15881659        // To be created automatically by mail()
    1589         if ($this->Mailer != 'mail') {
    1590             if ($this->SingleTo === true) {
    1591                 foreach ($this->to as $t) {
    1592                     $this->SingleToArray[] = $this->addrFormat($t);
     1660        if ($this->SingleTo === true) {
     1661            if ($this->Mailer != 'mail') {
     1662                foreach ($this->to as $toaddr) {
     1663                    $this->SingleToArray[] = $this->addrFormat($toaddr);
    15931664                }
    1594             } else {
    1595                 if (count($this->to) > 0) {
     1665            }
     1666        } else {
     1667            if (count($this->to) > 0) {
     1668                if ($this->Mailer != 'mail') {
    15961669                    $result .= $this->addrAppend('To', $this->to);
    1597                 } elseif (count($this->cc) == 0) {
    1598                     $result .= $this->headerLine('To', 'undisclosed-recipients:;');
    15991670                }
     1671            } elseif (count($this->cc) == 0) {
     1672                $result .= $this->headerLine('To', 'undisclosed-recipients:;');
    16001673            }
    16011674        }
    16021675
     
    16081681        }
    16091682
    16101683        // sendmail and mail() extract Bcc from the header before sending
    1611         if ((($this->Mailer == 'sendmail') || ($this->Mailer == 'mail')) && (count($this->bcc) > 0)) {
     1684        if ((
     1685                $this->Mailer == 'sendmail' or $this->Mailer == 'qmail' or $this->Mailer == 'mail'
     1686            )
     1687            and count($this->bcc) > 0
     1688        ) {
    16121689            $result .= $this->addrAppend('Bcc', $this->bcc);
    16131690        }
    16141691
     
    16241701        if ($this->MessageID != '') {
    16251702            $this->lastMessageID = $this->MessageID;
    16261703        } else {
    1627             $this->lastMessageID = sprintf("<%s@%s>", $uniq_id, $this->ServerHostname());
     1704            $this->lastMessageID = sprintf('<%s@%s>', $uniq_id, $this->ServerHostname());
    16281705        }
    16291706        $result .= $this->HeaderLine('Message-ID', $this->lastMessageID);
    16301707        $result .= $this->headerLine('X-Priority', $this->Priority);
     
    16671744    public function getMailMIME()
    16681745    {
    16691746        $result = '';
     1747        $ismultipart = true;
    16701748        switch ($this->message_type) {
    16711749            case 'inline':
    16721750                $result .= $this->headerLine('Content-Type', 'multipart/related;');
     
    16871765            default:
    16881766                // Catches case 'plain': and case '':
    16891767                $result .= $this->textLine('Content-Type: ' . $this->ContentType . '; charset=' . $this->CharSet);
     1768                $ismultipart = false;
    16901769                break;
    16911770        }
    1692         //RFC1341 part 5 says 7bit is assumed if not specified
     1771        // RFC1341 part 5 says 7bit is assumed if not specified
    16931772        if ($this->Encoding != '7bit') {
    1694             $result .= $this->headerLine('Content-Transfer-Encoding', $this->Encoding);
     1773            // RFC 2045 section 6.4 says multipart MIME parts may only use 7bit, 8bit or binary CTE
     1774            if ($ismultipart) {
     1775                if ($this->Encoding == '8bit') {
     1776                    $result .= $this->headerLine('Content-Transfer-Encoding', '8bit');
     1777                }
     1778                // The only remaining alternatives are quoted-printable and base64, which are both 7bit compatible
     1779            } else {
     1780                $result .= $this->headerLine('Content-Transfer-Encoding', $this->Encoding);
     1781            }
    16951782        }
    16961783
    16971784        if ($this->Mailer != 'mail') {
     
    17041791    /**
    17051792     * Returns the whole MIME message.
    17061793     * Includes complete headers and body.
    1707      * Only valid post PreSend().
    1708      * @see PHPMailer::PreSend()
     1794     * Only valid post preSend().
     1795     * @see PHPMailer::preSend()
    17091796     * @access public
    17101797     * @return string
    17111798     */
     
    17321819
    17331820        $this->setWordWrap();
    17341821
     1822        $bodyEncoding = $this->Encoding;
     1823        $bodyCharSet = $this->CharSet;
     1824        if ($bodyEncoding == '8bit' and !$this->has8bitChars($this->Body)) {
     1825            $bodyEncoding = '7bit';
     1826            $bodyCharSet = 'us-ascii';
     1827        }
     1828        $altBodyEncoding = $this->Encoding;
     1829        $altBodyCharSet = $this->CharSet;
     1830        if ($altBodyEncoding == '8bit' and !$this->has8bitChars($this->AltBody)) {
     1831            $altBodyEncoding = '7bit';
     1832            $altBodyCharSet = 'us-ascii';
     1833        }
    17351834        switch ($this->message_type) {
    17361835            case 'inline':
    1737                 $body .= $this->getBoundary($this->boundary[1], '', '', '');
    1738                 $body .= $this->encodeString($this->Body, $this->Encoding);
     1836                $body .= $this->getBoundary($this->boundary[1], $bodyCharSet, '', $bodyEncoding);
     1837                $body .= $this->encodeString($this->Body, $bodyEncoding);
    17391838                $body .= $this->LE . $this->LE;
    17401839                $body .= $this->attachAll('inline', $this->boundary[1]);
    17411840                break;
    17421841            case 'attach':
    1743                 $body .= $this->getBoundary($this->boundary[1], '', '', '');
    1744                 $body .= $this->encodeString($this->Body, $this->Encoding);
     1842                $body .= $this->getBoundary($this->boundary[1], $bodyCharSet, '', $bodyEncoding);
     1843                $body .= $this->encodeString($this->Body, $bodyEncoding);
    17451844                $body .= $this->LE . $this->LE;
    17461845                $body .= $this->attachAll('attachment', $this->boundary[1]);
    17471846                break;
     
    17501849                $body .= $this->headerLine('Content-Type', 'multipart/related;');
    17511850                $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
    17521851                $body .= $this->LE;
    1753                 $body .= $this->getBoundary($this->boundary[2], '', '', '');
    1754                 $body .= $this->encodeString($this->Body, $this->Encoding);
     1852                $body .= $this->getBoundary($this->boundary[2], $bodyCharSet, '', $bodyEncoding);
     1853                $body .= $this->encodeString($this->Body, $bodyEncoding);
    17551854                $body .= $this->LE . $this->LE;
    17561855                $body .= $this->attachAll('inline', $this->boundary[2]);
    17571856                $body .= $this->LE;
     
    17581857                $body .= $this->attachAll('attachment', $this->boundary[1]);
    17591858                break;
    17601859            case 'alt':
    1761                 $body .= $this->getBoundary($this->boundary[1], '', 'text/plain', '');
    1762                 $body .= $this->encodeString($this->AltBody, $this->Encoding);
     1860                $body .= $this->getBoundary($this->boundary[1], $altBodyCharSet, 'text/plain', $altBodyEncoding);
     1861                $body .= $this->encodeString($this->AltBody, $altBodyEncoding);
    17631862                $body .= $this->LE . $this->LE;
    1764                 $body .= $this->getBoundary($this->boundary[1], '', 'text/html', '');
    1765                 $body .= $this->encodeString($this->Body, $this->Encoding);
     1863                $body .= $this->getBoundary($this->boundary[1], $bodyCharSet, 'text/html', $bodyEncoding);
     1864                $body .= $this->encodeString($this->Body, $bodyEncoding);
    17661865                $body .= $this->LE . $this->LE;
    17671866                if (!empty($this->Ical)) {
    17681867                    $body .= $this->getBoundary($this->boundary[1], '', 'text/calendar; method=REQUEST', '');
     
    17721871                $body .= $this->endBoundary($this->boundary[1]);
    17731872                break;
    17741873            case 'alt_inline':
    1775                 $body .= $this->getBoundary($this->boundary[1], '', 'text/plain', '');
    1776                 $body .= $this->encodeString($this->AltBody, $this->Encoding);
     1874                $body .= $this->getBoundary($this->boundary[1], $altBodyCharSet, 'text/plain', $altBodyEncoding);
     1875                $body .= $this->encodeString($this->AltBody, $altBodyEncoding);
    17771876                $body .= $this->LE . $this->LE;
    17781877                $body .= $this->textLine('--' . $this->boundary[1]);
    17791878                $body .= $this->headerLine('Content-Type', 'multipart/related;');
    17801879                $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
    17811880                $body .= $this->LE;
    1782                 $body .= $this->getBoundary($this->boundary[2], '', 'text/html', '');
    1783                 $body .= $this->encodeString($this->Body, $this->Encoding);
     1881                $body .= $this->getBoundary($this->boundary[2], $bodyCharSet, 'text/html', $bodyEncoding);
     1882                $body .= $this->encodeString($this->Body, $bodyEncoding);
    17841883                $body .= $this->LE . $this->LE;
    17851884                $body .= $this->attachAll('inline', $this->boundary[2]);
    17861885                $body .= $this->LE;
     
    17911890                $body .= $this->headerLine('Content-Type', 'multipart/alternative;');
    17921891                $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
    17931892                $body .= $this->LE;
    1794                 $body .= $this->getBoundary($this->boundary[2], '', 'text/plain', '');
    1795                 $body .= $this->encodeString($this->AltBody, $this->Encoding);
     1893                $body .= $this->getBoundary($this->boundary[2], $altBodyCharSet, 'text/plain', $altBodyEncoding);
     1894                $body .= $this->encodeString($this->AltBody, $altBodyEncoding);
    17961895                $body .= $this->LE . $this->LE;
    1797                 $body .= $this->getBoundary($this->boundary[2], '', 'text/html', '');
    1798                 $body .= $this->encodeString($this->Body, $this->Encoding);
     1896                $body .= $this->getBoundary($this->boundary[2], $bodyCharSet, 'text/html', $bodyEncoding);
     1897                $body .= $this->encodeString($this->Body, $bodyEncoding);
    17991898                $body .= $this->LE . $this->LE;
    18001899                $body .= $this->endBoundary($this->boundary[2]);
    18011900                $body .= $this->LE;
     
    18061905                $body .= $this->headerLine('Content-Type', 'multipart/alternative;');
    18071906                $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
    18081907                $body .= $this->LE;
    1809                 $body .= $this->getBoundary($this->boundary[2], '', 'text/plain', '');
    1810                 $body .= $this->encodeString($this->AltBody, $this->Encoding);
     1908                $body .= $this->getBoundary($this->boundary[2], $altBodyCharSet, 'text/plain', $altBodyEncoding);
     1909                $body .= $this->encodeString($this->AltBody, $altBodyEncoding);
    18111910                $body .= $this->LE . $this->LE;
    18121911                $body .= $this->textLine('--' . $this->boundary[2]);
    18131912                $body .= $this->headerLine('Content-Type', 'multipart/related;');
    18141913                $body .= $this->textLine("\tboundary=\"" . $this->boundary[3] . '"');
    18151914                $body .= $this->LE;
    1816                 $body .= $this->getBoundary($this->boundary[3], '', 'text/html', '');
    1817                 $body .= $this->encodeString($this->Body, $this->Encoding);
     1915                $body .= $this->getBoundary($this->boundary[3], $bodyCharSet, 'text/html', $bodyEncoding);
     1916                $body .= $this->encodeString($this->Body, $bodyEncoding);
    18181917                $body .= $this->LE . $this->LE;
    18191918                $body .= $this->attachAll('inline', $this->boundary[3]);
    18201919                $body .= $this->LE;
     
    18241923                break;
    18251924            default:
    18261925                // catch case 'plain' and case ''
    1827                 $body .= $this->encodeString($this->Body, $this->Encoding);
     1926                $body .= $this->encodeString($this->Body, $bodyEncoding);
    18281927                break;
    18291928        }
    18301929
     
    18351934                if (!defined('PKCS7_TEXT')) {
    18361935                    throw new phpmailerException($this->lang('signing') . ' OpenSSL extension missing.');
    18371936                }
     1937                // @TODO would be nice to use php://temp streams here, but need to wrap for PHP < 5.1
    18381938                $file = tempnam(sys_get_temp_dir(), 'mail');
    1839                 file_put_contents($file, $body); //TODO check this worked
     1939                file_put_contents($file, $body); // @TODO check this worked
    18401940                $signed = tempnam(sys_get_temp_dir(), 'signed');
    18411941                if (@openssl_pkcs7_sign(
    18421942                    $file,
     
    18541954                    @unlink($signed);
    18551955                    throw new phpmailerException($this->lang('signing') . openssl_error_string());
    18561956                }
    1857             } catch (phpmailerException $e) {
     1957            } catch (phpmailerException $exc) {
    18581958                $body = '';
    18591959                if ($this->exceptions) {
    1860                     throw $e;
     1960                    throw $exc;
    18611961                }
    18621962            }
    18631963        }
     
    18861986            $encoding = $this->Encoding;
    18871987        }
    18881988        $result .= $this->textLine('--' . $boundary);
    1889         $result .= sprintf("Content-Type: %s; charset=%s", $contentType, $charSet);
     1989        $result .= sprintf('Content-Type: %s; charset=%s', $contentType, $charSet);
    18901990        $result .= $this->LE;
    1891         $result .= $this->headerLine('Content-Transfer-Encoding', $encoding);
     1991        // RFC1341 part 5 says 7bit is assumed if not specified
     1992        if ($encoding != '7bit') {
     1993            $result .= $this->headerLine('Content-Transfer-Encoding', $encoding);
     1994        }
    18921995        $result .= $this->LE;
    18931996
    18941997        return $result;
     
    19142017     */
    19152018    protected function setMessageType()
    19162019    {
    1917         $this->message_type = array();
     2020        $type = array();
    19182021        if ($this->alternativeExists()) {
    1919             $this->message_type[] = "alt";
     2022            $type[] = 'alt';
    19202023        }
    19212024        if ($this->inlineImageExists()) {
    1922             $this->message_type[] = "inline";
     2025            $type[] = 'inline';
    19232026        }
    19242027        if ($this->attachmentExists()) {
    1925             $this->message_type[] = "attach";
     2028            $type[] = 'attach';
    19262029        }
    1927         $this->message_type = implode("_", $this->message_type);
    1928         if ($this->message_type == "") {
    1929             $this->message_type = "plain";
     2030        $this->message_type = implode('_', $type);
     2031        if ($this->message_type == '') {
     2032            $this->message_type = 'plain';
    19302033        }
    19312034    }
    19322035
     
    19622065     * @param string $type File extension (MIME) type.
    19632066     * @param string $disposition Disposition to use
    19642067     * @throws phpmailerException
    1965      * @return bool
     2068     * @return boolean
    19662069     */
    19672070    public function addAttachment($path, $name = '', $encoding = 'base64', $type = '', $disposition = 'attachment')
    19682071    {
     
    19712074                throw new phpmailerException($this->lang('file_access') . $path, self::STOP_CONTINUE);
    19722075            }
    19732076
    1974             //If a MIME type is not specified, try to work it out from the file name
     2077            // If a MIME type is not specified, try to work it out from the file name
    19752078            if ($type == '') {
    19762079                $type = self::filenameToType($path);
    19772080            }
     
    19922095                7 => 0
    19932096            );
    19942097
    1995         } catch (phpmailerException $e) {
    1996             $this->setError($e->getMessage());
     2098        } catch (phpmailerException $exc) {
     2099            $this->setError($exc->getMessage());
     2100            $this->edebug($exc->getMessage());
    19972101            if ($this->exceptions) {
    1998                 throw $e;
     2102                throw $exc;
    19992103            }
    2000             $this->edebug($e->getMessage() . "\n");
    20012104            return false;
    20022105        }
    20032106        return true;
     
    20562159                }
    20572160                $cidUniq[$cid] = true;
    20582161
    2059                 $mime[] = sprintf("--%s%s", $boundary, $this->LE);
     2162                $mime[] = sprintf('--%s%s', $boundary, $this->LE);
    20602163                $mime[] = sprintf(
    2061                     "Content-Type: %s; name=\"%s\"%s",
     2164                    'Content-Type: %s; name="%s"%s',
    20622165                    $type,
    20632166                    $this->encodeHeader($this->secureHeader($name)),
    20642167                    $this->LE
    20652168                );
    2066                 $mime[] = sprintf("Content-Transfer-Encoding: %s%s", $encoding, $this->LE);
     2169                // RFC1341 part 5 says 7bit is assumed if not specified
     2170                if ($encoding != '7bit') {
     2171                    $mime[] = sprintf('Content-Transfer-Encoding: %s%s', $encoding, $this->LE);
     2172                }
    20672173
    20682174                if ($disposition == 'inline') {
    2069                     $mime[] = sprintf("Content-ID: <%s>%s", $cid, $this->LE);
     2175                    $mime[] = sprintf('Content-ID: <%s>%s', $cid, $this->LE);
    20702176                }
    20712177
    20722178                // If a filename contains any of these chars, it should be quoted,
     
    20742180                // Fixes a warning in IETF's msglint MIME checker
    20752181                // Allow for bypassing the Content-Disposition header totally
    20762182                if (!(empty($disposition))) {
    2077                     if (preg_match('/[ \(\)<>@,;:\\"\/\[\]\?=]/', $name)) {
     2183                    $encoded_name = $this->encodeHeader($this->secureHeader($name));
     2184                    if (preg_match('/[ \(\)<>@,;:\\"\/\[\]\?=]/', $encoded_name)) {
    20782185                        $mime[] = sprintf(
    2079                             "Content-Disposition: %s; filename=\"%s\"%s",
     2186                            'Content-Disposition: %s; filename="%s"%s',
    20802187                            $disposition,
    2081                             $this->encodeHeader($this->secureHeader($name)),
     2188                            $encoded_name,
    20822189                            $this->LE . $this->LE
    20832190                        );
    20842191                    } else {
    20852192                        $mime[] = sprintf(
    2086                             "Content-Disposition: %s; filename=%s%s",
     2193                            'Content-Disposition: %s; filename=%s%s',
    20872194                            $disposition,
    2088                             $this->encodeHeader($this->secureHeader($name)),
     2195                            $encoded_name,
    20892196                            $this->LE . $this->LE
    20902197                        );
    20912198                    }
     
    21102217            }
    21112218        }
    21122219
    2113         $mime[] = sprintf("--%s--%s", $boundary, $this->LE);
     2220        $mime[] = sprintf('--%s--%s', $boundary, $this->LE);
    21142221
    2115         return implode("", $mime);
     2222        return implode('', $mime);
    21162223    }
    21172224
    21182225    /**
     
    21342241            $magic_quotes = get_magic_quotes_runtime();
    21352242            if ($magic_quotes) {
    21362243                if (version_compare(PHP_VERSION, '5.3.0', '<')) {
    2137                     set_magic_quotes_runtime(0);
     2244                    set_magic_quotes_runtime(false);
    21382245                } else {
     2246                    //Doesn't exist in PHP 5.4, but we don't need to check because
     2247                    //get_magic_quotes_runtime always returns false in 5.4+
     2248                    //so it will never get here
    21392249                    ini_set('magic_quotes_runtime', 0);
    21402250                }
    21412251            }
     
    21452255                if (version_compare(PHP_VERSION, '5.3.0', '<')) {
    21462256                    set_magic_quotes_runtime($magic_quotes);
    21472257                } else {
    2148                     ini_set('magic_quotes_runtime', $magic_quotes);
     2258                    ini_set('magic_quotes_runtime', ($magic_quotes?'1':'0'));
    21492259                }
    21502260            }
    21512261            return $file_buffer;
    2152         } catch (Exception $e) {
    2153             $this->setError($e->getMessage());
     2262        } catch (Exception $exc) {
     2263            $this->setError($exc->getMessage());
    21542264            return '';
    21552265        }
    21562266    }
     
    21732283            case '7bit':
    21742284            case '8bit':
    21752285                $encoded = $this->fixEOL($str);
    2176                 //Make sure it ends with a line break
     2286                // Make sure it ends with a line break
    21772287                if (substr($encoded, -(strlen($this->LE))) != $this->LE) {
    21782288                    $encoded .= $this->LE;
    21792289                }
     
    22012311     */
    22022312    public function encodeHeader($str, $position = 'text')
    22032313    {
    2204         $x = 0;
     2314        $matchcount = 0;
    22052315        switch (strtolower($position)) {
    22062316            case 'phrase':
    22072317                if (!preg_match('/[\200-\377]/', $str)) {
    2208                     // Can't use addslashes as we don't know what value has magic_quotes_sybase
     2318                    // Can't use addslashes as we don't know the value of magic_quotes_sybase
    22092319                    $encoded = addcslashes($str, "\0..\37\177\\\"");
    22102320                    if (($str == $encoded) && !preg_match('/[^A-Za-z0-9!#$%&\'*+\/=?^_`{|}~ -]/', $str)) {
    22112321                        return ($encoded);
     
    22132323                        return ("\"$encoded\"");
    22142324                    }
    22152325                }
    2216                 $x = preg_match_all('/[^\040\041\043-\133\135-\176]/', $str, $matches);
     2326                $matchcount = preg_match_all('/[^\040\041\043-\133\135-\176]/', $str, $matches);
    22172327                break;
    22182328            /** @noinspection PhpMissingBreakStatementInspection */
    22192329            case 'comment':
    2220                 $x = preg_match_all('/[()"]/', $str, $matches);
     2330                $matchcount = preg_match_all('/[()"]/', $str, $matches);
    22212331                // Intentional fall-through
    22222332            case 'text':
    22232333            default:
    2224                 $x += preg_match_all('/[\000-\010\013\014\016-\037\177-\377]/', $str, $matches);
     2334                $matchcount += preg_match_all('/[\000-\010\013\014\016-\037\177-\377]/', $str, $matches);
    22252335                break;
    22262336        }
    22272337
    2228         if ($x == 0) { //There are no chars that need encoding
     2338        if ($matchcount == 0) { // There are no chars that need encoding
    22292339            return ($str);
    22302340        }
    22312341
    22322342        $maxlen = 75 - 7 - strlen($this->CharSet);
    22332343        // Try to select the encoding which should produce the shortest output
    2234         if ($x > strlen($str) / 3) {
    2235             //More than a third of the content will need encoding, so B encoding will be most efficient
     2344        if ($matchcount > strlen($str) / 3) {
     2345            // More than a third of the content will need encoding, so B encoding will be most efficient
    22362346            $encoding = 'B';
    22372347            if (function_exists('mb_strlen') && $this->hasMultiBytes($str)) {
    22382348                // Use a custom function which correctly encodes and wraps long
     
    22502360            $encoded = str_replace('=' . self::CRLF, "\n", trim($encoded));
    22512361        }
    22522362
    2253         $encoded = preg_replace('/^(.*)$/m', " =?" . $this->CharSet . "?$encoding?\\1?=", $encoded);
     2363        $encoded = preg_replace('/^(.*)$/m', ' =?' . $this->CharSet . "?$encoding?\\1?=", $encoded);
    22542364        $encoded = trim(str_replace("\n", $this->LE, $encoded));
    22552365
    22562366        return $encoded;
     
    22602370     * Check if a string contains multi-byte characters.
    22612371     * @access public
    22622372     * @param string $str multi-byte text to wrap encode
    2263      * @return bool
     2373     * @return boolean
    22642374     */
    22652375    public function hasMultiBytes($str)
    22662376    {
     
    22722382    }
    22732383
    22742384    /**
     2385     * Does a string contain any 8-bit chars (in any charset)?
     2386     * @param string $text
     2387     * @return boolean
     2388     */
     2389    public function has8bitChars($text)
     2390    {
     2391        return (boolean)preg_match('/[\x80-\xFF]/', $text);
     2392    }
     2393
     2394    /**
    22752395     * Encode and wrap long multibyte strings for mail headers
    22762396     * without breaking lines within a character.
    2277      * Adapted from a function by paravoid at http://uk.php.net/manual/en/function.mb-encode-mimeheader.php
     2397     * Adapted from a function by paravoid
     2398     * @link http://www.php.net/manual/en/function.mb-encode-mimeheader.php#60283
    22782399     * @access public
    22792400     * @param string $str multi-byte text to wrap encode
    2280      * @param string $lf string to use as linefeed/end-of-line
     2401     * @param string $linebreak string to use as linefeed/end-of-line
    22812402     * @return string
    22822403     */
    2283     public function base64EncodeWrapMB($str, $lf = null)
     2404    public function base64EncodeWrapMB($str, $linebreak = null)
    22842405    {
    2285         $start = "=?" . $this->CharSet . "?B?";
    2286         $end = "?=";
    2287         $encoded = "";
    2288         if ($lf === null) {
    2289             $lf = $this->LE;
     2406        $start = '=?' . $this->CharSet . '?B?';
     2407        $end = '?=';
     2408        $encoded = '';
     2409        if ($linebreak === null) {
     2410            $linebreak = $this->LE;
    22902411        }
    22912412
    22922413        $mb_length = mb_strlen($str, $this->CharSet);
     
    23052426                $chunk = base64_encode($chunk);
    23062427                $lookBack++;
    23072428            } while (strlen($chunk) > $length);
    2308             $encoded .= $chunk . $lf;
     2429            $encoded .= $chunk . $linebreak;
    23092430        }
    23102431
    23112432        // Chomp the last linefeed
    2312         $encoded = substr($encoded, 0, -strlen($lf));
     2433        $encoded = substr($encoded, 0, -strlen($linebreak));
    23132434        return $encoded;
    23142435    }
    23152436
     
    23202441     * @param string $string The text to encode
    23212442     * @param integer $line_max Number of chars allowed on a line before wrapping
    23222443     * @return string
    2323      * @link PHP version adapted from http://www.php.net/manual/en/function.quoted-printable-decode.php#89417
     2444     * @link http://www.php.net/manual/en/function.quoted-printable-decode.php#89417 Adapted from this comment
    23242445     */
    23252446    public function encodeQP($string, $line_max = 76)
    23262447    {
    2327         if (function_exists('quoted_printable_encode')) { //Use native function if it's available (>= PHP5.3)
    2328             return quoted_printable_encode($string);
     2448        if (function_exists('quoted_printable_encode')) { // Use native function if it's available (>= PHP5.3)
     2449            return $this->fixEOL(quoted_printable_encode($string));
    23292450        }
    2330         //Fall back to a pure PHP implementation
     2451        // Fall back to a pure PHP implementation
    23312452        $string = str_replace(
    23322453            array('%20', '%0D%0A.', '%0D%0A', '%'),
    23332454            array(' ', "\r\n=2E", "\r\n", '='),
     
    23342455            rawurlencode($string)
    23352456        );
    23362457        $string = preg_replace('/[^\r\n]{' . ($line_max - 3) . '}[^=\r\n]{2}/', "$0=\r\n", $string);
    2337         return $string;
     2458        return $this->fixEOL($string);
    23382459    }
    23392460
    23402461    /**
     
    23432464     * @access public
    23442465     * @param string $string
    23452466     * @param integer $line_max
    2346      * @param bool $space_conv
     2467     * @param boolean $space_conv
    23472468     * @return string
    23482469     * @deprecated Use encodeQP instead.
    23492470     */
     
    23652486     */
    23662487    public function encodeQ($str, $position = 'text')
    23672488    {
    2368         //There should not be any EOL in the string
     2489        // There should not be any EOL in the string
    23692490        $pattern = '';
    23702491        $encoded = str_replace(array("\r", "\n"), '', $str);
    23712492        switch (strtolower($position)) {
    23722493            case 'phrase':
    2373                 //RFC 2047 section 5.3
     2494                // RFC 2047 section 5.3
    23742495                $pattern = '^A-Za-z0-9!*+\/ -';
    23752496                break;
    23762497            /** @noinspection PhpMissingBreakStatementInspection */
    23772498            case 'comment':
    2378                 //RFC 2047 section 5.2
     2499                // RFC 2047 section 5.2
    23792500                $pattern = '\(\)"';
    2380                 //intentional fall-through
    2381                 //for this reason we build the $pattern without including delimiters and []
     2501                // intentional fall-through
     2502                // for this reason we build the $pattern without including delimiters and []
    23822503            case 'text':
    23832504            default:
    2384                 //RFC 2047 section 5.1
    2385                 //Replace every high ascii, control, =, ? and _ characters
     2505                // RFC 2047 section 5.1
     2506                // Replace every high ascii, control, =, ? and _ characters
    23862507                $pattern = '\000-\011\013\014\016-\037\075\077\137\177-\377' . $pattern;
    23872508                break;
    23882509        }
    23892510        $matches = array();
    23902511        if (preg_match_all("/[{$pattern}]/", $encoded, $matches)) {
    2391             //If the string contains an '=', make sure it's the first thing we replace
    2392             //so as to avoid double-encoding
    2393             $s = array_search('=', $matches[0]);
    2394             if ($s !== false) {
    2395                 unset($matches[0][$s]);
     2512            // If the string contains an '=', make sure it's the first thing we replace
     2513            // so as to avoid double-encoding
     2514            $eqkey = array_search('=', $matches[0]);
     2515            if ($eqkey !== false) {
     2516                unset($matches[0][$eqkey]);
    23962517                array_unshift($matches[0], '=');
    23972518            }
    23982519            foreach (array_unique($matches[0]) as $char) {
     
    23992520                $encoded = str_replace($char, '=' . sprintf('%02X', ord($char)), $encoded);
    24002521            }
    24012522        }
    2402         //Replace every spaces to _ (more readable than =20)
     2523        // Replace every spaces to _ (more readable than =20)
    24032524        return str_replace(' ', '_', $encoded);
    24042525    }
    24052526
     
    24222543        $type = '',
    24232544        $disposition = 'attachment'
    24242545    ) {
    2425         //If a MIME type is not specified, try to work it out from the file name
     2546        // If a MIME type is not specified, try to work it out from the file name
    24262547        if ($type == '') {
    24272548            $type = self::filenameToType($filename);
    24282549        }
     
    24532574     * @param string $encoding File encoding (see $Encoding).
    24542575     * @param string $type File MIME type.
    24552576     * @param string $disposition Disposition to use
    2456      * @return bool True on successfully adding an attachment
     2577     * @return boolean True on successfully adding an attachment
    24572578     */
    24582579    public function addEmbeddedImage($path, $cid, $name = '', $encoding = 'base64', $type = '', $disposition = 'inline')
    24592580    {
     
    24622583            return false;
    24632584        }
    24642585
    2465         //If a MIME type is not specified, try to work it out from the file name
     2586        // If a MIME type is not specified, try to work it out from the file name
    24662587        if ($type == '') {
    24672588            $type = self::filenameToType($path);
    24682589        }
     
    24982619     * @param string $encoding File encoding (see $Encoding).
    24992620     * @param string $type MIME type.
    25002621     * @param string $disposition Disposition to use
    2501      * @return bool True on successfully adding an attachment
     2622     * @return boolean True on successfully adding an attachment
    25022623     */
    25032624    public function addStringEmbeddedImage(
    25042625        $string,
     
    25082629        $type = '',
    25092630        $disposition = 'inline'
    25102631    ) {
    2511         //If a MIME type is not specified, try to work it out from the name
     2632        // If a MIME type is not specified, try to work it out from the name
    25122633        if ($type == '') {
    25132634            $type = self::filenameToType($name);
    25142635        }
     
    25302651    /**
    25312652     * Check if an inline attachment is present.
    25322653     * @access public
    2533      * @return bool
     2654     * @return boolean
    25342655     */
    25352656    public function inlineImageExists()
    25362657    {
     
    25442665
    25452666    /**
    25462667     * Check if an attachment (non-inline) is present.
    2547      * @return bool
     2668     * @return boolean
    25482669     */
    25492670    public function attachmentExists()
    25502671    {
     
    25582679
    25592680    /**
    25602681     * Check if this message has an alternative body set.
    2561      * @return bool
     2682     * @return boolean
    25622683     */
    25632684    public function alternativeExists()
    25642685    {
     
    26662787     */
    26672788    public static function rfcDate()
    26682789    {
    2669         //Set the time zone to whatever the default is to avoid 500 errors
    2670         //Will default to UTC if it's not set properly in php.ini
     2790        // Set the time zone to whatever the default is to avoid 500 errors
     2791        // Will default to UTC if it's not set properly in php.ini
    26712792        date_default_timezone_set(@date_default_timezone_get());
    26722793        return date('D, j M Y H:i:s O');
    26732794    }
     
    26802801     */
    26812802    protected function serverHostname()
    26822803    {
     2804        $result = 'localhost.localdomain';
    26832805        if (!empty($this->Hostname)) {
    26842806            $result = $this->Hostname;
    2685         } elseif (isset($_SERVER['SERVER_NAME'])) {
     2807        } elseif (isset($_SERVER) and array_key_exists('SERVER_NAME', $_SERVER) and !empty($_SERVER['SERVER_NAME'])) {
    26862808            $result = $_SERVER['SERVER_NAME'];
    2687         } else {
    2688             $result = 'localhost.localdomain';
     2809        } elseif (function_exists('gethostname') && gethostname() !== false) {
     2810            $result = gethostname();
     2811        } elseif (php_uname('n') !== false) {
     2812            $result = php_uname('n');
    26892813        }
    2690 
    26912814        return $result;
    26922815    }
    26932816
     
    27132836    /**
    27142837     * Check if an error occurred.
    27152838     * @access public
    2716      * @return bool True if an error did occur.
     2839     * @return boolean True if an error did occur.
    27172840     */
    27182841    public function isError()
    27192842    {
     
    27652888     * @access public
    27662889     * @param string $message HTML message string
    27672890     * @param string $basedir baseline directory for path
    2768      * @param bool $advanced Whether to use the advanced HTML to text converter
     2891     * @param boolean $advanced Whether to use the advanced HTML to text converter
    27692892     * @return string $message
    27702893     */
    27712894    public function msgHTML($message, $basedir = '', $advanced = false)
    27722895    {
    2773         preg_match_all("/(src|background)=[\"'](.*)[\"']/Ui", $message, $images);
     2896        preg_match_all('/(src|background)=["\'](.*)["\']/Ui', $message, $images);
    27742897        if (isset($images[2])) {
    2775             foreach ($images[2] as $i => $url) {
    2776                 // do not change urls for absolute images (thanks to corvuscorax)
    2777                 if (!preg_match('#^[A-z]+://#', $url)) {
     2898            foreach ($images[2] as $imgindex => $url) {
     2899                // Convert data URIs into embedded images
     2900                if (preg_match('#^data:(image[^;,]*)(;base64)?,#', $url, $match)) {
     2901                    $data = substr($url, strpos($url, ','));
     2902                    if ($match[2]) {
     2903                        $data = base64_decode($data);
     2904                    } else {
     2905                        $data = rawurldecode($data);
     2906                    }
     2907                    $cid = md5($url) . '@phpmailer.0'; // RFC2392 S 2
     2908                    if ($this->addStringEmbeddedImage($data, $cid, '', 'base64', $match[1])) {
     2909                        $message = preg_replace(
     2910                            '/' . $images[1][$imgindex] . '=["\']' . preg_quote($url, '/') . '["\']/Ui',
     2911                            $images[1][$imgindex] . '="cid:' . $cid . '"',
     2912                            $message
     2913                        );
     2914                    }
     2915                } elseif (!preg_match('#^[A-z]+://#', $url)) {
     2916                    // Do not change urls for absolute images (thanks to corvuscorax)
    27782917                    $filename = basename($url);
    27792918                    $directory = dirname($url);
    27802919                    if ($directory == '.') {
    27812920                        $directory = '';
    27822921                    }
    2783                     $cid = md5($url) . '@phpmailer.0'; //RFC2392 S 2
     2922                    $cid = md5($url) . '@phpmailer.0'; // RFC2392 S 2
    27842923                    if (strlen($basedir) > 1 && substr($basedir, -1) != '/') {
    27852924                        $basedir .= '/';
    27862925                    }
     
    27962935                    )
    27972936                    ) {
    27982937                        $message = preg_replace(
    2799                             "/" . $images[1][$i] . "=[\"']" . preg_quote($url, '/') . "[\"']/Ui",
    2800                             $images[1][$i] . "=\"cid:" . $cid . "\"",
     2938                            '/' . $images[1][$imgindex] . '=["\']' . preg_quote($url, '/') . '["\']/Ui',
     2939                            $images[1][$imgindex] . '="cid:' . $cid . '"',
    28012940                            $message
    28022941                        );
    28032942                    }
     
    28052944            }
    28062945        }
    28072946        $this->isHTML(true);
     2947        // Convert all message body line breaks to CRLF, makes quoted-printable encoding work much better
     2948        $this->Body = $this->normalizeBreaks($message);
     2949        $this->AltBody = $this->normalizeBreaks($this->html2text($message, $advanced));
    28082950        if (empty($this->AltBody)) {
    2809             $this->AltBody = 'To view this email message, open it in a program that understands HTML!' . "\n\n";
     2951            $this->AltBody = 'To view this email message, open it in a program that understands HTML!' .
     2952                self::CRLF . self::CRLF;
    28102953        }
    2811         //Convert all message body line breaks to CRLF, makes quoted-printable encoding work much better
    2812         $this->Body = $this->normalizeBreaks($message);
    2813         $this->AltBody = $this->normalizeBreaks($this->html2text($message, $advanced));
    28142954        return $this->Body;
    28152955    }
    28162956
     
    28172957    /**
    28182958     * Convert an HTML string into plain text.
    28192959     * @param string $html The HTML text to convert
    2820      * @param bool $advanced Should this use the more complex html2text converter or just a simple one?
     2960     * @param boolean $advanced Should this use the more complex html2text converter or just a simple one?
    28212961     * @return string
    28222962     */
    28232963    public function html2text($html, $advanced = false)
     
    28242964    {
    28252965        if ($advanced) {
    28262966            require_once 'extras/class.html2text.php';
    2827             $h = new html2text($html);
    2828             return $h->get_text();
     2967            $htmlconverter = new html2text($html);
     2968            return $htmlconverter->get_text();
    28292969        }
    28302970        return html_entity_decode(
    28312971            trim(strip_tags(preg_replace('/<(head|title|style|script)[^>]*>.*?<\/\\1>/si', '', $html))),
     
    29203060            'txt' => 'text/plain',
    29213061            'rtx' => 'text/richtext',
    29223062            'rtf' => 'text/rtf',
     3063            'vcf' => 'text/vcard',
     3064            'vcard' => 'text/vcard',
    29233065            'xml' => 'text/xml',
    29243066            'xsl' => 'text/xml',
    29253067            'mpeg' => 'video/mpeg',
     
    29433085     */
    29443086    public static function filenameToType($filename)
    29453087    {
    2946         //In case the path is a URL, strip any query string before getting extension
     3088        // In case the path is a URL, strip any query string before getting extension
    29473089        $qpos = strpos($filename, '?');
    29483090        if ($qpos !== false) {
    29493091            $filename = substr($filename, 0, $qpos);
     
    29663108    public static function mb_pathinfo($path, $options = null)
    29673109    {
    29683110        $ret = array('dirname' => '', 'basename' => '', 'extension' => '', 'filename' => '');
    2969         $m = array();
    2970         preg_match('%^(.*?)[\\\\/]*(([^/\\\\]*?)(\.([^\.\\\\/]+?)|))[\\\\/\.]*$%im', $path, $m);
    2971         if (array_key_exists(1, $m)) {
    2972             $ret['dirname'] = $m[1];
     3111        $pathinfo = array();
     3112        if (preg_match('%^(.*?)[\\\\/]*(([^/\\\\]*?)(\.([^\.\\\\/]+?)|))[\\\\/\.]*$%im', $path, $pathinfo)) {
     3113            if (array_key_exists(1, $pathinfo)) {
     3114                $ret['dirname'] = $pathinfo[1];
     3115            }
     3116            if (array_key_exists(2, $pathinfo)) {
     3117                $ret['basename'] = $pathinfo[2];
     3118            }
     3119            if (array_key_exists(5, $pathinfo)) {
     3120                $ret['extension'] = $pathinfo[5];
     3121            }
     3122            if (array_key_exists(3, $pathinfo)) {
     3123                $ret['filename'] = $pathinfo[3];
     3124            }
    29733125        }
    2974         if (array_key_exists(2, $m)) {
    2975             $ret['basename'] = $m[2];
    2976         }
    2977         if (array_key_exists(5, $m)) {
    2978             $ret['extension'] = $m[5];
    2979         }
    2980         if (array_key_exists(3, $m)) {
    2981             $ret['filename'] = $m[3];
    2982         }
    29833126        switch ($options) {
    29843127            case PATHINFO_DIRNAME:
    29853128            case 'dirname':
    29863129                return $ret['dirname'];
    2987                 break;
    29883130            case PATHINFO_BASENAME:
    29893131            case 'basename':
    29903132                return $ret['basename'];
    2991                 break;
    29923133            case PATHINFO_EXTENSION:
    29933134            case 'extension':
    29943135                return $ret['extension'];
    2995                 break;
    29963136            case PATHINFO_FILENAME:
    29973137            case 'filename':
    29983138                return $ret['filename'];
    2999                 break;
    30003139            default:
    30013140                return $ret;
    30023141        }
     
    30133152     * @param mixed $value
    30143153     * NOTE: will not work with arrays, there are no arrays to set/reset
    30153154     * @throws phpmailerException
    3016      * @return bool
    3017      * @todo Should this not be using __set() magic function?
     3155     * @return boolean
     3156     * @TODO Should this not be using __set() magic function?
    30183157     */
    30193158    public function set($name, $value = '')
    30203159    {
     
    30243163            } else {
    30253164                throw new phpmailerException($this->lang('variable_set') . $name, self::STOP_CRITICAL);
    30263165            }
    3027         } catch (Exception $e) {
    3028             $this->setError($e->getMessage());
    3029             if ($e->getCode() == self::STOP_CRITICAL) {
     3166        } catch (Exception $exc) {
     3167            $this->setError($exc->getMessage());
     3168            if ($exc->getCode() == self::STOP_CRITICAL) {
    30303169                return false;
    30313170            }
    30323171        }
     
    30613200
    30623201
    30633202    /**
    3064      * Set the private key file and password for S/MIME signing.
     3203     * Set the public and private key files and password for S/MIME signing.
    30653204     * @access public
    30663205     * @param string $cert_filename
    30673206     * @param string $key_filename
     
    30883227            if (((0x21 <= $ord) && ($ord <= 0x3A)) || $ord == 0x3C || ((0x3E <= $ord) && ($ord <= 0x7E))) {
    30893228                $line .= $txt[$i];
    30903229            } else {
    3091                 $line .= "=" . sprintf("%02X", $ord);
     3230                $line .= '=' . sprintf('%02X', $ord);
    30923231            }
    30933232        }
    30943233        return $line;
     
    30973236    /**
    30983237     * Generate a DKIM signature.
    30993238     * @access public
    3100      * @param string $s Header
     3239     * @param string $signHeader
    31013240     * @throws phpmailerException
    31023241     * @return string
    31033242     */
    3104     public function DKIM_Sign($s)
     3243    public function DKIM_Sign($signHeader)
    31053244    {
    31063245        if (!defined('PKCS7_TEXT')) {
    31073246            if ($this->exceptions) {
    3108                 throw new phpmailerException($this->lang("signing") . ' OpenSSL extension missing.');
     3247                throw new phpmailerException($this->lang('signing') . ' OpenSSL extension missing.');
    31093248            }
    31103249            return '';
    31113250        }
     
    31153254        } else {
    31163255            $privKey = $privKeyStr;
    31173256        }
    3118         if (openssl_sign($s, $signature, $privKey)) {
     3257        if (openssl_sign($signHeader, $signature, $privKey)) {
    31193258            return base64_encode($signature);
    31203259        }
    31213260        return '';
     
    31243263    /**
    31253264     * Generate a DKIM canonicalization header.
    31263265     * @access public
    3127      * @param string $s Header
     3266     * @param string $signHeader Header
    31283267     * @return string
    31293268     */
    3130     public function DKIM_HeaderC($s)
     3269    public function DKIM_HeaderC($signHeader)
    31313270    {
    3132         $s = preg_replace("/\r\n\s+/", " ", $s);
    3133         $lines = explode("\r\n", $s);
     3271        $signHeader = preg_replace('/\r\n\s+/', ' ', $signHeader);
     3272        $lines = explode("\r\n", $signHeader);
    31343273        foreach ($lines as $key => $line) {
    3135             list($heading, $value) = explode(":", $line, 2);
     3274            list($heading, $value) = explode(':', $line, 2);
    31363275            $heading = strtolower($heading);
    3137             $value = preg_replace("/\s+/", " ", $value); // Compress useless spaces
    3138             $lines[$key] = $heading . ":" . trim($value); // Don't forget to remove WSP around the value
     3276            $value = preg_replace('/\s+/', ' ', $value); // Compress useless spaces
     3277            $lines[$key] = $heading . ':' . trim($value); // Don't forget to remove WSP around the value
    31393278        }
    3140         $s = implode("\r\n", $lines);
    3141         return $s;
     3279        $signHeader = implode("\r\n", $lines);
     3280        return $signHeader;
    31423281    }
    31433282
    31443283    /**
     
    32053344        ); // Copied header fields (dkim-quoted-printable)
    32063345        $body = $this->DKIM_BodyC($body);
    32073346        $DKIMlen = strlen($body); // Length of body
    3208         $DKIMb64 = base64_encode(pack("H*", sha1($body))); // Base64 of packed binary SHA-1 hash of body
    3209         $ident = ($this->DKIM_identity == '') ? '' : " i=" . $this->DKIM_identity . ";";
    3210         $dkimhdrs = "DKIM-Signature: v=1; a=" .
    3211             $DKIMsignatureType . "; q=" .
    3212             $DKIMquery . "; l=" .
    3213             $DKIMlen . "; s=" .
     3347        $DKIMb64 = base64_encode(pack('H*', sha1($body))); // Base64 of packed binary SHA-1 hash of body
     3348        $ident = ($this->DKIM_identity == '') ? '' : ' i=' . $this->DKIM_identity . ';';
     3349        $dkimhdrs = 'DKIM-Signature: v=1; a=' .
     3350            $DKIMsignatureType . '; q=' .
     3351            $DKIMquery . '; l=' .
     3352            $DKIMlen . '; s=' .
    32143353            $this->DKIM_selector .
    32153354            ";\r\n" .
    3216             "\tt=" . $DKIMtime . "; c=" . $DKIMcanonicalization . ";\r\n" .
     3355            "\tt=" . $DKIMtime . '; c=' . $DKIMcanonicalization . ";\r\n" .
    32173356            "\th=From:To:Subject;\r\n" .
    3218             "\td=" . $this->DKIM_domain . ";" . $ident . "\r\n" .
     3357            "\td=" . $this->DKIM_domain . ';' . $ident . "\r\n" .
    32193358            "\tz=$from\r\n" .
    32203359            "\t|$to\r\n" .
    32213360            "\t|$subject;\r\n" .
     
    32293368    }
    32303369
    32313370    /**
     3371     * Allows for public read access to 'to' property.
     3372     * @access public
     3373     * @return array
     3374     */
     3375    public function getToAddresses()
     3376    {
     3377        return $this->to;
     3378    }
     3379
     3380    /**
     3381     * Allows for public read access to 'cc' property.
     3382     * @access public
     3383     * @return array
     3384     */
     3385    public function getCcAddresses()
     3386    {
     3387        return $this->cc;
     3388    }
     3389
     3390    /**
     3391     * Allows for public read access to 'bcc' property.
     3392     * @access public
     3393     * @return array
     3394     */
     3395    public function getBccAddresses()
     3396    {
     3397        return $this->bcc;
     3398    }
     3399
     3400    /**
     3401     * Allows for public read access to 'ReplyTo' property.
     3402     * @access public
     3403     * @return array
     3404     */
     3405    public function getReplyToAddresses()
     3406    {
     3407        return $this->ReplyTo;
     3408    }
     3409
     3410    /**
     3411     * Allows for public read access to 'all_recipients' property.
     3412     * @access public
     3413     * @return array
     3414     */
     3415    public function getAllRecipientAddresses()
     3416    {
     3417        return $this->all_recipients;
     3418    }
     3419
     3420    /**
    32323421     * Perform a callback.
    3233      * @param bool $isSent
    3234      * @param string $to
    3235      * @param string $cc
    3236      * @param string $bcc
     3422     * @param boolean $isSent
     3423     * @param array $to
     3424     * @param array $cc
     3425     * @param array $bcc
    32373426     * @param string $subject
    32383427     * @param string $body
    32393428     * @param string $from
    32403429     */
    3241     protected function doCallback($isSent, $to, $cc, $bcc, $subject, $body, $from = null)
     3430    protected function doCallback($isSent, $to, $cc, $bcc, $subject, $body, $from)
    32423431    {
    32433432        if (!empty($this->action_function) && is_callable($this->action_function)) {
    32443433            $params = array($isSent, $to, $cc, $bcc, $subject, $body, $from);