PageRenderTime 61ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 1ms

/e107_handlers/bounce_handler.php

https://github.com/CasperGemini/e107
PHP | 837 lines | 599 code | 139 blank | 99 comment | 177 complexity | 9313cb34030423e015501d8c91becece MD5 | raw file
Possible License(s): GPL-2.0 
    

  1. #!/usr/bin/php -q

    2. 

  2. <?php

    3. 

  3. 

    4. 

  4. 

    5. 

  5.  // WARNING, any echoed output from this script will be returned to the sender as a bounce message. 

    6. 

  6.  

    7. 

  7.  $_E107['debug'] = FALSE;

    8. 

  8.  

    9. 

  9.  

    10. 

  10. if (!defined('e107_INIT'))

    11. 

  11. { 

    12. 

  12. 	$_E107['cli'] = TRUE;	

    13. 

  13. 	$class2 = realpath(dirname(__FILE__)."/../")."/class2.php";

    14. 

  14. 	require_once($class2);

    15. 

  15. }

    16. 

  16. 

    17. 

  17. 

    18. 

  18. $bnc = new e107Bounce;

    19. 

  19. $process = (varset($_GET['eml']) && $_E107['debug']) ? $_GET['eml'].".eml" : FALSE;

    20. 

  20. $bnc->process($process);

    21. 

  21. 

    22. 

  22. 

    23. 

  23. class e107Bounce

    24. 

  24. {

    25. 

  25. 	function process($source='')

    26. 

  26. 	{

    27. 

  27. 		global $_E107,$pref;

    28. 

  28. 		

    29. 

  29. 		e107::getCache()->CachePageMD5 = '_';

    30. 

  30. 		e107::getCache()->set('emailLastBounce',time(),TRUE,FALSE,TRUE);

    31. 

  31. 		

    32. 

  32. 		$strEmail= (!$source) ? $this->mailRead(-1) : file_get_contents(e_HANDLER."eml/".$source);

    33. 

  33. 		

    34. 

  34. 		if(!$strEmail)

    35. 

  35. 		{

    36. 

  36. 			return;

    37. 

  37. 		}

    38. 

  38. 		

    39. 

  39. 		$multiArray = Bouncehandler::get_the_facts($strEmail);

    40. 

  40. 		$head 		= BounceHandler::parse_head($strEmail); 

    41. 

  41. 

    42. 

  42. 	 	$e107_userid = (isset($head['X-e107-id'])) ? intval($head['X-e107-id']) : $this->getHeader($strEmail,'X-e107-id');

    43. 

  43. 		

    44. 

  44. 		if($_E107['debug'])

    45. 

  45. 		{

    46. 

  46. 			require_once(e_HANDLER."mail.php");

    47. 

  47. 			$message = "Your Bounce Handler is working. The data of the email you sent is displayed below.<br />";

    48. 

  48. 			if($e107_userid)

    49. 

  49. 			{

    50. 

  50. 				$message .= "A user-id was detected in the email you sent: <b>".$e107_userid."</b><br />";

    51. 

  51. 			}

    52. 

  52. 			$message .= "<br />";

    53. 

  53. 			$message .= "<pre>".print_r($multiArray,TRUE). "</pre>";

    54. 

  54. 			$message .= "<pre>".$strEmail. "</pre>";						

    55. 

  55. 	    	sendemail($pref['siteadminemail'], SITENAME." :: Bounce-Handler.", $message, $pref['siteadmin'],$pref['siteadminemail'], $pref['siteadmin']);	

    56. 

  56. 		}	

    57. 

  57. 		

    58. 

  58. 		if($e107_userid && ($this->setUser_Bounced($e107_userid)==TRUE))

    59. 

  59. 		{

    60. 

  60. 			return;	

    61. 

  61. 		}

    62. 

  62. 				

    63. 

  63. /*		echo "<pre>";

    64. 

  64. 		print_r($multiArray);

    65. 

  65. 		echo "</pre>"; 

    66. 

  66. */

    67. 

  67. 

    68. 

  68. 		

    69. 

  69. 		foreach($multiArray as $the)

    70. 

  70. 		{

    71. 

  71. 			$the['user_id'] = $head['X-e107-id'];

    72. 

  72. 			$the['user_email'] = $the['recipient'];

    73. 

  73. 			unset($the['recipient']);

    74. 

  74. 

    75. 

  75. 	        switch($the['action'])

    76. 

  76. 			{

    77. 

  77. 	            case 'failed':

    78. 

  78. 					e107::getEvent()->trigger('email-bounce-failed', $the);

    79. 

  79. 					$this->setUser_Bounced($the['user_email']);

    80. 

  80. 					break;

    81. 

  81. 					

    82. 

  82. 	            case 'transient':

    83. 

  83. 	               

    84. 

  84. 	            //    $num_attempts  = delivery_attempts($the['user_email']);

    85. 

  85. 					e107::getEvent()->trigger('email-bounce-transient', $the);

    86. 

  86. 	                if($num_attempts  > 10)

    87. 

  87. 					{

    88. 

  88. 	                    $this->setUser_Bounced($the['user_email'], $the['user_id']);

    89. 

  89. 	                }

    90. 

  90. 	                else

    91. 

  91. 					{

    92. 

  92. 	             //       insert_into_queue($the['user_email'], ($num_attempts+1));

    93. 

  93. 	                }

    94. 

  94. 	                break;

    95. 

  95. 					

    96. 

  96. 	            case 'autoreply':

    97. 

  97. 	            	e107::getEvent()->trigger('email-bounce-autoreply', $the);    

    98. 

  98. 	              //  postpone($the['user_email'], '7 days');

    99. 

  99. 	                break;

    100. 

  100. 					

    101. 

  101. 	            default:

    102. 

  102. 	                //don't do anything

    103. 

  103. 	                break;

    104. 

  104. 	        }

    105. 

  105. 		}

    106. 

  106.     }

    107. 

  107. 

    108. 

  108. 

    109. 

  109. 	function getHeader($message, $id='X-e107-id')

    110. 

  110. 	{

    111. 

  111. 		$tmp = explode("\n",$message); 

    112. 

  112. 		foreach($tmp as $val)

    113. 

  113. 		{

    114. 

  114. 			if(strpos($val,$id.":")!==FALSE)

    115. 

  115. 			{

    116. 

  116. 	            return intval(str_replace($id.":","",$val));

    117. 

  117. 			}

    118. 

  118. 		}   

    119. 

  119. 	}

    120. 

  120. 

    121. 

  121. 

    122. 

  122. 	

    123. 

  123. 	function setUser_Bounced($email, $bounceString = '')

    124. 

  124. 	{

    125. 

  125. 		if(!$email && !$bounceString){ return; }

    126. 

  126. 	//	echo "Email bounced ID: ".$id_or_email;	

    127. 

  127. 		require_once(e_HANDLER.'mail_manager_class.php');

    128. 

  128. 		$mailHandler = new e107MailManager();

    129. 

  129. 		if ($mailManager->markBounce($bounceString, $email))

    130. 

  130. 		{	// Success

    131. 

  131. 		}

    132. 

  132. 		// Failure

    133. 

  133. 	//	$query = (is_numeric($id_or_email)) ? "user_ban = 3 WHERE user_id = ".intval($id_or_email)." LIMIT 1" : "user_ban = 3 WHERE user_email = '".$id_or_email."' ";

    134. 

  134. 	//	return e107::getDb()->db_Update('user',$query);

    135. 

  135. 	}

    136. 

  136. 

    137. 

  137. 	

    138. 

  138. 	

    139. 

  139. 		

    140. 

  140. 	/**

    141. 

  141. 	 * Read the Mail. 

    142. 

  142. 	 * @param object $iKlimit [optional]

    143. 

  143. 	 * @return string mail message

    144. 

  144. 	 */

    145. 

  145. 	function mailRead($iKlimit = 4096)

    146. 

  146.     {

    147. 

  147. 

    148. 

  148. 		$sErrorSTDINFail = "Error - failed to read mail from STDIN!";

    149. 

  149. 		$fp = fopen("php://stdin", "r");

    150. 

  150. 

    151. 

  151.         if (!$fp)

    152. 

  152. 		{

    153. 

  153. 			mail("adminaddress@something.com","Bounce-Processing - Bounce-Processing",$sErrorSTDINFail,$headers);

    154. 

  154.             exit();

    155. 

  155.         }

    156. 

  156. 

    157. 

  157.         // Create empty string for storing message

    158. 

  158.         $sEmail = "";

    159. 

  159. 

    160. 

  160.         if ($iKlimit == -1) {

    161. 

  161.             while (!feof($fp)) {

    162. 

  162.                 $sEmail .= fread($fp, 1024);

    163. 

  163.             }

    164. 

  164.         } else {

    165. 

  165.             while (!feof($fp) && $i_limit < $iKlimit) {

    166. 

  166.                 $sEmail .= fread($fp, 1024);

    167. 

  167.                 $i_limit++;

    168. 

  168.             }

    169. 

  169.         }

    170. 

  170. 

    171. 

  171.         fclose($fp);

    172. 

  172.         return $sEmail;

    173. 

  173.     }		

    174. 

  174. }

    175. 

  175. 

    176. 

  176. 

    177. 

  177. 

    178. 

  178. //error_reporting(E_ALL);

    179. 

  179. 

    180. 

  180. /* BOUNCE HANDLER Class, Version 5.1

    181. 

  181.  * Description: "chops up the bounce into associative arrays"

    182. 

  182.  *     ~ http://www.phpclasses.org/browse/file/11665.html

    183. 

  183.  */

    184. 

  184. 

    185. 

  185. /* Debugging / Contributers:

    186. 

  186.     * "Kanon"

    187. 

  187.     * Jamie McClelland http://mayfirst.org

    188. 

  188.     * Michael Cooper

    189. 

  189.     * Thomas Seifert

    190. 

  190.     * Tim Petrowsky http://neuecouch.de

    191. 

  191.     * Willy T. Koch http://apeland.no

    192. 

  192. */

    193. 

  193. 

    194. 

  194. 

    195. 

  195. /*

    196. 

  196.  The BSD License

    197. 

  197.  Copyright (c) 2006, Chris Fortune http://cfortune.kics.bc.ca

    198. 

  198.  All rights reserved.

    199. 

  199. 

    200. 

  200. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

    201. 

  201. 

    202. 

  202.     * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

    203. 

  203.     * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

    204. 

  204.     * Neither the name of the BounceHandler nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

    205. 

  205. 

    206. 

  206. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    207. 

  207. */

    208. 

  208. class BounceHandler{

    209. 

  209. 	

    210. 

  210. 	

    211. 

  211. 	var $status_code_classes;

    212. 

  212. 	var $status_code_subclasses;

    213. 

  213. 

    214. 

  214. 	function BounceHandler()

    215. 

  215. 	{

    216. 

  216. 		

    217. 

  217. 		$this->status_code_classes['2']['title'] =  "Success";

    218. 

  218. 		$this->status_code_classes['2']['descr'] =  "Success specifies that the DSN is reporting a positive delivery action.  Detail sub-codes may provide notification of transformations required for delivery.";

    219. 

  219. 		

    220. 

  220. 		$this->status_code_classes['4']['title'] =  "Persistent Transient Failure";

    221. 

  221. 		$this->status_code_classes['4']['descr'] =  "A persistent transient failure is one in which the message as sent is valid, but some temporary event prevents the successful sending of the message.  Sending in the future may be successful.";

    222. 

  222. 		

    223. 

  223. 		$this->status_code_classes['5']['title'] =  "Permanent Failure";

    224. 

  224. 		$this->status_code_classes['5']['descr'] =  "A permanent failure is one which is not likely to be resolved by resending the message in the current form.  Some change to the message or the destination must be made for successful delivery.";

    225. 

  225. 		

    226. 

  226. 		$this->status_code_subclasses['0.0']['title'] =  "Other undefined Status";

    227. 

  227. 		$this->status_code_subclasses['0.0']['descr'] =  "Other undefined status is the only undefined error code. It should be used for all errors for which only the class of the error is known.";

    228. 

  228. 		

    229. 

  229. 		$this->status_code_subclasses['1.0']['title'] =  "Other address status";

    230. 

  230. 		$this->status_code_subclasses['0.0']['descr'] =  "Something about the address specified in the message caused this DSN.";

    231. 

  231. 		

    232. 

  232. 		$this->status_code_subclasses['1.1']['title'] =  "Bad destination mailbox address";

    233. 

  233. 		$this->status_code_subclasses['1.1']['descr'] =  "The mailbox specified in the address does not exist.  For Internet mail names, this means the address portion to the left of the @ sign is invalid.  This code is only useful for permanent failures.";

    234. 

  234. 		   

    235. 

  235. 		$this->status_code_subclasses['1.2']['title'] =  "Bad destination system address";

    236. 

  236. 		$this->status_code_subclasses['1.2']['descr'] =  "The destination system specified in the address does not exist or is incapable of accepting mail.  For Internet mail names, this means the address portion to the right of the @ is invalid for mail.  This codes is only useful for permanent failures.";

    237. 

  237. 		

    238. 

  238. 		$this->status_code_subclasses['1.3']['title'] = "Bad destination mailbox address syntax";

    239. 

  239. 		$this->status_code_subclasses['1.3']['descr'] =  "The destination address was syntactically invalid.  This can apply to any field in the address.  This code is only useful for permanent failures.";

    240. 

  240. 		

    241. 

  241. 		$this->status_code_subclasses['1.4']['title'] = "Destination mailbox address ambiguous";

    242. 

  242. 		$this->status_code_subclasses['1.4']['descr'] =  "The mailbox address as specified matches one or more recipients on the destination system.  This may result if a heuristic address mapping algorithm is used to map the specified address to a local mailbox name.";

    243. 

  243. 		

    244. 

  244. 		$this->status_code_subclasses['1.5']['title'] = "Destination address valid";

    245. 

  245. 		$this->status_code_subclasses['1.5']['descr'] =  "This mailbox address as specified was valid.  This status code should be used for positive delivery reports.";

    246. 

  246. 		

    247. 

  247. 		$this->status_code_subclasses['1.6']['title'] = "Destination mailbox has moved, No forwarding address";

    248. 

  248. 		$this->status_code_subclasses['1.6']['descr'] =  "The mailbox address provided was at one time valid, but mail is no longer being accepted for that address.  This code is only useful for permanent failures.";

    249. 

  249. 		

    250. 

  250. 		$this->status_code_subclasses['1.7']['title'] = "Bad sender's mailbox address syntax";

    251. 

  251. 		$this->status_code_subclasses['1.7']['descr'] =  "The sender's address was syntactically invalid.  This can apply to any field in the address.";

    252. 

  252. 		

    253. 

  253. 		$this->status_code_subclasses['1.8']['title'] = "Bad sender's system address";

    254. 

  254. 		$this->status_code_subclasses['1.8']['descr'] =  "The sender's system specified in the address does not exist or is incapable of accepting return mail.  For domain names, this means the address portion to the right of the @ is invalid for mail. ";

    255. 

  255. 		

    256. 

  256. 		$this->status_code_subclasses['2.0']['title'] = "Other or undefined mailbox status";

    257. 

  257. 		$this->status_code_subclasses['2.0']['descr'] =  "The mailbox exists, but something about the destination mailbox has caused the sending of this DSN.";

    258. 

  258. 		

    259. 

  259. 		$this->status_code_subclasses['2.1']['title'] = "Mailbox disabled, not accepting messages";

    260. 

  260. 		$this->status_code_subclasses['2.1']['descr'] =  "The mailbox exists, but is not accepting messages.  This may be a permanent error if the mailbox will never be re-enabled or a transient error if the mailbox is only temporarily disabled.";

    261. 

  261. 		

    262. 

  262. 		$this->status_code_subclasses['2.2']['title'] = "Mailbox full";

    263. 

  263. 		$this->status_code_subclasses['2.2']['descr'] =  "The mailbox is full because the user has exceeded a per-mailbox administrative quota or physical capacity.  The general semantics implies that the recipient can delete messages to make more space available.  This code should be used as a persistent transient failure.";

    264. 

  264. 		

    265. 

  265. 		$this->status_code_subclasses['2.3']['title'] = "Message length exceeds administrative limit";

    266. 

  266. 		$this->status_code_subclasses['2.2']['descr'] =  "A per-mailbox administrative message length limit has been exceeded.  This status code should be used when the per-mailbox message length limit is less than the general system limit.  This code should be used as a permanent failure.";

    267. 

  267. 		

    268. 

  268. 		$this->status_code_subclasses['2.4']['title'] = "Mailing list expansion problem";

    269. 

  269. 		$this->status_code_subclasses['2.3']['descr'] =  "The mailbox is a mailing list address and the mailing list was unable to be expanded.  This code may represent a permanent failure or a persistent transient failure. ";

    270. 

  270. 		

    271. 

  271. 		$this->status_code_subclasses['3.0']['title'] = "Other or undefined mail system status";

    272. 

  272. 		$this->status_code_subclasses['3.0']['descr'] =  "The destination system exists and normally accepts mail, but something about the system has caused the generation of this DSN.";

    273. 

  273. 		

    274. 

  274. 		$this->status_code_subclasses['3.1']['title'] = "Mail system full";

    275. 

  275. 		$this->status_code_subclasses['3.1']['descr'] =  "Mail system storage has been exceeded.  The general semantics imply that the individual recipient may not be able to delete material to make room for additional messages.  This is useful only as a persistent transient error.";

    276. 

  276. 		

    277. 

  277. 		$this->status_code_subclasses['3.2']['title'] = "System not accepting network messages";

    278. 

  278. 		$this->status_code_subclasses['3.2']['descr'] =  "The host on which the mailbox is resident is not accepting messages.  Examples of such conditions include an immanent shutdown, excessive load, or system maintenance.  This is useful for both permanent and permanent transient errors. ";

    279. 

  279. 		

    280. 

  280. 		$this->status_code_subclasses['3.3']['title'] = "System not capable of selected features";

    281. 

  281. 		$this->status_code_subclasses['3.3']['descr'] =  "Selected features specified for the message are not supported by the destination system.  This can occur in gateways when features from one domain cannot be mapped onto the supported feature in another.";

    282. 

  282. 		

    283. 

  283. 		$this->status_code_subclasses['3.4']['title'] = "Message too big for system";

    284. 

  284. 		$this->status_code_subclasses['3.4']['descr'] =  "The message is larger than per-message size limit.  This limit may either be for physical or administrative reasons. This is useful only as a permanent error.";

    285. 

  285. 		

    286. 

  286. 		$this->status_code_subclasses['3.5']['title'] = "System incorrectly configured";

    287. 

  287. 		$this->status_code_subclasses['3.5']['descr'] =  "The system is not configured in a manner which will permit it to accept this message.";

    288. 

  288. 		

    289. 

  289. 		$this->status_code_subclasses['4.0']['title'] = "Other or undefined network or routing status";

    290. 

  290. 		$this->status_code_subclasses['4.0']['descr'] =  "Something went wrong with the networking, but it is not clear what the problem is, or the problem cannot be well expressed with any of the other provided detail codes.";

    291. 

  291. 		

    292. 

  292. 		$this->status_code_subclasses['4.1']['title'] = "No answer from host";

    293. 

  293. 		$this->status_code_subclasses['4.1']['descr'] =  "The outbound connection attempt was not answered, either because the remote system was busy, or otherwise unable to take a call.  This is useful only as a persistent transient error.";

    294. 

  294. 		

    295. 

  295. 		$this->status_code_subclasses['4.2']['title'] = "Bad connection";

    296. 

  296. 		$this->status_code_subclasses['4.2']['descr'] =  "The outbound connection was established, but was otherwise unable to complete the message transaction, either because of time-out, or inadequate connection quality. This is useful only as a persistent transient error.";

    297. 

  297. 		

    298. 

  298. 		$this->status_code_subclasses['4.3']['title'] = "Directory server failure";

    299. 

  299. 		$this->status_code_subclasses['4.3']['descr'] =  "The network system was unable to forward the message, because a directory server was unavailable.  This is useful only as a persistent transient error. The inability to connect to an Internet DNS server is one example of the directory server failure error. ";

    300. 

  300. 		

    301. 

  301. 		$this->status_code_subclasses['4.4']['title'] = "Unable to route";

    302. 

  302. 		$this->status_code_subclasses['4.4']['descr'] =  "The mail system was unable to determine the next hop for the message because the necessary routing information was unavailable from the directory server. This is useful for both permanent and persistent transient errors.  A DNS lookup returning only an SOA (Start of Administration) record for a domain name is one example of the unable to route error.";

    303. 

  303. 		

    304. 

  304. 		$this->status_code_subclasses['4.5']['title'] = "Mail system congestion";

    305. 

  305. 		$this->status_code_subclasses['4.5']['descr'] =  "The mail system was unable to deliver the message because the mail system was congested. This is useful only as a persistent transient error.";

    306. 

  306. 		

    307. 

  307. 		$this->status_code_subclasses['4.6']['title'] = "Routing loop detected";

    308. 

  308. 		$this->status_code_subclasses['4.6']['descr'] =  "A routing loop caused the message to be forwarded too many times, either because of incorrect routing tables or a user forwarding loop. This is useful only as a persistent transient error.";

    309. 

  309. 		

    310. 

  310. 		$this->status_code_subclasses['4.7']['title'] = "Delivery time expired";

    311. 

  311. 		$this->status_code_subclasses['4.7']['descr'] =  "The message was considered too old by the rejecting system, either because it remained on that host too long or because the time-to-live value specified by the sender of the message was exceeded. If possible, the code for the actual problem found when delivery was attempted should be returned rather than this code.  This is useful only as a persistent transient error.";

    312. 

  312. 		

    313. 

  313. 		$this->status_code_subclasses['5.0']['title'] = "Other or undefined protocol status";

    314. 

  314. 		$this->status_code_subclasses['5.0']['descr'] =  "Something was wrong with the protocol necessary to deliver the message to the next hop and the problem cannot be well expressed with any of the other provided detail codes.";

    315. 

  315. 		

    316. 

  316. 		$this->status_code_subclasses['5.1']['title'] = "Invalid command";

    317. 

  317. 		$this->status_code_subclasses['5.1']['descr'] =  "A mail transaction protocol command was issued which was either out of sequence or unsupported.  This is useful only as a permanent error.";

    318. 

  318. 		

    319. 

  319. 		$this->status_code_subclasses['5.2']['title'] = "Syntax error";

    320. 

  320. 		$this->status_code_subclasses['5.2']['descr'] =  "A mail transaction protocol command was issued which could not be interpreted, either because the syntax was wrong or the command is unrecognized. This is useful only as a permanent error.";

    321. 

  321. 		

    322. 

  322. 		$this->status_code_subclasses['5.3']['title'] = "Too many recipients";

    323. 

  323. 		$this->status_code_subclasses['5.3']['descr'] =  "More recipients were specified for the message than could have been delivered by the protocol.  This error should normally result in the segmentation of the message into two, the remainder of the recipients to be delivered on a subsequent delivery attempt.  It is included in this list in the event that such segmentation is not possible.";

    324. 

  324. 		

    325. 

  325. 		$this->status_code_subclasses['5.4']['title'] = "Invalid command arguments";

    326. 

  326. 		$this->status_code_subclasses['5.4']['descr'] =  "A valid mail transaction protocol command was issued with invalid arguments, either because the arguments were out of range or represented unrecognized features. This is useful only as a permanent error. ";

    327. 

  327. 		

    328. 

  328. 		$this->status_code_subclasses['5.5']['title'] = "Wrong protocol version";

    329. 

  329. 		$this->status_code_subclasses['5.5']['descr'] =  "A protocol version mis-match existed which could not be automatically resolved by the communicating parties.";

    330. 

  330. 		

    331. 

  331. 		$this->status_code_subclasses['6.0']['title'] = "Other or undefined media error";

    332. 

  332. 		$this->status_code_subclasses['6.0']['descr'] =  "Something about the content of a message caused it to be considered undeliverable and the problem cannot be well expressed with any of the other provided detail codes. ";

    333. 

  333. 		

    334. 

  334. 		$this->status_code_subclasses['6.1']['title'] = "Media not supported";

    335. 

  335. 		$this->status_code_subclasses['6.1']['descr'] =  "The media of the message is not supported by either the delivery protocol or the next system in the forwarding path. This is useful only as a permanent error.";

    336. 

  336. 		

    337. 

  337. 		$this->status_code_subclasses['6.2']['title'] = "Conversion required and prohibited";

    338. 

  338. 		$this->status_code_subclasses['6.2']['descr'] =  "The content of the message must be converted before it can be delivered and such conversion is not permitted.  Such prohibitions may be the expression of the sender in the message itself or the policy of the sending host.";

    339. 

  339. 		

    340. 

  340. 		$this->status_code_subclasses['6.3']['title'] = "Conversion required but not supported";

    341. 

  341. 		$this->status_code_subclasses['6.3']['descr'] =  "The message content must be converted to be forwarded but such conversion is not possible or is not practical by a host in the forwarding path.  This condition may result when an ESMTP gateway supports 8bit transport but is not able to downgrade the message to 7 bit as required for the next hop.";

    342. 

  342. 		

    343. 

  343. 		$this->status_code_subclasses['6.4']['title'] = "Conversion with loss performed";

    344. 

  344. 		$this->status_code_subclasses['6.4']['descr'] =  "This is a warning sent to the sender when message delivery was successfully but when the delivery required a conversion in which some data was lost.  This may also be a permanant error if the sender has indicated that conversion with loss is prohibited for the message.";

    345. 

  345. 		

    346. 

  346. 		$this->status_code_subclasses['6.5']['title'] = "Conversion Failed";

    347. 

  347. 		$this->status_code_subclasses['6.5']['descr'] =  "A conversion was required but was unsuccessful.  This may be useful as a permanent or persistent temporary notification.";

    348. 

  348. 		

    349. 

  349. 		$this->status_code_subclasses['7.0']['title'] = "Other or undefined security status";

    350. 

  350. 		$this->status_code_subclasses['7.0']['descr'] =  "Something related to security caused the message to be returned, and the problem cannot be well expressed with any of the other provided detail codes.  This status code may also be used when the condition cannot be further described because of security policies in force.";

    351. 

  351. 		

    352. 

  352. 		$this->status_code_subclasses['7.1']['title'] = "Delivery not authorized, message refused";

    353. 

  353. 		$this->status_code_subclasses['7.1']['descr'] =  "The sender is not authorized to send to the destination. This can be the result of per-host or per-recipient filtering.  This memo does not discuss the merits of any such filtering, but provides a mechanism to report such. This is useful only as a permanent error.";

    354. 

  354. 		

    355. 

  355. 		$this->status_code_subclasses['7.2']['title'] = "Mailing list expansion prohibited";

    356. 

  356. 		$this->status_code_subclasses['7.2']['descr'] =  "The sender is not authorized to send a message to the intended mailing list. This is useful only as a permanent error.";

    357. 

  357. 		

    358. 

  358. 		$this->status_code_subclasses['7.3']['title'] = "Security conversion required but not possible";

    359. 

  359. 		$this->status_code_subclasses['7.3']['descr'] =  "A conversion from one secure messaging protocol to another was required for delivery and such conversion was not possible. This is useful only as a permanent error. ";

    360. 

  360. 		

    361. 

  361. 		$this->status_code_subclasses['7.4']['title'] = "Security features not supported";

    362. 

  362. 		$this->status_code_subclasses['7.4']['descr'] =  "A message contained security features such as secure authentication which could not be supported on the delivery protocol. This is useful only as a permanent error.";

    363. 

  363. 		

    364. 

  364. 		$this->status_code_subclasses['7.5']['title'] = "Cryptographic failure";

    365. 

  365. 		$this->status_code_subclasses['7.5']['descr'] =  "A transport system otherwise authorized to validate or decrypt a message in transport was unable to do so because necessary information such as key was not available or such information was invalid.";

    366. 

  366. 		

    367. 

  367. 		$this->status_code_subclasses['7.6']['title'] = "Cryptographic algorithm not supported";

    368. 

  368. 		$this->status_code_subclasses['7.6']['descr'] =  "A transport system otherwise authorized to validate or decrypt a message was unable to do so because the necessary algorithm was not supported. ";

    369. 

  369. 		

    370. 

  370. 		$this->status_code_subclasses['7.7']['title'] = "Message integrity failure";

    371. 

  371. 		$this->status_code_subclasses['7.7']['descr'] =  "A transport system otherwise authorized to validate a message was unable to do so because the message was corrupted or altered.  This may be useful as a permanent, transient persistent, or successful delivery code.";

    372. 

  372. 		

    373. 

  373. 	}

    374. 

  374. 

    375. 

  375. 	

    376. 

  376. 	

    377. 

  377. 

    378. 

  378. 	// this is the most commonly used public method

    379. 

  379. 	// quick and dirty

    380. 

  380. 	// useage: $multiArray = Bouncehandler::get_the_facts($strEmail);

    381. 

  381. 	function get_the_facts($eml){

    382. 

  382. 		// fluff up the email

    383. 

  383. 		$bounce = BounceHandler::init_bouncehandler($eml);

    384. 

  384. 		list($head, $body) = preg_split("/\r\n\r\n/", $bounce, 2);

    385. 

  385. 		$head_hash = BounceHandler::parse_head($head);

    386. 

  386. 

    387. 

  387. 		// initialize output variable

    388. 

  388. 		$output[0]['recipient'] = "";

    389. 

  389. 		$output[0]['status'] = "";

    390. 

  390. 		$output[0]['action'] = "";

    391. 

  391. 

    392. 

  392. 		// sanity check.

    393. 

  393. 		if(!BounceHandler::is_a_bounce($head_hash)){

    394. 

  394. 			return $output;

    395. 

  395. 		}

    396. 

  396. 

    397. 

  397. 		// parse the email into data structures

    398. 

  398. 		$boundary = $head_hash['Content-type']['boundary'];

    399. 

  399. 		$mime_sections = BounceHandler::parse_body_into_mime_sections($body, $boundary);

    400. 

  400. 		$arrBody = explode("\r\n", $body);

    401. 

  401. 

    402. 

  402. 		// now we try all our weird text parsing methods

    403. 

  403. 		if (preg_match("/auto.{0,20}reply|vacation|(out|away|on holiday).*office/i", $head_hash['Subject'])){

    404. 

  404. 		    // looks like a vacation autoreply, ignoring

    405. 

  405. 

    406. 

  406. 			$output[0]['action'] = 'autoreply';

    407. 

  407. 		}

    408. 

  408. 		else if (BounceHandler::is_RFC1892_multipart_report($head_hash) === TRUE){

    409. 

  409. 			$rpt_hash = BounceHandler::parse_machine_parsable_body_part($mime_sections['machine_parsable_body_part']);

    410. 

  410. 			for($i=0; $i<count($rpt_hash['per_recipient']); $i++){

    411. 

  411. 				$output[$i]['recipient'] = BounceHandler::get_recipient($rpt_hash['per_recipient'][$i]);

    412. 

  412. 				$output[$i]['status'] = $rpt_hash['per_recipient'][$i]['Status'];

    413. 

  413. 				$output[$i]['action'] = $rpt_hash['per_recipient'][$i]['Action'];

    414. 

  414. 			}

    415. 

  415. 		}

    416. 

  416. 		else if(isset($head_hash['X-failed-recipients'])) {

    417. 

  417. 			//  Busted Exim MTA

    418. 

  418. 			//  Up to 50 email addresses can be listed on each header.

    419. 

  419. 			//  There can be multiple X-Failed-Recipients: headers. - (not supported)

    420. 

  420. 			$arrFailed = explode(',', $head_hash['X-failed-recipients']);

    421. 

  421. 			for($j=0; $j<count($arrFailed); $j++){

    422. 

  422. 				$output[$j]['recipient'] = trim($arrFailed[$j]);

    423. 

  423. 				$output[$j]['status'] = BounceHandler::get_status_code_from_text($output[$j]['recipient'], $arrBody,0);

    424. 

  424. 				$output[$j]['action'] = BounceHandler::get_action_from_status_code($output[$j]['status']);

    425. 

  425. 			}

    426. 

  426. 		}

    427. 

  427. 		else if(!empty($boundary) && BounceHandler::is_a_bounce($head_hash)){

    428. 

  428. 			// oh god it could be anything, but at least it has mime parts, so let's try anyway

    429. 

  429. 			$arrFailed = BounceHandler::find_email_addresses($mime_sections['first_body_part']);

    430. 

  430. 			for($j=0; $j<count($arrFailed); $j++){

    431. 

  431. 				$output[$j]['recipient'] = trim($arrFailed[$j]);

    432. 

  432. 				$output[$j]['status'] = BounceHandler::get_status_code_from_text($output[$j]['recipient'], $arrBody,0);

    433. 

  433. 				$output[$j]['action'] = BounceHandler::get_action_from_status_code($output[$j]['status']);

    434. 

  434. 			}

    435. 

  435. 		}

    436. 

  436. 		else if(BounceHandler::is_a_bounce($head_hash)){

    437. 

  437. 			// last ditch attempt

    438. 

  438. 			// could possibly produce erroneous output, or be very resource consuming,

    439. 

  439. 			// so be careful.  You should comment out this section if you are very concerned

    440. 

  440. 			// about 100% accuracy or if you want very fast performance.

    441. 

  441. 			// Leave it turned on if you know that all messages to be analyzed are bounces.

    442. 

  442. 			$arrFailed = BounceHandler::find_email_addresses($body);

    443. 

  443. 			for($j=0; $j<count($arrFailed); $j++){

    444. 

  444. 				$output[$j]['recipient'] = trim($arrFailed[$j]);

    445. 

  445. 				$output[$j]['status'] = BounceHandler::get_status_code_from_text($output[$j]['recipient'], $arrBody,0);

    446. 

  446. 				$output[$j]['action'] = BounceHandler::get_action_from_status_code($output[$j]['status']);

    447. 

  447. 			}

    448. 

  448. 		}

    449. 

  449. 		// else if()..... add a parser for your busted-ass MTA here

    450. 

  450. 		return $output;

    451. 

  451. 	}

    452. 

  452. 

    453. 

  453. 	// general purpose recursive heuristic function

    454. 

  454. 	// to try to extract useful info from the bounces produced by busted MTAs

    455. 

  455. 	function get_status_code_from_text($recipient, $arrBody, $index){

    456. 

  456. 		for($i=$index; $i<count($arrBody); $i++){

    457. 

  457. 			$line = trim($arrBody[$i]);

    458. 

  458. 

    459. 

  459. 			/******** recurse into the email if you find the recipient ********/

    460. 

  460. 			if(stristr($line, $recipient)!==FALSE){

    461. 

  461. 				// the status code MIGHT be in the next few lines after the recipient line,

    462. 

  462. 				// depending on the message from the foreign host... What a laugh riot!

    463. 

  463. 				$output = BounceHandler::get_status_code_from_text($recipient, $arrBody, $i+1);

    464. 

  464. 				if($output){

    465. 

  465. 					return $output;

    466. 

  466. 				}

    467. 

  467. 

    468. 

  468. 			}

    469. 

  469. 

    470. 

  470. 			/******** exit conditions ********/

    471. 

  471. 			// if it's the end of the human readable part in this stupid bounce

    472. 

  472. 			if(stristr($line, '------ This is a copy of the message')!==FALSE){

    473. 

  473. 				return '';

    474. 

  474. 			}

    475. 

  475. 			//if we see an email address other than our current recipient's,

    476. 

  476. 			if(count(BounceHandler::find_email_addresses($line))>=1

    477. 

  477. 			   && stristr($line, $recipient)===FALSE

    478. 

  478. 			   && strstr($line, 'FROM:<')===FALSE){ // Kanon added this line because Hotmail puts the e-mail address too soon and there actually is error message stuff after it.

    479. 

  479. 				return '';

    480. 

  480. 			}

    481. 

  481. 			/******** pattern matching ********/

    482. 

  482. 			if(    stristr($line, 'no such address')!==FALSE

    483. 

  483.                ||  stristr($line, 'Recipient address rejected')!==FALSE

    484. 

  484.                ||  stristr($line, 'User unknown in virtual alias table')!==FALSE){

    485. 

  485. 				return  '5.1.1';

    486. 

  486. 			}

    487. 

  487. 			else if(stristr($line, 'unrouteable mail domain')!==FALSE

    488. 

  488. 				 || stristr($line, 'Esta casilla ha expirado por falta de uso')!==FALSE){

    489. 

  489. 				return  '5.1.2';

    490. 

  490. 			}

    491. 

  491. 			else if(stristr($line, 'mailbox is full')!==FALSE

    492. 

  492. 				||  stristr($line, 'Mailbox quota usage exceeded')!==FALSE

    493. 

  493. 				||  stristr($line, 'User mailbox exceeds allowed size')!==FALSE){

    494. 

  494. 				return  '4.2.2';

    495. 

  495. 			}

    496. 

  496. 			else if(stristr($line, 'not yet been delivered')!==FALSE){

    497. 

  497. 				return  '4.2.0';

    498. 

  498. 			}

    499. 

  499. 			else if(stristr($line, 'mailbox unavailable')!==FALSE){

    500. 

  500. 				return  '5.2.0';

    501. 

  501. 			}

    502. 

  502. 			else if(stristr($line, 'Unrouteable address')!==FALSE){

    503. 

  503. 				return  '5.4.4';

    504. 

  504. 			}

    505. 

  505. 			else if(stristr($line, 'retry timeout exceeded')!==FALSE){

    506. 

  506. 				return  '4.4.7';

    507. 

  507. 			}

    508. 

  508. 			else if(stristr($line, 'The account or domain may not exist, they may be blacklisted, or missing the proper dns entries.')!==FALSE){ // Kanon added

    509. 

  509. 				return  '5.2.0'; // I guess.... seems like 5.1.1, 5.1.2, or 5.4.4 would fit too, but 5.2.0 seemed most generic

    510. 

  510. 			}

    511. 

  511. 			else if(stristr($line, '554 TRANSACTION FAILED')!==FALSE){ // Kanon added

    512. 

  512. 				return  '5.5.4'; // I think this should be 5.7.1. "SMTP error from remote mail server after end of data: ... (HVU:B1) http://postmaster.info.aol.com/errors/554hvub1.html" -- AOL rejects messages that have links to certain sites in them.

    513. 

  513. 			}

    514. 

  514. 			else if(stristr($line, 'Status: 4.4.1')!==FALSE

    515. 

  515. 				 || stristr($line, 'delivery temporarily suspended')!==FALSE){ // Kanon added

    516. 

  516. 				return  '4.4.1';

    517. 

  517. 			}

    518. 

  518. 			else if(stristr($line, '550 OU-002')!==FALSE

    519. 

  519. 				 || stristr($line, 'Mail rejected by Windows Live Hotmail for policy reasons')!==FALSE){ // Kanon added

    520. 

  520. 				return  '5.5.0'; // Again, why isn't this 5.7.1 instead?

    521. 

  521. 			}

    522. 

  522. 			else if(stristr($line, 'PERM_FAILURE: DNS Error: Domain name not found')!==FALSE){ // Kanon added

    523. 

  523. 				return  '5.1.2'; // Not sure if this is right code. Just copied from above.

    524. 

  524. 			}

    525. 

  525. 			else if(stristr($line, 'Delivery attempts will continue to be made for')!==FALSE){ // Kanon added. From Symantec_AntiVirus_for_SMTP_Gateways@uqam.ca

    526. 

  526. 				return  '4.2.0'; // I'm not sure why Symantec delayed this message, but x.2.x means something to do with the mailbox, which seemed appropriate. x.5.x (protocol) or x.7.x (security) also seem possibly appropriate. It seems a lot of times it's x.5.x when it seems to me it should be x.7.x, so maybe x.5.x is standard when mail is rejected due to spam-like characteristics instead of x.7.x like I think it should be.

    527. 

  527. 			}

    528. 

  528. 			else if(stristr($line, '554 delivery error:')!==FALSE){

    529. 

  529. 				return  '5.5.4'; // rogers.com

    530. 

  530. 			}

    531. 

  531. 			else if(strstr ($line, '550-5.1.1')!==FALSE

    532. 

  532. 				 || stristr($line, 'This Gmail user does not exist.')!==FALSE){ // Kanon added

    533. 

  533. 				return  '5.1.1'; // Or should it be 5.5.0?

    534. 

  534. 			}

    535. 

  535.             else{

    536. 

  536.                 // end strstr tests

    537. 

  537.             }

    538. 

  538. 

    539. 

  539.             // rfc1893 return code

    540. 

  540.             if(preg_match('/([245]\.[01234567]\.[012345678])/', $line, $matches)){

    541. 

  541.                 $mycode = str_replace('.', '', $matches[1]);

    542. 

  542.                 $mycode = Bouncehandler::format_status_code($mycode);

    543. 

  543.                 return implode('.', $mycode['code']);

    544. 

  544.             }

    545. 

  545. 

    546. 

  546.             // search for RFC821 return code

    547. 

  547.             // thanks to mark.tolman@gmail.com

    548. 

  548.             // Maybe at some point it should have it's own place within the main parsing scheme (at line 88)

    549. 

  549.             if(preg_match('/\]?: ([45][01257][012345]) /', $line, $matches)

    550. 

  550.                || preg_match('/^([45][01257][012345]) (?:.*?)(?:denied|inactive|deactivated|rejected|disabled|unknown|no such|not (?:our|activated|a valid))+/i', $line, $matches))

    551. 

  551.             {

    552. 

  552.                 $mycode = $matches[1];

    553. 

  553.                 // map common codes to new rfc values

    554. 

  554.                 if($mycode == '450' || $mycode == '550' || $mycode == '551' || $mycode == '554'){

    555. 

  555.                     $mycode = '511';

    556. 

  556.                 } else if($mycode == '452' || $mycode == '552'){

    557. 

  557.                     $mycode = '422';

    558. 

  558.                 } else if ($mycode == '421'){

    559. 

  559.                     $mycode = '432';

    560. 

  560.                 }

    561. 

  561.                 $mycode = Bouncehandler::format_status_code($mycode);

    562. 

  562.                 return implode('.', $mycode['code']);

    563. 

  563.             }

    564. 

  564. 

    565. 

  565. 		}

    566. 

  566. 		return '';

    567. 

  567. 	}

    568. 

  568. 

    569. 

  569. 	function init_bouncehandler($blob, $format='string'){

    570. 

  570. 	    if($format=='xml_array'){

    571. 

  571. 	        $strEmail = "";

    572. 

  572. 			$out = "";

    573. 

  573. 	        for($i=0; $i<$blob; $i++){

    574. 

  574. 	            $out = preg_replace("/<HEADER>/i", "", $blob[$i]);

    575. 

  575. 	            $out = preg_replace("/</HEADER>/i", "", $out);

    576. 

  576. 	            $out = preg_replace("/<MESSAGE>/i", "", $out);

    577. 

  577. 	            $out = preg_replace("/</MESSAGE>/i", "", $out);

    578. 

  578. 	            $out = rtrim($out) . "\r\n";

    579. 

  579. 	            $strEmail .= $out;

    580. 

  580. 	        }

    581. 

  581. 	    }

    582. 

  582. 	    else if($format=='string'){

    583. 

  583. 	        $strEmail = str_replace("\r\n", "\n", $blob);

    584. 

  584. 	        $strEmail = str_replace("\n", "\r\n", $strEmail);

    585. 

  585. 	    }

    586. 

  586. 	    else if($format=='array'){

    587. 

  587. 	        $strEmail = "";

    588. 

  588. 	        for($i=0; $i<$blob; $i++){

    589. 

  589. 	            $strEmail .= rtrim($blob[$i]) . "\r\n";

    590. 

  590. 	        }

    591. 

  591. 	    }

    592. 

  592. 	    return $strEmail;

    593. 

  593. 	}

    594. 

  594. 

    595. 

  595. 	function is_RFC1892_multipart_report($head_hash){

    596. 

  596. 	    return $head_hash['Content-type']['type']=='multipart/report'

    597. 

  597. 	       &&  $head_hash['Content-type']['report-type']=='delivery-status'

    598. 

  598. 	       && $head_hash['Content-type']['boundary']!=='';

    599. 

  599. 	}

    600. 

  600. 

    601. 

  601. 	function parse_head($headers){

    602. 

  602. 	    if(!is_array($headers)) $headers = explode("\r\n", $headers);

    603. 

  603. 	    $hash = BounceHandler::standard_parser($headers);

    604. 

  604. 	    // get a little more complex

    605. 

  605. 	    $arrRec = explode('|', $hash['Received']);

    606. 

  606. 	    $hash['Received']= $arrRec;

    607. 

  607. 	    if($hash['Content-type']){//preg_match('/Multipart\/Report/i', $hash['Content-type'])){

    608. 

  608. 	        $multipart_report = explode (';', $hash['Content-type']);

    609. 

  609. 	        $hash['Content-type']='';

    610. 

  610. 	        $hash['Content-type']['type'] = strtolower($multipart_report[0]);

    611. 

  611. 	        foreach($multipart_report as $mr){

    612. 

  612. 	            if(preg_match('/([^=.]*?)=(.*)/i', $mr, $matches)){

    613. 

  613.                 // didn't work when the content-type boundary ID contained an equal sign,

    614. 

  614.                 // that exists in bounces from many Exchange servers

    615. 

  615. 	            //if(preg_match('/([a-z]*)=(.*)?/i', $mr, $matches)){

    616. 

  616. 	                $hash['Content-type'][strtolower(trim($matches[1]))]= str_replace('"','',$matches[2]);

    617. 

  617. 	            }

    618. 

  618. 	        }

    619. 

  619. 	    }

    620. 

  620. 	    return $hash;

    621. 

  621. 	}

    622. 

  622. 

    623. 

  623. 	function parse_body_into_mime_sections($body, $boundary){

    624. 

  624. 	    if(!$boundary) return array();

    625. 

  625. 	    if(is_array($body)) $body = implode("\r\n", $body);

    626. 

  626. 	    $body = explode($boundary, $body);

    627. 

  627. 	    $mime_sections['first_body_part'] = $body[1];

    628. 

  628. 	    $mime_sections['machine_parsable_body_part'] = $body[2];

    629. 

  629. 	    $mime_sections['returned_message_body_part'] = $body[3];

    630. 

  630. 	    return $mime_sections;

    631. 

  631. 	}

    632. 

  632. 

    633. 

  633. 

    634. 

  634. 	function standard_parser($content){ // associative array orstr

    635. 

  635. 	    // receives email head as array of lines

    636. 

  636. 	    // simple parse (Entity: value\n)

    637. 

  637. 		$entity = "";

    638. 

  638. 	

    639. 

  639. 		

    640. 

  640. 	    if(!is_array($content)) $content = explode("\r\n", $content);

    641. 

  641. 	    foreach($content as $line){

    642. 

  642. 	        if(preg_match('/([^\s.]*):\s(.*)/', $line, $array)){

    643. 

  643. 	            $entity = ucfirst(strtolower($array[1]));

    644. 

  644. 	            if(empty($hash[$entity]))

    645. 

  645. 				{

    646. 

  646. 	                $hash[$entity] = trim($array[2]);

    647. 

  647. 	            }

    648. 

  648. 	            else if($hash['Received']){

    649. 

  649. 	                // grab extra Received headers :(

    650. 

  650. 	                // pile it on with pipe delimiters,

    651. 

  651. 	                // oh well, SMTP is broken in this way

    652. 

  652. 	                if ($entity and $array[2] and $array[2] != $hash[$entity]){

    653. 

  653. 	                    $hash[$entity] .= "|" . trim($array[2]);

    654. 

  654. 	                }

    655. 

  655. 	            }

    656. 

  656. 	        }

    657. 

  657. 	        else{

    658. 

  658. 	            if ($entity){

    659. 

  659. 	                $hash[$entity] .= " $line";

    660. 

  660. 	            }

    661. 

  661. 	        }

    662. 

  662. 	    }

    663. 

  663. 	    return $hash;

    664. 

  664. 	}

    665. 

  665. 

    666. 

  666. 	function parse_machine_parsable_body_part($str){

    667. 

  667. 	    //Per-Message DSN fields

    668. 

  668. 	    $hash = BounceHandler::parse_dsn_fields($str);

    669. 

  669. 	    $hash['mime_header'] = BounceHandler::standard_parser($hash['mime_header']);

    670. 

  670. 	    $hash['per_message'] = BounceHandler::standard_parser($hash['per_message']);

    671. 

  671. 	    if(isset($hash['per_message']['X-postfix-sender']) && $hash['per_message']['X-postfix-sender'] ){

    672. 

  672. 	        $arr = explode (';', $hash['per_message']['X-postfix-sender']);

    673. 

  673. 	        $hash['per_message']['X-postfix-sender']='';

    674. 

  674. 	        $hash['per_message']['X-postfix-sender']['type'] = trim($arr[0]);

    675. 

  675. 	        $hash['per_message']['X-postfix-sender']['addr'] = trim($arr[1]);

    676. 

  676. 	    }

    677. 

  677. 	    if($hash['per_message']['Reporting-mta']){

    678. 

  678. 	        $arr = explode (';', $hash['per_message']['Reporting-mta']);

    679. 

  679. 	        $hash['per_message']['Reporting-mta']='';

    680. 

  680. 	        $hash['per_message']['Reporting-mta']['type'] = trim($arr[0]);

    681. 

  681. 	        $hash['per_message']['Reporting-mta']['addr'] = trim($arr[1]);

    682. 

  682. 	    }

    683. 

  683. 	    //Per-Recipient DSN fields

    684. 

  684. 	    for($i=0; $i<count($hash['per_recipient']); $i++){

    685. 

  685. 	        $temp = BounceHandler::standard_parser(explode("\r\n", $hash['per_recipient'][$i]));

    686. 

  686. 	        $arr = explode (';', $temp['Final-recipient']);

    687. 

  687. 	        $temp['Final-recipient']='';

    688. 

  688. 	        $temp['Final-recipient']['type'] = trim($arr[0]);

    689. 

  689. 	        $temp['Final-recipient']['addr'] = trim($arr[1]);

    690. 

  690. 	        $arr = explode (';', $temp['Original-recipient']);

    691. 

  691. 	        $temp['Original-recipient']='';

    692. 

  692. 	        $temp['Original-recipient']['type'] = trim($arr[0]);

    693. 

  693. 	        $temp['Original-recipient']['addr'] = trim($arr[1]);

    694. 

  694. 	        $arr = explode (';', $temp['Diagnostic-code']);

    695. 

  695. 	        $temp['Diagnostic-code']='';

    696. 

  696. 	        $temp['Diagnostic-code']['type'] = trim($arr[0]);

    697. 

  697. 	        $temp['Diagnostic-code']['text'] = trim($arr[1]);

    698. 

  698. 			// now this is wierd: plenty of times you see the status code is a permanent failure,

    699. 

  699. 			// but the diagnostic code is a temporary failure.  So we will assert the most general

    700. 

  700. 			// temporary failure in this case.

    701. 

  701. 			$ddc=''; $judgement='';

    702. 

  702. 			$ddc = BounceHandler::decode_diagnostic_code($temp['Diagnostic-code']['text']);

    703. 

  703. 			$judgement = BounceHandler::get_action_from_status_code($ddc);

    704. 

  704. 	        if($judgement == 'transient'){

    705. 

  705. 				if(stristr($temp['Action'],'failed')!==FALSE){

    706. 

  706. 					$temp['Action']='transient';

    707. 

  707. 					$temp['Status']='4.3.0';

    708. 

  708. 				}

    709. 

  709. 			}

    710. 

  710. 	        $hash['per_recipient'][$i]='';

    711. 

  711. 	        $hash['per_recipient'][$i]=$temp;

    712. 

  712. 	    }

    713. 

  713. 	    return $hash;

    714. 

  714. 	}

    715. 

  715. 

    716. 

  716. 	function get_head_from_returned_message_body_part($mime_sections){

    717. 

  717. 	    $temp = explode("\r\n\r\n", $mime_sections[returned_message_body_part]);

    718. 

  718. 	    $head = BounceHandler::standard_parser($temp[1]);

    719. 

  719. 	    $head['From'] = BounceHandler::extract_address($head['From']);

    720. 

  720. 	    $head['To'] = BounceHandler::extract_address($head['To']);

    721. 

  721. 	    return $head;

    722. 

  722. 	}

    723. 

  723. 

    724. 

  724. 	function extract_address($str){

    725. 

  725. 	    $from_stuff = preg_split('/[ \"\'\<\>:\(\)\[\]]/', $str);

    726. 

  726. 	    foreach ($from_stuff as $things){

    727. 

  727. 	        if (strpos($things, '@')!==FALSE){$from = $things;}

    728. 

  728. 	    }

    729. 

  729. 	    return $from;

    730. 

  730. 	}

    731. 

  731. 

    732. 

  732. 	function get_recipient($per_rcpt){

    733. 

  733. 	    if($per_rcpt['Original-recipient']['addr'] !== ''){

    734. 

  734. 			$recipient = $per_rcpt['Original-recipient']['addr'];

    735. 

  735. 		}

    736. 

  736. 	    else if($per_rcpt['Final-recipient']['addr'] !== ''){

    737. 

  737. 			$recipient = $per_rcpt['Final-recipient']['addr'];

    738. 

  738. 		}

    739. 

  739. 		$recipient = str_replace('<', '', $recipient);

    740. 

  740. 		$recipient = str_replace('>', '', $recipient);

    741. 

  741. 		return $recipient;

    742. 

  742. 	}

    743. 

  743. 

    744. 

  744. 	function parse_dsn_fields($dsn_fields){

    745. 

  745. 	    if(!is_array($dsn_fields)) $dsn_fields = explode("\r\n\r\n", $dsn_fields);

    746. 

  746. 	    $j = 0;

    747. 

  747.         reset($dsn_fields);

    748. 

  748. 	    for($i=0; $i<count($dsn_fields); $i++){

    749. 

  749. 	        if($i==0)

    750. 

  750.                 $hash['mime_header'] = $dsn_fields[0];

    751. 

  751. 	        elseif($i==1 && !preg_match('/(Final|Original)-Recipient/',$dsn_fields[1])) {

    752. 

  752.                 // some mta's don't output the per_message part, which means

    753. 

  753.                 // the second element in the array should really be

    754. 

  754.                 // per_recipient - test with Final-Recipient - which should always

    755. 

  755.                 // indicate that the part is a per_recipient part

    756. 

  756. 				$hash['per_message'] = $dsn_fields[1];

    757. 

  757. 			}

    758. 

  758. 	        else {

    759. 

  759. 	            if($dsn_fields[$i] == '--') continue;

    760. 

  760. 	            $hash['per_recipient'][$j] = $dsn_fields[$i];

    761. 

  761. 	            $j++;

    762. 

  762. 	        }

    763. 

  763. 	    }

    764. 

  764. 	    return $hash;

    765. 

  765. 	}

    766. 

  766. 

    767. 

  767. 	function format_status_code($code){

    768. 

  768. 		$ret = "";

    769. 

  769. 	    if(preg_match('/([245]\.[01234567]\.[012345678])(.*)/', $code, $matches)){

    770. 

  770. 	        $ret['code'] = $matches[1];

    771. 

  771. 	        $ret['text'] = $matches[2];

    772. 

  772. 	    }

    773. 

  773. 	    else if(preg_match('/([245][01234567][012345678])(.*)/', $code, $matches)){

    774. 

  774. 	        preg_match_all("/./", $matches[1], $out);

    775. 

  775. 	        $ret['code'] = $out[0];

    776. 

  776. 	        $ret['text'] = $matches[2];

    777. 

  777. 	    }

    778. 

  778. 	    return $ret;

    779. 

  779. 	}

    780. 

  780. 

    781. 

  781. 	function fetch_status_messages($code){

    782. 

  782. 	    include_once ("rfc1893.error.codes.php");

    783. 

  783. 	    $ret = BounceHandler::format_status_code($code);

    784. 

  784. 	    $arr = explode('.', $ret['code']);

    785. 

  785. 	    $str = "<P><B>". $this->status_code_classes[$arr[0]]['title'] . "</B> - " .$this->status_code_classes[$arr[0]]['descr']. "  <B>". $this->status_code_subclasses[$arr[1].".".$arr[2]]['title'] . "</B> - " .$this->status_code_subclasses[$arr[1].".".$arr[2]]['descr']. "</P>";

    786. 

  786. 	    return $str;

    787. 

  787. 	}

    788. 

  788. 

    789. 

  789. 	function get_action_from_status_code($code){

    790. 

  790. 		if($code=='') return '';

    791. 

  791. 	    $ret = BounceHandler::format_status_code($code);

    792. 

  792. 	    $stat = $ret['code'][0];

    793. 

  793. 		switch($stat){

    794. 

  794. 			case(2):

    795. 

  795. 				return 'success';

    796. 

  796. 				break;

    797. 

  797. 			case(4):

    798. 

  798. 				return 'transient';

    799. 

  799. 				break;

    800. 

  800. 			case(5):

    801. 

  801. 				return 'failed';

    802. 

  802. 				break;

    803. 

  803. 			default:

    804. 

  804. 				return '';

    805. 

  805. 				break;

    806. 

  806. 		}

    807. 

  807. 	}

    808. 

  808. 

    809. 

  809. 	function decode_diagnostic_code($dcode){

    810. 

  810. 	    if(preg_match("/(\d\.\d\.\d)\s/", $dcode, $array)){

    811. 

  811. 	        return $array[1];

    812. 

  812. 	    }

    813. 

  813. 	    else if(preg_match("/(\d\d\d)\s/", $dcode, $array)){

    814. 

  814. 	        return $array[1];

    815. 

  815. 	    }

    816. 

  816. 	}

    817. 

  817. 

    818. 

  818. 	function is_a_bounce($head_hash){

    819. 

  819. 		if(preg_match("/(mail delivery failed|failure notice|warning: message|delivery status notif|delivery failure|delivery problem|spam eater|returned mail|undeliverable|returned mail|delivery errors|mail status report|mail system error|failure delivery|delivery notification|delivery has failed|undelivered mail|returned email|returning message to sender|returned to sender|message delayed|mdaemon notification|mailserver notification|mail delivery system|nondeliverable mail|mail transaction failed)|auto.{0,20}reply|vacation|(out|away|on holiday).*office/i", $head_hash['Subject'])) return true;

    820. 

  820. 

    821. 

  821.  		if(preg_match('/auto_reply/',$head_hash['Precedence'])) return true;

    822. 

  822. 

    823. 

  823. 		if(preg_match("/^(postmaster|mailer-daemon)\@?/i", $head_hash['From'])) return true;

    824. 

  824. 		return false;

    825. 

  825. 	}

    826. 

  826. 

    827. 

  827. 	function find_email_addresses($first_body_part){

    828. 

  828. 		// not finished yet.  This finds only one address.

    829. 

  829. 		if(preg_match("/\b([A-Z0-9._%-]+@[A-Z0-9.-]+\.[A-Z]{2,4})\b/i", $first_body_part, $matches)){

    830. 

  830. 			return array($matches[1]);

    831. 

  831. 		}

    832. 

  832. 		else

    833. 

  833. 			return array();

    834. 

  834. 	}

    835. 

  835. 

    836. 

  836. }/** END class BounceHandler **/

    837. 

  837. ?>
    838.