WordPress.org

Make WordPress Core

Ticket #28909: 28909v3.diff

File 28909v3.diff, 164.8 KB (added by MattyRob, 4 years ago)
  • 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.10';
    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     * Set to 0 to not wrap. A useful value here is 78, for RFC2822 section 2.1.1 compliance.
     153     * @type integer
    159154     */
    160155    public $WordWrap = 0;
    161156
     
    175170    /**
    176171     * Whether mail() uses a fully sendmail-compatible MTA.
    177172     * One which supports sendmail's "-oi -f" options.
    178      * @type bool
     173     * @type boolean
    179174     */
    180175    public $UseSendmailOptions = true;
    181176
     
    222217     * You can also specify a different port
    223218     * for each host by using this format: [hostname:port]
    224219     * (e.g. "smtp1.example.com:25;smtp2.example.com").
     220     * You can also specify encryption type, for example:
     221     * (e.g. "tls://smtp1.example.com:587;ssl://smtp2.example.com:465").
    225222     * Hosts will be tried in order.
    226223     * @type string
    227224     */
     
    229226
    230227    /**
    231228     * The default SMTP server port.
    232      * @type int
    233      * @Todo Why is this needed when the SMTP class takes care of it?
     229     * @type integer
     230     * @TODO Why is this needed when the SMTP class takes care of it?
    234231     */
    235232    public $Port = 25;
    236233
     
    243240    public $Helo = '';
    244241
    245242    /**
    246      * The secure connection prefix.
    247      * Options: "", "ssl" or "tls"
     243     * What kind of encryption to use on the SMTP connection.
     244     * Options: '', 'ssl' or 'tls'
    248245     * @type string
    249246     */
    250247    public $SMTPSecure = '';
    251248
    252249    /**
     250     * Whether to enable TLS encryption automatically if a server supports it,
     251     * even if `SMTPSecure` is not set to 'tls'.
     252     * Be aware that in PHP >= 5.6 this requires that the server's certificates are valid.
     253     * @type boolean
     254     */
     255    public $SMTPAutoTLS = true;
     256
     257    /**
    253258     * Whether to use SMTP authentication.
    254259     * Uses the Username and Password properties.
    255      * @type bool
     260     * @type boolean
    256261     * @see PHPMailer::$Username
    257262     * @see PHPMailer::$Password
    258263     */
     
    259264    public $SMTPAuth = false;
    260265
    261266    /**
     267     * Options array passed to stream_context_create when connecting via SMTP.
     268     * @type array
     269     */
     270    public $SMTPOptions = array();
     271
     272    /**
    262273     * SMTP username.
    263274     * @type string
    264275     */
     
    293304
    294305    /**
    295306     * The SMTP server timeout in seconds.
    296      * @type int
     307     * Default of 5 minutes (300sec) is from RFC2821 section 4.5.3.2
     308     * @type integer
    297309     */
    298     public $Timeout = 10;
     310    public $Timeout = 300;
    299311
    300312    /**
    301313     * SMTP class debug output mode.
    302      * Options: 0 = off, 1 = commands, 2 = commands and data
    303      * @type int
     314     * Debug output level.
     315     * Options:
     316     * * `0` No output
     317     * * `1` Commands
     318     * * `2` Data and commands
     319     * * `3` As 2 plus connection status
     320     * * `4` Low-level data output
     321     * @type integer
    304322     * @see SMTP::$do_debug
    305323     */
    306324    public $SMTPDebug = 0;
    307325
    308326    /**
    309      * The function/method to use for debugging output.
    310      * Options: "echo" or "error_log"
    311      * @type string
     327     * How to handle debug output.
     328     * Options:
     329     * * `echo` Output plain-text as-is, appropriate for CLI
     330     * * `html` Output escaped, line breaks converted to `<br>`, appropriate for browser output
     331     * * `error_log` Output to error log as configured in php.ini
     332     *
     333     * Alternatively, you can provide a callable expecting two params: a message string and the debug level:
     334     * <code>
     335     * $mail->Debugoutput = function($str, $level) {echo "debug level $level; message: $str";};
     336     * </code>
     337     * @type string|callable
    312338     * @see SMTP::$Debugoutput
    313339     */
    314     public $Debugoutput = "echo";
     340    public $Debugoutput = 'echo';
    315341
    316342    /**
    317343     * Whether to keep SMTP connection open after each message.
    318344     * If this is set to true then to close the connection
    319345     * requires an explicit call to smtpClose().
    320      * @type bool
     346     * @type boolean
    321347     */
    322348    public $SMTPKeepAlive = false;
    323349
     
    324350    /**
    325351     * Whether to split multiple to addresses into multiple messages
    326352     * or send them all in one message.
    327      * @type bool
     353     * @type boolean
    328354     */
    329355    public $SingleTo = false;
    330356
     
    331357    /**
    332358     * Storage for addresses when SingleTo is enabled.
    333359     * @type array
    334      * @todo This should really not be public
     360     * @TODO This should really not be public
    335361     */
    336362    public $SingleToArray = array();
    337363
     
    339365     * Whether to generate VERP addresses on send.
    340366     * Only applicable when sending via SMTP.
    341367     * @link http://en.wikipedia.org/wiki/Variable_envelope_return_path
    342      * @type bool
     368     * @link http://www.postfix.org/VERP_README.html Postfix VERP info
     369     * @type boolean
    343370     */
    344371    public $do_verp = false;
    345372
    346373    /**
    347374     * Whether to allow sending messages with an empty body.
    348      * @type bool
     375     * @type boolean
    349376     */
    350377    public $AllowEmpty = false;
    351378
     
    396423     * The function that handles the result of the send email action.
    397424     * It is called out by send() for each email sent.
    398425     *
    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.
     426     * Value can be any php callable: http://www.php.net/is_callable
    404427     *
    405428     * Parameters:
    406      *   bool    $result        result of the send action
     429     *   boolean $result        result of the send action
    407430     *   string  $to            email address of the recipient
    408431     *   string  $cc            cc email addresses
    409432     *   string  $bcc           bcc email addresses
     
    410433     *   string  $subject       the subject
    411434     *   string  $body          the email body
    412435     *   string  $from          email address of sender
    413      *
    414436     * @type string
    415437     */
    416438    public $action_function = '';
    417439
    418440    /**
    419      * What to use in the X-Mailer header.
    420      * Options: null for default, whitespace for none, or a string to use
     441     * What to put in the X-Mailer header.
     442     * Options: An empty string for PHPMailer default, whitespace for none, or a string to use
    421443     * @type string
    422444     */
    423445    public $XMailer = '';
     
    459481
    460482    /**
    461483     * An array of all kinds of addresses.
    462      * Includes all of $to, $cc, $bcc, $replyto
     484     * Includes all of $to, $cc, $bcc
    463485     * @type array
    464486     * @access protected
    465487     */
     
    529551    protected $sign_key_file = '';
    530552
    531553    /**
     554     * The optional S/MIME extra certificates ("CA Chain") file path.
     555     * @type string
     556     * @access protected
     557     */
     558    protected $sign_extracerts_file = '';
     559
     560    /**
    532561     * The S/MIME password for the key.
    533562     * Used only if the key is encrypted.
    534563     * @type string
     
    538567
    539568    /**
    540569     * Whether to throw exceptions for errors.
    541      * @type bool
     570     * @type boolean
    542571     * @access protected
    543572     */
    544573    protected $exceptions = false;
    545574
    546575    /**
    547      * Error severity: message only, continue processing
     576     * Unique ID used for message ID and boundaries.
     577     * @type string
     578     * @access protected
    548579     */
     580    protected $uniqueid = '';
     581
     582    /**
     583     * Error severity: message only, continue processing.
     584     */
    549585    const STOP_MESSAGE = 0;
    550586
    551587    /**
    552      * Error severity: message, likely ok to continue processing
     588     * Error severity: message, likely ok to continue processing.
    553589     */
    554590    const STOP_CONTINUE = 1;
    555591
    556592    /**
    557      * Error severity: message, plus full stop, critical error reached
     593     * Error severity: message, plus full stop, critical error reached.
    558594     */
    559595    const STOP_CRITICAL = 2;
    560596
    561597    /**
    562      * SMTP RFC standard line ending
     598     * SMTP RFC standard line ending.
    563599     */
    564600    const CRLF = "\r\n";
    565601
    566602    /**
    567      * Constructor
    568      * @param bool $exceptions Should we throw external exceptions?
     603     * The maximum line length allowed by RFC 2822 section 2.1.1
     604     * @type integer
    569605     */
     606    const MAX_LINE_LENGTH = 998;
     607
     608    /**
     609     * Constructor.
     610     * @param boolean $exceptions Should we throw external exceptions?
     611     */
    570612    public function __construct($exceptions = false)
    571613    {
    572         $this->exceptions = ($exceptions == true);
     614        $this->exceptions = (boolean)$exceptions;
    573615    }
    574616
    575617    /**
     
    577619     */
    578620    public function __destruct()
    579621    {
    580         if ($this->Mailer == 'smtp') { //close any open SMTP connection nicely
     622        //Close any open SMTP connection nicely
     623        if ($this->Mailer == 'smtp') {
    581624            $this->smtpClose();
    582625        }
    583626    }
     
    593636     * @param string $header Additional Header(s)
    594637     * @param string $params Params
    595638     * @access private
    596      * @return bool
     639     * @return boolean
    597640     */
    598641    private function mailPassthru($to, $subject, $body, $header, $params)
    599642    {
     643        //Check overloading of mail function to avoid double-encoding
     644        if (ini_get('mbstring.func_overload') & 1) {
     645            $subject = $this->secureHeader($subject);
     646        } else {
     647            $subject = $this->encodeHeader($this->secureHeader($subject));
     648        }
    600649        if (ini_get('safe_mode') || !($this->UseSendmailOptions)) {
    601             $rt = @mail($to, $this->encodeHeader($this->secureHeader($subject)), $body, $header);
     650            $result = @mail($to, $subject, $body, $header);
    602651        } else {
    603             $rt = @mail($to, $this->encodeHeader($this->secureHeader($subject)), $body, $header, $params);
     652            $result = @mail($to, $subject, $body, $header, $params);
    604653        }
    605         return $rt;
     654        return $result;
    606655    }
    607656
    608657    /**
    609658     * Output debugging info via user-defined method.
    610      * Only if debug output is enabled.
     659     * Only generates output if SMTP debug output is enabled (@see SMTP::$do_debug).
    611660     * @see PHPMailer::$Debugoutput
    612661     * @see PHPMailer::$SMTPDebug
    613662     * @param string $str
     
    614663     */
    615664    protected function edebug($str)
    616665    {
    617         if (!$this->SMTPDebug) {
     666        if ($this->SMTPDebug <= 0) {
    618667            return;
    619668        }
     669        //Avoid clash with built-in function names
     670        if (!in_array($this->Debugoutput, array('error_log', 'html', 'echo')) and is_callable($this->Debugoutput)) {
     671            call_user_func($this->Debugoutput, $str, $this->SMTPDebug);
     672            return;
     673        }
    620674        switch ($this->Debugoutput) {
    621675            case 'error_log':
     676                //Don't output, just log
    622677                error_log($str);
    623678                break;
    624679            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";
     680                //Cleans up output a bit for a better looking, HTML-safe output
     681                echo htmlentities(
     682                    preg_replace('/[\r\n]+/', '', $str),
     683                    ENT_QUOTES,
     684                    'UTF-8'
     685                )
     686                . "<br>\n";
    627687                break;
    628688            case 'echo':
    629689            default:
    630                 //Just echoes exactly what was received
    631                 echo $str;
     690                //Normalize line breaks
     691                $str = preg_replace('/(\r\n|\r|\n)/ms', "\n", $str);
     692                echo gmdate('Y-m-d H:i:s') . "\t" . str_replace(
     693                    "\n",
     694                    "\n                   \t                  ",
     695                    trim($str)
     696                ) . "\n";
    632697        }
    633698    }
    634699
    635700    /**
    636701     * Sets message type to HTML or plain.
    637      * @param bool $ishtml True for HTML mode.
     702     * @param boolean $isHtml True for HTML mode.
    638703     * @return void
    639704     */
    640     public function isHTML($ishtml = true)
     705    public function isHTML($isHtml = true)
    641706    {
    642         if ($ishtml) {
     707        if ($isHtml) {
    643708            $this->ContentType = 'text/html';
    644709        } else {
    645710            $this->ContentType = 'text/plain';
     
    670735     */
    671736    public function isSendmail()
    672737    {
    673         if (!stristr(ini_get('sendmail_path'), 'sendmail')) {
    674             $this->Sendmail = '/var/qmail/bin/sendmail';
     738        $ini_sendmail_path = ini_get('sendmail_path');
     739
     740        if (!stristr($ini_sendmail_path, 'sendmail')) {
     741            $this->Sendmail = '/usr/sbin/sendmail';
     742        } else {
     743            $this->Sendmail = $ini_sendmail_path;
    675744        }
    676745        $this->Mailer = 'sendmail';
    677746    }
     
    682751     */
    683752    public function isQmail()
    684753    {
    685         if (stristr(ini_get('sendmail_path'), 'qmail')) {
    686             $this->Sendmail = '/var/qmail/bin/sendmail';
     754        $ini_sendmail_path = ini_get('sendmail_path');
     755
     756        if (!stristr($ini_sendmail_path, 'qmail')) {
     757            $this->Sendmail = '/var/qmail/bin/qmail-inject';
     758        } else {
     759            $this->Sendmail = $ini_sendmail_path;
    687760        }
    688         $this->Mailer = 'sendmail';
     761        $this->Mailer = 'qmail';
    689762    }
    690763
    691764    /**
     
    692765     * Add a "To" address.
    693766     * @param string $address
    694767     * @param string $name
    695      * @return bool true on success, false if address already used
     768     * @return boolean true on success, false if address already used
    696769     */
    697770    public function addAddress($address, $name = '')
    698771    {
     
    704777     * @note: This function works with the SMTP mailer on win32, not with the "mail" mailer.
    705778     * @param string $address
    706779     * @param string $name
    707      * @return bool true on success, false if address already used
     780     * @return boolean true on success, false if address already used
    708781     */
    709782    public function addCC($address, $name = '')
    710783    {
     
    716789     * @note: This function works with the SMTP mailer on win32, not with the "mail" mailer.
    717790     * @param string $address
    718791     * @param string $name
    719      * @return bool true on success, false if address already used
     792     * @return boolean true on success, false if address already used
    720793     */
    721794    public function addBCC($address, $name = '')
    722795    {
     
    727800     * Add a "Reply-to" address.
    728801     * @param string $address
    729802     * @param string $name
    730      * @return bool
     803     * @return boolean
    731804     */
    732805    public function addReplyTo($address, $name = '')
    733806    {
     
    741814     * @param string $address The email address to send to
    742815     * @param string $name
    743816     * @throws phpmailerException
    744      * @return bool true on success, false if address already used or invalid in some way
     817     * @return boolean true on success, false if address already used or invalid in some way
    745818     * @access protected
    746819     */
    747820    protected function addAnAddress($kind, $address, $name = '')
     
    748821    {
    749822        if (!preg_match('/^(to|cc|bcc|Reply-To)$/', $kind)) {
    750823            $this->setError($this->lang('Invalid recipient array') . ': ' . $kind);
     824            $this->edebug($this->lang('Invalid recipient array') . ': ' . $kind);
    751825            if ($this->exceptions) {
    752826                throw new phpmailerException('Invalid recipient array: ' . $kind);
    753827            }
    754             $this->edebug($this->lang('Invalid recipient array') . ': ' . $kind);
    755828            return false;
    756829        }
    757830        $address = trim($address);
     
    758831        $name = trim(preg_replace('/[\r\n]+/', '', $name)); //Strip breaks and trim
    759832        if (!$this->validateAddress($address)) {
    760833            $this->setError($this->lang('invalid_address') . ': ' . $address);
     834            $this->edebug($this->lang('invalid_address') . ': ' . $address);
    761835            if ($this->exceptions) {
    762836                throw new phpmailerException($this->lang('invalid_address') . ': ' . $address);
    763837            }
    764             $this->edebug($this->lang('invalid_address') . ': ' . $address);
    765838            return false;
    766839        }
    767840        if ($kind != 'Reply-To') {
     
    783856     * Set the From and FromName properties.
    784857     * @param string $address
    785858     * @param string $name
    786      * @param bool $auto Whether to also set the Sender address, defaults to true
     859     * @param boolean $auto Whether to also set the Sender address, defaults to true
    787860     * @throws phpmailerException
    788      * @return bool
     861     * @return boolean
    789862     */
    790863    public function setFrom($address, $name = '', $auto = true)
    791864    {
     
    793866        $name = trim(preg_replace('/[\r\n]+/', '', $name)); //Strip breaks and trim
    794867        if (!$this->validateAddress($address)) {
    795868            $this->setError($this->lang('invalid_address') . ': ' . $address);
     869            $this->edebug($this->lang('invalid_address') . ': ' . $address);
    796870            if ($this->exceptions) {
    797871                throw new phpmailerException($this->lang('invalid_address') . ': ' . $address);
    798872            }
    799             $this->edebug($this->lang('invalid_address') . ': ' . $address);
    800873            return false;
    801874        }
    802875        $this->From = $address;
     
    825898     * Check that a string looks like an email address.
    826899     * @param string $address The email address to check
    827900     * @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
     901     * * `auto` Pick strictest one automatically;
     902     * * `pcre8` Use the squiloople.com pattern, requires PCRE > 8.0, PHP >= 5.3.2, 5.2.14;
     903     * * `pcre` Use old PCRE implementation;
     904     * * `php` Use PHP built-in FILTER_VALIDATE_EMAIL; same as pcre8 but does not allow 'dotless' domains;
     905     * * `html5` Use the pattern given by the HTML5 spec for 'email' type form input elements.
     906     * * `noregex` Don't use a regex: super fast, really dumb.
     907     * @return boolean
    834908     * @static
    835909     * @access public
    836910     */
    837911    public static function validateAddress($address, $patternselect = 'auto')
    838912    {
    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) {
     913        if (!$patternselect or $patternselect == 'auto') {
     914            //Check this constant first so it works when extension_loaded() is disabled by safe mode
     915            //Constant was added in PHP 5.2.4
     916            if (defined('PCRE_VERSION')) {
     917                //This pattern can get stuck in a recursive loop in PCRE <= 8.0.2
     918                if (version_compare(PCRE_VERSION, '8.0.3') >= 0) {
    845919                    $patternselect = 'pcre8';
    846920                } else {
    847921                    $patternselect = 'pcre';
    848922                }
     923            } elseif (function_exists('extension_loaded') and extension_loaded('pcre')) {
     924                //Fall back to older PCRE
     925                $patternselect = 'pcre';
    849926            } else {
    850927                //Filter_var appeared in PHP 5.2.0 and does not require the PCRE extension
    851928                if (version_compare(PHP_VERSION, '5.2.0') >= 0) {
     
    858935        switch ($patternselect) {
    859936            case 'pcre8':
    860937                /**
    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 :(
     938                 * Uses the same RFC5322 regex on which FILTER_VALIDATE_EMAIL is based, but allows dotless domains.
    864939                 * @link http://squiloople.com/2009/12/20/email-address-validation/
    865940                 * @copyright 2009-2010 Michael Rushton
    866941                 * Feel free to use and redistribute this code. But please keep this copyright notice.
    867942                 */
    868                 return (bool)preg_match(
     943                return (boolean)preg_match(
    869944                    '/^(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){255,})(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){65,}@)' .
    870945                    '((?>(?>(?>((?>(?>(?>\x0D\x0A)?[\t ])+|(?>[\t ]*\x0D\x0A)?[\t ]+)?)(\((?>(?2)' .
    871946                    '(?>[\x01-\x08\x0B\x0C\x0E-\'*-\[\]-\x7F]|\\\[\x00-\x7F]|(?3)))*(?2)\)))+(?2))|(?2))?)' .
     
    877952                    '|[1-9]?[0-9])(?>\.(?9)){3}))\])(?1)$/isD',
    878953                    $address
    879954                );
    880                 break;
    881955            case 'pcre':
    882956                //An older regex that doesn't need a recent PCRE
    883                 return (bool)preg_match(
     957                return (boolean)preg_match(
    884958                    '/^(?!(?>"?(?>\\\[ -~]|[^"])"?){255,})(?!(?>"?(?>\\\[ -~]|[^"])"?){65,}@)(?>' .
    885959                    '[!#-\'*+\/-9=?^-~-]+|"(?>(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\xFF]))*")' .
    886960                    '(?>\.(?>[!#-\'*+\/-9=?^-~-]+|"(?>(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\xFF]))*"))*' .
     
    893967                    '|[1-9]?[0-9])(?>\.(?>25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}))\])$/isD',
    894968                    $address
    895969                );
    896                 break;
    897             case 'php':
    898             default:
    899                 return (bool)filter_var($address, FILTER_VALIDATE_EMAIL);
    900                 break;
     970            case 'html5':
     971                /**
     972                 * This is the pattern used in the HTML5 spec for validation of 'email' type form input elements.
     973                 * @link http://www.whatwg.org/specs/web-apps/current-work/#e-mail-state-(type=email)
     974                 */
     975                return (boolean)preg_match(
     976                    '/^[a-zA-Z0-9.!#$%&\'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}' .
     977                    '[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/sD',
     978                    $address
     979                );
    901980            case 'noregex':
    902981                //No PCRE! Do something _very_ approximate!
    903982                //Check the address is 3 chars or longer and contains an @ that's not the first or last char
     
    904983                return (strlen($address) >= 3
    905984                    and strpos($address, '@') >= 1
    906985                    and strpos($address, '@') != strlen($address) - 1);
    907                 break;
     986            case 'php':
     987            default:
     988                return (boolean)filter_var($address, FILTER_VALIDATE_EMAIL);
    908989        }
    909990    }
    910991
     
    911992    /**
    912993     * Create a message and send it.
    913994     * Uses the sending method specified by $Mailer.
    914      * Returns false on error - Use the ErrorInfo variable to view description of the error.
    915995     * @throws phpmailerException
    916      * @return bool
     996     * @return boolean false on error - See the ErrorInfo property for details of the error.
    917997     */
    918998    public function send()
    919999    {
     
    9221002                return false;
    9231003            }
    9241004            return $this->postSend();
    925         } catch (phpmailerException $e) {
     1005        } catch (phpmailerException $exc) {
    9261006            $this->mailHeader = '';
    927             $this->setError($e->getMessage());
     1007            $this->setError($exc->getMessage());
    9281008            if ($this->exceptions) {
    929                 throw $e;
     1009                throw $exc;
    9301010            }
    9311011            return false;
    9321012        }
     
    9351015    /**
    9361016     * Prepare a message for sending.
    9371017     * @throws phpmailerException
    938      * @return bool
     1018     * @return boolean
    9391019     */
    9401020    public function preSend()
    9411021    {
    9421022        try {
    943             $this->mailHeader = "";
     1023            $this->mailHeader = '';
    9441024            if ((count($this->to) + count($this->cc) + count($this->bcc)) < 1) {
    9451025                throw new phpmailerException($this->lang('provide_address'), self::STOP_CRITICAL);
    9461026            }
     
    9501030                $this->ContentType = 'multipart/alternative';
    9511031            }
    9521032
    953             $this->error_count = 0; // reset errors
     1033            $this->error_count = 0; // Reset errors
    9541034            $this->setMessageType();
    9551035            // Refuse to send an empty message unless we are specifically allowing it
    9561036            if (!$this->AllowEmpty and empty($this->Body)) {
     
    9571037                throw new phpmailerException($this->lang('empty_message'), self::STOP_CRITICAL);
    9581038            }
    9591039
     1040            // Create body before headers in case body makes changes to headers (e.g. altering transfer encoding)
     1041            $this->MIMEHeader = '';
     1042            $this->MIMEBody = $this->createBody();
     1043            // createBody may have added some headers, so retain them
     1044            $tempheaders = $this->MIMEHeader;
    9601045            $this->MIMEHeader = $this->createHeader();
    961             $this->MIMEBody = $this->createBody();
     1046            $this->MIMEHeader .= $tempheaders;
    9621047
    9631048            // To capture the complete message when using mail(), create
    9641049            // an extra header list which createHeader() doesn't fold in
    9651050            if ($this->Mailer == 'mail') {
    9661051                if (count($this->to) > 0) {
    967                     $this->mailHeader .= $this->addrAppend("To", $this->to);
     1052                    $this->mailHeader .= $this->addrAppend('To', $this->to);
    9681053                } else {
    969                     $this->mailHeader .= $this->headerLine("To", "undisclosed-recipients:;");
     1054                    $this->mailHeader .= $this->headerLine('To', 'undisclosed-recipients:;');
    9701055                }
    9711056                $this->mailHeader .= $this->headerLine(
    9721057                    'Subject',
     
    9781063            if (!empty($this->DKIM_domain)
    9791064                && !empty($this->DKIM_private)
    9801065                && !empty($this->DKIM_selector)
    981                 && !empty($this->DKIM_domain)
    9821066                && file_exists($this->DKIM_private)) {
    9831067                $header_dkim = $this->DKIM_Add(
    9841068                    $this->MIMEHeader . $this->mailHeader,
     
    9891073                    str_replace("\r\n", "\n", $header_dkim) . self::CRLF;
    9901074            }
    9911075            return true;
    992 
    993         } catch (phpmailerException $e) {
    994             $this->setError($e->getMessage());
     1076        } catch (phpmailerException $exc) {
     1077            $this->setError($exc->getMessage());
    9951078            if ($this->exceptions) {
    996                 throw $e;
     1079                throw $exc;
    9971080            }
    9981081            return false;
    9991082        }
     
    10031086     * Actually send a message.
    10041087     * Send the email via the selected mechanism
    10051088     * @throws phpmailerException
    1006      * @return bool
     1089     * @return boolean
    10071090     */
    10081091    public function postSend()
    10091092    {
     
    10111094            // Choose the mailer and send through it
    10121095            switch ($this->Mailer) {
    10131096                case 'sendmail':
     1097                case 'qmail':
    10141098                    return $this->sendmailSend($this->MIMEHeader, $this->MIMEBody);
    10151099                case 'smtp':
    10161100                    return $this->smtpSend($this->MIMEHeader, $this->MIMEBody);
     
    10171101                case 'mail':
    10181102                    return $this->mailSend($this->MIMEHeader, $this->MIMEBody);
    10191103                default:
     1104                    $sendMethod = $this->Mailer.'Send';
     1105                    if (method_exists($this, $sendMethod)) {
     1106                        return $this->$sendMethod($this->MIMEHeader, $this->MIMEBody);
     1107                    }
     1108
    10201109                    return $this->mailSend($this->MIMEHeader, $this->MIMEBody);
    10211110            }
    1022         } catch (phpmailerException $e) {
    1023             $this->setError($e->getMessage());
     1111        } catch (phpmailerException $exc) {
     1112            $this->setError($exc->getMessage());
     1113            $this->edebug($exc->getMessage());
    10241114            if ($this->exceptions) {
    1025                 throw $e;
     1115                throw $exc;
    10261116            }
    1027             $this->edebug($e->getMessage() . "\n");
    10281117        }
    10291118        return false;
    10301119    }
     
    10361125     * @see PHPMailer::$Sendmail
    10371126     * @throws phpmailerException
    10381127     * @access protected
    1039      * @return bool
     1128     * @return boolean
    10401129     */
    10411130    protected function sendmailSend($header, $body)
    10421131    {
    10431132        if ($this->Sender != '') {
    1044             $sendmail = sprintf("%s -oi -f%s -t", escapeshellcmd($this->Sendmail), escapeshellarg($this->Sender));
     1133            if ($this->Mailer == 'qmail') {
     1134                $sendmail = sprintf('%s -f%s', escapeshellcmd($this->Sendmail), escapeshellarg($this->Sender));
     1135            } else {
     1136                $sendmail = sprintf('%s -oi -f%s -t', escapeshellcmd($this->Sendmail), escapeshellarg($this->Sender));
     1137            }
    10451138        } else {
    1046             $sendmail = sprintf("%s -oi -t", escapeshellcmd($this->Sendmail));
     1139            if ($this->Mailer == 'qmail') {
     1140                $sendmail = sprintf('%s', escapeshellcmd($this->Sendmail));
     1141            } else {
     1142                $sendmail = sprintf('%s -oi -t', escapeshellcmd($this->Sendmail));
     1143            }
    10471144        }
    1048         if ($this->SingleTo === true) {
    1049             foreach ($this->SingleToArray as $val) {
     1145        if ($this->SingleTo) {
     1146            foreach ($this->SingleToArray as $toAddr) {
    10501147                if (!@$mail = popen($sendmail, 'w')) {
    10511148                    throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
    10521149                }
    1053                 fputs($mail, "To: " . $val . "\n");
     1150                fputs($mail, 'To: ' . $toAddr . "\n");
    10541151                fputs($mail, $header);
    10551152                fputs($mail, $body);
    10561153                $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);
     1154                $this->doCallback(
     1155                    ($result == 0),
     1156                    array($toAddr),
     1157                    $this->cc,
     1158                    $this->bcc,
     1159                    $this->Subject,
     1160                    $body,
     1161                    $this->From
     1162                );
    10601163                if ($result != 0) {
    10611164                    throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
    10621165                }
     
    10681171            fputs($mail, $header);
    10691172            fputs($mail, $body);
    10701173            $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);
     1174            $this->doCallback(($result == 0), $this->to, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
    10741175            if ($result != 0) {
    10751176                throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
    10761177            }
     
    10851186     * @link http://www.php.net/manual/en/book.mail.php
    10861187     * @throws phpmailerException
    10871188     * @access protected
    1088      * @return bool
     1189     * @return boolean
    10891190     */
    10901191    protected function mailSend($header, $body)
    10911192    {
    10921193        $toArr = array();
    1093         foreach ($this->to as $t) {
    1094             $toArr[] = $this->addrFormat($t);
     1194        foreach ($this->to as $toaddr) {
     1195            $toArr[] = $this->addrFormat($toaddr);
    10951196        }
    10961197        $to = implode(', ', $toArr);
    10971198
    10981199        if (empty($this->Sender)) {
    1099             $params = " ";
     1200            $params = ' ';
    11001201        } else {
    1101             $params = sprintf("-f%s", $this->Sender);
     1202            $params = sprintf('-f%s', $this->Sender);
    11021203        }
    11031204        if ($this->Sender != '' and !ini_get('safe_mode')) {
    11041205            $old_from = ini_get('sendmail_from');
    11051206            ini_set('sendmail_from', $this->Sender);
    11061207        }
    1107         $rt = false;
    1108         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);
     1208        $result = false;
     1209        if ($this->SingleTo && count($toArr) > 1) {
     1210            foreach ($toArr as $toAddr) {
     1211                $result = $this->mailPassthru($toAddr, $this->Subject, $body, $header, $params);
     1212                $this->doCallback($result, array($toAddr), $this->cc, $this->bcc, $this->Subject, $body, $this->From);
    11141213            }
    11151214        } 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);
     1215            $result = $this->mailPassthru($to, $this->Subject, $body, $header, $params);
     1216            $this->doCallback($result, $this->to, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
    11201217        }
    11211218        if (isset($old_from)) {
    11221219            ini_set('sendmail_from', $old_from);
    11231220        }
    1124         if (!$rt) {
     1221        if (!$result) {
    11251222            throw new phpmailerException($this->lang('instantiate'), self::STOP_CRITICAL);
    11261223        }
    11271224        return true;
     
    11351232    public function getSMTPInstance()
    11361233    {
    11371234        if (!is_object($this->smtp)) {
    1138             require_once 'class-smtp.php';
     1235                require_once( 'class-smtp.php' );
    11391236            $this->smtp = new SMTP;
    11401237        }
    11411238        return $this->smtp;
     
    11511248     * @throws phpmailerException
    11521249     * @uses SMTP
    11531250     * @access protected
    1154      * @return bool
     1251     * @return boolean
    11551252     */
    11561253    protected function smtpSend($header, $body)
    11571254    {
    11581255        $bad_rcpt = array();
    1159 
    1160         if (!$this->smtpConnect()) {
     1256        if (!$this->smtpConnect($this->SMTPOptions)) {
    11611257            throw new phpmailerException($this->lang('smtp_connect_failed'), self::STOP_CRITICAL);
    11621258        }
    1163         $smtp_from = ($this->Sender == '') ? $this->From : $this->Sender;
     1259        if ('' == $this->Sender) {
     1260            $smtp_from = $this->From;
     1261        } else {
     1262            $smtp_from = $this->Sender;
     1263        }
    11641264        if (!$this->smtp->mail($smtp_from)) {
    11651265            $this->setError($this->lang('from_failed') . $smtp_from . ' : ' . implode(',', $this->smtp->getError()));
    11661266            throw new phpmailerException($this->ErrorInfo, self::STOP_CRITICAL);
    11671267        }
    11681268
    1169         // Attempt to send attach all recipients
    1170         foreach ($this->to as $to) {
    1171             if (!$this->smtp->recipient($to[0])) {
    1172                 $bad_rcpt[] = $to[0];
    1173                 $isSent = 0;
    1174             } else {
    1175                 $isSent = 1;
     1269        // Attempt to send to all recipients
     1270        foreach (array($this->to, $this->cc, $this->bcc) as $togroup) {
     1271            foreach ($togroup as $to) {
     1272                if (!$this->smtp->recipient($to[0])) {
     1273                    $error = $this->smtp->getError();
     1274                    $bad_rcpt[] = array('to' => $to[0], 'error' => $error['detail']);
     1275                    $isSent = false;
     1276                } else {
     1277                    $isSent = true;
     1278                }
     1279                $this->doCallback($isSent, array($to[0]), array(), array(), $this->Subject, $body, $this->From);
    11761280            }
    1177             $this->doCallback($isSent, $to[0], '', '', $this->Subject, $body, $this->From);
    11781281        }
    1179         foreach ($this->cc as $cc) {
    1180             if (!$this->smtp->recipient($cc[0])) {
    1181                 $bad_rcpt[] = $cc[0];
    1182                 $isSent = 0;
    1183             } else {
    1184                 $isSent = 1;
    1185             }
    1186             $this->doCallback($isSent, '', $cc[0], '', $this->Subject, $body, $this->From);
    1187         }
    1188         foreach ($this->bcc as $bcc) {
    1189             if (!$this->smtp->recipient($bcc[0])) {
    1190                 $bad_rcpt[] = $bcc[0];
    1191                 $isSent = 0;
    1192             } else {
    1193                 $isSent = 1;
    1194             }
    1195             $this->doCallback($isSent, '', '', $bcc[0], $this->Subject, $body, $this->From);
    1196         }
    11971282
    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)) {
     1283        // Only send the DATA command if we have viable recipients
     1284        if ((count($this->all_recipients) > count($bad_rcpt)) and !$this->smtp->data($header . $body)) {
    12021285            throw new phpmailerException($this->lang('data_not_accepted'), self::STOP_CRITICAL);
    12031286        }
    1204         if ($this->SMTPKeepAlive == true) {
     1287        if ($this->SMTPKeepAlive) {
    12051288            $this->smtp->reset();
    12061289        } else {
    12071290            $this->smtp->quit();
    12081291            $this->smtp->close();
    12091292        }
     1293        //Create error message for any bad addresses
     1294        if (count($bad_rcpt) > 0) {
     1295            $errstr = '';
     1296            foreach ($bad_rcpt as $bad) {
     1297                $errstr .= $bad['to'] . ': ' . $bad['error'];
     1298            }
     1299            throw new phpmailerException(
     1300                $this->lang('recipients_failed') . $errstr,
     1301                self::STOP_CONTINUE
     1302            );
     1303        }
    12101304        return true;
    12111305    }
    12121306
     
    12171311     * @uses SMTP
    12181312     * @access public
    12191313     * @throws phpmailerException
    1220      * @return bool
     1314     * @return boolean
    12211315     */
    12221316    public function smtpConnect($options = array())
    12231317    {
     
    12251319            $this->smtp = $this->getSMTPInstance();
    12261320        }
    12271321
    1228         //Already connected?
     1322        // Already connected?
    12291323        if ($this->smtp->connected()) {
    12301324            return true;
    12311325        }
     
    12341328        $this->smtp->setDebugLevel($this->SMTPDebug);
    12351329        $this->smtp->setDebugOutput($this->Debugoutput);
    12361330        $this->smtp->setVerp($this->do_verp);
    1237         $tls = ($this->SMTPSecure == 'tls');
    1238         $ssl = ($this->SMTPSecure == 'ssl');
    12391331        $hosts = explode(';', $this->Host);
    12401332        $lastexception = null;
    12411333
    12421334        foreach ($hosts as $hostentry) {
    12431335            $hostinfo = array();
    1244             $host = $hostentry;
     1336            if (!preg_match('/^((ssl|tls):\/\/)*([a-zA-Z0-9\.-]*):?([0-9]*)$/', trim($hostentry), $hostinfo)) {
     1337                // Not a valid host entry
     1338                continue;
     1339            }
     1340            // $hostinfo[2]: optional ssl or tls prefix
     1341            // $hostinfo[3]: the hostname
     1342            // $hostinfo[4]: optional port number
     1343            // The host string prefix can temporarily override the current setting for SMTPSecure
     1344            // If it's not specified, the default value is used
     1345            $prefix = '';
     1346            $secure = $this->SMTPSecure;
     1347            $tls = ($this->SMTPSecure == 'tls');
     1348            if ('ssl' == $hostinfo[2] or ('' == $hostinfo[2] and 'ssl' == $this->SMTPSecure)) {
     1349                $prefix = 'ssl://';
     1350                $tls = false; // Can't have SSL and TLS at the same time
     1351                $secure = 'ssl';
     1352            } elseif ($hostinfo[2] == 'tls') {
     1353                $tls = true;
     1354                // tls doesn't use a prefix
     1355                $secure = 'tls';
     1356            }
     1357            //Do we need the OpenSSL extension?
     1358            $sslext = defined('OPENSSL_ALGO_SHA1');
     1359            if ('tls' === $secure or 'ssl' === $secure) {
     1360                //Check for an OpenSSL constant rather than using extension_loaded, which is sometimes disabled
     1361                if (!$sslext) {
     1362                    throw new phpmailerException($this->lang('extension_missing').'openssl', self::STOP_CRITICAL);
     1363                }
     1364            }
     1365            $host = $hostinfo[3];
    12451366            $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];
     1367            $tport = (integer)$hostinfo[4];
     1368            if ($tport > 0 and $tport < 65536) {
     1369                $port = $tport;
    12541370            }
    1255             if ($this->smtp->connect(($ssl ? 'ssl://' : '') . $host, $port, $this->Timeout, $options)) {
     1371            if ($this->smtp->connect($prefix . $host, $port, $this->Timeout, $options)) {
    12561372                try {
    12571373                    if ($this->Helo) {
    12581374                        $hello = $this->Helo;
     
    12601376                        $hello = $this->serverHostname();
    12611377                    }
    12621378                    $this->smtp->hello($hello);
    1263 
     1379                    //Automatically enable TLS encryption if:
     1380                    // * it's not disabled
     1381                    // * we have openssl extension
     1382                    // * we are not already using SSL
     1383                    // * the server offers STARTTLS
     1384                    if ($this->SMTPAutoTLS and $sslext and $secure != 'ssl' and $this->smtp->getServerExt('STARTTLS')) {
     1385                        $tls = true;
     1386                    }
    12641387                    if ($tls) {
    12651388                        if (!$this->smtp->startTLS()) {
    12661389                            throw new phpmailerException($this->lang('connect_host'));
    12671390                        }
    1268                         //We must resend HELO after tls negotiation
     1391                        // We must resend HELO after tls negotiation
    12691392                        $this->smtp->hello($hello);
    12701393                    }
    12711394                    if ($this->SMTPAuth) {
     
    12811404                        }
    12821405                    }
    12831406                    return true;
    1284                 } catch (phpmailerException $e) {
    1285                     $lastexception = $e;
    1286                     //We must have connected, but then failed TLS or Auth, so close connection nicely
     1407                } catch (phpmailerException $exc) {
     1408                    $lastexception = $exc;
     1409                    $this->edebug($exc->getMessage());
     1410                    // We must have connected, but then failed TLS or Auth, so close connection nicely
    12871411                    $this->smtp->quit();
    12881412                }
    12891413            }
    12901414        }
    1291         //If we get here, all connection attempts have failed, so close connection hard
     1415        // If we get here, all connection attempts have failed, so close connection hard
    12921416        $this->smtp->close();
    1293         //As we've caught all exceptions, just report whatever the last one was
     1417        // As we've caught all exceptions, just report whatever the last one was
    12941418        if ($this->exceptions and !is_null($lastexception)) {
    12951419            throw $lastexception;
    12961420        }
     
    13171441     * The default language is English.
    13181442     * @param string $langcode ISO 639-1 2-character language code (e.g. French is "fr")
    13191443     * @param string $lang_path Path to the language file directory, with trailing separator (slash)
    1320      * @return bool
     1444     * @return boolean
    13211445     * @access public
    13221446     */
    1323     public function setLanguage($langcode = 'en', $lang_path = 'language/')
     1447    public function setLanguage($langcode = 'en', $lang_path = '')
    13241448    {
    1325         //Define full set of translatable strings
     1449        // Define full set of translatable strings in English
    13261450        $PHPMAILER_LANG = array(
    13271451            'authenticate' => 'SMTP Error: Could not authenticate.',
    13281452            'connect_host' => 'SMTP Error: Could not connect to SMTP host.',
     
    13411465            'signing' => 'Signing Error: ',
    13421466            'smtp_connect_failed' => 'SMTP connect() failed.',
    13431467            'smtp_error' => 'SMTP server error: ',
    1344             'variable_set' => 'Cannot set or reset variable: '
     1468            'variable_set' => 'Cannot set or reset variable: ',
     1469            'extension_missing' => 'Extension missing: '
    13451470        );
    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';
     1471        if (empty($lang_path)) {
     1472            // Calculate an absolute path so it can work if CWD is not here
     1473            $lang_path = dirname(__FILE__). DIRECTORY_SEPARATOR . 'language'. DIRECTORY_SEPARATOR;
    13511474        }
     1475        $foundlang = true;
     1476        $lang_file = $lang_path . 'phpmailer.lang-' . $langcode . '.php';
     1477        // There is no English translation file
     1478        if ($langcode != 'en') {
     1479            // Make sure language file path is readable
     1480            if (!is_readable($lang_file)) {
     1481                $foundlang = false;
     1482            } else {
     1483                // Overwrite language-specific strings.
     1484                // This way we'll never have missing translation keys.
     1485                $foundlang = include $lang_file;
     1486            }
     1487        }
    13521488        $this->language = $PHPMAILER_LANG;
    1353         return ($l == true); //Returns false if language not found
     1489        return (boolean)$foundlang; // Returns false if language not found
    13541490    }
    13551491
    13561492    /**
     
    13751511    public function addrAppend($type, $addr)
    13761512    {
    13771513        $addresses = array();
    1378         foreach ($addr as $a) {
    1379             $addresses[] = $this->addrFormat($a);
     1514        foreach ($addr as $address) {
     1515            $addresses[] = $this->addrFormat($address);
    13801516        }
    13811517        return $type . ': ' . implode(', ', $addresses) . $this->LE;
    13821518    }
     
    13931529        if (empty($addr[1])) { // No name provided
    13941530            return $this->secureHeader($addr[0]);
    13951531        } else {
    1396             return $this->encodeHeader($this->secureHeader($addr[1]), 'phrase') . " <" . $this->secureHeader(
     1532            return $this->encodeHeader($this->secureHeader($addr[1]), 'phrase') . ' <' . $this->secureHeader(
    13971533                $addr[0]
    1398             ) . ">";
     1534            ) . '>';
    13991535        }
    14001536    }
    14011537
     
    14061542     * Original written by philippe.
    14071543     * @param string $message The message to wrap
    14081544     * @param integer $length The line length to wrap to
    1409      * @param bool $qp_mode Whether to run in Quoted-Printable mode
     1545     * @param boolean $qp_mode Whether to run in Quoted-Printable mode
    14101546     * @access public
    14111547     * @return string
    14121548     */
    14131549    public function wrapText($message, $length, $qp_mode = false)
    14141550    {
    1415         $soft_break = ($qp_mode) ? sprintf(" =%s", $this->LE) : $this->LE;
     1551        if ($qp_mode) {
     1552            $soft_break = sprintf(' =%s', $this->LE);
     1553        } else {
     1554            $soft_break = $this->LE;
     1555        }
    14161556        // If utf-8 encoding is used, we will need to make sure we don't
    14171557        // split multibyte characters when we wrap
    1418         $is_utf8 = (strtolower($this->CharSet) == "utf-8");
     1558        $is_utf8 = (strtolower($this->CharSet) == 'utf-8');
    14191559        $lelen = strlen($this->LE);
    14201560        $crlflen = strlen(self::CRLF);
    14211561
    14221562        $message = $this->fixEOL($message);
     1563        //Remove a trailing line break
    14231564        if (substr($message, -$lelen) == $this->LE) {
    14241565            $message = substr($message, 0, -$lelen);
    14251566        }
    14261567
    1427         $line = explode($this->LE, $message); // Magic. We know fixEOL uses $LE
     1568        //Split message into lines
     1569        $lines = explode($this->LE, $message);
     1570        //Message will be rebuilt in here
    14281571        $message = '';
    1429         for ($i = 0; $i < count($line); $i++) {
    1430             $line_part = explode(' ', $line[$i]);
     1572        foreach ($lines as $line) {
     1573            $words = explode(' ', $line);
    14311574            $buf = '';
    1432             for ($e = 0; $e < count($line_part); $e++) {
    1433                 $word = $line_part[$e];
     1575            $firstword = true;
     1576            foreach ($words as $word) {
    14341577                if ($qp_mode and (strlen($word) > $length)) {
    14351578                    $space_left = $length - strlen($buf) - $crlflen;
    1436                     if ($e != 0) {
     1579                    if (!$firstword) {
    14371580                        if ($space_left > 20) {
    14381581                            $len = $space_left;
    14391582                            if ($is_utf8) {
    14401583                                $len = $this->utf8CharBoundary($word, $len);
    1441                             } elseif (substr($word, $len - 1, 1) == "=") {
     1584                            } elseif (substr($word, $len - 1, 1) == '=') {
    14421585                                $len--;
    1443                             } elseif (substr($word, $len - 2, 1) == "=") {
     1586                            } elseif (substr($word, $len - 2, 1) == '=') {
    14441587                                $len -= 2;
    14451588                            }
    14461589                            $part = substr($word, 0, $len);
    14471590                            $word = substr($word, $len);
    14481591                            $buf .= ' ' . $part;
    1449                             $message .= $buf . sprintf("=%s", self::CRLF);
     1592                            $message .= $buf . sprintf('=%s', self::CRLF);
    14501593                        } else {
    14511594                            $message .= $buf . $soft_break;
    14521595                        }
     
    14591602                        $len = $length;
    14601603                        if ($is_utf8) {
    14611604                            $len = $this->utf8CharBoundary($word, $len);
    1462                         } elseif (substr($word, $len - 1, 1) == "=") {
     1605                        } elseif (substr($word, $len - 1, 1) == '=') {
    14631606                            $len--;
    1464                         } elseif (substr($word, $len - 2, 1) == "=") {
     1607                        } elseif (substr($word, $len - 2, 1) == '=') {
    14651608                            $len -= 2;
    14661609                        }
    14671610                        $part = substr($word, 0, $len);
     
    14681611                        $word = substr($word, $len);
    14691612
    14701613                        if (strlen($word) > 0) {
    1471                             $message .= $part . sprintf("=%s", self::CRLF);
     1614                            $message .= $part . sprintf('=%s', self::CRLF);
    14721615                        } else {
    14731616                            $buf = $part;
    14741617                        }
     
    14751618                    }
    14761619                } else {
    14771620                    $buf_o = $buf;
    1478                     $buf .= ($e == 0) ? $word : (' ' . $word);
     1621                    if (!$firstword) {
     1622                        $buf .= ' ';
     1623                    }
     1624                    $buf .= $word;
    14791625
    14801626                    if (strlen($buf) > $length and $buf_o != '') {
    14811627                        $message .= $buf_o . $soft_break;
     
    14821628                        $buf = $word;
    14831629                    }
    14841630                }
     1631                $firstword = false;
    14851632            }
    14861633            $message .= $buf . self::CRLF;
    14871634        }
     
    14911638
    14921639    /**
    14931640     * Find the last character boundary prior to $maxLength in a utf-8
    1494      * quoted (printable) encoded string.
     1641     * quoted-printable encoded string.
    14951642     * Original written by Colin Brown.
    14961643     * @access public
    14971644     * @param string $encodedText utf-8 QP text
    1498      * @param int $maxLength   find last character boundary prior to this length
    1499      * @return int
     1645     * @param integer $maxLength Find the last character boundary prior to this length
     1646     * @return integer
    15001647     */
    15011648    public function utf8CharBoundary($encodedText, $maxLength)
    15021649    {
     
    15041651        $lookBack = 3;
    15051652        while (!$foundSplitPos) {
    15061653            $lastChunk = substr($encodedText, $maxLength - $lookBack, $lookBack);
    1507             $encodedCharPos = strpos($lastChunk, "=");
    1508             if ($encodedCharPos !== false) {
     1654            $encodedCharPos = strpos($lastChunk, '=');
     1655            if (false !== $encodedCharPos) {
    15091656                // Found start of encoded character byte within $lookBack block.
    15101657                // Check the encoded byte value (the 2 chars after the '=')
    15111658                $hex = substr($encodedText, $maxLength - $lookBack + $encodedCharPos + 1, 2);
    15121659                $dec = hexdec($hex);
    1513                 if ($dec < 128) { // Single byte character.
     1660                if ($dec < 128) {
     1661                    // Single byte character.
    15141662                    // If the encoded char was found at pos 0, it will fit
    15151663                    // otherwise reduce maxLength to start of the encoded char
    1516                     $maxLength = ($encodedCharPos == 0) ? $maxLength :
    1517                         $maxLength - ($lookBack - $encodedCharPos);
     1664                    if ($encodedCharPos > 0) {
     1665                        $maxLength = $maxLength - ($lookBack - $encodedCharPos);
     1666                    }
    15181667                    $foundSplitPos = true;
    1519                 } elseif ($dec >= 192) { // First byte of a multi byte character
     1668                } elseif ($dec >= 192) {
     1669                    // First byte of a multi byte character
    15201670                    // Reduce maxLength to split at start of character
    15211671                    $maxLength = $maxLength - ($lookBack - $encodedCharPos);
    15221672                    $foundSplitPos = true;
    1523                 } elseif ($dec < 192) { // Middle byte of a multi byte character, look further back
     1673                } elseif ($dec < 192) {
     1674                    // Middle byte of a multi byte character, look further back
    15241675                    $lookBack += 3;
    15251676                }
    15261677            } else {
     
    15311682        return $maxLength;
    15321683    }
    15331684
    1534 
    15351685    /**
    1536      * Set the body wrapping.
     1686     * Apply word wrapping to the message body.
     1687     * Wraps the message body to the number of chars set in the WordWrap property.
     1688     * You should only do this to plain-text bodies as wrapping HTML tags may break them.
     1689     * This is called automatically by createBody(), so you don't need to call it yourself.
    15371690     * @access public
    15381691     * @return void
    15391692     */
     
    15651718    {
    15661719        $result = '';
    15671720
    1568         // Set the boundaries
    1569         $uniq_id = md5(uniqid(time()));
    1570         $this->boundary[1] = 'b1_' . $uniq_id;
    1571         $this->boundary[2] = 'b2_' . $uniq_id;
    1572         $this->boundary[3] = 'b3_' . $uniq_id;
    1573 
    15741721        if ($this->MessageDate == '') {
    1575             $result .= $this->headerLine('Date', self::rfcDate());
    1576         } else {
    1577             $result .= $this->headerLine('Date', $this->MessageDate);
     1722            $this->MessageDate = self::rfcDate();
    15781723        }
     1724        $result .= $this->headerLine('Date', $this->MessageDate);
    15791725
    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         }
    15871726
    15881727        // 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);
     1728        if ($this->SingleTo) {
     1729            if ($this->Mailer != 'mail') {
     1730                foreach ($this->to as $toaddr) {
     1731                    $this->SingleToArray[] = $this->addrFormat($toaddr);
    15931732                }
    1594             } else {
    1595                 if (count($this->to) > 0) {
     1733            }
     1734        } else {
     1735            if (count($this->to) > 0) {
     1736                if ($this->Mailer != 'mail') {
    15961737                    $result .= $this->addrAppend('To', $this->to);
    1597                 } elseif (count($this->cc) == 0) {
    1598                     $result .= $this->headerLine('To', 'undisclosed-recipients:;');
    15991738                }
     1739            } elseif (count($this->cc) == 0) {
     1740                $result .= $this->headerLine('To', 'undisclosed-recipients:;');
    16001741            }
    16011742        }
    16021743
     
    16081749        }
    16091750
    16101751        // sendmail and mail() extract Bcc from the header before sending
    1611         if ((($this->Mailer == 'sendmail') || ($this->Mailer == 'mail')) && (count($this->bcc) > 0)) {
     1752        if ((
     1753                $this->Mailer == 'sendmail' or $this->Mailer == 'qmail' or $this->Mailer == 'mail'
     1754            )
     1755            and count($this->bcc) > 0
     1756        ) {
    16121757            $result .= $this->addrAppend('Bcc', $this->bcc);
    16131758        }
    16141759
     
    16241769        if ($this->MessageID != '') {
    16251770            $this->lastMessageID = $this->MessageID;
    16261771        } else {
    1627             $this->lastMessageID = sprintf("<%s@%s>", $uniq_id, $this->ServerHostname());
     1772            $this->lastMessageID = sprintf('<%s@%s>', $this->uniqueid, $this->ServerHostname());
    16281773        }
    1629         $result .= $this->HeaderLine('Message-ID', $this->lastMessageID);
     1774        $result .= $this->headerLine('Message-ID', $this->lastMessageID);
    16301775        $result .= $this->headerLine('X-Priority', $this->Priority);
    16311776        if ($this->XMailer == '') {
    16321777            $result .= $this->headerLine(
     
    16451790        }
    16461791
    16471792        // Add custom headers
    1648         for ($index = 0; $index < count($this->CustomHeader); $index++) {
     1793        foreach ($this->CustomHeader as $header) {
    16491794            $result .= $this->headerLine(
    1650                 trim($this->CustomHeader[$index][0]),
    1651                 $this->encodeHeader(trim($this->CustomHeader[$index][1]))
     1795                trim($header[0]),
     1796                $this->encodeHeader(trim($header[1]))
    16521797            );
    16531798        }
    16541799        if (!$this->sign_key_file) {
     
    16671812    public function getMailMIME()
    16681813    {
    16691814        $result = '';
     1815        $ismultipart = true;
    16701816        switch ($this->message_type) {
    16711817            case 'inline':
    16721818                $result .= $this->headerLine('Content-Type', 'multipart/related;');
     
    16871833            default:
    16881834                // Catches case 'plain': and case '':
    16891835                $result .= $this->textLine('Content-Type: ' . $this->ContentType . '; charset=' . $this->CharSet);
     1836                $ismultipart = false;
    16901837                break;
    16911838        }
    1692         //RFC1341 part 5 says 7bit is assumed if not specified
     1839        // RFC1341 part 5 says 7bit is assumed if not specified
    16931840        if ($this->Encoding != '7bit') {
    1694             $result .= $this->headerLine('Content-Transfer-Encoding', $this->Encoding);
     1841            // RFC 2045 section 6.4 says multipart MIME parts may only use 7bit, 8bit or binary CTE
     1842            if ($ismultipart) {
     1843                if ($this->Encoding == '8bit') {
     1844                    $result .= $this->headerLine('Content-Transfer-Encoding', '8bit');
     1845                }
     1846                // The only remaining alternatives are quoted-printable and base64, which are both 7bit compatible
     1847            } else {
     1848                $result .= $this->headerLine('Content-Transfer-Encoding', $this->Encoding);
     1849            }
    16951850        }
    16961851
    16971852        if ($this->Mailer != 'mail') {
     
    17041859    /**
    17051860     * Returns the whole MIME message.
    17061861     * Includes complete headers and body.
    1707      * Only valid post PreSend().
    1708      * @see PHPMailer::PreSend()
     1862     * Only valid post preSend().
     1863     * @see PHPMailer::preSend()
    17091864     * @access public
    17101865     * @return string
    17111866     */
     
    17141869        return $this->MIMEHeader . $this->mailHeader . self::CRLF . $this->MIMEBody;
    17151870    }
    17161871
    1717 
    17181872    /**
    17191873     * Assemble the message body.
    17201874     * Returns an empty string on failure.
     
    17251879    public function createBody()
    17261880    {
    17271881        $body = '';
     1882        //Create unique IDs and preset boundaries
     1883        $this->uniqueid = md5(uniqid(time()));
     1884        $this->boundary[1] = 'b1_' . $this->uniqueid;
     1885        $this->boundary[2] = 'b2_' . $this->uniqueid;
     1886        $this->boundary[3] = 'b3_' . $this->uniqueid;
    17281887
    17291888        if ($this->sign_key_file) {
    17301889            $body .= $this->getMailMIME() . $this->LE;
     
    17321891
    17331892        $this->setWordWrap();
    17341893
     1894        $bodyEncoding = $this->Encoding;
     1895        $bodyCharSet = $this->CharSet;
     1896        //Can we do a 7-bit downgrade?
     1897        if ($bodyEncoding == '8bit' and !$this->has8bitChars($this->Body)) {
     1898            $bodyEncoding = '7bit';
     1899            $bodyCharSet = 'us-ascii';
     1900        }
     1901        //If lines are too long, change to quoted-printable transfer encoding
     1902        if (self::hasLineLongerThanMax($this->Body)) {
     1903            $this->Encoding = 'quoted-printable';
     1904            $bodyEncoding = 'quoted-printable';
     1905        }
     1906
     1907        $altBodyEncoding = $this->Encoding;
     1908        $altBodyCharSet = $this->CharSet;
     1909        //Can we do a 7-bit downgrade?
     1910        if ($altBodyEncoding == '8bit' and !$this->has8bitChars($this->AltBody)) {
     1911            $altBodyEncoding = '7bit';
     1912            $altBodyCharSet = 'us-ascii';
     1913        }
     1914        //If lines are too long, change to quoted-printable transfer encoding
     1915        if (self::hasLineLongerThanMax($this->AltBody)) {
     1916            $altBodyEncoding = 'quoted-printable';
     1917        }
     1918        //Use this as a preamble in all multipart message types
     1919        $mimepre = "This is a multi-part message in MIME format." . $this->LE . $this->LE;
    17351920        switch ($this->message_type) {
    17361921            case 'inline':
    1737                 $body .= $this->getBoundary($this->boundary[1], '', '', '');
    1738                 $body .= $this->encodeString($this->Body, $this->Encoding);
     1922                $body .= $mimepre;
     1923                $body .= $this->getBoundary($this->boundary[1], $bodyCharSet, '', $bodyEncoding);
     1924                $body .= $this->encodeString($this->Body, $bodyEncoding);
    17391925                $body .= $this->LE . $this->LE;
    17401926                $body .= $this->attachAll('inline', $this->boundary[1]);
    17411927                break;
    17421928            case 'attach':
    1743                 $body .= $this->getBoundary($this->boundary[1], '', '', '');
    1744                 $body .= $this->encodeString($this->Body, $this->Encoding);
     1929                $body .= $mimepre;
     1930                $body .= $this->getBoundary($this->boundary[1], $bodyCharSet, '', $bodyEncoding);
     1931                $body .= $this->encodeString($this->Body, $bodyEncoding);
    17451932                $body .= $this->LE . $this->LE;
    17461933                $body .= $this->attachAll('attachment', $this->boundary[1]);
    17471934                break;
    17481935            case 'inline_attach':
     1936                $body .= $mimepre;
    17491937                $body .= $this->textLine('--' . $this->boundary[1]);
    17501938                $body .= $this->headerLine('Content-Type', 'multipart/related;');
    17511939                $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
    17521940                $body .= $this->LE;
    1753                 $body .= $this->getBoundary($this->boundary[2], '', '', '');
    1754                 $body .= $this->encodeString($this->Body, $this->Encoding);
     1941                $body .= $this->getBoundary($this->boundary[2], $bodyCharSet, '', $bodyEncoding);
     1942                $body .= $this->encodeString($this->Body, $bodyEncoding);
    17551943                $body .= $this->LE . $this->LE;
    17561944                $body .= $this->attachAll('inline', $this->boundary[2]);
    17571945                $body .= $this->LE;
     
    17581946                $body .= $this->attachAll('attachment', $this->boundary[1]);
    17591947                break;
    17601948            case 'alt':
    1761                 $body .= $this->getBoundary($this->boundary[1], '', 'text/plain', '');
    1762                 $body .= $this->encodeString($this->AltBody, $this->Encoding);
     1949                $body .= $mimepre;
     1950                $body .= $this->getBoundary($this->boundary[1], $altBodyCharSet, 'text/plain', $altBodyEncoding);
     1951                $body .= $this->encodeString($this->AltBody, $altBodyEncoding);
    17631952                $body .= $this->LE . $this->LE;
    1764                 $body .= $this->getBoundary($this->boundary[1], '', 'text/html', '');
    1765                 $body .= $this->encodeString($this->Body, $this->Encoding);
     1953                $body .= $this->getBoundary($this->boundary[1], $bodyCharSet, 'text/html', $bodyEncoding);
     1954                $body .= $this->encodeString($this->Body, $bodyEncoding);
    17661955                $body .= $this->LE . $this->LE;
    17671956                if (!empty($this->Ical)) {
    17681957                    $body .= $this->getBoundary($this->boundary[1], '', 'text/calendar; method=REQUEST', '');
     
    17721961                $body .= $this->endBoundary($this->boundary[1]);
    17731962                break;
    17741963            case 'alt_inline':
    1775                 $body .= $this->getBoundary($this->boundary[1], '', 'text/plain', '');
    1776                 $body .= $this->encodeString($this->AltBody, $this->Encoding);
     1964                $body .= $mimepre;
     1965                $body .= $this->getBoundary($this->boundary[1], $altBodyCharSet, 'text/plain', $altBodyEncoding);
     1966                $body .= $this->encodeString($this->AltBody, $altBodyEncoding);
    17771967                $body .= $this->LE . $this->LE;
    17781968                $body .= $this->textLine('--' . $this->boundary[1]);
    17791969                $body .= $this->headerLine('Content-Type', 'multipart/related;');
    17801970                $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
    17811971                $body .= $this->LE;
    1782                 $body .= $this->getBoundary($this->boundary[2], '', 'text/html', '');
    1783                 $body .= $this->encodeString($this->Body, $this->Encoding);
     1972                $body .= $this->getBoundary($this->boundary[2], $bodyCharSet, 'text/html', $bodyEncoding);
     1973                $body .= $this->encodeString($this->Body, $bodyEncoding);
    17841974                $body .= $this->LE . $this->LE;
    17851975                $body .= $this->attachAll('inline', $this->boundary[2]);
    17861976                $body .= $this->LE;
     
    17871977                $body .= $this->endBoundary($this->boundary[1]);
    17881978                break;
    17891979            case 'alt_attach':
     1980                $body .= $mimepre;
    17901981                $body .= $this->textLine('--' . $this->boundary[1]);
    17911982                $body .= $this->headerLine('Content-Type', 'multipart/alternative;');
    17921983                $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
    17931984                $body .= $this->LE;
    1794                 $body .= $this->getBoundary($this->boundary[2], '', 'text/plain', '');
    1795                 $body .= $this->encodeString($this->AltBody, $this->Encoding);
     1985                $body .= $this->getBoundary($this->boundary[2], $altBodyCharSet, 'text/plain', $altBodyEncoding);
     1986                $body .= $this->encodeString($this->AltBody, $altBodyEncoding);
    17961987                $body .= $this->LE . $this->LE;
    1797                 $body .= $this->getBoundary($this->boundary[2], '', 'text/html', '');
    1798                 $body .= $this->encodeString($this->Body, $this->Encoding);
     1988                $body .= $this->getBoundary($this->boundary[2], $bodyCharSet, 'text/html', $bodyEncoding);
     1989                $body .= $this->encodeString($this->Body, $bodyEncoding);
    17991990                $body .= $this->LE . $this->LE;
    18001991                $body .= $this->endBoundary($this->boundary[2]);
    18011992                $body .= $this->LE;
     
    18021993                $body .= $this->attachAll('attachment', $this->boundary[1]);
    18031994                break;
    18041995            case 'alt_inline_attach':
     1996                $body .= $mimepre;
    18051997                $body .= $this->textLine('--' . $this->boundary[1]);
    18061998                $body .= $this->headerLine('Content-Type', 'multipart/alternative;');
    18071999                $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
    18082000                $body .= $this->LE;
    1809                 $body .= $this->getBoundary($this->boundary[2], '', 'text/plain', '');
    1810                 $body .= $this->encodeString($this->AltBody, $this->Encoding);
     2001                $body .= $this->getBoundary($this->boundary[2], $altBodyCharSet, 'text/plain', $altBodyEncoding);
     2002                $body .= $this->encodeString($this->AltBody, $altBodyEncoding);
    18112003                $body .= $this->LE . $this->LE;
    18122004                $body .= $this->textLine('--' . $this->boundary[2]);
    18132005                $body .= $this->headerLine('Content-Type', 'multipart/related;');
    18142006                $body .= $this->textLine("\tboundary=\"" . $this->boundary[3] . '"');
    18152007                $body .= $this->LE;
    1816                 $body .= $this->getBoundary($this->boundary[3], '', 'text/html', '');
    1817                 $body .= $this->encodeString($this->Body, $this->Encoding);
     2008                $body .= $this->getBoundary($this->boundary[3], $bodyCharSet, 'text/html', $bodyEncoding);
     2009                $body .= $this->encodeString($this->Body, $bodyEncoding);
    18182010                $body .= $this->LE . $this->LE;
    18192011                $body .= $this->attachAll('inline', $this->boundary[3]);
    18202012                $body .= $this->LE;
     
    18242016                break;
    18252017            default:
    18262018                // catch case 'plain' and case ''
    1827                 $body .= $this->encodeString($this->Body, $this->Encoding);
     2019                $body .= $this->encodeString($this->Body, $bodyEncoding);
    18282020                break;
    18292021        }
    18302022
     
    18332025        } elseif ($this->sign_key_file) {
    18342026            try {
    18352027                if (!defined('PKCS7_TEXT')) {
    1836                     throw new phpmailerException($this->lang('signing') . ' OpenSSL extension missing.');
     2028                    throw new phpmailerException($this->lang('extension_missing') . 'openssl');
    18372029                }
     2030                // @TODO would be nice to use php://temp streams here, but need to wrap for PHP < 5.1
    18382031                $file = tempnam(sys_get_temp_dir(), 'mail');
    1839                 file_put_contents($file, $body); //TODO check this worked
     2032                if (false === file_put_contents($file, $body)) {
     2033                    throw new phpmailerException($this->lang('signing') . ' Could not write temp file');
     2034                }
    18402035                $signed = tempnam(sys_get_temp_dir(), 'signed');
    1841                 if (@openssl_pkcs7_sign(
    1842                     $file,
    1843                     $signed,
    1844                     'file://' . realpath($this->sign_cert_file),
    1845                     array('file://' . realpath($this->sign_key_file), $this->sign_key_pass),
    1846                     null
    1847                 )
    1848                 ) {
     2036                //Workaround for PHP bug https://bugs.php.net/bug.php?id=69197
     2037                if (empty($this->sign_extracerts_file)) {
     2038                    $sign = @openssl_pkcs7_sign(
     2039                        $file,
     2040                        $signed,
     2041                        'file://' . realpath($this->sign_cert_file),
     2042                        array('file://' . realpath($this->sign_key_file), $this->sign_key_pass),
     2043                        null
     2044                    );
     2045                } else {
     2046                    $sign = @openssl_pkcs7_sign(
     2047                        $file,
     2048                        $signed,
     2049                        'file://' . realpath($this->sign_cert_file),
     2050                        array('file://' . realpath($this->sign_key_file), $this->sign_key_pass),
     2051                        null,
     2052                        PKCS7_DETACHED,
     2053                        $this->sign_extracerts_file
     2054                    );
     2055                }
     2056                if ($sign) {
    18492057                    @unlink($file);
    18502058                    $body = file_get_contents($signed);
    18512059                    @unlink($signed);
     2060                    //The message returned by openssl contains both headers and body, so need to split them up
     2061                    $parts = explode("\n\n", $body, 2);
     2062                    $this->MIMEHeader .= $parts[0] . $this->LE . $this->LE;
     2063                    $body = $parts[1];
    18522064                } else {
    18532065                    @unlink($file);
    18542066                    @unlink($signed);
    18552067                    throw new phpmailerException($this->lang('signing') . openssl_error_string());
    18562068                }
    1857             } catch (phpmailerException $e) {
     2069            } catch (phpmailerException $exc) {
    18582070                $body = '';
    18592071                if ($this->exceptions) {
    1860                     throw $e;
     2072                    throw $exc;
    18612073                }
    18622074            }
    18632075        }
     
    18862098            $encoding = $this->Encoding;
    18872099        }
    18882100        $result .= $this->textLine('--' . $boundary);
    1889         $result .= sprintf("Content-Type: %s; charset=%s", $contentType, $charSet);
     2101        $result .= sprintf('Content-Type: %s; charset=%s', $contentType, $charSet);
    18902102        $result .= $this->LE;
    1891         $result .= $this->headerLine('Content-Transfer-Encoding', $encoding);
     2103        // RFC1341 part 5 says 7bit is assumed if not specified
     2104        if ($encoding != '7bit') {
     2105            $result .= $this->headerLine('Content-Transfer-Encoding', $encoding);
     2106        }
    18922107        $result .= $this->LE;
    18932108
    18942109        return $result;
     
    19142129     */
    19152130    protected function setMessageType()
    19162131    {
    1917         $this->message_type = array();
     2132        $type = array();
    19182133        if ($this->alternativeExists()) {
    1919             $this->message_type[] = "alt";
     2134            $type[] = 'alt';
    19202135        }
    19212136        if ($this->inlineImageExists()) {
    1922             $this->message_type[] = "inline";
     2137            $type[] = 'inline';
    19232138        }
    19242139        if ($this->attachmentExists()) {
    1925             $this->message_type[] = "attach";
     2140            $type[] = 'attach';
    19262141        }
    1927         $this->message_type = implode("_", $this->message_type);
    1928         if ($this->message_type == "") {
    1929             $this->message_type = "plain";
     2142        $this->message_type = implode('_', $type);
     2143        if ($this->message_type == '') {
     2144            $this->message_type = 'plain';
    19302145        }
    19312146    }
    19322147
     
    19622177     * @param string $type File extension (MIME) type.
    19632178     * @param string $disposition Disposition to use
    19642179     * @throws phpmailerException
    1965      * @return bool
     2180     * @return boolean
    19662181     */
    19672182    public function addAttachment($path, $name = '', $encoding = 'base64', $type = '', $disposition = 'attachment')
    19682183    {
     
    19712186                throw new phpmailerException($this->lang('file_access') . $path, self::STOP_CONTINUE);
    19722187            }
    19732188
    1974             //If a MIME type is not specified, try to work it out from the file name
     2189            // If a MIME type is not specified, try to work it out from the file name
    19752190            if ($type == '') {
    19762191                $type = self::filenameToType($path);
    19772192            }
     
    19922207                7 => 0
    19932208            );
    19942209
    1995         } catch (phpmailerException $e) {
    1996             $this->setError($e->getMessage());
     2210        } catch (phpmailerException $exc) {
     2211            $this->setError($exc->getMessage());
     2212            $this->edebug($exc->getMessage());
    19972213            if ($this->exceptions) {
    1998                 throw $e;
     2214                throw $exc;
    19992215            }
    2000             $this->edebug($e->getMessage() . "\n");
    20012216            return false;
    20022217        }
    20032218        return true;
     
    20562271                }
    20572272                $cidUniq[$cid] = true;
    20582273
    2059                 $mime[] = sprintf("--%s%s", $boundary, $this->LE);
     2274                $mime[] = sprintf('--%s%s', $boundary, $this->LE);
    20602275                $mime[] = sprintf(
    2061                     "Content-Type: %s; name=\"%s\"%s",
     2276                    'Content-Type: %s; name="%s"%s',
    20622277                    $type,
    20632278                    $this->encodeHeader($this->secureHeader($name)),
    20642279                    $this->LE
    20652280                );
    2066                 $mime[] = sprintf("Content-Transfer-Encoding: %s%s", $encoding, $this->LE);
     2281                // RFC1341 part 5 says 7bit is assumed if not specified
     2282                if ($encoding != '7bit') {
     2283                    $mime[] = sprintf('Content-Transfer-Encoding: %s%s', $encoding, $this->LE);
     2284                }
    20672285
    20682286                if ($disposition == 'inline') {
    2069                     $mime[] = sprintf("Content-ID: <%s>%s", $cid, $this->LE);
     2287                    $mime[] = sprintf('Content-ID: <%s>%s', $cid, $this->LE);
    20702288                }
    20712289
    20722290                // If a filename contains any of these chars, it should be quoted,
     
    20742292                // Fixes a warning in IETF's msglint MIME checker
    20752293                // Allow for bypassing the Content-Disposition header totally
    20762294                if (!(empty($disposition))) {
    2077                     if (preg_match('/[ \(\)<>@,;:\\"\/\[\]\?=]/', $name)) {
     2295                    $encoded_name = $this->encodeHeader($this->secureHeader($name));
     2296                    if (preg_match('/[ \(\)<>@,;:\\"\/\[\]\?=]/', $encoded_name)) {
    20782297                        $mime[] = sprintf(
    2079                             "Content-Disposition: %s; filename=\"%s\"%s",
     2298                            'Content-Disposition: %s; filename="%s"%s',
    20802299                            $disposition,
    2081                             $this->encodeHeader($this->secureHeader($name)),
     2300                            $encoded_name,
    20822301                            $this->LE . $this->LE
    20832302                        );
    20842303                    } else {
    20852304                        $mime[] = sprintf(
    2086                             "Content-Disposition: %s; filename=%s%s",
     2305                            'Content-Disposition: %s; filename=%s%s',
    20872306                            $disposition,
    2088                             $this->encodeHeader($this->secureHeader($name)),
     2307                            $encoded_name,
    20892308                            $this->LE . $this->LE
    20902309                        );
    20912310                    }
     
    21102329            }
    21112330        }
    21122331
    2113         $mime[] = sprintf("--%s--%s", $boundary, $this->LE);
     2332        $mime[] = sprintf('--%s--%s', $boundary, $this->LE);
    21142333
    2115         return implode("", $mime);
     2334        return implode('', $mime);
    21162335    }
    21172336
    21182337    /**
     
    21342353            $magic_quotes = get_magic_quotes_runtime();
    21352354            if ($magic_quotes) {
    21362355                if (version_compare(PHP_VERSION, '5.3.0', '<')) {
    2137                     set_magic_quotes_runtime(0);
     2356                    set_magic_quotes_runtime(false);
    21382357                } else {
    2139                     ini_set('magic_quotes_runtime', 0);
     2358                    //Doesn't exist in PHP 5.4, but we don't need to check because
     2359                    //get_magic_quotes_runtime always returns false in 5.4+
     2360                    //so it will never get here
     2361                    ini_set('magic_quotes_runtime', false);
    21402362                }
    21412363            }
    21422364            $file_buffer = file_get_contents($path);
     
    21492371                }
    21502372            }
    21512373            return $file_buffer;
    2152         } catch (Exception $e) {
    2153             $this->setError($e->getMessage());
     2374        } catch (Exception $exc) {
     2375            $this->setError($exc->getMessage());
    21542376            return '';
    21552377        }
    21562378    }
     
    21732395            case '7bit':
    21742396            case '8bit':
    21752397                $encoded = $this->fixEOL($str);
    2176                 //Make sure it ends with a line break
     2398                // Make sure it ends with a line break
    21772399                if (substr($encoded, -(strlen($this->LE))) != $this->LE) {
    21782400                    $encoded .= $this->LE;
    21792401                }
     
    22012423     */
    22022424    public function encodeHeader($str, $position = 'text')
    22032425    {
    2204         $x = 0;
     2426        $matchcount = 0;
    22052427        switch (strtolower($position)) {
    22062428            case 'phrase':
    22072429                if (!preg_match('/[\200-\377]/', $str)) {
    2208                     // Can't use addslashes as we don't know what value has magic_quotes_sybase
     2430                    // Can't use addslashes as we don't know the value of magic_quotes_sybase
    22092431                    $encoded = addcslashes($str, "\0..\37\177\\\"");
    22102432                    if (($str == $encoded) && !preg_match('/[^A-Za-z0-9!#$%&\'*+\/=?^_`{|}~ -]/', $str)) {
    22112433                        return ($encoded);
     
    22132435                        return ("\"$encoded\"");
    22142436                    }
    22152437                }
    2216                 $x = preg_match_all('/[^\040\041\043-\133\135-\176]/', $str, $matches);
     2438                $matchcount = preg_match_all('/[^\040\041\043-\133\135-\176]/', $str, $matches);
    22172439                break;
    22182440            /** @noinspection PhpMissingBreakStatementInspection */
    22192441            case 'comment':
    2220                 $x = preg_match_all('/[()"]/', $str, $matches);
     2442                $matchcount = preg_match_all('/[()"]/', $str, $matches);
    22212443                // Intentional fall-through
    22222444            case 'text':
    22232445            default:
    2224                 $x += preg_match_all('/[\000-\010\013\014\016-\037\177-\377]/', $str, $matches);
     2446                $matchcount += preg_match_all('/[\000-\010\013\014\016-\037\177-\377]/', $str, $matches);
    22252447                break;
    22262448        }
    22272449
    2228         if ($x == 0) { //There are no chars that need encoding
     2450        //There are no chars that need encoding
     2451        if ($matchcount == 0) {
    22292452            return ($str);
    22302453        }
    22312454
    22322455        $maxlen = 75 - 7 - strlen($this->CharSet);
    22332456        // 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
     2457        if ($matchcount > strlen($str) / 3) {
     2458            // More than a third of the content will need encoding, so B encoding will be most efficient
    22362459            $encoding = 'B';
    22372460            if (function_exists('mb_strlen') && $this->hasMultiBytes($str)) {
    22382461                // Use a custom function which correctly encodes and wraps long
     
    22502473            $encoded = str_replace('=' . self::CRLF, "\n", trim($encoded));
    22512474        }
    22522475
    2253         $encoded = preg_replace('/^(.*)$/m', " =?" . $this->CharSet . "?$encoding?\\1?=", $encoded);
     2476        $encoded = preg_replace('/^(.*)$/m', ' =?' . $this->CharSet . "?$encoding?\\1?=", $encoded);
    22542477        $encoded = trim(str_replace("\n", $this->LE, $encoded));
    22552478
    22562479        return $encoded;
     
    22602483     * Check if a string contains multi-byte characters.
    22612484     * @access public
    22622485     * @param string $str multi-byte text to wrap encode
    2263      * @return bool
     2486     * @return boolean
    22642487     */
    22652488    public function hasMultiBytes($str)
    22662489    {
     
    22722495    }
    22732496
    22742497    /**
     2498     * Does a string contain any 8-bit chars (in any charset)?
     2499     * @param string $text
     2500     * @return boolean
     2501     */
     2502    public function has8bitChars($text)
     2503    {
     2504        return (boolean)preg_match('/[\x80-\xFF]/', $text);
     2505    }
     2506
     2507    /**
    22752508     * Encode and wrap long multibyte strings for mail headers
    22762509     * 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
     2510     * Adapted from a function by paravoid
     2511     * @link http://www.php.net/manual/en/function.mb-encode-mimeheader.php#60283
    22782512     * @access public
    22792513     * @param string $str multi-byte text to wrap encode
    2280      * @param string $lf string to use as linefeed/end-of-line
     2514     * @param string $linebreak string to use as linefeed/end-of-line
    22812515     * @return string
    22822516     */
    2283     public function base64EncodeWrapMB($str, $lf = null)
     2517    public function base64EncodeWrapMB($str, $linebreak = null)
    22842518    {
    2285         $start = "=?" . $this->CharSet . "?B?";
    2286         $end = "?=";
    2287         $encoded = "";
    2288         if ($lf === null) {
    2289             $lf = $this->LE;
     2519        $start = '=?' . $this->CharSet . '?B?';
     2520        $end = '?=';
     2521        $encoded = '';
     2522        if ($linebreak === null) {
     2523            $linebreak = $this->LE;
    22902524        }
    22912525
    22922526        $mb_length = mb_strlen($str, $this->CharSet);
     
    23052539                $chunk = base64_encode($chunk);
    23062540                $lookBack++;
    23072541            } while (strlen($chunk) > $length);
    2308             $encoded .= $chunk . $lf;
     2542            $encoded .= $chunk . $linebreak;
    23092543        }
    23102544
    23112545        // Chomp the last linefeed
    2312         $encoded = substr($encoded, 0, -strlen($lf));
     2546        $encoded = substr($encoded, 0, -strlen($linebreak));
    23132547        return $encoded;
    23142548    }
    23152549
     
    23202554     * @param string $string The text to encode
    23212555     * @param integer $line_max Number of chars allowed on a line before wrapping
    23222556     * @return string
    2323      * @link PHP version adapted from http://www.php.net/manual/en/function.quoted-printable-decode.php#89417
     2557     * @link http://www.php.net/manual/en/function.quoted-printable-decode.php#89417 Adapted from this comment
    23242558     */
    23252559    public function encodeQP($string, $line_max = 76)
    23262560    {
    2327         if (function_exists('quoted_printable_encode')) { //Use native function if it's available (>= PHP5.3)
    2328             return quoted_printable_encode($string);
     2561        // Use native function if it's available (>= PHP5.3)
     2562        if (function_exists('quoted_printable_encode')) {
     2563            return $this->fixEOL(quoted_printable_encode($string));
    23292564        }
    2330         //Fall back to a pure PHP implementation
     2565        // Fall back to a pure PHP implementation
    23312566        $string = str_replace(
    23322567            array('%20', '%0D%0A.', '%0D%0A', '%'),
    23332568            array(' ', "\r\n=2E", "\r\n", '='),
     
    23342569            rawurlencode($string)
    23352570        );
    23362571        $string = preg_replace('/[^\r\n]{' . ($line_max - 3) . '}[^=\r\n]{2}/', "$0=\r\n", $string);
    2337         return $string;
     2572        return $this->fixEOL($string);
    23382573    }
    23392574
    23402575    /**
     
    23432578     * @access public
    23442579     * @param string $string
    23452580     * @param integer $line_max
    2346      * @param bool $space_conv
     2581     * @param boolean $space_conv
    23472582     * @return string
    23482583     * @deprecated Use encodeQP instead.
    23492584     */
     
    23652600     */
    23662601    public function encodeQ($str, $position = 'text')
    23672602    {
    2368         //There should not be any EOL in the string
     2603        // There should not be any EOL in the string
    23692604        $pattern = '';
    23702605        $encoded = str_replace(array("\r", "\n"), '', $str);
    23712606        switch (strtolower($position)) {
    23722607            case 'phrase':
    2373                 //RFC 2047 section 5.3
     2608                // RFC 2047 section 5.3
    23742609                $pattern = '^A-Za-z0-9!*+\/ -';
    23752610                break;
    23762611            /** @noinspection PhpMissingBreakStatementInspection */
    23772612            case 'comment':
    2378                 //RFC 2047 section 5.2
     2613                // RFC 2047 section 5.2
    23792614                $pattern = '\(\)"';
    2380                 //intentional fall-through
    2381                 //for this reason we build the $pattern without including delimiters and []
     2615                // intentional fall-through
     2616                // for this reason we build the $pattern without including delimiters and []
    23822617            case 'text':
    23832618            default:
    2384                 //RFC 2047 section 5.1
    2385                 //Replace every high ascii, control, =, ? and _ characters
     2619                // RFC 2047 section 5.1
     2620                // Replace every high ascii, control, =, ? and _ characters
    23862621                $pattern = '\000-\011\013\014\016-\037\075\077\137\177-\377' . $pattern;
    23872622                break;
    23882623        }
    23892624        $matches = array();
    23902625        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]);
     2626            // If the string contains an '=', make sure it's the first thing we replace
     2627            // so as to avoid double-encoding
     2628            $eqkey = array_search('=', $matches[0]);
     2629            if (false !== $eqkey) {
     2630                unset($matches[0][$eqkey]);
    23962631                array_unshift($matches[0], '=');
    23972632            }
    23982633            foreach (array_unique($matches[0]) as $char) {
     
    23992634                $encoded = str_replace($char, '=' . sprintf('%02X', ord($char)), $encoded);
    24002635            }
    24012636        }
    2402         //Replace every spaces to _ (more readable than =20)
     2637        // Replace every spaces to _ (more readable than =20)
    24032638        return str_replace(' ', '_', $encoded);
    24042639    }
    24052640
     
    24222657        $type = '',
    24232658        $disposition = 'attachment'
    24242659    ) {
    2425         //If a MIME type is not specified, try to work it out from the file name
     2660        // If a MIME type is not specified, try to work it out from the file name
    24262661        if ($type == '') {
    24272662            $type = self::filenameToType($filename);
    24282663        }
     
    24422677    /**
    24432678     * Add an embedded (inline) attachment from a file.
    24442679     * This can include images, sounds, and just about any other document type.
    2445      * These differ from 'regular' attachmants in that they are intended to be
     2680     * These differ from 'regular' attachments in that they are intended to be
    24462681     * displayed inline with the message, not just attached for download.
    24472682     * This is used in HTML messages that embed the images
    24482683     * the HTML refers to using the $cid value.
     
    24532688     * @param string $encoding File encoding (see $Encoding).
    24542689     * @param string $type File MIME type.
    24552690     * @param string $disposition Disposition to use
    2456      * @return bool True on successfully adding an attachment
     2691     * @return boolean True on successfully adding an attachment
    24572692     */
    24582693    public function addEmbeddedImage($path, $cid, $name = '', $encoding = 'base64', $type = '', $disposition = 'inline')
    24592694    {
     
    24622697            return false;
    24632698        }
    24642699
    2465         //If a MIME type is not specified, try to work it out from the file name
     2700        // If a MIME type is not specified, try to work it out from the file name
    24662701        if ($type == '') {
    24672702            $type = self::filenameToType($path);
    24682703        }
     
    24982733     * @param string $encoding File encoding (see $Encoding).
    24992734     * @param string $type MIME type.
    25002735     * @param string $disposition Disposition to use
    2501      * @return bool True on successfully adding an attachment
     2736     * @return boolean True on successfully adding an attachment
    25022737     */
    25032738    public function addStringEmbeddedImage(
    25042739        $string,
     
    25082743        $type = '',
    25092744        $disposition = 'inline'
    25102745    ) {
    2511         //If a MIME type is not specified, try to work it out from the name
     2746        // If a MIME type is not specified, try to work it out from the name
    25122747        if ($type == '') {
    25132748            $type = self::filenameToType($name);
    25142749        }
     
    25302765    /**
    25312766     * Check if an inline attachment is present.
    25322767     * @access public
    2533      * @return bool
     2768     * @return boolean
    25342769     */
    25352770    public function inlineImageExists()
    25362771    {
     
    25442779
    25452780    /**
    25462781     * Check if an attachment (non-inline) is present.
    2547      * @return bool
     2782     * @return boolean
    25482783     */
    25492784    public function attachmentExists()
    25502785    {
     
    25582793
    25592794    /**
    25602795     * Check if this message has an alternative body set.
    2561      * @return bool
     2796     * @return boolean
    25622797     */
    25632798    public function alternativeExists()
    25642799    {
     
    26512886        $this->error_count++;
    26522887        if ($this->Mailer == 'smtp' and !is_null($this->smtp)) {
    26532888            $lasterror = $this->smtp->getError();
    2654             if (!empty($lasterror) and array_key_exists('smtp_msg', $lasterror)) {
    2655                 $msg .= '<p>' . $this->lang('smtp_error') . $lasterror['smtp_msg'] . "</p>\n";
     2889            if (!empty($lasterror['error'])) {
     2890                $msg .= $this->lang('smtp_error') . $lasterror['error'];
     2891                if (!empty($lasterror['detail'])) {
     2892                    $msg .= ' Detail: '. $lasterror['detail'];
     2893                }
     2894                if (!empty($lasterror['smtp_code'])) {
     2895                    $msg .= ' SMTP code: ' . $lasterror['smtp_code'];
     2896                }
     2897                if (!empty($lasterror['smtp_code_ex'])) {
     2898                    $msg .= ' Additional SMTP info: ' . $lasterror['smtp_code_ex'];
     2899                }
    26562900            }
    26572901        }
    26582902        $this->ErrorInfo = $msg;
     
    26662910     */
    26672911    public static function rfcDate()
    26682912    {
    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
     2913        // Set the time zone to whatever the default is to avoid 500 errors
     2914        // Will default to UTC if it's not set properly in php.ini
    26712915        date_default_timezone_set(@date_default_timezone_get());
    26722916        return date('D, j M Y H:i:s O');
    26732917    }
     
    26802924     */
    26812925    protected function serverHostname()
    26822926    {
     2927        $result = 'localhost.localdomain';
    26832928        if (!empty($this->Hostname)) {
    26842929            $result = $this->Hostname;
    2685         } elseif (isset($_SERVER['SERVER_NAME'])) {
     2930        } elseif (isset($_SERVER) and array_key_exists('SERVER_NAME', $_SERVER) and !empty($_SERVER['SERVER_NAME'])) {
    26862931            $result = $_SERVER['SERVER_NAME'];
    2687         } else {
    2688             $result = 'localhost.localdomain';
     2932        } elseif (function_exists('gethostname') && gethostname() !== false) {
     2933            $result = gethostname();
     2934        } elseif (php_uname('n') !== false) {
     2935            $result = php_uname('n');
    26892936        }
    2690 
    26912937        return $result;
    26922938    }
    26932939
     
    27032949            $this->setLanguage('en'); // set the default language
    27042950        }
    27052951
    2706         if (isset($this->language[$key])) {
     2952        if (array_key_exists($key, $this->language)) {
     2953            if ($key == 'smtp_connect_failed') {
     2954                //Include a link to troubleshooting docs on SMTP connection failure
     2955                //this is by far the biggest cause of support questions
     2956                //but it's usually not PHPMailer's fault.
     2957                return $this->language[$key] . ' https://github.com/PHPMailer/PHPMailer/wiki/Troubleshooting';
     2958            }
    27072959            return $this->language[$key];
    27082960        } else {
    2709             return 'Language string failed to load: ' . $key;
     2961            //Return the key as a fallback
     2962            return $key;
    27102963        }
    27112964    }
    27122965
     
    27132966    /**
    27142967     * Check if an error occurred.
    27152968     * @access public
    2716      * @return bool True if an error did occur.
     2969     * @return boolean True if an error did occur.
    27172970     */
    27182971    public function isError()
    27192972    {
     
    27583011    }
    27593012
    27603013    /**
     3014     * Returns all custom headers
     3015     *
     3016     * @return array
     3017     */
     3018    public function getCustomHeaders()
     3019    {
     3020        return $this->CustomHeader;
     3021    }
     3022
     3023    /**
    27613024     * Create a message from an HTML string.
    27623025     * Automatically makes modifications for inline images and backgrounds
    27633026     * and creates a plain-text version by converting the HTML.
     
    27653028     * @access public
    27663029     * @param string $message HTML message string
    27673030     * @param string $basedir baseline directory for path
    2768      * @param bool $advanced Whether to use the advanced HTML to text converter
     3031     * @param boolean|callable $advanced Whether to use the internal HTML to text converter
     3032     *    or your own custom converter @see html2text()
    27693033     * @return string $message
    27703034     */
    27713035    public function msgHTML($message, $basedir = '', $advanced = false)
    27723036    {
    2773         preg_match_all("/(src|background)=[\"'](.*)[\"']/Ui", $message, $images);
     3037        preg_match_all('/(src|background)=["\'](.*)["\']/Ui', $message, $images);
    27743038        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)) {
     3039            foreach ($images[2] as $imgindex => $url) {
     3040                // Convert data URIs into embedded images
     3041                if (preg_match('#^data:(image[^;,]*)(;base64)?,#', $url, $match)) {
     3042                    $data = substr($url, strpos($url, ','));
     3043                    if ($match[2]) {
     3044                        $data = base64_decode($data);
     3045                    } else {
     3046                        $data = rawurldecode($data);
     3047                    }
     3048                    $cid = md5($url) . '@phpmailer.0'; // RFC2392 S 2
     3049                    if ($this->addStringEmbeddedImage($data, $cid, '', 'base64', $match[1])) {
     3050                        $message = str_replace(
     3051                            $images[0][$imgindex],
     3052                            $images[1][$imgindex] . '="cid:' . $cid . '"',
     3053                            $message
     3054                        );
     3055                    }
     3056                } elseif (!preg_match('#^[A-z]+://#', $url)) {
     3057                    // Do not change urls for absolute images (thanks to corvuscorax)
    27783058                    $filename = basename($url);
    27793059                    $directory = dirname($url);
    27803060                    if ($directory == '.') {
    27813061                        $directory = '';
    27823062                    }
    2783                     $cid = md5($url) . '@phpmailer.0'; //RFC2392 S 2
     3063                    $cid = md5($url) . '@phpmailer.0'; // RFC2392 S 2
    27843064                    if (strlen($basedir) > 1 && substr($basedir, -1) != '/') {
    27853065                        $basedir .= '/';
    27863066                    }
     
    27923072                        $cid,
    27933073                        $filename,
    27943074                        'base64',
    2795                         self::_mime_types(self::mb_pathinfo($filename, PATHINFO_EXTENSION))
     3075                        self::_mime_types((string)self::mb_pathinfo($filename, PATHINFO_EXTENSION))
    27963076                    )
    27973077                    ) {
    27983078                        $message = preg_replace(
    2799                             "/" . $images[1][$i] . "=[\"']" . preg_quote($url, '/') . "[\"']/Ui",
    2800                             $images[1][$i] . "=\"cid:" . $cid . "\"",
     3079                            '/' . $images[1][$imgindex] . '=["\']' . preg_quote($url, '/') . '["\']/Ui',
     3080                            $images[1][$imgindex] . '="cid:' . $cid . '"',
    28013081                            $message
    28023082                        );
    28033083                    }
     
    28053085            }
    28063086        }
    28073087        $this->isHTML(true);
     3088        // Convert all message body line breaks to CRLF, makes quoted-printable encoding work much better
     3089        $this->Body = $this->normalizeBreaks($message);
     3090        $this->AltBody = $this->normalizeBreaks($this->html2text($message, $advanced));
    28083091        if (empty($this->AltBody)) {
    2809             $this->AltBody = 'To view this email message, open it in a program that understands HTML!' . "\n\n";
     3092            $this->AltBody = 'To view this email message, open it in a program that understands HTML!' .
     3093                self::CRLF . self::CRLF;
    28103094        }
    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));
    28143095        return $this->Body;
    28153096    }
    28163097
    28173098    /**
    28183099     * Convert an HTML string into plain text.
     3100     * This is used by msgHTML().
     3101     * Note - older versions of this function used a bundled advanced converter
     3102     * which was been removed for license reasons in #232
     3103     * Example usage:
     3104     * <code>
     3105     * // Use default conversion
     3106     * $plain = $mail->html2text($html);
     3107     * // Use your own custom converter
     3108     * $plain = $mail->html2text($html, function($html) {
     3109     *     $converter = new MyHtml2text($html);
     3110     *     return $converter->get_text();
     3111     * });
     3112     * </code>
    28193113     * @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?
     3114     * @param boolean|callable $advanced Any boolean value to use the internal converter,
     3115     *   or provide your own callable for custom conversion.
    28213116     * @return string
    28223117     */
    28233118    public function html2text($html, $advanced = false)
    28243119    {
    2825         if ($advanced) {
    2826             require_once 'extras/class.html2text.php';
    2827             $h = new html2text($html);
    2828             return $h->get_text();
     3120        if (is_callable($advanced)) {
     3121            return call_user_func($advanced, $html);
    28293122        }
    28303123        return html_entity_decode(
    28313124            trim(strip_tags(preg_replace('/<(head|title|style|script)[^>]*>.*?<\/\\1>/si', '', $html))),
     
    28443137    public static function _mime_types($ext = '')
    28453138    {
    28463139        $mimes = array(
    2847             'xl' => 'application/excel',
    2848             'hqx' => 'application/mac-binhex40',
    2849             'cpt' => 'application/mac-compactpro',
    2850             'bin' => 'application/macbinary',
    2851             'doc' => 'application/msword',
    2852             'word' => 'application/msword',
     3140            'xl'    => 'application/excel',
     3141            'js'    => 'application/javascript',
     3142            'hqx'   => 'application/mac-binhex40',
     3143            'cpt'   => 'application/mac-compactpro',
     3144            'bin'   => 'application/macbinary',
     3145            'doc'   => 'application/msword',
     3146            'word'  => 'application/msword',
    28533147            'class' => 'application/octet-stream',
    2854             'dll' => 'application/octet-stream',
    2855             'dms' => 'application/octet-stream',
    2856             'exe' => 'application/octet-stream',
    2857             'lha' => 'application/octet-stream',
    2858             'lzh' => 'application/octet-stream',
    2859             'psd' => 'application/octet-stream',
    2860             'sea' => 'application/octet-stream',
    2861             'so' => 'application/octet-stream',
    2862             'oda' => 'application/oda',
    2863             'pdf' => 'application/pdf',
    2864             'ai' => 'application/postscript',
    2865             'eps' => 'application/postscript',
    2866             'ps' => 'application/postscript',
    2867             'smi' => 'application/smil',
    2868             'smil' => 'application/smil',
    2869             'mif' => 'application/vnd.mif',
    2870             'xls' => 'application/vnd.ms-excel',
    2871             'ppt' => 'application/vnd.ms-powerpoint',
     3148            'dll'   => 'application/octet-stream',
     3149            'dms'   => 'application/octet-stream',
     3150            'exe'   => 'application/octet-stream',
     3151            'lha'   => 'application/octet-stream',
     3152            'lzh'   => 'application/octet-stream',
     3153            'psd'   => 'application/octet-stream',
     3154            'sea'   => 'application/octet-stream',
     3155            'so'    => 'application/octet-stream',
     3156            'oda'   => 'application/oda',
     3157            'pdf'   => 'application/pdf',
     3158            'ai'    => 'application/postscript',
     3159            'eps'   => 'application/postscript',
     3160            'ps'    => 'application/postscript',
     3161            'smi'   => 'application/smil',
     3162            'smil'  => 'application/smil',
     3163            'mif'   => 'application/vnd.mif',
     3164            'xls'   => 'application/vnd.ms-excel',
     3165            'ppt'   => 'application/vnd.ms-powerpoint',
    28723166            'wbxml' => 'application/vnd.wap.wbxml',
    2873             'wmlc' => 'application/vnd.wap.wmlc',
    2874             'dcr' => 'application/x-director',
    2875             'dir' => 'application/x-director',
    2876             'dxr' => 'application/x-director',
    2877             'dvi' => 'application/x-dvi',
    2878             'gtar' => 'application/x-gtar',
    2879             'php3' => 'application/x-httpd-php',
    2880             'php4' => 'application/x-httpd-php',
    2881             'php' => 'application/x-httpd-php',
     3167            'wmlc'  => 'application/vnd.wap.wmlc',
     3168            'dcr'   => 'application/x-director',
     3169            'dir'   => 'application/x-director',
     3170            'dxr'   => 'application/x-director',
     3171            'dvi'   => 'application/x-dvi',
     3172            'gtar'  => 'application/x-gtar',
     3173            'php3'  => 'application/x-httpd-php',
     3174            'php4'  => 'application/x-httpd-php',
     3175            'php'   => 'application/x-httpd-php',
    28823176            'phtml' => 'application/x-httpd-php',
    2883             'phps' => 'application/x-httpd-php-source',
    2884             'js' => 'application/x-javascript',
    2885             'swf' => 'application/x-shockwave-flash',
    2886             'sit' => 'application/x-stuffit',
    2887             'tar' => 'application/x-tar',
    2888             'tgz' => 'application/x-tar',
    2889             'xht' => 'application/xhtml+xml',
     3177            'phps'  => 'application/x-httpd-php-source',
     3178            'swf'   => 'application/x-shockwave-flash',
     3179            'sit'   => 'application/x-stuffit',
     3180            'tar'   => 'application/x-tar',
     3181            'tgz'   => 'application/x-tar',
     3182            'xht'   => 'application/xhtml+xml',
    28903183            'xhtml' => 'application/xhtml+xml',
    2891             'zip' => 'application/zip',
    2892             'mid' => 'audio/midi',
    2893             'midi' => 'audio/midi',
    2894             'mp2' => 'audio/mpeg',
    2895             'mp3' => 'audio/mpeg',
    2896             'mpga' => 'audio/mpeg',
    2897             'aif' => 'audio/x-aiff',
    2898             'aifc' => 'audio/x-aiff',
    2899             'aiff' => 'audio/x-aiff',
    2900             'ram' => 'audio/x-pn-realaudio',
    2901             'rm' => 'audio/x-pn-realaudio',
    2902             'rpm' => 'audio/x-pn-realaudio-plugin',
    2903             'ra' => 'audio/x-realaudio',
    2904             'wav' => 'audio/x-wav',
    2905             'bmp' => 'image/bmp',
    2906             'gif' => 'image/gif',
    2907             'jpeg' => 'image/jpeg',
    2908             'jpe' => 'image/jpeg',
    2909             'jpg' => 'image/jpeg',
    2910             'png' => 'image/png',
    2911             'tiff' => 'image/tiff',
    2912             'tif' => 'image/tiff',
    2913             'eml' => 'message/rfc822',
    2914             'css' => 'text/css',
    2915             'html' => 'text/html',
    2916             'htm' => 'text/html',
     3184            'zip'   => 'application/zip',
     3185            'mid'   => 'audio/midi',
     3186            'midi'  => 'audio/midi',
     3187            'mp2'   => 'audio/mpeg',
     3188            'mp3'   => 'audio/mpeg',
     3189            'mpga'  => 'audio/mpeg',
     3190            'aif'   => 'audio/x-aiff',
     3191            'aifc'  => 'audio/x-aiff',
     3192            'aiff'  => 'audio/x-aiff',
     3193            'ram'   => 'audio/x-pn-realaudio',
     3194            'rm'    => 'audio/x-pn-realaudio',
     3195            'rpm'   => 'audio/x-pn-realaudio-plugin',
     3196            'ra'    => 'audio/x-realaudio',
     3197            'wav'   => 'audio/x-wav',
     3198            'bmp'   => 'image/bmp',
     3199            'gif'   => 'image/gif',
     3200            'jpeg'  => 'image/jpeg',
     3201            'jpe'   => 'image/jpeg',
     3202            'jpg'   => 'image/jpeg',
     3203            'png'   => 'image/png',
     3204            'tiff'  => 'image/tiff',
     3205            'tif'   => 'image/tiff',
     3206            'eml'   => 'message/rfc822',
     3207            'css'   => 'text/css',
     3208            'html'  => 'text/html',
     3209            'htm'   => 'text/html',
    29173210            'shtml' => 'text/html',
    2918             'log' => 'text/plain',
    2919             'text' => 'text/plain',
    2920             'txt' => 'text/plain',
    2921             'rtx' => 'text/richtext',
    2922             'rtf' => 'text/rtf',
    2923             'xml' => 'text/xml',
    2924             'xsl' => 'text/xml',
    2925             'mpeg' => 'video/mpeg',
    2926             'mpe' => 'video/mpeg',
    2927             'mpg' => 'video/mpeg',
    2928             'mov' => 'video/quicktime',
    2929             'qt' => 'video/quicktime',
    2930             'rv' => 'video/vnd.rn-realvideo',
    2931             'avi' => 'video/x-msvideo',
     3211            'log'   => 'text/plain',
     3212            'text'  => 'text/plain',
     3213            'txt'   => 'text/plain',
     3214            'rtx'   => 'text/richtext',
     3215            'rtf'   => 'text/rtf',
     3216            'vcf'   => 'text/vcard',
     3217            'vcard' => 'text/vcard',
     3218            'xml'   => 'text/xml',
     3219            'xsl'   => 'text/xml',
     3220            'mpeg'  => 'video/mpeg',
     3221            'mpe'   => 'video/mpeg',
     3222            'mpg'   => 'video/mpeg',
     3223            'mov'   => 'video/quicktime',
     3224            'qt'    => 'video/quicktime',
     3225            'rv'    => 'video/vnd.rn-realvideo',
     3226            'avi'   => 'video/x-msvideo',
    29323227            'movie' => 'video/x-sgi-movie'
    29333228        );
    2934         return (array_key_exists(strtolower($ext), $mimes) ? $mimes[strtolower($ext)]: 'application/octet-stream');
     3229        if (array_key_exists(strtolower($ext), $mimes)) {
     3230            return $mimes[strtolower($ext)];
     3231        }
     3232        return 'application/octet-stream';
    29353233    }
    29363234
    29373235    /**
     
    29433241     */
    29443242    public static function filenameToType($filename)
    29453243    {
    2946         //In case the path is a URL, strip any query string before getting extension
     3244        // In case the path is a URL, strip any query string before getting extension
    29473245        $qpos = strpos($filename, '?');
    2948         if ($qpos !== false) {
     3246        if (false !== $qpos) {
    29493247            $filename = substr($filename, 0, $qpos);
    29503248        }
    29513249        $pathinfo = self::mb_pathinfo($filename);
     
    29663264    public static function mb_pathinfo($path, $options = null)
    29673265    {
    29683266        $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];
     3267        $pathinfo = array();
     3268        if (preg_match('%^(.*?)[\\\\/]*(([^/\\\\]*?)(\.([^\.\\\\/]+?)|))[\\\\/\.]*$%im', $path, $pathinfo)) {
     3269            if (array_key_exists(1, $pathinfo)) {
     3270                $ret['dirname'] = $pathinfo[1];
     3271            }
     3272            if (array_key_exists(2, $pathinfo)) {
     3273                $ret['basename'] = $pathinfo[2];
     3274            }
     3275            if (array_key_exists(5, $pathinfo)) {
     3276                $ret['extension'] = $pathinfo[5];
     3277            }
     3278            if (array_key_exists(3, $pathinfo)) {
     3279                $ret['filename'] = $pathinfo[3];
     3280            }
    29733281        }
    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         }
    29833282        switch ($options) {
    29843283            case PATHINFO_DIRNAME:
    29853284            case 'dirname':
    29863285                return $ret['dirname'];
    2987                 break;
    29883286            case PATHINFO_BASENAME:
    29893287            case 'basename':
    29903288                return $ret['basename'];
    2991                 break;
    29923289            case PATHINFO_EXTENSION:
    29933290            case 'extension':
    29943291                return $ret['extension'];
    2995                 break;
    29963292            case PATHINFO_FILENAME:
    29973293            case 'filename':
    29983294                return $ret['filename'];
    2999                 break;
    30003295            default:
    30013296                return $ret;
    30023297        }
     
    30043299
    30053300    /**
    30063301     * Set or reset instance properties.
    3007      *
     3302     * You should avoid this function - it's more verbose, less efficient, more error-prone and
     3303     * harder to debug than setting properties directly.
    30083304     * Usage Example:
    3009      * $page->set('X-Priority', '3');
    3010      *
     3305     * `$mail->set('SMTPSecure', 'tls');`
     3306     *   is the same as:
     3307     * `$mail->SMTPSecure = 'tls';`
    30113308     * @access public
    3012      * @param string $name
    3013      * @param mixed $value
    3014      * NOTE: will not work with arrays, there are no arrays to set/reset
    3015      * @throws phpmailerException
    3016      * @return bool
    3017      * @todo Should this not be using __set() magic function?
     3309     * @param string $name The property name to set
     3310     * @param mixed $value The value to set the property to
     3311     * @return boolean
     3312     * @TODO Should this not be using the __set() magic function?
    30183313     */
    30193314    public function set($name, $value = '')
    30203315    {
    3021         try {
    3022             if (isset($this->$name)) {
    3023                 $this->$name = $value;
    3024             } else {
    3025                 throw new phpmailerException($this->lang('variable_set') . $name, self::STOP_CRITICAL);
    3026             }
    3027         } catch (Exception $e) {
    3028             $this->setError($e->getMessage());
    3029             if ($e->getCode() == self::STOP_CRITICAL) {
    3030                 return false;
    3031             }
     3316        if (property_exists($this, $name)) {
     3317            $this->$name = $value;
     3318            return true;
     3319        } else {
     3320            $this->setError($this->lang('variable_set') . $name);
     3321            return false;
    30323322        }
    3033         return true;
    30343323    }
    30353324
    30363325    /**
     
    30613350
    30623351
    30633352    /**
    3064      * Set the private key file and password for S/MIME signing.
     3353     * Set the public and private key files and password for S/MIME signing.
    30653354     * @access public
    30663355     * @param string $cert_filename
    30673356     * @param string $key_filename
    30683357     * @param string $key_pass Password for private key
     3358     * @param string $extracerts_filename Optional path to chain certificate
    30693359     */
    3070     public function sign($cert_filename, $key_filename, $key_pass)
     3360    public function sign($cert_filename, $key_filename, $key_pass, $extracerts_filename = '')
    30713361    {
    30723362        $this->sign_cert_file = $cert_filename;
    30733363        $this->sign_key_file = $key_filename;
    30743364        $this->sign_key_pass = $key_pass;
     3365        $this->sign_extracerts_file = $extracerts_filename;
    30753366    }
    30763367
    30773368    /**
     
    30883379            if (((0x21 <= $ord) && ($ord <= 0x3A)) || $ord == 0x3C || ((0x3E <= $ord) && ($ord <= 0x7E))) {
    30893380                $line .= $txt[$i];
    30903381            } else {
    3091                 $line .= "=" . sprintf("%02X", $ord);
     3382                $line .= '=' . sprintf('%02X', $ord);
    30923383            }
    30933384        }
    30943385        return $line;
     
    30973388    /**
    30983389     * Generate a DKIM signature.
    30993390     * @access public
    3100      * @param string $s Header
     3391     * @param string $signHeader
    31013392     * @throws phpmailerException
    31023393     * @return string
    31033394     */
    3104     public function DKIM_Sign($s)
     3395    public function DKIM_Sign($signHeader)
    31053396    {
    31063397        if (!defined('PKCS7_TEXT')) {
    31073398            if ($this->exceptions) {
    3108                 throw new phpmailerException($this->lang("signing") . ' OpenSSL extension missing.');
     3399                throw new phpmailerException($this->lang('extension_missing') . 'openssl');
    31093400            }
    31103401            return '';
    31113402        }
     
    31153406        } else {
    31163407            $privKey = $privKeyStr;
    31173408        }
    3118         if (openssl_sign($s, $signature, $privKey)) {
     3409        if (openssl_sign($signHeader, $signature, $privKey)) {
    31193410            return base64_encode($signature);
    31203411        }
    31213412        return '';
     
    31243415    /**
    31253416     * Generate a DKIM canonicalization header.
    31263417     * @access public
    3127      * @param string $s Header
     3418     * @param string $signHeader Header
    31283419     * @return string
    31293420     */
    3130     public function DKIM_HeaderC($s)
     3421    public function DKIM_HeaderC($signHeader)
    31313422    {
    3132         $s = preg_replace("/\r\n\s+/", " ", $s);
    3133         $lines = explode("\r\n", $s);
     3423        $signHeader = preg_replace('/\r\n\s+/', ' ', $signHeader);
     3424        $lines = explode("\r\n", $signHeader);
    31343425        foreach ($lines as $key => $line) {
    3135             list($heading, $value) = explode(":", $line, 2);
     3426            list($heading, $value) = explode(':', $line, 2);
    31363427            $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
     3428            $value = preg_replace('/\s+/', ' ', $value); // Compress useless spaces
     3429            $lines[$key] = $heading . ':' . trim($value); // Don't forget to remove WSP around the value
    31393430        }
    3140         $s = implode("\r\n", $lines);
    3141         return $s;
     3431        $signHeader = implode("\r\n", $lines);
     3432        return $signHeader;
    31423433    }
    31433434
    31443435    /**
     
    31893480                $to_header = $header;
    31903481                $current = 'to_header';
    31913482            } else {
    3192                 if ($current && strpos($header, ' =?') === 0) {
    3193                     $current .= $header;
     3483                if (!empty($$current) && strpos($header, ' =?') === 0) {
     3484                    $$current .= $header;
    31943485                } else {
    31953486                    $current = '';
    31963487                }
     
    32053496        ); // Copied header fields (dkim-quoted-printable)
    32063497        $body = $this->DKIM_BodyC($body);
    32073498        $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=" .
     3499        $DKIMb64 = base64_encode(pack('H*', sha1($body))); // Base64 of packed binary SHA-1 hash of body
     3500        if ('' == $this->DKIM_identity) {
     3501            $ident = '';
     3502        } else {
     3503            $ident = ' i=' . $this->DKIM_identity . ';';
     3504        }
     3505        $dkimhdrs = 'DKIM-Signature: v=1; a=' .
     3506            $DKIMsignatureType . '; q=' .
     3507            $DKIMquery . '; l=' .
     3508            $DKIMlen . '; s=' .
    32143509            $this->DKIM_selector .
    32153510            ";\r\n" .
    3216             "\tt=" . $DKIMtime . "; c=" . $DKIMcanonicalization . ";\r\n" .
     3511            "\tt=" . $DKIMtime . '; c=' . $DKIMcanonicalization . ";\r\n" .
    32173512            "\th=From:To:Subject;\r\n" .
    3218             "\td=" . $this->DKIM_domain . ";" . $ident . "\r\n" .
     3513            "\td=" . $this->DKIM_domain . ';' . $ident . "\r\n" .
    32193514            "\tz=$from\r\n" .
    32203515            "\t|$to\r\n" .
    32213516            "\t|$subject;\r\n" .
     
    32293524    }
    32303525
    32313526    /**
     3527     * Detect if a string contains a line longer than the maximum line length allowed.
     3528     * @param string $str
     3529     * @return boolean
     3530     * @static
     3531     */
     3532    public static function hasLineLongerThanMax($str)
     3533    {
     3534        //+2 to include CRLF line break for a 1000 total
     3535        return (boolean)preg_match('/^(.{'.(self::MAX_LINE_LENGTH + 2).',})/m', $str);
     3536    }
     3537
     3538    /**
     3539     * Allows for public read access to 'to' property.
     3540     * @access public
     3541     * @return array
     3542     */
     3543    public function getToAddresses()
     3544    {
     3545        return $this->to;
     3546    }
     3547
     3548    /**
     3549     * Allows for public read access to 'cc' property.
     3550     * @access public
     3551     * @return array
     3552     */
     3553    public function getCcAddresses()
     3554    {
     3555        return $this->cc;
     3556    }
     3557
     3558    /**
     3559     * Allows for public read access to 'bcc' property.
     3560     * @access public
     3561     * @return array
     3562     */
     3563    public function getBccAddresses()
     3564    {
     3565        return $this->bcc;
     3566    }
     3567
     3568    /**
     3569     * Allows for public read access to 'ReplyTo' property.
     3570     * @access public
     3571     * @return array
     3572     */
     3573    public function getReplyToAddresses()
     3574    {
     3575        return $this->ReplyTo;
     3576    }
     3577
     3578    /**
     3579     * Allows for public read access to 'all_recipients' property.
     3580     * @access public
     3581     * @return array
     3582     */
     3583    public function getAllRecipientAddresses()
     3584    {
     3585        return $this->all_recipients;
     3586    }
     3587
     3588    /**
    32323589     * Perform a callback.
    3233      * @param bool $isSent
    3234      * @param string $to
    3235      * @param string $cc
    3236      * @param string $bcc
     3590     * @param boolean $isSent
     3591     * @param array $to
     3592     * @param array $cc
     3593     * @param array $bcc
    32373594     * @param string $subject
    32383595     * @param string $body
    32393596     * @param string $from
    32403597     */
    3241     protected function doCallback($isSent, $to, $cc, $bcc, $subject, $body, $from = null)
     3598    protected function doCallback($isSent, $to, $cc, $bcc, $subject, $body, $from)
    32423599    {
    32433600        if (!empty($this->action_function) && is_callable($this->action_function)) {
    32443601            $params = array($isSent, $to, $cc, $bcc, $subject, $body, $from);
  • 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
     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.10';
    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.10';
    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    /**
    102      * The SMTP timelimit value for reads, in seconds.
    103      * @type int
     147     * How long to wait for commands to complete, in seconds.
     148     * Default of 5 minutes (300sec) is from RFC2821 section 4.5.3.2
     149     * @type integer
    104150     */
    105     public $Timelimit = 30;
     151    public $Timelimit = 300;
    106152
    107153    /**
    108154     * The socket for the server connection.
     
    111157    protected $smtp_conn;
    112158
    113159    /**
    114      * Error message, if any, for the last call.
    115      * @type string
     160     * Error information, if any, for the last SMTP command.
     161     * @type array
    116162     */
    117     protected $error = '';
     163    protected $error = array(
     164        'error' => '',
     165        'detail' => '',
     166        'smtp_code' => '',
     167        'smtp_code_ex' => ''
     168    );
    118169
    119170    /**
    120171     * The reply the server sent to us for HELO.
    121      * @type string
     172     * If null, no HELO string has yet been received.
     173     * @type string|null
    122174     */
    123     protected $helo_rply = '';
     175    protected $helo_rply = null;
    124176
    125177    /**
     178     * The set of SMTP extensions sent in reply to EHLO command.
     179     * Indexes of the array are extension names.
     180     * Value at index 'HELO' or 'EHLO' (according to command that was sent)
     181     * represents the server name. In case of HELO it is the only element of the array.
     182     * Other values can be boolean TRUE or an array containing extension options.
     183     * If null, no HELO/EHLO string has yet been received.
     184     * @type array|null
     185     */
     186    protected $server_caps = null;
     187
     188    /**
    126189     * The most recent reply received from the server.
    127190     * @type string
    128191     */
     
    129192    protected $last_reply = '';
    130193
    131194    /**
    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     /**
    145195     * Output debugging info via a user-selected method.
     196     * @see SMTP::$Debugoutput
     197     * @see SMTP::$do_debug
    146198     * @param string $str Debug string to output
     199     * @param integer $level The debug level of this message; see DEBUG_* constants
    147200     * @return void
    148201     */
    149     protected function edebug($str)
     202    protected function edebug($str, $level = 0)
    150203    {
     204        if ($level > $this->do_debug) {
     205            return;
     206        }
     207        //Avoid clash with built-in function names
     208        if (!in_array($this->Debugoutput, array('error_log', 'html', 'echo')) and is_callable($this->Debugoutput)) {
     209            call_user_func($this->Debugoutput, $str, $this->do_debug);
     210            return;
     211        }
    151212        switch ($this->Debugoutput) {
    152213            case 'error_log':
    153214                //Don't output, just log
     
    164225                break;
    165226            case 'echo':
    166227            default:
    167                 //Just echoes whatever was received
    168                 echo $str;
     228                //Normalize line breaks
     229                $str = preg_replace('/(\r\n|\r|\n)/ms', "\n", $str);
     230                echo gmdate('Y-m-d H:i:s') . "\t" . str_replace(
     231                    "\n",
     232                    "\n                   \t                  ",
     233                    trim($str)
     234                )."\n";
    169235        }
    170236    }
    171237
    172238    /**
    173239     * 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
     240     * @param string $host SMTP server IP or host name
     241     * @param integer $port The port number to connect to
     242     * @param integer $timeout How long to wait for the connection to open
    177243     * @param array $options An array of options for stream_context_create()
    178244     * @access public
    179      * @return bool
     245     * @return boolean
    180246     */
    181247    public function connect($host, $port = null, $timeout = 30, $options = array())
    182248    {
     249        static $streamok;
     250        //This is enabled by default since 5.0.0 but some providers disable it
     251        //Check this once and cache the result
     252        if (is_null($streamok)) {
     253            $streamok = function_exists('stream_socket_client');
     254        }
    183255        // Clear errors to avoid confusion
    184         $this->error = null;
    185 
     256        $this->setError('');
    186257        // Make sure we are __not__ connected
    187258        if ($this->connected()) {
    188259            // Already connected, generate error
    189             $this->error = array('error' => 'Already connected to a server');
     260            $this->setError('Already connected to a server');
    190261            return false;
    191262        }
    192 
    193263        if (empty($port)) {
    194264            $port = self::DEFAULT_SMTP_PORT;
    195265        }
    196 
    197266        // Connect to the SMTP server
     267        $this->edebug(
     268            "Connection: opening to $host:$port, timeout=$timeout, options=".var_export($options, true),
     269            self::DEBUG_CONNECTION
     270        );
    198271        $errno = 0;
    199272        $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 
     273        if ($streamok) {
     274            $socket_context = stream_context_create($options);
     275            //Suppress errors; connection failures are handled at a higher level
     276            $this->smtp_conn = @stream_socket_client(
     277                $host . ":" . $port,
     278                $errno,
     279                $errstr,
     280                $timeout,
     281                STREAM_CLIENT_CONNECT,
     282                $socket_context
     283            );
     284        } else {
     285            //Fall back to fsockopen which should work in more places, but is missing some features
     286            $this->edebug(
     287                "Connection: stream_socket_client not available, falling back to fsockopen",
     288                self::DEBUG_CONNECTION
     289            );
     290            $this->smtp_conn = fsockopen(
     291                $host,
     292                $port,
     293                $errno,
     294                $errstr,
     295                $timeout
     296            );
     297        }
    211298        // Verify we connected properly
    212         if (empty($this->smtp_conn)) {
    213             $this->error = array(
    214                 'error' => 'Failed to connect to server',
    215                 'errno' => $errno,
    216                 'errstr' => $errstr
     299        if (!is_resource($this->smtp_conn)) {
     300            $this->setError(
     301                'Failed to connect to server',
     302                $errno,
     303                $errstr
    217304            );
    218             if ($this->do_debug >= 1) {
    219                 $this->edebug(
    220                     'SMTP -> ERROR: ' . $this->error['error']
    221                     . ": $errstr ($errno)"
    222                 );
    223             }
     305            $this->edebug(
     306                'SMTP ERROR: ' . $this->error['error']
     307                . ": $errstr ($errno)",
     308                self::DEBUG_CLIENT
     309            );
    224310            return false;
    225311        }
    226 
     312        $this->edebug('Connection: opened', self::DEBUG_CONNECTION);
    227313        // SMTP server can take longer to respond, give longer timeout for first read
    228314        // Windows does not have support for this timeout function
    229315        if (substr(PHP_OS, 0, 3) != 'WIN') {
    230316            $max = ini_get('max_execution_time');
    231             if ($max != 0 && $timeout > $max) { // Don't bother if unlimited
     317            // Don't bother if unlimited
     318            if ($max != 0 && $timeout > $max) {
    232319                @set_time_limit($timeout);
    233320            }
    234321            stream_set_timeout($this->smtp_conn, $timeout, 0);
    235322        }
    236 
    237323        // Get any announcement
    238324        $announce = $this->get_lines();
    239 
    240         if ($this->do_debug >= 2) {
    241             $this->edebug('SMTP -> FROM SERVER:' . $announce);
    242         }
    243 
     325        $this->edebug('SERVER -> CLIENT: ' . $announce, self::DEBUG_SERVER);
    244326        return true;
    245327    }
    246328
     
    247329    /**
    248330     * Initiate a TLS (encrypted) session.
    249331     * @access public
    250      * @return bool
     332     * @return boolean
    251333     */
    252334    public function startTLS()
    253335    {
    254         if (!$this->sendCommand("STARTTLS", "STARTTLS", 220)) {
     336        if (!$this->sendCommand('STARTTLS', 'STARTTLS', 220)) {
    255337            return false;
    256338        }
    257339        // Begin encrypted connection
     
    259341            $this->smtp_conn,
    260342            true,
    261343            STREAM_CRYPTO_METHOD_TLS_CLIENT
    262         )
    263         ) {
     344        )) {
    264345            return false;
    265346        }
    266347        return true;
     
    276357     * @param string $realm       The auth realm for NTLM
    277358     * @param string $workstation The auth workstation for NTLM
    278359     * @access public
    279      * @return bool True if successfully authenticated.
     360     * @return boolean True if successfully authenticated.
    280361     */
    281362    public function authenticate(
    282363        $username,
    283364        $password,
    284         $authtype = 'LOGIN',
     365        $authtype = null,
    285366        $realm = '',
    286367        $workstation = ''
    287368    ) {
    288         if (empty($authtype)) {
     369        if (!$this->server_caps) {
     370            $this->setError('Authentication is not allowed before HELO/EHLO');
     371            return false;
     372        }
     373
     374        if (array_key_exists('EHLO', $this->server_caps)) {
     375        // SMTP extensions are available. Let's try to find a proper authentication method
     376
     377            if (!array_key_exists('AUTH', $this->server_caps)) {
     378                $this->setError('Authentication is not allowed at this stage');
     379                // 'at this stage' means that auth may be allowed after the stage changes
     380                // e.g. after STARTTLS
     381                return false;
     382            }
     383
     384            self::edebug('Auth method requested: ' . ($authtype ? $authtype : 'UNKNOWN'), self::DEBUG_LOWLEVEL);
     385            self::edebug(
     386                'Auth methods available on the server: ' . implode(',', $this->server_caps['AUTH']),
     387                self::DEBUG_LOWLEVEL
     388            );
     389
     390            if (empty($authtype)) {
     391                foreach (array('LOGIN', 'CRAM-MD5', 'PLAIN') as $method) {
     392                    if (in_array($method, $this->server_caps['AUTH'])) {
     393                        $authtype = $method;
     394                        break;
     395                    }
     396                }
     397                if (empty($authtype)) {
     398                    $this->setError('No supported authentication methods found');
     399                    return false;
     400                }
     401                self::edebug('Auth method selected: '.$authtype, self::DEBUG_LOWLEVEL);
     402            }
     403
     404            if (!in_array($authtype, $this->server_caps['AUTH'])) {
     405                $this->setError("The requested authentication method \"$authtype\" is not supported by the server");
     406                return false;
     407            }
     408        } elseif (empty($authtype)) {
    289409            $authtype = 'LOGIN';
    290410        }
    291 
    292411        switch ($authtype) {
    293412            case 'PLAIN':
    294413                // Start authentication
     
    317436                    return false;
    318437                }
    319438                break;
    320             case 'NTLM':
    321                 /*
    322                  * ntlm_sasl_client.php
    323                  * Bundled with Permission
    324                  *
    325                  * How to telnet in windows:
    326                  * http://technet.microsoft.com/en-us/library/aa995718%28EXCHG.65%29.aspx
    327                  * PROTOCOL Docs http://curl.haxx.se/rfc/ntlm.html#ntlmSmtpAuthentication
    328                  */
    329                 require_once 'extras/ntlm_sasl_client.php';
    330                 $temp = new stdClass();
    331                 $ntlm_client = new ntlm_sasl_client_class;
    332                 //Check that functions are available
    333                 if (!$ntlm_client->Initialize($temp)) {
    334                     $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                     }
    341                     return false;
    342                 }
    343                 //msg1
    344                 $msg1 = $ntlm_client->TypeMsg1($realm, $workstation); //msg1
    345 
    346                 if (!$this->sendCommand(
    347                     'AUTH NTLM',
    348                     'AUTH NTLM ' . base64_encode($msg1),
    349                     334
    350                 )
    351                 ) {
    352                     return false;
    353                 }
    354 
    355                 //Though 0 based, there is a white space after the 3 digit number
    356                 //msg2
    357                 $challenge = substr($this->last_reply, 3);
    358                 $challenge = base64_decode($challenge);
    359                 $ntlm_res = $ntlm_client->NTLMResponse(
    360                     substr($challenge, 24, 8),
    361                     $password
    362                 );
    363                 //msg3
    364                 $msg3 = $ntlm_client->TypeMsg3(
    365                     $ntlm_res,
    366                     $username,
    367                     $realm,
    368                     $workstation
    369                 );
    370                 // send encoded username
    371                 return $this->sendCommand('Username', base64_encode($msg3), 235);
    372                 break;
    373439            case 'CRAM-MD5':
    374440                // Start authentication
    375441                if (!$this->sendCommand('AUTH CRAM-MD5', 'AUTH CRAM-MD5', 334)) {
     
    383449
    384450                // send encoded credentials
    385451                return $this->sendCommand('Username', base64_encode($response), 235);
    386                 break;
     452            default:
     453                $this->setError("Authentication method \"$authtype\" is not supported");
     454                return false;
    387455        }
    388456        return true;
    389457    }
     
    411479        // Eliminates the need to install mhash to compute a HMAC
    412480        // by Lance Rushing
    413481
    414         $b = 64; // byte length for md5
    415         if (strlen($key) > $b) {
     482        $bytelen = 64; // byte length for md5
     483        if (strlen($key) > $bytelen) {
    416484            $key = pack('H*', md5($key));
    417485        }
    418         $key = str_pad($key, $b, chr(0x00));
    419         $ipad = str_pad('', $b, chr(0x36));
    420         $opad = str_pad('', $b, chr(0x5c));
     486        $key = str_pad($key, $bytelen, chr(0x00));
     487        $ipad = str_pad('', $bytelen, chr(0x36));
     488        $opad = str_pad('', $bytelen, chr(0x5c));
    421489        $k_ipad = $key ^ $ipad;
    422490        $k_opad = $key ^ $opad;
    423491
     
    427495    /**
    428496     * Check connection state.
    429497     * @access public
    430      * @return bool True if connected.
     498     * @return boolean True if connected.
    431499     */
    432500    public function connected()
    433501    {
    434         if (!empty($this->smtp_conn)) {
     502        if (is_resource($this->smtp_conn)) {
    435503            $sock_status = stream_get_meta_data($this->smtp_conn);
    436504            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                 }
     505                // The socket is valid but we are not connected
     506                $this->edebug(
     507                    'SMTP NOTICE: EOF caught while checking if connected',
     508                    self::DEBUG_CLIENT
     509                );
    443510                $this->close();
    444511                return false;
    445512            }
     
    457524     */
    458525    public function close()
    459526    {
    460         $this->error = null; // so there is no confusion
     527        $this->setError('');
     528        $this->server_caps = null;
    461529        $this->helo_rply = null;
    462         if (!empty($this->smtp_conn)) {
     530        if (is_resource($this->smtp_conn)) {
    463531            // close the connection and cleanup
    464532            fclose($this->smtp_conn);
    465             $this->smtp_conn = 0;
     533            $this->smtp_conn = null; //Makes for cleaner serialization
     534            $this->edebug('Connection: closed', self::DEBUG_CONNECTION);
    466535        }
    467536    }
    468537
     
    476545     * Implements rfc 821: DATA <CRLF>
    477546     * @param string $msg_data Message data to send
    478547     * @access public
    479      * @return bool
     548     * @return boolean
    480549     */
    481550    public function data($msg_data)
    482551    {
     552        //This will use the standard timelimit
    483553        if (!$this->sendCommand('DATA', 'DATA', 354)) {
    484554            return false;
    485555        }
    486556
    487557        /* 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.
     558         * According to rfc821 we should not send more than 1000 characters on a single line (including the CRLF)
     559         * so we will break the data up into lines by \r and/or \n then if needed we will break each of those into
     560         * smaller lines to fit within the limit.
     561         * We will also look for lines that start with a '.' and prepend an additional '.'.
     562         * NOTE: this does not count towards line-length limit.
    496563         */
    497564
    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);
     565        // Normalize line breaks before exploding
     566        $lines = explode("\n", str_replace(array("\r\n", "\r"), "\n", $msg_data));
    502567
    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.
     568        /* To distinguish between a complete RFC822 message and a plain message body, we check if the first field
     569         * of the first line (':' separated) does not contain a space then it _should_ be a header and we will
     570         * process all lines before a blank line as headers.
    510571         */
    511572
    512573        $field = substr($lines[0], 0, strpos($lines[0], ':'));
    513574        $in_headers = false;
    514         if (!empty($field) && !strstr($field, ' ')) {
     575        if (!empty($field) && strpos($field, ' ') === false) {
    515576            $in_headers = true;
    516577        }
    517578
    518         //RFC 2822 section 2.1.1 limit
    519         $max_line_length = 998;
    520 
    521579        foreach ($lines as $line) {
    522             $lines_out = null;
    523             if ($line == '' && $in_headers) {
     580            $lines_out = array();
     581            if ($in_headers and $line == '') {
    524582                $in_headers = false;
    525583            }
    526             // 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
     584            //Break this line up into several smaller lines if it's too long
     585            //Micro-optimisation: isset($str[$len]) is faster than (strlen($str) > $len),
     586            while (isset($line[self::MAX_LINE_LENGTH])) {
     587                //Working backwards, try to find a space within the last MAX_LINE_LENGTH chars of the line to break on
     588                //so as to avoid breaking in the middle of a word
     589                $pos = strrpos(substr($line, 0, self::MAX_LINE_LENGTH), ' ');
     590                //Deliberately matches both false and 0
    531591                if (!$pos) {
    532                     $pos = $max_line_length - 1;
     592                    //No nice break found, add a hard break
     593                    $pos = self::MAX_LINE_LENGTH - 1;
    533594                    $lines_out[] = substr($line, 0, $pos);
    534595                    $line = substr($line, $pos);
    535596                } else {
     597                    //Break at the found point
    536598                    $lines_out[] = substr($line, 0, $pos);
     599                    //Move along by the amount we dealt with
    537600                    $line = substr($line, $pos + 1);
    538601                }
    539 
    540                 /* If processing headers add a LWSP-char to the front of new line
    541                  * rfc822 on long msg headers
    542                  */
     602                //If processing headers add a LWSP-char to the front of new line RFC822 section 3.1.1
    543603                if ($in_headers) {
    544604                    $line = "\t" . $line;
    545605                }
     
    546606            }
    547607            $lines_out[] = $line;
    548608
    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                     }
     609            //Send the lines to the server
     610            foreach ($lines_out as $line_out) {
     611                //RFC2821 section 4.5.2
     612                if (!empty($line_out) and $line_out[0] == '.') {
     613                    $line_out = '.' . $line_out;
    555614                }
    556615                $this->client_send($line_out . self::CRLF);
    557616            }
    558617        }
    559618
    560         // Message data has been sent, complete the command
    561         return $this->sendCommand('DATA END', '.', 250);
     619        //Message data has been sent, complete the command
     620        //Increase timelimit for end of DATA command
     621        $savetimelimit = $this->Timelimit;
     622        $this->Timelimit = $this->Timelimit * 2;
     623        $result = $this->sendCommand('DATA END', '.', 250);
     624        //Restore timelimit
     625        $this->Timelimit = $savetimelimit;
     626        return $result;
    562627    }
    563628
    564629    /**
     
    565630     * Send an SMTP HELO or EHLO command.
    566631     * Used to identify the sending server to the receiving server.
    567632     * This makes sure that client and server are in a known state.
    568      * Implements from RFC 821: HELO <SP> <domain> <CRLF>
     633     * Implements RFC 821: HELO <SP> <domain> <CRLF>
    569634     * and RFC 2821 EHLO.
    570635     * @param string $host The host name or IP to connect to
    571636     * @access public
    572      * @return bool
     637     * @return boolean
    573638     */
    574639    public function hello($host = '')
    575640    {
    576         // 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;
     641        //Try extended hello first (RFC 2821)
     642        return (boolean)($this->sendHello('EHLO', $host) or $this->sendHello('HELO', $host));
    584643    }
    585644
    586645    /**
     
    588647     * Low-level implementation used by hello()
    589648     * @see hello()
    590649     * @param string $hello The HELO string
    591      * @param string $host  The hostname to say we are
     650     * @param string $host The hostname to say we are
    592651     * @access protected
    593      * @return bool
     652     * @return boolean
    594653     */
    595654    protected function sendHello($hello, $host)
    596655    {
    597656        $noerror = $this->sendCommand($hello, $hello . ' ' . $host, 250);
    598657        $this->helo_rply = $this->last_reply;
     658        if ($noerror) {
     659            $this->parseHelloFields($hello);
     660        } else {
     661            $this->server_caps = null;
     662        }
    599663        return $noerror;
    600664    }
    601665
    602666    /**
     667     * Parse a reply to HELO/EHLO command to discover server extensions.
     668     * In case of HELO, the only parameter that can be discovered is a server name.
     669     * @access protected
     670     * @param string $type - 'HELO' or 'EHLO'
     671     */
     672    protected function parseHelloFields($type)
     673    {
     674        $this->server_caps = array();
     675        $lines = explode("\n", $this->last_reply);
     676        foreach ($lines as $n => $s) {
     677            $s = trim(substr($s, 4));
     678            if (!$s) {
     679                continue;
     680            }
     681            $fields = explode(' ', $s);
     682            if (!empty($fields)) {
     683                if (!$n) {
     684                    $name = $type;
     685                    $fields = $fields[0];
     686                } else {
     687                    $name = array_shift($fields);
     688                    if ($name == 'SIZE') {
     689                        $fields = ($fields) ? $fields[0] : 0;
     690                    }
     691                }
     692                $this->server_caps[$name] = ($fields ? $fields : true);
     693            }
     694        }
     695    }
     696
     697    /**
    603698     * Send an SMTP MAIL command.
    604699     * Starts a mail transaction from the email address specified in
    605700     * $from. Returns true if successful or false otherwise. If True
     
    608703     * Implements rfc 821: MAIL <SP> FROM:<reverse-path> <CRLF>
    609704     * @param string $from Source address of this message
    610705     * @access public
    611      * @return bool
     706     * @return boolean
    612707     */
    613708    public function mail($from)
    614709    {
     
    624719     * Send an SMTP QUIT command.
    625720     * Closes the socket if there is no error or the $close_on_error argument is true.
    626721     * Implements from rfc 821: QUIT <CRLF>
    627      * @param bool $close_on_error Should the connection close if an error occurs?
     722     * @param boolean $close_on_error Should the connection close if an error occurs?
    628723     * @access public
    629      * @return bool
     724     * @return boolean
    630725     */
    631726    public function quit($close_on_error = true)
    632727    {
    633728        $noerror = $this->sendCommand('QUIT', 'QUIT', 221);
    634         $e = $this->error; //Save any error
     729        $err = $this->error; //Save any error
    635730        if ($noerror or $close_on_error) {
    636731            $this->close();
    637             $this->error = $e; //Restore any error from the quit command
     732            $this->error = $err; //Restore any error from the quit command
    638733        }
    639734        return $noerror;
    640735    }
     
    641736
    642737    /**
    643738     * Send an SMTP RCPT command.
    644      * Sets the TO argument to $to.
     739     * Sets the TO argument to $toaddr.
    645740     * Returns true if the recipient was accepted false if it was rejected.
    646741     * Implements from rfc 821: RCPT <SP> TO:<forward-path> <CRLF>
    647      * @param string $to The address the message is being sent to
     742     * @param string $toaddr The address the message is being sent to
    648743     * @access public
    649      * @return bool
     744     * @return boolean
    650745     */
    651     public function recipient($to)
     746    public function recipient($toaddr)
    652747    {
    653748        return $this->sendCommand(
    654             'RCPT TO ',
    655             'RCPT TO:<' . $to . '>',
     749            'RCPT TO',
     750            'RCPT TO:<' . $toaddr . '>',
    656751            array(250, 251)
    657752        );
    658753    }
     
    662757     * Abort any transaction that is currently in progress.
    663758     * Implements rfc 821: RSET <CRLF>
    664759     * @access public
    665      * @return bool True on success.
     760     * @return boolean True on success.
    666761     */
    667762    public function reset()
    668763    {
     
    673768     * Send a command to an SMTP server and check its return code.
    674769     * @param string $command       The command name - not sent to the server
    675770     * @param string $commandstring The actual command to send
    676      * @param int|array $expect     One or more expected integer success codes
     771     * @param integer|array $expect     One or more expected integer success codes
    677772     * @access protected
    678      * @return bool True on success.
     773     * @return boolean True on success.
    679774     */
    680775    protected function sendCommand($command, $commandstring, $expect)
    681776    {
    682777        if (!$this->connected()) {
    683             $this->error = array(
    684                 "error" => "Called $command without being connected"
    685             );
     778            $this->setError("Called $command without being connected");
    686779            return false;
    687780        }
    688781        $this->client_send($commandstring . self::CRLF);
    689782
    690         $reply = $this->get_lines();
    691         $code = substr($reply, 0, 3);
    692 
    693         if ($this->do_debug >= 2) {
    694             $this->edebug('SMTP -> FROM SERVER:' . $reply);
     783        $this->last_reply = $this->get_lines();
     784        // Fetch SMTP code and possible error code explanation
     785        $matches = array();
     786        if (preg_match("/^([0-9]{3})[ -](?:([0-9]\\.[0-9]\\.[0-9]) )?/", $this->last_reply, $matches)) {
     787            $code = $matches[1];
     788            $code_ex = (count($matches) > 2 ? $matches[2] : null);
     789            // Cut off error code from each response line
     790            $detail = preg_replace(
     791                "/{$code}[ -]".($code_ex ? str_replace('.', '\\.', $code_ex).' ' : '')."/m",
     792                '',
     793                $this->last_reply
     794            );
     795        } else {
     796            // Fall back to simple parsing if regex fails
     797            $code = substr($this->last_reply, 0, 3);
     798            $code_ex = null;
     799            $detail = substr($this->last_reply, 4);
    695800        }
    696801
     802        $this->edebug('SERVER -> CLIENT: ' . $this->last_reply, self::DEBUG_SERVER);
     803
    697804        if (!in_array($code, (array)$expect)) {
    698             $this->last_reply = null;
    699             $this->error = array(
    700                 "error" => "$command command failed",
    701                 "smtp_code" => $code,
    702                 "detail" => substr($reply, 4)
     805            $this->setError(
     806                "$command command failed",
     807                $detail,
     808                $code,
     809                $code_ex
    703810            );
    704             if ($this->do_debug >= 1) {
    705                 $this->edebug(
    706                     'SMTP -> ERROR: ' . $this->error['error'] . ': ' . $reply
    707                 );
    708             }
     811            $this->edebug(
     812                'SMTP ERROR: ' . $this->error['error'] . ': ' . $this->last_reply,
     813                self::DEBUG_CLIENT
     814            );
    709815            return false;
    710816        }
    711817
    712         $this->last_reply = $reply;
    713         $this->error = null;
     818        $this->setError('');
    714819        return true;
    715820    }
    716821
     
    725830     * Implements rfc 821: SAML <SP> FROM:<reverse-path> <CRLF>
    726831     * @param string $from The address the message is from
    727832     * @access public
    728      * @return bool
     833     * @return boolean
    729834     */
    730835    public function sendAndMail($from)
    731836    {
    732         return $this->sendCommand("SAML", "SAML FROM:$from", 250);
     837        return $this->sendCommand('SAML', "SAML FROM:$from", 250);
    733838    }
    734839
    735840    /**
     
    736841     * Send an SMTP VRFY command.
    737842     * @param string $name The name to verify
    738843     * @access public
    739      * @return bool
     844     * @return boolean
    740845     */
    741846    public function verify($name)
    742847    {
    743         return $this->sendCommand("VRFY", "VRFY $name", array(250, 251));
     848        return $this->sendCommand('VRFY', "VRFY $name", array(250, 251));
    744849    }
    745850
    746851    /**
     
    747852     * Send an SMTP NOOP command.
    748853     * Used to keep keep-alives alive, doesn't actually do anything
    749854     * @access public
    750      * @return bool
     855     * @return boolean
    751856     */
    752857    public function noop()
    753858    {
    754         return $this->sendCommand("NOOP", "NOOP", 250);
     859        return $this->sendCommand('NOOP', 'NOOP', 250);
    755860    }
    756861
    757862    /**
    758863     * Send an SMTP TURN command.
    759864     * 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
     865     * This method is here to make the RFC821 Definition complete for this class
     866     * and _may_ be implemented in future
    762867     * Implements from rfc 821: TURN <CRLF>
    763868     * @access public
    764      * @return bool
     869     * @return boolean
    765870     */
    766871    public function turn()
    767872    {
    768         $this->error = array(
    769             'error' => 'The SMTP TURN command is not implemented'
    770         );
    771         if ($this->do_debug >= 1) {
    772             $this->edebug('SMTP -> NOTICE: ' . $this->error['error']);
    773         }
     873        $this->setError('The SMTP TURN command is not implemented');
     874        $this->edebug('SMTP NOTICE: ' . $this->error['error'], self::DEBUG_CLIENT);
    774875        return false;
    775876    }
    776877
     
    778879     * Send raw data to the server.
    779880     * @param string $data The data to send
    780881     * @access public
    781      * @return int|bool The number of bytes sent to the server or FALSE on error
     882     * @return integer|boolean The number of bytes sent to the server or false on error
    782883     */
    783884    public function client_send($data)
    784885    {
    785         if ($this->do_debug >= 1) {
    786             $this->edebug("CLIENT -> SMTP: $data");
    787         }
     886        $this->edebug("CLIENT -> SERVER: $data", self::DEBUG_CLIENT);
    788887        return fwrite($this->smtp_conn, $data);
    789888    }
    790889
     
    799898    }
    800899
    801900    /**
     901     * Get SMTP extensions available on the server
     902     * @access public
     903     * @return array|null
     904     */
     905    public function getServerExtList()
     906    {
     907        return $this->server_caps;
     908    }
     909
     910    /**
     911     * A multipurpose method
     912     * The method works in three ways, dependent on argument value and current state
     913     *   1. HELO/EHLO was not sent - returns null and set up $this->error
     914     *   2. HELO was sent
     915     *     $name = 'HELO': returns server name
     916     *     $name = 'EHLO': returns boolean false
     917     *     $name = any string: returns null and set up $this->error
     918     *   3. EHLO was sent
     919     *     $name = 'HELO'|'EHLO': returns server name
     920     *     $name = any string: if extension $name exists, returns boolean True
     921     *       or its options. Otherwise returns boolean False
     922     * In other words, one can use this method to detect 3 conditions:
     923     *  - null returned: handshake was not or we don't know about ext (refer to $this->error)
     924     *  - false returned: the requested feature exactly not exists
     925     *  - positive value returned: the requested feature exists
     926     * @param string $name Name of SMTP extension or 'HELO'|'EHLO'
     927     * @return mixed
     928     */
     929    public function getServerExt($name)
     930    {
     931        if (!$this->server_caps) {
     932            $this->setError('No HELO/EHLO was sent');
     933            return null;
     934        }
     935
     936        // the tight logic knot ;)
     937        if (!array_key_exists($name, $this->server_caps)) {
     938            if ($name == 'HELO') {
     939                return $this->server_caps['EHLO'];
     940            }
     941            if ($name == 'EHLO' || array_key_exists('EHLO', $this->server_caps)) {
     942                return false;
     943            }
     944            $this->setError('HELO handshake was used. Client knows nothing about server extensions');
     945            return null;
     946        }
     947
     948        return $this->server_caps[$name];
     949    }
     950
     951    /**
    802952     * Get the last reply from the server.
    803953     * @access public
    804954     * @return string
     
    819969     */
    820970    protected function get_lines()
    821971    {
     972        // If the connection is bad, give up straight away
     973        if (!is_resource($this->smtp_conn)) {
     974            return '';
     975        }
    822976        $data = '';
    823977        $endtime = 0;
    824         // If the connection is bad, give up now
    825         if (!is_resource($this->smtp_conn)) {
    826             return $data;
    827         }
    828978        stream_set_timeout($this->smtp_conn, $this->Timeout);
    829979        if ($this->Timelimit > 0) {
    830980            $endtime = time() + $this->Timelimit;
     
    831981        }
    832982        while (is_resource($this->smtp_conn) && !feof($this->smtp_conn)) {
    833983            $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             }
     984            $this->edebug("SMTP -> get_lines(): \$data was \"$data\"", self::DEBUG_LOWLEVEL);
     985            $this->edebug("SMTP -> get_lines(): \$str is \"$str\"", self::DEBUG_LOWLEVEL);
    838986            $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) == ' ') {
     987            $this->edebug("SMTP -> get_lines(): \$data is \"$data\"", self::DEBUG_LOWLEVEL);
     988            // If 4th character is a space, we are done reading, break the loop, micro-optimisation over strlen
     989            if ((isset($str[3]) and $str[3] == ' ')) {
    844990                break;
    845991            }
    846992            // Timed-out? Log and break
    847993            $info = stream_get_meta_data($this->smtp_conn);
    848994            if ($info['timed_out']) {
    849                 if ($this->do_debug >= 4) {
    850                     $this->edebug(
    851                         'SMTP -> get_lines(): timed-out (' . $this->Timeout . ' sec)'
    852                     );
    853                 }
     995                $this->edebug(
     996                    'SMTP -> get_lines(): timed-out (' . $this->Timeout . ' sec)',
     997                    self::DEBUG_LOWLEVEL
     998                );
    854999                break;
    8551000            }
    8561001            // 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                 }
     1002            if ($endtime and time() > $endtime) {
     1003                $this->edebug(
     1004                    'SMTP -> get_lines(): timelimit reached ('.
     1005                    $this->Timelimit . ' sec)',
     1006                    self::DEBUG_LOWLEVEL
     1007                );
     1008                break;
    8671009            }
    8681010        }
    8691011        return $data;
     
    8711013
    8721014    /**
    8731015     * Enable or disable VERP address generation.
    874      * @param bool $enabled
     1016     * @param boolean $enabled
    8751017     */
    8761018    public function setVerp($enabled = false)
    8771019    {
     
    8801022
    8811023    /**
    8821024     * Get VERP address generation mode.
    883      * @return bool
     1025     * @return boolean
    8841026     */
    8851027    public function getVerp()
    8861028    {
     
    8881030    }
    8891031
    8901032    /**
     1033     * Set error messages and codes.
     1034     * @param string $message The error message
     1035     * @param string $detail Further detail on the error
     1036     * @param string $smtp_code An associated SMTP error code
     1037     * @param string $smtp_code_ex Extended SMTP code
     1038     */
     1039    protected function setError($message, $detail = '', $smtp_code = '', $smtp_code_ex = '')
     1040    {
     1041        $this->error = array(
     1042            'error' => $message,
     1043            'detail' => $detail,
     1044            'smtp_code' => $smtp_code,
     1045            'smtp_code_ex' => $smtp_code_ex
     1046        );
     1047    }
     1048
     1049    /**
    8911050     * Set debug output method.
    892      * @param string $method The function/method to use for debugging output.
     1051     * @param string|callable $method The name of the mechanism to use for debugging output, or a callable to handle it.
    8931052     */
    8941053    public function setDebugOutput($method = 'echo')
    8951054    {
     
    9071066
    9081067    /**
    9091068     * Set debug output level.
    910      * @param int $level
     1069     * @param integer $level
    9111070     */
    9121071    public function setDebugLevel($level = 0)
    9131072    {
     
    9161075
    9171076    /**
    9181077     * Get debug output level.
    919      * @return int
     1078     * @return integer
    9201079     */
    9211080    public function getDebugLevel()
    9221081    {
     
    9251084
    9261085    /**
    9271086     * Set SMTP timeout.
    928      * @param int $timeout
     1087     * @param integer $timeout
    9291088     */
    9301089    public function setTimeout($timeout = 0)
    9311090    {
     
    9341093
    9351094    /**
    9361095     * Get SMTP timeout.
    937      * @return int
     1096     * @return integer
    9381097     */
    9391098    public function getTimeout()
    9401099    {