PageRenderTime 49ms CodeModel.GetById 13ms RepoModel.GetById 1ms app.codeStats 0ms

/protected/extensions/mailer/phpmailer/class.phpmailer.php

https://bitbucket.org/RSol/fotobank
PHP | 2068 lines | 1389 code | 154 blank | 525 comment | 211 complexity | 649d9538bfa7906485cabf6cecb6750c MD5 | raw file
Possible License(s): MIT, LGPL-2.1, BSD-3-Clause, Apache-2.0

Large files files are truncated, but you can click here to view the full file

    

  1. <?php

    2. 

  2. /*~ class.phpmailer.php

    3. 

  3. .---------------------------------------------------------------------------.

    4. 

  4. |  Software: PHPMailer - PHP email class                                    |

    5. 

  5. |   Version: 5.0.0                                                          |

    6. 

  6. |   Contact: via sourceforge.net support pages (also www.codeworxtech.com)  |

    7. 

  7. |      Info: http://phpmailer.sourceforge.net                               |

    8. 

  8. |   Support: http://sourceforge.net/projects/phpmailer/                     |

    9. 

  9. | ------------------------------------------------------------------------- |

    10. 

  10. |     Admin: Andy Prevost (project admininistrator)                         |

    11. 

  11. |   Authors: Andy Prevost (codeworxtech) codeworxtech@users.sourceforge.net |

    12. 

  12. |          : Marcus Bointon (coolbru) coolbru@users.sourceforge.net         |

    13. 

  13. |   Founder: Brent R. Matzelle (original founder)                           |

    14. 

  14. | Copyright (c) 2004-2009, Andy Prevost. All Rights Reserved.               |

    15. 

  15. | Copyright (c) 2001-2003, Brent R. Matzelle                                |

    16. 

  16. | ------------------------------------------------------------------------- |

    17. 

  17. |   License: Distributed under the Lesser General Public License (LGPL)     |

    18. 

  18. |            http://www.gnu.org/copyleft/lesser.html                        |

    19. 

  19. | This program is distributed in the hope that it will be useful - WITHOUT  |

    20. 

  20. | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or     |

    21. 

  21. | FITNESS FOR A PARTICULAR PURPOSE.                                         |

    22. 

  22. | ------------------------------------------------------------------------- |

    23. 

  23. | We offer a number of paid services (www.codeworxtech.com):                |

    24. 

  24. | - Web Hosting on highly optimized fast and secure servers                 |

    25. 

  25. | - Technology Consulting                                                   |

    26. 

  26. | - Oursourcing (highly qualified programmers and graphic designers)        |

    27. 

  27. '---------------------------------------------------------------------------'

    28. 

  28. */

    29. 

  29. 

    30. 

  30. /**

    31. 

  31.  * PHPMailer - PHP email transport class

    32. 

  32.  * NOTE: Requires PHP version 5 or later

    33. 

  33.  * @package PHPMailer

    34. 

  34.  * @author Andy Prevost

    35. 

  35.  * @author Marcus Bointon

    36. 

  36.  * @copyright 2004 - 2009 Andy Prevost

    37. 

  37.  * @version $Id: class.phpmailer.php 254 2009-04-02 18:52:18Z codeworxtech $

    38. 

  38.  * @license http://www.gnu.org/copyleft/lesser.html GNU Lesser General Public License

    39. 

  39.  */

    40. 

  40. 

    41. 

  41. if (version_compare(PHP_VERSION, '5.0.0', '<') ) exit("Sorry, this version of PHPMailer will only run on PHP version 5 or greater!\n");

    42. 

  42. 

    43. 

  43. class PHPMailer {

    44. 

  44. 

    45. 

  45.   /////////////////////////////////////////////////

    46. 

  46.   // PROPERTIES, PUBLIC

    47. 

  47.   /////////////////////////////////////////////////

    48. 

  48. 

    49. 

  49.   /**

    50. 

  50.    * Email priority (1 = High, 3 = Normal, 5 = low).

    51. 

  51.    * @var int

    52. 

  52.    */

    53. 

  53.   public $Priority          = 3;

    54. 

  54. 

    55. 

  55.   /**

    56. 

  56.    * Sets the CharSet of the message.

    57. 

  57.    * @var string

    58. 

  58.    */

    59. 

  59.   public $CharSet           = 'iso-8859-1';

    60. 

  60. 

    61. 

  61.   /**

    62. 

  62.    * Sets the Content-type of the message.

    63. 

  63.    * @var string

    64. 

  64.    */

    65. 

  65.   public $ContentType       = 'text/plain';

    66. 

  66. 

    67. 

  67.   /**

    68. 

  68.    * Sets the Encoding of the message. Options for this are

    69. 

  69.    *  "8bit", "7bit", "binary", "base64", and "quoted-printable".

    70. 

  70.    * @var string

    71. 

  71.    */

    72. 

  72.   public $Encoding          = '8bit';

    73. 

  73. 

    74. 

  74.   /**

    75. 

  75.    * Holds the most recent mailer error message.

    76. 

  76.    * @var string

    77. 

  77.    */

    78. 

  78.   public $ErrorInfo         = '';

    79. 

  79. 

    80. 

  80.   /**

    81. 

  81.    * Sets the From email address for the message.

    82. 

  82.    * @var string

    83. 

  83.    */

    84. 

  84.   public $From              = 'root@localhost';

    85. 

  85. 

    86. 

  86.   /**

    87. 

  87.    * Sets the From name of the message.

    88. 

  88.    * @var string

    89. 

  89.    */

    90. 

  90.   public $FromName          = 'Root User';

    91. 

  91. 

    92. 

  92.   /**

    93. 

  93.    * Sets the Sender email (Return-Path) of the message.  If not empty,

    94. 

  94.    * will be sent via -f to sendmail or as 'MAIL FROM' in smtp mode.

    95. 

  95.    * @var string

    96. 

  96.    */

    97. 

  97.   public $Sender            = '';

    98. 

  98. 

    99. 

  99.   /**

    100. 

  100.    * Sets the Subject of the message.

    101. 

  101.    * @var string

    102. 

  102.    */

    103. 

  103.   public $Subject           = '';

    104. 

  104. 

    105. 

  105.   /**

    106. 

  106.    * Sets the Body of the message.  This can be either an HTML or text body.

    107. 

  107.    * If HTML then run IsHTML(true).

    108. 

  108.    * @var string

    109. 

  109.    */

    110. 

  110.   public $Body              = '';

    111. 

  111. 

    112. 

  112.   /**

    113. 

  113.    * Sets the text-only body of the message.  This automatically sets the

    114. 

  114.    * email to multipart/alternative.  This body can be read by mail

    115. 

  115.    * clients that do not have HTML email capability such as mutt. Clients

    116. 

  116.    * that can read HTML will view the normal Body.

    117. 

  117.    * @var string

    118. 

  118.    */

    119. 

  119.   public $AltBody           = '';

    120. 

  120. 

    121. 

  121.   /**

    122. 

  122.    * Sets word wrapping on the body of the message to a given number of

    123. 

  123.    * characters.

    124. 

  124.    * @var int

    125. 

  125.    */

    126. 

  126.   public $WordWrap          = 0;

    127. 

  127. 

    128. 

  128.   /**

    129. 

  129.    * Method to send mail: ("mail", "sendmail", or "smtp").

    130. 

  130.    * @var string

    131. 

  131.    */

    132. 

  132.   public $Mailer            = 'mail';

    133. 

  133. 

    134. 

  134.   /**

    135. 

  135.    * Sets the path of the sendmail program.

    136. 

  136.    * @var string

    137. 

  137.    */

    138. 

  138.   public $Sendmail          = '/usr/sbin/sendmail';

    139. 

  139. 

    140. 

  140.   /**

    141. 

  141.    * Path to PHPMailer plugins.  Useful if the SMTP class

    142. 

  142.    * is in a different directory than the PHP include path.

    143. 

  143.    * @var string

    144. 

  144.    */

    145. 

  145.   public $PluginDir         = '';

    146. 

  146. 

    147. 

  147.   /**

    148. 

  148.    * Sets the email address that a reading confirmation will be sent.

    149. 

  149.    * @var string

    150. 

  150.    */

    151. 

  151.   public $ConfirmReadingTo  = '';

    152. 

  152. 

    153. 

  153.   /**

    154. 

  154.    * Sets the hostname to use in Message-Id and Received headers

    155. 

  155.    * and as default HELO string. If empty, the value returned

    156. 

  156.    * by SERVER_NAME is used or 'localhost.localdomain'.

    157. 

  157.    * @var string

    158. 

  158.    */

    159. 

  159.   public $Hostname          = '';

    160. 

  160. 

    161. 

  161.   /**

    162. 

  162.    * Sets the message ID to be used in the Message-Id header.

    163. 

  163.    * If empty, a unique id will be generated.

    164. 

  164.    * @var string

    165. 

  165.    */

    166. 

  166.   public $MessageID         = '';

    167. 

  167. 

    168. 

  168.   /////////////////////////////////////////////////

    169. 

  169.   // PROPERTIES FOR SMTP

    170. 

  170.   /////////////////////////////////////////////////

    171. 

  171. 

    172. 

  172.   /**

    173. 

  173.    * Sets the SMTP hosts.  All hosts must be separated by a

    174. 

  174.    * semicolon.  You can also specify a different port

    175. 

  175.    * for each host by using this format: [hostname:port]

    176. 

  176.    * (e.g. "smtp1.example.com:25;smtp2.example.com").

    177. 

  177.    * Hosts will be tried in order.

    178. 

  178.    * @var string

    179. 

  179.    */

    180. 

  180.   public $Host          = 'localhost';

    181. 

  181. 

    182. 

  182.   /**

    183. 

  183.    * Sets the default SMTP server port.

    184. 

  184.    * @var int

    185. 

  185.    */

    186. 

  186.   public $Port          = 25;

    187. 

  187. 

    188. 

  188.   /**

    189. 

  189.    * Sets the SMTP HELO of the message (Default is $Hostname).

    190. 

  190.    * @var string

    191. 

  191.    */

    192. 

  192.   public $Helo          = '';

    193. 

  193. 

    194. 

  194.   /**

    195. 

  195.    * Sets connection prefix.

    196. 

  196.    * Options are "", "ssl" or "tls"

    197. 

  197.    * @var string

    198. 

  198.    */

    199. 

  199.   public $SMTPSecure    = '';

    200. 

  200. 

    201. 

  201.   /**

    202. 

  202.    * Sets SMTP authentication. Utilizes the Username and Password variables.

    203. 

  203.    * @var bool

    204. 

  204.    */

    205. 

  205.   public $SMTPAuth      = false;

    206. 

  206. 

    207. 

  207.   /**

    208. 

  208.    * Sets SMTP username.

    209. 

  209.    * @var string

    210. 

  210.    */

    211. 

  211.   public $Username      = '';

    212. 

  212. 

    213. 

  213.   /**

    214. 

  214.    * Sets SMTP password.

    215. 

  215.    * @var string

    216. 

  216.    */

    217. 

  217.   public $Password      = '';

    218. 

  218. 

    219. 

  219.   /**

    220. 

  220.    * Sets the SMTP server timeout in seconds.

    221. 

  221.    * This function will not work with the win32 version.

    222. 

  222.    * @var int

    223. 

  223.    */

    224. 

  224.   public $Timeout       = 10;

    225. 

  225. 

    226. 

  226.   /**

    227. 

  227.    * Sets SMTP class debugging on or off.

    228. 

  228.    * @var bool

    229. 

  229.    */

    230. 

  230.   public $SMTPDebug     = false;

    231. 

  231. 

    232. 

  232.   /**

    233. 

  233.    * Prevents the SMTP connection from being closed after each mail

    234. 

  234.    * sending.  If this is set to true then to close the connection

    235. 

  235.    * requires an explicit call to SmtpClose().

    236. 

  236.    * @var bool

    237. 

  237.    */

    238. 

  238.   public $SMTPKeepAlive = false;

    239. 

  239. 

    240. 

  240.   /**

    241. 

  241.    * Provides the ability to have the TO field process individual

    242. 

  242.    * emails, instead of sending to entire TO addresses

    243. 

  243.    * @var bool

    244. 

  244.    */

    245. 

  245.   public $SingleTo      = false;

    246. 

  246. 

    247. 

  247.   /**

    248. 

  248.    * Provides the ability to change the line ending

    249. 

  249.    * @var string

    250. 

  250.    */

    251. 

  251.   public $LE              = "\n";

    252. 

  252. 

    253. 

  253.   /////////////////////////////////////////////////

    254. 

  254.   // PROPERTIES, PRIVATE AND PROTECTED

    255. 

  255.   /////////////////////////////////////////////////

    256. 

  256. 

    257. 

  257.   private   $smtp           = NULL;

    258. 

  258.   private   $to             = array();

    259. 

  259.   private   $cc             = array();

    260. 

  260.   private   $bcc            = array();

    261. 

  261.   private   $ReplyTo        = array();

    262. 

  262.   private   $all_recipients = array();

    263. 

  263.   private   $attachment     = array();

    264. 

  264.   private   $CustomHeader   = array();

    265. 

  265.   private   $message_type   = '';

    266. 

  266.   private   $boundary       = array();

    267. 

  267.   protected $language       = array();

    268. 

  268.   private   $error_count    = 0;

    269. 

  269.   private   $sign_cert_file = "";

    270. 

  270.   private   $sign_key_file  = "";

    271. 

  271.   private   $sign_key_pass  = "";

    272. 

  272.   private   $exceptions     = false;

    273. 

  273. 

    274. 

  274.   /////////////////////////////////////////////////

    275. 

  275.   // CONSTANTS

    276. 

  276.   /////////////////////////////////////////////////

    277. 

  277. 

    278. 

  278.   const VERSION = '5.0.0';

    279. 

  279.   const STOP_MESSAGE = 0; // message only, continue processing

    280. 

  280.   const STOP_CONTINUE = 1; // message?, likely ok to continue processing

    281. 

  281.   const STOP_CRITICAL = 2; // message, plus full stop, critical error reached

    282. 

  282. 

    283. 

  283.   /////////////////////////////////////////////////

    284. 

  284.   // METHODS, VARIABLES

    285. 

  285.   /////////////////////////////////////////////////

    286. 

  286. 

    287. 

  287.   /**

    288. 

  288.    * Constructor

    289. 

  289.    * @param boolean $exceptions Should we throw external exceptions?

    290. 

  290.    */

    291. 

  291.   public function __construct($exceptions = false) {

    292. 

  292.     $this->exceptions = ($exceptions == true);

    293. 

  293.   }

    294. 

  294. 

    295. 

  295.   /**

    296. 

  296.    * Sets message type to HTML.

    297. 

  297.    * @param bool $ishtml

    298. 

  298.    * @return void

    299. 

  299.    */

    300. 

  300.   public function IsHTML($ishtml = true) {

    301. 

  301.     if ($ishtml) {

    302. 

  302.       $this->ContentType = 'text/html';

    303. 

  303.     } else {

    304. 

  304.       $this->ContentType = 'text/plain';

    305. 

  305.     }

    306. 

  306.   }

    307. 

  307. 

    308. 

  308.   /**

    309. 

  309.    * Sets Mailer to send message using SMTP.

    310. 

  310.    * @return void

    311. 

  311.    */

    312. 

  312.   public function IsSMTP() {

    313. 

  313.     $this->Mailer = 'smtp';

    314. 

  314.   }

    315. 

  315. 

    316. 

  316.   /**

    317. 

  317.    * Sets Mailer to send message using PHP mail() function.

    318. 

  318.    * @return void

    319. 

  319.    */

    320. 

  320.   public function IsMail() {

    321. 

  321.     $this->Mailer = 'mail';

    322. 

  322.   }

    323. 

  323. 

    324. 

  324.   /**

    325. 

  325.    * Sets Mailer to send message using the $Sendmail program.

    326. 

  326.    * @return void

    327. 

  327.    */

    328. 

  328.   public function IsSendmail() {

    329. 

  329.     if (!stristr(ini_get('sendmail_path'), 'sendmail')) {

    330. 

  330.       $this->Sendmail = '/var/qmail/bin/sendmail';

    331. 

  331.     }

    332. 

  332.     $this->Mailer = 'sendmail';

    333. 

  333.   }

    334. 

  334. 

    335. 

  335.   /**

    336. 

  336.    * Sets Mailer to send message using the qmail MTA.

    337. 

  337.    * @return void

    338. 

  338.    */

    339. 

  339.   public function IsQmail() {

    340. 

  340.     if (stristr(ini_get('sendmail_path'), 'qmail')) {

    341. 

  341.       $this->Sendmail = '/var/qmail/bin/sendmail';

    342. 

  342.     }

    343. 

  343.     $this->Mailer = 'sendmail';

    344. 

  344.   }

    345. 

  345. 

    346. 

  346.   /////////////////////////////////////////////////

    347. 

  347.   // METHODS, RECIPIENTS

    348. 

  348.   /////////////////////////////////////////////////

    349. 

  349. 

    350. 

  350.   /**

    351. 

  351.    * Adds a "To" address.

    352. 

  352.    * @param string $address

    353. 

  353.    * @param string $name

    354. 

  354.    * @return boolean true on success, false if address already used

    355. 

  355.    */

    356. 

  356.   public function AddAddress($address, $name = '') {

    357. 

  357.     return $this->AddAnAddress('to', $address, $name);

    358. 

  358.   }

    359. 

  359. 

    360. 

  360.   /**

    361. 

  361.    * Adds a "Cc" address.

    362. 

  362.    * Note: this function works with the SMTP mailer on win32, not with the "mail" mailer.

    363. 

  363.    * @param string $address

    364. 

  364.    * @param string $name

    365. 

  365.    * @return boolean true on success, false if address already used

    366. 

  366.    */

    367. 

  367.   public function AddCC($address, $name = '') {

    368. 

  368.     return $this->AddAnAddress('cc', $address, $name);

    369. 

  369.   }

    370. 

  370. 

    371. 

  371.   /**

    372. 

  372.    * Adds a "Bcc" address.

    373. 

  373.    * Note: this function works with the SMTP mailer on win32, not with the "mail" mailer.

    374. 

  374.    * @param string $address

    375. 

  375.    * @param string $name

    376. 

  376.    * @return boolean true on success, false if address already used

    377. 

  377.    */

    378. 

  378.   public function AddBCC($address, $name = '') {

    379. 

  379.     return $this->AddAnAddress('bcc', $address, $name);

    380. 

  380.   }

    381. 

  381. 

    382. 

  382.   /**

    383. 

  383.    * Adds a "Reply-to" address.

    384. 

  384.    * @param string $address

    385. 

  385.    * @param string $name

    386. 

  386.    * @return boolean

    387. 

  387.    */

    388. 

  388.   public function AddReplyTo($address, $name = '') {

    389. 

  389.     return $this->AddAnAddress('ReplyTo', $address, $name);

    390. 

  390.   }

    391. 

  391. 

    392. 

  392.   /**

    393. 

  393.    * Adds an address to one of the recipient arrays

    394. 

  394.    * Addresses that have been added already return false, but do not throw exceptions

    395. 

  395.    * @param string $kind One of 'to', 'cc', 'bcc', 'ReplyTo'

    396. 

  396.    * @param string $address The email address to send to

    397. 

  397.    * @param string $name

    398. 

  398.    * @return boolean true on success, false if address already used or invalid in some way

    399. 

  399.    * @access private

    400. 

  400.    */

    401. 

  401.   private function AddAnAddress($kind, $address, $name = '') {

    402. 

  402.     if (!preg_match('/^(to|cc|bcc|ReplyTo)$/', $kind)) {

    403. 

  403.       echo 'Invalid recipient array: ' . kind;

    404. 

  404.       return false;

    405. 

  405.     }

    406. 

  406.     $address = trim($address);

    407. 

  407.     $name = trim(preg_replace('/[\r\n]+/', '', $name)); //Strip breaks and trim

    408. 

  408.     if (!self::ValidateAddress($address)) {

    409. 

  409.       $this->SetError($this->Lang('invalid_address').': '. $address);

    410. 

  410.       if ($this->exceptions) {

    411. 

  411.         throw new phpmailerException($this->Lang('invalid_address').': '.$address);

    412. 

  412.       }

    413. 

  413.       echo $this->Lang('invalid_address').': '.$address;

    414. 

  414.       return false;

    415. 

  415.     }

    416. 

  416.   if ($kind != 'ReplyTo') {

    417. 

  417.     if (!isset($this->all_recipients[strtolower($address)])) {

    418. 

  418.         array_push($this->$kind, array($address, $name));

    419. 

  419.         $this->all_recipients[strtolower($address)] = true;

    420. 

  420.     return true;

    421. 

  421.       }

    422. 

  422.   } else {

    423. 

  423.     if (!array_key_exists(strtolower($address), $this->ReplyTo)) {

    424. 

  424.         $this->ReplyTo[strtolower($address)] = array($address, $name);

    425. 

  425.     return true;

    426. 

  426.     }

    427. 

  427.   }

    428. 

  428.     return false;

    429. 

  429.   }

    430. 

  430. 

    431. 

  431. /**

    432. 

  432.  * Set the From and FromName properties

    433. 

  433.  * @param string $address

    434. 

  434.  * @param string $name

    435. 

  435.  * @return boolean

    436. 

  436.  */

    437. 

  437.   public function SetFrom($address, $name = '') {

    438. 

  438.     $address = trim($address);

    439. 

  439.     $name = trim(preg_replace('/[\r\n]+/', '', $name)); //Strip breaks and trim

    440. 

  440.     if (!self::ValidateAddress($address)) {

    441. 

  441.       $this->SetError($this->Lang('invalid_address').': '. $address);

    442. 

  442.       if ($this->exceptions) {

    443. 

  443.         throw new phpmailerException($this->Lang('invalid_address').': '.$address);

    444. 

  444.       }

    445. 

  445.       echo $this->Lang('invalid_address').': '.$address;

    446. 

  446.       return false;

    447. 

  447.     }

    448. 

  448.   $this->From = $address;

    449. 

  449.   $this->FromName = $name;

    450. 

  450.   return true;

    451. 

  451.   }

    452. 

  452. 

    453. 

  453.   /**

    454. 

  454.    * Check that a string looks roughly like an email address should

    455. 

  455.    * Static so it can be used without instantiation

    456. 

  456.    * Tries to use PHP built-in validator in the filter extension (from PHP 5.2), falls back to a reasonably competent regex validator

    457. 

  457.    * Conforms approximately to RFC2822

    458. 

  458.    * @link http://www.hexillion.com/samples/#Regex Original pattern found here

    459. 

  459.    * @param string $address The email address to check

    460. 

  460.    * @return boolean

    461. 

  461.    * @static

    462. 

  462.    * @access public

    463. 

  463.    */

    464. 

  464.   public static function ValidateAddress($address) {

    465. 

  465.     if (0 && function_exists('filter_var')) { //Introduced in PHP 5.2

    466. 

  466.       if(filter_var($address, FILTER_VALIDATE_EMAIL) === FALSE) {

    467. 

  467.         return false;

    468. 

  468.       } else {

    469. 

  469.         return true;

    470. 

  470.       }

    471. 

  471.     } else {

    472. 

  472.       return preg_match('/^(?:[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+\.)*[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+@(?:(?:(?:[a-zA-Z0-9_](?:[a-zA-Z0-9_\-](?!\.)){0,61}[a-zA-Z0-9_-]?\.)+[a-zA-Z0-9_](?:[a-zA-Z0-9_\-](?!$)){0,61}[a-zA-Z0-9_]?)|(?:\[(?:(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\]))$/', $address);

    473. 

  473.     }

    474. 

  474.   }

    475. 

  475. 

    476. 

  476.   /////////////////////////////////////////////////

    477. 

  477.   // METHODS, MAIL SENDING

    478. 

  478.   /////////////////////////////////////////////////

    479. 

  479. 

    480. 

  480.   /**

    481. 

  481.    * Creates message and assigns Mailer. If the message is

    482. 

  482.    * not sent successfully then it returns false.  Use the ErrorInfo

    483. 

  483.    * variable to view description of the error.

    484. 

  484.    * @return bool

    485. 

  485.    */

    486. 

  486.   public function Send() {

    487. 

  487.     try {

    488. 

  488.       if ((count($this->to) + count($this->cc) + count($this->bcc)) < 1) {

    489. 

  489.         throw new phpmailerException($this->Lang('provide_address'), self::STOP_CRITICAL);

    490. 

  490.       }

    491. 

  491. 

    492. 

  492.       // Set whether the message is multipart/alternative

    493. 

  493.       if(!empty($this->AltBody)) {

    494. 

  494.         $this->ContentType = 'multipart/alternative';

    495. 

  495.       }

    496. 

  496. 

    497. 

  497.       $this->error_count = 0; // reset errors

    498. 

  498.       $this->SetMessageType();

    499. 

  499.       $header = $this->CreateHeader();

    500. 

  500.       $body = $this->CreateBody();

    501. 

  501. 

    502. 

  502.       if (empty($this->Body)) {

    503. 

  503.         throw new phpmailerException($this->Lang('empty_message'), self::STOP_CRITICAL);

    504. 

  504.       }

    505. 

  505. 

    506. 

  506.       // Choose the mailer and send through it

    507. 

  507.       switch($this->Mailer) {

    508. 

  508.         case 'sendmail':

    509. 

  509.           return $this->SendmailSend($header, $body);

    510. 

  510.         case 'smtp':

    511. 

  511.           return $this->SmtpSend($header, $body);

    512. 

  512.         case 'mail':

    513. 

  513.         default:

    514. 

  514.           return $this->MailSend($header, $body);

    515. 

  515.       }

    516. 

  516. 

    517. 

  517.     } catch (phpmailerException $e) {

    518. 

  518.       $this->SetError($e->getMessage());

    519. 

  519.       if ($this->exceptions) {

    520. 

  520.         throw $e;

    521. 

  521.       }

    522. 

  522.       echo $e->getMessage()."\n";

    523. 

  523.       return false;

    524. 

  524.     }

    525. 

  525.   }

    526. 

  526. 

    527. 

  527.   /**

    528. 

  528.    * Sends mail using the $Sendmail program.

    529. 

  529.    * @param string $header The message headers

    530. 

  530.    * @param string $body The message body

    531. 

  531.    * @access protected

    532. 

  532.    * @return bool

    533. 

  533.    */

    534. 

  534.   protected function SendmailSend($header, $body) {

    535. 

  535.     if ($this->Sender != '') {

    536. 

  536.       $sendmail = sprintf("%s -oi -f %s -t", escapeshellcmd($this->Sendmail), escapeshellarg($this->Sender));

    537. 

  537.     } else {

    538. 

  538.       $sendmail = sprintf("%s -oi -t", escapeshellcmd($this->Sendmail));

    539. 

  539.     }

    540. 

  540.     if(!@$mail = popen($sendmail, 'w')) {

    541. 

  541.       throw new phpmailerException($this->Lang('execute') . $this->Sendmail, self::STOP_CRITICAL);

    542. 

  542.     }

    543. 

  543.     fputs($mail, $header);

    544. 

  544.     fputs($mail, $body);

    545. 

  545.     $result = pclose($mail);

    546. 

  546.     if($result != 0) {

    547. 

  547.       throw new phpmailerException($this->Lang('execute') . $this->Sendmail, self::STOP_CRITICAL);

    548. 

  548.     }

    549. 

  549.     return true;

    550. 

  550.   }

    551. 

  551. 

    552. 

  552.   /**

    553. 

  553.    * Sends mail using the PHP mail() function.

    554. 

  554.    * @param string $header The message headers

    555. 

  555.    * @param string $body The message body

    556. 

  556.    * @access protected

    557. 

  557.    * @return bool

    558. 

  558.    */

    559. 

  559.   protected function MailSend($header, $body) {

    560. 

  560.     $toArr = array();

    561. 

  561.     foreach($this->to as $t) {

    562. 

  562.       $toArr[] = $this->AddrFormat($t);

    563. 

  563.     }

    564. 

  564.     $to = implode(', ', $toArr);

    565. 

  565. 

    566. 

  566.     $params = sprintf("-oi -f %s", $this->Sender);

    567. 

  567.     if ($this->Sender != '' && strlen(ini_get('safe_mode'))< 1) {

    568. 

  568.       $old_from = ini_get('sendmail_from');

    569. 

  569.       ini_set('sendmail_from', $this->Sender);

    570. 

  570.       if ($this->SingleTo === true && count($toArr) > 1) {

    571. 

  571.         foreach ($toArr as $key => $val) {

    572. 

  572.           $rt = @mail($val, $this->EncodeHeader($this->SecureHeader($this->Subject)), $body, $header, $params);

    573. 

  573.         }

    574. 

  574.       } else {

    575. 

  575.         $rt = @mail($to, $this->EncodeHeader($this->SecureHeader($this->Subject)), $body, $header, $params);

    576. 

  576.       }

    577. 

  577.     } else {

    578. 

  578.       if ($this->SingleTo === true && count($toArr) > 1) {

    579. 

  579.         foreach ($toArr as $key => $val) {

    580. 

  580.           $rt = @mail($val, $this->EncodeHeader($this->SecureHeader($this->Subject)), $body, $header, $params);

    581. 

  581.         }

    582. 

  582.       } else {

    583. 

  583.         $rt = @mail($to, $this->EncodeHeader($this->SecureHeader($this->Subject)), $body, $header);

    584. 

  584.       }

    585. 

  585.     }

    586. 

  586.     if (isset($old_from)) {

    587. 

  587.       ini_set('sendmail_from', $old_from);

    588. 

  588.     }

    589. 

  589.     if(!$rt) {

    590. 

  590.       throw new phpmailerException($this->Lang('instantiate'), self::STOP_CRITICAL);

    591. 

  591.     }

    592. 

  592.     return true;

    593. 

  593.   }

    594. 

  594. 

    595. 

  595.   /**

    596. 

  596.    * Sends mail via SMTP using PhpSMTP

    597. 

  597.    * Returns false if there is a bad MAIL FROM, RCPT, or DATA input.

    598. 

  598.    * @param string $header The message headers

    599. 

  599.    * @param string $body The message body

    600. 

  600.    * @uses SMTP

    601. 

  601.    * @access protected

    602. 

  602.    * @return bool

    603. 

  603.    */

    604. 

  604.   protected function SmtpSend($header, $body) {

    605. 

  605.     require_once $this->PluginDir . 'class.smtp.php';

    606. 

  606.     $bad_rcpt = array();

    607. 

  607. 

    608. 

  608.     if(!$this->SmtpConnect()) {

    609. 

  609.       throw new phpmailerException($this->Lang('smtp_connect_failed'), self::STOP_CRITICAL);

    610. 

  610.     }

    611. 

  611.     $smtp_from = ($this->Sender == '') ? $this->From : $this->Sender;

    612. 

  612.     if(!$this->smtp->Mail($smtp_from)) {

    613. 

  613.       throw new phpmailerException($this->Lang('from_failed') . $smtp_from, self::STOP_CRITICAL);

    614. 

  614.     }

    615. 

  615. 

    616. 

  616.     // Attempt to send attach all recipients

    617. 

  617.     foreach($this->to as $to) {

    618. 

  618.       if (!$this->smtp->Recipient($to[0])) {

    619. 

  619.         $bad_rcpt[] = $to[0];

    620. 

  620.       }

    621. 

  621.     }

    622. 

  622.     foreach($this->cc as $cc) {

    623. 

  623.       if (!$this->smtp->Recipient($cc[0])) {

    624. 

  624.         $bad_rcpt[] = $cc[0];

    625. 

  625.       }

    626. 

  626.     }

    627. 

  627.     foreach($this->bcc as $bcc) {

    628. 

  628.       if (!$this->smtp->Recipient($bcc[0])) {

    629. 

  629.         $bad_rcpt[] = $bcc[0];

    630. 

  630.       }

    631. 

  631.     }

    632. 

  632.     if (count($bad_rcpt) > 0 ) { //Create error message for any bad addresses

    633. 

  633.       $badaddresses = implode(', ', $bad_rcpt);

    634. 

  634.       throw new phpmailerException($this->Lang('recipients_failed') . $badaddresses);

    635. 

  635.     }

    636. 

  636.     if(!$this->smtp->Data($header . $body)) {

    637. 

  637.       throw new phpmailerException($this->Lang('data_not_accepted'), self::STOP_CRITICAL);

    638. 

  638.     }

    639. 

  639.     if($this->SMTPKeepAlive == true) {

    640. 

  640.       $this->smtp->Reset();

    641. 

  641.     }

    642. 

  642.     return true;

    643. 

  643.   }

    644. 

  644. 

    645. 

  645.   /**

    646. 

  646.    * Initiates a connection to an SMTP server.

    647. 

  647.    * Returns false if the operation failed.

    648. 

  648.    * @uses SMTP

    649. 

  649.    * @access public

    650. 

  650.    * @return bool

    651. 

  651.    */

    652. 

  652.   public function SmtpConnect() {

    653. 

  653.     if(is_null($this->smtp)) {

    654. 

  654.       $this->smtp = new SMTP();

    655. 

  655.     }

    656. 

  656. 

    657. 

  657.     $this->smtp->do_debug = $this->SMTPDebug;

    658. 

  658.     $hosts = explode(';', $this->Host);

    659. 

  659.     $index = 0;

    660. 

  660.     $connection = $this->smtp->Connected();

    661. 

  661. 

    662. 

  662.     // Retry while there is no connection

    663. 

  663.     try {

    664. 

  664.       while($index < count($hosts) && !$connection) {

    665. 

  665.         $hostinfo = array();

    666. 

  666.         if (preg_match('/^(.+):([0-9]+)$/', $hosts[$index], $hostinfo)) {

    667. 

  667.           $host = $hostinfo[1];

    668. 

  668.           $port = $hostinfo[2];

    669. 

  669.         } else {

    670. 

  670.           $host = $hosts[$index];

    671. 

  671.           $port = $this->Port;

    672. 

  672.         }

    673. 

  673. 

    674. 

  674.         $tls = ($this->SMTPSecure == 'tls');

    675. 

  675.         $ssl = ($this->SMTPSecure == 'ssl');

    676. 

  676. 

    677. 

  677.         if ($this->smtp->Connect(($ssl ? 'ssl://':'').$host, $port, $this->Timeout)) {

    678. 

  678. 

    679. 

  679.           $hello = ($this->Helo != '' ? $this->Helo : $this->ServerHostname());

    680. 

  680.           $this->smtp->Hello($hello);

    681. 

  681. 

    682. 

  682.           if ($tls) {

    683. 

  683.             if (!$this->smtp->StartTLS()) {

    684. 

  684.               throw new phpmailerException($this->Lang('tls'));

    685. 

  685.             }

    686. 

  686. 

    687. 

  687.             //We must resend HELO after tls negotiation

    688. 

  688.             $this->smtp->Hello($hello);

    689. 

  689.           }

    690. 

  690. 

    691. 

  691.           $connection = true;

    692. 

  692.           if ($this->SMTPAuth) {

    693. 

  693.             if (!$this->smtp->Authenticate($this->Username, $this->Password)) {

    694. 

  694.               throw new phpmailerException($this->Lang('authenticate'));

    695. 

  695.             }

    696. 

  696.           }

    697. 

  697.         }

    698. 

  698.         $index++;

    699. 

  699.         if (!$connection) {

    700. 

  700.           throw new phpmailerException($this->Lang('connect_host'));

    701. 

  701.         }

    702. 

  702.       }

    703. 

  703.     } catch (phpmailerException $e) {

    704. 

  704.       $this->smtp->Reset();

    705. 

  705.       throw $e;

    706. 

  706.     }

    707. 

  707.     return true;

    708. 

  708.   }

    709. 

  709. 

    710. 

  710.   /**

    711. 

  711.    * Closes the active SMTP session if one exists.

    712. 

  712.    * @return void

    713. 

  713.    */

    714. 

  714.   public function SmtpClose() {

    715. 

  715.     if(!is_null($this->smtp)) {

    716. 

  716.       if($this->smtp->Connected()) {

    717. 

  717.         $this->smtp->Quit();

    718. 

  718.         $this->smtp->Close();

    719. 

  719.       }

    720. 

  720.     }

    721. 

  721.   }

    722. 

  722. 

    723. 

  723.   /**

    724. 

  724.   * Sets the language for all class error messages.

    725. 

  725.   * Returns false if it cannot load the language file.  The default language is English.

    726. 

  726.   * @param string $langcode ISO 639-1 2-character language code (e.g. Portuguese: "br")

    727. 

  727.   * @param string $lang_path Path to the language file directory

    728. 

  728.   * @access public

    729. 

  729.   */

    730. 

  730.   function SetLanguage($langcode = 'en', $lang_path = 'language/') {

    731. 

  731.     //Define full set of translatable strings

    732. 

  732.     $PHPMAILER_LANG = array(

    733. 

  733.       'provide_address' => Yii::t('yiiext','You must provide at least one recipient email address.'),

    734. 

  734.       'mailer_not_supported' => Yii::t('yiiext',' mailer is not supported.'),

    735. 

  735.       'execute' => Yii::t('yiiext','Could not execute: '),

    736. 

  736.       'instantiate' => Yii::t('yiiext','Could not instantiate mail function.'),

    737. 

  737.       'authenticate' => Yii::t('yiiext','SMTP Error: Could not authenticate.'),

    738. 

  738.       'from_failed' => Yii::t('yiiext','The following From address failed: '),

    739. 

  739.       'recipients_failed' => Yii::t('yiiext','SMTP Error: The following recipients failed: '),

    740. 

  740.       'data_not_accepted' => Yii::t('yiiext','SMTP Error: Data not accepted.'),

    741. 

  741.       'connect_host' => Yii::t('yiiext','SMTP Error: Could not connect to SMTP host.'),

    742. 

  742.       'file_access' => Yii::t('yiiext','Could not access file: '),

    743. 

  743.       'file_open' => Yii::t('yiiext','File Error: Could not open file: '),

    744. 

  744.       'encoding' => Yii::t('yiiext','Unknown encoding: '),

    745. 

  745.       'signing' => Yii::t('yiiext','Signing Error: '),

    746. 

  746.       'smtp_error' => Yii::t('yiiext','SMTP server error: '),

    747. 

  747.       'empty_message' => Yii::t('yiiext','Message body empty'),

    748. 

  748.       'invalid_address' => Yii::t('yiiext','Invalid address'),

    749. 

  749.       'variable_set' => Yii::t('yiiext','Cannot set or reset variable: ')

    750. 

  750.     );

    751. 

  751.     //Overwrite language-specific strings. This way we'll never have missing translations - no more "language string failed to load"!

    752. 

  752.     $l = true;

    753. 

  753.     if ($langcode != 'en') { //There is no English translation file

    754. 

  754.       $l = @include $lang_path.'phpmailer.lang-'.$langcode.'.php';

    755. 

  755.     }

    756. 

  756.     $this->language = $PHPMAILER_LANG;

    757. 

  757.     return ($l == true); //Returns false if language not found

    758. 

  758.   }

    759. 

  759. 

    760. 

  760.   /**

    761. 

  761.   * Return the current array of language strings

    762. 

  762.   * @return array

    763. 

  763.   */

    764. 

  764.   public function GetTranslations() {

    765. 

  765.     return $this->language;

    766. 

  766.   }

    767. 

  767. 

    768. 

  768.   /////////////////////////////////////////////////

    769. 

  769.   // METHODS, MESSAGE CREATION

    770. 

  770.   /////////////////////////////////////////////////

    771. 

  771. 

    772. 

  772.   /**

    773. 

  773.    * Creates recipient headers.

    774. 

  774.    * @access public

    775. 

  775.    * @return string

    776. 

  776.    */

    777. 

  777.   public function AddrAppend($type, $addr) {

    778. 

  778.     $addr_str = $type . ': ';

    779. 

  779.     $addresses = array();

    780. 

  780.     foreach ($addr as $a) {

    781. 

  781.       $addresses[] = $this->AddrFormat($a);

    782. 

  782.     }

    783. 

  783.     $addr_str .= implode(', ', $addresses);

    784. 

  784.     $addr_str .= $this->LE;

    785. 

  785. 

    786. 

  786.     return $addr_str;

    787. 

  787.   }

    788. 

  788. 

    789. 

  789.   /**

    790. 

  790.    * Formats an address correctly.

    791. 

  791.    * @access public

    792. 

  792.    * @return string

    793. 

  793.    */

    794. 

  794.   public function AddrFormat($addr) {

    795. 

  795.     if (empty($addr[1])) {

    796. 

  796.       return $this->SecureHeader($addr[0]);

    797. 

  797.     } else {

    798. 

  798.       return $this->EncodeHeader($this->SecureHeader($addr[1]), 'phrase') . " <" . $this->SecureHeader($addr[0]) . ">";

    799. 

  799.     }

    800. 

  800.   }

    801. 

  801. 

    802. 

  802.   /**

    803. 

  803.    * Wraps message for use with mailers that do not

    804. 

  804.    * automatically perform wrapping and for quoted-printable.

    805. 

  805.    * Original written by philippe.

    806. 

  806.    * @param string $message The message to wrap

    807. 

  807.    * @param integer $length The line length to wrap to

    808. 

  808.    * @param boolean $qp_mode Whether to run in Quoted-Printable mode

    809. 

  809.    * @access public

    810. 

  810.    * @return string

    811. 

  811.    */

    812. 

  812.   public function WrapText($message, $length, $qp_mode = false) {

    813. 

  813.     $soft_break = ($qp_mode) ? sprintf(" =%s", $this->LE) : $this->LE;

    814. 

  814.     // If utf-8 encoding is used, we will need to make sure we don't

    815. 

  815.     // split multibyte characters when we wrap

    816. 

  816.     $is_utf8 = (strtolower($this->CharSet) == "utf-8");

    817. 

  817. 

    818. 

  818.     $message = $this->FixEOL($message);

    819. 

  819.     if (substr($message, -1) == $this->LE) {

    820. 

  820.       $message = substr($message, 0, -1);

    821. 

  821.     }

    822. 

  822. 

    823. 

  823.     $line = explode($this->LE, $message);

    824. 

  824.     $message = '';

    825. 

  825.     for ($i=0 ;$i < count($line); $i++) {

    826. 

  826.       $line_part = explode(' ', $line[$i]);

    827. 

  827.       $buf = '';

    828. 

  828.       for ($e = 0; $e<count($line_part); $e++) {

    829. 

  829.         $word = $line_part[$e];

    830. 

  830.         if ($qp_mode and (strlen($word) > $length)) {

    831. 

  831.           $space_left = $length - strlen($buf) - 1;

    832. 

  832.           if ($e != 0) {

    833. 

  833.             if ($space_left > 20) {

    834. 

  834.               $len = $space_left;

    835. 

  835.               if ($is_utf8) {

    836. 

  836.                 $len = $this->UTF8CharBoundary($word, $len);

    837. 

  837.               } elseif (substr($word, $len - 1, 1) == "=") {

    838. 

  838.                 $len--;

    839. 

  839.               } elseif (substr($word, $len - 2, 1) == "=") {

    840. 

  840.                 $len -= 2;

    841. 

  841.               }

    842. 

  842.               $part = substr($word, 0, $len);

    843. 

  843.               $word = substr($word, $len);

    844. 

  844.               $buf .= ' ' . $part;

    845. 

  845.               $message .= $buf . sprintf("=%s", $this->LE);

    846. 

  846.             } else {

    847. 

  847.               $message .= $buf . $soft_break;

    848. 

  848.             }

    849. 

  849.             $buf = '';

    850. 

  850.           }

    851. 

  851.           while (strlen($word) > 0) {

    852. 

  852.             $len = $length;

    853. 

  853.             if ($is_utf8) {

    854. 

  854.               $len = $this->UTF8CharBoundary($word, $len);

    855. 

  855.             } elseif (substr($word, $len - 1, 1) == "=") {

    856. 

  856.               $len--;

    857. 

  857.             } elseif (substr($word, $len - 2, 1) == "=") {

    858. 

  858.               $len -= 2;

    859. 

  859.             }

    860. 

  860.             $part = substr($word, 0, $len);

    861. 

  861.             $word = substr($word, $len);

    862. 

  862. 

    863. 

  863.             if (strlen($word) > 0) {

    864. 

  864.               $message .= $part . sprintf("=%s", $this->LE);

    865. 

  865.             } else {

    866. 

  866.               $buf = $part;

    867. 

  867.             }

    868. 

  868.           }

    869. 

  869.         } else {

    870. 

  870.           $buf_o = $buf;

    871. 

  871.           $buf .= ($e == 0) ? $word : (' ' . $word);

    872. 

  872. 

    873. 

  873.           if (strlen($buf) > $length and $buf_o != '') {

    874. 

  874.             $message .= $buf_o . $soft_break;

    875. 

  875.             $buf = $word;

    876. 

  876.           }

    877. 

  877.         }

    878. 

  878.       }

    879. 

  879.       $message .= $buf . $this->LE;

    880. 

  880.     }

    881. 

  881. 

    882. 

  882.     return $message;

    883. 

  883.   }

    884. 

  884. 

    885. 

  885.   /**

    886. 

  886.    * Finds last character boundary prior to maxLength in a utf-8

    887. 

  887.    * quoted (printable) encoded string.

    888. 

  888.    * Original written by Colin Brown.

    889. 

  889.    * @access public

    890. 

  890.    * @param string $encodedText utf-8 QP text

    891. 

  891.    * @param int    $maxLength   find last character boundary prior to this length

    892. 

  892.    * @return int

    893. 

  893.    */

    894. 

  894.   public function UTF8CharBoundary($encodedText, $maxLength) {

    895. 

  895.     $foundSplitPos = false;

    896. 

  896.     $lookBack = 3;

    897. 

  897.     while (!$foundSplitPos) {

    898. 

  898.       $lastChunk = substr($encodedText, $maxLength - $lookBack, $lookBack);

    899. 

  899.       $encodedCharPos = strpos($lastChunk, "=");

    900. 

  900.       if ($encodedCharPos !== false) {

    901. 

  901.         // Found start of encoded character byte within $lookBack block.

    902. 

  902.         // Check the encoded byte value (the 2 chars after the '=')

    903. 

  903.         $hex = substr($encodedText, $maxLength - $lookBack + $encodedCharPos + 1, 2);

    904. 

  904.         $dec = hexdec($hex);

    905. 

  905.         if ($dec < 128) { // Single byte character.

    906. 

  906.           // If the encoded char was found at pos 0, it will fit

    907. 

  907.           // otherwise reduce maxLength to start of the encoded char

    908. 

  908.           $maxLength = ($encodedCharPos == 0) ? $maxLength :

    909. 

  909.           $maxLength - ($lookBack - $encodedCharPos);

    910. 

  910.           $foundSplitPos = true;

    911. 

  911.         } elseif ($dec >= 192) { // First byte of a multi byte character

    912. 

  912.           // Reduce maxLength to split at start of character

    913. 

  913.           $maxLength = $maxLength - ($lookBack - $encodedCharPos);

    914. 

  914.           $foundSplitPos = true;

    915. 

  915.         } elseif ($dec < 192) { // Middle byte of a multi byte character, look further back

    916. 

  916.           $lookBack += 3;

    917. 

  917.         }

    918. 

  918.       } else {

    919. 

  919.         // No encoded character found

    920. 

  920.         $foundSplitPos = true;

    921. 

  921.       }

    922. 

  922.     }

    923. 

  923.     return $maxLength;

    924. 

  924.   }

    925. 

  925. 

    926. 

  926. 

    927. 

  927.   /**

    928. 

  928.    * Set the body wrapping.

    929. 

  929.    * @access public

    930. 

  930.    * @return void

    931. 

  931.    */

    932. 

  932.   public function SetWordWrap() {

    933. 

  933.     if($this->WordWrap < 1) {

    934. 

  934.       return;

    935. 

  935.     }

    936. 

  936. 

    937. 

  937.     switch($this->message_type) {

    938. 

  938.       case 'alt':

    939. 

  939.       case 'alt_attachments':

    940. 

  940.         $this->AltBody = $this->WrapText($this->AltBody, $this->WordWrap);

    941. 

  941.         break;

    942. 

  942.       default:

    943. 

  943.         $this->Body = $this->WrapText($this->Body, $this->WordWrap);

    944. 

  944.         break;

    945. 

  945.     }

    946. 

  946.   }

    947. 

  947. 

    948. 

  948.   /**

    949. 

  949.    * Assembles message header.

    950. 

  950.    * @access public

    951. 

  951.    * @return string The assembled header

    952. 

  952.    */

    953. 

  953.   public function CreateHeader() {

    954. 

  954.     $result = '';

    955. 

  955. 

    956. 

  956.     // Set the boundaries

    957. 

  957.     $uniq_id = md5(uniqid(time()));

    958. 

  958.     $this->boundary[1] = 'b1_' . $uniq_id;

    959. 

  959.     $this->boundary[2] = 'b2_' . $uniq_id;

    960. 

  960. 

    961. 

  961.     $result .= $this->HeaderLine('Date', self::RFCDate());

    962. 

  962.     if($this->Sender == '') {

    963. 

  963.       $result .= $this->HeaderLine('Return-Path', trim($this->From));

    964. 

  964.     } else {

    965. 

  965.       $result .= $this->HeaderLine('Return-Path', trim($this->Sender));

    966. 

  966.     }

    967. 

  967. 

    968. 

  968.     // To be created automatically by mail()

    969. 

  969.     if($this->Mailer != 'mail') {

    970. 

  970.       if(count($this->to) > 0) {

    971. 

  971.         $result .= $this->AddrAppend('To', $this->to);

    972. 

  972.       } elseif (count($this->cc) == 0) {

    973. 

  973.         $result .= $this->HeaderLine('To', 'undisclosed-recipients:;');

    974. 

  974.       }

    975. 

  975.     }

    976. 

  976. 

    977. 

  977.     $from = array();

    978. 

  978.     $from[0][0] = trim($this->From);

    979. 

  979.     $from[0][1] = $this->FromName;

    980. 

  980.     $result .= $this->AddrAppend('From', $from);

    981. 

  981. 

    982. 

  982.     // sendmail and mail() extract Cc from the header before sending

    983. 

  983.     if((($this->Mailer == 'sendmail') || ($this->Mailer == 'mail')) && (count($this->cc) > 0)) {

    984. 

  984.       $result .= $this->AddrAppend('Cc', $this->cc);

    985. 

  985.     }

    986. 

  986. 

    987. 

  987.     // sendmail and mail() extract Bcc from the header before sending

    988. 

  988.     if((($this->Mailer == 'sendmail') || ($this->Mailer == 'mail')) && (count($this->bcc) > 0)) {

    989. 

  989.       $result .= $this->AddrAppend('Bcc', $this->bcc);

    990. 

  990.     }

    991. 

  991. 

    992. 

  992.     if(count($this->ReplyTo) > 0) {

    993. 

  993.       $result .= $this->AddrAppend('Reply-to', $this->ReplyTo);

    994. 

  994.     }

    995. 

  995. 

    996. 

  996.     // mail() sets the subject itself

    997. 

  997.     if($this->Mailer != 'mail') {

    998. 

  998.       $result .= $this->HeaderLine('Subject', $this->EncodeHeader($this->SecureHeader($this->Subject)));

    999. 

  999.     }

    1000. 

  1000. 

    1001. 

  1001.     if($this->MessageID != '') {

    1002. 

  1002.       $result .= $this->HeaderLine('Message-ID',$this->MessageID);

    1003. 

  1003.     } else {

    1004. 

  1004.       $result .= sprintf("Message-ID: <%s@%s>%s", $uniq_id, $this->ServerHostname(), $this->LE);

    1005. 

  1005.     }

    1006. 

  1006.     $result .= $this->HeaderLine('X-Priority', $this->Priority);

    1007. 

  1007.     $result .= $this->HeaderLine('X-Mailer', 'PHPMailer ' . self::VERSION . ' (phpmailer.codeworxtech.com)');

    1008. 

  1008. 

    1009. 

  1009.     if($this->ConfirmReadingTo != '') {

    1010. 

  1010.       $result .= $this->HeaderLine('Disposition-Notification-To', '<' . trim($this->ConfirmReadingTo) . '>');

    1011. 

  1011.     }

    1012. 

  1012. 

    1013. 

  1013.     // Add custom headers

    1014. 

  1014.     for($index = 0; $index < count($this->CustomHeader); $index++) {

    1015. 

  1015.       $result .= $this->HeaderLine(trim($this->CustomHeader[$index][0]), $this->EncodeHeader(trim($this->CustomHeader[$index][1])));

    1016. 

  1016.     }

    1017. 

  1017.     if (!$this->sign_key_file) {

    1018. 

  1018.       $result .= $this->HeaderLine('MIME-Version', '1.0');

    1019. 

  1019.       $result .= $this->GetMailMIME();

    1020. 

  1020.     }

    1021. 

  1021. 

    1022. 

  1022.     return $result;

    1023. 

  1023.   }

    1024. 

  1024. 

    1025. 

  1025.   /**

    1026. 

  1026.    * Returns the message MIME.

    1027. 

  1027.    * @access public

    1028. 

  1028.    * @return string

    1029. 

  1029.    */

    1030. 

  1030.   public function GetMailMIME() {

    1031. 

  1031.     $result = '';

    1032. 

  1032.     switch($this->message_type) {

    1033. 

  1033.       case 'plain':

    1034. 

  1034.         $result .= $this->HeaderLine('Content-Transfer-Encoding', $this->Encoding);

    1035. 

  1035.         $result .= sprintf("Content-Type: %s; charset=\"%s\"", $this->ContentType, $this->CharSet);

    1036. 

  1036.         break;

    1037. 

  1037.       case 'attachments':

    1038. 

  1038.       case 'alt_attachments':

    1039. 

  1039.         if($this->InlineImageExists()){

    1040. 

  1040.           $result .= sprintf("Content-Type: %s;%s\ttype=\"text/html\";%s\tboundary=\"%s\"%s", 'multipart/related', $this->LE, $this->LE, $this->boundary[1], $this->LE);

    1041. 

  1041.         } else {

    1042. 

  1042.           $result .= $this->HeaderLine('Content-Type', 'multipart/mixed;');

    1043. 

  1043.           $result .= $this->TextLine("\tboundary=\"" . $this->boundary[1] . '"');

    1044. 

  1044.         }

    1045. 

  1045.         break;

    1046. 

  1046.       case 'alt':

    1047. 

  1047.         $result .= $this->HeaderLine('Content-Type', 'multipart/alternative;');

    1048. 

  1048.         $result .= $this->TextLine("\tboundary=\"" . $this->boundary[1] . '"');

    1049. 

  1049.         break;

    1050. 

  1050.     }

    1051. 

  1051. 

    1052. 

  1052.     if($this->Mailer != 'mail') {

    1053. 

  1053.       $result .= $this->LE.$this->LE;

    1054. 

  1054.     }

    1055. 

  1055. 

    1056. 

  1056.     return $result;

    1057. 

  1057.   }

    1058. 

  1058. 

    1059. 

  1059.   /**

    1060. 

  1060.    * Assembles the message body.  Returns an empty string on failure.

    1061. 

  1061.    * @access public

    1062. 

  1062.    * @return string The assembled message body

    1063. 

  1063.    */

    1064. 

  1064.   public function CreateBody() {

    1065. 

  1065.     $body = '';

    1066. 

  1066. 

    1067. 

  1067.     if ($this->sign_key_file) {

    1068. 

  1068.       $body .= $this->GetMailMIME();

    1069. 

  1069.     }

    1070. 

  1070. 

    1071. 

  1071.     $this->SetWordWrap();

    1072. 

  1072. 

    1073. 

  1073.     switch($this->message_type) {

    1074. 

  1074.       case 'alt':

    1075. 

  1075.         $body .= $this->GetBoundary($this->boundary[1], '', 'text/plain', '');

    1076. 

  1076.         $body .= $this->EncodeString($this->AltBody, $this->Encoding);

    1077. 

  1077.         $body .= $this->LE.$this->LE;

    1078. 

  1078.         $body .= $this->GetBoundary($this->boundary[1], '', 'text/html', '');

    1079. 

  1079.         $body .= $this->EncodeString($this->Body, $this->Encoding);

    1080. 

  1080.         $body .= $this->LE.$this->LE;

    1081. 

  1081.         $body .= $this->EndBoundary($this->boundary[1]);

    1082. 

  1082.         break;

    1083. 

  1083.       case 'plain':

    1084. 

  1084.         $body .= $this->EncodeString($this->Body, $this->Encoding);

    1085. 

  1085.         break;

    1086. 

  1086.       case 'attachments':

    1087. 

  1087.         $body .= $this->GetBoundary($this->boundary[1], '', '', '');

    1088. 

  1088.         $body .= $this->EncodeString($this->Body, $this->Encoding);

    1089. 

  1089.         $body .= $this->LE;

    1090. 

  1090.         $body .= $this->AttachAll();

    1091. 

  1091.         break;

    1092. 

  1092.       case 'alt_attachments':

    1093. 

  1093.         $body .= sprintf("--%s%s", $this->boundary[1], $this->LE);

    1094. 

  1094.         $body .= sprintf("Content-Type: %s;%s" . "\tboundary=\"%s\"%s", 'multipart/alternative', $this->LE, $this->boundary[2], $this->LE.$this->LE);

    1095. 

  1095.         $body .= $this->GetBoundary($this->boundary[2], '', 'text/plain', '') . $this->LE; // Create text body

    1096. 

  1096.         $body .= $this->EncodeString($this->AltBody, $this->Encoding);

    1097. 

  1097.         $body .= $this->LE.$this->LE;

    1098. 

  1098.         $body .= $this->GetBoundary($this->boundary[2], '', 'text/html', '') . $this->LE; // Create the HTML body

    1099. 

  1099.         $body .= $this->EncodeString($this->Body, $this->Encoding);

    1100. 

  1100.         $body .= $this->LE.$this->LE;

    1101. 

  1101.         $body .= $this->EndBoundary($this->boundary[2]);

    1102. 

  1102.         $body .= $this->AttachAll();

    1103. 

  1103.         break;

    1104. 

  1104.     }

    1105. 

  1105. 

    1106. 

  1106.     if ($this->IsError()) {

    1107. 

  1107.       $body = '';

    1108. 

  1108.     } elseif ($this->sign_key_file) {

    1109. 

  1109.       try {

    1110. 

  1110.         $file = tempnam('', 'mail');

    1111. 

  1111.         file_put_contents($file, $body); //TODO check this worked

    1112. 

  1112.         $signed = tempnam("", "signed");

    1113. 

  1113.         if (@openssl_pkcs7_sign($file, $signed, "file://".$this->sign_cert_file, array("file://".$this->sign_key_file, $this->sign_key_pass), NULL)) {

    1114. 

  1114.           @unlink($file);

    1115. 

  1115.           @unlink($signed);

    1116. 

  1116.           $body = file_get_contents($signed);

    1117. 

  1117.         } else {

    1118. 

  1118.           @unlink($file);

    1119. 

  1119.           @unlink($signed);

    1120. 

  1120.           throw new phpmailerException($this->Lang("signing").openssl_error_string());

    1121. 

  1121.         }

    1122. 

  1122.       } catch (phpmailerException $e) {

    1123. 

  1123.         $body = '';

    1124. 

  1124.         if ($this->exceptions) {

    1125. 

  1125.           throw $e;

    1126. 

  1126.         }

    1127. 

  1127.       }

    1128. 

  1128.     }

    1129. 

  1129. 

    1130. 

  1130.     return $body;

    1131. 

  1131.   }

    1132. 

  1132. 

    1133. 

  1133.   /**

    1134. 

  1134.    * Returns the start of a message boundary.

    1135. 

  1135.    * @access private

    1136. 

  1136.    */

    1137. 

  1137.   private function GetBoundary($boundary, $charSet, $contentType, $encoding) {

    1138. 

  1138.     $result = '';

    1139. 

  1139.     if($charSet == '') {

    1140. 

  1140.       $charSet = $this->CharSet;

    1141. 

  1141.     }

    1142. 

  1142.     if($contentType == '') {

    1143. 

  1143.       $contentType = $this->ContentType;

    1144. 

  1144.     }

    1145. 

  1145.     if($encoding == '') {

    1146. 

  1146.       $encoding = $this->Encoding;

    1147. 

  1147.     }

    1148. 

  1148.     $result .= $this->TextLine('--' . $boundary);

    1149. 

  1149.     $result .= sprintf("Content-Type: %s; charset = \"%s\"", $contentType, $charSet);

    1150. 

  1150.     $result .= $this->LE;

    1151. 

  1151.     $result .= $this->HeaderLine('Content-Transfer-Encoding', $encoding);

    1152. 

  1152.     $result .= $this->LE;

    1153. 

  1153. 

    1154. 

  1154.     return $result;

    1155. 

  1155.   }

    1156. 

  1156. 

    1157. 

  1157.   /**

    1158. 

  1158.    * Returns the end of a message boundary.

    1159. 

  1159.    * @access private

    1160. 

  1160.    */

    1161. 

  1161.   private function EndBoundary($boundary) {

    1162. 

  1162.     return $this->LE . '--' . $boundary . '--' . $this->LE;

    1163. 

  1163.   }

    1164. 

  1164. 

    1165. 

  1165.   /**

    1166. 

  1166.    * Sets the message type.

    1167. 

  1167.    * @access private

    1168. 

  1168.    * @return void

    1169. 

  1169.    */

    1170. 

  1170.   private function SetMessageType() {

    1171. 

  1171.     if(count($this->attachment) < 1 && strlen($this->AltBody) < 1) {

    1172. 

  1172.       $this->message_type = 'plain';

    1173. 

  1173.     } else {

    1174. 

  1174.       if(count($this->attachment) > 0) {

    1175. 

  1175.         $this->message_type = 'attachments';

    1176. 

  1176.       }

    1177. 

  1177.       if(strlen($this->AltBody) > 0 && count($this->attachment) < 1) {

    1178. 

  1178.         $this->message_type = 'alt';

    1179. 

  1179.       }

    1180. 

  1180.       if(strlen($this->AltBody) > 0 && count($this->attachment) > 0) {

    1181. 

  1181.         $this->message_type = 'alt_attachments';

    1182. 

  1182.       }

    1183. 

  1183.     }

    1184. 

  1184.   }

    1185. 

  1185. 

    1186. 

  1186.   /**

    1187. 

  1187.    *  Returns a formatted header line.

    1188. 

  1188.    * @access public

    1189. 

  1189.    * @return string

    1190. 

  1190.    */

    1191. 

  1191.   public function HeaderLine($name, $value) {

    1192. 

  1192.     return $name . ': ' . $value . $this->LE;

    1193. 

  1193.   }

    1194. 

  1194. 

    1195. 

  1195.   /**

    1196. 

  1196.    * Returns a formatted mail line.

    1197. 

  1197.    * @access public

    1198. 

  1198.    * @return string

    1199. 

  1199.    */

    1200. 

  1200.   public function TextLine($value) {

    1201. 

  1201.     return $value . $this->LE;

    1202. 

  1202.   }

    1203. 

  1203. 

    1204. 

  1204.   /////////////////////////////////////////////////

    1205. 

  1205.   // CLASS METHODS, ATTACHMENTS

    1206. 

  1206.   /////////////////////////////////////////////////

    1207. 

  1207. 

    1208. 

  1208.   /**

    1209. 

  1209.    * Adds an attachment from a path on the filesystem.

    1210. 

  1210.    * Returns false if the file could not be found

    1211. 

  1211.    * or accessed.

    1212. 

  1212.    * @param string $path Path to the attachment.

    1213. 

  1213.    * @param string $name Overrides the attachment name.

    1214. 

  1214.    * @param string $encoding File encoding (see $Encoding).

    1215. 

  1215.    * @param string $type File extension (MIME) type.

    1216. 

  1216.    * @return bool

    1217. 

  1217.    */

    1218. 

  1218.   public function AddAttachment($path, $name = '', $encoding = 'base64', $type = 'application/octet-stream') {

    1219. 

  1219.     try {

    1220. 

  1220.       if ( !@is_file($path) ) {

    1221. 

  1221.         throw new phpmailerException($this->Lang('file_access') . $path, self::STOP_CONTINUE);

    1222. 

  1222.       }

    1223. 

  1223.       $filename = basename($path);

    1224. 

  1224.       if ( $name == '' ) {

    1225. 

  1225.         $name = $filename;

    1226. 

  1226.       }

    1227. 

  1227. 

    1228. 

  1228.       $this->attachment[] = array(

    1229. 

  1229.         0 => $path,

    1230. 

  1230.         1 => $filename,

    1231. 

  1231.         2 => $name,

    1232. 

  1232.         3 => $encoding,

    1233. 

  1233.         4 => $type,

    1234. 

  1234.         5 => false,  // isStringAttachment

    1235. 

  1235.         6 => 'attachment',

    1236. 

  1236.         7 => 0

    1237. 

  1237.       );

    1238. 

  1238. 

    1239. 

  1239.     } catch (phpmailerException $e) {

    1240. 

  1240.       $this->SetError($e->getMessage());

    1241. 

  1241.       if ($this->exceptions) {

    1242. 

  1242.         throw $e;

    1243. 

  1243.       }

    1244. 

  1244.       echo $e->getMessage()."\n";

    1245. 

  1245.       if ( $e->getCode() == self::STOP_CRITICAL ) {

    1246. 

  1246.         return false;

    1247. 

  1247.       }

    1248. 

  1248.     }

    1249. 

  1249.     return true;

    1250. 

  1250.   }

    1251. 

  1251. 

    1252. 

  1252.   /**

    1253. 

  1253.   * Return the current array of attachments

    1254. 

  1254.   * @return array

    1255. 

  1255.   */

    1256. 

  1256.   public function GetAttachments() {

    1257. 

  1257.     return $this->attachment;

    1258. 

  1258.   }

    1259. 

  1259. 

    1260. 

  1260.   /**

    1261. 

  1261.    * Attaches all fs, string, and binary attachments to the message.

    1262. 

  1262.    * Returns an empty string on failure.

    1263. 

  1263.    * @access private

    1264. 

  1264.    * @return string

    1265. 

  1265.    */

    1266. 

  1266.   private function AttachAll() {

    1267. 

  1267.     // Return text of body

    1268. 

  1268.     $mime = array();

    1269. 

  1269.     $cidUniq = array();

    1270. 

  1270.     $incl = array();

    1271. 

  1271. 

    1272. 

  1272.     // Add all attachments

    1273. 

  1273.     foreach ($this->attachment as $attachment) {

    1274. 

  1274.       // Check for string attachment

    1275. 

  1275.       $bString = $attachment[5];

    1276. 

  1276.       if ($bString) {

    1277. 

  1277.         $string = $attachment[0];

    1278. 

  1278.       } else {

    1279. 

  1279.         $path = $attachment[0];

    1280. 

  1280.       }

    1281. 

  1281. 

    1282. 

  1282.       if (in_array($attachment[0], $incl)) { continue; }

    1283. 

  1283.       $filename    = $attachment[1];

    1284. 

  1284.       $name        = $attachment[2];

    1285. 

  1285.       $encoding    = $attachment[3];

    1286. 

  1286.       $type        = $attachment[4];

    1287. 

  1287.       $disposition = $attachment[6];

    1288. 

  1288.       $cid         = $attachment[7];

    1289. 

  1289.       $incl[]      = $attachment[0];

    1290. 

  1290.       if ( isset($cidUniq[$cid]) ) { continue; }

    1291. 

  1291.       $cidUniq[$cid] = true;

    1292. 

  1292. 

    1293. 

  1293.       $mime[] = sprintf("--%s%s", $this->boundary[1], $this->LE);

    1294. 

  1294.       $mime[] = sprintf("Content-Type: %s; name=\"%s\"%s", $type, $this->EncodeHeader($this->SecureHeader($name)), $this->LE);

    1295. 

  1295.       $mime[] = sprintf("Content-Transfer-Encoding: %s%s", $encoding, $this->LE);

    1296. 

  1296. 

    1297. 

  1297.       if($disposition == 'inline') {

    1298. 

  1298.         $mime[] = sprintf("Content-ID: <%s>%s", $cid, $this->LE);

    1299. 

  1299.       }

    1300. 

  1300. 

    1301. 

  1301.       $mime[] = sprintf("Content-Disposition: %s; filename=\"%s\"%s", $disposition, $this->EncodeHeader($this->SecureHeader($name)), $this->LE.$this->LE);

    1302. 

  1302. 

    1303. 

  1303.       // Encode as string attachment

    1304. 

  1304.       if($bString) {

    1305. 

  1305.         $mime[] = $this->EncodeString($string, $encoding);

    1306. 

  1306.         if($this->IsError()) {

    1307. 

  1307.           return '';

    1308. 

  1308.         }

    1309. 

  1309.         $mime[] = $this->LE.$this->LE;

    1310. 

  1310.       } else {

    1311. 

  1311.         $mime[] = $this->EncodeFile($path, $encoding);

    1312. 

  1312.         if($this->IsError()) {

    1313. 

  1313.           return '';

    1314. 

  1314.         }

    1315. 

  1315.         $mime[] = $this->LE.$this->LE;

    1316. 

  1316.       }

    1317. 

  1317.     }

    1318. 

  1318. 

    1319. 

  1319.     $mime[] = sprintf("--%s--%s", $this->boundary[1], $this->LE);

    1320. 

  1320. 

    1321. 

  1321.     return join('', $mime);

    1322. 

  1322.   }

    1323. 

  1323. 

    1324. 

  1324.   /**

    1325. 

  1325.    * Encodes attachment in requested format.

    1326. 

  1326.    * Returns an empty string on failure.

    1327. 

  1327.    * @param string $path The full path to the file

    1328. 

  1328.    * @param string $encoding The encoding to use; one of 'base64', '7bit', '8bit', 'binary', 'quoted-printable'

    1329. 

  1329.    * @see EncodeFile()

    1330. 

  1330.    * @access private

    1331. 

  1331.    * @return string

    1332. 

  1332.    */

    1333. 

  1333.   private function EncodeFile($path, $encoding = 'base64') {

    1334. 

  1334.     try {

    1335. 

  1335.       if (!is_readable($path)) {

    1336. 

  1336.         throw new phpmailerException($this->Lang('file_open') . $path, self::STOP_CONTINUE);

    1337. 

  1337.       }

    1338. 

  1338.       if (function_exists('get_magic_quotes')) {

    1339. 

  1339.         function get_magic_quotes() {

    1340. 

  1340.           return false;

    1341. 

  1341.         }

    1342. 

  1342.       }

    1343. 

  1343.       if (PHP_VERSION < 6) {

    1344. 

  1344.         $magic_quotes = get_magic_quotes_runtime();

    1345. 

  1345.         set_magic_quotes_runtime(0);

    1346. 

  1346.       }

    1347. 

  1347.       $file_buffer  = file_get_contents($path);

    1348. 

  1348.       $file_buffer  = $this->EncodeString($file_buffer, $encoding);

    1349. 

  1349.       if (PHP_VERSION < 6) { set_magic_quotes_runtime($magic_quotes); }

    1350. 

  1350.       return $file_buffer;

    1351. 

  1351.     } catch (Exception $e) {

    1352. 

  1352.       $this->SetError($e->getMessage());

    1353. 

  1353.       return '';

    1354. 

  1354.     }

    1355. 

  1355.   }

    1356. 

  1356. 

    1357. 

  1357.   /**

    1358. 

  1358.    * Encodes string to requested format.

    1359. 

  1359.    * Returns an empty string on failure.

    1360. 

  1360.    * @param string $str The text to encode

    1361. 

  1361.    * @param string $encoding The encoding to use; one of 'base64', '7bit', '8bit', 'binary', 'quoted-printable'

    1362. 

  1362.    * @access public

    1363. 

  1363.    * @return string

    1364. 

  1364.    */

    1365. 

  1365.   public function EncodeString ($str, $encoding = 'base64') {

    1366. 

  1366.     $encoded = '';

    1367. 

  1367.     switch(strtolower($encoding)) {

    1368. 

  1368.       case 'base64':

    1369. 

  1369.         $encoded = chunk_split(base64_encode($str), 76, $this->LE);

    1370. 

  1370.         break;

    1371. 

  1371.       case '7bit':

    1372. 

  1372.       case '8bit':

    1373. 

  1373.         $encoded = $this->FixEOL($str);

    1374. 

  1374.         //Make sure it ends with a line break

    1375. 

  1375.         if (substr($encoded, -(strlen($this->LE))) != $this->LE)

    1376. 

  1376.           $encoded .= $this->LE;

    1377. 

  1377.         break;

    1378. 

  1378.       case 'binary':

    1379. 

  1379.         $encoded = $str;

    1380. 

  1380.         break;

    1381. 

  1381.       case 'quoted-printable':

    1382. 

  1382.         $encoded = $this->EncodeQP($str);

    1383. 

  1383.         break;

    1384. 

  1384.       default:

    1385. 

  1385.         $this->SetError($this->Lang('encoding') . $encoding);

    1386. 

  1386.         break;

    1387. 

  1387.     }

    1388. 

  1388.     return $encoded;

    1389. 

  1389.   }

    1390. 

  1390. 

    1391. 

  1391.   /**

    1392. 

  1392.    * Encode a header string to best (shortest) of Q, B, quoted or none.

    1393. 

  1393.    * @access public

    1394. 

  1394.    * @return string

    1395. 

  1395.    */

    1396. 

  1396.   public function EncodeHeader($str, $position = 'text') {

    1397. 

  1397.     $x = 0;

    1398. 

  1398. 

    1399. 

  1399.     switch (strtolower($position)) {

    1400. 

  1400.       case 'phrase':

    1401. 

  1401.         if (!preg_match('/[\200-\377]/', $str)) {

    1402. 

  1402.           // Can't use addslashes as we don't know what value has magic_quotes_sybase

    1403. 

  1403.           $encoded = addcslashes($str, "\0..\37\177\\\"");

    1404. 

  1404.           if (($str == $encoded) && !preg_match('/[^A-Za-z0-9!#$%&\'*+\/=?^_`{|}~ -]/', $str)) {

    1405. 

  1405.             return ($encoded);

    1406. 

  1406.           } else {

    1407. 

  1407.             return ("\"$encoded\"");

    1408. 

  1408.           }

    1409. 

  1409.         }

    1410. 

  1410.         $x = preg_match_all('/[^\040\041\043-\133\135-\176]/', $str, $matches);

    1411. 

  1411.         break;

    1412. 

  1412.       case 'comment':

    1413. 

  1413.         $x = preg_match_all('/[()"]/', $str, $matches);

    1414. 

  1414.         // Fall-through

    1415. 

  1415.       case 'text':

    1416. 

  1416.       default:

    1417. 

  1417.         $x += preg_match_all('/[\000-\010\013\014\016-\037\177-\377]/', $str, $matches);

    1418. 

  1418.         break;

    1419. 

  1419.     }

    1420. 

  1420. 

    1421. 

  1421.     if ($x == 0) {

    1422. 

  1422.       return ($str);

    1423. 

  1423.     }

    1424. 

  1424. 

    1425. 

  1425.     $maxlen = 75 - 7 - strlen($this->CharSet);

    1426. 

  1426.     // Try to select the encoding which should produce the shortest output

    1427. 

  1427.     if (strlen($str)/3 < $x) {

    1428. 

  1428.       $encoding = 'B';

    1429. 

  1429.       if (function_exists('mb_strlen') && $this->HasMultiBytes($str)) {

    1430. 

  1430.         // Use a custom function which correctly encodes and wraps long

    1431. 

  1431.         // multibyte strings without breaking lines within a character

    1432. 

  1432.         $encoded = $this->Base64EncodeWrapMB($str);

    1433. 

  1433.       } else {

    1434. 

  1434.         $encoded = base64_encode($str);

    1435. 

  1435.         $maxlen -= $maxlen % 4;

    1436. 

  1436.         $encoded = trim(chunk_split($encoded, $maxlen, "\n"));

    1437. 

  1437.       }

    1438. 

  1438.     } else {

    1439. 

  1439.       $encoding = 'Q';

    1440. 

  1440.       $encoded = $this->EncodeQ($str, $position);

    1441. 

  1441.       $encoded = $this->WrapText($encoded, $maxlen, true);

    1442. 

  1442.       $encoded = str_replace('='.$this->LE, "\n", trim($encoded));

    1443. 

  1443.     }

    1444. 

  1444. 

    1445. 

  1445.     $encoded = preg_replace('/^(.*)$/m', " =?".$this->CharSet."?$encoding?\\1?=", $encoded);

    1446. 

  1446.     $encoded = trim(str_replace("\n", $this->LE, $encoded));

    1447. 

  1447. 

    1448. 

  1448.     return $encoded;

    1449. 

  1449.   }

    1450. 

  1450. 

    1451. 

  1451.   /**

    1452. 

  1452.    * Checks if a string contains multibyte characters.

    1453. 

  1453.    * @access public

    1454. 

  1454.    * @param string $str multi-byte text to wrap encode

    1455. 

  1455.    * @return bool

    1456. 

  1456.    */

    1457. 

  1457.   public function HasMultiBytes($str) {

    1458. 

  1458.     if (function_exists('mb_strlen')) {

    1459. 

  1459.       return (strlen($str) > mb_strlen($str, $this->CharSet));

    1460. 

  1460.     } else { // Assume no multibytes (we can't handle without mbstring functions anyway)

    1461. 

  1461.       return false;

    1462. 

  1462.     }

    1463. 

  1463.   }

    1464. 

  1464. 

    1465. 

  1465.   /**

    1466. 

  1466.    * Correctly encodes and wraps long multibyte strings for mail headers

    1467. 

  1467.    * without breaking lines within a character.

    1468. 

  1468.    * Adapted from a function by paravoid at http://uk.php.net/manual/en/function.mb-encode-mimeheader.php

    1469. 

  1469.    * @access public

    1470. 

  1470.    * @param string $str multi-byte text to wrap encode

    1471. 

  1471.    * @return string

    1472. 

  1472.    */

    1473. 

  1473.   public function Base64EncodeWrapMB($str) {

    1474. 

  1474.     $start = "=?".$this->CharSet."?B?";

    1475. 

  1475.     $end = "?=";

    1476. 

  1476.     $encoded = "";

    1477. 

  1477. 

    1478. 

  1478.     $mb_length = mb_strlen($str, $this->CharSet);

    1479. 

  1479.     // Each line must have length <= 75, including $start and $end

    1480. 

  1480.     $length = 75 - strlen($start) - strlen($end);

    1481. 

  1481.     // Average multi-byte ratio

    1482. 

  1482.     $ratio = $mb_length / strlen($str);

    1483. 

  1483.     // Base64 has a 4:3 ratio

    1484. 

  1484.     $offset = $avgLength = floor($length * $ratio * .75);

    1485. 

  1485. 

    1486. 

  1486.     for ($i = 0; $i < $mb_length; $i += $offset) {

    1487. 

  1487.       $lookBack = 0;

    1488. 

  1488. 

    1489. 

  1489.       do {

    1490. 

  1490.         $offset = $avgLength - $lookBack;

    1491. 

  1491.         $chunk = mb_substr($str, $i, $offset, $this->CharSet);

    1492. 

  1492.         $chunk = base64_encode($chunk);

    1493. 

  1493.         $lookBack++;

    1494. 

  1494.       }

    1495. 

  1495.       while (strlen($chunk) > $length);

    1496. 

  1496. 

    1497. 

  1497.       $encoded .= $chunk . $this->LE;

    1498. 

  1498.     }

    1499. 

  1499. 

    1500. 

  1500.     // Chomp the last linefeed

    1501. 

  1501.     $encoded = substr($encoded, 0, -strlen($this->LE));

    1502. 

  1502.     return $encoded;

    1503. 

  1503.   }

    1504. 

  1504. 

    1505. 

  1505.   /**

    1506. 

  1506.   * Encode string to quoted-printable.

    1507. 

  1507.   * Only uses standard PHP, slow, but will always work

    1508. 

  1508.   * @access public

    1509. 

  1509.   * @param string $string the text to encode

    1510. 

  1510.   * @param integer $line_max Number of chars allowed on a line before wrapping

    1511. 

  1511.   * @return string

    1512. 

  1512.   */

    1513. 

  1513.   public function EncodeQPphp( $input = '', $line_max = 76, $space_conv = false) {

    1514. 

  1514.     $hex = array('0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F');

    1515. 

  1515.     $lines = preg_split('/(?:\r\n|\r|\n)/', $input);

    1516. 

  1516.     $eol = "\r\n";

    1517. 

  1517.     $escape = '=';

    1518. 

  1518.     $output = '';

    1519. 

  1519.     while( list(, $line) = each($lines) ) {

    1520. 

  1520.       $linlen = strlen($line);

    1521. 

  1521.       $newline = '';

    1522. 

  1522.   …
    1523.

Large files files are truncated, but you can click here to view the full file