class/mime.class.php

   1 <?php
   2
   3 /**
   4  * mime.class
   5  *
   6  * Copyright (c) 2002 The SquirrelMail Project Team
   7  * Licensed under the GNU GPL. For full terms see the file COPYING.
   8  *
   9  *
  10  * This contains functions needed to handle mime messages.
  11  *
  12  * $Id$
  13  */
  14
  15
  16
  17 /*
  18  * rdc822_header class
  19  * input: header_string or array
  20  */
  21 class rfc822_header
  22 {
  23     var $date = '',
  24         $subject = '',
  25         $from = array(),
  26         $sender = '',
  27         $reply_to = array(),
  28         $to = array(),
  29         $cc = array(),
  30         $bcc = array(),
  31         $in_reply_to = '',
  32         $message_id = '',
  33         $mime = false,
  34         $content_type = '',
  35         $disposition = '',
  36         $xmailer = '',
  37         $priority = 3,
  38         $dnt = '',
  39         $mlist = array(),
  40         $more_headers = array(); /* only needed for constructing headers
  41                                     in smtp.php */
  42
  43     function parseHeader($hdr)
  44     {
  45         if (is_array($hdr))
  46         {
  47             $hdr = implode('',$hdr);
  48         }
  49         /* first we unfold the header */
  50         $hdr = trim(str_replace(array("\r\n\t","\r\n "),array('',''),$hdr));
  51         /*
  52          * now we can make a new header array with each element representing
  53          * a headerline
  54          */
  55         $hdr = explode("\r\n" , $hdr);
  56         foreach ($hdr as $line)
  57         {
  58             $pos = strpos($line,':');
  59             if ($pos > 0)
  60             {
  61                 $field = substr($line,0,$pos);
  62                 $value = trim(substr($line,$pos+1));
  63                 if(!preg_match('/^X.*/i',$field)) {
  64                     $value = $this->stripComments($value);
  65                 }
  66                 $this->parseField($field,$value);
  67             }
  68         }
  69         if ($this->content_type == '')
  70         {
  71             $this->parseContentType('text/plain; charset=us-ascii');
  72         }
  73     }
  74
  75     function stripComments($value)
  76     {
  77         $cnt = strlen($value);
  78         $s = '';
  79         $i = 0;
  80         while ($i < $cnt)
  81         {
  82            switch ($value{$i})
  83            {
  84            case ('"'):
  85               $s .= '"';
  86               $i++;
  87               while ($value{$i} != '"')
  88               {
  89                  if ($value{$i} == '\\')
  90                  {
  91                     $s .= '\\';
  92                     $i++;
  93                  }
  94                  $s .= $value{$i};
  95                  $i++;
  96                  if ($i > $cnt) break;
  97               }
  98               $s .= $value{$i};
  99               break;
 100            case ('('):
 101               while ($value{$i} != ')')
 102               {
 103                  if ($value{$i} == '\\')
 104                  {
 105                     $i++;
 106                  }
 107                  $i++;
 108               }
 109               break;
 110            default:
 111               $s .= $value{$i};
 112               break;
 113            }
 114            $i++;
 115         }
 116         return $s;
 117     }
 118
 119     function parseField($field,$value)
 120     {
 121         $field = strtolower($field);
 122         switch($field)
 123         {
 124         case ('date'):
 125             $d = strtr($value, array('  ' => ' '));
 126             $d = explode(' ', $d);
 127             $this->date = getTimeStamp($d);
 128             break;
 129         case ('subject'):
 130             $this->subject = $value;
 131             break;
 132         case ('from'):
 133             $this->from = $this->parseAddress($value,true);
 134             break;
 135         case ('sender'):
 136             $this->sender = $this->parseAddress($value);
 137             break;
 138         case ('reply-to'):
 139             $this->reply_to = $this->parseAddress($value, true);
 140             break;
 141         case ('to'):
 142             $this->to = $this->parseAddress($value, true);
 143             break;
 144         case ('cc'):
 145             $this->cc = $this->parseAddress($value, true);
 146             break;
 147         case ('bcc'):
 148             $this->bcc = $this->parseAddress($value, true);
 149             break;
 150         case ('in-reply-to'):
 151             $this->in_reply_to = $value;
 152             break;
 153         case ('message_id'):
 154             $this->message_id = $value;
 155             break;
 156         case ('disposition-notification-to'):
 157             $this->dnt = $this->parseAddress($value);
 158             break;
 159         case ('mime-Version'):
 160             $value = str_replace(' ','',$value);
 161             if ($value == '1.0')
 162             {
 163                $this->mime = true;
 164             }
 165             break;
 166         case ('content-type'):
 167             $this->parseContentType($value);
 168             break;
 169         case ('content-disposition'):
 170             $this->parseDisposition($value);
 171             break;
 172         case ('x-mailer'):
 173             $this->xmailer = $value;
 174             break;
 175         case ('x-priority'):
 176             $this->priority = $value;
 177             break;
 178         case ('list-post'):
 179             $this->mlist('post',$value);
 180             break;
 181         case ('list-reply'):
 182             $this->mlist('reply',$value);
 183             break;
 184         case ('list-subscribe'):
 185             $this->mlist('subscribe',$value);
 186             break;
 187         case ('list-unsubscribe'):
 188             $this->mlist('unsubscribe',$value);
 189             break;
 190         case ('list-archive'):
 191             $this->mlist('archive',$value);
 192             break;
 193         case ('list-owner'):
 194             $this->mlist('owner',$value);
 195             break;
 196         case ('list-help'):
 197             $this->mlist('help',$value);
 198             break;
 199         case ('list-id'):
 200             $this->mlist('id',$value);
 201             break;
 202         default:
 203             break;
 204         }
 205     }
 206
 207     function parseAddress($address, $ar=false, $addr_ar = array(), $group = '')
 208     {
 209         $pos = 0;
 210         $j = strlen( $address );
 211         $name = '';
 212         $addr = '';
 213         while ( $pos < $j ) {
 214            switch ($address{$pos})
 215            {
 216            case ('"'): /* get the personal name */
 217               $pos++;
 218               if ($address{$pos} == '"')
 219               {
 220                  $pos++;
 221               } else
 222               {
 223                  while ( $pos < $j && $address{$pos} != '"')
 224                  {
 225                      if (substr($address, $pos, 2) == '\\"')
 226                      {
 227                         $name .= $address{$pos};
 228                         $pos++;
 229                      } elseif (substr($address, $pos, 2) == '\\\\')
 230                      {
 231                         $name .= $address{$pos};
 232                         $pos++;
 233                      }
 234                      $name .= $address{$pos};
 235                      $pos++;
 236                  }
 237               }
 238               $pos++;
 239               break;
 240            case ('<'):  /* get email address */
 241               $addr_start=$pos;
 242               $pos++;
 243               while ( $pos < $j && $address{$pos} != '>' )
 244               {
 245                  $addr .= $address{$pos};
 246                  $pos++;
 247               }
 248               $pos++;
 249               break;
 250            case ('('):  /* rip off comments */
 251               $addr_start=$pos;
 252               $pos++;
 253               while ( $pos < $j && $address{$pos} != ')' )
 254               {
 255                  $addr .= $address{$pos};
 256                  $pos++;
 257               }
 258               $address_start = substr($address,0,$addr_start);
 259               $address_end = substr($address,$pos+1);
 260               $address = $address_start . $address_end;
 261               $j = strlen( $address );
 262               $pos = $addr_start;
 263               $pos++;
 264               break;
 265            case (','):  /* we reached a delimiter */
 266               if ($addr == '')
 267               {
 268                  $addr = substr($address,0,$pos);
 269               } elseif ($name == '') {
 270                  $name = trim(substr($address,0,$addr_start));
 271               }
 272
 273               $at = strpos($addr, '@');
 274               $addr_structure = new address_structure();
 275               $addr_structure->personal = $name;
 276               $addr_structure->group = $group;
 277               if ($at)
 278               {
 279                  $addr_structure->mailbox = substr($addr,0,$at);
 280                  $addr_structure->host = substr($addr,$at+1);
 281               } else
 282               {
 283                  $addr_structure->mailbox = $addr;
 284               }
 285               $address = trim(substr($address,$pos+1));
 286               $j = strlen( $address );
 287               $pos = 0;
 288               $name = '';
 289               $addr = '';
 290               $addr_ar[] = $addr_structure;
 291               break;
 292            case (':'):  /* process the group addresses */
 293               /* group marker */
 294               $group = substr($address,0,$pos);
 295               $address = substr($address,$pos+1);
 296               $result = $this->parseAddress($address, $ar, $addr_ar, $group);
 297               $addr_ar = $result[0];
 298               $pos = $result[1];
 299               $address = substr($address,$pos);
 300               $j = strlen( $address );
 301               $group = '';
 302               $pos++;
 303               break;
 304            case (';'):
 305               if ($group)
 306               {
 307                  $address = substr($address, 0, $pos-1);
 308               }
 309               $pos++;
 310               break;
 311            default:
 312               $pos++;
 313               break;
 314            }
 315
 316         }
 317         if ($addr == '')
 318         {
 319            $addr = substr($address,0,$pos);
 320         } elseif ($name == '')
 321         {
 322            $name = trim(substr($address,0,$addr_start));
 323         }
 324         $at = strpos($addr, '@');
 325         $addr_structure = new address_structure();
 326         $addr_structure->group = $group;
 327         if ($at)
 328         {
 329            $addr_structure->mailbox = trim(substr($addr,0,$at));
 330            $addr_structure->host = trim(substr($addr,$at+1));
 331         } else
 332         {
 333            $addr_structure->mailbox = trim($addr);
 334         }
 335         if ($group && $addr == '') /* no addresses found in group */
 336         {
 337            $name = "$group: Undisclosed recipients;";
 338            $addr_structure->personal = $name;
 339            $addr_ar[] = $addr_structure;
 340            return (array($addr_ar,$pos+1));
 341         } else
 342         {
 343            $addr_structure->personal = $name;
 344            if ($name || $addr)
 345            {
 346               $addr_ar[] = $addr_structure;
 347            }
 348         }
 349         if ($ar)
 350         {
 351            return ($addr_ar);
 352         } else
 353         {
 354            return ($addr_ar[0]);
 355         }
 356     }
 357
 358    function parseContentType($value)
 359    {
 360        $pos = strpos($value,';');
 361        $props = '';
 362        if ($pos > 0)
 363        {
 364           $type = trim(substr($value,0,$pos));
 365           $props = trim(substr($type,$pos+1));
 366        } else
 367        {
 368           $type = $value;
 369        }
 370        $content_type = new content_type($type);
 371        if ($props)
 372        {
 373           $properties = $this->parseProperties($props);
 374           if (!isset($properties['charset']))
 375           {
 376              $properties['charset'] = 'us-ascii';
 377           }
 378           $content_type->properties = $this->parseProperties($props);
 379        }
 380        $this->content_type = $content_type;
 381    }
 382
 383    function parseProperties($value)
 384    {
 385       $propArray = explode(';',$value);
 386       $propResultArray = array();
 387       foreach ($propArray as $prop)
 388       {
 389          $prop = trim($prop);
 390          $pos = strpos($prop,'=');
 391          if ($pos>0)
 392          {
 393             $key = trim(substr($prop,0,$pos));
 394             $val = trim(substr($prop,$pos+1));
 395             if ($val{0} == '"')
 396             {
 397                $val = substr($val,1,-1);
 398             }
 399             $propResultArray[$key] = $val;
 400          }
 401       }
 402       return $propResultArray;
 403    }
 404
 405    function parseDisposition($value)
 406    {
 407        $pos = strpos($value,';');
 408        $props = '';
 409        if ($pos > 0)
 410        {
 411           $name = trim(substr($value,0,$pos));
 412           $props = trim(substr($type,$pos+1));
 413        } else
 414        {
 415           $name = $value;
 416        }
 417        $props_a = $this->parseProperties($props);
 418        $disp = new disposition($name);
 419        $disp->properties = $props_a;
 420        $this->disposition = $disp;
 421    }
 422
 423    function mlist($field, $value)
 424    {
 425        $res_a = array();
 426        $value_a = explode(',',$value);
 427        foreach ($value_a as $val) {
 428           $val = trim($val);
 429           if ($val{0} == '<')
 430           {
 431              $val = substr($val,1,-1);
 432           }
 433           if (substr($val,0,7) == 'mailto:')
 434           {
 435              $res_a['mailto'] = substr($val,7);
 436           } else
 437           {
 438              $res_a['href'] = $val;
 439           }
 440        }
 441        $this->mlist[$field] = $res_a;
 442    }
 443
 444     /*
 445     * function to get the addres strings out of the header.
 446     * Arguments: string or array of strings !
 447     * example1: header->getAddr_s('to').
 448     * example2: header->getAddr_s(array('to','cc','bcc'))
 449     */
 450     function getAddr_s($arr, $separator=', ')
 451     {
 452         if (is_array($arr))
 453         {
 454             $s = '';
 455             foreach($arr as $arg )
 456             {
 457                $result = $this->getAddr_s($arg);
 458                if ($result)
 459                {
 460                   $s .= $separator . $result;
 461                }
 462             }
 463             if ($s) $s = substr($s,2);
 464             return $s;
 465         } else
 466         {
 467             $s = '';
 468             eval('$addr = $this->'.$arr.';') ;
 469             if (is_array($addr))
 470             {
 471                foreach ($addr as $addr_o)
 472                {
 473                   if (is_object($addr_o))
 474                   {
 475                      $s .= $addr_o->getAddress() . $separator;
 476                   }
 477                }
 478                $s = substr($s,0,-strlen($separator));
 479             } else
 480             {
 481                if (is_object($addr))
 482                {
 483                   $s .= $addr->getAddress();
 484                }
 485             }
 486             return $s;
 487         }
 488     }
 489
 490     function getAddr_a($arg, $excl_arr=array(), $arr = array())
 491     {
 492         if (is_array($arg))
 493         {
 494             foreach($arg as $argument )
 495             {
 496                $arr = $this->getAddr_a($argument, $excl_arr, $arr);
 497             }
 498             return $arr;
 499         } else
 500         {
 501             eval('$addr = $this->'.$arg.';') ;
 502             if (is_array($addr))
 503             {
 504                foreach ($addr as $addr_o)
 505                {
 506                   if (is_object($addr_o))
 507                   {
 508                      if (isset($addr_o->host) && $addr_o->host !='')
 509                      {
 510                         $email = $addr_o->mailbox.'@'.$addr_o->host;
 511                      } else
 512                      {
 513                         $email = $addr_o->mailbox;
 514                      }
 515                      $email = strtolower($email);
 516                      if ($email && !isset($arr[$email]) && !isset($excl_arr[$email]))
 517                      {
 518                         $arr[$email] = $addr_o->personal;
 519                      }
 520                   }
 521                }
 522             } else
 523             {
 524                if (is_object($addr))
 525                {
 526                   if (isset($addr->host))
 527                   {
 528                      $email = $addr->mailbox.'@'.$addr->host;
 529                   } else
 530                   {
 531                      $email = $addr->mailbox;
 532                   }
 533                   $email = strtolower($email);
 534                   if ($email && !isset($arr[$email]) && !isset($excl_arr[$email]))
 535                   {
 536                      $arr[$email] = $addr->personal;
 537                   }
 538                }
 539             }
 540             return $arr;
 541         }
 542     }
 543
 544     function getContentType($type0, $type1)
 545     {
 546         $type0 = $this->content_type->type0;
 547         $type1 = $this->content_type->type1;
 548         return $this->content_type->properties;
 549     }
 550 }
 551
 552 class msg_header
 553 {
 554     /** msg_header contains all variables available in a bodystructure **/
 555     /** entity like described in rfc2060                               **/
 556
 557     var $type0 = '',
 558         $type1 = '',
 559         $parameters = array(),
 560         $id = 0,
 561         $description = '',
 562         $encoding='',
 563         $size = 0,
 564         $md5='',
 565         $disposition = '',
 566         $language='';
 567
 568     /*
 569      * returns addres_list of supplied argument
 570      * arguments: array('to', 'from', ...) or just a string like 'to'.
 571      * result: string: address1, addres2, ....
 572      */
 573
 574     function setVar($var, $value)
 575     {
 576         $this->{$var} = $value;
 577     }
 578
 579     function getParameter($par)
 580     {
 581         $value = strtolower($par);
 582         if (isset($this->parameters[$par]))
 583         {
 584            return $this->parameters[$par];
 585         }
 586         return '';
 587     }
 588
 589     function setParameter($parameter, $value)
 590     {
 591         $this->parameters[strtolower($parameter)] = $value;
 592     }
 593 }
 594
 595
 596
 597 class address_structure
 598 {
 599    var $personal = '', $adl = '', $mailbox = '', $host = '', $group = '';
 600
 601    function getAddress($full=true)
 602    {
 603      if (is_object($this))
 604      {
 605         if (isset($this->host) && $this->host !='')
 606         {
 607            $email = $this->mailbox.'@'.$this->host;
 608         } else
 609         {
 610            $email = $this->mailbox;
 611         }
 612         if (trim($this->personal) !='')
 613         {
 614            if ($email)
 615            {
 616                 $addr = '"' . $this->personal . '" <' .$email.'>';
 617            } else
 618            {
 619                 $addr = $this->personal;
 620            }
 621            $best_dpl = $this->personal;
 622         } else
 623         {
 624            $addr = $email;
 625            $best_dpl = $email;
 626         }
 627         if ($full)
 628         {
 629            return $addr;
 630         } else
 631         {
 632            return $best_dpl;
 633         }
 634      } else return '';
 635    }
 636 }
 637
 638 class message
 639 {
 640     /** message is the object that contains messages.  It is a recursive
 641       object in that through the $entities variable, it can contain
 642       more objects of type message.  See documentation in mime.txt for
 643       a better description of how this works.
 644     **/
 645     var $rfc822_header = '',
 646         $mime_header = '',
 647         $flags = '',
 648         $type0='',
 649         $type1='',
 650         $entities = array(),
 651         $parent_ent, $entity,
 652         $parent = '', $decoded_body='',
 653         $is_seen = 0, $is_answered = 0, $is_deleted = 0, $is_flagged = 0,
 654         $is_mdnsent = 0,
 655         $body_part = '',
 656         $offset = 0,  /* for fetching body parts out of raw messages */
 657         $length = 0;  /* for fetching body parts out of raw messages */
 658
 659     function setEnt($ent)
 660     {
 661         $this->entity_id= $ent;
 662     }
 663
 664     function addEntity ($msg)
 665     {
 666         $msg->parent = &$this;
 667         $this->entities[] = $msg;
 668     }
 669
 670     function getFilename()
 671     {
 672         $filename = '';
 673         if (is_object($this->header->disposition))
 674         {
 675             $filename = $this->header->disposition->getproperty('filename');
 676             if (!$filename)
 677             {
 678                 $filename = $this->header->disposition->getproperty('name');
 679             }
 680         }
 681         if (!$filename)
 682         {
 683             $filename = 'untitled-'.$this->entity_id;
 684         }
 685         return $filename;
 686     }
 687
 688
 689     function addRFC822Header($read)
 690     {
 691         $header = new rfc822_header();
 692         $this->rfc822_header = $header->parseHeader($read);
 693     }
 694
 695     function getEntity($ent)
 696     {
 697         $cur_ent = $this->entity_id;
 698         $msg = $this;
 699         if ($cur_ent == '' || $cur_ent == '0')
 700         {
 701            $cur_ent_a = array();
 702         } else
 703         {
 704            $cur_ent_a = explode('.',$this->entity_id);
 705         }
 706         $ent_a = explode('.',$ent);
 707
 708         $cnt = count($ent_a);
 709
 710         for ($i=0;$i<$cnt -1;$i++)
 711         {
 712            if (isset($cur_ent_a[$i]) && $cur_ent_a[$i] != $ent_a[$i])
 713            {
 714               $msg = $msg->parent;
 715               $cur_ent_a = explode('.',$msg->entity_id);
 716               $i--;
 717            } else if (!isset($cur_ent_a[$i]))
 718            {
 719               if (isset($msg->entities[($ent_a[$i]-1)]))
 720               {
 721                 $msg = $msg->entities[($ent_a[$i]-1)];
 722               } else {
 723                 $msg = $msg->entities[0];
 724               }
 725            }
 726            if ($msg->type0 == 'message' && $msg->type1 == 'rfc822')
 727            {
 728               /*this is a header for a message/rfc822 entity */
 729               $msg = $msg->entities[0];
 730            }
 731         }
 732
 733         if ($msg->type0 == 'message' && $msg->type1 == 'rfc822')
 734         {
 735            /*this is a header for a message/rfc822 entity */
 736            $msg = $msg->entities[0];
 737         }
 738
 739         if (isset($msg->entities[($ent_a[$cnt-1])-1]))
 740         {
 741             if (is_object($msg->entities[($ent_a[$cnt-1])-1]))
 742             {
 743                 $msg = $msg->entities[($ent_a[$cnt-1]-1)];
 744             }
 745         }
 746
 747         return $msg;
 748     }
 749
 750     function setBody($s)
 751     {
 752         $this->body_part = $s;
 753     }
 754
 755     function clean_up()
 756     {
 757         $msg = $this;
 758         $msg->body_part = '';
 759         $i=0;
 760         while ( isset($msg->entities[$i]))
 761         {
 762             $msg->entities[$i]->clean_up();
 763             $i++;
 764         }
 765     }
 766
 767     function getMailbox()
 768     {
 769        $msg = $this;
 770        while (is_object($msg->parent))
 771        {
 772           $msg = $msg->parent;
 773        }
 774        return $msg->mailbox;
 775     }
 776
 777     function calcEntity($msg)
 778     {
 779         if ($this->type0 == 'message' && $this->type1 == 'rfc822')
 780         {
 781             $msg->entity_id = $this->entity_id .'.0'; /* header of message/rfc822 */
 782         } else if (isset($this->entity_id) && $this->entity_id !='')
 783         {
 784             $ent_no = count($this->entities)+1;
 785             $par_ent = substr($this->entity_id,-2);
 786             if ($par_ent{0} == '.')
 787             {
 788                $par_ent = $par_ent{1};
 789             }
 790             if ($par_ent == '0')
 791             {
 792                 $ent_no = count($this->entities)+1;
 793                 if ($ent_no > 0)
 794                 {
 795                    $ent = substr($this->entity_id,0,strrpos($this->entity_id,'.'));
 796                    if ($ent)
 797                    {
 798                       $ent = $ent . ".$ent_no";
 799                    } else
 800                    {
 801                       $ent = $ent_no;
 802                    }
 803                    $msg->entity_id = $ent;
 804                 } else
 805                 {
 806                    $msg->entity_id = $ent_no;
 807                 }
 808             } else
 809             {
 810                 $ent = $this->entity_id . ".$ent_no";
 811                 $msg->entity_id = $ent;
 812             }
 813         } else
 814         {
 815             $msg->entity_id = '0';
 816         }
 817         return $msg->entity_id;
 818     }
 819
 820
 821     /*
 822      * Bodystructure parser, a recursive function for generating the
 823      * entity-tree with all the mime-parts.
 824      *
 825      * It follows RFC2060 and stores all the described fields in the
 826      * message object.
 827      *
 828      * Question/Bugs:
 829      *
 830      * Ask for me (Marc Groot Koerkamp, stekkel@users.sourceforge.net.
 831      *
 832      */
 833     function parseStructure($read, $i=0)
 834     {
 835       $arg_no = 0;
 836       $arg_a = array();
 837       $cnt = strlen($read);
 838       while ($i < $cnt)
 839       {
 840         $char = strtoupper($read{$i});
 841         switch ($char)
 842         {
 843         case '(':
 844            if ($arg_no == 0 )
 845            {
 846               if (!isset($msg))
 847               {
 848                  $msg = new message();
 849                  $hdr = new msg_header();
 850                  $hdr->type0 = 'text';
 851                  $hdr->type1 = 'plain';
 852                  $hdr->encoding = 'us-ascii';
 853                  $msg->entity_id = $this->calcEntity($msg);
 854               } else
 855               {
 856                    $msg->header->type0 = 'multipart';
 857                    $msg->type0 = 'multipart';
 858                    while ($read{$i} == '(')
 859                    {
 860                       $res = $msg->parseStructure($read,$i);
 861                       $i = $res[1];
 862                       $msg->addEntity($res[0]);
 863                    }
 864               }
 865            } else
 866            {
 867               switch ($arg_no)
 868               {
 869               case 1:
 870                  /* multipart properties */
 871                  $i++;
 872                  $res = $this->parseProperties($read,$i);
 873
 874                  $arg_a[] = $res[0];
 875                  $i = $res[1];
 876                  $arg_no++;
 877                  break;
 878               case 2:
 879                  if (isset($msg->type0) &&  $msg->type0 == 'multipart')
 880                  {
 881                     $i++;
 882                     $res = $msg->parseDisposition($read,$i);
 883                     $arg_a[] = $res[0];
 884                     $i = $res[1];
 885                  } else /* properties */
 886                  {
 887                     $res = $msg->parseProperties($read,$i);
 888                     $arg_a[] = $res[0];
 889                     $i = $res[1];
 890                  }
 891                  $arg_no++;
 892                  break;
 893               case 3:
 894                  if (isset($msg->type0) &&  $msg->type0 == 'multipart')
 895                  {
 896                     $i++;
 897                     $res= $msg->parseLanguage($read,$i);
 898                     $arg_a[] = $res[0];
 899                     $i = $res[1];
 900                  }
 901               case 7:
 902                  if ($arg_a[0] == 'message' && $arg_a[1] == 'rfc822')
 903                  {
 904                      $msg->header->type0 = $arg_a[0];
 905                      $msg->type0 = $arg_a[0];
 906                      $msg->header->type1 = $arg_a[1];
 907                      $msg->type1 = $arg_a[1];
 908                      $rfc822_hdr = new rfc822_header();
 909                      $res = $msg->parseEnvelope($read,$i,$rfc822_hdr);
 910                      $i = $res[1];
 911                      $msg->rfc822_header =  $res[0];
 912                      $i++;
 913                      while ($i < $cnt && $read{$i} != '(')
 914                      {
 915                        $i++;
 916                      }
 917                      $res = $msg->parseStructure($read,$i);
 918                      $i = $res[1];
 919                      $msg->addEntity($res[0]);
 920                  }
 921                  break;
 922               case 8:
 923                  $i++;
 924                  $res = $msg->parseDisposition($read,$i);
 925                  $arg_a[] = $res[0];
 926                  $i = $res[1];
 927                  $arg_no++;
 928                  break;
 929               case 9:
 930                  if ($arg_a[0] == 'text' ||
 931                      ($arg_a[0] == 'message' && $arg_a[1] == 'rfc822'))
 932                  {
 933                     $i++;
 934                     $res = $msg->parseDisposition($read,$i);
 935                     $arg_a[] = $res[0];
 936                     $i = $res[1];
 937                  } else
 938                  {
 939                     $i++;
 940                     $res = $msg->parseLanguage($read,$i);
 941                     $arg_a[] = $res[0];
 942                     $i = $res[1];
 943                  }
 944                  $arg_no++;
 945                  break;
 946               case 10:
 947                  if ($arg_a[0] == 'text' ||
 948                      ($arg_a[0] == 'message' && $arg_a[1] == 'rfc822'))
 949                  {
 950                     $i++;
 951                     $res = $msg->parseLanguage($read,$i);
 952                     $arg_a[] = $res[0];
 953                     $i = $res[1];
 954                  } else
 955                  {
 956                     $i = $msg->parseParenthesis($read,$i);
 957                     $arg_a[] = ''; /* not yet desribed in rfc2060 */
 958                  }
 959                  $arg_no++;
 960                  break;
 961               default:
 962                  /* unknown argument, skip this part */
 963                  $i = $msg->parseParenthesis($read,$i);
 964                  $arg_a[] = '';
 965                  $arg_no++;
 966                  break;
 967               } /* switch */
 968            }
 969            break;
 970         case '"':
 971            /* inside an entity -> start processing */
 972            $debug = substr($read,$i,20);
 973            $res = $msg->parseQuote($read,$i);
 974            $arg_s = $res[0];
 975            $i = $res[1];
 976            $arg_no++;
 977            if ($arg_no < 3) $arg_s = strtolower($arg_s); /* type0 and type1 */
 978            $arg_a[] = $arg_s;
 979            break;
 980         case 'n':
 981         case 'N':
 982            /* probably NIL argument */
 983            if (strtoupper(substr($read,$i,4)) == 'NIL ' ||
 984                strtoupper(substr($read,$i,4)) == 'NIL)')
 985            {
 986               $arg_a[] = '';
 987               $arg_no++;
 988               $i = $i+2;
 989            }
 990            break;
 991         case '{':
 992            /* process the literal value */
 993            $res = $msg->parseLiteral($read,$i);
 994            $arg_s = $res[0];
 995            $i = $res[1];
 996            $arg_no++;
 997            break;
 998         case (is_numeric($read{$i}) ):
 999            /* process integers */
1000            if ($read{$i} == ' ') break;
1001            $arg_s = $read{$i};;
1002            $i++;
1003            while (preg_match('/^[0-9]{1}$/',$read{$i}))
1004            {
1005               $arg_s .= $read{$i};
1006               $i++;
1007            }
1008            $arg_no++;
1009            $arg_a[] = $arg_s;
1010            break;
1011         case ')':
1012            if (isset($msg->type0) && $msg->type0 == 'multipart')
1013            {
1014               $multipart = true;
1015            } else
1016            {
1017               $multipart = false;
1018            }
1019            if (!$multipart)
1020            {
1021               if ($arg_a[0] == 'text' ||
1022                   ($arg_a[0] == 'message' && $arg_a[1] == 'rfc822'))
1023               {
1024                  $shifted_args = true;
1025               } else
1026               {
1027                  $shifted_args = false;
1028               }
1029               $hdr->type0 = $arg_a[0];
1030               $hdr->type1 = $arg_a[1];
1031
1032               $msg->type0 = $arg_a[0];
1033               $msg->type1 = $arg_a[1];
1034
1035               $arr = $arg_a[2];
1036               if (is_array($arr))
1037               {
1038                  $hdr->parameters = $arg_a[2];
1039               }
1040               $hdr->id = str_replace( '<', '', str_replace( '>', '', $arg_a[3] ) );
1041               $hdr->description = $arg_a[4];
1042               $hdr->encoding = strtolower($arg_a[5]);
1043               $hdr->entity_id = $msg->entity_id;
1044               $hdr->size = $arg_a[6];
1045               if ($shifted_args)
1046               {
1047                  $hdr->lines = $arg_a[7];
1048                  if (isset($arg_a[8]))
1049                  {
1050                     $hdr->md5 = $arg_a[8];
1051                  }
1052                  if (isset($arg_a[9]))
1053                  {
1054                     $hdr->disposition = $arg_a[9];
1055                  }
1056                  if (isset($arg_a[10]))
1057                  {
1058                     $hdr->language = $arg_a[10];
1059                  }
1060               } else
1061               {
1062                  if (isset($arg_a[7]))
1063                  {
1064                     $hdr->md5 = $arg_a[7];
1065                  }
1066                  if (isset($arg_a[8]))
1067                  {
1068                     $hdr->disposition = $arg_a[8];
1069                  }
1070                  if (isset($arg_a[9]))
1071                  {
1072                     $hdr->language = $arg_a[9];
1073                  }
1074               }
1075               $msg->header = $hdr;
1076               $arg_no = 0;
1077               $i++;
1078               if (substr($msg->entity_id,-2) == '.0' && $msg->type0 !='multipart')
1079               {
1080                  $msg->entity_id++;
1081               }
1082               return (array($msg, $i));
1083            } else
1084            {
1085               $hdr->type0 = 'multipart';
1086               $hdr->type1 = $arg_a[0];
1087               $msg->type0 = 'multipart';
1088               $msg->type1 = $arg_a[0];
1089               if (is_array($arg_a[1]))
1090               {
1091                  $hdr->parameters = $arg_a[1];
1092               }
1093               if (isset($arg_a[2]))
1094               {
1095                  $hdr->disposition = $arg_a[2];
1096               }
1097               if (isset($arg_a[3]))
1098               {
1099                  $hdr->language = $arg_a[3];
1100               }
1101               $msg->header = $hdr;
1102               return (array($msg, $i));
1103            }
1104         default:
1105            break;
1106         } /* switch */
1107         $i++;
1108       } /* while */
1109     } /* parsestructure */
1110
1111     function parseProperties($read, $i)
1112     {
1113       $properties = array();
1114       $arg_s = '';
1115       $prop_name = '';
1116       while ($read{$i} != ')')
1117       {
1118          if ($read{$i} == '"')
1119          {
1120             $res = $this->parseQuote($read,$i);
1121             $arg_s = $res[0];
1122             $i = $res[1];
1123          } else if ($read{$i} == '{')
1124          {
1125             $res = $this->parseLiteral($read,$i);
1126             $arg_s = $res[0];
1127             $i = $res[1];
1128          }
1129          if ($prop_name == '' && $arg_s)
1130          {
1131             $prop_name = strtolower($arg_s);
1132             $properties[$prop_name] = '';
1133             $arg_s = '';
1134          } elseif ($prop_name != '' && $arg_s != '')
1135          {
1136             $properties[$prop_name] = $arg_s;
1137             $prop_name = '';
1138             $arg_s = '';
1139          }
1140          $i++;
1141       }
1142       return (array($properties, $i));
1143     }
1144
1145     function parseEnvelope($read, $i, $hdr)
1146     {
1147         $arg_no = 0;
1148         $arg_a = array();
1149         $cnt = strlen($read);
1150         while ($i< $cnt && $read{$i} != ')')
1151         {
1152            $i++;
1153            $char = strtoupper($read{$i});
1154            switch ($char)
1155            {
1156            case '"':
1157                $res = $this->parseQuote($read,$i);
1158                $arg_a[] = $res[0];
1159                $i = $res[1];
1160                $arg_no++;
1161                break;
1162            case '{':
1163                $res = $this->parseLiteral($read,$i);
1164                $arg_a[] = $res[0];
1165                $i = $res[1];
1166                $arg_no++;
1167                break;
1168            case 'N':
1169                /* probably NIL argument */
1170                if (strtoupper(substr($read,$i,3)) == 'NIL') {
1171                   $arg_a[] = '';
1172                   $arg_no++;
1173                   $i = $i+2;
1174                }
1175                break;
1176            case '(':
1177                /* Address structure
1178                 * With group support.
1179                 * Note: Group support is useless on SMTP connections
1180                 * because the protocol doesn't support it
1181                 */
1182                $addr_a = array();
1183                $group = '';
1184                $a=0;
1185                while ($i < $cnt && $read{$i} != ')')
1186                {
1187                   if ($read{$i} == '(')
1188                   {
1189                      $res = $this->parseAddress($read,$i);
1190                      $addr = $res[0];
1191                      $i = $res[1];
1192                      if ($addr->host == '' && $addr->mailbox != '')
1193                      {
1194                         /* start of group */
1195                         $group = $addr->mailbox;
1196                         $group_addr = $addr;
1197                         $j = $a;
1198                      } elseif ($group && $addr->host == '' && $addr->mailbox == '')
1199                      {
1200                         /* end group */
1201                         if ($a == $j+1) /* no group members */
1202                         {
1203                            $group_addr->group = $group;
1204                            $group_addr->mailbox = '';
1205                            $group_addr->personal = "$group: Undisclosed recipients;";
1206                            $addr_a[] = $group_addr;
1207                            $group ='';
1208                         }
1209                      } else
1210                      {
1211                         $addr->group = $group;
1212                         $addr_a[] = $addr;
1213                      }
1214                      $a++;
1215                   }
1216                   $i++;
1217                }
1218                $arg_a[] = $addr_a;
1219                break;
1220            default:
1221                break;
1222            }
1223            $i++;
1224         }
1225         if (count($arg_a) > 9)
1226         {
1227             /* argument 1: date */
1228             $d = strtr($arg_a[0], array('  ' => ' '));
1229             $d = explode(' ', $d);
1230             $hdr->date = getTimeStamp($d);
1231             /* argument 2: subject */
1232             if (!trim($arg_a[1]))
1233             {
1234                 $arg_a[1]= _("(no subject)");
1235             }
1236             $hdr->subject = $arg_a[1];
1237             /* argument 3: from */
1238             $hdr->from = $arg_a[2][0];
1239             /* argument 4: sender */
1240             $hdr->sender = $arg_a[3][0];
1241             /* argument 5: reply-to */
1242             $hdr->replyto = $arg_a[4][0];
1243             /* argument 6: to */
1244             $hdr->to = $arg_a[5];
1245             /* argument 7: cc */
1246             $hdr->cc = $arg_a[6];
1247             /* argument 8: bcc */
1248             $hdr->bcc = $arg_a[7];
1249             /* argument 9: in-reply-to */
1250             $hdr->inreplyto = $arg_a[8];
1251             /* argument 10: message-id */
1252             $hdr->message_id = $arg_a[9];
1253         }
1254         return (array($hdr,$i));
1255     }
1256
1257     function parseLiteral($read, $i)
1258     {
1259         $lit_cnt = '';
1260         $i++;
1261         while ($read{$i} != '}')
1262         {
1263            $lit_cnt .= $read{$i};
1264            $i++;
1265         }
1266         $lit_cnt +=2; /* add the { and } characters */
1267         $s = '';
1268         for ($j = 0; $j < $lit_cnt; $j++)
1269         {
1270            $i++;
1271            $s .= $read{$i};
1272         }
1273         return (array($s, $i));
1274     }
1275
1276     function parseQuote($read, $i)
1277     {
1278         $i++;
1279         $s = '';
1280         while ($read{$i} != '"')
1281         {
1282            if ($read{$i} == '\\')
1283            {
1284                $i++;
1285            }
1286            $s .= $read{$i};
1287            $i++;
1288         }
1289         return (array($s, $i));
1290     }
1291
1292     function parseAddress($read, $i)
1293     {
1294         $arg_a = array();
1295         while ($read{$i} != ')' )
1296         {
1297            $char = strtoupper($read{$i});
1298            switch ($char)
1299            {
1300            case '"':
1301                $res = $this->parseQuote($read,$i);
1302                $arg_a[] = $res[0];
1303                $i = $res[1];
1304                break;
1305            case '{':
1306                $res = $this->parseLiteral($read,$i);
1307                $arg_a[] = $res[0];
1308                $i = $res[1];
1309                break;
1310            case 'n':
1311            case 'N':
1312                if (strtoupper(substr($read,$i,3)) == 'NIL') {
1313                   $arg_a[] = '';
1314                   $i = $i+2;
1315                }
1316                break;
1317            default:
1318                break;
1319            }
1320            $i++;
1321         }
1322         if (count($arg_a) == 4)
1323         {
1324             $adr = new address_structure();
1325             $adr->personal = $arg_a[0];
1326             $adr->adl = $arg_a[1];
1327             $adr->mailbox = $arg_a[2];
1328             $adr->host = $arg_a[3];
1329         } else
1330         {
1331            $adr = '';
1332         }
1333         return (array($adr,$i));
1334     }
1335
1336     function parseDisposition($read,$i)
1337     {
1338         $arg_a = array();
1339         while ($read{$i} != ')')
1340         {
1341            switch ($read{$i})
1342            {
1343            case '"':
1344                $res = $this->parseQuote($read,$i);
1345                $arg_a[] = $res[0];
1346                $i = $res[1];
1347                break;
1348            case '{':
1349                $res = $this->parseLiteral($read,$i);
1350                $arg_a[] = $res[0];
1351                $i = $res[1];
1352                break;
1353            case '(':
1354                $res = $this->parseProperties($read,$i);
1355                $arg_a[] = $res[0];
1356                $i = $res[1];
1357                break;
1358            default:
1359                break;
1360            }
1361            $i++;
1362         }
1363         if (isset($arg_a[0]))
1364         {
1365            $disp = new disposition($arg_a[0]);
1366            if (isset($arg_a[1]))
1367            {
1368               $disp->properties = $arg_a[1];
1369            }
1370         }
1371         if (is_object($disp))
1372         {
1373            return (array($disp, $i));
1374         } else
1375         {
1376            return (array('',$i));
1377         }
1378     }
1379
1380     function parseLanguage($read,$i)
1381     {
1382         /* no idea how to process this one without examples */
1383         $arg_a = array();
1384         while ($read{$i} != ')')
1385         {
1386            switch ($read{$i})
1387            {
1388            case '"':
1389                $res = $this->parseQuote($read,$i);
1390                $arg_a[] = $res[0];
1391                $i = $res[1];
1392                break;
1393            case '{':
1394                $res = $this->parseLiteral($read,$i);
1395                $arg_a[] = $res[0];
1396                $i = $res[1];
1397                break;
1398            case '(':
1399                $res = $this->parseProperties($read,$i);
1400                $arg_a[] = $res[0];
1401                $i = $res[1];
1402                break;
1403            default:
1404                break;
1405            }
1406            $i++;
1407         }
1408         if (isset($arg_a[0]))
1409         {
1410            $lang = new language($arg_a[0]);
1411            if (isset($arg_a[1]))
1412            {
1413               $lang->properties = $arg_a[1];
1414            }
1415         }
1416         if (is_object($lang))
1417         {
1418            return (array($lang, $i));
1419         } else
1420         {
1421            return (array('', $i));
1422         }
1423     }
1424
1425     function parseParenthesis($read,$i)
1426     {
1427         while ($read{$i} != ')')
1428         {
1429            switch ($read{$i})
1430            {
1431            case '"':
1432                $res = $this->parseQuote($read,$i);
1433                $i = $res[1];
1434                break;
1435            case '{':
1436                $res = $this->parseLiteral($read,$i);
1437                $i = $res[1];
1438                break;
1439            case '(':
1440                $res = $this->parseParenthesis($read,$i);
1441                $i = $res[1];
1442                break;
1443            default:
1444                break;
1445            }
1446            $i++;
1447         }
1448         return $i;
1449     }
1450
1451     /* function to fill the message structure in case the bodystructure
1452     isn't available NOT FINISHED YET
1453     */
1454     function parseMessage($read, $type0, $type1)
1455     {
1456         switch ($type0)
1457         {
1458         case 'message':
1459             $rfc822_header = true;
1460             $mime_header = false;
1461             break;
1462         case 'multipart':
1463             $mime_header = true;
1464             $rfc822_header = false;
1465             break;
1466         default:
1467             return $read;
1468         }
1469
1470         for ($i=1; $i < $count; $i++)
1471         {
1472             $line = trim($body[$i]);
1473             if ( ( $mime_header || $rfc822_header) &&
1474                  (preg_match("/^.*boundary=\"?(.+(?=\")|.+).*/i",$line,$reg)) )
1475             {
1476                 $bnd = $reg[1];
1477                 $bndreg = $bnd;
1478                 $bndreg = str_replace("\\","\\\\",$bndreg);
1479                 $bndreg = str_replace("?","\\?",$bndreg);
1480                 $bndreg = str_replace("+","\\+",$bndreg);
1481                 $bndreg = str_replace(".","\\.",$bndreg);
1482                 $bndreg = str_replace("/","\\/",$bndreg);
1483                 $bndreg = str_replace("-","\\-",$bndreg);
1484                 $bndreg = str_replace("(","\\(",$bndreg);
1485                 $bndreg = str_replace(")","\\)",$bndreg);
1486             } elseif ( $rfc822_header && $line == '' )
1487             {
1488                 $rfc822_header = false;
1489                 if ($msg->type0 == 'multipart')
1490                 {
1491                     $mime_header = true;
1492                 }
1493             }
1494
1495             if (($line{0} == '-' || $rfc822_header)  && isset($boundaries[0]))
1496             {
1497                 $cnt=count($boundaries)-1;
1498                 $bnd = $boundaries[$cnt]['bnd'];
1499                 $bndreg = $boundaries[$cnt]['bndreg'];
1500
1501                 $regstr = '/^--'."($bndreg)".".*".'/';
1502                 if (preg_match($regstr,$line,$reg) )
1503                 {
1504                     $bndlen = strlen($reg[1]);
1505                     $bndend = false;
1506                     if (strlen($line) > ($bndlen + 3))
1507                     {
1508                         if ($line{$bndlen+2} == '-' && $line{$bndlen+3} == '-')
1509                             $bndend = true;
1510                     }
1511                     if ($bndend)
1512                     {
1513                         /* calc offset and return $msg */
1514         //              $entStr = CalcEntity("$entStr",-1);
1515                         array_pop($boundaries);
1516                         $mime_header = true;
1517                         $bnd_end = true;
1518                     } else
1519                     {
1520                         $mime_header = true;
1521                         $bnd_end = false;
1522 //              $entStr = CalcEntity("$entStr",0);
1523                         $content_indx++;
1524                     }
1525                 }  else
1526                 {
1527                     if ($header)
1528                     {
1529                     }
1530                 }
1531             }
1532         }
1533     }
1534
1535     function findDisplayEntity ($entity = array(), $alt_order = array('text/plain','text/html'))
1536     {
1537         $found = false;
1538         $type = $this->type0.'/'.$this->type1;
1539         if ( $type == 'multipart/alternative')
1540         {
1541             $msg = $this->findAlternativeEntity($alt_order);
1542             if (count($msg->entities) == 0)
1543             {
1544                 $entity[] = $msg->entity_id;
1545             } else
1546             {
1547                 $entity = $msg->findDisplayEntity($entity, $alt_order);
1548             }
1549             $found = true;
1550         } else if ( $type == 'multipart/related')
1551         {
1552             $msgs = $this->findRelatedEntity();
1553             foreach ($msgs as $msg)
1554             {
1555                 if (count($msg->entities) == 0)
1556                 {
1557                     $entity[] = $msg->entity_id;
1558                 } else
1559                 {
1560                     $entity = $msg->findDisplayEntity($entity,$alt_order);
1561                 }
1562             }
1563             if (count($msgs) > 0) {
1564                 $found = true;
1565             }
1566         } else if ($this->type0 == 'text' &&
1567                    ($this->type1 == 'plain' ||
1568                     $this->type1 == 'html'  ||
1569                     $this->type1 == 'message') &&
1570                    isset($this->entity_id) )
1571         {
1572             if (count($this->entities) == 0)
1573             {
1574                 if (strtolower($this->header->disposition->name) != 'attachment')
1575                 {
1576                     $entity[] = $this->entity_id;
1577                 }
1578             }
1579         }
1580         $i = 0;
1581         if(!$found) {
1582             foreach ($this->entities as $ent) {
1583                 if(strtolower($ent->header->disposition->name) != 'attachment' &&
1584                    ($ent->type0 != 'message' && $ent->type1 != 'rfc822'))
1585                 {
1586                     $entity = $ent->findDisplayEntity($entity, $alt_order);
1587                 }
1588             }
1589         }
1590         /*
1591         while ( isset($this->entities[$i]) && !$found &&
1592                 (strtolower($this->entities[$i]->header->disposition->name)
1593                  != 'attachment') &&
1594                 ($this->entities[$i]->type0 != 'message' &&
1595                  $this->entities[$i]->type1 != 'rfc822' )
1596               )
1597         {
1598             $entity = $this->entities[$i]->findDisplayEntity($entity, $alt_order);
1599             $i++;
1600         }
1601         */
1602         return( $entity );
1603     }
1604
1605     function findAlternativeEntity ($alt_order)
1606     {
1607        /* if we are dealing with alternative parts then we choose the best
1608         * viewable message supported by SM.
1609         */
1610         $best_view = 0;
1611         $entity = array();
1612         $altcount = count($alt_order);
1613         foreach($this->entities as $ent)
1614         {
1615             $type = $ent->header->type0.'/'.$ent->header->type1;
1616             if ($type == 'multipart/related')
1617             {
1618                 $type = $ent->header->getParameter('type');
1619             }
1620             for ($j = $best_view; $j < $altcount; $j++)
1621             {
1622                 if ($alt_order[$j] == $type && $j >= $best_view)
1623                 {
1624                     $best_view = $j;
1625                     $entity = $ent;
1626                 }
1627             }
1628         }
1629         return $entity;
1630     }
1631
1632     function findRelatedEntity ()
1633     {
1634         $msgs = array();
1635         $entcount = count($this->entities);
1636         for ($i = 0; $i < $entcount; $i++)
1637         {
1638             $type = $this->entities[$i]->header->type0.'/'.$this->entities[$i]->header->type1;
1639             if ($this->header->getParameter('type') == $type)
1640             {
1641                 $msgs[] = $this->entities[$i];
1642             }
1643         }
1644         return $msgs;
1645     }
1646
1647     function getAttachments($exclude_id=array(), $result = array())
1648     {
1649        if ($this->type0 == 'message' && $this->type1 == 'rfc822')
1650        {
1651           $this = $this->entities[0];
1652        }
1653        if (count($this->entities))
1654        {
1655           foreach ($this->entities as $entity)
1656           {
1657             $exclude = false;
1658             foreach ($exclude_id as $excl)
1659             {
1660                if ($entity->entity_id === $excl)
1661                {
1662                   $exclude = true;
1663                }
1664             }
1665             if (!$exclude)
1666             {
1667                if ($entity->type0 == 'multipart' &&
1668                    $entity->type1 != 'related')
1669                {
1670                   $result = $entity->getAttachments($exclude_id, $result);
1671                } else if ($entity->type0 != 'multipart')
1672                {
1673                   $result[] = $entity;
1674                }
1675             }
1676           }
1677        } else
1678        {
1679           $exclude = false;
1680           foreach ($exclude_id as $excl)
1681           {
1682              if ($this->entity_id == $excl)
1683              {
1684                 $exclude = true;
1685              }
1686           }
1687           if (!$exclude)
1688           {
1689              $result[] = $this;
1690           }
1691        }
1692        return $result;
1693     }
1694 }
1695
1696 class smime_message
1697 {
1698 }
1699
1700 class disposition
1701 {
1702     function disposition($name)
1703     {
1704        $this->name = $name;
1705        $this->properties = array();
1706     }
1707
1708     function getProperty($par)
1709     {
1710         $value = strtolower($par);
1711         if (isset($this->properties[$par]))
1712         {
1713            return $this->properties[$par];
1714         }
1715         return '';
1716     }
1717
1718 }
1719
1720 class language
1721 {
1722     function language($name)
1723     {
1724        $this->name = $name;
1725        $this->properties = array();
1726     }
1727 }
1728
1729 class content_type
1730 {
1731     var $type0='text',
1732         $type1='plain',
1733         $properties='';
1734     function content_type($type)
1735     {
1736        $pos = strpos($type,'/');
1737        if ($pos > 0)
1738        {
1739           $this->type0 = substr($type,0,$pos);
1740           $this->type1 = substr($type,$pos+1);
1741        } else
1742        {
1743           $this->type0 = $type;
1744        }
1745        $this->properties = array();
1746     }
1747 }
1748
1749 ?>