class/mime/Message.class.php

   1 <?php
   2
   3 /**
   4  * Message.class.php
   5  *
   6  * This file contains functions needed to handle mime messages.
   7  *
   8  * @copyright &copy; 2003-2007 The SquirrelMail Project Team
   9  * @license http://opensource.org/licenses/gpl-license.php GNU Public License
  10  * @version $Id$
  11  * @package squirrelmail
  12  * @subpackage mime
  13  * @since 1.3.2
  14  */
  15
  16 /**
  17  * The object that contains a message.
  18  *
  19  * message is the object that contains messages. It is a recursive object in
  20  * that through the $entities variable, it can contain more objects of type
  21  * message. See documentation in mime.txt for a better description of how this
  22  * works.
  23  * @package squirrelmail
  24  * @subpackage mime
  25  * @since 1.3.0
  26  */
  27 class Message {
  28     /**
  29      * rfc822header object
  30      * @var object
  31      */
  32     var $rfc822_header = '';
  33     /**
  34      * MessageHeader object
  35      * @var object
  36      */
  37     var $mime_header = '';
  38     /**
  39      * @var mixed
  40      */
  41     var $flags = '';
  42     /**
  43      * Media type
  44      * @var string
  45      */
  46     var $type0='';
  47     /**
  48      * Media subtype
  49      * @var string
  50      */
  51     var $type1='';
  52     /**
  53      * Nested mime parts
  54      * @var array
  55      */
  56     var $entities = array();
  57     /**
  58      * Message part id
  59      * @var string
  60      */
  61     var $entity_id = '';
  62     /**
  63      * Parent message part id
  64      * @var string
  65      */
  66     var $parent_ent;
  67     /**
  68      * @var mixed
  69      */
  70     var $entity;
  71     /**
  72      * @var mixed
  73      */
  74     var $parent = '';
  75     /**
  76      * @var string
  77      */
  78     var $decoded_body='';
  79     /**
  80      * Message \seen status
  81      * @var boolean
  82      */
  83     var $is_seen = 0;
  84     /**
  85      * Message \answered status
  86      * @var boolean
  87      */
  88     var $is_answered = 0;
  89     /**
  90      * Message \deleted status
  91      * @var boolean
  92      */
  93     var $is_deleted = 0;
  94     /**
  95      * Message \flagged status
  96      * @var boolean
  97      */
  98     var $is_flagged = 0;
  99     /**
 100      * Message mdn status
 101      * @var boolean
 102      */
 103     var $is_mdnsent = 0;
 104     /**
 105      * Message text body
 106      * @var string
 107      */
 108     var $body_part = '';
 109     /**
 110      * Message part offset
 111      * for fetching body parts out of raw messages
 112      * @var integer
 113      */
 114     var $offset = 0;
 115     /**
 116      * Message part length
 117      * for fetching body parts out of raw messages
 118      * @var integer
 119      */
 120     var $length = 0;
 121     /**
 122      * Local attachment filename location where the tempory attachment is
 123      * stored. For use in delivery class.
 124      * @var string
 125      */
 126     var $att_local_name = '';
 127
 128     /**
 129      * @param string $ent entity id
 130      */
 131     function setEnt($ent) {
 132         $this->entity_id= $ent;
 133     }
 134
 135     /**
 136      * Add nested message part
 137      * @param object $msg
 138      */
 139     function addEntity ($msg) {
 140         $this->entities[] = $msg;
 141     }
 142
 143     /**
 144      * Get file name used for mime part
 145      * @return string file name
 146      * @since 1.3.2
 147      */
 148     function getFilename() {
 149          $filename = '';
 150          $header = $this->header;
 151          if (is_object($header->disposition)) {
 152               $filename = $header->disposition->getProperty('filename');
 153               if (trim($filename) == '') {
 154                   $name = decodeHeader($header->disposition->getProperty('name'));
 155                   if (!trim($name)) {
 156                       $name = $header->getParameter('name');
 157                       if(!trim($name)) {
 158                           if (!trim( $header->id )) {
 159                               $filename = 'untitled-[' . $this->entity_id . ']' ;
 160                           } else {
 161                               $filename = 'cid: ' . $header->id;
 162                           }
 163                       } else {
 164                           $filename = $name;
 165                       }
 166                   } else {
 167                       $filename = $name;
 168                   }
 169               }
 170          } else {
 171               $filename = $header->getParameter('filename');
 172               if (!trim($filename)) {
 173                   $filename = $header->getParameter('name');
 174                   if (!trim($filename)) {
 175                       if (!trim( $header->id )) {
 176                           $filename = 'untitled-[' . $this->entity_id . ']' ;
 177                       } else {
 178                           $filename = 'cid: ' . $header->id;
 179                       }
 180                   }
 181               }
 182          }
 183          return $filename;
 184     }
 185
 186     /**
 187      * Add header object to message object.
 188      * WARNING: Unfinished code. Don't expect it to work in older sm versions.
 189      * @param mixed $read array or string with message headers
 190      * @todo FIXME: rfc822header->parseHeader() does not return rfc822header object
 191      */
 192     function addRFC822Header($read) {
 193         $header = new Rfc822Header();
 194         $this->rfc822_header = $header->parseHeader($read);
 195     }
 196
 197     /**
 198      * @param string $ent
 199      * @return mixed (object or string?)
 200      */
 201     function getEntity($ent) {
 202         $cur_ent = $this->entity_id;
 203         $msg = $this;
 204         if (($cur_ent == '') || ($cur_ent == '0')) {
 205             $cur_ent_a = array();
 206         } else {
 207             $cur_ent_a = explode('.', $this->entity_id);
 208         }
 209         $ent_a = explode('.', $ent);
 210
 211         for ($i = 0,$entCount = count($ent_a) - 1; $i < $entCount; ++$i) {
 212             if (isset($cur_ent_a[$i]) && ($cur_ent_a[$i] != $ent_a[$i])) {
 213                 $msg = $msg->parent;
 214                 $cur_ent_a = explode('.', $msg->entity_id);
 215                 --$i;
 216             } else if (!isset($cur_ent_a[$i])) {
 217                 if (isset($msg->entities[($ent_a[$i]-1)])) {
 218                     $msg = $msg->entities[($ent_a[$i]-1)];
 219                 } else {
 220                     $msg = $msg->entities[0];
 221                 }
 222             }
 223             if (($msg->type0 == 'message') && ($msg->type1 == 'rfc822')) {
 224                 /*this is a header for a message/rfc822 entity */
 225                 $msg = $msg->entities[0];
 226             }
 227         }
 228
 229         if (($msg->type0 == 'message') && ($msg->type1 == 'rfc822')) {
 230             /*this is a header for a message/rfc822 entity */
 231             $msg = $msg->entities[0];
 232         }
 233
 234         if (isset($msg->entities[($ent_a[$entCount])-1])) {
 235             if (is_object($msg->entities[($ent_a[$entCount])-1])) {
 236                 $msg = $msg->entities[($ent_a[$entCount]-1)];
 237             }
 238         }
 239
 240         return $msg;
 241     }
 242
 243     /**
 244      * Set message body
 245      * @param string $s message body
 246      */
 247     function setBody($s) {
 248         $this->body_part = $s;
 249     }
 250
 251     /**
 252      * Clean message object
 253      */
 254     function clean_up() {
 255         $msg = $this;
 256         $msg->body_part = '';
 257
 258         foreach ($msg->entities as $m) {
 259             $m->clean_up();
 260         }
 261     }
 262
 263     /**
 264      * @return string
 265      */
 266     function getMailbox() {
 267         $msg = $this;
 268         while (is_object($msg->parent)) {
 269             $msg = $msg->parent;
 270         }
 271         return $msg->mailbox;
 272     }
 273
 274     /*
 275      * Bodystructure parser, a recursive function for generating the
 276      * entity-tree with all the mime-parts.
 277      *
 278      * It follows RFC2060 and stores all the described fields in the
 279      * message object.
 280      *
 281      * Question/Bugs:
 282      *
 283      * Ask for me (Marc Groot Koerkamp, stekkel@users.sourceforge.net)
 284      * @param string $read
 285      * @param integer $i
 286      * @param mixed $sub_msg
 287      * @return object Message object
 288      * @todo define argument and return types
 289      */
 290     function parseStructure($read, &$i, $sub_msg = '') {
 291         $msg = Message::parseBodyStructure($read, $i, $sub_msg);
 292         if($msg) $msg->setEntIds($msg,false,0);
 293         return $msg;
 294     }
 295
 296     /**
 297      * @param object $msg
 298      * @param mixed $init
 299      * @param integer $i
 300      * @todo document me
 301      * @since 1.4.0
 302      */
 303     function setEntIds(&$msg,$init=false,$i=0) {
 304         $iCnt = count($msg->entities);
 305         if ($init !==false) {
 306             $iEntSub = $i+1;
 307             if ($msg->parent->type0 == 'message' &&
 308                 $msg->parent->type1 == 'rfc822' &&
 309                 $msg->type0 == 'multipart') {
 310                 $iEntSub = '0';
 311             }
 312             if ($init) {
 313                 $msg->entity_id = "$init.$iEntSub";
 314             } else {
 315                 $msg->entity_id = $iEntSub;
 316             }
 317         } else if ($iCnt) {
 318             $msg->entity_id='0';
 319         } else {
 320             $msg->entity_id='1';
 321         }
 322         for ($i=0;$i<$iCnt;++$i) {
 323             $msg->entities[$i]->parent =& $msg;
 324             if (strrchr($msg->entity_id, '.') != '.0') {
 325                 $msg->entities[$i]->setEntIds($msg->entities[$i],$msg->entity_id,$i);
 326             } else {
 327                 $msg->entities[$i]->setEntIds($msg->entities[$i],$msg->parent->entity_id,$i);
 328             }
 329         }
 330     }
 331
 332     /**
 333      * @param string $read
 334      * @param integer $i
 335      * @param mixed $sub_msg
 336      * @return object Message object
 337      * @todo document me
 338      * @since 1.4.0 (code was part of parseStructure() in 1.3.x)
 339      */
 340     function parseBodyStructure($read, &$i, $sub_msg = '') {
 341         $arg_no = 0;
 342         $arg_a  = array();
 343         if ($sub_msg) {
 344             $message = $sub_msg;
 345         } else {
 346             $message = new Message();
 347         }
 348
 349         for ($cnt = strlen($read); $i < $cnt; ++$i) {
 350             $char = strtoupper($read{$i});
 351             switch ($char) {
 352                 case '(':
 353                     switch($arg_no) {
 354                         case 0:
 355                             if (!isset($msg)) {
 356                                 $msg = new Message();
 357                                 $hdr = new MessageHeader();
 358                                 $hdr->type0 = 'text';
 359                                 $hdr->type1 = 'plain';
 360                                 $hdr->encoding = 'us-ascii';
 361                             } else {
 362                                 $msg->header->type0 = 'multipart';
 363                                 $msg->type0 = 'multipart';
 364                                 while ($read{$i} == '(') {
 365                                     $msg->addEntity($msg->parseBodyStructure($read, $i, $msg));
 366                                 }
 367                             }
 368                             break;
 369                         case 1:
 370                             /* multipart properties */
 371                             ++$i;
 372                             $arg_a[] = $msg->parseProperties($read, $i);
 373                             ++$arg_no;
 374                             break;
 375                         case 2:
 376                             if (isset($msg->type0) && ($msg->type0 == 'multipart')) {
 377                                 ++$i;
 378                                 $arg_a[] = $msg->parseDisposition($read, $i);
 379                             } else { /* properties */
 380                                 $arg_a[] = $msg->parseProperties($read, $i);
 381                             }
 382                             ++$arg_no;
 383                             break;
 384                         case 3:
 385                             if (isset($msg->type0) && ($msg->type0 == 'multipart')) {
 386                                 ++$i;
 387                                 $arg_a[]= $msg->parseLanguage($read, $i);
 388                             }
 389                         case 7:
 390                             if (($arg_a[0] == 'message') && ($arg_a[1] == 'rfc822')) {
 391                                 $msg->header->type0 = $arg_a[0];
 392                                 $msg->header->type1 = $arg_a[1];
 393                                 $msg->type0 = $arg_a[0];
 394                                 $msg->type1 = $arg_a[1];
 395                                 $rfc822_hdr = new Rfc822Header();
 396                                 $msg->rfc822_header = $msg->parseEnvelope($read, $i, $rfc822_hdr);
 397                                 while (($i < $cnt) && ($read{$i} != '(')) {
 398                                     ++$i;
 399                                 }
 400                                 $msg->addEntity($msg->parseBodyStructure($read, $i,$msg));
 401                             }
 402                             break;
 403                         case 8:
 404                             ++$i;
 405                             $arg_a[] = $msg->parseDisposition($read, $i);
 406                             ++$arg_no;
 407                             break;
 408                         case 9:
 409                             ++$i;
 410                             if (($arg_a[0] == 'text') || (($arg_a[0] == 'message') && ($arg_a[1] == 'rfc822'))) {
 411                                 $arg_a[] = $msg->parseDisposition($read, $i);
 412                             } else {
 413                                 $arg_a[] = $msg->parseLanguage($read, $i);
 414                             }
 415                             ++$arg_no;
 416                             break;
 417                        case 10:
 418                            if (($arg_a[0] == 'text') || (($arg_a[0] == 'message') && ($arg_a[1] == 'rfc822'))) {
 419                                ++$i;
 420                                $arg_a[] = $msg->parseLanguage($read, $i);
 421                            } else {
 422                                $i = $msg->parseParenthesis($read, $i);
 423                                $arg_a[] = ''; /* not yet described in rfc2060 */
 424                            }
 425                            ++$arg_no;
 426                            break;
 427                        default:
 428                            /* unknown argument, skip this part */
 429                            $i = $msg->parseParenthesis($read, $i);
 430                            $arg_a[] = '';
 431                            ++$arg_no;
 432                            break;
 433                    } /* switch */
 434                    break;
 435                 case '"':
 436                     /* inside an entity -> start processing */
 437                     $arg_s = $msg->parseQuote($read, $i);
 438                     ++$arg_no;
 439                     if ($arg_no < 3) {
 440                         $arg_s = strtolower($arg_s); /* type0 and type1 */
 441                     }
 442                     $arg_a[] = $arg_s;
 443                     break;
 444                 case 'n':
 445                 case 'N':
 446                     /* probably NIL argument */
 447                     $tmpnil = strtoupper(substr($read, $i, 4));
 448                     if ($tmpnil == 'NIL ' || $tmpnil == 'NIL)') {
 449                         $arg_a[] = '';
 450                         ++$arg_no;
 451                         $i += 2;
 452                     }
 453                     break;
 454                 case '{':
 455                     /* process the literal value */
 456                     $arg_a[] = $msg->parseLiteral($read, $i);
 457                     ++$arg_no;
 458                     break;
 459         case '0':
 460                 case is_numeric($read{$i}):
 461                     /* process integers */
 462                     if ($read{$i} == ' ') { break; }
 463             ++$arg_no;
 464             if (preg_match('/^([0-9]+).*/',substr($read,$i), $regs)) {
 465                 $i += strlen($regs[1])-1;
 466                 $arg_a[] = $regs[1];
 467             } else {
 468                 $arg_a[] = 0;
 469             }
 470                     break;
 471                 case ')':
 472                     $multipart = (isset($msg->type0) && ($msg->type0 == 'multipart'));
 473                     if (!$multipart) {
 474                         $shifted_args = (($arg_a[0] == 'text') || (($arg_a[0] == 'message') && ($arg_a[1] == 'rfc822')));
 475                         $hdr->type0 = $arg_a[0];
 476                         $hdr->type1 = $arg_a[1];
 477
 478                         $msg->type0 = $arg_a[0];
 479                         $msg->type1 = $arg_a[1];
 480                         $arr = $arg_a[2];
 481                         if (is_array($arr)) {
 482                             $hdr->parameters = $arg_a[2];
 483                         }
 484                         $hdr->id = str_replace('<', '', str_replace('>', '', $arg_a[3]));
 485                         $hdr->description = $arg_a[4];
 486                         $hdr->encoding = strtolower($arg_a[5]);
 487                         $hdr->entity_id = $msg->entity_id;
 488                         $hdr->size = $arg_a[6];
 489                         if ($shifted_args) {
 490                             $hdr->lines = $arg_a[7];
 491                             $s = 1;
 492                         } else {
 493                             $s = 0;
 494                         }
 495                         $hdr->md5 = (isset($arg_a[7+$s]) ? $arg_a[7+$s] : $hdr->md5);
 496                         $hdr->disposition = (isset($arg_a[8+$s]) ? $arg_a[8+$s] : $hdr->disposition);
 497                         $hdr->language = (isset($arg_a[9+$s]) ? $arg_a[9+$s] : $hdr->language);
 498                         $msg->header = $hdr;
 499                     } else {
 500                         $hdr->type0 = 'multipart';
 501                         $hdr->type1 = $arg_a[0];
 502                         $msg->type0 = 'multipart';
 503                         $msg->type1 = $arg_a[0];
 504                         $hdr->parameters = (isset($arg_a[1]) ? $arg_a[1] : $hdr->parameters);
 505                         $hdr->disposition = (isset($arg_a[2]) ? $arg_a[2] : $hdr->disposition);
 506                         $hdr->language = (isset($arg_a[3]) ? $arg_a[3] : $hdr->language);
 507                         $msg->header = $hdr;
 508                     }
 509                     return $msg;
 510                 default: break;
 511             } /* switch */
 512         } /* for */
 513     } /* parsestructure */
 514
 515     /**
 516      * @param string $read
 517      * @param integer $i
 518      * @return array
 519      */
 520     function parseProperties($read, &$i) {
 521         $properties = array();
 522         $prop_name = '';
 523
 524         for (; $read{$i} != ')'; ++$i) {
 525             $arg_s = '';
 526             if ($read{$i} == '"') {
 527                 $arg_s = $this->parseQuote($read, $i);
 528             } else if ($read{$i} == '{') {
 529                 $arg_s = $this->parseLiteral($read, $i);
 530             }
 531
 532             if ($arg_s != '') {
 533                 if ($prop_name == '') {
 534                     $prop_name = strtolower($arg_s);
 535                     $properties[$prop_name] = '';
 536                 } else if ($prop_name != '') {
 537                     $properties[$prop_name] = $arg_s;
 538                     $prop_name = '';
 539                 }
 540             }
 541         }
 542         return $this->handleRfc2231($properties);
 543     }
 544
 545     /**
 546      * Joins RFC-2231 continuations, converts encoding to RFC-2047 style
 547      * @param array $properties
 548      * @return array
 549      */
 550     function handleRfc2231($properties) {
 551
 552         /* STAGE 1: look for multi-line parameters, convert to the single line
 553            form, and normalize values */
 554
 555         $cont = array();
 556         foreach($properties as $key=>$value) {
 557             /* Look for parameters followed by "*", a number, and an optional "*"
 558                at the end. */
 559             if (preg_match('/^(.*\*)(\d+)(|\*)$/', $key, $matches)) {
 560                 unset($properties[$key]);
 561                 $prop_name = $matches[1];
 562                 if (!isset($cont[$prop_name])) $cont[$prop_name] = array();
 563
 564                 /* An asterisk at the end of parameter name indicates that there
 565                    may be an encoding information present, and the parameter
 566                    value is percent-hex encoded. If parameter is not encoded, we
 567                    encode it to simplify further processing.
 568                 */
 569                 if ($matches[3] == '') $value = rawurlencode($value);
 570                 /* Use the number from parameter name as segment index */
 571                 $cont[$prop_name][$matches[2]] = $value;
 572             }
 573         }
 574         foreach($cont as $key=>$values) {
 575             /* Sort segments of multi-line parameters by index number. */
 576             ksort($values);
 577             /* Join segments. We can do it safely, because:
 578                - All segments are encoded.
 579                - Per RFC-2231, chapter 4.1 notes.
 580             */
 581             $value = implode('', $values);
 582             /* Add language and character set field delimiters if not present,
 583                as required per RFC-2231, chapter 4.1, note #5. */
 584             if (strpos($value, "'") === false) $value = "''".$value;
 585             $properties[$key] = $value;
 586         }
 587
 588         /* STAGE 2: Convert single line RFC-2231 encoded parameters, and
 589            previously converted multi-line parameters, to RFC-2047 encoding */
 590
 591         foreach($properties as $key=>$value) {
 592             if ($idx = strpos($key, '*')) {
 593                 unset($properties[$key]);
 594                 /* Extract the charset & language. */
 595                 $charset = substr($value,0,strpos($value,"'"));
 596                 $value = substr($value,strlen($charset)+1);
 597                 $language = substr($value,0,strpos($value,"'"));
 598                 $value = substr($value,strlen($language)+1);
 599                 /* No character set defaults to US-ASCII */
 600                 if (!$charset) $charset = 'US-ASCII';
 601                 if ($language) $language = '*'.$language;
 602                 /* Convert to RFC-2047 base64 encoded string. */
 603                 $properties[substr($key, 0, $idx)] = '=?'.$charset.$language.'?B?'.base64_encode(rawurldecode($value)).'?=';
 604             }
 605         }
 606         return $properties;
 607     }
 608
 609     /**
 610      * @param string $read
 611      * @param integer $i
 612      * @param object $hdr MessageHeader object
 613      * @return object MessageHeader object
 614      */
 615     function parseEnvelope($read, &$i, $hdr) {
 616         $arg_no = 0;
 617         $arg_a = array();
 618         ++$i;
 619         for ($cnt = strlen($read); ($i < $cnt) && ($read{$i} != ')'); ++$i) {
 620             $char = strtoupper($read{$i});
 621             switch ($char) {
 622                 case '"':
 623                     $arg_a[] = $this->parseQuote($read, $i);
 624                     ++$arg_no;
 625                     break;
 626                 case '{':
 627                     $arg_a[] = $this->parseLiteral($read, $i);
 628             /* temp bugfix (SM 1.5 will have a working clean version)
 629                too much work to implement that version right now */
 630 //            --$i;
 631                     ++$arg_no;
 632                     break;
 633                 case 'N':
 634                     /* probably NIL argument */
 635                     if (strtoupper(substr($read, $i, 3)) == 'NIL') {
 636                         $arg_a[] = '';
 637                         ++$arg_no;
 638                         $i += 2;
 639                     }
 640                     break;
 641                 case '(':
 642                     /* Address structure (with group support)
 643                      * Note: Group support is useless on SMTP connections
 644                      *       because the protocol doesn't support it
 645                      */
 646                     $addr_a = array();
 647                     $group = '';
 648                     $a=0;
 649                     for (; $i < $cnt && $read{$i} != ')'; ++$i) {
 650                         if ($read{$i} == '(') {
 651                             $addr = $this->parseAddress($read, $i);
 652                             if (($addr->host == '') && ($addr->mailbox != '')) {
 653                                 /* start of group */
 654                                 $group = $addr->mailbox;
 655                                 $group_addr = $addr;
 656                                 $j = $a;
 657                             } else if ($group && ($addr->host == '') && ($addr->mailbox == '')) {
 658                                /* end group */
 659                                 if ($a == ($j+1)) { /* no group members */
 660                                     $group_addr->group = $group;
 661                                     $group_addr->mailbox = '';
 662                                     $group_addr->personal = "$group: Undisclosed recipients;";
 663                                     $addr_a[] = $group_addr;
 664                                     $group ='';
 665                                 }
 666                             } else {
 667                                 $addr->group = $group;
 668                                 $addr_a[] = $addr;
 669                             }
 670                             ++$a;
 671                         }
 672                     }
 673                     $arg_a[] = $addr_a;
 674                     break;
 675                 default: break;
 676             }
 677         }
 678
 679         if (count($arg_a) > 9) {
 680             $d = strtr($arg_a[0], array('  ' => ' '));
 681             $d_parts = explode(' ', $d);
 682             if (!$arg_a[1]) $arg_a[1] = _("(no subject)");
 683
 684             $hdr->date = getTimeStamp($d_parts); /* argument 1: date */
 685             $hdr->date_unparsed = strtr($d,'<>','  '); /* original date */
 686             $hdr->subject = $arg_a[1];     /* argument 2: subject */
 687             $hdr->from = is_array($arg_a[2]) ? $arg_a[2][0] : '';     /* argument 3: from        */
 688             $hdr->sender = is_array($arg_a[3]) ? $arg_a[3][0] : '';   /* argument 4: sender      */
 689             $hdr->reply_to = is_array($arg_a[4]) ? $arg_a[4][0] : '';  /* argument 5: reply-to    */
 690             $hdr->to = $arg_a[5];          /* argument 6: to          */
 691             $hdr->cc = $arg_a[6];          /* argument 7: cc          */
 692             $hdr->bcc = $arg_a[7];         /* argument 8: bcc         */
 693             $hdr->in_reply_to = $arg_a[8];   /* argument 9: in-reply-to */
 694             $hdr->message_id = $arg_a[9];  /* argument 10: message-id */
 695         }
 696         return $hdr;
 697     }
 698
 699     /**
 700      * @param string $read
 701      * @param integer $i
 702      * @return string
 703      * @todo document me
 704      */
 705     function parseLiteral($read, &$i) {
 706         $lit_cnt = '';
 707         ++$i;
 708         $iPos = strpos($read,'}',$i);
 709         if ($iPos) {
 710             $lit_cnt = substr($read, $i, $iPos - $i);
 711             $i += strlen($lit_cnt) + 3; /* skip } + \r + \n */
 712             /* Now read the literal */
 713             $s = ($lit_cnt ? substr($read,$i,$lit_cnt): '');
 714             $i += $lit_cnt;
 715             /* temp bugfix (SM 1.5 will have a working clean version)
 716                too much work to implement that version right now */
 717             --$i;
 718         } else { /* should never happen */
 719             $i += 3; /* } + \r + \n */
 720             $s = '';
 721         }
 722         return $s;
 723     }
 724
 725     /**
 726      * function parseQuote
 727      *
 728      * This extract the string value from a quoted string. After the end-quote
 729      * character is found it returns the string. The offset $i when calling
 730      * this function points to the first double quote. At the end it points to
 731      * The ending quote. This function takes care of escaped double quotes.
 732      * "some \"string\""
 733      * ^               ^
 734      * initial $i      end position $i
 735      *
 736      * @param string $read
 737      * @param integer $i offset in $read
 738      * @return string string inbetween the double quotes
 739      * @author Marc Groot Koerkamp
 740      */
 741     function parseQuote($read, &$i) {
 742         $s = '';
 743         $iPos = ++$i;
 744         $iPosStart = $iPos;
 745         while (true) {
 746             $iPos = strpos($read,'"',$iPos);
 747             if (!$iPos) break;
 748             if ($iPos && $read{$iPos -1} != '\\') {
 749                 $s = substr($read,$i,($iPos-$i));
 750                 $i = $iPos;
 751                 break;
 752             } else if ($iPos > 1 && $read{$iPos -1} == '\\' && $read{$iPos-2} == '\\') {
 753                 // This is an unique situation where the fast detection of the string
 754                 // fails. If the quote string ends with \\ then we need to iterate
 755                 // through the entire string to make sure we detect the unexcaped
 756                 // double quotes correctly.
 757                 $s = '';
 758                 $bEscaped = false;
 759                 $k = 0;
 760                  for ($j=$iPosStart,$iCnt=strlen($read);$j<$iCnt;++$j) {
 761                     $cChar = $read{$j};
 762                     switch ($cChar) {
 763                         case '\\':
 764                            $bEscaped = !$bEscaped;
 765                             $s .= $cChar;
 766                             break;
 767                          case '"':
 768                             if ($bEscaped) {
 769                                 $s .= $cChar;
 770                                 $bEscaped = false;
 771                             } else {
 772                                 $i = $j;
 773                                 break 3;
 774                             }
 775                             break;
 776                          default:
 777                             if ($bEscaped) {
 778                                $bEscaped = false;
 779                             }
 780                             $s .= $cChar;
 781                             break;
 782                     }
 783                 }
 784             }
 785             ++$iPos;
 786             if ($iPos > strlen($read)) {
 787                 break;
 788             }
 789         }
 790         return $s;
 791     }
 792
 793     /**
 794      * @param string $read
 795      * @param integer $i
 796      * @return object AddressStructure object
 797      */
 798     function parseAddress($read, &$i) {
 799         $arg_a = array();
 800         for (; $read{$i} != ')'; ++$i) {
 801             $char = strtoupper($read{$i});
 802             switch ($char) {
 803                 case '"': $arg_a[] = $this->parseQuote($read, $i); break;
 804                 case '{': $arg_a[] = $this->parseLiteral($read, $i); break;
 805                 case 'n':
 806                 case 'N':
 807                     if (strtoupper(substr($read, $i, 3)) == 'NIL') {
 808                         $arg_a[] = '';
 809                         $i += 2;
 810                     }
 811                     break;
 812                 default: break;
 813             }
 814         }
 815
 816         if (count($arg_a) == 4) {
 817             $adr = new AddressStructure();
 818             $adr->personal = $arg_a[0];
 819             $adr->adl = $arg_a[1];
 820             $adr->mailbox = $arg_a[2];
 821             $adr->host = $arg_a[3];
 822         } else {
 823             $adr = '';
 824         }
 825         return $adr;
 826     }
 827
 828     /**
 829      * @param string $read
 830      * @param integer $i
 831      * @param object Disposition object or empty string
 832      */
 833     function parseDisposition($read, &$i) {
 834         $arg_a = array();
 835         for (; $read{$i} != ')'; ++$i) {
 836             switch ($read{$i}) {
 837                 case '"': $arg_a[] = $this->parseQuote($read, $i); break;
 838                 case '{': $arg_a[] = $this->parseLiteral($read, $i); break;
 839                 case '(': $arg_a[] = $this->parseProperties($read, $i); break;
 840                 default: break;
 841             }
 842         }
 843
 844         if (isset($arg_a[0])) {
 845             $disp = new Disposition($arg_a[0]);
 846             if (isset($arg_a[1])) {
 847                 $disp->properties = $arg_a[1];
 848             }
 849         }
 850         return (is_object($disp) ? $disp : '');
 851     }
 852
 853     /**
 854      * @param string $read
 855      * @param integer $i
 856      * @return object Language object or empty string
 857      */
 858     function parseLanguage($read, &$i) {
 859         /* no idea how to process this one without examples */
 860         $arg_a = array();
 861
 862         for (; $read{$i} != ')'; ++$i) {
 863             switch ($read{$i}) {
 864                 case '"': $arg_a[] = $this->parseQuote($read, $i); break;
 865                 case '{': $arg_a[] = $this->parseLiteral($read, $i); break;
 866                 case '(': $arg_a[] = $this->parseProperties($read, $i); break;
 867                 default: break;
 868             }
 869         }
 870
 871         if (isset($arg_a[0])) {
 872             $lang = new Language($arg_a[0]);
 873             if (isset($arg_a[1])) {
 874                 $lang->properties = $arg_a[1];
 875             }
 876         }
 877         return (is_object($lang) ? $lang : '');
 878     }
 879
 880     /**
 881      * Parse message text enclosed in parenthesis
 882      * @param string $read
 883      * @param integer $i
 884      * @return integer
 885      */
 886     function parseParenthesis($read, $i) {
 887         for ($i++; $read{$i} != ')'; ++$i) {
 888             switch ($read{$i}) {
 889                 case '"': $this->parseQuote($read, $i); break;
 890                 case '{': $this->parseLiteral($read, $i); break;
 891                 case '(': $this->parseProperties($read, $i); break;
 892                 default: break;
 893             }
 894         }
 895         return $i;
 896     }
 897
 898     /**
 899      * Function to fill the message structure in case the
 900      * bodystructure is not available
 901      * NOT FINISHED YET
 902      * @param string $read
 903      * @param string $type0 message part type
 904      * @param string $type1 message part subtype
 905      * @return string (only when type0 is not message or multipart)
 906      */
 907     function parseMessage($read, $type0, $type1) {
 908         switch ($type0) {
 909             case 'message':
 910                 $rfc822_header = true;
 911                 $mime_header = false;
 912                 break;
 913             case 'multipart':
 914                 $rfc822_header = false;
 915                 $mime_header = true;
 916                 break;
 917             default: return $read;
 918         }
 919
 920         for ($i = 1; $i < $count; ++$i) {
 921             $line = trim($body[$i]);
 922             if (($mime_header || $rfc822_header) &&
 923                 (preg_match("/^.*boundary=\"?(.+(?=\")|.+).*/i", $line, $reg))) {
 924                 $bnd = $reg[1];
 925                 $bndreg = $bnd;
 926                 $bndreg = str_replace("\\", "\\\\", $bndreg);
 927                 $bndreg = str_replace("?", "\\?", $bndreg);
 928                 $bndreg = str_replace("+", "\\+", $bndreg);
 929                 $bndreg = str_replace(".", "\\.", $bndreg);
 930                 $bndreg = str_replace("/", "\\/", $bndreg);
 931                 $bndreg = str_replace("-", "\\-", $bndreg);
 932                 $bndreg = str_replace("(", "\\(", $bndreg);
 933                 $bndreg = str_replace(")", "\\)", $bndreg);
 934             } else if ($rfc822_header && $line == '') {
 935                 $rfc822_header = false;
 936                 if ($msg->type0 == 'multipart') {
 937                     $mime_header = true;
 938                 }
 939             }
 940
 941             if ((($line{0} == '-') || $rfc822_header)  && isset($boundaries[0])) {
 942                 $cnt = count($boundaries)-1;
 943                 $bnd = $boundaries[$cnt]['bnd'];
 944                 $bndreg = $boundaries[$cnt]['bndreg'];
 945
 946                 $regstr = '/^--'."($bndreg)".".*".'/';
 947                 if (preg_match($regstr, $line, $reg)) {
 948                     $bndlen = strlen($reg[1]);
 949                     $bndend = false;
 950                     if (strlen($line) > ($bndlen + 3)) {
 951                         if (($line{$bndlen+2} == '-') && ($line{$bndlen+3} == '-')) {
 952                             $bndend = true;
 953                         }
 954                     }
 955                     if ($bndend) {
 956                         /* calc offset and return $msg */
 957                         //$entStr = CalcEntity("$entStr", -1);
 958                         array_pop($boundaries);
 959                         $mime_header = true;
 960                         $bnd_end = true;
 961                     } else {
 962                         $mime_header = true;
 963                          $bnd_end = false;
 964                         //$entStr = CalcEntity("$entStr", 0);
 965                         ++$content_indx;
 966                     }
 967                 } else {
 968                     if ($header) { }
 969                 }
 970             }
 971         }
 972     }
 973
 974     /**
 975      * @param array $entity
 976      * @param array $alt_order
 977      * @param boolean $strict
 978      * @return array
 979      */
 980     function findDisplayEntity($entity = array(), $alt_order = array('text/plain', 'text/html'), $strict=false) {
 981         $found = false;
 982         if ($this->type0 == 'multipart') {
 983             if($this->type1 == 'alternative') {
 984                 $msg = $this->findAlternativeEntity($alt_order);
 985                 if (count($msg->entities) == 0) {
 986                     $entity[] = $msg->entity_id;
 987                 } else {
 988                     $entity = $msg->findDisplayEntity($entity, $alt_order, $strict);
 989                 }
 990                 $found = true;
 991             } else if ($this->type1 == 'related') { /* RFC 2387 */
 992                 $msgs = $this->findRelatedEntity();
 993                 foreach ($msgs as $msg) {
 994                     if (count($msg->entities) == 0) {
 995                         $entity[] = $msg->entity_id;
 996                     } else {
 997                         $entity = $msg->findDisplayEntity($entity, $alt_order, $strict);
 998                     }
 999                 }
1000                 if (count($msgs) > 0) {
1001                     $found = true;
1002                 }
1003             } else { /* Treat as multipart/mixed */
1004                 foreach ($this->entities as $ent) {
1005                     if(!(is_object($ent->header->disposition) && strtolower($ent->header->disposition->name) == 'attachment') &&
1006                             (!isset($ent->header->parameters['filename'])) &&
1007                             (!isset($ent->header->parameters['name'])) &&
1008                             (($ent->type0 != 'message') && ($ent->type1 != 'rfc822'))) {
1009                         $entity = $ent->findDisplayEntity($entity, $alt_order, $strict);
1010                         $found = true;
1011                     }
1012                 }
1013             }
1014         } else { /* If not multipart, then just compare with each entry from $alt_order */
1015             $type = $this->type0.'/'.$this->type1;
1016 //        $alt_order[] = "message/rfc822";
1017             foreach ($alt_order as $alt) {
1018                 if( ($alt == $type) && isset($this->entity_id) ) {
1019                     if ((count($this->entities) == 0) &&
1020                             (!isset($this->header->parameters['filename'])) &&
1021                             (!isset($this->header->parameters['name'])) &&
1022                             isset($this->header->disposition) && is_object($this->header->disposition) &&
1023                             !(is_object($this->header->disposition) && strtolower($this->header->disposition->name) == 'attachment')) {
1024                         $entity[] = $this->entity_id;
1025                         $found = true;
1026                     }
1027                 }
1028             }
1029         }
1030         if(!$found) {
1031             foreach ($this->entities as $ent) {
1032                 if(!(is_object($ent->header->disposition) && strtolower($ent->header->disposition->name) == 'attachment') &&
1033                    (($ent->type0 != 'message') && ($ent->type1 != 'rfc822'))) {
1034                     $entity = $ent->findDisplayEntity($entity, $alt_order, $strict);
1035                     $found = true;
1036                 }
1037             }
1038         }
1039         if(!$strict && !$found) {
1040             if (($this->type0 == 'text') &&
1041                 in_array($this->type1, array('plain', 'html', 'message')) &&
1042                 isset($this->entity_id)) {
1043                 if (count($this->entities) == 0) {
1044                     if (!is_object($this->header->disposition) || strtolower($this->header->disposition->name) != 'attachment') {
1045                         $entity[] = $this->entity_id;
1046                     }
1047                 }
1048             }
1049         }
1050         return $entity;
1051     }
1052
1053     /**
1054      * @param array $alt_order
1055      * @return array
1056      */
1057     function findAlternativeEntity($alt_order) {
1058         /* If we are dealing with alternative parts then we  */
1059         /* choose the best viewable message supported by SM. */
1060         $best_view = 0;
1061         $entity = array();
1062         foreach($this->entities as $ent) {
1063             $type = $ent->header->type0 . '/' . $ent->header->type1;
1064             if ($type == 'multipart/related') {
1065                 $type = $ent->header->getParameter('type');
1066             // Mozilla bug. Mozilla does not provide the parameter type.
1067             if (!$type) $type = 'text/html';
1068             }
1069             $altCount = count($alt_order);
1070             for ($j = $best_view; $j < $altCount; ++$j) {
1071                 if (($alt_order[$j] == $type) && ($j >= $best_view)) {
1072                     $best_view = $j;
1073                     $entity = $ent;
1074                 }
1075             }
1076         }
1077         return $entity;
1078     }
1079
1080     /**
1081      * @return array
1082      */
1083     function findRelatedEntity() {
1084         $msgs = array();
1085         $related_type = $this->header->getParameter('type');
1086         // Mozilla bug. Mozilla does not provide the parameter type.
1087         if (!$related_type) $related_type = 'text/html';
1088         $entCount = count($this->entities);
1089         for ($i = 0; $i < $entCount; ++$i) {
1090             $type = $this->entities[$i]->header->type0.'/'.$this->entities[$i]->header->type1;
1091             if ($related_type == $type) {
1092                 $msgs[] = $this->entities[$i];
1093             }
1094         }
1095         return $msgs;
1096     }
1097
1098     /**
1099      * @param array $exclude_id
1100      * @param array $result
1101      * @return array
1102      */
1103     function getAttachments($exclude_id=array(), $result = array()) {
1104 /*
1105         if (($this->type0 == 'message') &&
1106         ($this->type1 == 'rfc822') &&
1107         ($this->entity_id) ) {
1108             $this = $this->entities[0];
1109         }
1110 */
1111         if (count($this->entities)) {
1112             foreach ($this->entities as $entity) {
1113                 $exclude = false;
1114                 foreach ($exclude_id as $excl) {
1115                     if ($entity->entity_id === $excl) {
1116                         $exclude = true;
1117                     }
1118                 }
1119
1120                 if (!$exclude) {
1121                     if (($entity->type0 == 'multipart') &&
1122                         ($entity->type1 != 'related')) {
1123                         $result = $entity->getAttachments($exclude_id, $result);
1124                     } else if ($entity->type0 != 'multipart') {
1125                         $result[] = $entity;
1126                     }
1127                 }
1128             }
1129         } else {
1130             $exclude = false;
1131             foreach ($exclude_id as $excl) {
1132                 $exclude = $exclude || ($this->entity_id == $excl);
1133             }
1134
1135             if (!$exclude) {
1136                 $result[] = $this;
1137             }
1138         }
1139         return $result;
1140     }
1141
1142     /**
1143      * Add attachment to message object
1144      * @param string $type attachment type
1145      * @param string $name attachment name
1146      * @param string $location path to attachment
1147      */
1148     function initAttachment($type, $name, $location) {
1149         $attachment = new Message();
1150         $mime_header = new MessageHeader();
1151         $mime_header->setParameter('name', $name);
1152         // FIXME: duplicate code. see ContentType class
1153         $pos = strpos($type, '/');
1154         if ($pos > 0) {
1155             $mime_header->type0 = substr($type, 0, $pos);
1156             $mime_header->type1 = substr($type, $pos+1);
1157         } else {
1158             $mime_header->type0 = $type;
1159         }
1160         $attachment->att_local_name = $location;
1161         $disposition = new Disposition('attachment');
1162         $disposition->properties['filename'] = $name;
1163         $mime_header->disposition = $disposition;
1164         $attachment->mime_header = $mime_header;
1165         $this->entities[]=$attachment;
1166     }
1167
1168     /**
1169      * Delete all attachments from this object from disk.
1170      * @since 1.5.1
1171      */
1172     function purgeAttachments() {
1173         if ($this->att_local_name) {
1174             global $username, $attachment_dir;
1175             $hashed_attachment_dir = getHashedDir($username, $attachment_dir);
1176             if ( file_exists($hashed_attachment_dir . '/' . $this->att_local_name) ) {
1177                 unlink($hashed_attachment_dir . '/' . $this->att_local_name);
1178             }
1179         }
1180         // recursively delete attachments from entities contained in this object
1181         for ($i=0, $entCount=count($this->entities);$i< $entCount; ++$i) {
1182             $this->entities[$i]->purgeAttachments();
1183         }
1184     }
1185 }