PageRenderTime 55ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 1ms

/helpers/fMailbox/fMailbox.php

https://github.com/Creatiwity/wityCMS
PHP | 1525 lines | 929 code | 202 blank | 394 comment | 262 complexity | 2d4b8358cbd7c8dae8f5eafdde5a0aac MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.1, MPL-2.0-no-copyleft-exception 
    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * Retrieves and deletes messages from a email account via IMAP or POP3
    4. 

  4.  *
    5. 

  5.  * All headers, text and html content returned by this class are encoded in
    6. 

  6.  * UTF-8. Please see http://flourishlib.com/docs/UTF-8 for more information.
    7. 

  7.  *
    8. 

  8.  * @copyright  Copyright (c) 2010-2012 Will Bond
    9. 

  9.  * @author     Will Bond [wb] <will@flourishlib.com>
    10. 

  10.  * @license    http://flourishlib.com/license
    11. 

  11.  *
    12. 

  12.  * @package    Flourish
    13. 

  13.  * @link       http://flourishlib.com/fMailbox
    14. 

  14.  *
    15. 

  15.  * @version    1.0.0b18
    16. 

  16.  * @changes    1.0.0b18  Fixed a bug in ::fetchMessageSource() where IMAP connections would add an extra `\r\n` to the end of the source [wb, 2012-09-16]
    17. 

  17.  * @changes    1.0.0b17  Updated the class to be more forgiving when parsing the response for `STATUS` and `FETCH` IMAP commands [wb, 2012-09-15]
    18. 

  18.  * @changes    1.0.0b16  Added method ::fetchMessageSource() [wb, 2012-09-15]
    19. 

  19.  * @changes    1.0.0b15  Fixed handling of bounces with no headers [wb, 2012-09-15]
    20. 

  20.  * @changes    1.0.0b14  Added a workaround for iconv having issues in MAMP 1.9.4+ [wb, 2011-07-26]
    21. 

  21.  * @changes    1.0.0b13  Fixed handling of headers in relation to encoded-words being embedded inside of quoted strings [wb, 2011-07-26]
    22. 

  22.  * @changes    1.0.0b12  Enhanced the error checking in ::write() [wb, 2011-06-03]
    23. 

  23.  * @changes    1.0.0b11  Added code to work around PHP bug #42682 (http://bugs.php.net/bug.php?id=42682) where `stream_select()` doesn't work on 64bit machines from PHP 5.2.0 to 5.2.5, improved connectivity error handling and timeouts while reading data [wb, 2011-01-10]
    24. 

  24.  * @changes    1.0.0b10  Fixed ::parseMessage() to properly handle a header format edge case and properly set the `text` and `html` keys even when the email has an explicit `Content-disposition: inline` header [wb, 2010-11-25]
    25. 

  25.  * @changes    1.0.0b9   Fixed a bug in ::parseMessage() that could cause HTML alternate content to be included in the `inline` content array instead of the `html` element [wb, 2010-09-20]
    26. 

  26.  * @changes    1.0.0b8   Fixed ::parseMessage() to be able to handle non-text/non-html multipart parts that do not have a `Content-disposition` header [wb, 2010-09-18]
    27. 

  27.  * @changes    1.0.0b7   Fixed a typo in ::read() [wb, 2010-09-07]
    28. 

  28.  * @changes    1.0.0b6   Fixed a typo from 1.0.0b4 [wb, 2010-07-21]
    29. 

  29.  * @changes    1.0.0b5   Fixes for increased compatibility with various IMAP and POP3 servers, hacked around a bug in PHP 5.3 on Windows [wb, 2010-06-22]
    30. 

  30.  * @changes    1.0.0b4   Added code to handle emails without an explicit `Content-type` header [wb, 2010-06-04]
    31. 

  31.  * @changes    1.0.0b3   Added missing static method callback constants [wb, 2010-05-11]
    32. 

  32.  * @changes    1.0.0b2   Added the missing ::enableDebugging() [wb, 2010-05-05]
    33. 

  33.  * @changes    1.0.0b    The initial implementation [wb, 2010-05-05]
    34. 

  34.  */
    35. 

  35. class fMailbox
    36. 

  36. {
    37. 

  37. 	const addSMIMEPair = 'fMailbox::addSMIMEPair';
    38. 

  38. 	const parseMessage = 'fMailbox::parseMessage';
    39. 

  39. 	const reset        = 'fMailbox::reset';
    40. 

  40. 

  41. 

  42. 	/**
    43. 

  43. 	 * S/MIME certificates and private keys for verification and decryption
    44. 

  44. 	 *
    45. 

  45. 	 * @var array
    46. 

  46. 	 */
    47. 

  47. 	static private $smime_pairs = array();
    48. 

  48. 

  49. 

  50. 	/**
    51. 

  51. 	 * Adds an S/MIME certificate, or certificate + private key pair for verification and decryption of S/MIME messages
    52. 

  52. 	 *
    53. 

  53. 	 * @param string       $email_address         The email address the certificate or private key is for
    54. 

  54. 	 * @param fFile|string $certificate_file      The file the S/MIME certificate is stored in - required for verification and decryption
    55. 

  55. 	 * @param fFile        $private_key_file      The file the S/MIME private key is stored in - required for decryption only
    56. 

  56. 	 * @param string       $private_key_password  The password for the private key
    57. 

  57. 	 * @return void
    58. 

  58. 	 */
    59. 

  59. 	static public function addSMIMEPair($email_address, $certificate_file, $private_key_file=NULL, $private_key_password=NULL)
    60. 

  60. 	{
    61. 

  61. 		if ($private_key_file !== NULL && !$private_key_file instanceof fFile) {
    62. 

  62. 			$private_key_file = new fFile($private_key_file);
    63. 

  63. 		}
    64. 

  64. 		if (!$certificate_file instanceof fFile) {
    65. 

  65. 			$certificate_file = new fFile($certificate_file);
    66. 

  66. 		}
    67. 

  67. 		self::$smime_pairs[strtolower($email_address)] = array(
    68. 

  68. 			'certificate' => $certificate_file,
    69. 

  69. 			'private_key' => $private_key_file,
    70. 

  70. 			'password'    => $private_key_password
    71. 

  71. 		);
    72. 

  72. 	}
    73. 

  73. 

  74. 

  75. 	/**
    76. 

  76. 	 * Takes a date, removes comments and cleans up some common formatting inconsistencies
    77. 

  77. 	 *
    78. 

  78. 	 * @param string $date  The date to clean
    79. 

  79. 	 * @return string  The cleaned date
    80. 

  80. 	 */
    81. 

  81. 	static private function cleanDate($date)
    82. 

  82. 	{
    83. 

  83. 		$date = preg_replace('#\([^)]+\)#', ' ', trim($date));
    84. 

  84. 		$date = preg_replace('#\s+#', ' ', $date);
    85. 

  85. 		$date = preg_replace('#(\d+)-([a-z]+)-(\d{4})#i', '\1 \2 \3', $date);
    86. 

  86. 		$date = preg_replace('#^[a-z]+\s*,\s*#i', '', trim($date));
    87. 

  87. 		return trim($date);
    88. 

  88. 	}
    89. 

  89. 

  90. 

  91. 	/**
    92. 

  92. 	 * Decodes encoded-word headers of any encoding into raw UTF-8
    93. 

  93. 	 *
    94. 

  94. 	 * @param string $text  The header value to decode
    95. 

  95. 	 * @return string  The decoded UTF-8
    96. 

  96. 	 */
    97. 

  97. 	static private function decodeHeader($text)
    98. 

  98. 	{
    99. 

  99. 		$parts = preg_split('#(=\?[^\?]+\?[QB]\?[^\?]+\?=)#i', $text, -1, PREG_SPLIT_DELIM_CAPTURE);
    100. 

  100. 

  101. 		$part_with_encoding = array();
    102. 

  102. 		$output = '';
    103. 

  103. 		foreach ($parts as $part) {
    104. 

  104. 			if ($part === '') {
    105. 

  105. 				continue;
    106. 

  106. 			}
    107. 

  107. 

  108. 			if (preg_match_all('#=\?([^\?]+)\?([QB])\?([^\?]+)\?=#i', $part, $matches, PREG_SET_ORDER)) {
    109. 

  109. 				foreach ($matches as $match) {
    110. 

  110. 					if (strtoupper($match[2]) == 'Q') {
    111. 

  111. 						$part_string = rawurldecode(strtr(
    112. 

  112. 							$match[3],
    113. 

  113. 							array(
    114. 

  114. 								'=' => '%',
    115. 

  115. 								'_' => ' '
    116. 

  116. 							)
    117. 

  117. 						));
    118. 

  118. 					} else {
    119. 

  119. 						$part_string = base64_decode($match[3]);
    120. 

  120. 					}
    121. 

  121. 					$lower_encoding = strtolower($match[1]);
    122. 

  122. 					$last_key = count($part_with_encoding) - 1;
    123. 

  123. 					if (isset($part_with_encoding[$last_key]) && $part_with_encoding[$last_key]['encoding'] == $lower_encoding) {
    124. 

  124. 						$part_with_encoding[$last_key]['string'] .= $part_string;
    125. 

  125. 					} else {
    126. 

  126. 						$part_with_encoding[] = array('encoding' => $lower_encoding, 'string' => $part_string);
    127. 

  127. 					}
    128. 

  128. 				}
    129. 

  129. 

  130. 			} else {
    131. 

  131. 				$last_key = count($part_with_encoding) - 1;
    132. 

  132. 				if (isset($part_with_encoding[$last_key]) && $part_with_encoding[$last_key]['encoding'] == 'iso-8859-1') {
    133. 

  133. 					$part_with_encoding[$last_key]['string'] .= $part;
    134. 

  134. 				} else {
    135. 

  135. 					$part_with_encoding[] = array('encoding' => 'iso-8859-1', 'string' => $part);
    136. 

  136. 				}
    137. 

  137. 			}
    138. 

  138. 		}
    139. 

  139. 

  140. 		foreach ($part_with_encoding as $part) {
    141. 

  141. 			$output .= self::iconv($part['encoding'], 'UTF-8', $part['string']);
    142. 

  142. 		}
    143. 

  143. 

  144. 		return $output;
    145. 

  145. 	}
    146. 

  146. 

  147. 

  148. 	/**
    149. 

  149. 	 * Handles an individual part of a multipart message
    150. 

  150. 	 *
    151. 

  151. 	 * @param array  $info       An array of information about the message
    152. 

  152. 	 * @param array  $structure  An array describing the structure of the message
    153. 

  153. 	 * @return array  The modified $info array
    154. 

  154. 	 */
    155. 

  155. 	static private function handlePart($info, $structure)
    156. 

  156. 	{
    157. 

  157. 		if ($structure['type'] == 'multipart') {
    158. 

  158. 			foreach ($structure['parts'] as $part) {
    159. 

  159. 				$info = self::handlePart($info, $part);
    160. 

  160. 			}
    161. 

  161. 			return $info;
    162. 

  162. 		}
    163. 

  163. 

  164. 		if ($structure['type'] == 'application' && in_array($structure['subtype'], array('pkcs7-mime', 'x-pkcs7-mime'))) {
    165. 

  165. 			$to = NULL;
    166. 

  166. 			if (isset($info['headers']['to'][0])) {
    167. 

  167. 				$to = $info['headers']['to'][0]['mailbox'];
    168. 

  168. 				if (!empty($info['headers']['to'][0]['host'])) {
    169. 

  169. 					$to .= '@' . $info['headers']['to'][0]['host'];
    170. 

  170. 				}
    171. 

  171. 			}
    172. 

  172. 			if ($to && !empty(self::$smime_pairs[$to]['private_key'])) {
    173. 

  173. 				if (self::handleSMIMEDecryption($info, $structure, self::$smime_pairs[$to])) {
    174. 

  174. 					return $info;
    175. 

  175. 				}
    176. 

  176. 			}
    177. 

  177. 		}
    178. 

  178. 

  179. 		if ($structure['type'] == 'application' && in_array($structure['subtype'], array('pkcs7-signature', 'x-pkcs7-signature'))) {
    180. 

  180. 			$from = NULL;
    181. 

  181. 			if (isset($info['headers']['from'])) {
    182. 

  182. 				$from = $info['headers']['from']['mailbox'];
    183. 

  183. 				if (!empty($info['headers']['from']['host'])) {
    184. 

  184. 					$from .= '@' . $info['headers']['from']['host'];
    185. 

  185. 				}
    186. 

  186. 			}
    187. 

  187. 			if ($from && !empty(self::$smime_pairs[$from]['certificate'])) {
    188. 

  188. 				if (self::handleSMIMEVerification($info, $structure, self::$smime_pairs[$from])) {
    189. 

  189. 					return $info;
    190. 

  190. 				}
    191. 

  191. 			}
    192. 

  192. 		}
    193. 

  193. 

  194. 		$data = $structure['data'];
    195. 

  195. 

  196. 		if ($structure['encoding'] == 'base64') {
    197. 

  197. 			$content = '';
    198. 

  198. 			foreach (explode("\r\n", $data) as $line) {
    199. 

  199. 				$content .= base64_decode($line);
    200. 

  200. 			}
    201. 

  201. 		} elseif ($structure['encoding'] == 'quoted-printable') {
    202. 

  202. 			$content = quoted_printable_decode($data);
    203. 

  203. 		} else {
    204. 

  204. 			$content = $data;
    205. 

  205. 		}
    206. 

  206. 

  207. 		if ($structure['type'] == 'text') {
    208. 

  208. 			$charset = 'iso-8859-1';
    209. 

  209. 			foreach ($structure['type_fields'] as $field => $value) {
    210. 

  210. 				if (strtolower($field) == 'charset') {
    211. 

  211. 					$charset = $value;
    212. 

  212. 					break;
    213. 

  213. 				}
    214. 

  214. 			}
    215. 

  215. 			$content = self::iconv($charset, 'UTF-8', $content);
    216. 

  216. 			if ($structure['subtype'] == 'html') {
    217. 

  217. 				$content = preg_replace('#(content=(["\'])text/html\s*;\s*charset=(["\']?))' . preg_quote($charset, '#') . '(\3\2)#i', '\1utf-8\4', $content);
    218. 

  218. 			}
    219. 

  219. 		}
    220. 

  220. 

  221. 		// This indicates a content-id which is used for multipart/related
    222. 

  222. 		if ($structure['content_id']) {
    223. 

  223. 			if (!isset($info['related'])) {
    224. 

  224. 				$info['related'] = array();
    225. 

  225. 			}
    226. 

  226. 			$cid = $structure['content_id'][0] == '<' ? substr($structure['content_id'], 1, -1) : $structure['content_id'];
    227. 

  227. 			$info['related']['cid:' . $cid] = array(
    228. 

  228. 				'mimetype' => $structure['type'] . '/' . $structure['subtype'],
    229. 

  229. 				'data'     => $content
    230. 

  230. 			);
    231. 

  231. 			return $info;
    232. 

  232. 		}
    233. 

  233. 

  234. 

  235. 		$has_disposition = !empty($structure['disposition']);
    236. 

  236. 		$is_text         = $structure['type'] == 'text' && $structure['subtype'] == 'plain';
    237. 

  237. 		$is_html         = $structure['type'] == 'text' && $structure['subtype'] == 'html';
    238. 

  238. 

  239. 		// If the part doesn't have a disposition and is not the default text or html, set the disposition to inline
    240. 

  240. 		if (!$has_disposition && ((!$is_text || !empty($info['text'])) && (!$is_html || !empty($info['html'])))) {
    241. 

  241. 			$is_web_image = $structure['type'] == 'image' && in_array($structure['subtype'], array('gif', 'png', 'jpeg', 'pjpeg'));
    242. 

  242. 			$structure['disposition'] = $is_text || $is_html || $is_web_image ? 'inline' : 'attachment';
    243. 

  243. 			$structure['disposition_fields'] = array();
    244. 

  244. 			$has_disposition = TRUE;
    245. 

  245. 		}
    246. 

  246. 

  247. 

  248. 		// Attachments or inline content
    249. 

  249. 		if ($has_disposition) {
    250. 

  250. 

  251. 			$filename = '';
    252. 

  252. 			foreach ($structure['disposition_fields'] as $field => $value) {
    253. 

  253. 				if (strtolower($field) == 'filename') {
    254. 

  254. 					$filename = $value;
    255. 

  255. 					break;
    256. 

  256. 				}
    257. 

  257. 			}
    258. 

  258. 			foreach ($structure['type_fields'] as $field => $value) {
    259. 

  259. 				if (strtolower($field) == 'name') {
    260. 

  260. 					$filename = $value;
    261. 

  261. 					break;
    262. 

  262. 				}
    263. 

  263. 			}
    264. 

  264. 

  265. 			// This automatically handles primary content that has a content-disposition header on it
    266. 

  266. 			if ($structure['disposition'] == 'inline' && $filename === '') {
    267. 

  267. 				if ($is_text && !isset($info['text'])) {
    268. 

  268. 					$info['text'] = $content;
    269. 

  269. 					return $info;
    270. 

  270. 				}
    271. 

  271. 				if ($is_html && !isset($info['html'])) {
    272. 

  272. 					$info['html'] = $content;
    273. 

  273. 					return $info;
    274. 

  274. 				}
    275. 

  275. 			}
    276. 

  276. 

  277. 			if (!isset($info[$structure['disposition']])) {
    278. 

  278. 				$info[$structure['disposition']] = array();
    279. 

  279. 			}
    280. 

  280. 

  281. 			$info[$structure['disposition']][] = array(
    282. 

  282. 				'filename' => $filename,
    283. 

  283. 				'mimetype' => $structure['type'] . '/' . $structure['subtype'],
    284. 

  284. 				'data'     => $content
    285. 

  285. 			);
    286. 

  286. 			return $info;
    287. 

  287. 		}
    288. 

  288. 

  289. 		if ($is_text) {
    290. 

  290. 			$info['text'] = $content;
    291. 

  291. 			return $info;
    292. 

  292. 		}
    293. 

  293. 

  294. 		if ($is_html) {
    295. 

  295. 			$info['html'] = $content;
    296. 

  296. 			return $info;
    297. 

  297. 		}
    298. 

  298. 	}
    299. 

  299. 

  300. 

  301. 	/**
    302. 

  302. 	 * Tries to decrypt an S/MIME message using a private key
    303. 

  303. 	 *
    304. 

  304. 	 * @param array  &$info       The array of information about a message
    305. 

  305. 	 * @param array  $structure   The structure of this part
    306. 

  306. 	 * @param array  $smime_pair  An associative array containing an S/MIME certificate, private key and password
    307. 

  307. 	 * @return boolean  If the message was decrypted
    308. 

  308. 	 */
    309. 

  309. 	static private function handleSMIMEDecryption(&$info, $structure, $smime_pair)
    310. 

  310. 	{
    311. 

  311. 		$plaintext_file  = tempnam('', '__fMailbox_');
    312. 

  312. 		$ciphertext_file = tempnam('', '__fMailbox_');
    313. 

  313. 

  314. 		$headers   = array();
    315. 

  315. 		$headers[] = "Content-Type: " . $structure['type'] . '/' . $structure['subtype'];
    316. 

  316. 		$headers[] = "Content-Transfer-Encoding: " . $structure['encoding'];
    317. 

  317. 		$header    = "Content-Disposition: " . $structure['disposition'];
    318. 

  318. 		foreach ($structure['disposition_fields'] as $field => $value) {
    319. 

  319. 			$header .= '; ' . $field . '="' . $value . '"';
    320. 

  320. 		}
    321. 

  321. 		$headers[] = $header;
    322. 

  322. 

  323. 		file_put_contents($ciphertext_file, join("\r\n", $headers) . "\r\n\r\n" . $structure['data']);
    324. 

  324. 

  325. 		$private_key = openssl_pkey_get_private(
    326. 

  326. 			$smime_pair['private_key']->read(),
    327. 

  327. 			$smime_pair['password']
    328. 

  328. 		);
    329. 

  329. 		$certificate = $smime_pair['certificate']->read();
    330. 

  330. 

  331. 		$result = openssl_pkcs7_decrypt($ciphertext_file, $plaintext_file, $certificate, $private_key);
    332. 

  332. 		unlink($ciphertext_file);
    333. 

  333. 

  334. 		if (!$result) {
    335. 

  335. 			unlink($plaintext_file);
    336. 

  336. 			return FALSE;
    337. 

  337. 		}
    338. 

  338. 

  339. 		$contents = file_get_contents($plaintext_file);
    340. 

  340. 		$info['raw_message'] = $contents;
    341. 

  341. 		$info = self::handlePart($info, self::parseStructure($contents));
    342. 

  342. 		$info['decrypted'] = TRUE;
    343. 

  343. 

  344. 		unlink($plaintext_file);
    345. 

  345. 		return TRUE;
    346. 

  346. 	}
    347. 

  347. 

  348. 

  349. 

  350. 	/**
    351. 

  351. 	 * Takes a message with an S/MIME signature and verifies it if possible
    352. 

  352. 	 *
    353. 

  353. 	 * @param array &$info       The array of information about a message
    354. 

  354. 	 * @param array $structure
    355. 

  355. 	 * @param array $smime_pair  An associative array containing an S/MIME certificate file
    356. 

  356. 	 * @return boolean  If the message was verified
    357. 

  357. 	 */
    358. 

  358. 	static private function handleSMIMEVerification(&$info, $structure, $smime_pair)
    359. 

  359. 	{
    360. 

  360. 		$certificates_file = tempnam('', '__fMailbox_');
    361. 

  361. 		$ciphertext_file   = tempnam('', '__fMailbox_');
    362. 

  362. 

  363. 		file_put_contents($ciphertext_file, $info['raw_message']);
    364. 

  364. 

  365. 		$result = openssl_pkcs7_verify(
    366. 

  366. 			$ciphertext_file,
    367. 

  367. 			PKCS7_NOINTERN | PKCS7_NOVERIFY,
    368. 

  368. 			$certificates_file,
    369. 

  369. 			array(),
    370. 

  370. 			$smime_pair['certificate']->getPath()
    371. 

  371. 		);
    372. 

  372. 		unlink($ciphertext_file);
    373. 

  373. 		unlink($certificates_file);
    374. 

  374. 

  375. 		if (!$result || $result === -1) {
    376. 

  376. 			return FALSE;
    377. 

  377. 		}
    378. 

  378. 

  379. 		$info['verified'] = TRUE;
    380. 

  380. 

  381. 		return TRUE;
    382. 

  382. 	}
    383. 

  383. 

  384. 

  385. 	/**
    386. 

  386. 	 * This works around a bug in MAMP 1.9.4+ and PHP 5.3 where iconv()
    387. 

  387. 	 * does not seem to properly assign the return value to a variable, but
    388. 

  388. 	 * does work when returning the value.
    389. 

  389. 	 *
    390. 

  390. 	 * @param string $in_charset   The incoming character encoding
    391. 

  391. 	 * @param string $out_charset  The outgoing character encoding
    392. 

  392. 	 * @param string $string       The string to convert
    393. 

  393. 	 * @return string  The converted string
    394. 

  394. 	 */
    395. 

  395. 	static private function iconv($in_charset, $out_charset, $string)
    396. 

  396. 	{
    397. 

  397. 		return iconv($in_charset, $out_charset, $string);
    398. 

  398. 	}
    399. 

  399. 

  400. 

  401. 	/**
    402. 

  402. 	 * Joins parsed emails into a comma-delimited string
    403. 

  403. 	 *
    404. 

  404. 	 * @param array $emails  An array of emails split into personal, mailbox and host parts
    405. 

  405. 	 * @return string  An comma-delimited list of emails
    406. 

  406. 	 */
    407. 

  407. 	static private function joinEmails($emails)
    408. 

  408. 	{
    409. 

  409. 		$output = '';
    410. 

  410. 		foreach ($emails as $email) {
    411. 

  411. 			if ($output) { $output .= ', '; }
    412. 

  412. 

  413. 			if (!isset($email[0])) {
    414. 

  414. 				$email[0] = !empty($email['personal']) ? $email['personal'] : '';
    415. 

  415. 				$email[2] = $email['mailbox'];
    416. 

  416. 				$email[3] = !empty($email['host']) ? $email['host'] : '';
    417. 

  417. 			}
    418. 

  418. 

  419. 			$address = $email[2];
    420. 

  420. 			if (!empty($email[3])) {
    421. 

  421. 				$address .= '@' . $email[3];
    422. 

  422. 			}
    423. 

  423. 			$output .= fEmail::combineNameEmail($email[0], $address);
    424. 

  424. 		}
    425. 

  425. 		return $output;
    426. 

  426. 	}
    427. 

  427. 

  428. 

  429. 	/**
    430. 

  430. 	 * Parses a string representation of an email into the persona, mailbox and host parts
    431. 

  431. 	 *
    432. 

  432. 	 * @param  string $string  The email string to parse
    433. 

  433. 	 * @return array  An associative array with the key `mailbox`, and possibly `host` and `personal`
    434. 

  434. 	 */
    435. 

  435. 	static private function parseEmail($string)
    436. 

  436. 	{
    437. 

  437. 		$email_regex = '((?:[^\x00-\x20\(\)<>@,;:\\\\"\.\[\]]+|"[^"\\\\\n\r]+")(?:\.[ \t]*(?:[^\x00-\x20\(\)<>@,;:\\\\"\.\[\]]+|"[^"\\\\\n\r]+"[ \t]*))*)@((?:[a-z0-9\\-]+\.)+[a-z]{2,}|\[(?:(?:[01]?\d?\d|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d?\d|2[0-4]\d|25[0-5])\])';
    438. 

  438. 		$name_regex  = '((?:[^\x00-\x20\(\)<>@,;:\\\\"\.\[\]]+[ \t]*|"[^"\\\\\n\r]+"[ \t]*)(?:\.?[ \t]*(?:[^\x00-\x20\(\)<>@,;:\\\\"\.\[\]]+[ \t]*|"[^"\\\\\n\r]+"[ \t]*))*)';
    439. 

  439. 

  440. 		if (preg_match('~^[ \t]*' . $name_regex . '[ \t]*<[ \t]*' . $email_regex . '[ \t]*>[ \t]*$~ixD', $string, $match)) {
    441. 

  441. 			$match[1] = trim($match[1]);
    442. 

  442. 			if ($match[1][0] == '"' && substr($match[1], -1) == '"') {
    443. 

  443. 				$match[1] = substr($match[1], 1, -1);
    444. 

  444. 			}
    445. 

  445. 			return array(
    446. 

  446. 				'personal' => self::decodeHeader($match[1]),
    447. 

  447. 				'mailbox' => self::decodeHeader($match[2]),
    448. 

  448. 				'host' => self::decodeHeader($match[3])
    449. 

  449. 			);
    450. 

  450. 

  451. 		} elseif (preg_match('~^[ \t]*(?:<[ \t]*)?' . $email_regex . '(?:[ \t]*>)?[ \t]*$~ixD', $string, $match)) {
    452. 

  452. 			return array(
    453. 

  453. 				'mailbox' => self::decodeHeader($match[1]),
    454. 

  454. 				'host' => self::decodeHeader($match[2])
    455. 

  455. 			);
    456. 

  456. 

  457. 		// This handles the outdated practice of including the personal
    458. 

  458. 		// part of the email in a comment after the email address
    459. 

  459. 		} elseif (preg_match('~^[ \t]*(?:<[ \t]*)?' . $email_regex . '(?:[ \t]*>)?[ \t]*\(([^)]+)\)[ \t]*$~ixD', $string, $match)) {
    460. 

  460. 			$match[3] = trim($match[1]);
    461. 

  461. 			if ($match[3][0] == '"' && substr($match[3], -1) == '"') {
    462. 

  462. 				$match[3] = substr($match[3], 1, -1);
    463. 

  463. 			}
    464. 

  464. 

  465. 			return array(
    466. 

  466. 				'personal' => self::decodeHeader($match[3]),
    467. 

  467. 				'mailbox' => self::decodeHeader($match[1]),
    468. 

  468. 				'host' => self::decodeHeader($match[2])
    469. 

  469. 			);
    470. 

  470. 		}
    471. 

  471. 

  472. 		if (strpos($string, '@') !== FALSE) {
    473. 

  473. 			list ($mailbox, $host) = explode('@', $string, 2);
    474. 

  474. 			return array(
    475. 

  475. 				'mailbox' => self::decodeHeader($mailbox),
    476. 

  476. 				'host' => self::decodeHeader($host)
    477. 

  477. 			);
    478. 

  478. 		}
    479. 

  479. 

  480. 		return array(
    481. 

  481. 			'mailbox' => self::decodeHeader($string),
    482. 

  482. 			'host' => ''
    483. 

  483. 		);
    484. 

  484. 	}
    485. 

  485. 

  486. 

  487. 	/**
    488. 

  488. 	 * Parses full email headers into an associative array
    489. 

  489. 	 *
    490. 

  490. 	 * @param  string $headers  The header to parse
    491. 

  491. 	 * @param  string $filter   Remove any headers that match this
    492. 

  492. 	 * @return array  The parsed headers
    493. 

  493. 	 */
    494. 

  494. 	static private function parseHeaders($headers, $filter=NULL)
    495. 

  495. 	{
    496. 

  496. 		$headers = trim($headers);
    497. 

  497. 		if (!strlen($headers)) {
    498. 

  498. 			return array();
    499. 

  499. 		}
    500. 

  500. 		$header_lines = preg_split("#\r\n(?!\s)#", $headers);
    501. 

  501. 

  502. 		$single_email_fields    = array('from', 'sender', 'reply-to');
    503. 

  503. 		$multi_email_fields     = array('to', 'cc');
    504. 

  504. 		$additional_info_fields = array('content-type', 'content-disposition');
    505. 

  505. 

  506. 		$headers = array();
    507. 

  507. 		foreach ($header_lines as $header_line) {
    508. 

  508. 			$header_line = preg_replace("#\r\n\s+#", '', $header_line);
    509. 

  509. 

  510. 			list ($header, $value) = preg_split('#:\s*#', $header_line, 2);
    511. 

  511. 			$header = strtolower($header);
    512. 

  512. 

  513. 			if (strpos($header, $filter) !== FALSE) {
    514. 

  514. 				continue;
    515. 

  515. 			}
    516. 

  516. 

  517. 			$is_single_email          = in_array($header, $single_email_fields);
    518. 

  518. 			$is_multi_email           = in_array($header, $multi_email_fields);
    519. 

  519. 			$is_additional_info_field = in_array($header, $additional_info_fields);
    520. 

  520. 

  521. 			if ($is_additional_info_field) {
    522. 

  522. 				$pieces = preg_split('#;\s*#', $value, 2);
    523. 

  523. 				$value = $pieces[0];
    524. 

  524. 

  525. 				$headers[$header] = array('value' => self::decodeHeader($value));
    526. 

  526. 

  527. 				$fields = array();
    528. 

  528. 				if (!empty($pieces[1])) {
    529. 

  529. 					preg_match_all('#(\w+)=("([^"]+)"|([^\s;]+))(?=;|$)#', $pieces[1], $matches, PREG_SET_ORDER);
    530. 

  530. 					foreach ($matches as $match) {
    531. 

  531. 						$fields[$match[1]] = self::decodeHeader(!empty($match[4]) ? $match[4] : $match[3]);
    532. 

  532. 					}
    533. 

  533. 				}
    534. 

  534. 				$headers[$header]['fields'] = $fields;
    535. 

  535. 

  536. 			} elseif ($is_single_email) {
    537. 

  537. 				$headers[$header] = self::parseEmail($value);
    538. 

  538. 

  539. 			} elseif ($is_multi_email) {
    540. 

  540. 				$strings = array();
    541. 

  541. 

  542. 				preg_match_all('#"[^"]+?"#', $value, $matches, PREG_SET_ORDER);
    543. 

  543. 				foreach ($matches as $i => $match) {
    544. 

  544. 					$strings[] = $match[0];
    545. 

  545. 					$value = preg_replace('#' . preg_quote($match[0], '#') . '#', ':string' . sizeof($strings), $value, 1);
    546. 

  546. 				}
    547. 

  547. 				preg_match_all('#\([^)]+?\)#', $value, $matches, PREG_SET_ORDER);
    548. 

  548. 				foreach ($matches as $i => $match) {
    549. 

  549. 					$strings[] = $match[0];
    550. 

  550. 					$value = preg_replace('#' . preg_quote($match[0], '#') . '#', ':string' . sizeof($strings), $value, 1);
    551. 

  551. 				}
    552. 

  552. 

  553. 				$emails = explode(',', $value);
    554. 

  554. 				array_map('trim', $emails);
    555. 

  555. 				foreach ($strings as $i => $string) {
    556. 

  556. 					$emails = preg_replace(
    557. 

  557. 						'#:string' . ($i+1) . '\b#',
    558. 

  558. 						strtr($string, array('\\' => '\\\\', '$' => '\\$')),
    559. 

  559. 						$emails,
    560. 

  560. 						1
    561. 

  561. 					);
    562. 

  562. 				}
    563. 

  563. 

  564. 				$headers[$header] = array();
    565. 

  565. 				foreach ($emails as $email) {
    566. 

  566. 					$headers[$header][] = self::parseEmail($email);
    567. 

  567. 				}
    568. 

  568. 

  569. 			} elseif ($header == 'references') {
    570. 

  570. 				$headers[$header] = array_map(array('fMailbox', 'decodeHeader'), preg_split('#(?<=>)\s+(?=<)#', $value));
    571. 

  571. 

  572. 			} elseif ($header == 'received') {
    573. 

  573. 				if (!isset($headers[$header])) {
    574. 

  574. 					$headers[$header] = array();
    575. 

  575. 				}
    576. 

  576. 				$headers[$header][] = preg_replace('#\s+#', ' ', self::decodeHeader($value));
    577. 

  577. 

  578. 			} else {
    579. 

  579. 				$headers[$header] = self::decodeHeader($value);
    580. 

  580. 			}
    581. 

  581. 		}
    582. 

  582. 

  583. 		return $headers;
    584. 

  584. 	}
    585. 

  585. 

  586. 

  587. 	/**
    588. 

  588. 	 * Parses a MIME message into an associative array of information
    589. 

  589. 	 *
    590. 

  590. 	 * The output includes the following keys:
    591. 

  591. 	 *
    592. 

  592. 	 *  - `'received'`: The date the message was received by the server
    593. 

  593. 	 *  - `'headers'`: An associative array of mail headers, the keys are the header names, in lowercase
    594. 

  594. 	 *
    595. 

  595. 	 * And one or more of the following:
    596. 

  596. 	 *
    597. 

  597. 	 *  - `'text'`: The plaintext body
    598. 

  598. 	 *  - `'html'`: The HTML body
    599. 

  599. 	 *  - `'attachment'`: An array of attachments, each containing:
    600. 

  600. 	 *   - `'filename'`: The name of the file
    601. 

  601. 	 *   - `'mimetype'`: The mimetype of the file
    602. 

  602. 	 *   - `'data'`: The raw contents of the file
    603. 

  603. 	 *  - `'inline'`: An array of inline files, each containing:
    604. 

  604. 	 *   - `'filename'`: The name of the file
    605. 

  605. 	 *   - `'mimetype'`: The mimetype of the file
    606. 

  606. 	 *   - `'data'`: The raw contents of the file
    607. 

  607. 	 *  - `'related'`: An associative array of related files, such as embedded images, with the key `'cid:{content-id}'` and an array value containing:
    608. 

  608. 	 *   - `'mimetype'`: The mimetype of the file
    609. 

  609. 	 *   - `'data'`: The raw contents of the file
    610. 

  610. 	 *  - `'verified'`: If the message contents were verified via an S/MIME certificate - if not verified the smime.p7s will be listed as an attachment
    611. 

  611. 	 *  - `'decrypted'`: If the message contents were decrypted via an S/MIME private key - if not decrypted the smime.p7m will be listed as an attachment
    612. 

  612. 	 *
    613. 

  613. 	 * All values in `headers`, `text` and `body` will have been decoded to
    614. 

  614. 	 * UTF-8. Files in the `attachment`, `inline` and `related` array will all
    615. 

  615. 	 * retain their original encodings.
    616. 

  616. 	 *
    617. 

  617. 	 * @param string  $message           The full source of the email message
    618. 

  618. 	 * @param boolean $convert_newlines  If `\r\n` should be converted to `\n` in the `text` and `html` parts the message
    619. 

  619. 	 * @return array  The parsed email message - see method description for details
    620. 

  620. 	 */
    621. 

  621. 	static public function parseMessage($message, $convert_newlines=FALSE)
    622. 

  622. 	{
    623. 

  623. 		$info = array();
    624. 

  624. 		list ($headers, $body)   = explode("\r\n\r\n", $message, 2);
    625. 

  625. 		$parsed_headers          = self::parseHeaders($headers);
    626. 

  626. 		$info['received']        = self::cleanDate(preg_replace('#^.*;\s*([^;]+)$#', '\1', $parsed_headers['received'][0]));
    627. 

  627. 		$info['headers']         = array();
    628. 

  628. 		foreach ($parsed_headers as $header => $value) {
    629. 

  629. 			if (substr($header, 0, 8) == 'content-') {
    630. 

  630. 				continue;
    631. 

  631. 			}
    632. 

  632. 			$info['headers'][$header] = $value;
    633. 

  633. 		}
    634. 

  634. 		$info['raw_headers'] = $headers;
    635. 

  635. 		$info['raw_message'] = $message;
    636. 

  636. 

  637. 		$info = self::handlePart($info, self::parseStructure($body, $parsed_headers));
    638. 

  638. 		unset($info['raw_message']);
    639. 

  639. 		unset($info['raw_headers']);
    640. 

  640. 

  641. 		if ($convert_newlines) {
    642. 

  642. 			if (isset($info['text'])) {
    643. 

  643. 				$info['text'] = str_replace("\r\n", "\n", $info['text']);
    644. 

  644. 			}
    645. 

  645. 			if (isset($info['html'])) {
    646. 

  646. 				$info['html'] = str_replace("\r\n", "\n", $info['html']);
    647. 

  647. 			}
    648. 

  648. 		}
    649. 

  649. 

  650. 		if (isset($info['text'])) {
    651. 

  651. 			$info['text'] = preg_replace('#\r?\n$#D', '', $info['text']);
    652. 

  652. 		}
    653. 

  653. 		if (isset($info['html'])) {
    654. 

  654. 			$info['html'] = preg_replace('#\r?\n$#D', '', $info['html']);
    655. 

  655. 		}
    656. 

  656. 

  657. 		return $info;
    658. 

  658. 	}
    659. 

  659. 

  660. 

  661. 	/**
    662. 

  662. 	 * Takes a response from an IMAP command and parses it into a
    663. 

  663. 	 * multi-dimensional array
    664. 

  664. 	 *
    665. 

  665. 	 * @param string  $text       The IMAP command response
    666. 

  666. 	 * @param boolean $top_level  If we are parsing the top level
    667. 

  667. 	 * @return array  The parsed representation of the response text
    668. 

  668. 	 */
    669. 

  669. 	static private function parseResponse($text, $top_level=FALSE)
    670. 

  670. 	{
    671. 

  671. 		$regex = '[\\\\\w.\[\]]+|"([^"\\\\]+|\\\\"|\\\\\\\\)*"|\((?:(?1)[ \t]*)*\)';
    672. 

  672. 

  673. 		if (preg_match('#\{(\d+)\}#', $text, $match)) {
    674. 

  674. 			$regex = '\{' . $match[1] . '\}\r\n.{' . ($match[1]) . '}|' . $regex;
    675. 

  675. 		}
    676. 

  676. 

  677. 		preg_match_all('#(' . $regex . ')#s', $text, $matches, PREG_SET_ORDER);
    678. 

  678. 		$output = array();
    679. 

  679. 		foreach ($matches as $match) {
    680. 

  680. 			if (substr($match[0], 0, 1) == '"') {
    681. 

  681. 				$output[] = str_replace('\\"', '"', substr($match[0], 1, -1));
    682. 

  682. 			} elseif (substr($match[0], 0, 1) == '(') {
    683. 

  683. 				$output[] = self::parseResponse(substr($match[0], 1, -1));
    684. 

  684. 			} elseif (substr($match[0], 0, 1) == '{') {
    685. 

  685. 				$output[] = preg_replace('#^[^\r]+\r\n#', '', $match[0]);
    686. 

  686. 			} else {
    687. 

  687. 				$output[] = $match[0];
    688. 

  688. 			}
    689. 

  689. 		}
    690. 

  690. 

  691. 		if ($top_level) {
    692. 

  692. 			$new_output = array();
    693. 

  693. 			$total_size = count($output);
    694. 

  694. 			for ($i = 0; $i < $total_size; $i = $i + 2) {
    695. 

  695. 				$new_output[strtolower($output[$i])] = $output[$i+1];
    696. 

  696. 			}
    697. 

  697. 			$output = $new_output;
    698. 

  698. 		}
    699. 

  699. 

  700. 		return $output;
    701. 

  701. 	}
    702. 

  702. 

  703. 

  704. 	/**
    705. 

  705. 	 * Takes the raw contents of a MIME message and creates an array that
    706. 

  706. 	 * describes the structure of the message
    707. 

  707. 	 *
    708. 

  708. 	 * @param string $data     The contents to get the structure of
    709. 

  709. 	 * @param string $headers  The parsed headers for the message - if not present they will be extracted from the `$data`
    710. 

  710. 	 * @return array  The multi-dimensional, associative array containing the message structure
    711. 

  711. 	 */
    712. 

  712. 	static private function parseStructure($data, $headers=NULL)
    713. 

  713. 	{
    714. 

  714. 		if (!$headers) {
    715. 

  715. 			list ($headers, $data) = preg_split("#^\r\n|\r\n\r\n#", $data, 2);
    716. 

  716. 			$headers = self::parseHeaders($headers);
    717. 

  717. 		}
    718. 

  718. 

  719. 		if (!isset($headers['content-type'])) {
    720. 

  720. 			$headers['content-type'] = array(
    721. 

  721. 				'value'  => 'text/plain',
    722. 

  722. 				'fields' => array()
    723. 

  723. 			);
    724. 

  724. 		}
    725. 

  725. 

  726. 		list ($type, $subtype) = explode('/', strtolower($headers['content-type']['value']), 2);
    727. 

  727. 

  728. 		if ($type == 'multipart') {
    729. 

  729. 			$structure    = array(
    730. 

  730. 				'type'    => $type,
    731. 

  731. 				'subtype' => $subtype,
    732. 

  732. 				'parts'   => array()
    733. 

  733. 			);
    734. 

  734. 			$boundary     = $headers['content-type']['fields']['boundary'];
    735. 

  735. 			$start_pos    = strpos($data, '--' . $boundary) + strlen($boundary) + 4;
    736. 

  736. 			$end_pos      = strrpos($data, '--' . $boundary . '--') - 2;
    737. 

  737. 			$sub_contents = explode("\r\n--" . $boundary . "\r\n", substr(
    738. 

  738. 				$data,
    739. 

  739. 				$start_pos,
    740. 

  740. 				$end_pos - $start_pos
    741. 

  741. 			));
    742. 

  742. 			foreach ($sub_contents as $sub_content) {
    743. 

  743. 				$structure['parts'][] = self::parseStructure($sub_content);
    744. 

  744. 			}
    745. 

  745. 

  746. 		} else {
    747. 

  747. 			$structure = array(
    748. 

  748. 				'type'               => $type,
    749. 

  749. 				'type_fields'        => !empty($headers['content-type']['fields']) ? $headers['content-type']['fields'] : array(),
    750. 

  750. 				'subtype'            => $subtype,
    751. 

  751. 				'content_id'         => isset($headers['content-id']) ? $headers['content-id'] : NULL,
    752. 

  752. 				'encoding'           => isset($headers['content-transfer-encoding']) ? strtolower($headers['content-transfer-encoding']) : '8bit',
    753. 

  753. 				'disposition'        => isset($headers['content-disposition']) ? strtolower($headers['content-disposition']['value']) : NULL,
    754. 

  754. 				'disposition_fields' => isset($headers['content-disposition']) ? $headers['content-disposition']['fields'] : array(),
    755. 

  755. 				'data'               => $data
    756. 

  756. 			);
    757. 

  757. 		}
    758. 

  758. 

  759. 		return $structure;
    760. 

  760. 	}
    761. 

  761. 

  762. 

  763. 	/**
    764. 

  764. 	 * Resets the configuration of the class
    765. 

  765. 	 *
    766. 

  766. 	 * @internal
    767. 

  767. 	 *
    768. 

  768. 	 * @return void
    769. 

  769. 	 */
    770. 

  770. 	static public function reset()
    771. 

  771. 	{
    772. 

  772. 		self::$smime_pairs = array();
    773. 

  773. 	}
    774. 

  774. 

  775. 

  776. 	/**
    777. 

  777. 	 * Takes an associative array and unfolds the keys and values so that the
    778. 

  778. 	 * result in an integer-indexed array of `0 => key1, 1 => value1, 2 => key2,
    779. 

  779. 	 * 3 => value2, ...`.
    780. 

  780. 	 *
    781. 

  781. 	 * @param array $array  The array to unfold
    782. 

  782. 	 * @return array  The unfolded array
    783. 

  783. 	 */
    784. 

  784. 	static private function unfoldAssociativeArray($array)
    785. 

  785. 	{
    786. 

  786. 		$new_array = array();
    787. 

  787. 		foreach ($array as $key => $value) {
    788. 

  788. 			$new_array[] = $key;
    789. 

  789. 			$new_array[] = $value;
    790. 

  790. 		}
    791. 

  791. 		return $new_array;
    792. 

  792. 	}
    793. 

  793. 

  794. 

  795. 	/**
    796. 

  796. 	 * A counter to use for generating command keys
    797. 

  797. 	 *
    798. 

  798. 	 * @var integer
    799. 

  799. 	 */
    800. 

  800. 	private $command_num = 1;
    801. 

  801. 

  802. 	/**
    803. 

  803. 	 * The connection resource
    804. 

  804. 	 *
    805. 

  805. 	 * @var resource
    806. 

  806. 	 */
    807. 

  807. 	private $connection;
    808. 

  808. 

  809. 	/**
    810. 

  810. 	 * If debugging has been enabled
    811. 

  811. 	 *
    812. 

  812. 	 * @var boolean
    813. 

  813. 	 */
    814. 

  814. 	private $debug;
    815. 

  815. 

  816. 	/**
    817. 

  817. 	 * The server hostname or IP address
    818. 

  818. 	 *
    819. 

  819. 	 * @var string
    820. 

  820. 	 */
    821. 

  821. 	private $host;
    822. 

  822. 

  823. 	/**
    824. 

  824. 	 * The password for the account
    825. 

  825. 	 *
    826. 

  826. 	 * @var string
    827. 

  827. 	 */
    828. 

  828. 	private $password;
    829. 

  829. 

  830. 	/**
    831. 

  831. 	 * The port for the server
    832. 

  832. 	 *
    833. 

  833. 	 * @var integer
    834. 

  834. 	 */
    835. 

  835. 	private $port;
    836. 

  836. 

  837. 	/**
    838. 

  838. 	 * If the connection to the server should be secure
    839. 

  839. 	 *
    840. 

  840. 	 * @var boolean
    841. 

  841. 	 */
    842. 

  842. 	private $secure;
    843. 

  843. 

  844. 	/**
    845. 

  845. 	 * The timeout for the connection
    846. 

  846. 	 *
    847. 

  847. 	 * @var integer
    848. 

  848. 	 */
    849. 

  849. 	private $timeout = 5;
    850. 

  850. 

  851. 	/**
    852. 

  852. 	 * The type of mailbox, `'imap'` or `'pop3'`
    853. 

  853. 	 *
    854. 

  854. 	 * @var string
    855. 

  855. 	 */
    856. 

  856. 	private $type;
    857. 

  857. 

  858. 	/**
    859. 

  859. 	 * The username for the account
    860. 

  860. 	 *
    861. 

  861. 	 * @var string
    862. 

  862. 	 */
    863. 

  863. 	private $username;
    864. 

  864. 

  865. 

  866. 	/**
    867. 

  867. 	 * Configures the connection to the server
    868. 

  868. 	 *
    869. 

  869. 	 * Please note that the GMail POP3 server does not act like other POP3
    870. 

  870. 	 * servers and the GMail IMAP server should be used instead. GMail POP3 only
    871. 

  871. 	 * allows retrieving a message once - during future connections the email
    872. 

  872. 	 * in question will no longer be available.
    873. 

  873. 	 *
    874. 

  874. 	 * @param  string  $type      The type of mailbox, `'pop3'` or `'imap'`
    875. 

  875. 	 * @param  string  $host      The server hostname or IP address
    876. 

  876. 	 * @param  string  $username  The user to log in as
    877. 

  877. 	 * @param  string  $password  The user's password
    878. 

  878. 	 * @param  integer $port      The port to connect via - only required if non-standard
    879. 

  879. 	 * @param  boolean $secure    If SSL should be used for the connection - this requires the `openssl` extension
    880. 

  880. 	 * @param  integer $timeout   The timeout to use when connecting
    881. 

  881. 	 * @return fMailbox
    882. 

  882. 	 */
    883. 

  883. 	public function __construct($type, $host, $username, $password, $port=NULL, $secure=FALSE, $timeout=NULL)
    884. 

  884. 	{
    885. 

  885. 		if ($timeout === NULL) {
    886. 

  886. 			$timeout = ini_get('default_socket_timeout');
    887. 

  887. 		}
    888. 

  888. 

  889. 		$valid_types = array('imap', 'pop3');
    890. 

  890. 		if (!in_array($type, $valid_types)) {
    891. 

  891. 			throw new fProgrammerException(
    892. 

  892. 				'The mailbox type specified, %1$s, in invalid. Must be one of: %2$s.',
    893. 

  893. 				$type,
    894. 

  894. 				join(', ', $valid_types)
    895. 

  895. 			);
    896. 

  896. 		}
    897. 

  897. 

  898. 		if ($port === NULL) {
    899. 

  899. 			if ($type == 'imap') {
    900. 

  900. 				$port = !$secure ? 143 : 993;
    901. 

  901. 			} else {
    902. 

  902. 				$port = !$secure ? 110 : 995;
    903. 

  903. 			}
    904. 

  904. 		}
    905. 

  905. 

  906. 		if ($secure && !extension_loaded('openssl')) {
    907. 

  907. 			throw new fEnvironmentException(
    908. 

  908. 				'A secure connection was requested, but the %s extension is not installed',
    909. 

  909. 				'openssl'
    910. 

  910. 			);
    911. 

  911. 		}
    912. 

  912. 

  913. 		$this->type     = $type;
    914. 

  914. 		$this->host     = $host;
    915. 

  915. 		$this->username = $username;
    916. 

  916. 		$this->password = $password;
    917. 

  917. 		$this->port     = $port;
    918. 

  918. 		$this->secure   = $secure;
    919. 

  919. 		$this->timeout  = $timeout;
    920. 

  920. 	}
    921. 

  921. 

  922. 

  923. 	/**
    924. 

  924. 	 * Disconnects from the server
    925. 

  925. 	 *
    926. 

  926. 	 * @return void
    927. 

  927. 	 */
    928. 

  928. 	public function __destruct()
    929. 

  929. 	{
    930. 

  930. 		$this->close();
    931. 

  931. 	}
    932. 

  932. 

  933. 

  934. 	/**
    935. 

  935. 	 * Closes the connection to the server
    936. 

  936. 	 *
    937. 

  937. 	 * @return void
    938. 

  938. 	 */
    939. 

  939. 	public function close()
    940. 

  940. 	{
    941. 

  941. 		if (!$this->connection) {
    942. 

  942. 			return;
    943. 

  943. 		}
    944. 

  944. 

  945. 		if ($this->type == 'imap') {
    946. 

  946. 			$this->write('LOGOUT');
    947. 

  947. 		} else {
    948. 

  948. 			$this->write('QUIT', 1);
    949. 

  949. 		}
    950. 

  950. 

  951. 		$this->connection = NULL;
    952. 

  952. 	}
    953. 

  953. 

  954. 

  955. 	/**
    956. 

  956. 	 * Connects to the server
    957. 

  957. 	 *
    958. 

  958. 	 * @return void
    959. 

  959. 	 */
    960. 

  960. 	private function connect()
    961. 

  961. 	{
    962. 

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

  963. 			return;
    964. 

  964. 		}
    965. 

  965. 

  966. 		fCore::startErrorCapture(E_WARNING);
    967. 

  967. 

  968. 		$this->connection = fsockopen(
    969. 

  969. 			$this->secure ? 'tls://' . $this->host : $this->host,
    970. 

  970. 			$this->port,
    971. 

  971. 			$error_number,
    972. 

  972. 			$error_string,
    973. 

  973. 			$this->timeout
    974. 

  974. 		);
    975. 

  975. 

  976. 		foreach (fCore::stopErrorCapture('#ssl#i') as $error) {
    977. 

  977. 			throw new fConnectivityException('There was an error connecting to the server. A secure connection was requested, but was not available. Try a non-secure connection instead.');
    978. 

  978. 		}
    979. 

  979. 

  980. 		if (!$this->connection) {
    981. 

  981. 			throw new fConnectivityException('There was an error connecting to the server');
    982. 

  982. 		}
    983. 

  983. 

  984. 		stream_set_timeout($this->connection, $this->timeout);
    985. 

  985. 

  986. 

  987. 		if ($this->type == 'imap') {
    988. 

  988. 			if (!$this->secure && extension_loaded('openssl')) {
    989. 

  989. 				$response = $this->write('CAPABILITY');
    990. 

  990. 				if (preg_match('#\bstarttls\b#i', $response[0])) {
    991. 

  991. 					$this->write('STARTTLS');
    992. 

  992. 					do {
    993. 

  993. 						if (isset($res)) {
    994. 

  994. 							sleep(0.1);
    995. 

  995. 						}
    996. 

  996. 						$res = stream_socket_enable_crypto($this->connection, TRUE, STREAM_CRYPTO_METHOD_TLS_CLIENT);
    997. 

  997. 					} while ($res === 0);
    998. 

  998. 				}
    999. 

  999. 			}
    1000. 

  1000. 

  1001. 			$response = $this->write('LOGIN ' . $this->username . ' ' . $this->password);
    1002. 

  1002. 			if (!$response || !preg_match('#^[^ ]+\s+OK#', $response[count($response)-1])) {
    1003. 

  1003. 				throw new fValidationException(
    1004. 

  1004. 					'The username and password provided were not accepted for the %1$s server %2$s on port %3$s',
    1005. 

  1005. 					strtoupper($this->type),
    1006. 

  1006. 					$this->host,
    1007. 

  1007. 					$this->port
    1008. 

  1008. 				);
    1009. 

  1009. 			}
    1010. 

  1010. 			$this->write('SELECT "INBOX"');
    1011. 

  1011. 

  1012. 		} elseif ($this->type == 'pop3') {
    1013. 

  1013. 			$response = $this->read(1);
    1014. 

  1014. 			if (isset($response[0])) {
    1015. 

  1015. 				if ($response[0][0] == '-') {
    1016. 

  1016. 					throw new fConnectivityException(
    1017. 

  1017. 						'There was an error connecting to the POP3 server %1$s on port %2$s',
    1018. 

  1018. 						$this->host,
    1019. 

  1019. 						$this->port
    1020. 

  1020. 					);
    1021. 

  1021. 				}
    1022. 

  1022. 				preg_match('#<[^@]+@[^>]+>#', $response[0], $match);
    1023. 

  1023. 			}
    1024. 

  1024. 

  1025. 			if (!$this->secure && extension_loaded('openssl')) {
    1026. 

  1026. 				$response = $this->write('STLS', 1);
    1027. 

  1027. 				if ($response[0][0] == '+') {
    1028. 

  1028. 					do {
    1029. 

  1029. 						if (isset($res)) {
    1030. 

  1030. 							sleep(0.1);
    1031. 

  1031. 						}
    1032. 

  1032. 						$res = stream_socket_enable_crypto($this->connection, TRUE, STREAM_CRYPTO_METHOD_TLS_CLIENT);
    1033. 

  1033. 					} while ($res === 0);
    1034. 

  1034. 					if ($res === FALSE) {
    1035. 

  1035. 						throw new fConnectivityException('Error establishing secure connection');
    1036. 

  1036. 					}
    1037. 

  1037. 				}
    1038. 

  1038. 			}
    1039. 

  1039. 

  1040. 			$authenticated = FALSE;
    1041. 

  1041. 			if (isset($match[0])) {
    1042. 

  1042. 				$response = $this->write('APOP ' . $this->username . ' ' . md5($match[0] . $this->password), 1);
    1043. 

  1043. 				if (isset($response[0]) && $response[0][0] == '+') {
    1044. 

  1044. 					$authenticated = TRUE;
    1045. 

  1045. 				}
    1046. 

  1046. 			}
    1047. 

  1047. 

  1048. 			if (!$authenticated) {
    1049. 

  1049. 				$response = $this->write('USER ' . $this->username, 1);
    1050. 

  1050. 				if ($response[0][0] == '+') {
    1051. 

  1051. 					$response = $this->write('PASS ' . $this->password, 1);
    1052. 

  1052. 					if (isset($response[0][0]) && $response[0][0] == '+') {
    1053. 

  1053. 						$authenticated = TRUE;
    1054. 

  1054. 					}
    1055. 

  1055. 				}
    1056. 

  1056. 			}
    1057. 

  1057. 

  1058. 			if (!$authenticated) {
    1059. 

  1059. 				throw new fValidationException(
    1060. 

  1060. 					'The username and password provided were not accepted for the %1$s server %2$s on port %3$s',
    1061. 

  1061. 					strtoupper($this->type),
    1062. 

  1062. 					$this->host,
    1063. 

  1063. 					$this->port
    1064. 

  1064. 				);
    1065. 

  1065. 			}
    1066. 

  1066. 		}
    1067. 

  1067. 	}
    1068. 

  1068. 

  1069. 

  1070. 	/**
    1071. 

  1071. 	 * Deletes one or more messages from the server
    1072. 

  1072. 	 *
    1073. 

  1073. 	 * Passing more than one UID at a time is more efficient for IMAP mailboxes,
    1074. 

  1074. 	 * whereas POP3 mailboxes will see no difference in performance.
    1075. 

  1075. 	 *
    1076. 

  1076. 	 * @param  integer|array $uid  The UID(s) of the message(s) to delete
    1077. 

  1077. 	 * @return void
    1078. 

  1078. 	 */
    1079. 

  1079. 	public function deleteMessages($uid)
    1080. 

  1080. 	{
    1081. 

  1081. 		$this->connect();
    1082. 

  1082. 

  1083. 		settype($uid, 'array');
    1084. 

  1084. 

  1085. 		if ($this->type == 'imap') {
    1086. 

  1086. 			$this->write('UID STORE ' . join(',', $uid) . ' +FLAGS (\\Deleted)');
    1087. 

  1087. 			$this->write('EXPUNGE');
    1088. 

  1088. 

  1089. 		} elseif ($this->type == 'pop3') {
    1090. 

  1090. 			foreach ($uid as $id) {
    1091. 

  1091. 				$this->write('DELE ' . $id, 1);
    1092. 

  1092. 			}
    1093. 

  1093. 		}
    1094. 

  1094. 	}
    1095. 

  1095. 

  1096. 

  1097. 	/**
    1098. 

  1098. 	 * Sets if debug messages should be shown
    1099. 

  1099. 	 *
    1100. 

  1100. 	 * @param  boolean $flag  If debugging messages should be shown
    1101. 

  1101. 	 * @return void
    1102. 

  1102. 	 */
    1103. 

  1103. 	public function enableDebugging($flag)
    1104. 

  1104. 	{
    1105. 

  1105. 		$this->debug = (boolean) $flag;
    1106. 

  1106. 	}
    1107. 

  1107. 

  1108. 

  1109. 	/**
    1110. 

  1110. 	 * Retrieves a single message from the server
    1111. 

  1111. 	 *
    1112. 

  1112. 	 * The output includes the following keys:
    1113. 

  1113. 	 *
    1114. 

  1114. 	 *  - `'uid'`: The UID of the message
    1115. 

  1115. 	 *  - `'received'`: The date the message was received by the server
    1116. 

  1116. 	 *  - `'headers'`: An associative array of mail headers, the keys are the header names, in lowercase
    1117. 

  1117. 	 *
    1118. 

  1118. 	 * And one or more of the following:
    1119. 

  1119. 	 *
    1120. 

  1120. 	 *  - `'text'`: The plaintext body
    1121. 

  1121. 	 *  - `'html'`: The HTML body
    1122. 

  1122. 	 *  - `'attachment'`: An array of attachments, each containing:
    1123. 

  1123. 	 *   - `'filename'`: The name of the file
    1124. 

  1124. 	 *   - `'mimetype'`: The mimetype of the file
    1125. 

  1125. 	 *   - `'data'`: The raw contents of the file
    1126. 

  1126. 	 *  - `'inline'`: An array of inline files, each containing:
    1127. 

  1127. 	 *   - `'filename'`: The name of the file
    1128. 

  1128. 	 *   - `'mimetype'`: The mimetype of the file
    1129. 

  1129. 	 *   - `'data'`: The raw contents of the file
    1130. 

  1130. 	 *  - `'related'`: An associative array of related files, such as embedded images, with the key `'cid:{content-id}'` and an array value containing:
    1131. 

  1131. 	 *   - `'mimetype'`: The mimetype of the file
    1132. 

  1132. 	 *   - `'data'`: The raw contents of the file
    1133. 

  1133. 	 *  - `'verified'`: If the message contents were verified via an S/MIME certificate - if not verified the smime.p7s will be listed as an attachment
    1134. 

  1134. 	 *  - `'decrypted'`: If the message contents were decrypted via an S/MIME private key - if not decrypted the smime.p7m will be listed as an attachment
    1135. 

  1135. 	 *
    1136. 

  1136. 	 * All values in `headers`, `text` and `body` will have been decoded to
    1137. 

  1137. 	 * UTF-8. Files in the `attachment`, `inline` and `related` array will all
    1138. 

  1138. 	 * retain their original encodings.
    1139. 

  1139. 	 *
    1140. 

  1140. 	 * @param  integer $uid               The UID of the message to retrieve
    1141. 

  1141. 	 * @param  boolean $convert_newlines  If `\r\n` should be converted to `\n` in the `text` and `html` parts the message
    1142. 

  1142. 	 * @return array  The parsed email message - see method description for details
    1143. 

  1143. 	 */
    1144. 

  1144. 	public function fetchMessage($uid, $convert_newlines=FALSE)
    1145. 

  1145. 	{
    1146. 

  1146. 		$this->connect();
    1147. 

  1147. 

  1148. 		$source = $this->fetchMessageSource($uid);
    1149. 

  1149. 

  1150. 		$info = self::parseMessage($source, $convert_newlines);
    1151. 

  1151. 		$info['uid'] = $uid;
    1152. 

  1152. 

  1153. 		return $info;
    1154. 

  1154. 	}
    1155. 

  1155. 

  1156. 

  1157. 	/**
    1158. 

  1158. 	 * Retrieves the raw source of a single message from the server
    1159. 

  1159. 	 *
    1160. 

  1160. 	 * This method is primarily useful for storing the raw source of a message.
    1161. 

  1161. 	 * Normal use of fMailbox would involved calling ::fetchMessage(), which
    1162. 

  1162. 	 * calls this method and then ::parseMessage().
    1163. 

  1163. 	 *
    1164. 

  1164. 	 * @param  integer $uid  The UID of the message to retrieve
    1165. 

  1165. 	 * @return string  The raw message source of the email
    1166. 

  1166. 	 */
    1167. 

  1167. 	public function fetchMessageSource($uid)
    1168. 

  1168. 	{
    1169. 

  1169. 		$this->connect();
    1170. 

  1170. 

  1171. 		if ($this->type == 'imap') {
    1172. 

  1172. 			$response = $this->write('UID FETCH ' . $uid . ' (BODY[])');
    1173. 

  1173. 			preg_match('#\{(\d+)\}$#', $response[0], $match);
    1174. 

  1174. 

  1175. 			$message = '';
    1176. 

  1176. 			foreach ($response as $i => $line) {
    1177. 

  1177. 				if (!$i) { continue; }
    1178. 

  1178. 				if (strlen($message) + strlen($line) + 2 > $match[1]) {
    1179. 

  1179. 					$message .= substr($line . "\r\n", 0, $match[1] - strlen($message));
    1180. 

  1180. 				} else {
    1181. 

  1181. 					$message .= $line . "\r\n";
    1182. 

  1182. 				}
    1183. 

  1183. 			}
    1184. 

  1184. 

  1185. 			// Removes the extra trailing \r\n added above to the last line
    1186. 

  1186. 			return substr($message, 0, -2);
    1187. 

  1187. 

  1188. 		} elseif ($this->type == 'pop3') {
    1189. 

  1189. 			$response = $this->write('RETR ' . $uid);
    1190. 

  1190. 			array_shift($response);
    1191. 

  1191. 			$response = join("\r\n", $response);
    1192. 

  1192. 

  1193. 			return $response;
    1194. 

  1194. 		}
    1195. 

  1195. 	}
    1196. 

  1196. 

  1197. 

  1198. 	/**
    1199. 

  1199. 	 * Gets a list of messages from the server
    1200. 

  1200. 	 *
    1201. 

  1201. 	 * The structure of the returned array is:
    1202. 

  1202. 	 *
    1203. 

  1203. 	 * {{{
    1204. 

  1204. 	 * array(
    1205. 

  1205. 	 *     (integer) {uid} => array(
    1206. 

  1206. 	 *         'uid'         => (integer) {a unique identifier for this message on this server},
    1207. 

  1207. 	 *         'received'    => (string) {date message was received},
    1208. 

  1208. 	 *         'size'        => (integer) {size of message in bytes},
    1209. 

  1209. 	 *         'date'        => (string) {date message was sent},
    1210. 

  1210. 	 *         'from'        => (string) {the from header value},
    1211. 

  1211. 	 *         'subject'     => (string) {the message subject},
    1212. 

  1212. 	 *         'message_id'  => (string) {optional - the message-id header value, should be globally unique},
    1213. 

  1213. 	 *         'to'          => (string) {optional - the to header value},
    1214. 

  1214. 	 *         'in_reply_to' => (string) {optional - the in-reply-to header value}
    1215. 

  1215. 	 *     ), ...
    1216. 

  1216. 	 * )
    1217. 

  1217. 	 * }}}
    1218. 

  1218. 	 *
    1219. 

  1219. 	 * All values will have been decoded to UTF-8.
    1220. 

  1220. 	 *
    1221. 

  1221. 	 * @param  integer $limit  The number of messages to retrieve
    1222. 

  1222. 	 * @param  integer $page   The page of messages to retrieve
    1223. 

  1223. 	 * @return array  A list of messages on the server - see method description for details
    1224. 

  1224. 	 */
    1225. 

  1225. 	public function listMessages($limit=NULL, $page=NULL)
    1226. 

  1226. 	{
    1227. 

  1227. 		$this->connect();
    1228. 

  1228. 

  1229. 		if ($this->type == 'imap') {
    1230. 

  1230. 			if (!$limit) {
    1231. 

  1231. 				$start = 1;
    1232. 

  1232. 				$end   = '*';
    1233. 

  1233. 			} else {
    1234. 

  1234. 				if (!$page) {
    1235. 

  1235. 					$page = 1;
    1236. 

  1236. 				}
    1237. 

  1237. 				$start = ($limit * ($page-1)) + 1;
    1238. 

  1238. 				$end   = $start + $limit - 1;
    1239. 

  1239. 			}
    1240. 

  1240. 

  1241. 			$total_messages = 0;
    1242. 

  1242. 			$response = $this->write('STATUS "INBOX" (MESSAGES)');
    1243. 

  1243. 			foreach ($response as $line) {
    1244. 

  1244. 				if (preg_match('#^\s*\*\s+STATUS\s+"?INBOX"?\s+\((.*)\)\s*$#', $line, $match)) {
    1245. 

  1245. 					$details = self::parseResponse($match[1], TRUE);
    1246. 

  1246. 					$total_messages = $details['messages'];
    1247. 

  1247. 				}
    1248. 

  1248. 			}
    1249. 

  1249. 

  1250. 			if ($start > $total_messages) {
    1251. 

  1251. 				return array();
    1252. 

  1252. 			}
    1253. 

  1253. 

  1254. 			if ($end > $total_messages) {
    1255. 

  1255. 				$end = $total_messages;
    1256. 

  1256. 			}
    1257. 

  1257. 

  1258. 			$output = array();
    1259. 

  1259. 			$response = $this->write('FETCH ' . $start . ':' . $end . ' (UID INTERNALDATE RFC822.SIZE ENVELOPE)');
    1260. 

  1260. 			foreach ($response as $line) {
    1261. 

  1261. 				if (preg_match('#^\s*\*\s+(\d+)\s+FETCH\s+\((.*)\)\s*$#', $line, $match)) {
    1262. 

  1262. 					$details = self::parseResponse($match[2], TRUE);
    1263. 

  1263. 					$info    = array();
    1264. 

  1264. 

  1265. 					$info['uid']      = $details['uid'];
    1266. 

  1266. 					$info['received'] = self::cleanDate($details['internaldate']);
    1267. 

  1267. 					$info['size']     = $details['rfc822.size'];
    1268. 

  1268. 

  1269. 					$envelope = $details['envelope'];
    1270. 

  1270. 					$info['date']    = $envelope[0] != 'NIL' ? $envelope[0] : '';
    1271. 

  1271. 					$info['from']    = self::joinEmails($envelope[2]);
    1272. 

  1272. 					if (preg_match('#=\?[^\?]+\?[QB]\?[^\?]+\?=#', $envelope[1])) {
    1273. 

  1273. 						do {
    1274. 

  1274. 							$last_subject = $envelope[1];
    1275. 

  1275. 							$envelope[1] = preg_replace('#(=\?([^\?]+)\?[QB]\?[^\?]+\?=) (\s*=\?\2)#', '\1\3', $envelope[1]);
    1276. 

  1276. 						} while ($envelope[1] != $last_subject);
    1277. 

  1277. 						$info['subject'] = self::decodeHeader($envelope[1]);
    1278. 

  1278. 					} else {
    1279. 

  1279. 						$info['subject'] = $envelope[1] == 'NIL' ? '' : self::decodeHeader($envelope[1]);
    1280. 

  1280. 					}
    1281. 

  1281. 					if ($envelope[9] != 'NIL') {
    1282. 

  1282. 						$info['message_id'] = $envelope[9];
    1283. 

  1283. 					}
    1284. 

  1284. 					if ($envelope[5] != 'NIL') {
    1285. 

  1285. 						$info['to'] = self::joinEmails($envelope[5]);
    1286. 

  1286. 					}
    1287. 

  1287. 					if ($envelope[8] != 'NIL') {
    1288. 

  1288. 						$info['in_reply_to'] = $envelope[8];
    1289. 

  1289. 					}
    1290. 

  1290. 

  1291. 					$output[$info['uid']] = $info;
    1292. 

  1292. 				}
    1293. 

  1293. 			}
    1294. 

  1294. 

  1295. 		} elseif ($this->type == 'pop3') {
    1296. 

  1296. 			if (!$limit) {
    1297. 

  1297. 				$start = 1;
    1298. 

  1298. 				$end   = NULL;
    1299. 

  1299. 			} else {
    1300. 

  1300. 				if (!$page) {
    1301. 

  1301. 					$page = 1;
    1302. 

  1302. 				}
    1303. 

  1303. 				$start = ($limit * ($page-1)) + 1;
    1304. 

  1304. 				$end   = $start + $limit - 1;
    1305. 

  1305. 			}
    1306. 

  1306. 

  1307. 			$total_messages = 0;
    1308. 

  1308. 			$response = $this->write('STAT', 1);
    1309. 

  1309. 			preg_match('#^\+OK\s+(\d+)\s+#', $response[0], $match);
    1310. 

  1310. 			$total_messages = $match[1];
    1311. 

  1311. 

  1312. 			if ($start > $total_messages) {
    1313. 

  1313. 				return array();
    1314. 

  1314. 			}
    1315. 

  1315. 

  1316. 			if ($end === NULL || $end > $total_messages) {
    1317. 

  1317. 				$end = $total_messages;
    1318. 

  1318. 			}
    1319. 

  1319. 

  1320. 			$sizes = array();
    1321. 

  1321. 			$response = $this->write('LIST');
    1322. 

  1322. 			array_shift($response);
    1323. 

  1323. 			foreach ($response as $line) {
    1324. 

  1324. 				preg_match('#^(\d+)\s+(\d+)$#', $line, $match);
    1325. 

  1325. 				$sizes[$match[1]] = $match[2];
    1326. 

  1326. 			}
    1327. 

  1327. 

  1328. 			$output = array();
    1329. 

  1329. 			for ($i = $start; $i <= $end; $i++) {
    1330. 

  1330. 				$response = $this->write('TOP ' . $i . ' 1');
    1331. 

  1331. 				array_shift($response);
    1332. 

  1332. 				$value = array_pop($response);
    1333. 

  1333. 				// Some servers add an extra blank line after the 1 requested line
    1334. 

  1334. 				if (trim($value) == '') {
    1335. 

  1335. 					array_pop($response);
    1336. 

  1336. 				}
    1337. 

  1337. 

  1338. 				$response = trim(join("\r\n", $response));
    1339. 

  1339. 				$headers = self::parseHeaders($response);
    1340. 

  1340. 				$output[$i] = array(
    1341. 

  1341. 					'uid'      => $i,
    1342. 

  1342. 					'received' => self::cleanDate(preg_replace('#^.*;\s*([^;]+)$#', '\1', $headers['received'][0])),
    1343. 

  1343. 					'size'     => $sizes[$i],
    1344. 

  1344. 					'date'     => $headers['date'],
    1345. 

  1345. 					'from'     => self::joinEmails(array($headers['from'])),
    1346. 

  1346. 					'subject'  => isset($headers['subject']) ? $headers['subject'] : ''
    1347. 

  1347. 				);
    1348. 

  1348. 				if (isset($headers['message-id'])) {
    1349. 

  1349. 					$output[$i]['message_id'] = $headers['message-id'];
    1350. 

  1350. 				}
    1351. 

  1351. 				if (isset($headers['to'])) {
    1352. 

  1352. 					$output[$i]['to'] = self::joinEmails($headers['to']);
    1353. 

  1353. 				}
    1354. 

  1354. 				if (isset($headers['in-reply-to'])) {
    1355. 

  1355. 					$output[$i]['in_reply_to'] = $headers['in-reply-to'];
    1356. 

  1356. 				}
    1357. 

  1357. 			}
    1358. 

  1358. 		}
    1359. 

  1359. 

  1360. 		return $output;
    1361. 

  1361. 	}
    1362. 

  1362. 

  1363. 

  1364. 	/**
    1365. 

  1365. 	 * Reads responses from the server
    1366. 

  1366. 	 *
    1367. 

  1367. 	 * @param  integer|string $expect  The expected number of lines of response or a regex of the last line
    1368. 

  1368. 	 * @return array  The lines of response from the server
    1369. 

  1369. 	 */
    1370. 

  1370. 	private function read($expect=NULL)
    1371. 

  1371. 	{
    1372. 

  1372. 		$read     = array($this->connection);
    1373. 

  1373. 		$write    = NULL;
    1374. 

  1374. 		$except   = NULL;
    1375. 

  1375. 		$response = array();
    1376. 

  1376. 

  1377. 		// PHP 5.2.0 to 5.2.5 has a bug on amd64 linux where stream_select()
    1378. 

  1378. 		// fails, so we have to fake it - http://bugs.php.net/bug.php?id=42682
    1379. 

  1379. 		static $broken_select = NULL;
    1380. 

  1380. 		if ($broken_select === NULL) {
    1381. 

  1381. 			$broken_select = strpos(php_uname('m'), '64') !== FALSE && fCore::checkVersion('5.2.0') && !fCore::checkVersion('5.2.6');
    1382. 

  1382. 		}
    1383. 

  1383. 

  1384. 		// Fixes an issue with stream_select throwing a warning on PHP 5.3 on Windows
    1385. 

  1385. 		if (fCore::checkOS('windows') && fCore::checkVersion('5.3.0')) {
    1386. 

  1386. 			$select = @stream_select($read, $write, $except, $this->timeout);
    1387. 

  1387. 

  1388. 		} elseif ($broken_select) {
    1389. 

  1389. 			$broken_select_buffer = NULL;
    1390. 

  1390. 			$start_time = microtime(TRUE);
    1391. 

  1391. 			$i = 0;
    1392. 

  1392. 			do {
    1393. 

  1393. 				if ($i) {
    1394. 

  1394. 					usleep(50000);
    1395. 

  1395. 				}
    1396. 

  1396. 				$char = fgetc($this->connection);
    1397. 

  1397. 				if ($char != "\x00" && $char !== FALSE) {
    1398. 

  1398. 					$broken_select_buffer = $char;
    1399. 

  1399. 				}
    1400. 

  1400. 				$i++;
    1401. 

  1401. 			} while ($broken_select_buffer === NULL && microtime(TRUE) - $start_time < $this->timeout);
    1402. 

  1402. 			$select = $broken_select_buffer !== NULL;
    1403. 

  1403. 

  1404. 		} else {
    1405. 

  1405. 			$select = stream_select($read, $write, $except, $this->timeout);
    1406. 

  1406. 		}
    1407. 

  1407. 

  1408. 		if ($select) {
    1409. 

  1409. 			while (!feof($this->connection)) {
    1410. 

  1410. 				$line = fgets($this->connection);
    1411. 

  1411. 				if ($line === FALSE) {
    1412. 

  1412. 					break;
    1413. 

  1413. 				}
    1414. 

  1414. 				$line = substr($line, 0, -2);
    1415. 

  1415. 

  1416. 				// When we fake select, we have to handle what we've retrieved
    1417. 

  1417. 				if ($broken_select && $broken_select_buffer !== NULL) {
    1418. 

  1418. 					$line = $broken_select_buffer . $line;
    1419. 

  1419. 					$broken_select_buffer = NULL;
    1420. 

  1420. 				}
    1421. 

  1421. 

  1422. 				$response[] = $line;
    1423. 

  1423. 

  1424. 				// Automatically stop at the termination octet or a bad response
    1425. 

  1425. 				if ($this->type == 'pop3' && ($line == '.' || (count($response) == 1 && $response[0][0] == '-'))) {
    1426. 

  1426. 					break;
    1427. 

  1427. 				}
    1428. 

  1428. 

  1429. 				if ($expect !== NULL) {
    1430. 

  1430. 					$matched_number = is_int($expect) && sizeof($response) == $expect;
    1431. 

  1431. 					$matched_regex  = is_string($expect) && preg_match($expect, $line);
    1432. 

  1432. 					if ($matched_number || $matched_regex) {
    1433. 

  1433. 						break;
    1434. 

  1434. 					}
    1435. 

  1435. 				}
    1436. 

  1436. 			}
    1437. 

  1437. 		}
    1438. 

  1438. 		if (fCore::getDebug($this->debug)) {
    1439. 

  1439. 			fCore::debug("Received:\n" . join("\r\n", $response), $this->debug);
    1440. 

  1440. 		}
    1441. 

  1441. 

  1442. 		if ($this->type == 'pop3') {
    1443. 

  1443. 			// Remove the termination octet
    1444. 

  1444. 			if ($response && $response[sizeof($response)-1] == '.') {
    1445. 

  1445. 				$response = array_slice($response, 0, -1);
    1446. 

  1446. 			}
    1447. 

  1447. 			// Remove byte-stuffing
    1448. 

  1448. 			$lines = count($response);
    1449. 

  1449. 			for ($i = 0; $i < $lines; $i++) {
    1450. 

  1450. 				if (strlen($response[$i]) && $response[$i][0] == '.') {
    1451. 

  1451. 					$response[$i] = substr($response[$i], 1);
    1452. 

  1452. 				}
    1453. 

  1453. 			}
    1454. 

  1454. 		}
    1455. 

  1455. 

  1456. 		return $response;
    1457. 

  1457. 	}
    1458. 

  1458. 

  1459. 

  1460. 	/**
    1461. 

  1461. 	 * Sends commands to the IMAP or POP3 server
    1462. 

  1462. 	 *
    1463. 

  1463. 	 * @param  string  $command   The command to send
    1464. 

  1464. 	 * @param  integer $expected  The number of lines or regex expected for a POP3 command
    1465. 

  1465. 	 * @return array  The response from the server
    1466. 

  1466. 	 */
    1467. 

  1467. 	private function write($command, $expected=NULL)
    1468. 

  1468. 	{
    1469. 

  1469. 		if (!$this->connection) {
    1470. 

  1470. 			throw new fProgrammerException('Unable to send data since the connection has already been closed');
    1471. 

  1471. 		}
    1472. 

  1472. 

  1473. 		if ($this->type == 'imap') {
    1474. 

  1474. 			$identifier = 'a' . str_pad($this->command_num++, 4, '0', STR_PAD_LEFT);
    1475. 

  1475. 			$command    = $identifier . ' ' . $command;
    1476. 

  1476. 		}
    1477. 

  1477. 

  1478. 		if (substr($command, -2) != "\r\n") {
    1479. 

  1479. 			$command .= "\r\n";
    1480. 

  1480. 		}
    1481. 

  1481. 

  1482. 		if (fCore::getDebug($this->debug)) {
    1483. 

  1483. 			fCore::debug("Sending:\n" . trim($command), $this->debug);
    1484. 

  1484. 		}
    1485. 

  1485. 

  1486. 		$res = fwrite($this->connection, $command);
    1487. 

  1487. 

  1488. 		if ($res === FALSE || $res === 0) {
    1489. 

  1489. 			throw new fConnectivityException(
    1490. 

  1490. 				'Unable to write data to %1$s server %2$s on port %3$s',
    1491. 

  1491. 				strtoupper($this->type),
    1492. 

  1492. 				$this->host,
    1493. 

  1493. 				$this->port
    1494. 

  1494. 			);
    1495. 

  1495. 		}
    1496. 

  1496. 

  1497. 		if ($this->type == 'imap') {
    1498. 

  1498. 			return $this->read('#^' . $identifier . '#');
    1499. 

  1499. 		} elseif ($this->type == 'pop3') {
    1500. 

  1500. 			return $this->read($expected);
    1501. 

  1501. 		}
    1502. 

  1502. 	}
    1503. 

  1503. }
    1504. 

  1504. 

  1505. /**
    1506. 

  1506.  * Copyright (c) 2010-2012 Will Bond <will@flourishlib.com>
    1507. 

  1507.  *
    1508. 

  1508.  * Permission is hereby granted, free of charge, to any person obtaining a copy
    1509. 

  1509.  * of this software and associated documentation files (the "Software"), to deal
    1510. 

  1510.  * in the Software without restriction, including without limitation the rights
    1511. 

  1511.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    1512. 

  1512.  * copies of the Software, and to permit persons to whom the Software is
    1513. 

  1513.  * furnished to do so, subject to the following conditions:
    1514. 

  1514.  *
    1515. 

  1515.  * The above copyright notice and this permission notice shall be included in
    1516. 

  1516.  * all copies or substantial portions of the Software.
    1517. 

  1517.  *
    1518. 

  1518.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    1519. 

  1519.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    1520. 

  1520.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    1521. 

  1521.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    1522. 

  1522.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    1523. 

  1523.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    1524. 

  1524.  * THE SOFTWARE.
    1525. 

  1525.  */
    1526.