PageRenderTime 135ms CodeModel.GetById 41ms RepoModel.GetById 1ms app.codeStats 0ms

/classes/fEmail.php

https://bitbucket.org/dsqmoore/flourish
PHP | 1805 lines | 1283 code | 150 blank | 372 comment | 78 complexity | c7a9954763f589c31b0ec0d86a2cff79 MD5 | raw file

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

    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * Allows creating and sending a single email containing plaintext, HTML, attachments and S/MIME encryption
    4. 

  4.  * 
    5. 

  5.  * Please note that this class uses the [http://php.net/function.mail mail()]
    6. 

  6.  * function by default. Developers that are sending multiple emails, or need
    7. 

  7.  * SMTP support, should use fSMTP with this class.
    8. 

  8.  * 
    9. 

  9.  * This class is implemented to use the UTF-8 character encoding. Please see
    10. 

  10.  * http://flourishlib.com/docs/UTF-8 for more information.
    11. 

  11.  * 
    12. 

  12.  * @copyright  Copyright (c) 2008-2011 Will Bond, others
    13. 

  13.  * @author     Will Bond [wb] <will@flourishlib.com>
    14. 

  14.  * @author     Bill Bushee, iMarc LLC [bb-imarc] <bill@imarc.net>
    15. 

  15.  * @author     netcarver [n] <fContrib@netcarving.com>
    16. 

  16.  * @license    http://flourishlib.com/license
    17. 

  17.  * 
    18. 

  18.  * @package    Flourish
    19. 

  19.  * @link       http://flourishlib.com/fEmail
    20. 

  20.  * 
    21. 

  21.  * @version    1.0.0b30
    22. 

  22.  * @changes    1.0.0b30  Changed methods to return instance for method chaining [n, 2011-09-12]
    23. 

  23.  * @changes    1.0.0b29  Changed ::combineNameEmail() to be a static method and to be exposed publicly for use by other classes [wb, 2011-07-26]
    24. 

  24.  * @changes    1.0.0b28  Fixed ::addAttachment() and ::addRelatedFile() to properly handle duplicate filenames [wb, 2011-05-17]
    25. 

  25.  * @changes    1.0.0b27  Fixed a bug with generating FQDNs on some Windows machines [wb, 2011-02-24]
    26. 

  26.  * @changes    1.0.0b26  Added ::addCustomerHeader() [wb, 2011-02-02]
    27. 

  27.  * @changes    1.0.0b25  Fixed a bug with finding the FQDN on non-Windows machines [wb, 2011-01-19]
    28. 

  28.  * @changes    1.0.0b24  Backwards Compatibility Break - the `$contents` parameter of ::addAttachment() is now first instead of third, ::addAttachment() will now accept fFile objects for the `$contents` parameter, added ::addRelatedFile() [wb, 2010-12-01]
    29. 

  29.  * @changes    1.0.0b23  Fixed a bug on Windows where emails starting with a `.` would have the `.` removed [wb, 2010-09-11]
    30. 

  30.  * @changes    1.0.0b22  Revamped the FQDN code and added ::getFQDN() [wb, 2010-09-07]
    31. 

  31.  * @changes    1.0.0b21  Added a check to prevent permissions warnings when getting the FQDN on Windows machines [wb, 2010-09-02]
    32. 

  32.  * @changes    1.0.0b20  Fixed ::send() to only remove the name of a recipient when dealing with the `mail()` function on Windows and to leave it when using fSMTP [wb, 2010-06-22]
    33. 

  33.  * @changes    1.0.0b19  Changed ::send() to return the message id for the email, fixed the email regexes to require [] around IPs [wb, 2010-05-05]
    34. 

  34.  * @changes    1.0.0b18  Fixed the name of the static method ::unindentExpand() [wb, 2010-04-28]
    35. 

  35.  * @changes    1.0.0b17  Added the static method ::unindentExpand() [wb, 2010-04-26]
    36. 

  36.  * @changes    1.0.0b16  Added support for sending emails via fSMTP [wb, 2010-04-20]
    37. 

  37.  * @changes    1.0.0b15  Added the `$unindent_expand_constants` parameter to ::setBody(), added ::loadBody() and ::loadHTMLBody(), fixed HTML emails with attachments [wb, 2010-03-14]
    38. 

  38.  * @changes    1.0.0b14  Changed ::send() to not double `.`s at the beginning of lines on Windows since it seemed to break things rather than fix them [wb, 2010-03-05]
    39. 

  39.  * @changes    1.0.0b13  Fixed the class to work when safe mode is turned on [wb, 2009-10-23]
    40. 

  40.  * @changes    1.0.0b12  Removed duplicate MIME-Version headers that were being included in S/MIME encrypted emails [wb, 2009-10-05]
    41. 

  41.  * @changes    1.0.0b11  Updated to use the new fValidationException API [wb, 2009-09-17]
    42. 

  42.  * @changes    1.0.0b10  Fixed a bug with sending both an HTML and a plaintext body [bb-imarc, 2009-06-18]
    43. 

  43.  * @changes    1.0.0b9   Fixed a bug where the MIME headers were not being set for all emails [wb, 2009-06-12]
    44. 

  44.  * @changes    1.0.0b8   Added the method ::clearRecipients() [wb, 2009-05-29]
    45. 

  45.  * @changes    1.0.0b7   Email names with UTF-8 characters are now properly encoded [wb, 2009-05-08]
    46. 

  46.  * @changes    1.0.0b6   Fixed a bug where <> quoted email addresses in validation messages were not showing [wb, 2009-03-27]
    47. 

  47.  * @changes    1.0.0b5   Updated for new fCore API [wb, 2009-02-16]
    48. 

  48.  * @changes    1.0.0b4   The recipient error message in ::validate() no longer contains a typo [wb, 2009-02-09]
    49. 

  49.  * @changes    1.0.0b3   Fixed a bug with missing content in the fValidationException thrown by ::validate() [wb, 2009-01-14]
    50. 

  50.  * @changes    1.0.0b2   Fixed a few bugs with sending S/MIME encrypted/signed emails [wb, 2009-01-10]
    51. 

  51.  * @changes    1.0.0b    The initial implementation [wb, 2008-06-23]
    52. 

  52.  */
    53. 

  53. class fEmail
    54. 

  54. {
    55. 

  55. 	// The following constants allow for nice looking callbacks to static methods
    56. 

  56. 	const combineNameEmail = 'fEmail::combineNameEmail';
    57. 

  57. 	const fixQmail         = 'fEmail::fixQmail';
    58. 

  58. 	const getFQDN          = 'fEmail::getFQDN';
    59. 

  59. 	const reset            = 'fEmail::reset';
    60. 

  60. 	const unindentExpand   = 'fEmail::unindentExpand';
    61. 

  61. 	
    62. 

  62. 	
    63. 

  63. 	/**
    64. 

  64. 	 * A regular expression to match an email address, exluding those with comments and folding whitespace
    65. 

  65. 	 * 
    66. 

  66. 	 * The matches will be:
    67. 

  67. 	 *  
    68. 

  68. 	 *  - `[0]`: The whole email address
    69. 

  69. 	 *  - `[1]`: The name before the `@`
    70. 

  70. 	 *  - `[2]`: The domain/ip after the `@`
    71. 

  71. 	 * 
    72. 

  72. 	 * @var string
    73. 

  73. 	 */
    74. 

  74. 	const EMAIL_REGEX = '~^[ \t]*(                                                                      # Allow leading whitespace
    75. 

  75. 						   (?:[^\x00-\x20\(\)<>@,;:\\\\"\.\[\]]+|"[^"\\\\\n\r]+")                       # An "atom" or a quoted string
    76. 

  76. 						   (?:\.[ \t]*(?:[^\x00-\x20\(\)<>@,;:\\\\"\.\[\]]+|"[^"\\\\\n\r]+"[ \t]*))*    # A . plus another "atom" or a quoted string, any number of times
    77. 

  77. 						 )@(                                                                            # The @ symbol
    78. 

  78. 						   (?:[a-z0-9\\-]+\.)+[a-z]{2,}|                                                # Domain name
    79. 

  79. 						   \[(?:(?:[01]?\d?\d|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d?\d|2[0-4]\d|25[0-5])\]  # (or) IP addresses
    80. 

  80. 						 )[ \t]*$~ixD';                                                                 # Allow Trailing whitespace
    81. 

  81. 	
    82. 

  82. 	/**
    83. 

  83. 	 * A regular expression to match a `name <email>` string, exluding those with comments and folding whitespace
    84. 

  84. 	 * 
    85. 

  85. 	 * The matches will be:
    86. 

  86. 	 * 
    87. 

  87. 	 *  - `[0]`: The whole name and email address
    88. 

  88. 	 *  - `[1]`: The name
    89. 

  89. 	 *  - `[2]`: The whole email address
    90. 

  90. 	 *  - `[3]`: The email username before the `@`
    91. 

  91. 	 *  - `[4]`: The email domain/ip after the `@`
    92. 

  92. 	 * 
    93. 

  93. 	 * @var string
    94. 

  94. 	 */
    95. 

  95. 	const NAME_EMAIL_REGEX = '~^[ \t]*(                                                                            # Allow leading whitespace
    96. 

  96. 								(?:[^\x00-\x20\(\)<>@,;:\\\\"\.\[\]]+[ \t]*|"[^"\\\\\n\r]+"[ \t]*)                 # An "atom" or a quoted string
    97. 

  97. 								(?:\.?[ \t]*(?:[^\x00-\x20\(\)<>@,;:\\\\"\.\[\]]+[ \t]*|"[^"\\\\\n\r]+"[ \t]*))*)  # Another "atom" or a quoted string or a . followed by one of those, any number of times
    98. 

  98. 							  [ \t]*<[ \t]*((                                                                      # The < encapsulating the email address
    99. 

  99. 								(?:[^\x00-\x20\(\)<>@,;:\\\\"\.\[\]]+|"[^"\\\\\n\r]+")                             # An "atom" or a quoted string
    100. 

  100. 								(?:\.[ \t]*(?:[^\x00-\x20\(\)<>@,;:\\\\"\.\[\]]+|"[^"\\\\\n\r]+"[ \t]*))*          # A . plus another "atom" or a quoted string, any number of times
    101. 

  101. 							  )@(                                                                                  # The @ symbol
    102. 

  102. 								(?:[a-z0-9\\-]+\.)+[a-z]{2,}|                                                      # Domain nam
    103. 

  103. 								\[(?:(?:[01]?\d?\d|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d?\d|2[0-4]\d|25[0-5])\]        # (or) IP addresses
    104. 

  104. 							  ))[ \t]*>[ \t]*$~ixD';                                                               # Closing > and trailing whitespace
    105. 

  105. 	
    106. 

  106. 	
    107. 

  107. 	/**
    108. 

  108. 	 * Flags if the class should convert `\r\n` to `\n` for qmail. This makes invalid email headers that may work.
    109. 

  109. 	 * 
    110. 

  110. 	 * @var boolean
    111. 

  111. 	 */
    112. 

  112. 	static private $convert_crlf  = FALSE;
    113. 

  113. 	
    114. 

  114. 	/**
    115. 

  115. 	 * The local fully-qualified domain name
    116. 

  116. 	 */
    117. 

  117. 	static private $fqdn;
    118. 

  118. 	
    119. 

  119. 	/**
    120. 

  120. 	 * Flags if the class should use [http://php.net/popen popen()] to send mail via sendmail
    121. 

  121. 	 * 
    122. 

  122. 	 * @var boolean
    123. 

  123. 	 */
    124. 

  124. 	static private $popen_sendmail = FALSE;
    125. 

  125. 

  126. 

  127. 	/**
    128. 

  128. 	 * Turns a name and email into a `"name" <email>` string, or just `email` if no name is provided
    129. 

  129. 	 * 
    130. 

  130. 	 * This method will remove newline characters from the name and email, and
    131. 

  131. 	 * will remove any backslash (`\`) and double quote (`"`) characters from
    132. 

  132. 	 * the name.
    133. 

  133. 	 * 
    134. 

  134. 	 * @internal
    135. 

  135. 	 *
    136. 

  136. 	 * @param  string $name   The name associated with the email address
    137. 

  137. 	 * @param  string $email  The email address
    138. 

  138. 	 * @return string  The '"name" <email>' or 'email' string
    139. 

  139. 	 */
    140. 

  140. 	static public function combineNameEmail($name, $email)
    141. 

  141. 	{
    142. 

  142. 		// Strip lower ascii character since they aren't useful in email addresses
    143. 

  143. 		$email = preg_replace('#[\x0-\x19]+#', '', $email);
    144. 

  144. 		$name  = preg_replace('#[\x0-\x19]+#', '', $name);
    145. 

  145. 		
    146. 

  146. 		if (!$name) {
    147. 

  147. 			return $email;
    148. 

  148. 		}
    149. 

  149. 		
    150. 

  150. 		// If the name contains any non-ascii bytes or stuff not allowed
    151. 

  151. 		// in quoted strings we just make an encoded word out of it
    152. 

  152. 		if (preg_replace('#[\x80-\xff\x5C\x22]#', '', $name) != $name) {
    153. 

  153. 			// The longest header name that will contain email addresses is
    154. 

  154. 			// "Bcc: ", which is 5 characters long
    155. 

  155. 			$name = self::makeEncodedWord($name, 5);
    156. 

  156. 		} else {
    157. 

  157. 			$name = '"' . $name . '"';	
    158. 

  158. 		}
    159. 

  159. 		
    160. 

  160. 		return $name . ' <' . $email . '>';
    161. 

  161. 	}
    162. 

  162. 	
    163. 

  163. 	
    164. 

  164. 	/**
    165. 

  165. 	 * Composes text using fText if loaded
    166. 

  166. 	 * 
    167. 

  167. 	 * @param  string  $message    The message to compose
    168. 

  168. 	 * @param  mixed   $component  A string or number to insert into the message
    169. 

  169. 	 * @param  mixed   ...
    170. 

  170. 	 * @return string  The composed and possible translated message
    171. 

  171. 	 */
    172. 

  172. 	static protected function compose($message)
    173. 

  173. 	{
    174. 

  174. 		$args = array_slice(func_get_args(), 1);
    175. 

  175. 		
    176. 

  176. 		if (class_exists('fText', FALSE)) {
    177. 

  177. 			return call_user_func_array(
    178. 

  178. 				array('fText', 'compose'),
    179. 

  179. 				array($message, $args)
    180. 

  180. 			);
    181. 

  181. 		} else {
    182. 

  182. 			return vsprintf($message, $args);
    183. 

  183. 		}
    184. 

  184. 	}
    185. 

  185. 	
    186. 

  186. 	
    187. 

  187. 	/**
    188. 

  188. 	 * Sets the class to try and fix broken qmail implementations that add `\r` to `\r\n`
    189. 

  189. 	 * 
    190. 

  190. 	 * Before trying to fix qmail with this method, please try using fSMTP
    191. 

  191. 	 * to connect to `localhost` and pass the fSMTP object to ::send().
    192. 

  192. 	 * 
    193. 

  193. 	 * @return void
    194. 

  194. 	 */
    195. 

  195. 	static public function fixQmail()
    196. 

  196. 	{
    197. 

  197. 		if (fCore::checkOS('windows')) {
    198. 

  198. 			return;
    199. 

  199. 		}
    200. 

  200. 		
    201. 

  201. 		$sendmail_command = ini_get('sendmail_path');
    202. 

  202. 		
    203. 

  203. 		if (!$sendmail_command) {
    204. 

  204. 			self::$convert_crlf = TRUE;
    205. 

  205. 			trigger_error(
    206. 

  206. 				self::compose('The proper fix for sending through qmail is not possible since the sendmail path is not set'),
    207. 

  207. 				E_USER_WARNING
    208. 

  208. 			);
    209. 

  209. 			trigger_error(
    210. 

  210. 				self::compose('Trying to fix qmail by converting all \r\n to \n. This will cause invalid (but possibly functioning) email headers to be generated.'),
    211. 

  211. 				E_USER_WARNING
    212. 

  212. 			);
    213. 

  213. 		}
    214. 

  214. 		
    215. 

  215. 		$sendmail_command_parts = explode(' ', $sendmail_command, 2);
    216. 

  216. 		
    217. 

  217. 		$sendmail_path   = $sendmail_command_parts[0];
    218. 

  218. 		$sendmail_dir    = pathinfo($sendmail_path, PATHINFO_DIRNAME);
    219. 

  219. 		$sendmail_params = (isset($sendmail_command_parts[1])) ? $sendmail_command_parts[1] : '';
    220. 

  220. 		
    221. 

  221. 		// Check to see if we can run sendmail via popen
    222. 

  222. 		$executable = FALSE;
    223. 

  223. 		$safe_mode  = FALSE;
    224. 

  224. 		
    225. 

  225. 		if (!in_array(strtolower(ini_get('safe_mode')), array('0', '', 'off'))) {
    226. 

  226. 			$safe_mode = TRUE;
    227. 

  227. 			$exec_dirs = explode(';', ini_get('safe_mode_exec_dir'));
    228. 

  228. 			foreach ($exec_dirs as $exec_dir) {
    229. 

  229. 				if (stripos($sendmail_dir, $exec_dir) !== 0) {
    230. 

  230. 					continue;
    231. 

  231. 				}
    232. 

  232. 				if (file_exists($sendmail_path) && is_executable($sendmail_path)) {
    233. 

  233. 					$executable = TRUE;
    234. 

  234. 				}
    235. 

  235. 			}
    236. 

  236. 			
    237. 

  237. 		} else {
    238. 

  238. 			if (file_exists($sendmail_path) && is_executable($sendmail_path)) {
    239. 

  239. 				$executable = TRUE;
    240. 

  240. 			}
    241. 

  241. 		}
    242. 

  242. 		
    243. 

  243. 		if ($executable) {
    244. 

  244. 			self::$popen_sendmail = TRUE;
    245. 

  245. 		} else {
    246. 

  246. 			self::$convert_crlf   = TRUE;
    247. 

  247. 			if ($safe_mode) {
    248. 

  248. 				trigger_error(
    249. 

  249. 					self::compose('The proper fix for sending through qmail is not possible since safe mode is turned on and the sendmail binary is not in one of the paths defined by the safe_mode_exec_dir ini setting'),
    250. 

  250. 					E_USER_WARNING
    251. 

  251. 				);
    252. 

  252. 				trigger_error(
    253. 

  253. 					self::compose('Trying to fix qmail by converting all \r\n to \n. This will cause invalid (but possibly functioning) email headers to be generated.'),
    254. 

  254. 					E_USER_WARNING
    255. 

  255. 				);
    256. 

  256. 			} else {
    257. 

  257. 				trigger_error(
    258. 

  258. 					self::compose('The proper fix for sending through qmail is not possible since the sendmail binary could not be found or is not executable'),
    259. 

  259. 					E_USER_WARNING
    260. 

  260. 				);
    261. 

  261. 				trigger_error(
    262. 

  262. 					self::compose('Trying to fix qmail by converting all \r\n to \n. This will cause invalid (but possibly functioning) email headers to be generated.'),
    263. 

  263. 					E_USER_WARNING
    264. 

  264. 				);
    265. 

  265. 			}
    266. 

  266. 		}
    267. 

  267. 	}
    268. 

  268. 	
    269. 

  269. 	
    270. 

  270. 	/**
    271. 

  271. 	 * Returns the fully-qualified domain name of the server
    272. 

  272. 	 * 
    273. 

  273. 	 * @internal
    274. 

  274. 	 * 
    275. 

  275. 	 * @return string  The fully-qualified domain name of the server
    276. 

  276. 	 */
    277. 

  277. 	static public function getFQDN()
    278. 

  278. 	{
    279. 

  279. 		if (self::$fqdn !== NULL) {
    280. 

  280. 			return self::$fqdn;
    281. 

  281. 		}
    282. 

  282. 		
    283. 

  283. 		if (isset($_ENV['HOST'])) {
    284. 

  284. 			self::$fqdn = $_ENV['HOST'];
    285. 

  285. 		}
    286. 

  286. 		if (strpos(self::$fqdn, '.') === FALSE && isset($_ENV['HOSTNAME'])) {
    287. 

  287. 			self::$fqdn = $_ENV['HOSTNAME'];
    288. 

  288. 		}
    289. 

  289. 		if (strpos(self::$fqdn, '.') === FALSE) {
    290. 

  290. 			self::$fqdn = php_uname('n');
    291. 

  291. 		}
    292. 

  292. 		
    293. 

  293. 		if (strpos(self::$fqdn, '.') === FALSE) {
    294. 

  294. 			
    295. 

  295. 			$can_exec = !in_array('exec', array_map('trim', explode(',', ini_get('disable_functions')))) && !ini_get('safe_mode');
    296. 

  296. 			if (fCore::checkOS('linux') && $can_exec) {
    297. 

  297. 				self::$fqdn = trim(shell_exec('hostname --fqdn'));
    298. 

  298. 				
    299. 

  299. 			} elseif (fCore::checkOS('windows')) {
    300. 

  300. 				$shell = new COM('WScript.Shell');
    301. 

  301. 				$tcpip_key = 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip';
    302. 

  302. 				try {
    303. 

  303. 					$domain = $shell->RegRead($tcpip_key . '\Parameters\NV Domain');
    304. 

  304. 				} catch (com_exception $e) {
    305. 

  305. 					try {
    306. 

  306. 						$domain = $shell->RegRead($tcpip_key . '\Parameters\DhcpDomain');
    307. 

  307. 					} catch (com_exception $e) {
    308. 

  308. 						try {
    309. 

  309. 							$adapters = $shell->RegRead($tcpip_key . '\Linkage\Route');
    310. 

  310. 							foreach ($adapters as $adapter) {
    311. 

  311. 								if ($adapter[0] != '{') { continue; }
    312. 

  312. 								try {
    313. 

  313. 									$domain = $shell->RegRead($tcpip_key . '\Interfaces\\' . $adapter . '\Domain');
    314. 

  314. 								} catch (com_exception $e) {
    315. 

  315. 									try {
    316. 

  316. 										$domain = $shell->RegRead($tcpip_key . '\Interfaces\\' . $adapter . '\DhcpDomain');
    317. 

  317. 									} catch (com_exception $e) { }
    318. 

  318. 								}
    319. 

  319. 							}
    320. 

  320. 						} catch (com_exception $e) { }
    321. 

  321. 					}
    322. 

  322. 				}
    323. 

  323. 				if (!empty($domain)) {
    324. 

  324. 					self::$fqdn .= '.' . $domain;
    325. 

  325. 				} 
    326. 

  326. 				
    327. 

  327. 			} elseif (!fCore::checkOS('windows') && !ini_get('open_basedir') && file_exists('/etc/resolv.conf')) {
    328. 

  328. 				$output = file_get_contents('/etc/resolv.conf');
    329. 

  329. 				if (preg_match('#^domain ([a-z0-9_.-]+)#im', $output, $match)) {
    330. 

  330. 					self::$fqdn .= '.' . $match[1];
    331. 

  331. 				}
    332. 

  332. 			}
    333. 

  333. 		}
    334. 

  334. 		
    335. 

  335. 		return self::$fqdn;
    336. 

  336. 	}
    337. 

  337. 

  338. 

  339. 	/**
    340. 

  340. 	 * Encodes a string to UTF-8 encoded-word
    341. 

  341. 	 * 
    342. 

  342. 	 * @param  string  $content                   The content to encode
    343. 

  343. 	 * @param  integer $first_line_prefix_length  The length of any prefix applied to the first line of the encoded word - this allows properly accounting for a header name
    344. 

  344. 	 * @return string  The encoded string
    345. 

  345. 	 */
    346. 

  346. 	static private function makeEncodedWord($content, $first_line_prefix_length)
    347. 

  347. 	{
    348. 

  348. 		// Homogenize the line-endings to CRLF
    349. 

  349. 		$content = str_replace("\r\n", "\n", $content);
    350. 

  350. 		$content = str_replace("\r", "\n", $content);
    351. 

  351. 		$content = str_replace("\n", "\r\n", $content);
    352. 

  352. 		
    353. 

  353. 		// Encoded word is not required if all characters are ascii
    354. 

  354. 		if (!preg_match('#[\x80-\xFF]#', $content)) {
    355. 

  355. 			return $content;
    356. 

  356. 		}
    357. 

  357. 		
    358. 

  358. 		// A quick a dirty hex encoding
    359. 

  359. 		$content = rawurlencode($content);
    360. 

  360. 		$content = str_replace('=', '%3D', $content);
    361. 

  361. 		$content = str_replace('%', '=', $content);
    362. 

  362. 		
    363. 

  363. 		// Decode characters that don't have to be coded
    364. 

  364. 		$decodings = array(
    365. 

  365. 			'=20' => '_', '=21' => '!', '=22' => '"',  '=23' => '#',
    366. 

  366. 			'=24' => '$', '=25' => '%', '=26' => '&',  '=27' => "'",
    367. 

  367. 			'=28' => '(', '=29' => ')', '=2A' => '*',  '=2B' => '+',
    368. 

  368. 			'=2C' => ',', '=2D' => '-', '=2E' => '.',  '=2F' => '/',
    369. 

  369. 			'=3A' => ':', '=3B' => ';', '=3C' => '<',  '=3E' => '>',
    370. 

  370. 			'=40' => '@', '=5B' => '[', '=5C' => '\\', '=5D' => ']',
    371. 

  371. 			'=5E' => '^', '=60' => '`', '=7B' => '{',  '=7C' => '|',
    372. 

  372. 			'=7D' => '}', '=7E' => '~', ' '   => '_'
    373. 

  373. 		);
    374. 

  374. 		
    375. 

  375. 		$content = strtr($content, $decodings);
    376. 

  376. 		
    377. 

  377. 		$length = strlen($content);
    378. 

  378. 		
    379. 

  379. 		$prefix = '=?utf-8?Q?';
    380. 

  380. 		$suffix = '?=';
    381. 

  381. 		
    382. 

  382. 		$prefix_length = 10;
    383. 

  383. 		$suffix_length = 2;
    384. 

  384. 		
    385. 

  385. 		// This loop goes through and ensures we are wrapping by 75 chars
    386. 

  386. 		// including the encoded word delimiters
    387. 

  387. 		$output = $prefix;
    388. 

  388. 		$line_length = $prefix_length + $first_line_prefix_length;
    389. 

  389. 		
    390. 

  390. 		for ($i=0; $i<$length; $i++) {
    391. 

  391. 			
    392. 

  392. 			// Get info about the next character
    393. 

  393. 			$char_length = ($content[$i] == '=') ? 3 : 1;
    394. 

  394. 			$char        = $content[$i];
    395. 

  395. 			if ($char_length == 3) {
    396. 

  396. 				$char .= $content[$i+1] . $content[$i+2];
    397. 

  397. 			}
    398. 

  398. 			
    399. 

  399. 			// If we have too long a line, wrap it
    400. 

  400. 			if ($line_length + $suffix_length + $char_length > 75) {
    401. 

  401. 				$output .= $suffix . "\r\n " . $prefix;
    402. 

  402. 				$line_length = $prefix_length + 2;
    403. 

  403. 			}
    404. 

  404. 			
    405. 

  405. 			// Add the character
    406. 

  406. 			$output .= $char;
    407. 

  407. 			
    408. 

  408. 			// Figure out how much longer the line is
    409. 

  409. 			$line_length += $char_length;
    410. 

  410. 			
    411. 

  411. 			// Skip characters if we have an encoded character
    412. 

  412. 			$i += $char_length-1;
    413. 

  413. 		}
    414. 

  414. 		
    415. 

  415. 		if (substr($output, -2) != $suffix) {
    416. 

  416. 			$output .= $suffix;
    417. 

  417. 		}
    418. 

  418. 		
    419. 

  419. 		return $output;
    420. 

  420. 	}
    421. 

  421. 	
    422. 

  422. 	
    423. 

  423. 	/**
    424. 

  424. 	 * Resets the configuration of the class
    425. 

  425. 	 * 
    426. 

  426. 	 * @internal
    427. 

  427. 	 * 
    428. 

  428. 	 * @return void
    429. 

  429. 	 */
    430. 

  430. 	static public function reset()
    431. 

  431. 	{
    432. 

  432. 		self::$convert_crlf   = FALSE;
    433. 

  433. 		self::$fqdn           = NULL;
    434. 

  434. 		self::$popen_sendmail = FALSE;
    435. 

  435. 	}
    436. 

  436. 	
    437. 

  437. 	
    438. 

  438. 	/**
    439. 

  439. 	 * Returns `TRUE` for non-empty strings, numbers, objects, empty numbers and string-like numbers (such as `0`, `0.0`, `'0'`)
    440. 

  440. 	 * 
    441. 

  441. 	 * @param  mixed $value  The value to check
    442. 

  442. 	 * @return boolean  If the value is string-like
    443. 

  443. 	 */
    444. 

  444. 	static protected function stringlike($value)
    445. 

  445. 	{
    446. 

  446. 		if ((!is_string($value) && !is_object($value) && !is_numeric($value)) || !strlen(trim($value))) {
    447. 

  447. 			return FALSE;	
    448. 

  448. 		}
    449. 

  449. 		
    450. 

  450. 		return TRUE;
    451. 

  451. 	}
    452. 

  452. 	
    453. 

  453. 	
    454. 

  454. 	/**
    455. 

  455. 	 * Takes a block of text, unindents it and replaces {CONSTANT} tokens with the constant's value
    456. 

  456. 	 * 
    457. 

  457. 	 * @param string $text  The text to unindent and replace constants in
    458. 

  458. 	 * @return string  The unindented text
    459. 

  459. 	 */
    460. 

  460. 	static public function unindentExpand($text)
    461. 

  461. 	{
    462. 

  462. 		$text = preg_replace('#^[ \t]*\n|\n[ \t]*$#D', '', $text);
    463. 

  463. 			
    464. 

  464. 		if (preg_match('#^[ \t]+(?=\S)#m', $text, $match)) {
    465. 

  465. 			$text = preg_replace('#^' . preg_quote($match[0]) . '#m', '', $text);
    466. 

  466. 		}
    467. 

  467. 		
    468. 

  468. 		preg_match_all('#\{([a-z][a-z0-9_]*)\}#i', $text, $constants, PREG_SET_ORDER);
    469. 

  469. 		foreach ($constants as $constant) {
    470. 

  470. 			if (!defined($constant[1])) { continue; }
    471. 

  471. 			$text = preg_replace('#' . preg_quote($constant[0], '#') . '#', constant($constant[1]), $text, 1);
    472. 

  472. 		}
    473. 

  473. 		
    474. 

  474. 		return $text;
    475. 

  475. 	}
    476. 

  476. 	
    477. 

  477. 	
    478. 

  478. 	/**
    479. 

  479. 	 * The file contents to attach
    480. 

  480. 	 * 
    481. 

  481. 	 * @var array
    482. 

  482. 	 */
    483. 

  483. 	private $attachments = array();
    484. 

  484. 	
    485. 

  485. 	/**
    486. 

  486. 	 * The email address(es) to BCC to
    487. 

  487. 	 * 
    488. 

  488. 	 * @var array
    489. 

  489. 	 */
    490. 

  490. 	private $bcc_emails = array();
    491. 

  491. 	
    492. 

  492. 	/**
    493. 

  493. 	 * The email address to bounce to
    494. 

  494. 	 * 
    495. 

  495. 	 * @var string
    496. 

  496. 	 */
    497. 

  497. 	private $bounce_to_email = NULL;
    498. 

  498. 	
    499. 

  499. 	/**
    500. 

  500. 	 * The email address(es) to CC to
    501. 

  501. 	 * 
    502. 

  502. 	 * @var array
    503. 

  503. 	 */
    504. 

  504. 	private $cc_emails = array();
    505. 

  505. 	
    506. 

  506. 	/**
    507. 

  507. 	 * Custom headers
    508. 

  508. 	 * 
    509. 

  509. 	 * @var array
    510. 

  510. 	 */
    511. 

  511. 	private $custom_headers = array();
    512. 

  512. 	
    513. 

  513. 	/**
    514. 

  514. 	 * The email address being sent from
    515. 

  515. 	 * 
    516. 

  516. 	 * @var string
    517. 

  517. 	 */
    518. 

  518. 	private $from_email = NULL;
    519. 

  519. 	
    520. 

  520. 	/**
    521. 

  521. 	 * The HTML body of the email
    522. 

  522. 	 * 
    523. 

  523. 	 * @var string
    524. 

  524. 	 */
    525. 

  525. 	private $html_body = NULL;
    526. 

  526. 	
    527. 

  527. 	/**
    528. 

  528. 	 * The Message-ID header for the email
    529. 

  529. 	 * 
    530. 

  530. 	 * @var string
    531. 

  531. 	 */
    532. 

  532. 	private $message_id = NULL;
    533. 

  533. 	
    534. 

  534. 	/**
    535. 

  535. 	 * The plaintext body of the email
    536. 

  536. 	 * 
    537. 

  537. 	 * @var string
    538. 

  538. 	 */
    539. 

  539. 	private $plaintext_body = NULL;
    540. 

  540. 	
    541. 

  541. 	/**
    542. 

  542. 	 * The recipient's S/MIME PEM certificate filename, used for encryption of the message
    543. 

  543. 	 * 
    544. 

  544. 	 * @var string
    545. 

  545. 	 */
    546. 

  546. 	private $recipients_smime_cert_file = NULL;
    547. 

  547. 	
    548. 

  548. 	/**
    549. 

  549. 	 * The files to include as multipart/related
    550. 

  550. 	 * 
    551. 

  551. 	 * @var array
    552. 

  552. 	 */
    553. 

  553. 	private $related_files = array();
    554. 

  554. 	
    555. 

  555. 	/**
    556. 

  556. 	 * The email address to reply to
    557. 

  557. 	 * 
    558. 

  558. 	 * @var string
    559. 

  559. 	 */
    560. 

  560. 	private $reply_to_email = NULL;
    561. 

  561. 	
    562. 

  562. 	/**
    563. 

  563. 	 * The email address actually sending the email
    564. 

  564. 	 * 
    565. 

  565. 	 * @var string
    566. 

  566. 	 */
    567. 

  567. 	private $sender_email = NULL;
    568. 

  568. 	
    569. 

  569. 	/**
    570. 

  570. 	 * The senders's S/MIME PEM certificate filename, used for singing the message
    571. 

  571. 	 * 
    572. 

  572. 	 * @var string
    573. 

  573. 	 */
    574. 

  574. 	private $senders_smime_cert_file = NULL;
    575. 

  575. 	
    576. 

  576. 	/**
    577. 

  577. 	 * The senders's S/MIME private key filename, used for singing the message
    578. 

  578. 	 * 
    579. 

  579. 	 * @var string
    580. 

  580. 	 */
    581. 

  581. 	private $senders_smime_pk_file = NULL;
    582. 

  582. 	
    583. 

  583. 	/**
    584. 

  584. 	 * The senders's S/MIME private key password, used for singing the message
    585. 

  585. 	 * 
    586. 

  586. 	 * @var string
    587. 

  587. 	 */
    588. 

  588. 	private $senders_smime_pk_password = NULL;
    589. 

  589. 	
    590. 

  590. 	/**
    591. 

  591. 	 * If the message should be encrypted using the recipient's S/MIME certificate
    592. 

  592. 	 * 
    593. 

  593. 	 * @var boolean
    594. 

  594. 	 */
    595. 

  595. 	private $smime_encrypt = FALSE;
    596. 

  596. 	
    597. 

  597. 	/**
    598. 

  598. 	 * If the message should be signed using the senders's S/MIME private key
    599. 

  599. 	 * 
    600. 

  600. 	 * @var boolean
    601. 

  601. 	 */
    602. 

  602. 	private $smime_sign = FALSE;
    603. 

  603. 	
    604. 

  604. 	/**
    605. 

  605. 	 * The subject of the email
    606. 

  606. 	 * 
    607. 

  607. 	 * @var string
    608. 

  608. 	 */
    609. 

  609. 	private $subject = NULL;
    610. 

  610. 	
    611. 

  611. 	/**
    612. 

  612. 	 * The email address(es) to send to
    613. 

  613. 	 * 
    614. 

  614. 	 * @var array
    615. 

  615. 	 */
    616. 

  616. 	private $to_emails = array();
    617. 

  617. 	
    618. 

  618. 	
    619. 

  619. 	/**
    620. 

  620. 	 * Initializes fEmail for creating message ids
    621. 

  621. 	 * 
    622. 

  622. 	 * @return fEmail
    623. 

  623. 	 */
    624. 

  624. 	public function __construct()
    625. 

  625. 	{
    626. 

  626. 		$this->message_id = '<' . fCryptography::randomString(10, 'hexadecimal') . '.' . time() . '@' . self::getFQDN() . '>';
    627. 

  627. 	}
    628. 

  628. 	
    629. 

  629. 	
    630. 

  630. 	/**
    631. 

  631. 	 * All requests that hit this method should be requests for callbacks
    632. 

  632. 	 * 
    633. 

  633. 	 * @internal
    634. 

  634. 	 * 
    635. 

  635. 	 * @param  string $method  The method to create a callback for
    636. 

  636. 	 * @return callback  The callback for the method requested
    637. 

  637. 	 */
    638. 

  638. 	public function __get($method)
    639. 

  639. 	{
    640. 

  640. 		return array($this, $method);		
    641. 

  641. 	}
    642. 

  642. 	
    643. 

  643. 	
    644. 

  644. 	/**
    645. 

  645. 	 * Adds an attachment to the email
    646. 

  646. 	 * 
    647. 

  647. 	 * If a duplicate filename is detected, it will be changed to be unique.
    648. 

  648. 	 * 
    649. 

  649. 	 * @param  string|fFile $contents   The contents of the file
    650. 

  650. 	 * @param  string       $filename   The name to give the attachement - optional if `$contents` is an fFile object
    651. 

  651. 	 * @param  string       $mime_type  The mime type of the file - this allows overriding the mime type of the file if incorrectly detected
    652. 

  652. 	 * @return fEmail  The email object, to allow for method chaining
    653. 

  653. 	 */
    654. 

  654. 	public function addAttachment($contents, $filename=NULL, $mime_type=NULL)
    655. 

  655. 	{
    656. 

  656. 		$this->extrapolateFileInfo($contents, $filename, $mime_type);
    657. 

  657. 		
    658. 

  658. 		while (isset($this->attachments[$filename])) {
    659. 

  659. 			$filename = $this->generateNewFilename($filename);
    660. 

  660. 		}
    661. 

  661. 		
    662. 

  662. 		$this->attachments[$filename] = array(
    663. 

  663. 			'mime-type' => $mime_type,
    664. 

  664. 			'contents'  => $contents
    665. 

  665. 		);
    666. 

  666. 

  667. 		return $this;
    668. 

  668. 	}
    669. 

  669. 	
    670. 

  670. 	
    671. 

  671. 	/**
    672. 

  672. 	 * Adds a “related” file to the email, returning the `Content-ID` for use in HTML
    673. 

  673. 	 * 
    674. 

  674. 	 * The purpose of a related file is to be able to reference it in part of
    675. 

  675. 	 * the HTML body. Image `src` URLs can reference a related file by starting
    676. 

  676. 	 * the URL with `cid:` and then inserting the `Content-ID`.
    677. 

  677. 	 * 
    678. 

  678. 	 * If a duplicate filename is detected, it will be changed to be unique.
    679. 

  679. 	 * 
    680. 

  680. 	 * @param  string|fFile $contents   The contents of the file
    681. 

  681. 	 * @param  string       $filename   The name to give the attachement - optional if `$contents` is an fFile object
    682. 

  682. 	 * @param  string       $mime_type  The mime type of the file - this allows overriding the mime type of the file if incorrectly detected
    683. 

  683. 	 * @return string  The fully-formed `cid:` URL for use in HTML `src` attributes
    684. 

  684. 	 */
    685. 

  685. 	public function addRelatedFile($contents, $filename=NULL, $mime_type=NULL)
    686. 

  686. 	{
    687. 

  687. 		$this->extrapolateFileInfo($contents, $filename, $mime_type);
    688. 

  688. 		
    689. 

  689. 		while (isset($this->related_files[$filename])) {
    690. 

  690. 			$filename = $this->generateNewFilename($filename);
    691. 

  691. 		}
    692. 

  692. 		
    693. 

  693. 		$cid = count($this->related_files) . '.' . substr($this->message_id, 1, -1);
    694. 

  694. 		
    695. 

  695. 		$this->related_files[$filename] = array(
    696. 

  696. 			'mime-type'  => $mime_type,
    697. 

  697. 			'contents'   => $contents,
    698. 

  698. 			'content-id' => '<' . $cid . '>'
    699. 

  699. 		);
    700. 

  700. 		
    701. 

  701. 		return 'cid:' . $cid;
    702. 

  702. 	}
    703. 

  703. 	
    704. 

  704. 	
    705. 

  705. 	/**
    706. 

  706. 	 * Adds a blind carbon copy (BCC) email recipient
    707. 

  707. 	 * 
    708. 

  708. 	 * @param  string $email  The email address to BCC
    709. 

  709. 	 * @param  string $name   The recipient's name
    710. 

  710. 	 * @return fEmail  The email object, to allow for method chaining
    711. 

  711. 	 */
    712. 

  712. 	public function addBCCRecipient($email, $name=NULL)
    713. 

  713. 	{
    714. 

  714. 		if (!$email) {
    715. 

  715. 			return;
    716. 

  716. 		}
    717. 

  717. 		
    718. 

  718. 		$this->bcc_emails[] = self::combineNameEmail($name, $email);
    719. 

  719. 

  720. 		return $this;
    721. 

  721. 	}
    722. 

  722. 	
    723. 

  723. 	
    724. 

  724. 	/**
    725. 

  725. 	 * Adds a carbon copy (CC) email recipient
    726. 

  726. 	 * 
    727. 

  727. 	 * @param  string $email  The email address to BCC
    728. 

  728. 	 * @param  string $name   The recipient's name
    729. 

  729. 	 * @return fEmail  The email object, to allow for method chaining
    730. 

  730. 	 */
    731. 

  731. 	public function addCCRecipient($email, $name=NULL)
    732. 

  732. 	{
    733. 

  733. 		if (!$email) {
    734. 

  734. 			return;
    735. 

  735. 		}
    736. 

  736. 		
    737. 

  737. 		$this->cc_emails[] = self::combineNameEmail($name, $email);
    738. 

  738. 

  739. 		return $this;
    740. 

  740. 	}
    741. 

  741. 	
    742. 

  742. 	
    743. 

  743. 	/**
    744. 

  744. 	 * Allows adding a custom header to the email
    745. 

  745. 	 * 
    746. 

  746. 	 * If the method is called multiple times with the same name, the last
    747. 

  747. 	 * value will be used.
    748. 

  748. 	 * 
    749. 

  749. 	 * Please note that this class will properly format the header, including
    750. 

  750. 	 * adding the `:` between the name and value and wrapping values that are
    751. 

  751. 	 * too long for a single line.
    752. 

  752. 	 * 
    753. 

  753. 	 * @param  string $name      The name of the header
    754. 

  754. 	 * @param  string $value     The value of the header
    755. 

  755. 	 * @param  array  :$headers  An associative array of `{name} => {value}`
    756. 

  756. 	 * @return fEmail  The email object, to allow for method chaining
    757. 

  757. 	 */
    758. 

  758. 	public function addCustomHeader($name, $value=NULL)
    759. 

  759. 	{
    760. 

  760. 		if ($value === NULL && is_array($name)) {
    761. 

  761. 			foreach ($name as $key => $value) {
    762. 

  762. 				$this->addCustomHeader($key, $value);
    763. 

  763. 			}
    764. 

  764. 			return;	
    765. 

  765. 		}
    766. 

  766. 		
    767. 

  767. 		$lower_name = fUTF8::lower($name);
    768. 

  768. 		$this->custom_headers[$lower_name] = array($name, $value);
    769. 

  769. 

  770. 		return $this;
    771. 

  771. 	}
    772. 

  772. 	
    773. 

  773. 	
    774. 

  774. 	/**
    775. 

  775. 	 * Adds an email recipient
    776. 

  776. 	 * 
    777. 

  777. 	 * @param  string $email  The email address to send to
    778. 

  778. 	 * @param  string $name   The recipient's name
    779. 

  779. 	 * @return fEmail  The email object, to allow for method chaining
    780. 

  780. 	 */
    781. 

  781. 	public function addRecipient($email, $name=NULL)
    782. 

  782. 	{
    783. 

  783. 		if (!$email) {
    784. 

  784. 			return;
    785. 

  785. 		}
    786. 

  786. 		
    787. 

  787. 		$this->to_emails[] = self::combineNameEmail($name, $email);
    788. 

  788. 

  789. 		return $this;
    790. 

  790. 	}
    791. 

  791. 	
    792. 

  792. 	
    793. 

  793. 	/**
    794. 

  794. 	 * Takes a multi-address email header and builds it out using an array of emails
    795. 

  795. 	 * 
    796. 

  796. 	 * @param  string $header  The header name without `': '`, the header is non-blank, `': '` will be added
    797. 

  797. 	 * @param  array  $emails  The email addresses for the header
    798. 

  798. 	 * @return string  The email header with a trailing `\r\n`
    799. 

  799. 	 */
    800. 

  800. 	private function buildMultiAddressHeader($header, $emails)
    801. 

  801. 	{
    802. 

  802. 		$header .= ': ';
    803. 

  803. 		
    804. 

  804. 		$first = TRUE;
    805. 

  805. 		$line  = 1;
    806. 

  806. 		foreach ($emails as $email) {
    807. 

  807. 			if ($first) { $first = FALSE; } else { $header .= ', '; }
    808. 

  808. 			
    809. 

  809. 			// Try to stay within the recommended 78 character line limit
    810. 

  810. 			$last_crlf_pos = (integer) strrpos($header, "\r\n");
    811. 

  811. 			if (strlen($header . $email) - $last_crlf_pos > 78) {
    812. 

  812. 				$header .= "\r\n ";
    813. 

  813. 				$line++;
    814. 

  814. 			}
    815. 

  815. 			
    816. 

  816. 			$header .= trim($email);
    817. 

  817. 		}
    818. 

  818. 		
    819. 

  819. 		return $header . "\r\n";
    820. 

  820. 	}
    821. 

  821. 	
    822. 

  822. 	
    823. 

  823. 	/**
    824. 

  824. 	 * Removes all To, CC and BCC recipients from the email
    825. 

  825. 	 * 
    826. 

  826. 	 * @return fEmail  The email object, to allow for method chaining
    827. 

  827. 	 */
    828. 

  828. 	public function clearRecipients()
    829. 

  829. 	{
    830. 

  830. 		$this->to_emails  = array();
    831. 

  831. 		$this->cc_emails  = array();
    832. 

  832. 		$this->bcc_emails = array();
    833. 

  833. 

  834. 		return $this;
    835. 

  835. 	}
    836. 

  836. 	
    837. 

  837. 	
    838. 

  838. 	/**
    839. 

  839. 	 * Creates a 32-character boundary for a multipart message
    840. 

  840. 	 * 
    841. 

  841. 	 * @return string  A multipart boundary
    842. 

  842. 	 */
    843. 

  843. 	private function createBoundary()
    844. 

  844. 	{
    845. 

  845. 		$chars      = 'ancdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ:-_';
    846. 

  846. 		$last_index = strlen($chars) - 1;
    847. 

  847. 		$output     = '';
    848. 

  848. 		
    849. 

  849. 		for ($i = 0; $i < 28; $i++) {
    850. 

  850. 			$output .= $chars[rand(0, $last_index)];
    851. 

  851. 		}
    852. 

  852. 		return $output;
    853. 

  853. 	}
    854. 

  854. 	
    855. 

  855. 	
    856. 

  856. 	/**
    857. 

  857. 	 * Builds the body of the email
    858. 

  858. 	 * 
    859. 

  859. 	 * @param  string $boundary  The boundary to use for the top level mime block
    860. 

  860. 	 * @return string  The message body to be sent to the mail() function
    861. 

  861. 	 */
    862. 

  862. 	private function createBody($boundary)
    863. 

  863. 	{
    864. 

  864. 		$boundary_stack = array($boundary);
    865. 

  865. 		
    866. 

  866. 		$mime_notice = self::compose(
    867. 

  867. 			"This message has been formatted using MIME. It does not appear that your\r\nemail client supports MIME."
    868. 

  868. 		);
    869. 

  869. 		
    870. 

  870. 		$body = '';
    871. 

  871. 		
    872. 

  872. 		if ($this->html_body || $this->attachments) {
    873. 

  873. 			$body .= $mime_notice . "\r\n\r\n";
    874. 

  874. 		}
    875. 

  875. 		
    876. 

  876. 		if ($this->html_body && $this->related_files && $this->attachments) {
    877. 

  877. 			$body    .= '--' . end($boundary_stack) . "\r\n";
    878. 

  878. 			$boundary_stack[] = $this->createBoundary();
    879. 

  879. 			$body .= 'Content-Type: multipart/related; boundary="' . end($boundary_stack) . "\"\r\n\r\n";
    880. 

  880. 		}
    881. 

  881. 		
    882. 

  882. 		if ($this->html_body && ($this->attachments || $this->related_files)) {
    883. 

  883. 			$body    .= '--' . end($boundary_stack) . "\r\n";
    884. 

  884. 			$boundary_stack[] = $this->createBoundary();
    885. 

  885. 			$body    .= 'Content-Type: multipart/alternative; boundary="' . end($boundary_stack) . "\"\r\n\r\n";
    886. 

  886. 		}
    887. 

  887. 		
    888. 

  888. 		if ($this->html_body || $this->attachments) {
    889. 

  889. 			$body .= '--' . end($boundary_stack) . "\r\n";
    890. 

  890. 			$body .= "Content-Type: text/plain; charset=utf-8\r\n";
    891. 

  891. 			$body .= "Content-Transfer-Encoding: quoted-printable\r\n\r\n";
    892. 

  892. 		}
    893. 

  893. 		
    894. 

  894. 		$body .= $this->makeQuotedPrintable($this->plaintext_body) . "\r\n";
    895. 

  895. 		
    896. 

  896. 		if ($this->html_body) {
    897. 

  897. 			$body .= '--' . end($boundary_stack) . "\r\n";
    898. 

  898. 			$body .= "Content-Type: text/html; charset=utf-8\r\n";
    899. 

  899. 			$body .= "Content-Transfer-Encoding: quoted-printable\r\n\r\n";
    900. 

  900. 			$body .= $this->makeQuotedPrintable($this->html_body) . "\r\n";
    901. 

  901. 		}
    902. 

  902. 		
    903. 

  903. 		if ($this->related_files) {
    904. 

  904. 			$body .= '--' . end($boundary_stack) . "--\r\n";
    905. 

  905. 			array_pop($boundary_stack);
    906. 

  906. 			
    907. 

  907. 			foreach ($this->related_files as $filename => $file_info) {
    908. 

  908. 				$body .= '--' . end($boundary_stack) . "\r\n";
    909. 

  909. 				$body .= 'Content-Type: ' . $file_info['mime-type'] . '; name="' . $filename . "\"\r\n";
    910. 

  910. 				$body .= "Content-Transfer-Encoding: base64\r\n";
    911. 

  911. 				$body .= 'Content-ID: ' . $file_info['content-id'] . "\r\n\r\n";
    912. 

  912. 				$body .= $this->makeBase64($file_info['contents']) . "\r\n";
    913. 

  913. 			}
    914. 

  914. 		}
    915. 

  915. 		
    916. 

  916. 		if ($this->attachments) {
    917. 

  917. 			
    918. 

  918. 			if ($this->html_body) {
    919. 

  919. 				$body .= '--' . end($boundary_stack) . "--\r\n";
    920. 

  920. 				array_pop($boundary_stack);
    921. 

  921. 			}
    922. 

  922. 			
    923. 

  923. 			foreach ($this->attachments as $filename => $file_info) {
    924. 

  924. 				$body .= '--' . end($boundary_stack) . "\r\n";
    925. 

  925. 				$body .= 'Content-Type: ' . $file_info['mime-type'] . "\r\n";
    926. 

  926. 				$body .= "Content-Transfer-Encoding: base64\r\n";
    927. 

  927. 				$body .= 'Content-Disposition: attachment; filename="' . $filename . "\";\r\n\r\n";
    928. 

  928. 				$body .= $this->makeBase64($file_info['contents']) . "\r\n";
    929. 

  929. 			}
    930. 

  930. 		}
    931. 

  931. 		
    932. 

  932. 		if ($this->html_body || $this->attachments) {
    933. 

  933. 			$body .= '--' . end($boundary_stack) . "--\r\n";
    934. 

  934. 			array_pop($boundary_stack);
    935. 

  935. 		}
    936. 

  936. 		
    937. 

  937. 		return $body;
    938. 

  938. 	}
    939. 

  939. 	
    940. 

  940. 	
    941. 

  941. 	/**
    942. 

  942. 	 * Builds the headers for the email
    943. 

  943. 	 * 
    944. 

  944. 	 * @param  string $boundary    The boundary to use for the top level mime block
    945. 

  945. 	 * @param  string $message_id  The message id for the message
    946. 

  946. 	 * @return string  The headers to be sent to the [http://php.net/function.mail mail()] function
    947. 

  947. 	 */
    948. 

  948. 	private function createHeaders($boundary, $message_id)
    949. 

  949. 	{
    950. 

  950. 		$headers = '';
    951. 

  951. 		
    952. 

  952. 		if ($this->cc_emails) {
    953. 

  953. 			$headers .= $this->buildMultiAddressHeader("Cc", $this->cc_emails);
    954. 

  954. 		}
    955. 

  955. 		
    956. 

  956. 		if ($this->bcc_emails) {
    957. 

  957. 			$headers .= $this->buildMultiAddressHeader("Bcc", $this->bcc_emails);
    958. 

  958. 		}
    959. 

  959. 		
    960. 

  960. 		$headers .= "From: " . trim($this->from_email) . "\r\n";
    961. 

  961. 		
    962. 

  962. 		if ($this->reply_to_email) {
    963. 

  963. 			$headers .= "Reply-To: " . trim($this->reply_to_email) . "\r\n";
    964. 

  964. 		}
    965. 

  965. 		
    966. 

  966. 		if ($this->sender_email) {
    967. 

  967. 			$headers .= "Sender: " . trim($this->sender_email) . "\r\n";
    968. 

  968. 		}
    969. 

  969. 		
    970. 

  970. 		foreach ($this->custom_headers as $header_info) {
    971. 

  971. 			$header_prefix = $header_info[0] . ': ';
    972. 

  972. 			$headers .= $header_prefix . self::makeEncodedWord($header_info[1], strlen($header_prefix)) . "\r\n";  
    973. 

  973. 		}
    974. 

  974. 		
    975. 

  975. 		$headers .= "Message-ID: " . $message_id . "\r\n";
    976. 

  976. 		$headers .= "MIME-Version: 1.0\r\n";
    977. 

  977. 		
    978. 

  978. 		if (!$this->html_body && !$this->attachments) {
    979. 

  979. 			$headers .= "Content-Type: text/plain; charset=utf-8\r\n";
    980. 

  980. 			$headers .= "Content-Transfer-Encoding: quoted-printable\r\n";
    981. 

  981. 		
    982. 

  982. 		} elseif ($this->html_body && !$this->attachments) {
    983. 

  983. 			if ($this->related_files) {
    984. 

  984. 				$headers .= 'Content-Type: multipart/related; boundary="' . $boundary . "\"\r\n";
    985. 

  985. 			} else {
    986. 

  986. 				$headers .= 'Content-Type: multipart/alternative; boundary="' . $boundary . "\"\r\n";
    987. 

  987. 			}
    988. 

  988. 		
    989. 

  989. 		} elseif ($this->attachments) {
    990. 

  990. 			$headers .= 'Content-Type: multipart/mixed; boundary="' . $boundary . "\"\r\n";
    991. 

  991. 		}
    992. 

  992. 		
    993. 

  993. 		return $headers . "\r\n";
    994. 

  994. 	}
    995. 

  995. 	
    996. 

  996. 	
    997. 

  997. 	/**
    998. 

  998. 	 * Takes the body of the message and processes it with S/MIME
    999. 

  999. 	 * 
    1000. 

  1000. 	 * @param  string $to       The recipients being sent to
    1001. 

  1001. 	 * @param  string $subject  The subject of the email
    1002. 

  1002. 	 * @param  string $headers  The headers for the message
    1003. 

  1003. 	 * @param  string $body     The message body
    1004. 

  1004. 	 * @return array  `0` => The message headers, `1` => The message body
    1005. 

  1005. 	 */
    1006. 

  1006. 	private function createSMIMEBody($to, $subject, $headers, $body)
    1007. 

  1007. 	{
    1008. 

  1008. 		if (!$this->smime_encrypt && !$this->smime_sign) {
    1009. 

  1009. 			return array($headers, $body);
    1010. 

  1010. 		}
    1011. 

  1011. 		
    1012. 

  1012. 		$plaintext_file  = tempnam('', '__fEmail_');
    1013. 

  1013. 		$ciphertext_file = tempnam('', '__fEmail_');
    1014. 

  1014. 		
    1015. 

  1015. 		$headers_array = array(
    1016. 

  1016. 			'To'      => $to,
    1017. 

  1017. 			'Subject' => $subject
    1018. 

  1018. 		);
    1019. 

  1019. 		
    1020. 

  1020. 		preg_match_all('#^([\w\-]+):\s+([^\n]+\n( [^\n]+\n)*)#im', $headers, $header_matches, PREG_SET_ORDER);
    1021. 

  1021. 		foreach ($header_matches as $header_match) {
    1022. 

  1022. 			$headers_array[$header_match[1]] = trim($header_match[2]);
    1023. 

  1023. 		}
    1024. 

  1024. 		
    1025. 

  1025. 		$body_headers = "";
    1026. 

  1026. 		if (isset($headers_array['Content-Type'])) {
    1027. 

  1027. 			$body_headers .= 'Content-Type: ' . $headers_array['Content-Type'] . "\r\n";
    1028. 

  1028. 		}
    1029. 

  1029. 		if (isset($headers_array['Content-Transfer-Encoding'])) {
    1030. 

  1030. 			$body_headers .= 'Content-Transfer-Encoding: ' . $headers_array['Content-Transfer-Encoding'] . "\r\n";
    1031. 

  1031. 		}
    1032. 

  1032. 		
    1033. 

  1033. 		if ($body_headers) {
    1034. 

  1034. 			$body = $body_headers . "\r\n" . $body;
    1035. 

  1035. 		}
    1036. 

  1036. 		
    1037. 

  1037. 		file_put_contents($plaintext_file, $body);
    1038. 

  1038. 		file_put_contents($ciphertext_file, '');
    1039. 

  1039. 		
    1040. 

  1040. 		// Set up the neccessary S/MIME resources
    1041. 

  1041. 		if ($this->smime_sign) {
    1042. 

  1042. 			$senders_smime_cert  = file_get_contents($this->senders_smime_cert_file);
    1043. 

  1043. 			$senders_private_key = openssl_pkey_get_private(
    1044. 

  1044. 				file_get_contents($this->senders_smime_pk_file),
    1045. 

  1045. 				$this->senders_smime_pk_password
    1046. 

  1046. 			);
    1047. 

  1047. 			
    1048. 

  1048. 			if ($senders_private_key === FALSE) {
    1049. 

  1049. 				throw new fValidationException(
    1050. 

  1050. 					"The sender's S/MIME private key password specified does not appear to be valid for the private key"
    1051. 

  1051. 				);
    1052. 

  1052. 			}
    1053. 

  1053. 		}
    1054. 

  1054. 		
    1055. 

  1055. 		if ($this->smime_encrypt) {
    1056. 

  1056. 			$recipients_smime_cert = file_get_contents($this->recipients_smime_cert_file);
    1057. 

  1057. 		}
    1058. 

  1058. 		
    1059. 

  1059. 		
    1060. 

  1060. 		// If we are going to sign and encrypt, the best way is to sign, encrypt and then sign again
    1061. 

  1061. 		if ($this->smime_encrypt && $this->smime_sign) {
    1062. 

  1062. 			openssl_pkcs7_sign($plaintext_file, $ciphertext_file, $senders_smime_cert, $senders_private_key, array());
    1063. 

  1063. 			openssl_pkcs7_encrypt($ciphertext_file, $plaintext_file, $recipients_smime_cert, array(), NULL, OPENSSL_CIPHER_RC2_128);
    1064. 

  1064. 			openssl_pkcs7_sign($plaintext_file, $ciphertext_file, $senders_smime_cert, $senders_private_key, $headers_array);
    1065. 

  1065. 		
    1066. 

  1066. 		} elseif ($this->smime_sign) {
    1067. 

  1067. 			openssl_pkcs7_sign($plaintext_file, $ciphertext_file, $senders_smime_cert, $senders_private_key, $headers_array);
    1068. 

  1068. 		  
    1069. 

  1069. 		} elseif ($this->smime_encrypt) {
    1070. 

  1070. 			openssl_pkcs7_encrypt($plaintext_file, $ciphertext_file, $recipients_smime_cert, $headers_array, NULL, OPENSSL_CIPHER_RC2_128);
    1071. 

  1071. 		}
    1072. 

  1072. 		
    1073. 

  1073. 		// It seems that the contents of the ciphertext is not always \r\n line breaks
    1074. 

  1074. 		$message = file_get_contents($ciphertext_file);
    1075. 

  1075. 		$message = str_replace("\r\n", "\n", $message);
    1076. 

  1076. 		$message = str_replace("\r", "\n", $message);
    1077. 

  1077. 		$message = str_replace("\n", "\r\n", $message);
    1078. 

  1078. 		
    1079. 

  1079. 		list($new_headers, $new_body) = explode("\r\n\r\n", $message, 2);
    1080. 

  1080. 		
    1081. 

  1081. 		$new_headers = preg_replace('#^To:[^\n]+\n( [^\n]+\n)*#mi', '', $new_headers);
    1082. 

  1082. 		$new_headers = preg_replace('#^Subject:[^\n]+\n( [^\n]+\n)*#mi', '', $new_headers);
    1083. 

  1083. 		$new_headers = preg_replace("#^MIME-Version: 1.0\r?\n#mi", '', $new_headers, 1);
    1084. 

  1084. 		$new_headers = preg_replace('#^Content-Type:\s+' . preg_quote($headers_array['Content-Type'], '#') . "\r?\n#mi", '', $new_headers);
    1085. 

  1085. 		$new_headers = preg_replace('#^Content-Transfer-Encoding:\s+' . preg_quote($headers_array['Content-Transfer-Encoding'], '#') . "\r?\n#mi", '', $new_headers);
    1086. 

  1086. 		
    1087. 

  1087. 		unlink($plaintext_file);
    1088. 

  1088. 		unlink($ciphertext_file);
    1089. 

  1089. 		
    1090. 

  1090. 		if ($this->smime_sign) {
    1091. 

  1091. 			openssl_pkey_free($senders_private_key);
    1092. 

  1092. 		}
    1093. 

  1093. 								  
    1094. 

  1094. 		return array($new_headers, $new_body);
    1095. 

  1095. 	}
    1096. 

  1096. 	
    1097. 

  1097. 	
    1098. 

  1098. 	/**
    1099. 

  1099. 	 * Sets the email to be encrypted with S/MIME
    1100. 

  1100. 	 * 
    1101. 

  1101. 	 * @param  string $recipients_smime_cert_file  The file path to the PEM-encoded S/MIME certificate for the recipient
    1102. 

  1102. 	 * @return fEmail  The email object, to allow for method chaining
    1103. 

  1103. 	 */
    1104. 

  1104. 	public function encrypt($recipients_smime_cert_file)
    1105. 

  1105. 	{
    1106. 

  1106. 		if (!extension_loaded('openssl')) {
    1107. 

  1107. 			throw new fEnvironmentException(
    1108. 

  1108. 				'S/MIME encryption was requested for an email, but the %s extension is not installed',
    1109. 

  1109. 				'openssl'
    1110. 

  1110. 			);
    1111. 

  1111. 		}
    1112. 

  1112. 		
    1113. 

  1113. 		if (!self::stringlike($recipients_smime_cert_file)) {
    1114. 

  1114. 			throw new fProgrammerException(
    1115. 

  1115. 				"The recipient's S/MIME certificate filename specified, %s, does not appear to be a valid filename",
    1116. 

  1116. 				$recipients_smime_cert_file
    1117. 

  1117. 			);
    1118. 

  1118. 		}
    1119. 

  1119. 		
    1120. 

  1120. 		$this->smime_encrypt              = TRUE;
    1121. 

  1121. 		$this->recipients_smime_cert_file = $recipients_smime_cert_file;
    1122. 

  1122. 

  1123. 		return $this;
    1124. 

  1124. 	}
    1125. 

  1125. 	
    1126. 

  1126. 	
    1127. 

  1127. 	/**
    1128. 

  1128. 	 * Extracts just the email addresses from an array of strings containing an
    1129. 

  1129. 	 * <email@address.com> or "Name" <email@address.com> combination.
    1130. 

  1130. 	 * 
    1131. 

  1131. 	 * @param array $list  The list of email or name/email to extract from
    1132. 

  1132. 	 * @return array  The email addresses
    1133. 

  1133. 	 */
    1134. 

  1134. 	private function extractEmails($list)
    1135. 

  1135. 	{
    1136. 

  1136. 		$output = array();
    1137. 

  1137. 		foreach ($list as $email) {
    1138. 

  1138. 			if (preg_match(self::NAME_EMAIL_REGEX, $email, $match)) {
    1139. 

  1139. 				$output[] = $match[2];
    1140. 

  1140. 			} else {
    1141. 

  1141. 				preg_match(self::EMAIL_REGEX, $email, $match);
    1142. 

  1142. 				$output[] = $match[0];
    1143. 

  1143. 			}
    1144. 

  1144. 		}
    1145. 

  1145. 		return $output;
    1146. 

  1146. 	}
    1147. 

  1147. 	
    1148. 

  1148. 	
    1149. 

  1149. 	/**
    1150. 

  1150. 	 * Extracts the filename and mime-type from an fFile object
    1151. 

  1151. 	 * 
    1152. 

  1152. 	 * @param  string|fFile &$contents   The file to extrapolate the info from
    1153. 

  1153. 	 * @param  string       &$filename   The filename to use for the file
    1154. 

  1154. 	 * @param  string       &$mime_type  The mime type of the file
    1155. 

  1155. 	 * @return void
    1156. 

  1156. 	 */
    1157. 

  1157. 	private function extrapolateFileInfo(&$contents, &$filename, &$mime_type)
    1158. 

  1158. 	{
    1159. 

  1159. 		if ($contents instanceof fFile) {
    1160. 

  1160. 			if ($filename === NULL) {
    1161. 

  1161. 				$filename = $contents->getName();
    1162. 

  1162. 			}
    1163. 

  1163. 			if ($mime_type === NULL) {
    1164. 

  1164. 				$mime_type = $contents->getMimeType();
    1165. 

  1165. 			}
    1166. 

  1166. 			$contents = $contents->read();
    1167. 

  1167. 			
    1168. 

  1168. 		} else {
    1169. 

  1169. 			if (!self::stringlike($filename)) {
    1170. 

  1170. 				throw new fProgrammerException(
    1171. 

  1171. 					'The filename specified, %s, does not appear to be a valid filename',
    1172. 

  1172. 					$filename
    1173. 

  1173. 				);
    1174. 

  1174. 			}
    1175. 

  1175. 			
    1176. 

  1176. 			$filename = (string) $filename;
    1177. 

  1177. 			
    1178. 

  1178. 			if ($mime_type === NULL) {
    1179. 

  1179. 				$mime_type = fFile::determineMimeType($filename, $contents);
    1180. 

  1180. 			}
    1181. 

  1181. 		}
    1182. 

  1182. 	}
    1183. 

  1183. 	
    1184. 

  1184. 	
    1185. 

  1185. 	/**
    1186. 

  1186. 	 * Generates a new filename in an attempt to create a unique name
    1187. 

  1187. 	 * 
    1188. 

  1188. 	 * @param  string $filename  The filename to generate another name for
    1189. 

  1189. 	 * @return string  The newly generated filename
    1190. 

  1190. 	 */
    1191. 

  1191. 	private function generateNewFilename($filename)
    1192. 

  1192. 	{
    1193. 

  1193. 		$filename_info = fFilesystem::getPathInfo($filename);
    1194. 

  1194. 		if (preg_match('#_copy(\d+)($|\.)#D', $filename_info['filename'], $match)) {
    1195. 

  1195. 			$i = $match[1] + 1;
    1196. 

  1196. 		} else {
    1197. 

  1197. 			$i = 1;
    1198. 

  1198. 		}
    1199. 

  1199. 		$extension = ($filename_info['extension']) ? '.' . $filename_info['extension'] : '';
    1200. 

  1200. 		return preg_replace('#_copy\d+$#D', '', $filename_info['filename']) . '_copy' . $i . $extension;
    1201. 

  1201. 	}
    1202. 

  1202. 	
    1203. 

  1203. 	
    1204. 

  1204. 	/**
    1205. 

  1205. 	 * Loads the plaintext version of the email body from a file and applies replacements
    1206. 

  1206. 	 * 
    1207. 

  1207. 	 * The should contain either ASCII or UTF-8 encoded text. Please see
    1208. 

  1208. 	 * http://flourishlib.com/docs/UTF-8 for more information.
    1209. 

  1209. 	 * 
    1210. 

  1210. 	 * @throws fValidationException  When no file was specified, the file does not exist or the path specified is not a file
    1211. 

  1211. 	 * 
    1212. 

  1212. 	 * @param  string|fFile $file          The plaintext version of the email body
    1213. 

  1213. 	 * @param  array        $replacements  The method will search the contents of the file for each key and replace it with the corresponding value
    1214. 

  1214. 	 * @return fEmail  The email object, to allow for method chaining
    1215. 

  1215. 	 */
    1216. 

  1216. 	public function loadBody($file, $replacements=array())
    1217. 

  1217. 	{
    1218. 

  1218. 		if (!$file instanceof fFile) {
    1219. 

  1219. 			$file = new fFile($file);	
    1220. 

  1220. 		}
    1221. 

  1221. 		
    1222. 

  1222. 		$plaintext = $file->read();
    1223. 

  1223. 		if ($replacements) {
    1224. 

  1224. 			$plaintext = strtr($plaintext, $replacements);	
    1225. 

  1225. 		}
    1226. 

  1226. 		
    1227. 

  1227. 		$this->plaintext_body = $plaintext;
    1228. 

  1228. 

  1229. 		return $this;
    1230. 

  1230. 	}
    1231. 

  1231. 	
    1232. 

  1232. 	
    1233. 

  1233. 	/**
    1234. 

  1234. 	 * Loads the plaintext version of the email body from a file and applies replacements
    1235. 

  1235. 	 * 
    1236. 

  1236. 	 * The should contain either ASCII or UTF-8 encoded text. Please see
    1237. 

  1237. 	 * http://flourishlib.com/docs/UTF-8 for more information.
    1238. 

  1238. 	 * 
    1239. 

  1239. 	 * @throws fValidationException  When no file was specified, the file does not exist or the path specified is not a file
    1240. 

  1240. 	 * 
    1241. 

  1241. 	 * @param  string|fFile $file          The plaintext version of the email body
    1242. 

  1242. 	 * @param  array        $replacements  The method will search the contents of the file for each key and replace it with the corresponding value
    1243. 

  1243. 	 * @return fEmail  The email object, to allow for method chaining
    1244. 

  1244. 	 */
    1245. 

  1245. 	public function loadHTMLBody($file, $replacements=array())
    1246. 

  1246. 	{
    1247. 

  1247. 		if (!$file instanceof fFile) {
    1248. 

  1248. 			$file = new fFile($file);	
    1249. 

  1249. 		}
    1250. 

  1250. 		
    1251. 

  1251. 		$html = $file->read();
    1252. 

  1252. 		if ($replacements) {
    1253. 

  1253. 			$html = strtr($html, $replacements);	
    1254. 

  1254. 		}
    1255. 

  1255. 		
    1256. 

  1256. 		$this->html_body = $html;
    1257. 

  1257. 

  1258. 		return $this;
    1259. 

  1259. 	}
    1260. 

  1260. 	
    1261. 

  1261. 	
    1262. 

  1262. 	/**
    1263. 

  1263. 	 * Encodes a string to base64
    1264. 

  1264. 	 * 
    1265. 

  1265. 	 * @param  string  $content  The content to encode
    1266. 

  1266. 	 * @return string  The encoded string
    1267. 

  1267. 	 */
    1268. 

  1268. 	private function makeBase64($content)
    1269. 

  1269. 	{
    1270. 

  1270. 		return chunk_split(base64_encode($content));
    1271. 

  1271. 	}
    1272. 

  1272. 	
    1273. 

  1273. 	
    1274. 

  1274. 	/**
    1275. 

  1275. 	 * Encodes a string to quoted-printable, properly handles UTF-8
    1276. 

  1276. 	 * 
    1277. 

  1277. 	 * @param  string  $content  The content to encode
    1278. 

  1278. 	 * @return string  The encoded string
    1279. 

  1279. 	 */
    1280. 

  1280. 	private function makeQuotedPrintable($content)
    1281. 

  1281. 	{
    1282. 

  1282. 		// Homogenize the line-endings to CRLF
    1283. 

  1283. 		$content = str_replace("\r\n", "\n", $content);
    1284. 

  1284. 		$content = str_replace("\r", "\n", $content);
    1285. 

  1285. 		$content = str_replace("\n", "\r\n", $content);
    1286. 

  1286. 		
    1287. 

  1287. 		// A quick a dirty hex encoding
    1288. 

  1288. 		$content = rawurlencode($content);
    1289. 

  1289. 		$content = str_replace('=', '%3D', $content);
    1290. 

  1290. 		$content = str_replace('%', '=', $content);
    1291. 

  1291. 		
    1292. 

  1292. 		// Decode characters that don't have to be coded
    1293. 

  1293. 		$decodings = array(
    1294. 

  1294. 			'=20' => ' ', '=21' => '!', '=22' => '"', '=23' => '#',
    1295. 

  1295. 			'=24' => '$', '=25' => '%', '=26' => '&', '=27' => "'",
    1296. 

  1296. 			'=28' => '(', '=29' => ')', '=2A' => '*', '=2B' => '+',
    1297. 

  1297. 			'=2C' => ',', '=2D' => '-', '=2E' => '.', '=2F' => '/',
    1298. 

  1298. 			'=3A' => ':', '=3B' => ';', '=3C' => '<', '=3E' => '>',
    1299. 

  1299. 			'=3F' => '?', '=40' => '@', '=5B' => '[', '=5C' => '\\',
    1300. 

  1300. 			'=5D' => ']', '=5E' => '^', '=5F' => '_', '=60' => '`',
    1301. 

  1301. 			'=7B' => '{', '=7C' => '|', '=7D' => '}', '=7E' => '~'
    1302. 

  1302. 		);
    1303. 

  1303. 		
    1304. 

  1304. 		$content = strtr($content, $decodings);
    1305. 

  1305. 		
    1306. 

  1306. 		$output = '';
    1307. 

  1307. 		
    1308. 

  1308. 		$length = strlen($content);
    1309. 

  1309. 		
    1310. 

  1310. 		// This loop goes through and ensures we are wrapping by 76 chars
    1311. 

  1311. 		$line_length = 0;
    1312. 

  1312. 		for ($i=0; $i<$length; $i++) {
    1313. 

  1313. 			
    1314. 

  1314. 			// Get info about the next character
    1315. 

  1315. 			$char_length = ($content[$i] == '=') ? 3 : 1;
    1316. 

  1316. 			$char        = $content[$i];
    1317. 

  1317. 			if ($char_length == 3) {
    1318. 

  1318. 				$char .= $content[$i+1] . $content[$i+2];
    1319. 

  1319. 			}
    1320. 

  1320. 			
    1321. 

  1321. 			// Skip characters if we have an encoded character, this must be
    1322. 

  1322. 			// done before checking for whitespace at the beginning and end of
    1323. 

  1323. 			// lines or else characters in the content will be skipped
    1324. 

  1324. 			$i += $char_length-1;
    1325. 

  1325. 			
    1326. 

  1326. 			// Spaces and tabs at the beginning and ending of lines have to be encoded
    1327. 

  1327. 			$begining_or_end = $line_length > 69 || $line_length == 0;
    1328. 

  1328. 			$tab_or_space    = $char == ' ' || $char == "\t";
    1329. 

  1329. 			if ($begining_or_end && $tab_or_space) {
    1330. 

  1330. 				$char_length = 3;
    1331. 

  1331. 				$char        = ($char == ' ') ? '=20' : '=09';
    1332. 

  1332. 			}
    1333. 

  1333. 			
    1334. 

  1334. 			// If we have too long a line, wrap it
    1335. 

  1335. 			if ($char != "\r" && $char != "\n" && $line_length + $char_length > 75) {
    1336. 

  1336. 				$output .= "=\r\n";
    1337. 

  1337. 				$line_length = 0;
    1338. 

  1338. 			}
    1339. 

  1339. 			
    1340. 

  1340. 			// Add the character
    1341. 

  1341. 			$output .= $char;
    1342. 

  1342. 			
    1343. 

  1343. 			// Figure out how much longer the line is now
    1344. 

  1344. 			if ($char == "\r" || $char == "\n") {
    1345. 

  1345. 				$line_length = 0;
    1346. 

  1346. 			} else {
    1347. 

  1347. 				$line_length += $char_length;
    1348. 

  1348. 			}
    1349. 

  1349. 		}
    1350. 

  1350. 		
    1351. 

  1351. 		return $output;
    1352. 

  1352. 	}
    1353. 

  1353. 	
    1354. 

  1354. 	
    1355. 

  1355. 	/**
    1356. 

  1356. 	 * Sends the email
    1357. 

  1357. 	 * 
    1358. 

  1358. 	 * The return value is the message id, which should be included as the
    1359. 

  1359. 	 * `Message-ID` header of the email. While almost all SMTP servers will not
    1360. 

  1360. 	 * modify this value, testing has indicated at least one (smtp.live.com
    1361. 

  1361. 	 * for Windows Live Mail) does.
    1362. 

  1362. 	 * 
    1363. 

  1363. 	 * @throws fValidationException  When ::validate() throws an exception
    1364. 

  1364. 	 * 
    1365. 

  1365. 	 * @param  fSMTP $connection  The SMTP connection to send the message over
    1366. 

  1366. 	 * @return string  The message id for the message - see method description for details
    1367. 

  1367. 	 */
    1368. 

  1368. 	public function send($connection=NULL)
    1369. 

  1369. 	{
    1370. 

  1370. 		$this->validate();
    1371. 

  1371. 		
    1372. 

  1372. 		// The mail() function on Windows doesn't support names in headers so
    1373. 

  1373. 		// we must strip them down to just the email address
    1374. 

  1374. 		if ($connection === NULL && fCore::checkOS('windows')) {
    1375. 

  1375. 			$vars = array('bcc_emails', 'bounce_to_email', 'cc_emails', 'from_email', 'reply_to_email', 'sender_email', 'to_emails');
    1376. 

  1376. 			foreach ($vars as $var) {
    1377. 

  1377. 				if (!is_array($this->$var)) {
    1378. 

  1378. 					if (preg_match(self::NAME_EMAIL_REGEX, $this->$var, $match)) {
    1379. 

  1379. 						$this->$var = $match[2];
    1380. 

  1380. 					}
    1381. 

  1381. 				} else {
    1382. 

  1382. 					$new_emails = array();
    1383. 

  1383. 					foreach ($this->$var as $email) {
    1384. 

  1384. 						if (preg_match(self::NAME_EMAIL_REGEX, $email, $match)) {
    1385. 

  1385. 							$email = $match[2];
    1386. 

  1386. 						}
    1387. 

  1387. 						$new_emails[] = $email;
    1388. 

  1388. 					}
    1389. 

  1389. 					$this->$var = $new_emails;
    1390. 

  1390. 				}
    1391. 

  1391. 			}
    1392. 

  1392. 		}
    1393. 

  1393. 		
    1394. 

  1394. 		$to = substr(trim($this->buildMultiAddressHeader("To", $this->to_emails)), 4);
    1395. 

  1395. 		
    1396. 

  1396. 		$top_level_boundary = $this->createBoundary();
    1397. 

  1397. 		$headers            = $this->createHeaders($top_level_boundary, $this->message_id);
    1398. 

  1398. 		
    1399. 

  1399. 		$subject = str_replace(array("\r", "\n"), '', $this->subject);
    1400. 

  1400. 		$subject = self::makeEncodedWord($subject, 9);
    1401. 

  1401. 		
    1402. 

  1402. 		$body = $this->createBody($top_level_boundary);
    1403. 

  1403. 		
    1404. 

  1404. 		if ($this->smime_encrypt || $this->smime_sign) {
    1405. 

  1405. 			list($headers, $body) = $this->createSMIMEBody($to, $subject, $headers, $body);
    1406. 

  1406. 		}
    1407. 

  1407. 		
    1408. 

  1408. 		// Remove extra line breaks
    1409. 

  1409. 		$headers = trim($headers);
    1410. 

  1410. 		$body    = trim($body);
    1411. 

  1411. 		
    1412. 

  1412. 		if ($connection) {
    1413. 

  1413. 			$to_emails = $this->extractEmails($this->to_emails);
    1414. 

  1414. 			$to_emails = array_merge($to_emails, $this->extractEmails($this->cc_emails));
    1415. 

  1415. 			$to_emails = array_merge($to_emails, $this->extractEmails($this->bcc_emails));
    1416. 

  1416. 			$from = $this->bounce_to_email ? $this->bounce_to_email : current($this->extractEmails(array($this->from_email)));
    1417. 

  1417. 			$connection->send($from, $to_emails, "To: " . $to . "\r\nSubject: " . $subject . "\r\n" . $headers, $body);
    1418. 

  1418. 			return $this->message_id;
    1419. 

  1419. 		}
    1420. 

  1420. 		
    1421. 

  1421. 		// Sendmail when not in safe mode will allow you to set the envelope from address via the -f parameter
    1422. 

  1422. 		$parameters = NULL;
    1423. 

  1423. 		if (!fCore::checkOS('windows') && $this->bounce_to_email) {
    1424. 

  1424. 			preg_match(self::EMAIL_REGEX, $this->bounce_to_email, $matches);
    1425. 

  1425. 			$parameters = '-f ' . $matches[0];
    1426. 

  1426. 		
    1427. 

  1427. 		// Windows takes the Return-Path email from the sendmail_from ini setting
    1428. 

  1428. 		} elseif (fCore::checkOS('windows') && $this->bounce_to_email) {
    1429. 

  1429. 			$old_sendmail_from = ini_get('sendmail_from');
    1430. 

  1430. 			preg_match(self::EMAIL_REGEX, $this->bounce_to_email, $matches);
    1431. 

  1431. 			ini_set('sendmail_from', $matches[0]);
    1432. 

  1432. 		}
    1433. 

  1433. 		
    1434. 

  1434. 		// This is a gross qmail fix that is a last resort
    1435. 

  1435. 		if (self::$popen_sendmail || self::$convert_crlf) {
    1436. 

  1436. 			$to      = str_replace("\r\n", "\n", $to);
    1437. 

  1437. 			$subject = str_replace("\r\n", "\n", $subject);
    1438. 

  1438. 			$body    = str_replace("\r\n", "\n", $body);
    1439. 

  1439. 			$headers = str_replace("\r\n", "\n", $headers);
    1440. 

  1440. 		}
    1441. 

  1441. 		
    1442. 

  1442. 		// If the user is using qmail and wants to try to fix the \r\r\n line break issue
    1443. 

  1443. 		if (self::$popen_sendmail) {
    1444. 

  1444. 			$sendmail_command = ini_get('sendmail_path');
    1445. 

  1445. 			if ($parameters) {
    1446. 

  1446. 				$sendmail_command .= ' ' . $parameters;
    1447. 

  1447. 			}
    1448. 

  1448. 			
    1449. 

  1449. 			$sendmail_process = popen($sendmail_command, 'w');
    1450. 

  1450. 			fprintf($sendmail_process, "To: %s\n", $to);
    1451. 

  1451. 			fprintf($sendmail_process, "Subject: %s\n", $subject);
    1452. 

  1452. 			if ($headers) {
    1453. 

  1453. 				fprintf($sendmail_process, "%s\n", $headers);
    1454. 

  1454. 			}
    1455. 

  1455. 			fprintf($sendmail_process, "\n%s\n", $body);
    1456. 

  1456. 			$error = pclose($sendmail_process);
    1457. 

  1457. 			
    1458. 

  1458. 		// This is the normal way to send mail
    1459. 

  1459. 		} else {
    1460. 

  1460. 			// On Windows, mail() sends directly to an SMTP server and will
    1461. 

  1461. 			// strip a leading . from the body
    1462. 

  1462. 			if (fCore::checkOS('windows')) {
    1463. 

  1463. 				$body = preg_replace('#^\.#', '..', $body);
    1464. 

  1464. 			}
    1465. 

  1465. 			
    1466. 

  1466. 			if ($parameters) {
    1467. 

  1467. 				$error = !mail($to, $subject, $body, $headers, $parameters);
    1468. 

  1468. 			} else {
    1469. 

  1469. 				$error = !mail($to, $subject, $body, $headers);
    1470. 

  1470. 			}
    1471. 

  1471. 		}
    1472. 

  1472. 		
    1473. 

  1473. 		if (fCore::checkOS('windows') && $this->bounce_to_email) {
    1474. 

  1474. 			ini_set('sendmail_from', $old_sendmail_from);
    1475. 

  1475. 		}
    1476. 

  1476. 		
    1477. 

  1477. 		if ($error) {
    1478. 

  1478. 			throw new fConnectivityException(
    1479. 

  1479. 				'An error occured while trying to send the email entitled %s',
    1480. 

  1480. 				$this->subject
    1481. 

  1481. 			);
    1482. 

  1482. 		}
    1483. 

  1483. 		
    1484. 

  1484. 		return $this->message_id;
    1485. 

  1485. 	}
    1486. 

  1486. 	
    1487. 

  1487. 	
    1488. 

  1488. 	/**
    1489. 

  1489. 	 * Sets the plaintext version of the email body
    1490. 

  1490. 	 * 
    1491. 

  1491. 	 * This method accepts either ASCII or UTF-8 encoded text. Please see
    1492. 

  1492. 	 * http://flourishlib.com/docs/UTF-8 for more information.
    1493. 

  1493. 	 * 
    1494. 

  1494. 	 * @param  string  $plaintext                  The plaintext version of the email body
    1495. 

  1495. 	 * @param  boolean $unindent_expand_constants  If this is `TRUE`, the body will be unindented as much as possible and {CONSTANT_NAME} will be replaced with the value of the constant
    1496. 

  1496. 	 * @return fEmail  The email object, to allow for method chaining
    1497. 

  1497. 	 */
    1498. 

  1498. 	public function setBody($plaintext, $unindent_expand_constants=FALSE)
    1499. 

  1499. 	{
    1500. 

  1500. 		if ($unindent_expand_constants) {
    1501. 

  1501. 			$plaintext = self::unindentExpand($plaintext);
    1502. 

  1502. 		}
    1503. 

  1503. 		
    1504. 

  1504. 		$this->plaintext_body = $plaintext;
    1505. 

  1505. 

  1506. 		return $this;
    1507. 

  1507. 	}
    1508. 

  1508. 	
    1509. 

  1509. 	
    1510. 

  1510. 	/**
    1511. 

  1511. 	 * Adds the email address the email will be bounced to
    1512. 

  1512. 	 * 
    1513. 

  1513. 	 * This email address will be set to the `Return-Path` header.
    1514. 

  1514. 	 * 
    1515. 

  1515. 	 * @param  string $email  The email address to bounce to
    1516. 

  1516. 	 * @return fEmail  The email object, to allow for method chaining
    1517. 

  1517. 	 */
    1518. 

  1518. 	public function setBounceToEmail($email)
    1519. 

  1519. 	{
    1520. 

  1520. 		if (ini_get('safe_mode') && !fCore::checkOS('windows')) {
    1521. 

  1521. 			throw new fProgrammerException('It is not possible to set a Bounce-To Email address when safe mode is enabled on a non-Windows server');
    1522. 

  1522. 		}
    1523. 

  1523. 		if (!$email) {
    1524. 

  1524. 			return;
    1525. 

  1525. 		}
    1526. 

  1526. 		
    1527. 

  1527. 		$this->bounce_to_email = self::combineNameEmail('', $email);
    1528. 

  1528. 

  1529. 		return $this;
    1530. 

  1530. 	}
    1531. 

  1531. 	
    1532. 

  1532. 	
    1533. 

  1533. 	/**
    1534. 

  1534. 	 * Adds the `From:` email address to the email
    1535. 

  1535. 	 * 
    1536. 

  1536. 	 * @param  string $email  The email address being sent from
    1537. 

  1537. 	 * @param  string $name   The from email user's name - unfortunately on windows this is ignored
    1538. 

  1538. 	 * @return fEmail  The email object, to allow for method chaining
    1539. 

  1539. 	 */
    1540. 

  1540. 	public function setFromEmail($email, $name=NULL)
    1541. 

  1541. 	{
    1542. 

  1542. 		if (!$email) {
    1543. 

  1543. 			return;
    1544. 

  1544. 		}
    1545. 

  1545. 		
    1546. 

  1546. 		$…
    1547.

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