PageRenderTime 114ms CodeModel.GetById 4ms app.highlight 88ms RepoModel.GetById 1ms app.codeStats 1ms

/webroot/lib/PHPMailer/class.phpmailer.php

https://github.com/jhonsegurag/SI
PHP | 3465 lines | 2020 code | 230 blank | 1215 comment | 339 complexity | fd252aff9feaf27318725ca3aa27204a MD5 | raw file
   1<?php
   2/**
   3 * PHPMailer - PHP email creation and transport class.
   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>
   8 * @author Jim Jagielski (jimjag) <jimjag@gmail.com>
   9 * @author Andy Prevost (codeworxtech) <codeworxtech@users.sourceforge.net>
  10 * @author Brent R. Matzelle (original founder)
  11 * @copyright 2012 - 2014 Marcus Bointon
  12 * @copyright 2010 - 2012 Jim Jagielski
  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.
  18 */
  19
  20/**
  21 * PHPMailer - PHP email creation and transport class.
  22 * @package PHPMailer
  23 * @author Marcus Bointon (Synchro/coolbru) <phpmailer@synchromedia.co.uk>
  24 * @author Jim Jagielski (jimjag) <jimjag@gmail.com>
  25 * @author Andy Prevost (codeworxtech) <codeworxtech@users.sourceforge.net>
  26 * @author Brent R. Matzelle (original founder)
  27 */
  28class PHPMailer
  29{
  30    /**
  31     * The PHPMailer Version number.
  32     * @type string
  33     */
  34    public $Version = '5.2.9';
  35
  36    /**
  37     * Email priority.
  38     * Options: 1 = High, 3 = Normal, 5 = low.
  39     * @type integer
  40     */
  41    public $Priority = 3;
  42
  43    /**
  44     * The character set of the message.
  45     * @type string
  46     */
  47    public $CharSet = 'iso-8859-1';
  48
  49    /**
  50     * The MIME Content-type of the message.
  51     * @type string
  52     */
  53    public $ContentType = 'text/plain';
  54
  55    /**
  56     * The message encoding.
  57     * Options: "8bit", "7bit", "binary", "base64", and "quoted-printable".
  58     * @type string
  59     */
  60    public $Encoding = '8bit';
  61
  62    /**
  63     * Holds the most recent mailer error message.
  64     * @type string
  65     */
  66    public $ErrorInfo = '';
  67
  68    /**
  69     * The From email address for the message.
  70     * @type string
  71     */
  72    public $From = 'root@localhost';
  73
  74    /**
  75     * The From name of the message.
  76     * @type string
  77     */
  78    public $FromName = 'Root User';
  79
  80    /**
  81     * The Sender email (Return-Path) of the message.
  82     * If not empty, will be sent via -f to sendmail or as 'MAIL FROM' in smtp mode.
  83     * @type string
  84     */
  85    public $Sender = '';
  86
  87    /**
  88     * The Return-Path of the message.
  89     * If empty, it will be set to either From or Sender.
  90     * @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
  94     */
  95    public $ReturnPath = '';
  96
  97    /**
  98     * The Subject of the message.
  99     * @type string
 100     */
 101    public $Subject = '';
 102
 103    /**
 104     * An HTML or plain text message body.
 105     * If HTML then call isHTML(true).
 106     * @type string
 107     */
 108    public $Body = '';
 109
 110    /**
 111     * The plain-text message body.
 112     * This body can be read by mail clients that do not have HTML email
 113     * capability such as mutt & Eudora.
 114     * Clients that can read HTML will view the normal Body.
 115     * @type string
 116     */
 117    public $AltBody = '';
 118
 119    /**
 120     * An iCal message part body.
 121     * Only supported in simple alt or alt_inline message types
 122     * To generate iCal events, use the bundled extras/EasyPeasyICS.php class or iCalcreator
 123     * @link http://sprain.ch/blog/downloads/php-class-easypeasyics-create-ical-files-with-php/
 124     * @link http://kigkonsult.se/iCalcreator/
 125     * @type string
 126     */
 127    public $Ical = '';
 128
 129    /**
 130     * The complete compiled MIME message body.
 131     * @access protected
 132     * @type string
 133     */
 134    protected $MIMEBody = '';
 135
 136    /**
 137     * The complete compiled MIME message headers.
 138     * @type string
 139     * @access protected
 140     */
 141    protected $MIMEHeader = '';
 142
 143    /**
 144     * Extra headers that createHeader() doesn't fold in.
 145     * @type string
 146     * @access protected
 147     */
 148    protected $mailHeader = '';
 149
 150    /**
 151     * Word-wrap the message body to this number of chars.
 152     * Set to 0 to not wrap. A useful value here is 78, for RFC2822 section 2.1.1 compliance.
 153     * @type integer
 154     */
 155    public $WordWrap = 0;
 156
 157    /**
 158     * Which method to use to send mail.
 159     * Options: "mail", "sendmail", or "smtp".
 160     * @type string
 161     */
 162    public $Mailer = 'mail';
 163
 164    /**
 165     * The path to the sendmail program.
 166     * @type string
 167     */
 168    public $Sendmail = '/usr/sbin/sendmail';
 169
 170    /**
 171     * Whether mail() uses a fully sendmail-compatible MTA.
 172     * One which supports sendmail's "-oi -f" options.
 173     * @type boolean
 174     */
 175    public $UseSendmailOptions = true;
 176
 177    /**
 178     * Path to PHPMailer plugins.
 179     * Useful if the SMTP class is not in the PHP include path.
 180     * @type string
 181     * @deprecated Should not be needed now there is an autoloader.
 182     */
 183    public $PluginDir = '';
 184
 185    /**
 186     * The email address that a reading confirmation should be sent to.
 187     * @type string
 188     */
 189    public $ConfirmReadingTo = '';
 190
 191    /**
 192     * The hostname to use in Message-Id and Received headers
 193     * and as default HELO string.
 194     * If empty, the value returned
 195     * by SERVER_NAME is used or 'localhost.localdomain'.
 196     * @type string
 197     */
 198    public $Hostname = '';
 199
 200    /**
 201     * An ID to be used in the Message-Id header.
 202     * If empty, a unique id will be generated.
 203     * @type string
 204     */
 205    public $MessageID = '';
 206
 207    /**
 208     * The message Date to be used in the Date header.
 209     * If empty, the current date will be added.
 210     * @type string
 211     */
 212    public $MessageDate = '';
 213
 214    /**
 215     * SMTP hosts.
 216     * Either a single hostname or multiple semicolon-delimited hostnames.
 217     * You can also specify a different port
 218     * for each host by using this format: [hostname:port]
 219     * (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").
 222     * Hosts will be tried in order.
 223     * @type string
 224     */
 225    public $Host = 'localhost';
 226
 227    /**
 228     * The default SMTP server port.
 229     * @type integer
 230     * @TODO Why is this needed when the SMTP class takes care of it?
 231     */
 232    public $Port = 25;
 233
 234    /**
 235     * The SMTP HELO of the message.
 236     * Default is $Hostname.
 237     * @type string
 238     * @see PHPMailer::$Hostname
 239     */
 240    public $Helo = '';
 241
 242    /**
 243     * The secure connection prefix.
 244     * Options: "", "ssl" or "tls"
 245     * @type string
 246     */
 247    public $SMTPSecure = '';
 248
 249    /**
 250     * Whether to use SMTP authentication.
 251     * Uses the Username and Password properties.
 252     * @type boolean
 253     * @see PHPMailer::$Username
 254     * @see PHPMailer::$Password
 255     */
 256    public $SMTPAuth = false;
 257
 258    /**
 259     * SMTP username.
 260     * @type string
 261     */
 262    public $Username = '';
 263
 264    /**
 265     * SMTP password.
 266     * @type string
 267     */
 268    public $Password = '';
 269
 270    /**
 271     * SMTP auth type.
 272     * Options are LOGIN (default), PLAIN, NTLM, CRAM-MD5
 273     * @type string
 274     */
 275    public $AuthType = '';
 276
 277    /**
 278     * SMTP realm.
 279     * Used for NTLM auth
 280     * @type string
 281     */
 282    public $Realm = '';
 283
 284    /**
 285     * SMTP workstation.
 286     * Used for NTLM auth
 287     * @type string
 288     */
 289    public $Workstation = '';
 290
 291    /**
 292     * The SMTP server timeout in seconds.
 293     * Default of 5 minutes (300sec) is from RFC2821 section 4.5.3.2
 294     * @type integer
 295     */
 296    public $Timeout = 300;
 297
 298    /**
 299     * SMTP class debug output mode.
 300     * Debug output level.
 301     * Options:
 302     * * `0` No output
 303     * * `1` Commands
 304     * * `2` Data and commands
 305     * * `3` As 2 plus connection status
 306     * * `4` Low-level data output
 307     * @type integer
 308     * @see SMTP::$do_debug
 309     */
 310    public $SMTPDebug = 0;
 311
 312    /**
 313     * How to handle debug output.
 314     * Options:
 315     * * `echo` Output plain-text as-is, appropriate for CLI
 316     * * `html` Output escaped, line breaks converted to `<br>`, appropriate for browser output
 317     * * `error_log` Output to error log as configured in php.ini
 318     *
 319     * Alternatively, you can provide a callable expecting two params: a message string and the debug level:
 320     * <code>
 321     * $mail->Debugoutput = function($str, $level) {echo "debug level $level; message: $str";};
 322     * </code>
 323     * @type string|callable
 324     * @see SMTP::$Debugoutput
 325     */
 326    public $Debugoutput = 'echo';
 327
 328    /**
 329     * Whether to keep SMTP connection open after each message.
 330     * If this is set to true then to close the connection
 331     * requires an explicit call to smtpClose().
 332     * @type boolean
 333     */
 334    public $SMTPKeepAlive = false;
 335
 336    /**
 337     * Whether to split multiple to addresses into multiple messages
 338     * or send them all in one message.
 339     * @type boolean
 340     */
 341    public $SingleTo = false;
 342
 343    /**
 344     * Storage for addresses when SingleTo is enabled.
 345     * @type array
 346     * @TODO This should really not be public
 347     */
 348    public $SingleToArray = array();
 349
 350    /**
 351     * Whether to generate VERP addresses on send.
 352     * Only applicable when sending via SMTP.
 353     * @link http://en.wikipedia.org/wiki/Variable_envelope_return_path
 354     * @link http://www.postfix.org/VERP_README.html Postfix VERP info
 355     * @type boolean
 356     */
 357    public $do_verp = false;
 358
 359    /**
 360     * Whether to allow sending messages with an empty body.
 361     * @type boolean
 362     */
 363    public $AllowEmpty = false;
 364
 365    /**
 366     * The default line ending.
 367     * @note The default remains "\n". We force CRLF where we know
 368     *        it must be used via self::CRLF.
 369     * @type string
 370     */
 371    public $LE = "\n";
 372
 373    /**
 374     * DKIM selector.
 375     * @type string
 376     */
 377    public $DKIM_selector = '';
 378
 379    /**
 380     * DKIM Identity.
 381     * Usually the email address used as the source of the email
 382     * @type string
 383     */
 384    public $DKIM_identity = '';
 385
 386    /**
 387     * DKIM passphrase.
 388     * Used if your key is encrypted.
 389     * @type string
 390     */
 391    public $DKIM_passphrase = '';
 392
 393    /**
 394     * DKIM signing domain name.
 395     * @example 'example.com'
 396     * @type string
 397     */
 398    public $DKIM_domain = '';
 399
 400    /**
 401     * DKIM private key file path.
 402     * @type string
 403     */
 404    public $DKIM_private = '';
 405
 406    /**
 407     * Callback Action function name.
 408     *
 409     * The function that handles the result of the send email action.
 410     * It is called out by send() for each email sent.
 411     *
 412     * Value can be any php callable: http://www.php.net/is_callable
 413     *
 414     * Parameters:
 415     *   boolean $result        result of the send action
 416     *   string  $to            email address of the recipient
 417     *   string  $cc            cc email addresses
 418     *   string  $bcc           bcc email addresses
 419     *   string  $subject       the subject
 420     *   string  $body          the email body
 421     *   string  $from          email address of sender
 422     * @type string
 423     */
 424    public $action_function = '';
 425
 426    /**
 427     * What to put in the X-Mailer header.
 428     * Options: An empty string for PHPMailer default, whitespace for none, or a string to use
 429     * @type string
 430     */
 431    public $XMailer = '';
 432
 433    /**
 434     * An instance of the SMTP sender class.
 435     * @type SMTP
 436     * @access protected
 437     */
 438    protected $smtp = null;
 439
 440    /**
 441     * The array of 'to' addresses.
 442     * @type array
 443     * @access protected
 444     */
 445    protected $to = array();
 446
 447    /**
 448     * The array of 'cc' addresses.
 449     * @type array
 450     * @access protected
 451     */
 452    protected $cc = array();
 453
 454    /**
 455     * The array of 'bcc' addresses.
 456     * @type array
 457     * @access protected
 458     */
 459    protected $bcc = array();
 460
 461    /**
 462     * The array of reply-to names and addresses.
 463     * @type array
 464     * @access protected
 465     */
 466    protected $ReplyTo = array();
 467
 468    /**
 469     * An array of all kinds of addresses.
 470     * Includes all of $to, $cc, $bcc, $replyto
 471     * @type array
 472     * @access protected
 473     */
 474    protected $all_recipients = array();
 475
 476    /**
 477     * The array of attachments.
 478     * @type array
 479     * @access protected
 480     */
 481    protected $attachment = array();
 482
 483    /**
 484     * The array of custom headers.
 485     * @type array
 486     * @access protected
 487     */
 488    protected $CustomHeader = array();
 489
 490    /**
 491     * The most recent Message-ID (including angular brackets).
 492     * @type string
 493     * @access protected
 494     */
 495    protected $lastMessageID = '';
 496
 497    /**
 498     * The message's MIME type.
 499     * @type string
 500     * @access protected
 501     */
 502    protected $message_type = '';
 503
 504    /**
 505     * The array of MIME boundary strings.
 506     * @type array
 507     * @access protected
 508     */
 509    protected $boundary = array();
 510
 511    /**
 512     * The array of available languages.
 513     * @type array
 514     * @access protected
 515     */
 516    protected $language = array();
 517
 518    /**
 519     * The number of errors encountered.
 520     * @type integer
 521     * @access protected
 522     */
 523    protected $error_count = 0;
 524
 525    /**
 526     * The S/MIME certificate file path.
 527     * @type string
 528     * @access protected
 529     */
 530    protected $sign_cert_file = '';
 531
 532    /**
 533     * The S/MIME key file path.
 534     * @type string
 535     * @access protected
 536     */
 537    protected $sign_key_file = '';
 538
 539    /**
 540     * The S/MIME password for the key.
 541     * Used only if the key is encrypted.
 542     * @type string
 543     * @access protected
 544     */
 545    protected $sign_key_pass = '';
 546
 547    /**
 548     * Whether to throw exceptions for errors.
 549     * @type boolean
 550     * @access protected
 551     */
 552    protected $exceptions = false;
 553
 554    /**
 555     * Error severity: message only, continue processing.
 556     */
 557    const STOP_MESSAGE = 0;
 558
 559    /**
 560     * Error severity: message, likely ok to continue processing.
 561     */
 562    const STOP_CONTINUE = 1;
 563
 564    /**
 565     * Error severity: message, plus full stop, critical error reached.
 566     */
 567    const STOP_CRITICAL = 2;
 568
 569    /**
 570     * SMTP RFC standard line ending.
 571     */
 572    const CRLF = "\r\n";
 573
 574    /**
 575     * Constructor.
 576     * @param boolean $exceptions Should we throw external exceptions?
 577     */
 578    public function __construct($exceptions = false)
 579    {
 580        $this->exceptions = (boolean)$exceptions;
 581    }
 582
 583    /**
 584     * Destructor.
 585     */
 586    public function __destruct()
 587    {
 588        if ($this->Mailer == 'smtp') { //close any open SMTP connection nicely
 589            $this->smtpClose();
 590        }
 591    }
 592
 593    /**
 594     * Call mail() in a safe_mode-aware fashion.
 595     * Also, unless sendmail_path points to sendmail (or something that
 596     * claims to be sendmail), don't pass params (not a perfect fix,
 597     * but it will do)
 598     * @param string $to To
 599     * @param string $subject Subject
 600     * @param string $body Message Body
 601     * @param string $header Additional Header(s)
 602     * @param string $params Params
 603     * @access private
 604     * @return boolean
 605     */
 606    private function mailPassthru($to, $subject, $body, $header, $params)
 607    {
 608        //Check overloading of mail function to avoid double-encoding
 609        if (ini_get('mbstring.func_overload') & 1) {
 610            $subject = $this->secureHeader($subject);
 611        } else {
 612            $subject = $this->encodeHeader($this->secureHeader($subject));
 613        }
 614        if (ini_get('safe_mode') || !($this->UseSendmailOptions)) {
 615            $result = @mail($to, $subject, $body, $header);
 616        } else {
 617            $result = @mail($to, $subject, $body, $header, $params);
 618        }
 619        return $result;
 620    }
 621
 622    /**
 623     * Output debugging info via user-defined method.
 624     * Only generates output if SMTP debug output is enabled (@see SMTP::$do_debug).
 625     * @see PHPMailer::$Debugoutput
 626     * @see PHPMailer::$SMTPDebug
 627     * @param string $str
 628     */
 629    protected function edebug($str)
 630    {
 631        if ($this->SMTPDebug <= 0) {
 632            return;
 633        }
 634        //Avoid clash with built-in function names
 635        if (!in_array($this->Debugoutput, array('error_log', 'html', 'echo')) and is_callable($this->Debugoutput)) {
 636            call_user_func($this->Debugoutput, $str, $this->SMTPDebug);
 637            return;
 638        }
 639        switch ($this->Debugoutput) {
 640            case 'error_log':
 641                //Don't output, just log
 642                error_log($str);
 643                break;
 644            case 'html':
 645                //Cleans up output a bit for a better looking, HTML-safe output
 646                echo htmlentities(
 647                    preg_replace('/[\r\n]+/', '', $str),
 648                    ENT_QUOTES,
 649                    'UTF-8'
 650                )
 651                . "<br>\n";
 652                break;
 653            case 'echo':
 654            default:
 655                //Normalize line breaks
 656                $str = preg_replace('/(\r\n|\r|\n)/ms', "\n", $str);
 657                echo gmdate('Y-m-d H:i:s') . "\t" . str_replace(
 658                    "\n",
 659                    "\n                   \t                  ",
 660                    trim($str)
 661                ) . "\n";
 662        }
 663    }
 664
 665    /**
 666     * Sets message type to HTML or plain.
 667     * @param boolean $isHtml True for HTML mode.
 668     * @return void
 669     */
 670    public function isHTML($isHtml = true)
 671    {
 672        if ($isHtml) {
 673            $this->ContentType = 'text/html';
 674        } else {
 675            $this->ContentType = 'text/plain';
 676        }
 677    }
 678
 679    /**
 680     * Send messages using SMTP.
 681     * @return void
 682     */
 683    public function isSMTP()
 684    {
 685        $this->Mailer = 'smtp';
 686    }
 687
 688    /**
 689     * Send messages using PHP's mail() function.
 690     * @return void
 691     */
 692    public function isMail()
 693    {
 694        $this->Mailer = 'mail';
 695    }
 696
 697    /**
 698     * Send messages using $Sendmail.
 699     * @return void
 700     */
 701    public function isSendmail()
 702    {
 703        $ini_sendmail_path = ini_get('sendmail_path');
 704
 705        if (!stristr($ini_sendmail_path, 'sendmail')) {
 706            $this->Sendmail = '/usr/sbin/sendmail';
 707        } else {
 708            $this->Sendmail = $ini_sendmail_path;
 709        }
 710        $this->Mailer = 'sendmail';
 711    }
 712
 713    /**
 714     * Send messages using qmail.
 715     * @return void
 716     */
 717    public function isQmail()
 718    {
 719        $ini_sendmail_path = ini_get('sendmail_path');
 720
 721        if (!stristr($ini_sendmail_path, 'qmail')) {
 722            $this->Sendmail = '/var/qmail/bin/qmail-inject';
 723        } else {
 724            $this->Sendmail = $ini_sendmail_path;
 725        }
 726        $this->Mailer = 'qmail';
 727    }
 728
 729    /**
 730     * Add a "To" address.
 731     * @param string $address
 732     * @param string $name
 733     * @return boolean true on success, false if address already used
 734     */
 735    public function addAddress($address, $name = '')
 736    {
 737        return $this->addAnAddress('to', $address, $name);
 738    }
 739
 740    /**
 741     * Add a "CC" address.
 742     * @note: This function works with the SMTP mailer on win32, not with the "mail" mailer.
 743     * @param string $address
 744     * @param string $name
 745     * @return boolean true on success, false if address already used
 746     */
 747    public function addCC($address, $name = '')
 748    {
 749        return $this->addAnAddress('cc', $address, $name);
 750    }
 751
 752    /**
 753     * Add a "BCC" address.
 754     * @note: This function works with the SMTP mailer on win32, not with the "mail" mailer.
 755     * @param string $address
 756     * @param string $name
 757     * @return boolean true on success, false if address already used
 758     */
 759    public function addBCC($address, $name = '')
 760    {
 761        return $this->addAnAddress('bcc', $address, $name);
 762    }
 763
 764    /**
 765     * Add a "Reply-to" address.
 766     * @param string $address
 767     * @param string $name
 768     * @return boolean
 769     */
 770    public function addReplyTo($address, $name = '')
 771    {
 772        return $this->addAnAddress('Reply-To', $address, $name);
 773    }
 774
 775    /**
 776     * Add an address to one of the recipient arrays.
 777     * Addresses that have been added already return false, but do not throw exceptions
 778     * @param string $kind One of 'to', 'cc', 'bcc', 'ReplyTo'
 779     * @param string $address The email address to send to
 780     * @param string $name
 781     * @throws phpmailerException
 782     * @return boolean true on success, false if address already used or invalid in some way
 783     * @access protected
 784     */
 785    protected function addAnAddress($kind, $address, $name = '')
 786    {
 787        if (!preg_match('/^(to|cc|bcc|Reply-To)$/', $kind)) {
 788            $this->setError($this->lang('Invalid recipient array') . ': ' . $kind);
 789            $this->edebug($this->lang('Invalid recipient array') . ': ' . $kind);
 790            if ($this->exceptions) {
 791                throw new phpmailerException('Invalid recipient array: ' . $kind);
 792            }
 793            return false;
 794        }
 795        $address = trim($address);
 796        $name = trim(preg_replace('/[\r\n]+/', '', $name)); //Strip breaks and trim
 797        if (!$this->validateAddress($address)) {
 798            $this->setError($this->lang('invalid_address') . ': ' . $address);
 799            $this->edebug($this->lang('invalid_address') . ': ' . $address);
 800            if ($this->exceptions) {
 801                throw new phpmailerException($this->lang('invalid_address') . ': ' . $address);
 802            }
 803            return false;
 804        }
 805        if ($kind != 'Reply-To') {
 806            if (!isset($this->all_recipients[strtolower($address)])) {
 807                array_push($this->$kind, array($address, $name));
 808                $this->all_recipients[strtolower($address)] = true;
 809                return true;
 810            }
 811        } else {
 812            if (!array_key_exists(strtolower($address), $this->ReplyTo)) {
 813                $this->ReplyTo[strtolower($address)] = array($address, $name);
 814                return true;
 815            }
 816        }
 817        return false;
 818    }
 819
 820    /**
 821     * Set the From and FromName properties.
 822     * @param string $address
 823     * @param string $name
 824     * @param boolean $auto Whether to also set the Sender address, defaults to true
 825     * @throws phpmailerException
 826     * @return boolean
 827     */
 828    public function setFrom($address, $name = '', $auto = true)
 829    {
 830        $address = trim($address);
 831        $name = trim(preg_replace('/[\r\n]+/', '', $name)); //Strip breaks and trim
 832        if (!$this->validateAddress($address)) {
 833            $this->setError($this->lang('invalid_address') . ': ' . $address);
 834            $this->edebug($this->lang('invalid_address') . ': ' . $address);
 835            if ($this->exceptions) {
 836                throw new phpmailerException($this->lang('invalid_address') . ': ' . $address);
 837            }
 838            return false;
 839        }
 840        $this->From = $address;
 841        $this->FromName = $name;
 842        if ($auto) {
 843            if (empty($this->Sender)) {
 844                $this->Sender = $address;
 845            }
 846        }
 847        return true;
 848    }
 849
 850    /**
 851     * Return the Message-ID header of the last email.
 852     * Technically this is the value from the last time the headers were created,
 853     * but it's also the message ID of the last sent message except in
 854     * pathological cases.
 855     * @return string
 856     */
 857    public function getLastMessageID()
 858    {
 859        return $this->lastMessageID;
 860    }
 861
 862    /**
 863     * Check that a string looks like an email address.
 864     * @param string $address The email address to check
 865     * @param string $patternselect A selector for the validation pattern to use :
 866     * * `auto` Pick strictest one automatically;
 867     * * `pcre8` Use the squiloople.com pattern, requires PCRE > 8.0, PHP >= 5.3.2, 5.2.14;
 868     * * `pcre` Use old PCRE implementation;
 869     * * `php` Use PHP built-in FILTER_VALIDATE_EMAIL; same as pcre8 but does not allow 'dotless' domains;
 870     * * `html5` Use the pattern given by the HTML5 spec for 'email' type form input elements.
 871     * * `noregex` Don't use a regex: super fast, really dumb.
 872     * @return boolean
 873     * @static
 874     * @access public
 875     */
 876    public static function validateAddress($address, $patternselect = 'auto')
 877    {
 878        if (!$patternselect or $patternselect == 'auto') {
 879            //Check this constant first so it works when extension_loaded() is disabled by safe mode
 880            //Constant was added in PHP 5.2.4
 881            if (defined('PCRE_VERSION')) {
 882                //This pattern can get stuck in a recursive loop in PCRE <= 8.0.2
 883                if (version_compare(PCRE_VERSION, '8.0.3') >= 0) {
 884                    $patternselect = 'pcre8';
 885                } else {
 886                    $patternselect = 'pcre';
 887                }
 888            } elseif (function_exists('extension_loaded') and extension_loaded('pcre')) {
 889                //Fall back to older PCRE
 890                $patternselect = 'pcre';
 891            } else {
 892                //Filter_var appeared in PHP 5.2.0 and does not require the PCRE extension
 893                if (version_compare(PHP_VERSION, '5.2.0') >= 0) {
 894                    $patternselect = 'php';
 895                } else {
 896                    $patternselect = 'noregex';
 897                }
 898            }
 899        }
 900        switch ($patternselect) {
 901            case 'pcre8':
 902                /**
 903                 * Uses the same RFC5322 regex on which FILTER_VALIDATE_EMAIL is based, but allows dotless domains.
 904                 * @link http://squiloople.com/2009/12/20/email-address-validation/
 905                 * @copyright 2009-2010 Michael Rushton
 906                 * Feel free to use and redistribute this code. But please keep this copyright notice.
 907                 */
 908                return (boolean)preg_match(
 909                    '/^(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){255,})(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){65,}@)' .
 910                    '((?>(?>(?>((?>(?>(?>\x0D\x0A)?[\t ])+|(?>[\t ]*\x0D\x0A)?[\t ]+)?)(\((?>(?2)' .
 911                    '(?>[\x01-\x08\x0B\x0C\x0E-\'*-\[\]-\x7F]|\\\[\x00-\x7F]|(?3)))*(?2)\)))+(?2))|(?2))?)' .
 912                    '([!#-\'*+\/-9=?^-~-]+|"(?>(?2)(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\x7F]))*' .
 913                    '(?2)")(?>(?1)\.(?1)(?4))*(?1)@(?!(?1)[a-z0-9-]{64,})(?1)(?>([a-z0-9](?>[a-z0-9-]*[a-z0-9])?)' .
 914                    '(?>(?1)\.(?!(?1)[a-z0-9-]{64,})(?1)(?5)){0,126}|\[(?:(?>IPv6:(?>([a-f0-9]{1,4})(?>:(?6)){7}' .
 915                    '|(?!(?:.*[a-f0-9][:\]]){8,})((?6)(?>:(?6)){0,6})?::(?7)?))|(?>(?>IPv6:(?>(?6)(?>:(?6)){5}:' .
 916                    '|(?!(?:.*[a-f0-9]:){6,})(?8)?::(?>((?6)(?>:(?6)){0,4}):)?))?(25[0-5]|2[0-4][0-9]|1[0-9]{2}' .
 917                    '|[1-9]?[0-9])(?>\.(?9)){3}))\])(?1)$/isD',
 918                    $address
 919                );
 920            case 'pcre':
 921                //An older regex that doesn't need a recent PCRE
 922                return (boolean)preg_match(
 923                    '/^(?!(?>"?(?>\\\[ -~]|[^"])"?){255,})(?!(?>"?(?>\\\[ -~]|[^"])"?){65,}@)(?>' .
 924                    '[!#-\'*+\/-9=?^-~-]+|"(?>(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\xFF]))*")' .
 925                    '(?>\.(?>[!#-\'*+\/-9=?^-~-]+|"(?>(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\xFF]))*"))*' .
 926                    '@(?>(?![a-z0-9-]{64,})(?>[a-z0-9](?>[a-z0-9-]*[a-z0-9])?)(?>\.(?![a-z0-9-]{64,})' .
 927                    '(?>[a-z0-9](?>[a-z0-9-]*[a-z0-9])?)){0,126}|\[(?:(?>IPv6:(?>(?>[a-f0-9]{1,4})(?>:' .
 928                    '[a-f0-9]{1,4}){7}|(?!(?:.*[a-f0-9][:\]]){8,})(?>[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,6})?' .
 929                    '::(?>[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,6})?))|(?>(?>IPv6:(?>[a-f0-9]{1,4}(?>:' .
 930                    '[a-f0-9]{1,4}){5}:|(?!(?:.*[a-f0-9]:){6,})(?>[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,4})?' .
 931                    '::(?>(?:[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,4}):)?))?(?>25[0-5]|2[0-4][0-9]|1[0-9]{2}' .
 932                    '|[1-9]?[0-9])(?>\.(?>25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}))\])$/isD',
 933                    $address
 934                );
 935            case 'html5':
 936                /**
 937                 * This is the pattern used in the HTML5 spec for validation of 'email' type form input elements.
 938                 * @link http://www.whatwg.org/specs/web-apps/current-work/#e-mail-state-(type=email)
 939                 */
 940                return (boolean)preg_match(
 941                    '/^[a-zA-Z0-9.!#$%&\'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}' .
 942                    '[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/sD',
 943                    $address
 944                );
 945            case 'noregex':
 946                //No PCRE! Do something _very_ approximate!
 947                //Check the address is 3 chars or longer and contains an @ that's not the first or last char
 948                return (strlen($address) >= 3
 949                    and strpos($address, '@') >= 1
 950                    and strpos($address, '@') != strlen($address) - 1);
 951            case 'php':
 952            default:
 953                return (boolean)filter_var($address, FILTER_VALIDATE_EMAIL);
 954        }
 955    }
 956
 957    /**
 958     * Create a message and send it.
 959     * Uses the sending method specified by $Mailer.
 960     * @throws phpmailerException
 961     * @return boolean false on error - See the ErrorInfo property for details of the error.
 962     */
 963    public function send()
 964    {
 965        try {
 966            if (!$this->preSend()) {
 967                return false;
 968            }
 969            return $this->postSend();
 970        } catch (phpmailerException $exc) {
 971            $this->mailHeader = '';
 972            $this->setError($exc->getMessage());
 973            if ($this->exceptions) {
 974                throw $exc;
 975            }
 976            return false;
 977        }
 978    }
 979
 980    /**
 981     * Prepare a message for sending.
 982     * @throws phpmailerException
 983     * @return boolean
 984     */
 985    public function preSend()
 986    {
 987        try {
 988            $this->mailHeader = '';
 989            if ((count($this->to) + count($this->cc) + count($this->bcc)) < 1) {
 990                throw new phpmailerException($this->lang('provide_address'), self::STOP_CRITICAL);
 991            }
 992
 993            // Set whether the message is multipart/alternative
 994            if (!empty($this->AltBody)) {
 995                $this->ContentType = 'multipart/alternative';
 996            }
 997
 998            $this->error_count = 0; // reset errors
 999            $this->setMessageType();
1000            // Refuse to send an empty message unless we are specifically allowing it
1001            if (!$this->AllowEmpty and empty($this->Body)) {
1002                throw new phpmailerException($this->lang('empty_message'), self::STOP_CRITICAL);
1003            }
1004
1005            $this->MIMEHeader = $this->createHeader();
1006            $this->MIMEBody = $this->createBody();
1007
1008            // To capture the complete message when using mail(), create
1009            // an extra header list which createHeader() doesn't fold in
1010            if ($this->Mailer == 'mail') {
1011                if (count($this->to) > 0) {
1012                    $this->mailHeader .= $this->addrAppend('To', $this->to);
1013                } else {
1014                    $this->mailHeader .= $this->headerLine('To', 'undisclosed-recipients:;');
1015                }
1016                $this->mailHeader .= $this->headerLine(
1017                    'Subject',
1018                    $this->encodeHeader($this->secureHeader(trim($this->Subject)))
1019                );
1020            }
1021
1022            // Sign with DKIM if enabled
1023            if (!empty($this->DKIM_domain)
1024                && !empty($this->DKIM_private)
1025                && !empty($this->DKIM_selector)
1026                && file_exists($this->DKIM_private)) {
1027                $header_dkim = $this->DKIM_Add(
1028                    $this->MIMEHeader . $this->mailHeader,
1029                    $this->encodeHeader($this->secureHeader($this->Subject)),
1030                    $this->MIMEBody
1031                );
1032                $this->MIMEHeader = rtrim($this->MIMEHeader, "\r\n ") . self::CRLF .
1033                    str_replace("\r\n", "\n", $header_dkim) . self::CRLF;
1034            }
1035            return true;
1036
1037        } catch (phpmailerException $exc) {
1038            $this->setError($exc->getMessage());
1039            if ($this->exceptions) {
1040                throw $exc;
1041            }
1042            return false;
1043        }
1044    }
1045
1046    /**
1047     * Actually send a message.
1048     * Send the email via the selected mechanism
1049     * @throws phpmailerException
1050     * @return boolean
1051     */
1052    public function postSend()
1053    {
1054        try {
1055            // Choose the mailer and send through it
1056            switch ($this->Mailer) {
1057                case 'sendmail':
1058                case 'qmail':
1059                    return $this->sendmailSend($this->MIMEHeader, $this->MIMEBody);
1060                case 'smtp':
1061                    return $this->smtpSend($this->MIMEHeader, $this->MIMEBody);
1062                case 'mail':
1063                    return $this->mailSend($this->MIMEHeader, $this->MIMEBody);
1064                default:
1065                    $sendMethod = $this->Mailer.'Send';
1066                    if (method_exists($this, $sendMethod)) {
1067                        return $this->$sendMethod($this->MIMEHeader, $this->MIMEBody);
1068                    }
1069
1070                    return $this->mailSend($this->MIMEHeader, $this->MIMEBody);
1071            }
1072        } catch (phpmailerException $exc) {
1073            $this->setError($exc->getMessage());
1074            $this->edebug($exc->getMessage());
1075            if ($this->exceptions) {
1076                throw $exc;
1077            }
1078        }
1079        return false;
1080    }
1081
1082    /**
1083     * Send mail using the $Sendmail program.
1084     * @param string $header The message headers
1085     * @param string $body The message body
1086     * @see PHPMailer::$Sendmail
1087     * @throws phpmailerException
1088     * @access protected
1089     * @return boolean
1090     */
1091    protected function sendmailSend($header, $body)
1092    {
1093        if ($this->Sender != '') {
1094            if ($this->Mailer == 'qmail') {
1095                $sendmail = sprintf('%s -f%s', escapeshellcmd($this->Sendmail), escapeshellarg($this->Sender));
1096            } else {
1097                $sendmail = sprintf('%s -oi -f%s -t', escapeshellcmd($this->Sendmail), escapeshellarg($this->Sender));
1098            }
1099        } else {
1100            if ($this->Mailer == 'qmail') {
1101                $sendmail = sprintf('%s', escapeshellcmd($this->Sendmail));
1102            } else {
1103                $sendmail = sprintf('%s -oi -t', escapeshellcmd($this->Sendmail));
1104            }
1105        }
1106        if ($this->SingleTo) {
1107            foreach ($this->SingleToArray as $toAddr) {
1108                if (!@$mail = popen($sendmail, 'w')) {
1109                    throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
1110                }
1111                fputs($mail, 'To: ' . $toAddr . "\n");
1112                fputs($mail, $header);
1113                fputs($mail, $body);
1114                $result = pclose($mail);
1115                $this->doCallback(
1116                    ($result == 0),
1117                    array($toAddr),
1118                    $this->cc,
1119                    $this->bcc,
1120                    $this->Subject,
1121                    $body,
1122                    $this->From
1123                );
1124                if ($result != 0) {
1125                    throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
1126                }
1127            }
1128        } else {
1129            if (!@$mail = popen($sendmail, 'w')) {
1130                throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
1131            }
1132            fputs($mail, $header);
1133            fputs($mail, $body);
1134            $result = pclose($mail);
1135            $this->doCallback(($result == 0), $this->to, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
1136            if ($result != 0) {
1137                throw new phpmailerException($this->lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
1138            }
1139        }
1140        return true;
1141    }
1142
1143    /**
1144     * Send mail using the PHP mail() function.
1145     * @param string $header The message headers
1146     * @param string $body The message body
1147     * @link http://www.php.net/manual/en/book.mail.php
1148     * @throws phpmailerException
1149     * @access protected
1150     * @return boolean
1151     */
1152    protected function mailSend($header, $body)
1153    {
1154        $toArr = array();
1155        foreach ($this->to as $toaddr) {
1156            $toArr[] = $this->addrFormat($toaddr);
1157        }
1158        $to = implode(', ', $toArr);
1159
1160        if (empty($this->Sender)) {
1161            $params = ' ';
1162        } else {
1163            $params = sprintf('-f%s', $this->Sender);
1164        }
1165        if ($this->Sender != '' and !ini_get('safe_mode')) {
1166            $old_from = ini_get('sendmail_from');
1167            ini_set('sendmail_from', $this->Sender);
1168        }
1169        $result = false;
1170        if ($this->SingleTo && count($toArr) > 1) {
1171            foreach ($toArr as $toAddr) {
1172                $result = $this->mailPassthru($toAddr, $this->Subject, $body, $header, $params);
1173                $this->doCallback($result, array($toAddr), $this->cc, $this->bcc, $this->Subject, $body, $this->From);
1174            }
1175        } else {
1176            $result = $this->mailPassthru($to, $this->Subject, $body, $header, $params);
1177            $this->doCallback($result, $this->to, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
1178        }
1179        if (isset($old_from)) {
1180            ini_set('sendmail_from', $old_from);
1181        }
1182        if (!$result) {
1183            throw new phpmailerException($this->lang('instantiate'), self::STOP_CRITICAL);
1184        }
1185        return true;
1186    }
1187
1188    /**
1189     * Get an instance to use for SMTP operations.
1190     * Override this function to load your own SMTP implementation
1191     * @return SMTP
1192     */
1193    public function getSMTPInstance()
1194    {
1195        if (!is_object($this->smtp)) {
1196            $this->smtp = new SMTP;
1197        }
1198        return $this->smtp;
1199    }
1200
1201    /**
1202     * Send mail via SMTP.
1203     * Returns false if there is a bad MAIL FROM, RCPT, or DATA input.
1204     * Uses the PHPMailerSMTP class by default.
1205     * @see PHPMailer::getSMTPInstance() to use a different class.
1206     * @param string $header The message headers
1207     * @param string $body The message body
1208     * @throws phpmailerException
1209     * @uses SMTP
1210     * @access protected
1211     * @return boolean
1212     */
1213    protected function smtpSend($header, $body)
1214    {
1215        $bad_rcpt = array();
1216
1217        if (!$this->smtpConnect()) {
1218            throw new phpmailerException($this->lang('smtp_connect_failed'), self::STOP_CRITICAL);
1219        }
1220        $smtp_from = ($this->Sender == '') ? $this->From : $this->Sender;
1221        if (!$this->smtp->mail($smtp_from)) {
1222            $this->setError($this->lang('from_failed') . $smtp_from . ' : ' . implode(',', $this->smtp->getError()));
1223            throw new phpmailerException($this->ErrorInfo, self::STOP_CRITICAL);
1224        }
1225
1226        // Attempt to send to all recipients
1227        foreach ($this->to as $to) {
1228            if (!$this->smtp->recipient($to[0])) {
1229                $bad_rcpt[] = $to[0];
1230                $isSent = false;
1231            } else {
1232                $isSent = true;
1233            }
1234            $this->doCallback($isSent, array($to[0]), array(), array(), $this->Subject, $body, $this->From);
1235        }
1236        foreach ($this->cc as $cc) {
1237            if (!$this->smtp->recipient($cc[0])) {
1238                $bad_rcpt[] = $cc[0];
1239                $isSent = false;
1240            } else {
1241                $isSent = true;
1242            }
1243            $this->doCallback($isSent, array(), array($cc[0]), array(), $this->Subject, $body, $this->From);
1244        }
1245        foreach ($this->bcc as $bcc) {
1246            if (!$this->smtp->recipient($bcc[0])) {
1247                $bad_rcpt[] = $bcc[0];
1248                $isSent = false;
1249            } else {
1250                $isSent = true;
1251            }
1252            $this->doCallback($isSent, array(), array(), array($bcc[0]), $this->Subject, $body, $this->From);
1253        }
1254
1255        // Only send the DATA command if we have viable recipients
1256        if ((count($this->all_recipients) > count($bad_rcpt)) and !$this->smtp->data($header . $body)) {
1257            throw new phpmailerException($this->lang('data_not_accepted'), self::STOP_CRITICAL);
1258        }
1259        if ($this->SMTPKeepAlive) {
1260            $this->smtp->reset();
1261        } else {
1262            $this->smtp->quit();
1263            $this->smtp->close();
1264        }
1265        if (count($bad_rcpt) > 0) { // Create error message for any bad addresses
1266            throw new phpmailerException(
1267                $this->lang('recipients_failed') . implode(', ', $bad_rcpt),
1268                self::STOP_CONTINUE
1269            );
1270        }
1271        return true;
1272    }
1273
1274    /**
1275     * Initiate a connection to an SMTP server.
1276     * Returns false if the operation failed.
1277     * @param array $options An array of options compatible with stream_context_create()
1278     * @uses SMTP
1279     * @access public
1280     * @throws phpmailerException
1281     * @return boolean
1282     */
1283    public function smtpConnect($options = array())
1284    {
1285        if (is_null($this->smtp)) {
1286            $this->smtp = $this->getSMTPInstance();
1287        }
1288
1289        // Already connected?
1290        if ($this->smtp->connected()) {
1291            return true;
1292        }
1293
1294        $this->smtp->setTimeout($this->Timeout);
1295        $this->smtp->setDebugLevel($this->SMTPDebug);
1296        $this->smtp->setDebugOutput($this->Debugoutput);
1297        $this->smtp->setVerp($this->do_verp);
1298        $hosts = explode(';', $this->Host);
1299        $lastexception = null;
1300
1301        foreach ($hosts as $hostentry) {
1302            $hostinfo = array();
1303            if (!preg_match('/^((ssl|tls):\/\/)*([a-zA-Z0-9\.-]*):?([0-9]*)$/', trim($hostentry), $hostinfo)) {
1304                // Not a valid host entry
1305                continue;
1306            }
1307            // $hostinfo[2]: optional ssl or tls prefix
1308            // $hostinfo[3]: the hostname
1309            // $hostinfo[4]: optional port number
1310            // The host string prefix can temporarily override the current setting for SMTPSecure
1311            // If it's not specified, the default value is used
1312            $prefix = '';
1313            $tls = ($this->SMTPSecure == 'tls');
1314            if ($hostinfo[2] == 'ssl' or ($hostinfo[2] == '' and $this->SMTPSecure == 'ssl')) {
1315                $prefix = 'ssl://';
1316                $tls = false; // Can't have SSL and TLS at once
1317            } elseif ($hostinfo[2] == 'tls') {
1318                $tls = true;
1319                // tls doesn't use a prefix
1320            }
1321            $host = $hostinfo[3];
1322            $port = $this->Port;
1323            $tport = (integer)$hostinfo[4];
1324            if ($tport > 0 and $tport < 65536) {
1325                $port = $tport;
1326            }
1327            if ($this->smtp->connect($prefix . $host, $port, $this->Timeout, $options)) {
1328                try {
1329                    if ($this->Helo) {
1330                        $hello = $this->Helo;
1331                    } else {
1332                        $hello = $this->serverHostname();
1333                    }
1334                    $this->smtp->hello($hello);
1335
1336                    if ($tls) {
1337                        if (!$this->smtp->startTLS()) {
1338                            throw new phpmailerException($this->lang('connect_host'));
1339                        }
1340                        // We must resend HELO after tls negotiation
1341                        $this->smtp->hello($hello);
1342                    }
1343                    if ($this->SMTPAuth) {
1344                        if (!$this->smtp->authenticate(
1345                            $this->Username,
1346                            $this->Password,
1347                            $this->AuthType,
1348                            $this->Realm,
1349                            $this->Workstation
1350                        )
1351                        ) {
1352                            throw new phpmailerException($this->lang('authenticate'));
1353                        }
1354                    }
1355                    return true;
1356                } catch (phpmailerException $exc) {
1357                    $lastexception = $exc;
1358                    // We must have connected, but then failed TLS or Auth, so close connection nicely
1359                    $this->smtp->quit();
1360                }
1361            }
1362        }
1363        // If we get here, all connection attempts have failed, so close connection hard
1364        $this->smtp->close();
1365        // As we've caught all exceptions, just report whatever the last one was
1366        if ($this->exceptions and !is_null($lastexception)) {
1367            throw $lastexception;
1368        }
1369        return false;
1370    }
1371
1372    /**
1373     * Close the active SMTP session if one exists.
1374     * @return void
1375     */
1376    public function smtpClose()
1377    {
1378        if ($this->smtp !== null) {
1379            if ($this->smtp->connected()) {
1380                $this->smtp->quit();
1381                $this->smtp->close();
1382            }
1383        }
1384    }
1385
1386    /**
1387     * Set the language for error messages.
1388     * Returns false if it cannot load the language file.
1389     * The default language is English.
1390     * @param string $langcode ISO 639-1 2-character language code (e.g. French is "fr")
1391     * @param string $lang_path Path to the language file directory, with trailing separator (slash)
1392     * @return boolean
1393     * @access public
1394     */
1395    public function setLanguage($langcode = 'en', $lang_path = '')
1396    {
1397        // Define full set of translatable strings in English
1398        $PHPMAILER_LANG = array(
1399            'authenticate' => 'SMTP Error: Could not authenticate.',
1400            'connect_host' => 'SMTP Error: Could not connect to SMTP host.',
1401            'data_not_accepted' => 'SMTP Error: data not accepted.',
1402            'empty_message' => 'Message body empty',
1403            'encoding' => 'Unknown encoding: ',
1404            'execute' => 'Could not execute: ',
1405            'file_access' => 'Could not access file: ',
1406            'file_open' => 'File Error: Could not open file: ',
1407            'from_failed' => 'The following From address failed: ',
1408            'instantiate' => 'Could not instantiate mail function.',
1409            'invalid_address' => 'Invalid address',
1410            'mailer_not_supported' => ' mailer is not supported.',
1411            'provide_address' => 'You must provide at least one recipient email address.',
1412            'recipients_failed' => 'SMTP Error: The following recipients failed: ',
1413            'signing' => 'Signing Error: ',
1414            'smtp_connect_failed' => 'SMTP connect() failed.',
1415            'smtp_error' => 'SMTP server error: ',
1416            'variable_set' => 'Cannot set or reset variable: '
1417        );
1418        if (empty($lang_path)) {
1419            // Calculate an absolute path so it can work if CWD is not here
1420            $lang_path = dirname(__FILE__). DIRECTORY_SEPARATOR . 'language'. DIRECTORY_SEPARATOR;
1421        }
1422        $foundlang = true;
1423        $lang_file = $lang_path . 'phpmailer.lang-' . $langcode . '.php';
1424        if ($langcode != 'en') { // There is no English translation file
1425            // Make sure language file path is readable
1426            if (!is_readable($lang_file)) {
1427                $foundlang = false;
1428            } else {
1429                // Overwrite language-specific strings.
1430                // This way we'll never have missing translations.
1431                $foundlang = include $lang_file;
1432            }
1433        }
1434        $this->language = $PHPMAILER_LANG;
1435        return (boolean)$foundlang; // Returns false if language not found
1436    }
1437
1438    /**
1439     * Get the array of strings for the current language.
1440     * @return array
1441     */
1442    public function getTranslations()
1443    {
1444        return $this->language;
1445    }
1446
1447    /**
1448     * Create recipient headers.
1449     * @access public
1450     * @param string $type
1451     * @param array $addr An array of recipient,
1452     * where each recipient is a 2-element indexed array with element 0 containing an address
1453     * and element 1 containing a name, like:
1454     * array(array('joe@example.com', 'Joe User'), array('zoe@example.com', 'Zoe User'))
1455     * @return string
1456     */
1457    public function addrAppend($type, $addr)
1458    {
1459        $addresses = array();
1460        foreach ($addr as $address) {
1461            $addresses[] = $this->addrFormat($address);
1462        }
1463        return $type . ': ' . implode(', ', $addresses) . $this->LE;
1464    }
1465
1466    /**
1467     * Format an address for use in a message header.
1468     * @access public
1469     * @param array $addr A 2-element indexed array, element 0 containing an address, element 1 containing a name
1470     *      like array('joe@example.com', 'Joe User')
1471     * @return string
1472     */
1473    public function addrFormat($addr)
1474    {
1475        if (empty($addr[1])) { // No name provided
1476            return $this->secureHeader($addr[0]);
1477        } else {
1478            return $this->encodeHeader($this->secureHeader($addr[1]), 'phrase') . ' <' . $this->secureHeader(
1479                $addr[0]
1480            ) . '>';
1481        }
1482    }
1483
1484    /**
1485     * Word-wrap message.
1486     * For use with mailers that do not automatically perform wrapping
1487     * and for quoted-printable encoded messages.
1488     * Original written by philippe.
1489     * @param string $message The message to wrap
1490     * @param integer $length The line length to wrap to
1491     * @param boolean $qp_mode Whether to run in Quoted-Printable mode
1492     * @access public
1493     * @return string
1494     */
1495    public function wrapText($message, $length, $qp_mode = false)
1496    {
1497        $soft_break = ($qp_mode) ? sprintf(' =%s', $this->LE) : $this->LE;
1498        // If utf-8 encoding is used, we will need to make sure we don't
1499        // split multibyte characters when we wrap
1500        $is_utf8 = (strtolower($this->CharSet) == 'utf-8');
1501        $lelen = strlen($this->LE);
1502        $crlflen = strlen(self::CRLF);
1503
1504        $message = $this->fixEOL($message);
1505        if (substr($message, -$lelen) == $this->LE) {
1506            $message = substr($message, 0, -$lelen);
1507        }
1508
1509        $line = explode($this->LE, $message); // Magic. We know fixEOL uses $LE
1510        $message = '';
1511        for ($i = 0; $i < count($line); $i++) {
1512            $line_part = explode(' ', $line[$i]);
1513            $buf = '';
1514            for ($e = 0; $e < count($line_part); $e++) {
1515                $word = $line_part[$e];
1516                if ($qp_mode and (strlen($word) > $length)) {
1517                    $space_left = $length - strlen($buf) - $crlflen;
1518                    if ($e != 0) {
1519                        if ($space_left > 20) {
1520                            $len = $space_left;
1521                            if ($is_utf8) {
1522                                $len = $this->utf8CharBoundary($word, $len);
1523                            } elseif (substr($word, $len - 1, 1) == '=') {
1524                                $len--;
1525                            } elseif (substr($word, $len - 2, 1) == '=') {
1526                                $len -= 2;
1527                            }
1528                            $part = substr($word, 0, $len);
1529                            $word = substr($word, $len);
1530                            $buf .= ' ' . $part;
1531                            $message .= $buf . sprintf('=%s', self::CRLF);
1532                        } else {
1533                            $message .= $buf . $soft_break;
1534                        }
1535                        $buf = '';
1536                    }
1537                    while (strlen($word) > 0) {
1538                        if ($length <= 0) {
1539                            break;
1540                        }
1541                        $len = $length;
1542                        if ($is_utf8) {
1543                            $len = $this->utf8CharBoundary($word, $len);
1544                        } elseif (substr($word, $len - 1, 1) == '=') {
1545                            $len--;
1546                        } elseif (substr($word, $len - 2, 1) == '=') {
1547                            $len -= 2;
1548                        }
1549                        $part = substr($word, 0, $len);
1550                        $word = substr($word, $len);
1551
1552                        if (strlen($word) > 0) {
1553                            $message .= $part . sprintf('=%s', self::CRLF);
1554                        } else {
1555                            $buf = $part;
1556                        }
1557                    }
1558                } else {
1559                    $buf_o = $buf;
1560                    $buf .= ($e == 0) ? $word : (' ' . $word);
1561
1562                    if (strlen($buf) > $length and $buf_o != '') {
1563                        $message .= $buf_o . $soft_break;
1564                        $buf = $word;
1565                    }
1566                }
1567            }
1568            $message .= $buf . self::CRLF;
1569        }
1570
1571        return $message;
1572    }
1573
1574    /**
1575     * Find the last character boundary prior to $maxLength in a utf-8
1576     * quoted (printable) encoded string.
1577     * Original written by Colin Brown.
1578     * @access public
1579     * @param string $encodedText utf-8 QP text
1580     * @param integer $maxLength   find last character boundary prior to this length
1581     * @return integer
1582     */
1583    public function utf8CharBoundary($encodedText, $maxLength)
1584    {
1585        $foundSplitPos = false;
1586        $lookBack = 3;
1587        while (!$foundSplitPos) {
1588            $lastChunk = substr($encodedText, $maxLength - $lookBack, $lookBack);
1589            $encodedCharPos = strpos($lastChunk, '=');
1590            if (false !== $encodedCharPos) {
1591                // Found start of encoded character byte within $lookBack block.
1592                // Check the encoded byte value (the 2 chars after the '=')
1593                $hex = substr($encodedText, $maxLength - $lookBack + $encodedCharPos + 1, 2);
1594                $dec = hexdec($hex);
1595                if ($dec < 128) { // Single byte character.
1596                    // If the encoded char was found at pos 0, it will fit
1597                    // otherwise reduce maxLength to start of the encoded char
1598                    $maxLength = ($encodedCharPos == 0) ? $maxLength :
1599                        $maxLength - ($lookBack - $encodedCharPos);
1600                    $foundSplitPos = true;
1601                } elseif ($dec >= 192) { // First byte of a multi byte character
1602                    // Reduce maxLength to split at start of character
1603                    $maxLength = $maxLength - ($lookBack - $encodedCharPos);
1604                    $foundSplitPos = true;
1605                } elseif ($dec < 192) { // Middle byte of a multi byte character, look further back
1606                    $lookBack += 3;
1607                }
1608            } else {
1609                // No encoded character found
1610                $foundSplitPos = true;
1611            }
1612        }
1613        return $maxLength;
1614    }
1615
1616    /**
1617     * Set the body wrapping.
1618     * @access public
1619     * @return void
1620     */
1621    public function setWordWrap()
1622    {
1623        if ($this->WordWrap < 1) {
1624            return;
1625        }
1626
1627        switch ($this->message_type) {
1628            case 'alt':
1629            case 'alt_inline':
1630            case 'alt_attach':
1631            case 'alt_inline_attach':
1632                $this->AltBody = $this->wrapText($this->AltBody, $this->WordWrap);
1633                break;
1634            default:
1635                $this->Body = $this->wrapText($this->Body, $this->WordWrap);
1636                break;
1637        }
1638    }
1639
1640    /**
1641     * Assemble message headers.
1642     * @access public
1643     * @return string The assembled headers
1644     */
1645    public function createHeader()
1646    {
1647        $result = '';
1648
1649        // Set the boundaries
1650        $uniq_id = md5(uniqid(time()));
1651        $this->boundary[1] = 'b1_' . $uniq_id;
1652        $this->boundary[2] = 'b2_' . $uniq_id;
1653        $this->boundary[3] = 'b3_' . $uniq_id;
1654
1655        if ($this->MessageDate == '') {
1656            $this->MessageDate = self::rfcDate();
1657        }
1658        $result .= $this->headerLine('Date', $this->MessageDate);
1659
1660
1661        // To be created automatically by mail()
1662        if ($this->SingleTo) {
1663            if ($this->Mailer != 'mail') {
1664                foreach ($this->to as $toaddr) {
1665                    $this->SingleToArray[] = $this->addrFormat($toaddr);
1666                }
1667            }
1668        } else {
1669            if (count($this->to) > 0) {
1670                if ($this->Mailer != 'mail') {
1671                    $result .= $this->addrAppend('To', $this->to);
1672                }
1673            } elseif (count($this->cc) == 0) {
1674                $result .= $this->headerLine('To', 'undisclosed-recipients:;');
1675            }
1676        }
1677
1678        $result .= $this->addrAppend('From', array(array(trim($this->From), $this->FromName)));
1679
1680        // sendmail and mail() extract Cc from the header before sending
1681        if (count($this->cc) > 0) {
1682            $result .= $this->addrAppend('Cc', $this->cc);
1683        }
1684
1685        // sendmail and mail() extract Bcc from the header before sending
1686        if ((
1687                $this->Mailer == 'sendmail' or $this->Mailer == 'qmail' or $this->Mailer == 'mail'
1688            )
1689            and count($this->bcc) > 0
1690        ) {
1691            $result .= $this->addrAppend('Bcc', $this->bcc);
1692        }
1693
1694        if (count($this->ReplyTo) > 0) {
1695            $result .= $this->addrAppend('Reply-To', $this->ReplyTo);
1696        }
1697
1698        // mail() sets the subject itself
1699        if ($this->Mailer != 'mail') {
1700            $result .= $this->headerLine('Subject', $this->encodeHeader($this->secureHeader($this->Subject)));
1701        }
1702
1703        if ($this->MessageID != '') {
1704            $this->lastMessageID = $this->MessageID;
1705        } else {
1706            $this->lastMessageID = sprintf('<%s@%s>', $uniq_id, $this->ServerHostname());
1707        }
1708        $result .= $this->HeaderLine('Message-ID', $this->lastMessageID);
1709        $result .= $this->headerLine('X-Priority', $this->Priority);
1710        if ($this->XMailer == '') {
1711            $result .= $this->headerLine(
1712                'X-Mailer',
1713                'PHPMailer ' . $this->Version . ' (https://github.com/PHPMailer/PHPMailer/)'
1714            );
1715        } else {
1716            $myXmailer = trim($this->XMailer);
1717            if ($myXmailer) {
1718                $result .= $this->headerLine('X-Mailer', $myXmailer);
1719            }
1720        }
1721
1722        if ($this->ConfirmReadingTo != '') {
1723            $result .= $this->headerLine('Disposition-Notification-To', '<' . trim($this->ConfirmReadingTo) . '>');
1724        }
1725
1726        // Add custom headers
1727        for ($index = 0; $index < count($this->CustomHeader); $index++) {
1728            $result .= $this->headerLine(
1729                trim($this->CustomHeader[$index][0]),
1730                $this->encodeHeader(trim($this->CustomHeader[$index][1]))
1731            );
1732        }
1733        if (!$this->sign_key_file) {
1734            $result .= $this->headerLine('MIME-Version', '1.0');
1735            $result .= $this->getMailMIME();
1736        }
1737
1738        return $result;
1739    }
1740
1741    /**
1742     * Get the message MIME type headers.
1743     * @access public
1744     * @return string
1745     */
1746    public function getMailMIME()
1747    {
1748        $result = '';
1749        $ismultipart = true;
1750        switch ($this->message_type) {
1751            case 'inline':
1752                $result .= $this->headerLine('Content-Type', 'multipart/related;');
1753                $result .= $this->textLine("\tboundary=\"" . $this->boundary[1] . '"');
1754                break;
1755            case 'attach':
1756            case 'inline_attach':
1757            case 'alt_attach':
1758            case 'alt_inline_attach':
1759                $result .= $this->headerLine('Content-Type', 'multipart/mixed;');
1760                $result .= $this->textLine("\tboundary=\"" . $this->boundary[1] . '"');
1761                break;
1762            case 'alt':
1763            case 'alt_inline':
1764                $result .= $this->headerLine('Content-Type', 'multipart/alternative;');
1765                $result .= $this->textLine("\tboundary=\"" . $this->boundary[1] . '"');
1766                break;
1767            default:
1768                // Catches case 'plain': and case '':
1769                $result .= $this->textLine('Content-Type: ' . $this->ContentType . '; charset=' . $this->CharSet);
1770                $ismultipart = false;
1771                break;
1772        }
1773        // RFC1341 part 5 says 7bit is assumed if not specified
1774        if ($this->Encoding != '7bit') {
1775            // RFC 2045 section 6.4 says multipart MIME parts may only use 7bit, 8bit or binary CTE
1776            if ($ismultipart) {
1777                if ($this->Encoding == '8bit') {
1778                    $result .= $this->headerLine('Content-Transfer-Encoding', '8bit');
1779                }
1780                // The only remaining alternatives are quoted-printable and base64, which are both 7bit compatible
1781            } else {
1782                $result .= $this->headerLine('Content-Transfer-Encoding', $this->Encoding);
1783            }
1784        }
1785
1786        if ($this->Mailer != 'mail') {
1787            $result .= $this->LE;
1788        }
1789
1790        return $result;
1791    }
1792
1793    /**
1794     * Returns the whole MIME message.
1795     * Includes complete headers and body.
1796     * Only valid post preSend().
1797     * @see PHPMailer::preSend()
1798     * @access public
1799     * @return string
1800     */
1801    public function getSentMIMEMessage()
1802    {
1803        return $this->MIMEHeader . $this->mailHeader . self::CRLF . $this->MIMEBody;
1804    }
1805
1806
1807    /**
1808     * Assemble the message body.
1809     * Returns an empty string on failure.
1810     * @access public
1811     * @throws phpmailerException
1812     * @return string The assembled message body
1813     */
1814    public function createBody()
1815    {
1816        $body = '';
1817
1818        if ($this->sign_key_file) {
1819            $body .= $this->getMailMIME() . $this->LE;
1820        }
1821
1822        $this->setWordWrap();
1823
1824        $bodyEncoding = $this->Encoding;
1825        $bodyCharSet = $this->CharSet;
1826        if ($bodyEncoding == '8bit' and !$this->has8bitChars($this->Body)) {
1827            $bodyEncoding = '7bit';
1828            $bodyCharSet = 'us-ascii';
1829        }
1830        $altBodyEncoding = $this->Encoding;
1831        $altBodyCharSet = $this->CharSet;
1832        if ($altBodyEncoding == '8bit' and !$this->has8bitChars($this->AltBody)) {
1833            $altBodyEncoding = '7bit';
1834            $altBodyCharSet = 'us-ascii';
1835        }
1836        switch ($this->message_type) {
1837            case 'inline':
1838                $body .= $this->getBoundary($this->boundary[1], $bodyCharSet, '', $bodyEncoding);
1839                $body .= $this->encodeString($this->Body, $bodyEncoding);
1840                $body .= $this->LE . $this->LE;
1841                $body .= $this->attachAll('inline', $this->boundary[1]);
1842                break;
1843            case 'attach':
1844                $body .= $this->getBoundary($this->boundary[1], $bodyCharSet, '', $bodyEncoding);
1845                $body .= $this->encodeString($this->Body, $bodyEncoding);
1846                $body .= $this->LE . $this->LE;
1847                $body .= $this->attachAll('attachment', $this->boundary[1]);
1848                break;
1849            case 'inline_attach':
1850                $body .= $this->textLine('--' . $this->boundary[1]);
1851                $body .= $this->headerLine('Content-Type', 'multipart/related;');
1852                $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
1853                $body .= $this->LE;
1854                $body .= $this->getBoundary($this->boundary[2], $bodyCharSet, '', $bodyEncoding);
1855                $body .= $this->encodeString($this->Body, $bodyEncoding);
1856                $body .= $this->LE . $this->LE;
1857                $body .= $this->attachAll('inline', $this->boundary[2]);
1858                $body .= $this->LE;
1859                $body .= $this->attachAll('attachment', $this->boundary[1]);
1860                break;
1861            case 'alt':
1862                $body .= $this->getBoundary($this->boundary[1], $altBodyCharSet, 'text/plain', $altBodyEncoding);
1863                $body .= $this->encodeString($this->AltBody, $altBodyEncoding);
1864                $body .= $this->LE . $this->LE;
1865                $body .= $this->getBoundary($this->boundary[1], $bodyCharSet, 'text/html', $bodyEncoding);
1866                $body .= $this->encodeString($this->Body, $bodyEncoding);
1867                $body .= $this->LE . $this->LE;
1868                if (!empty($this->Ical)) {
1869                    $body .= $this->getBoundary($this->boundary[1], '', 'text/calendar; method=REQUEST', '');
1870                    $body .= $this->encodeString($this->Ical, $this->Encoding);
1871                    $body .= $this->LE . $this->LE;
1872                }
1873                $body .= $this->endBoundary($this->boundary[1]);
1874                break;
1875            case 'alt_inline':
1876                $body .= $this->getBoundary($this->boundary[1], $altBodyCharSet, 'text/plain', $altBodyEncoding);
1877                $body .= $this->encodeString($this->AltBody, $altBodyEncoding);
1878                $body .= $this->LE . $this->LE;
1879                $body .= $this->textLine('--' . $this->boundary[1]);
1880                $body .= $this->headerLine('Content-Type', 'multipart/related;');
1881                $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
1882                $body .= $this->LE;
1883                $body .= $this->getBoundary($this->boundary[2], $bodyCharSet, 'text/html', $bodyEncoding);
1884                $body .= $this->encodeString($this->Body, $bodyEncoding);
1885                $body .= $this->LE . $this->LE;
1886                $body .= $this->attachAll('inline', $this->boundary[2]);
1887                $body .= $this->LE;
1888                $body .= $this->endBoundary($this->boundary[1]);
1889                break;
1890            case 'alt_attach':
1891                $body .= $this->textLine('--' . $this->boundary[1]);
1892                $body .= $this->headerLine('Content-Type', 'multipart/alternative;');
1893                $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
1894                $body .= $this->LE;
1895                $body .= $this->getBoundary($this->boundary[2], $altBodyCharSet, 'text/plain', $altBodyEncoding);
1896                $body .= $this->encodeString($this->AltBody, $altBodyEncoding);
1897                $body .= $this->LE . $this->LE;
1898                $body .= $this->getBoundary($this->boundary[2], $bodyCharSet, 'text/html', $bodyEncoding);
1899                $body .= $this->encodeString($this->Body, $bodyEncoding);
1900                $body .= $this->LE . $this->LE;
1901                $body .= $this->endBoundary($this->boundary[2]);
1902                $body .= $this->LE;
1903                $body .= $this->attachAll('attachment', $this->boundary[1]);
1904                break;
1905            case 'alt_inline_attach':
1906                $body .= $this->textLine('--' . $this->boundary[1]);
1907                $body .= $this->headerLine('Content-Type', 'multipart/alternative;');
1908                $body .= $this->textLine("\tboundary=\"" . $this->boundary[2] . '"');
1909                $body .= $this->LE;
1910                $body .= $this->getBoundary($this->boundary[2], $altBodyCharSet, 'text/plain', $altBodyEncoding);
1911                $body .= $this->encodeString($this->AltBody, $altBodyEncoding);
1912                $body .= $this->LE . $this->LE;
1913                $body .= $this->textLine('--' . $this->boundary[2]);
1914                $body .= $this->headerLine('Content-Type', 'multipart/related;');
1915                $body .= $this->textLine("\tboundary=\"" . $this->boundary[3] . '"');
1916                $body .= $this->LE;
1917                $body .= $this->getBoundary($this->boundary[3], $bodyCharSet, 'text/html', $bodyEncoding);
1918                $body .= $this->encodeString($this->Body, $bodyEncoding);
1919                $body .= $this->LE . $this->LE;
1920                $body .= $this->attachAll('inline', $this->boundary[3]);
1921                $body .= $this->LE;
1922                $body .= $this->endBoundary($this->boundary[2]);
1923                $body .= $this->LE;
1924                $body .= $this->attachAll('attachment', $this->boundary[1]);
1925                break;
1926            default:
1927                // catch case 'plain' and case ''
1928                $body .= $this->encodeString($this->Body, $bodyEncoding);
1929                break;
1930        }
1931
1932        if ($this->isError()) {
1933            $body = '';
1934        } elseif ($this->sign_key_file) {
1935            try {
1936                if (!defined('PKCS7_TEXT')) {
1937                    throw new phpmailerException($this->lang('signing') . ' OpenSSL extension missing.');
1938                }
1939                // @TODO would be nice to use php://temp streams here, but need to wrap for PHP < 5.1
1940                $file = tempnam(sys_get_temp_dir(), 'mail');
1941                if (false === file_put_contents($file, $body)) {
1942                    throw new phpmailerException($this->lang('signing') . ' Could not write temp file');
1943                }
1944                $signed = tempnam(sys_get_temp_dir(), 'signed');
1945                if (@openssl_pkcs7_sign(
1946                    $file,
1947                    $signed,
1948                    'file://' . realpath($this->sign_cert_file),
1949                    array('file://' . realpath($this->sign_key_file), $this->sign_key_pass),
1950                    null
1951                )
1952                ) {
1953                    @unlink($file);
1954                    $body = file_get_contents($signed);
1955                    @unlink($signed);
1956                } else {
1957                    @unlink($file);
1958                    @unlink($signed);
1959                    throw new phpmailerException($this->lang('signing') . openssl_error_string());
1960                }
1961            } catch (phpmailerException $exc) {
1962                $body = '';
1963                if ($this->exceptions) {
1964                    throw $exc;
1965                }
1966            }
1967        }
1968        return $body;
1969    }
1970
1971    /**
1972     * Return the start of a message boundary.
1973     * @access protected
1974     * @param string $boundary
1975     * @param string $charSet
1976     * @param string $contentType
1977     * @param string $encoding
1978     * @return string
1979     */
1980    protected function getBoundary($boundary, $charSet, $contentType, $encoding)
1981    {
1982        $result = '';
1983        if ($charSet == '') {
1984            $charSet = $this->CharSet;
1985        }
1986        if ($contentType == '') {
1987            $contentType = $this->ContentType;
1988        }
1989        if ($encoding == '') {
1990            $encoding = $this->Encoding;
1991        }
1992        $result .= $this->textLine('--' . $boundary);
1993        $result .= sprintf('Content-Type: %s; charset=%s', $contentType, $charSet);
1994        $result .= $this->LE;
1995        // RFC1341 part 5 says 7bit is assumed if not specified
1996        if ($encoding != '7bit') {
1997            $result .= $this->headerLine('Content-Transfer-Encoding', $encoding);
1998        }
1999        $result .= $this->LE;
2000
2001        return $result;
2002    }
2003
2004    /**
2005     * Return the end of a message boundary.
2006     * @access protected
2007     * @param string $boundary
2008     * @return string
2009     */
2010    protected function endBoundary($boundary)
2011    {
2012        return $this->LE . '--' . $boundary . '--' . $this->LE;
2013    }
2014
2015    /**
2016     * Set the message type.
2017     * PHPMailer only supports some preset message types,
2018     * not arbitrary MIME structures.
2019     * @access protected
2020     * @return void
2021     */
2022    protected function setMessageType()
2023    {
2024        $type = array();
2025        if ($this->alternativeExists()) {
2026            $type[] = 'alt';
2027        }
2028        if ($this->inlineImageExists()) {
2029            $type[] = 'inline';
2030        }
2031        if ($this->attachmentExists()) {
2032            $type[] = 'attach';
2033        }
2034        $this->message_type = implode('_', $type);
2035        if ($this->message_type == '') {
2036            $this->message_type = 'plain';
2037        }
2038    }
2039
2040    /**
2041     * Format a header line.
2042     * @access public
2043     * @param string $name
2044     * @param string $value
2045     * @return string
2046     */
2047    public function headerLine($name, $value)
2048    {
2049        return $name . ': ' . $value . $this->LE;
2050    }
2051
2052    /**
2053     * Return a formatted mail line.
2054     * @access public
2055     * @param string $value
2056     * @return string
2057     */
2058    public function textLine($value)
2059    {
2060        return $value . $this->LE;
2061    }
2062
2063    /**
2064     * Add an attachment from a path on the filesystem.
2065     * Returns false if the file could not be found or read.
2066     * @param string $path Path to the attachment.
2067     * @param string $name Overrides the attachment name.
2068     * @param string $encoding File encoding (see $Encoding).
2069     * @param string $type File extension (MIME) type.
2070     * @param string $disposition Disposition to use
2071     * @throws phpmailerException
2072     * @return boolean
2073     */
2074    public function addAttachment($path, $name = '', $encoding = 'base64', $type = '', $disposition = 'attachment')
2075    {
2076        try {
2077            if (!@is_file($path)) {
2078                throw new phpmailerException($this->lang('file_access') . $path, self::STOP_CONTINUE);
2079            }
2080
2081            // If a MIME type is not specified, try to work it out from the file name
2082            if ($type == '') {
2083                $type = self::filenameToType($path);
2084            }
2085
2086            $filename = basename($path);
2087            if ($name == '') {
2088                $name = $filename;
2089            }
2090
2091            $this->attachment[] = array(
2092                0 => $path,
2093                1 => $filename,
2094                2 => $name,
2095                3 => $encoding,
2096                4 => $type,
2097                5 => false, // isStringAttachment
2098                6 => $disposition,
2099                7 => 0
2100            );
2101
2102        } catch (phpmailerException $exc) {
2103            $this->setError($exc->getMessage());
2104            $this->edebug($exc->getMessage());
2105            if ($this->exceptions) {
2106                throw $exc;
2107            }
2108            return false;
2109        }
2110        return true;
2111    }
2112
2113    /**
2114     * Return the array of attachments.
2115     * @return array
2116     */
2117    public function getAttachments()
2118    {
2119        return $this->attachment;
2120    }
2121
2122    /**
2123     * Attach all file, string, and binary attachments to the message.
2124     * Returns an empty string on failure.
2125     * @access protected
2126     * @param string $disposition_type
2127     * @param string $boundary
2128     * @return string
2129     */
2130    protected function attachAll($disposition_type, $boundary)
2131    {
2132        // Return text of body
2133        $mime = array();
2134        $cidUniq = array();
2135        $incl = array();
2136
2137        // Add all attachments
2138        foreach ($this->attachment as $attachment) {
2139            // Check if it is a valid disposition_filter
2140            if ($attachment[6] == $disposition_type) {
2141                // Check for string attachment
2142                $string = '';
2143                $path = '';
2144                $bString = $attachment[5];
2145                if ($bString) {
2146                    $string = $attachment[0];
2147                } else {
2148                    $path = $attachment[0];
2149                }
2150
2151                $inclhash = md5(serialize($attachment));
2152                if (in_array($inclhash, $incl)) {
2153                    continue;
2154                }
2155                $incl[] = $inclhash;
2156                $name = $attachment[2];
2157                $encoding = $attachment[3];
2158                $type = $attachment[4];
2159                $disposition = $attachment[6];
2160                $cid = $attachment[7];
2161                if ($disposition == 'inline' && isset($cidUniq[$cid])) {
2162                    continue;
2163                }
2164                $cidUniq[$cid] = true;
2165
2166                $mime[] = sprintf('--%s%s', $boundary, $this->LE);
2167                $mime[] = sprintf(
2168                    'Content-Type: %s; name="%s"%s',
2169                    $type,
2170                    $this->encodeHeader($this->secureHeader($name)),
2171                    $this->LE
2172                );
2173                // RFC1341 part 5 says 7bit is assumed if not specified
2174                if ($encoding != '7bit') {
2175                    $mime[] = sprintf('Content-Transfer-Encoding: %s%s', $encoding, $this->LE);
2176                }
2177
2178                if ($disposition == 'inline') {
2179                    $mime[] = sprintf('Content-ID: <%s>%s', $cid, $this->LE);
2180                }
2181
2182                // If a filename contains any of these chars, it should be quoted,
2183                // but not otherwise: RFC2183 & RFC2045 5.1
2184                // Fixes a warning in IETF's msglint MIME checker
2185                // Allow for bypassing the Content-Disposition header totally
2186                if (!(empty($disposition))) {
2187                    $encoded_name = $this->encodeHeader($this->secureHeader($name));
2188                    if (preg_match('/[ \(\)<>@,;:\\"\/\[\]\?=]/', $encoded_name)) {
2189                        $mime[] = sprintf(
2190                            'Content-Disposition: %s; filename="%s"%s',
2191                            $disposition,
2192                            $encoded_name,
2193                            $this->LE . $this->LE
2194                        );
2195                    } else {
2196                        $mime[] = sprintf(
2197                            'Content-Disposition: %s; filename=%s%s',
2198                            $disposition,
2199                            $encoded_name,
2200                            $this->LE . $this->LE
2201                        );
2202                    }
2203                } else {
2204                    $mime[] = $this->LE;
2205                }
2206
2207                // Encode as string attachment
2208                if ($bString) {
2209                    $mime[] = $this->encodeString($string, $encoding);
2210                    if ($this->isError()) {
2211                        return '';
2212                    }
2213                    $mime[] = $this->LE . $this->LE;
2214                } else {
2215                    $mime[] = $this->encodeFile($path, $encoding);
2216                    if ($this->isError()) {
2217                        return '';
2218                    }
2219                    $mime[] = $this->LE . $this->LE;
2220                }
2221            }
2222        }
2223
2224        $mime[] = sprintf('--%s--%s', $boundary, $this->LE);
2225
2226        return implode('', $mime);
2227    }
2228
2229    /**
2230     * Encode a file attachment in requested format.
2231     * Returns an empty string on failure.
2232     * @param string $path The full path to the file
2233     * @param string $encoding The encoding to use; one of 'base64', '7bit', '8bit', 'binary', 'quoted-printable'
2234     * @throws phpmailerException
2235     * @see EncodeFile(encodeFile
2236     * @access protected
2237     * @return string
2238     */
2239    protected function encodeFile($path, $encoding = 'base64')
2240    {
2241        try {
2242            if (!is_readable($path)) {
2243                throw new phpmailerException($this->lang('file_open') . $path, self::STOP_CONTINUE);
2244            }
2245            $magic_quotes = get_magic_quotes_runtime();
2246            if ($magic_quotes) {
2247                if (version_compare(PHP_VERSION, '5.3.0', '<')) {
2248                    set_magic_quotes_runtime(false);
2249                } else {
2250                    //Doesn't exist in PHP 5.4, but we don't need to check because
2251                    //get_magic_quotes_runtime always returns false in 5.4+
2252                    //so it will never get here
2253                    ini_set('magic_quotes_runtime', 0);
2254                }
2255            }
2256            $file_buffer = file_get_contents($path);
2257            $file_buffer = $this->encodeString($file_buffer, $encoding);
2258            if ($magic_quotes) {
2259                if (version_compare(PHP_VERSION, '5.3.0', '<')) {
2260                    set_magic_quotes_runtime($magic_quotes);
2261                } else {
2262                    ini_set('magic_quotes_runtime', ($magic_quotes?'1':'0'));
2263                }
2264            }
2265            return $file_buffer;
2266        } catch (Exception $exc) {
2267            $this->setError($exc->getMessage());
2268            return '';
2269        }
2270    }
2271
2272    /**
2273     * Encode a string in requested format.
2274     * Returns an empty string on failure.
2275     * @param string $str The text to encode
2276     * @param string $encoding The encoding to use; one of 'base64', '7bit', '8bit', 'binary', 'quoted-printable'
2277     * @access public
2278     * @return string
2279     */
2280    public function encodeString($str, $encoding = 'base64')
2281    {
2282        $encoded = '';
2283        switch (strtolower($encoding)) {
2284            case 'base64':
2285                $encoded = chunk_split(base64_encode($str), 76, $this->LE);
2286                break;
2287            case '7bit':
2288            case '8bit':
2289                $encoded = $this->fixEOL($str);
2290                // Make sure it ends with a line break
2291                if (substr($encoded, -(strlen($this->LE))) != $this->LE) {
2292                    $encoded .= $this->LE;
2293                }
2294                break;
2295            case 'binary':
2296                $encoded = $str;
2297                break;
2298            case 'quoted-printable':
2299                $encoded = $this->encodeQP($str);
2300                break;
2301            default:
2302                $this->setError($this->lang('encoding') . $encoding);
2303                break;
2304        }
2305        return $encoded;
2306    }
2307
2308    /**
2309     * Encode a header string optimally.
2310     * Picks shortest of Q, B, quoted-printable or none.
2311     * @access public
2312     * @param string $str
2313     * @param string $position
2314     * @return string
2315     */
2316    public function encodeHeader($str, $position = 'text')
2317    {
2318        $matchcount = 0;
2319        switch (strtolower($position)) {
2320            case 'phrase':
2321                if (!preg_match('/[\200-\377]/', $str)) {
2322                    // Can't use addslashes as we don't know the value of magic_quotes_sybase
2323                    $encoded = addcslashes($str, "\0..\37\177\\\"");
2324                    if (($str == $encoded) && !preg_match('/[^A-Za-z0-9!#$%&\'*+\/=?^_`{|}~ -]/', $str)) {
2325                        return ($encoded);
2326                    } else {
2327                        return ("\"$encoded\"");
2328                    }
2329                }
2330                $matchcount = preg_match_all('/[^\040\041\043-\133\135-\176]/', $str, $matches);
2331                break;
2332            /** @noinspection PhpMissingBreakStatementInspection */
2333            case 'comment':
2334                $matchcount = preg_match_all('/[()"]/', $str, $matches);
2335                // Intentional fall-through
2336            case 'text':
2337            default:
2338                $matchcount += preg_match_all('/[\000-\010\013\014\016-\037\177-\377]/', $str, $matches);
2339                break;
2340        }
2341
2342        if ($matchcount == 0) { // There are no chars that need encoding
2343            return ($str);
2344        }
2345
2346        $maxlen = 75 - 7 - strlen($this->CharSet);
2347        // Try to select the encoding which should produce the shortest output
2348        if ($matchcount > strlen($str) / 3) {
2349            // More than a third of the content will need encoding, so B encoding will be most efficient
2350            $encoding = 'B';
2351            if (function_exists('mb_strlen') && $this->hasMultiBytes($str)) {
2352                // Use a custom function which correctly encodes and wraps long
2353                // multibyte strings without breaking lines within a character
2354                $encoded = $this->base64EncodeWrapMB($str, "\n");
2355            } else {
2356                $encoded = base64_encode($str);
2357                $maxlen -= $maxlen % 4;
2358                $encoded = trim(chunk_split($encoded, $maxlen, "\n"));
2359            }
2360        } else {
2361            $encoding = 'Q';
2362            $encoded = $this->encodeQ($str, $position);
2363            $encoded = $this->wrapText($encoded, $maxlen, true);
2364            $encoded = str_replace('=' . self::CRLF, "\n", trim($encoded));
2365        }
2366
2367        $encoded = preg_replace('/^(.*)$/m', ' =?' . $this->CharSet . "?$encoding?\\1?=", $encoded);
2368        $encoded = trim(str_replace("\n", $this->LE, $encoded));
2369
2370        return $encoded;
2371    }
2372
2373    /**
2374     * Check if a string contains multi-byte characters.
2375     * @access public
2376     * @param string $str multi-byte text to wrap encode
2377     * @return boolean
2378     */
2379    public function hasMultiBytes($str)
2380    {
2381        if (function_exists('mb_strlen')) {
2382            return (strlen($str) > mb_strlen($str, $this->CharSet));
2383        } else { // Assume no multibytes (we can't handle without mbstring functions anyway)
2384            return false;
2385        }
2386    }
2387
2388    /**
2389     * Does a string contain any 8-bit chars (in any charset)?
2390     * @param string $text
2391     * @return boolean
2392     */
2393    public function has8bitChars($text)
2394    {
2395        return (boolean)preg_match('/[\x80-\xFF]/', $text);
2396    }
2397
2398    /**
2399     * Encode and wrap long multibyte strings for mail headers
2400     * without breaking lines within a character.
2401     * Adapted from a function by paravoid
2402     * @link http://www.php.net/manual/en/function.mb-encode-mimeheader.php#60283
2403     * @access public
2404     * @param string $str multi-byte text to wrap encode
2405     * @param string $linebreak string to use as linefeed/end-of-line
2406     * @return string
2407     */
2408    public function base64EncodeWrapMB($str, $linebreak = null)
2409    {
2410        $start = '=?' . $this->CharSet . '?B?';
2411        $end = '?=';
2412        $encoded = '';
2413        if ($linebreak === null) {
2414            $linebreak = $this->LE;
2415        }
2416
2417        $mb_length = mb_strlen($str, $this->CharSet);
2418        // Each line must have length <= 75, including $start and $end
2419        $length = 75 - strlen($start) - strlen($end);
2420        // Average multi-byte ratio
2421        $ratio = $mb_length / strlen($str);
2422        // Base64 has a 4:3 ratio
2423        $avgLength = floor($length * $ratio * .75);
2424
2425        for ($i = 0; $i < $mb_length; $i += $offset) {
2426            $lookBack = 0;
2427            do {
2428                $offset = $avgLength - $lookBack;
2429                $chunk = mb_substr($str, $i, $offset, $this->CharSet);
2430                $chunk = base64_encode($chunk);
2431                $lookBack++;
2432            } while (strlen($chunk) > $length);
2433            $encoded .= $chunk . $linebreak;
2434        }
2435
2436        // Chomp the last linefeed
2437        $encoded = substr($encoded, 0, -strlen($linebreak));
2438        return $encoded;
2439    }
2440
2441    /**
2442     * Encode a string in quoted-printable format.
2443     * According to RFC2045 section 6.7.
2444     * @access public
2445     * @param string $string The text to encode
2446     * @param integer $line_max Number of chars allowed on a line before wrapping
2447     * @return string
2448     * @link http://www.php.net/manual/en/function.quoted-printable-decode.php#89417 Adapted from this comment
2449     */
2450    public function encodeQP($string, $line_max = 76)
2451    {
2452        if (function_exists('quoted_printable_encode')) { // Use native function if it's available (>= PHP5.3)
2453            return $this->fixEOL(quoted_printable_encode($string));
2454        }
2455        // Fall back to a pure PHP implementation
2456        $string = str_replace(
2457            array('%20', '%0D%0A.', '%0D%0A', '%'),
2458            array(' ', "\r\n=2E", "\r\n", '='),
2459            rawurlencode($string)
2460        );
2461        $string = preg_replace('/[^\r\n]{' . ($line_max - 3) . '}[^=\r\n]{2}/', "$0=\r\n", $string);
2462        return $this->fixEOL($string);
2463    }
2464
2465    /**
2466     * Backward compatibility wrapper for an old QP encoding function that was removed.
2467     * @see PHPMailer::encodeQP()
2468     * @access public
2469     * @param string $string
2470     * @param integer $line_max
2471     * @param boolean $space_conv
2472     * @return string
2473     * @deprecated Use encodeQP instead.
2474     */
2475    public function encodeQPphp(
2476        $string,
2477        $line_max = 76,
2478        /** @noinspection PhpUnusedParameterInspection */ $space_conv = false
2479    ) {
2480        return $this->encodeQP($string, $line_max);
2481    }
2482
2483    /**
2484     * Encode a string using Q encoding.
2485     * @link http://tools.ietf.org/html/rfc2047
2486     * @param string $str the text to encode
2487     * @param string $position Where the text is going to be used, see the RFC for what that means
2488     * @access public
2489     * @return string
2490     */
2491    public function encodeQ($str, $position = 'text')
2492    {
2493        // There should not be any EOL in the string
2494        $pattern = '';
2495        $encoded = str_replace(array("\r", "\n"), '', $str);
2496        switch (strtolower($position)) {
2497            case 'phrase':
2498                // RFC 2047 section 5.3
2499                $pattern = '^A-Za-z0-9!*+\/ -';
2500                break;
2501            /** @noinspection PhpMissingBreakStatementInspection */
2502            case 'comment':
2503                // RFC 2047 section 5.2
2504                $pattern = '\(\)"';
2505                // intentional fall-through
2506                // for this reason we build the $pattern without including delimiters and []
2507            case 'text':
2508            default:
2509                // RFC 2047 section 5.1
2510                // Replace every high ascii, control, =, ? and _ characters
2511                $pattern = '\000-\011\013\014\016-\037\075\077\137\177-\377' . $pattern;
2512                break;
2513        }
2514        $matches = array();
2515        if (preg_match_all("/[{$pattern}]/", $encoded, $matches)) {
2516            // If the string contains an '=', make sure it's the first thing we replace
2517            // so as to avoid double-encoding
2518            $eqkey = array_search('=', $matches[0]);
2519            if (false !== $eqkey) {
2520                unset($matches[0][$eqkey]);
2521                array_unshift($matches[0], '=');
2522            }
2523            foreach (array_unique($matches[0]) as $char) {
2524                $encoded = str_replace($char, '=' . sprintf('%02X', ord($char)), $encoded);
2525            }
2526        }
2527        // Replace every spaces to _ (more readable than =20)
2528        return str_replace(' ', '_', $encoded);
2529    }
2530
2531
2532    /**
2533     * Add a string or binary attachment (non-filesystem).
2534     * This method can be used to attach ascii or binary data,
2535     * such as a BLOB record from a database.
2536     * @param string $string String attachment data.
2537     * @param string $filename Name of the attachment.
2538     * @param string $encoding File encoding (see $Encoding).
2539     * @param string $type File extension (MIME) type.
2540     * @param string $disposition Disposition to use
2541     * @return void
2542     */
2543    public function addStringAttachment(
2544        $string,
2545        $filename,
2546        $encoding = 'base64',
2547        $type = '',
2548        $disposition = 'attachment'
2549    ) {
2550        // If a MIME type is not specified, try to work it out from the file name
2551        if ($type == '') {
2552            $type = self::filenameToType($filename);
2553        }
2554        // Append to $attachment array
2555        $this->attachment[] = array(
2556            0 => $string,
2557            1 => $filename,
2558            2 => basename($filename),
2559            3 => $encoding,
2560            4 => $type,
2561            5 => true, // isStringAttachment
2562            6 => $disposition,
2563            7 => 0
2564        );
2565    }
2566
2567    /**
2568     * Add an embedded (inline) attachment from a file.
2569     * This can include images, sounds, and just about any other document type.
2570     * These differ from 'regular' attachments in that they are intended to be
2571     * displayed inline with the message, not just attached for download.
2572     * This is used in HTML messages that embed the images
2573     * the HTML refers to using the $cid value.
2574     * @param string $path Path to the attachment.
2575     * @param string $cid Content ID of the attachment; Use this to reference
2576     *        the content when using an embedded image in HTML.
2577     * @param string $name Overrides the attachment name.
2578     * @param string $encoding File encoding (see $Encoding).
2579     * @param string $type File MIME type.
2580     * @param string $disposition Disposition to use
2581     * @return boolean True on successfully adding an attachment
2582     */
2583    public function addEmbeddedImage($path, $cid, $name = '', $encoding = 'base64', $type = '', $disposition = 'inline')
2584    {
2585        if (!@is_file($path)) {
2586            $this->setError($this->lang('file_access') . $path);
2587            return false;
2588        }
2589
2590        // If a MIME type is not specified, try to work it out from the file name
2591        if ($type == '') {
2592            $type = self::filenameToType($path);
2593        }
2594
2595        $filename = basename($path);
2596        if ($name == '') {
2597            $name = $filename;
2598        }
2599
2600        // Append to $attachment array
2601        $this->attachment[] = array(
2602            0 => $path,
2603            1 => $filename,
2604            2 => $name,
2605            3 => $encoding,
2606            4 => $type,
2607            5 => false, // isStringAttachment
2608            6 => $disposition,
2609            7 => $cid
2610        );
2611        return true;
2612    }
2613
2614    /**
2615     * Add an embedded stringified attachment.
2616     * This can include images, sounds, and just about any other document type.
2617     * Be sure to set the $type to an image type for images:
2618     * JPEG images use 'image/jpeg', GIF uses 'image/gif', PNG uses 'image/png'.
2619     * @param string $string The attachment binary data.
2620     * @param string $cid Content ID of the attachment; Use this to reference
2621     *        the content when using an embedded image in HTML.
2622     * @param string $name
2623     * @param string $encoding File encoding (see $Encoding).
2624     * @param string $type MIME type.
2625     * @param string $disposition Disposition to use
2626     * @return boolean True on successfully adding an attachment
2627     */
2628    public function addStringEmbeddedImage(
2629        $string,
2630        $cid,
2631        $name = '',
2632        $encoding = 'base64',
2633        $type = '',
2634        $disposition = 'inline'
2635    ) {
2636        // If a MIME type is not specified, try to work it out from the name
2637        if ($type == '') {
2638            $type = self::filenameToType($name);
2639        }
2640
2641        // Append to $attachment array
2642        $this->attachment[] = array(
2643            0 => $string,
2644            1 => $name,
2645            2 => $name,
2646            3 => $encoding,
2647            4 => $type,
2648            5 => true, // isStringAttachment
2649            6 => $disposition,
2650            7 => $cid
2651        );
2652        return true;
2653    }
2654
2655    /**
2656     * Check if an inline attachment is present.
2657     * @access public
2658     * @return boolean
2659     */
2660    public function inlineImageExists()
2661    {
2662        foreach ($this->attachment as $attachment) {
2663            if ($attachment[6] == 'inline') {
2664                return true;
2665            }
2666        }
2667        return false;
2668    }
2669
2670    /**
2671     * Check if an attachment (non-inline) is present.
2672     * @return boolean
2673     */
2674    public function attachmentExists()
2675    {
2676        foreach ($this->attachment as $attachment) {
2677            if ($attachment[6] == 'attachment') {
2678                return true;
2679            }
2680        }
2681        return false;
2682    }
2683
2684    /**
2685     * Check if this message has an alternative body set.
2686     * @return boolean
2687     */
2688    public function alternativeExists()
2689    {
2690        return !empty($this->AltBody);
2691    }
2692
2693    /**
2694     * Clear all To recipients.
2695     * @return void
2696     */
2697    public function clearAddresses()
2698    {
2699        foreach ($this->to as $to) {
2700            unset($this->all_recipients[strtolower($to[0])]);
2701        }
2702        $this->to = array();
2703    }
2704
2705    /**
2706     * Clear all CC recipients.
2707     * @return void
2708     */
2709    public function clearCCs()
2710    {
2711        foreach ($this->cc as $cc) {
2712            unset($this->all_recipients[strtolower($cc[0])]);
2713        }
2714        $this->cc = array();
2715    }
2716
2717    /**
2718     * Clear all BCC recipients.
2719     * @return void
2720     */
2721    public function clearBCCs()
2722    {
2723        foreach ($this->bcc as $bcc) {
2724            unset($this->all_recipients[strtolower($bcc[0])]);
2725        }
2726        $this->bcc = array();
2727    }
2728
2729    /**
2730     * Clear all ReplyTo recipients.
2731     * @return void
2732     */
2733    public function clearReplyTos()
2734    {
2735        $this->ReplyTo = array();
2736    }
2737
2738    /**
2739     * Clear all recipient types.
2740     * @return void
2741     */
2742    public function clearAllRecipients()
2743    {
2744        $this->to = array();
2745        $this->cc = array();
2746        $this->bcc = array();
2747        $this->all_recipients = array();
2748    }
2749
2750    /**
2751     * Clear all filesystem, string, and binary attachments.
2752     * @return void
2753     */
2754    public function clearAttachments()
2755    {
2756        $this->attachment = array();
2757    }
2758
2759    /**
2760     * Clear all custom headers.
2761     * @return void
2762     */
2763    public function clearCustomHeaders()
2764    {
2765        $this->CustomHeader = array();
2766    }
2767
2768    /**
2769     * Add an error message to the error container.
2770     * @access protected
2771     * @param string $msg
2772     * @return void
2773     */
2774    protected function setError($msg)
2775    {
2776        $this->error_count++;
2777        if ($this->Mailer == 'smtp' and !is_null($this->smtp)) {
2778            $lasterror = $this->smtp->getError();
2779            if (!empty($lasterror) and array_key_exists('smtp_msg', $lasterror)) {
2780                $msg .= '<p>' . $this->lang('smtp_error') . $lasterror['smtp_msg'] . "</p>\n";
2781            }
2782        }
2783        $this->ErrorInfo = $msg;
2784    }
2785
2786    /**
2787     * Return an RFC 822 formatted date.
2788     * @access public
2789     * @return string
2790     * @static
2791     */
2792    public static function rfcDate()
2793    {
2794        // Set the time zone to whatever the default is to avoid 500 errors
2795        // Will default to UTC if it's not set properly in php.ini
2796        date_default_timezone_set(@date_default_timezone_get());
2797        return date('D, j M Y H:i:s O');
2798    }
2799
2800    /**
2801     * Get the server hostname.
2802     * Returns 'localhost.localdomain' if unknown.
2803     * @access protected
2804     * @return string
2805     */
2806    protected function serverHostname()
2807    {
2808        $result = 'localhost.localdomain';
2809        if (!empty($this->Hostname)) {
2810            $result = $this->Hostname;
2811        } elseif (isset($_SERVER) and array_key_exists('SERVER_NAME', $_SERVER) and !empty($_SERVER['SERVER_NAME'])) {
2812            $result = $_SERVER['SERVER_NAME'];
2813        } elseif (function_exists('gethostname') && gethostname() !== false) {
2814            $result = gethostname();
2815        } elseif (php_uname('n') !== false) {
2816            $result = php_uname('n');
2817        }
2818        return $result;
2819    }
2820
2821    /**
2822     * Get an error message in the current language.
2823     * @access protected
2824     * @param string $key
2825     * @return string
2826     */
2827    protected function lang($key)
2828    {
2829        if (count($this->language) < 1) {
2830            $this->setLanguage('en'); // set the default language
2831        }
2832
2833        if (isset($this->language[$key])) {
2834            return $this->language[$key];
2835        } else {
2836            return 'Language string failed to load: ' . $key;
2837        }
2838    }
2839
2840    /**
2841     * Check if an error occurred.
2842     * @access public
2843     * @return boolean True if an error did occur.
2844     */
2845    public function isError()
2846    {
2847        return ($this->error_count > 0);
2848    }
2849
2850    /**
2851     * Ensure consistent line endings in a string.
2852     * Changes every end of line from CRLF, CR or LF to $this->LE.
2853     * @access public
2854     * @param string $str String to fixEOL
2855     * @return string
2856     */
2857    public function fixEOL($str)
2858    {
2859        // Normalise to \n
2860        $nstr = str_replace(array("\r\n", "\r"), "\n", $str);
2861        // Now convert LE as needed
2862        if ($this->LE !== "\n") {
2863            $nstr = str_replace("\n", $this->LE, $nstr);
2864        }
2865        return $nstr;
2866    }
2867
2868    /**
2869     * Add a custom header.
2870     * $name value can be overloaded to contain
2871     * both header name and value (name:value)
2872     * @access public
2873     * @param string $name Custom header name
2874     * @param string $value Header value
2875     * @return void
2876     */
2877    public function addCustomHeader($name, $value = null)
2878    {
2879        if ($value === null) {
2880            // Value passed in as name:value
2881            $this->CustomHeader[] = explode(':', $name, 2);
2882        } else {
2883            $this->CustomHeader[] = array($name, $value);
2884        }
2885    }
2886
2887    /**
2888     * Create a message from an HTML string.
2889     * Automatically makes modifications for inline images and backgrounds
2890     * and creates a plain-text version by converting the HTML.
2891     * Overwrites any existing values in $this->Body and $this->AltBody
2892     * @access public
2893     * @param string $message HTML message string
2894     * @param string $basedir baseline directory for path
2895     * @param boolean|callable $advanced Whether to use the internal HTML to text converter
2896     *    or your own custom converter @see html2text()
2897     * @return string $message
2898     */
2899    public function msgHTML($message, $basedir = '', $advanced = false)
2900    {
2901        preg_match_all('/(src|background)=["\'](.*)["\']/Ui', $message, $images);
2902        if (isset($images[2])) {
2903            foreach ($images[2] as $imgindex => $url) {
2904                // Convert data URIs into embedded images
2905                if (preg_match('#^data:(image[^;,]*)(;base64)?,#', $url, $match)) {
2906                    $data = substr($url, strpos($url, ','));
2907                    if ($match[2]) {
2908                        $data = base64_decode($data);
2909                    } else {
2910                        $data = rawurldecode($data);
2911                    }
2912                    $cid = md5($url) . '@phpmailer.0'; // RFC2392 S 2
2913                    if ($this->addStringEmbeddedImage($data, $cid, '', 'base64', $match[1])) {
2914                        $message = str_replace(
2915                            $images[0][$imgindex],
2916                            $images[1][$imgindex] . '="cid:' . $cid . '"',
2917                            $message
2918                        );
2919                    }
2920                } elseif (!preg_match('#^[A-z]+://#', $url)) {
2921                    // Do not change urls for absolute images (thanks to corvuscorax)
2922                    $filename = basename($url);
2923                    $directory = dirname($url);
2924                    if ($directory == '.') {
2925                        $directory = '';
2926                    }
2927                    $cid = md5($url) . '@phpmailer.0'; // RFC2392 S 2
2928                    if (strlen($basedir) > 1 && substr($basedir, -1) != '/') {
2929                        $basedir .= '/';
2930                    }
2931                    if (strlen($directory) > 1 && substr($directory, -1) != '/') {
2932                        $directory .= '/';
2933                    }
2934                    if ($this->addEmbeddedImage(
2935                        $basedir . $directory . $filename,
2936                        $cid,
2937                        $filename,
2938                        'base64',
2939                        self::_mime_types((string)self::mb_pathinfo($filename, PATHINFO_EXTENSION))
2940                    )
2941                    ) {
2942                        $message = preg_replace(
2943                            '/' . $images[1][$imgindex] . '=["\']' . preg_quote($url, '/') . '["\']/Ui',
2944                            $images[1][$imgindex] . '="cid:' . $cid . '"',
2945                            $message
2946                        );
2947                    }
2948                }
2949            }
2950        }
2951        $this->isHTML(true);
2952        // Convert all message body line breaks to CRLF, makes quoted-printable encoding work much better
2953        $this->Body = $this->normalizeBreaks($message);
2954        $this->AltBody = $this->normalizeBreaks($this->html2text($message, $advanced));
2955        if (empty($this->AltBody)) {
2956            $this->AltBody = 'To view this email message, open it in a program that understands HTML!' .
2957                self::CRLF . self::CRLF;
2958        }
2959        return $this->Body;
2960    }
2961
2962    /**
2963     * Convert an HTML string into plain text.
2964     * This is used by msgHTML().
2965     * Note - older versions of this function used a bundled advanced converter
2966     * which was been removed for license reasons in #232
2967     * Example usage:
2968     * <code>
2969     * // Use default conversion
2970     * $plain = $mail->html2text($html);
2971     * // Use your own custom converter
2972     * $plain = $mail->html2text($html, function($html) {
2973     *     $converter = new MyHtml2text($html);
2974     *     return $converter->get_text();
2975     * });
2976     * </code>
2977     * @param string $html The HTML text to convert
2978     * @param boolean|callable $advanced Any boolean value to use the internal converter,
2979     *   or provide your own callable for custom conversion.
2980     * @return string
2981     */
2982    public function html2text($html, $advanced = false)
2983    {
2984        if (is_callable($advanced)) {
2985            return call_user_func($advanced, $html);
2986        }
2987        return html_entity_decode(
2988            trim(strip_tags(preg_replace('/<(head|title|style|script)[^>]*>.*?<\/\\1>/si', '', $html))),
2989            ENT_QUOTES,
2990            $this->CharSet
2991        );
2992    }
2993
2994    /**
2995     * Get the MIME type for a file extension.
2996     * @param string $ext File extension
2997     * @access public
2998     * @return string MIME type of file.
2999     * @static
3000     */
3001    public static function _mime_types($ext = '')
3002    {
3003        $mimes = array(
3004            'xl'    => 'application/excel',
3005            'js'    => 'application/javascript',
3006            'hqx'   => 'application/mac-binhex40',
3007            'cpt'   => 'application/mac-compactpro',
3008            'bin'   => 'application/macbinary',
3009            'doc'   => 'application/msword',
3010            'word'  => 'application/msword',
3011            'class' => 'application/octet-stream',
3012            'dll'   => 'application/octet-stream',
3013            'dms'   => 'application/octet-stream',
3014            'exe'   => 'application/octet-stream',
3015            'lha'   => 'application/octet-stream',
3016            'lzh'   => 'application/octet-stream',
3017            'psd'   => 'application/octet-stream',
3018            'sea'   => 'application/octet-stream',
3019            'so'    => 'application/octet-stream',
3020            'oda'   => 'application/oda',
3021            'pdf'   => 'application/pdf',
3022            'ai'    => 'application/postscript',
3023            'eps'   => 'application/postscript',
3024            'ps'    => 'application/postscript',
3025            'smi'   => 'application/smil',
3026            'smil'  => 'application/smil',
3027            'mif'   => 'application/vnd.mif',
3028            'xls'   => 'application/vnd.ms-excel',
3029            'ppt'   => 'application/vnd.ms-powerpoint',
3030            'wbxml' => 'application/vnd.wap.wbxml',
3031            'wmlc'  => 'application/vnd.wap.wmlc',
3032            'dcr'   => 'application/x-director',
3033            'dir'   => 'application/x-director',
3034            'dxr'   => 'application/x-director',
3035            'dvi'   => 'application/x-dvi',
3036            'gtar'  => 'application/x-gtar',
3037            'php3'  => 'application/x-httpd-php',
3038            'php4'  => 'application/x-httpd-php',
3039            'php'   => 'application/x-httpd-php',
3040            'phtml' => 'application/x-httpd-php',
3041            'phps'  => 'application/x-httpd-php-source',
3042            'swf'   => 'application/x-shockwave-flash',
3043            'sit'   => 'application/x-stuffit',
3044            'tar'   => 'application/x-tar',
3045            'tgz'   => 'application/x-tar',
3046            'xht'   => 'application/xhtml+xml',
3047            'xhtml' => 'application/xhtml+xml',
3048            'zip'   => 'application/zip',
3049            'mid'   => 'audio/midi',
3050            'midi'  => 'audio/midi',
3051            'mp2'   => 'audio/mpeg',
3052            'mp3'   => 'audio/mpeg',
3053            'mpga'  => 'audio/mpeg',
3054            'aif'   => 'audio/x-aiff',
3055            'aifc'  => 'audio/x-aiff',
3056            'aiff'  => 'audio/x-aiff',
3057            'ram'   => 'audio/x-pn-realaudio',
3058            'rm'    => 'audio/x-pn-realaudio',
3059            'rpm'   => 'audio/x-pn-realaudio-plugin',
3060            'ra'    => 'audio/x-realaudio',
3061            'wav'   => 'audio/x-wav',
3062            'bmp'   => 'image/bmp',
3063            'gif'   => 'image/gif',
3064            'jpeg'  => 'image/jpeg',
3065            'jpe'   => 'image/jpeg',
3066            'jpg'   => 'image/jpeg',
3067            'png'   => 'image/png',
3068            'tiff'  => 'image/tiff',
3069            'tif'   => 'image/tiff',
3070            'eml'   => 'message/rfc822',
3071            'css'   => 'text/css',
3072            'html'  => 'text/html',
3073            'htm'   => 'text/html',
3074            'shtml' => 'text/html',
3075            'log'   => 'text/plain',
3076            'text'  => 'text/plain',
3077            'txt'   => 'text/plain',
3078            'rtx'   => 'text/richtext',
3079            'rtf'   => 'text/rtf',
3080            'vcf'   => 'text/vcard',
3081            'vcard' => 'text/vcard',
3082            'xml'   => 'text/xml',
3083            'xsl'   => 'text/xml',
3084            'mpeg'  => 'video/mpeg',
3085            'mpe'   => 'video/mpeg',
3086            'mpg'   => 'video/mpeg',
3087            'mov'   => 'video/quicktime',
3088            'qt'    => 'video/quicktime',
3089            'rv'    => 'video/vnd.rn-realvideo',
3090            'avi'   => 'video/x-msvideo',
3091            'movie' => 'video/x-sgi-movie'
3092        );
3093        return (array_key_exists(strtolower($ext), $mimes) ? $mimes[strtolower($ext)]: 'application/octet-stream');
3094    }
3095
3096    /**
3097     * Map a file name to a MIME type.
3098     * Defaults to 'application/octet-stream', i.e.. arbitrary binary data.
3099     * @param string $filename A file name or full path, does not need to exist as a file
3100     * @return string
3101     * @static
3102     */
3103    public static function filenameToType($filename)
3104    {
3105        // In case the path is a URL, strip any query string before getting extension
3106        $qpos = strpos($filename, '?');
3107        if (false !== $qpos) {
3108            $filename = substr($filename, 0, $qpos);
3109        }
3110        $pathinfo = self::mb_pathinfo($filename);
3111        return self::_mime_types($pathinfo['extension']);
3112    }
3113
3114    /**
3115     * Multi-byte-safe pathinfo replacement.
3116     * Drop-in replacement for pathinfo(), but multibyte-safe, cross-platform-safe, old-version-safe.
3117     * Works similarly to the one in PHP >= 5.2.0
3118     * @link http://www.php.net/manual/en/function.pathinfo.php#107461
3119     * @param string $path A filename or path, does not need to exist as a file
3120     * @param integer|string $options Either a PATHINFO_* constant,
3121     *      or a string name to return only the specified piece, allows 'filename' to work on PHP < 5.2
3122     * @return string|array
3123     * @static
3124     */
3125    public static function mb_pathinfo($path, $options = null)
3126    {
3127        $ret = array('dirname' => '', 'basename' => '', 'extension' => '', 'filename' => '');
3128        $pathinfo = array();
3129        if (preg_match('%^(.*?)[\\\\/]*(([^/\\\\]*?)(\.([^\.\\\\/]+?)|))[\\\\/\.]*$%im', $path, $pathinfo)) {
3130            if (array_key_exists(1, $pathinfo)) {
3131                $ret['dirname'] = $pathinfo[1];
3132            }
3133            if (array_key_exists(2, $pathinfo)) {
3134                $ret['basename'] = $pathinfo[2];
3135            }
3136            if (array_key_exists(5, $pathinfo)) {
3137                $ret['extension'] = $pathinfo[5];
3138            }
3139            if (array_key_exists(3, $pathinfo)) {
3140                $ret['filename'] = $pathinfo[3];
3141            }
3142        }
3143        switch ($options) {
3144            case PATHINFO_DIRNAME:
3145            case 'dirname':
3146                return $ret['dirname'];
3147            case PATHINFO_BASENAME:
3148            case 'basename':
3149                return $ret['basename'];
3150            case PATHINFO_EXTENSION:
3151            case 'extension':
3152                return $ret['extension'];
3153            case PATHINFO_FILENAME:
3154            case 'filename':
3155                return $ret['filename'];
3156            default:
3157                return $ret;
3158        }
3159    }
3160
3161    /**
3162     * Set or reset instance properties.
3163     * You should avoid this function - it's more verbose, less efficient, more error-prone and
3164     * harder to debug than setting properties directly.
3165     * Usage Example:
3166     * `$mail->set('SMTPSecure', 'tls');`
3167     *   is the same as:
3168     * `$mail->SMTPSecure = 'tls';`
3169     * @access public
3170     * @param string $name The property name to set
3171     * @param mixed $value The value to set the property to
3172     * @return boolean
3173     * @TODO Should this not be using the __set() magic function?
3174     */
3175    public function set($name, $value = '')
3176    {
3177        if (property_exists($this, $name)) {
3178            $this->$name = $value;
3179            return true;
3180        } else {
3181            $this->setError($this->lang('variable_set') . $name);
3182            return false;
3183        }
3184    }
3185
3186    /**
3187     * Strip newlines to prevent header injection.
3188     * @access public
3189     * @param string $str
3190     * @return string
3191     */
3192    public function secureHeader($str)
3193    {
3194        return trim(str_replace(array("\r", "\n"), '', $str));
3195    }
3196
3197    /**
3198     * Normalize line breaks in a string.
3199     * Converts UNIX LF, Mac CR and Windows CRLF line breaks into a single line break format.
3200     * Defaults to CRLF (for message bodies) and preserves consecutive breaks.
3201     * @param string $text
3202     * @param string $breaktype What kind of line break to use, defaults to CRLF
3203     * @return string
3204     * @access public
3205     * @static
3206     */
3207    public static function normalizeBreaks($text, $breaktype = "\r\n")
3208    {
3209        return preg_replace('/(\r\n|\r|\n)/ms', $breaktype, $text);
3210    }
3211
3212
3213    /**
3214     * Set the public and private key files and password for S/MIME signing.
3215     * @access public
3216     * @param string $cert_filename
3217     * @param string $key_filename
3218     * @param string $key_pass Password for private key
3219     */
3220    public function sign($cert_filename, $key_filename, $key_pass)
3221    {
3222        $this->sign_cert_file = $cert_filename;
3223        $this->sign_key_file = $key_filename;
3224        $this->sign_key_pass = $key_pass;
3225    }
3226
3227    /**
3228     * Quoted-Printable-encode a DKIM header.
3229     * @access public
3230     * @param string $txt
3231     * @return string
3232     */
3233    public function DKIM_QP($txt)
3234    {
3235        $line = '';
3236        for ($i = 0; $i < strlen($txt); $i++) {
3237            $ord = ord($txt[$i]);
3238            if (((0x21 <= $ord) && ($ord <= 0x3A)) || $ord == 0x3C || ((0x3E <= $ord) && ($ord <= 0x7E))) {
3239                $line .= $txt[$i];
3240            } else {
3241                $line .= '=' . sprintf('%02X', $ord);
3242            }
3243        }
3244        return $line;
3245    }
3246
3247    /**
3248     * Generate a DKIM signature.
3249     * @access public
3250     * @param string $signHeader
3251     * @throws phpmailerException
3252     * @return string
3253     */
3254    public function DKIM_Sign($signHeader)
3255    {
3256        if (!defined('PKCS7_TEXT')) {
3257            if ($this->exceptions) {
3258                throw new phpmailerException($this->lang('signing') . ' OpenSSL extension missing.');
3259            }
3260            return '';
3261        }
3262        $privKeyStr = file_get_contents($this->DKIM_private);
3263        if ($this->DKIM_passphrase != '') {
3264            $privKey = openssl_pkey_get_private($privKeyStr, $this->DKIM_passphrase);
3265        } else {
3266            $privKey = $privKeyStr;
3267        }
3268        if (openssl_sign($signHeader, $signature, $privKey)) {
3269            return base64_encode($signature);
3270        }
3271        return '';
3272    }
3273
3274    /**
3275     * Generate a DKIM canonicalization header.
3276     * @access public
3277     * @param string $signHeader Header
3278     * @return string
3279     */
3280    public function DKIM_HeaderC($signHeader)
3281    {
3282        $signHeader = preg_replace('/\r\n\s+/', ' ', $signHeader);
3283        $lines = explode("\r\n", $signHeader);
3284        foreach ($lines as $key => $line) {
3285            list($heading, $value) = explode(':', $line, 2);
3286            $heading = strtolower($heading);
3287            $value = preg_replace('/\s+/', ' ', $value); // Compress useless spaces
3288            $lines[$key] = $heading . ':' . trim($value); // Don't forget to remove WSP around the value
3289        }
3290        $signHeader = implode("\r\n", $lines);
3291        return $signHeader;
3292    }
3293
3294    /**
3295     * Generate a DKIM canonicalization body.
3296     * @access public
3297     * @param string $body Message Body
3298     * @return string
3299     */
3300    public function DKIM_BodyC($body)
3301    {
3302        if ($body == '') {
3303            return "\r\n";
3304        }
3305        // stabilize line endings
3306        $body = str_replace("\r\n", "\n", $body);
3307        $body = str_replace("\n", "\r\n", $body);
3308        // END stabilize line endings
3309        while (substr($body, strlen($body) - 4, 4) == "\r\n\r\n") {
3310            $body = substr($body, 0, strlen($body) - 2);
3311        }
3312        return $body;
3313    }
3314
3315    /**
3316     * Create the DKIM header and body in a new message header.
3317     * @access public
3318     * @param string $headers_line Header lines
3319     * @param string $subject Subject
3320     * @param string $body Body
3321     * @return string
3322     */
3323    public function DKIM_Add($headers_line, $subject, $body)
3324    {
3325        $DKIMsignatureType = 'rsa-sha1'; // Signature & hash algorithms
3326        $DKIMcanonicalization = 'relaxed/simple'; // Canonicalization of header/body
3327        $DKIMquery = 'dns/txt'; // Query method
3328        $DKIMtime = time(); // Signature Timestamp = seconds since 00:00:00 - Jan 1, 1970 (UTC time zone)
3329        $subject_header = "Subject: $subject";
3330        $headers = explode($this->LE, $headers_line);
3331        $from_header = '';
3332        $to_header = '';
3333        $current = '';
3334        foreach ($headers as $header) {
3335            if (strpos($header, 'From:') === 0) {
3336                $from_header = $header;
3337                $current = 'from_header';
3338            } elseif (strpos($header, 'To:') === 0) {
3339                $to_header = $header;
3340                $current = 'to_header';
3341            } else {
3342                if ($current && strpos($header, ' =?') === 0) {
3343                    $current .= $header;
3344                } else {
3345                    $current = '';
3346                }
3347            }
3348        }
3349        $from = str_replace('|', '=7C', $this->DKIM_QP($from_header));
3350        $to = str_replace('|', '=7C', $this->DKIM_QP($to_header));
3351        $subject = str_replace(
3352            '|',
3353            '=7C',
3354            $this->DKIM_QP($subject_header)
3355        ); // Copied header fields (dkim-quoted-printable)
3356        $body = $this->DKIM_BodyC($body);
3357        $DKIMlen = strlen($body); // Length of body
3358        $DKIMb64 = base64_encode(pack('H*', sha1($body))); // Base64 of packed binary SHA-1 hash of body
3359        $ident = ($this->DKIM_identity == '') ? '' : ' i=' . $this->DKIM_identity . ';';
3360        $dkimhdrs = 'DKIM-Signature: v=1; a=' .
3361            $DKIMsignatureType . '; q=' .
3362            $DKIMquery . '; l=' .
3363            $DKIMlen . '; s=' .
3364            $this->DKIM_selector .
3365            ";\r\n" .
3366            "\tt=" . $DKIMtime . '; c=' . $DKIMcanonicalization . ";\r\n" .
3367            "\th=From:To:Subject;\r\n" .
3368            "\td=" . $this->DKIM_domain . ';' . $ident . "\r\n" .
3369            "\tz=$from\r\n" .
3370            "\t|$to\r\n" .
3371            "\t|$subject;\r\n" .
3372            "\tbh=" . $DKIMb64 . ";\r\n" .
3373            "\tb=";
3374        $toSign = $this->DKIM_HeaderC(
3375            $from_header . "\r\n" . $to_header . "\r\n" . $subject_header . "\r\n" . $dkimhdrs
3376        );
3377        $signed = $this->DKIM_Sign($toSign);
3378        return $dkimhdrs . $signed . "\r\n";
3379    }
3380
3381    /**
3382     * Allows for public read access to 'to' property.
3383     * @access public
3384     * @return array
3385     */
3386    public function getToAddresses()
3387    {
3388        return $this->to;
3389    }
3390
3391    /**
3392     * Allows for public read access to 'cc' property.
3393     * @access public
3394     * @return array
3395     */
3396    public function getCcAddresses()
3397    {
3398        return $this->cc;
3399    }
3400
3401    /**
3402     * Allows for public read access to 'bcc' property.
3403     * @access public
3404     * @return array
3405     */
3406    public function getBccAddresses()
3407    {
3408        return $this->bcc;
3409    }
3410
3411    /**
3412     * Allows for public read access to 'ReplyTo' property.
3413     * @access public
3414     * @return array
3415     */
3416    public function getReplyToAddresses()
3417    {
3418        return $this->ReplyTo;
3419    }
3420
3421    /**
3422     * Allows for public read access to 'all_recipients' property.
3423     * @access public
3424     * @return array
3425     */
3426    public function getAllRecipientAddresses()
3427    {
3428        return $this->all_recipients;
3429    }
3430
3431    /**
3432     * Perform a callback.
3433     * @param boolean $isSent
3434     * @param array $to
3435     * @param array $cc
3436     * @param array $bcc
3437     * @param string $subject
3438     * @param string $body
3439     * @param string $from
3440     */
3441    protected function doCallback($isSent, $to, $cc, $bcc, $subject, $body, $from)
3442    {
3443        if (!empty($this->action_function) && is_callable($this->action_function)) {
3444            $params = array($isSent, $to, $cc, $bcc, $subject, $body, $from);
3445            call_user_func_array($this->action_function, $params);
3446        }
3447    }
3448}
3449
3450/**
3451 * PHPMailer exception handler
3452 * @package PHPMailer
3453 */
3454class phpmailerException extends Exception
3455{
3456    /**
3457     * Prettify error message output
3458     * @return string
3459     */
3460    public function errorMessage()
3461    {
3462        $errorMsg = '<strong>' . $this->getMessage() . "</strong><br />\n";
3463        return $errorMsg;
3464    }
3465}