crm.fsf.org/20131203/files/sites/all/modules-new/civicrm/CRM/Utils/Mail/EmailProcessor.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 4.6                                                |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2015                                |
   7  +--------------------------------------------------------------------+
   8  | This file is a part of CiviCRM.                                    |
   9  |                                                                    |
  10  | CiviCRM is free software; you can copy, modify, and distribute it  |
  11  | under the terms of the GNU Affero General Public License           |
  12  | Version 3, 19 November 2007 and the CiviCRM Licensing Exception.   |
  13  |                                                                    |
  14  | CiviCRM is distributed in the hope that it will be useful, but     |
  15  | WITHOUT ANY WARRANTY; without even the implied warranty of         |
  16  | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.               |
  17  | See the GNU Affero General Public License for more details.        |
  18  |                                                                    |
  19  | You should have received a copy of the GNU Affero General Public   |
  20  | License and the CiviCRM Licensing Exception along                  |
  21  | with this program; if not, contact CiviCRM LLC                     |
  22  | at info[AT]civicrm[DOT]org. If you have questions about the        |
  23  | GNU Affero General Public License or the licensing of CiviCRM,     |
  24  | see the CiviCRM license FAQ at http://civicrm.org/licensing        |
  25  +--------------------------------------------------------------------+
  26  */
  27
  28 /**
  29  *
  30  * @package CRM
  31  * @copyright CiviCRM LLC (c) 2004-2015
  32  * $Id$
  33  *
  34  */
  35
  36 // we should consider moving these to the settings table
  37 // before the 4.1 release
  38 define('EMAIL_ACTIVITY_TYPE_ID', NULL);
  39 define('MAIL_BATCH_SIZE', 50);
  40
  41 /**
  42  * Class CRM_Utils_Mail_EmailProcessor
  43  */
  44 class CRM_Utils_Mail_EmailProcessor {
  45
  46   /**
  47    * Process the default mailbox (ie. that is used by civiMail for the bounce)
  48    *
  49    * @return bool
  50    *   Always returns true (for the api). at a later stage we should
  51    *   fix this to return true on success / false on failure etc.
  52    */
  53   public static function processBounces() {
  54     $dao = new CRM_Core_DAO_MailSettings();
  55     $dao->domain_id = CRM_Core_Config::domainID();
  56     $dao->is_default = TRUE;
  57     $dao->find();
  58
  59     while ($dao->fetch()) {
  60       self::_process(TRUE, $dao);
  61     }
  62
  63     // always returns true, i.e. never fails :)
  64     return TRUE;
  65   }
  66
  67   /**
  68    * Delete old files from a given directory (recursively)
  69    *
  70    * @param string $dir
  71    *   Directory to cleanup.
  72    * @param int $age
  73    *   Files older than this many seconds will be deleted (default: 60 days).
  74    *
  75    * @return void
  76    */
  77   public static function cleanupDir($dir, $age = 5184000) {
  78     // return early if we can’t read/write the dir
  79     if (!is_writable($dir) or !is_readable($dir) or !is_dir($dir)) {
  80       return;
  81     }
  82
  83     foreach (scandir($dir) as $file) {
  84
  85       // don’t go up the directory stack and skip new files/dirs
  86       if ($file == '.' or $file == '..') {
  87         continue;
  88       }
  89       if (filemtime("$dir/$file") > time() - $age) {
  90         continue;
  91       }
  92
  93       // it’s an old file/dir, so delete/recurse
  94       is_dir("$dir/$file") ? self::cleanupDir("$dir/$file", $age) : unlink("$dir/$file");
  95     }
  96   }
  97
  98   /**
  99    * Process the mailboxes that aren't default (ie. that aren't used by civiMail for the bounce)
 100    *
 101    * @return void
 102    */
 103   public static function processActivities() {
 104     $dao = new CRM_Core_DAO_MailSettings();
 105     $dao->domain_id = CRM_Core_Config::domainID();
 106     $dao->is_default = FALSE;
 107     $dao->find();
 108     $found = FALSE;
 109     while ($dao->fetch()) {
 110       $found = TRUE;
 111       self::_process(FALSE, $dao);
 112     }
 113     if (!$found) {
 114       CRM_Core_Error::fatal(ts('No mailboxes have been configured for Email to Activity Processing'));
 115     }
 116     return $found;
 117   }
 118
 119   /**
 120    * Process the mailbox for all the settings from civicrm_mail_settings.
 121    *
 122    * @param bool|string $civiMail if true, processing is done in CiviMail context, or Activities otherwise.
 123    *
 124    * @return void
 125    */
 126   public static function process($civiMail = TRUE) {
 127     $dao = new CRM_Core_DAO_MailSettings();
 128     $dao->domain_id = CRM_Core_Config::domainID();
 129     $dao->find();
 130
 131     while ($dao->fetch()) {
 132       self::_process($civiMail, $dao);
 133     }
 134   }
 135
 136   /**
 137    * @param $civiMail
 138    * @param CRM_Core_DAO $dao
 139    *
 140    * @throws Exception
 141    */
 142   public static function _process($civiMail, $dao) {
 143     // 0 = activities; 1 = bounce;
 144     $usedfor = $dao->is_default;
 145
 146     $emailActivityTypeId
 147       = (defined('EMAIL_ACTIVITY_TYPE_ID') && EMAIL_ACTIVITY_TYPE_ID) ? EMAIL_ACTIVITY_TYPE_ID : CRM_Core_OptionGroup::getValue(
 148         'activity_type',
 149         'Inbound Email',
 150         'name'
 151       );
 152
 153     if (!$emailActivityTypeId) {
 154       CRM_Core_Error::fatal(ts('Could not find a valid Activity Type ID for Inbound Email'));
 155     }
 156
 157     $config = CRM_Core_Config::singleton();
 158     $verpSeperator = preg_quote($config->verpSeparator);
 159     $twoDigitStringMin = $verpSeperator . '(\d+)' . $verpSeperator . '(\d+)';
 160     $twoDigitString = $twoDigitStringMin . $verpSeperator;
 161     $threeDigitString = $twoDigitString . '(\d+)' . $verpSeperator;
 162
 163     // FIXME: legacy regexen to handle CiviCRM 2.1 address patterns, with domain id and possible VERP part
 164     $commonRegex = '/^' . preg_quote($dao->localpart) . '(b|bounce|c|confirm|o|optOut|r|reply|re|e|resubscribe|u|unsubscribe)' . $threeDigitString . '([0-9a-f]{16})(-.*)?@' . preg_quote($dao->domain) . '$/';
 165     $subscrRegex = '/^' . preg_quote($dao->localpart) . '(s|subscribe)' . $twoDigitStringMin . '@' . preg_quote($dao->domain) . '$/';
 166
 167     // a common-for-all-actions regex to handle CiviCRM 2.2 address patterns
 168     $regex = '/^' . preg_quote($dao->localpart) . '(b|c|e|o|r|u)' . $twoDigitString . '([0-9a-f]{16})@' . preg_quote($dao->domain) . '$/';
 169
 170     // a tighter regex for finding bounce info in soft bounces’ mail bodies
 171     $rpRegex = '/Return-Path: ' . preg_quote($dao->localpart) . '(b)' . $twoDigitString . '([0-9a-f]{16})@' . preg_quote($dao->domain) . '/';
 172
 173     // a regex for finding bound info X-Header
 174     $rpXheaderRegex = '/X-CiviMail-Bounce: ' . preg_quote($dao->localpart) . '(b)' . $twoDigitString . '([0-9a-f]{16})@' . preg_quote($dao->domain) . '/i';
 175     // CiviMail in regex and Civimail in header !!!
 176
 177     // retrieve the emails
 178     try {
 179       $store = CRM_Mailing_MailStore::getStore($dao->name);
 180     }
 181     catch (Exception$e) {
 182       $message = ts('Could not connect to MailStore for ') . $dao->username . '@' . $dao->server . '<p>';
 183       $message .= ts('Error message: ');
 184       $message .= '<pre>' . $e->getMessage() . '</pre><p>';
 185       CRM_Core_Error::fatal($message);
 186     }
 187
 188     // process fifty at a time, CRM-4002
 189     while ($mails = $store->fetchNext(MAIL_BATCH_SIZE)) {
 190       foreach ($mails as $key => $mail) {
 191
 192         // for every addressee: match address elements if it's to CiviMail
 193         $matches = array();
 194         $action = NULL;
 195
 196         if ($usedfor == 1) {
 197           foreach ($mail->to as $address) {
 198             if (preg_match($regex, $address->email, $matches)) {
 199               list($match, $action, $job, $queue, $hash) = $matches;
 200               break;
 201               // FIXME: the below elseifs should be dropped when we drop legacy support
 202             }
 203             elseif (preg_match($commonRegex, $address->email, $matches)) {
 204               list($match, $action, $_, $job, $queue, $hash) = $matches;
 205               break;
 206             }
 207             elseif (preg_match($subscrRegex, $address->email, $matches)) {
 208               list($match, $action, $_, $job) = $matches;
 209               break;
 210             }
 211           }
 212
 213           // CRM-5471: if $matches is empty, it still might be a soft bounce sent
 214           // to another address, so scan the body for ‘Return-Path: …bounce-pattern…’
 215           if (!$matches and preg_match($rpRegex, $mail->generateBody(), $matches)) {
 216             list($match, $action, $job, $queue, $hash) = $matches;
 217           }
 218
 219           // if $matches is still empty, look for the X-CiviMail-Bounce header
 220           // CRM-9855
 221           if (!$matches and preg_match($rpXheaderRegex, $mail->generateBody(), $matches)) {
 222             list($match, $action, $job, $queue, $hash) = $matches;
 223           }
 224           // With Mandrilla, the X-CiviMail-Bounce header is produced by generateBody
 225           // is base64 encoded
 226           // Check all parts
 227           if (!$matches) {
 228             $all_parts = $mail->fetchParts();
 229             foreach ($all_parts as $k_part => $v_part) {
 230               if ($v_part instanceof ezcMailFile) {
 231                 $p_file = $v_part->__get('fileName');
 232                 $c_file = file_get_contents($p_file);
 233                 if (preg_match($rpXheaderRegex, $c_file, $matches)) {
 234                   list($match, $action, $job, $queue, $hash) = $matches;
 235                 }
 236               }
 237             }
 238           }
 239
 240           // if all else fails, check Delivered-To for possible pattern
 241           if (!$matches and preg_match($regex, $mail->getHeader('Delivered-To'), $matches)) {
 242             list($match, $action, $job, $queue, $hash) = $matches;
 243           }
 244         }
 245
 246         // preseve backward compatibility
 247         if ($usedfor == 0 || !$civiMail) {
 248           // if its the activities that needs to be processed ..
 249           $mailParams = CRM_Utils_Mail_Incoming::parseMailingObject($mail);
 250
 251           require_once 'CRM/Utils/DeprecatedUtils.php';
 252           $params = _civicrm_api3_deprecated_activity_buildmailparams($mailParams, $emailActivityTypeId);
 253
 254           $params['version'] = 3;
 255           $result = civicrm_api('activity', 'create', $params);
 256
 257           if ($result['is_error']) {
 258             $matches = FALSE;
 259             echo "Failed Processing: {$mail->subject}. Reason: {$result['error_message']}\n";
 260           }
 261           else {
 262             $matches = TRUE;
 263             echo "Processed as Activity: {$mail->subject}\n";
 264           }
 265
 266           CRM_Utils_Hook::emailProcessor('activity', $params, $mail, $result);
 267         }
 268
 269         // if $matches is empty, this email is not CiviMail-bound
 270         if (!$matches) {
 271           $store->markIgnored($key);
 272           continue;
 273         }
 274
 275         // get $replyTo from either the Reply-To header or from From
 276         // FIXME: make sure it works with Reply-Tos containing non-email stuff
 277         $replyTo = $mail->getHeader('Reply-To') ? $mail->getHeader('Reply-To') : $mail->from->email;
 278
 279         // handle the action by passing it to the proper API call
 280         // FIXME: leave only one-letter cases when dropping legacy support
 281         if (!empty($action)) {
 282           $result = NULL;
 283
 284           switch ($action) {
 285             case 'b':
 286             case 'bounce':
 287               $text = '';
 288               if ($mail->body instanceof ezcMailText) {
 289                 $text = $mail->body->text;
 290               }
 291               elseif ($mail->body instanceof ezcMailMultipart) {
 292                 if ($mail->body instanceof ezcMailMultipartRelated) {
 293                   foreach ($mail->body->getRelatedParts() as $part) {
 294                     if (isset($part->subType) and $part->subType == 'plain') {
 295                       $text = $part->text;
 296                       break;
 297                     }
 298                   }
 299                 }
 300                 else {
 301                   foreach ($mail->body->getParts() as $part) {
 302                     if (isset($part->subType) and $part->subType == 'plain') {
 303                       $text = $part->text;
 304                       break;
 305                     }
 306                   }
 307                 }
 308               }
 309
 310               if (
 311                 $text == NULL &&
 312                 $mail->subject == "Delivery Status Notification (Failure)"
 313               ) {
 314                 // Exchange error - CRM-9361
 315                 foreach ($mail->body->getParts() as $part) {
 316                   if ($part instanceof ezcMailDeliveryStatus) {
 317                     foreach ($part->recipients as $rec) {
 318                       if ($rec["Status"] == "5.1.1") {
 319                         $text = "Delivery to the following recipients failed";
 320                         break;
 321                       }
 322                     }
 323                   }
 324                 }
 325               }
 326
 327               if (empty($text)) {
 328                 // If bounce processing fails, just take the raw body. Cf. CRM-11046
 329                 $text = $mail->generateBody();
 330
 331                 // if text is still empty, lets fudge a blank text so the api call below will succeed
 332                 if (empty($text)) {
 333                   $text = ts('We could not extract the mail body from this bounce message.');
 334                 }
 335               }
 336
 337               $params = array(
 338                 'job_id' => $job,
 339                 'event_queue_id' => $queue,
 340                 'hash' => $hash,
 341                 'body' => $text,
 342                 'version' => 3,
 343               );
 344               $result = civicrm_api('Mailing', 'event_bounce', $params);
 345               break;
 346
 347             case 'c':
 348             case 'confirm':
 349               // CRM-7921
 350               $params = array(
 351                 'contact_id' => $job,
 352                 'subscribe_id' => $queue,
 353                 'hash' => $hash,
 354                 'version' => 3,
 355               );
 356               $result = civicrm_api('Mailing', 'event_confirm', $params);
 357               break;
 358
 359             case 'o':
 360             case 'optOut':
 361               $params = array(
 362                 'job_id' => $job,
 363                 'event_queue_id' => $queue,
 364                 'hash' => $hash,
 365                 'version' => 3,
 366               );
 367               $result = civicrm_api('MailingGroup', 'event_domain_unsubscribe', $params);
 368               break;
 369
 370             case 'r':
 371             case 'reply':
 372               // instead of text and HTML parts (4th and 6th params) send the whole email as the last param
 373               $params = array(
 374                 'job_id' => $job,
 375                 'event_queue_id' => $queue,
 376                 'hash' => $hash,
 377                 'bodyTxt' => NULL,
 378                 'replyTo' => $replyTo,
 379                 'bodyHTML' => NULL,
 380                 'fullEmail' => $mail->generate(),
 381                 'version' => 3,
 382               );
 383               $result = civicrm_api('Mailing', 'event_reply', $params);
 384               break;
 385
 386             case 'e':
 387             case 're':
 388             case 'resubscribe':
 389               $params = array(
 390                 'job_id' => $job,
 391                 'event_queue_id' => $queue,
 392                 'hash' => $hash,
 393                 'version' => 3,
 394               );
 395               $result = civicrm_api('MailingGroup', 'event_resubscribe', $params);
 396               break;
 397
 398             case 's':
 399             case 'subscribe':
 400               $params = array(
 401                 'email' => $mail->from->email,
 402                 'group_id' => $job,
 403                 'version' => 3,
 404               );
 405               $result = civicrm_api('MailingGroup', 'event_subscribe', $params);
 406               break;
 407
 408             case 'u':
 409             case 'unsubscribe':
 410               $params = array(
 411                 'job_id' => $job,
 412                 'event_queue_id' => $queue,
 413                 'hash' => $hash,
 414                 'version' => 3,
 415               );
 416               $result = civicrm_api('MailingGroup', 'event_unsubscribe', $params);
 417               break;
 418           }
 419
 420           if ($result['is_error']) {
 421             echo "Failed Processing: {$mail->subject}, Action: $action, Job ID: $job, Queue ID: $queue, Hash: $hash. Reason: {$result['error_message']}\n";
 422           }
 423           else {
 424             CRM_Utils_Hook::emailProcessor('mailing', $params, $mail, $result, $action);
 425           }
 426         }
 427
 428         $store->markProcessed($key);
 429       }
 430       // CRM-7356 – used by IMAP only
 431       $store->expunge();
 432     }
 433   }
 434
 435 }