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 addRFC822Header($read)
 671     {
 672         $header = new rfc822_header();
 673         $this->rfc822_header = $header->parseHeader($read);
 674     }
 675
 676     function getEntity($ent)
 677     {
 678         $cur_ent = $this->entity_id;
 679         $msg = $this;
 680         if ($cur_ent == '' || $cur_ent == '0')
 681         {
 682            $cur_ent_a = array();
 683         } else
 684         {
 685            $cur_ent_a = explode('.',$this->entity_id);
 686         }
 687         $ent_a = explode('.',$ent);
 688
 689         $cnt = count($ent_a);
 690
 691         for ($i=0;$i<$cnt -1;$i++)
 692         {
 693            if (isset($cur_ent_a[$i]) && $cur_ent_a[$i] != $ent_a[$i])
 694            {
 695               $msg = $msg->parent;
 696               $cur_ent_a = explode('.',$msg->entity_id);
 697               $i--;
 698            } else if (!isset($cur_ent_a[$i]))
 699            {
 700               if (isset($msg->entities[($ent_a[$i]-1)]))
 701               {
 702                 $msg = $msg->entities[($ent_a[$i]-1)];
 703               } else {
 704                 $msg = $msg->entities[0];
 705               }
 706            }
 707            if ($msg->type0 == 'message' && $msg->type1 == 'rfc822')
 708            {
 709               /*this is a header for a message/rfc822 entity */
 710               $msg = $msg->entities[0];
 711            }
 712         }
 713
 714         if ($msg->type0 == 'message' && $msg->type1 == 'rfc822')
 715         {
 716            /*this is a header for a message/rfc822 entity */
 717            $msg = $msg->entities[0];
 718         }
 719
 720         if (isset($msg->entities[($ent_a[$cnt-1])-1]))
 721         {
 722             $msg = $msg->entities[($ent_a[$cnt-1]-1)];
 723         }
 724
 725         return $msg;
 726     }
 727
 728     function setBody($s)
 729     {
 730         $this->body_part = $s;
 731     }
 732
 733     function clean_up()
 734     {
 735         $msg = $this;
 736         $msg->body_part = '';
 737         $i=0;
 738         while ( isset($msg->entities[$i]))
 739         {
 740             $msg->entities[$i]->clean_up();
 741             $i++;
 742         }
 743     }
 744
 745     function getMailbox()
 746     {
 747        $msg = $this;
 748        while (is_object($msg->parent))
 749        {
 750           $msg = $msg->parent;
 751        }
 752        return $msg->mailbox;
 753     }
 754
 755     function calcEntity($msg)
 756     {
 757         if ($this->type0 == 'message' && $this->type1 == 'rfc822')
 758         {
 759             $msg->entity_id = $this->entity_id .'.0'; /* header of message/rfc822 */
 760         } else if (isset($this->entity_id) && $this->entity_id !='')
 761         {
 762             $ent_no = count($this->entities)+1;
 763             $par_ent = substr($this->entity_id,-2);
 764             if ($par_ent{0} == '.')
 765             {
 766                $par_ent = $par_ent{1};
 767             }
 768             if ($par_ent == '0')
 769             {
 770                 $ent_no = count($this->entities)+1;
 771                 if ($ent_no > 0)
 772                 {
 773                    $ent = substr($this->entity_id,0,strrpos($this->entity_id,'.'));
 774                    if ($ent)
 775                    {
 776                       $ent = $ent . ".$ent_no";
 777                    } else
 778                    {
 779                       $ent = $ent_no;
 780                    }
 781                    $msg->entity_id = $ent;
 782                 } else
 783                 {
 784                    $msg->entity_id = $ent_no;
 785                 }
 786             } else
 787             {
 788                 $ent = $this->entity_id . ".$ent_no";
 789                 $msg->entity_id = $ent;
 790             }
 791         } else
 792         {
 793             $msg->entity_id = '0';
 794         }
 795         return $msg->entity_id;
 796     }
 797
 798
 799     /*
 800      * Bodystructure parser, a recursive function for generating the
 801      * entity-tree with all the mime-parts.
 802      *
 803      * It follows RFC2060 and stores all the described fields in the
 804      * message object.
 805      *
 806      * Question/Bugs:
 807      *
 808      * Ask for me (Marc Groot Koerkamp, stekkel@users.sourceforge.net.
 809      *
 810      */
 811     function parseStructure($read, $i=0)
 812     {
 813       $arg_no = 0;
 814       $arg_a = array();
 815       $cnt = strlen($read);
 816       while ($i < $cnt)
 817       {
 818         $char = strtoupper($read{$i});
 819         switch ($char)
 820         {
 821         case '(':
 822            if ($arg_no == 0 )
 823            {
 824               if (!isset($msg))
 825               {
 826                  $msg = new message();
 827                  $hdr = new msg_header();
 828                  $hdr->type0 = 'text';
 829                  $hdr->type1 = 'plain';
 830                  $hdr->encoding = 'us-ascii';
 831                  $msg->entity_id = $this->calcEntity($msg);
 832               } else
 833               {
 834                    $msg->header->type0 = 'multipart';
 835                    $msg->type0 = 'multipart';
 836                    while ($read{$i} == '(')
 837                    {
 838                       $res = $msg->parseStructure($read,$i);
 839                       $i = $res[1];
 840                       $msg->addEntity($res[0]);
 841                    }
 842               }
 843            } else
 844            {
 845               switch ($arg_no)
 846               {
 847               case 1:
 848                  /* multipart properties */
 849                  $i++;
 850                  $res = $this->parseProperties($read,$i);
 851
 852                  $arg_a[] = $res[0];
 853                  $i = $res[1];
 854                  $arg_no++;
 855                  break;
 856               case 2:
 857                  if (isset($msg->type0) &&  $msg->type0 == 'multipart')
 858                  {
 859                     $i++;
 860                     $res = $msg->parseDisposition($read,$i);
 861                     $arg_a[] = $res[0];
 862                     $i = $res[1];
 863                  } else /* properties */
 864                  {
 865                     $res = $msg->parseProperties($read,$i);
 866                     $arg_a[] = $res[0];
 867                     $i = $res[1];
 868                  }
 869                  $arg_no++;
 870                  break;
 871               case 3:
 872                  if (isset($msg->type0) &&  $msg->type0 == 'multipart')
 873                  {
 874                     $i++;
 875                     $res= $msg->parseLanguage($read,$i);
 876                     $arg_a[] = $res[0];
 877                     $i = $res[1];
 878                  }
 879               case 7:
 880                  if ($arg_a[0] == 'message' && $arg_a[1] == 'rfc822')
 881                  {
 882                      $msg->header->type0 = $arg_a[0];
 883                      $msg->type0 = $arg_a[0];
 884                      $msg->header->type1 = $arg_a[1];
 885                      $msg->type1 = $arg_a[1];
 886                      $rfc822_hdr = new rfc822_header();
 887                      $res = $msg->parseEnvelope($read,$i,$rfc822_hdr);
 888                      $i = $res[1];
 889                      $msg->rfc822_header =  $res[0];
 890                      $i++;
 891                      while ($i < $cnt && $read{$i} != '(')
 892                      {
 893                        $i++;
 894                      }
 895                      $res = $msg->parseStructure($read,$i);
 896                      $i = $res[1];
 897                      $msg->addEntity($res[0]);
 898                  }
 899                  break;
 900               case 8:
 901                  $i++;
 902                  $res = $msg->parseDisposition($read,$i);
 903                  $arg_a[] = $res[0];
 904                  $i = $res[1];
 905                  $arg_no++;
 906                  break;
 907               case 9:
 908                  if ($arg_a[0] == 'text' ||
 909                      ($arg_a[0] == 'message' && $arg_a[1] == 'rfc822'))
 910                  {
 911                     $i++;
 912                     $res = $msg->parseDisposition($read,$i);
 913                     $arg_a[] = $res[0];
 914                     $i = $res[1];
 915                  } else
 916                  {
 917                     $i++;
 918                     $res = $msg->parseLanguage($read,$i);
 919                     $arg_a[] = $res[0];
 920                     $i = $res[1];
 921                  }
 922                  $arg_no++;
 923                  break;
 924               case 10:
 925                  if ($arg_a[0] == 'text' ||
 926                      ($arg_a[0] == 'message' && $arg_a[1] == 'rfc822'))
 927                  {
 928                     $i++;
 929                     $res = $msg->parseLanguage($read,$i);
 930                     $arg_a[] = $res[0];
 931                     $i = $res[1];
 932                  } else
 933                  {
 934                     $i = $msg->parseParenthesis($read,$i);
 935                     $arg_a[] = ''; /* not yet desribed in rfc2060 */
 936                  }
 937                  $arg_no++;
 938                  break;
 939               default:
 940                  /* unknown argument, skip this part */
 941                  $i = $msg->parseParenthesis($read,$i);
 942                  $arg_a[] = '';
 943                  $arg_no++;
 944                  break;
 945               } /* switch */
 946            }
 947            break;
 948         case '"':
 949            /* inside an entity -> start processing */
 950            $debug = substr($read,$i,20);
 951            $res = $msg->parseQuote($read,$i);
 952            $arg_s = $res[0];
 953            $i = $res[1];
 954            $arg_no++;
 955            if ($arg_no < 3) $arg_s = strtolower($arg_s); /* type0 and type1 */
 956            $arg_a[] = $arg_s;
 957            break;
 958         case 'n':
 959         case 'N':
 960            /* probably NIL argument */
 961            if (strtoupper(substr($read,$i,4)) == 'NIL ' ||
 962                strtoupper(substr($read,$i,4)) == 'NIL)')
 963            {
 964               $arg_a[] = '';
 965               $arg_no++;
 966               $i = $i+2;
 967            }
 968            break;
 969         case '{':
 970            /* process the literal value */
 971            $res = $msg->parseLiteral($read,$i);
 972            $arg_s = $res[0];
 973            $i = $res[1];
 974            $arg_no++;
 975            break;
 976         case (is_numeric($read{$i}) ):
 977            /* process integers */
 978            if ($read{$i} == ' ') break;
 979            $arg_s = $read{$i};;
 980            $i++;
 981            while (preg_match('/^[0-9]{1}$/',$read{$i}))
 982            {
 983               $arg_s .= $read{$i};
 984               $i++;
 985            }
 986            $arg_no++;
 987            $arg_a[] = $arg_s;
 988            break;
 989         case ')':
 990            if (isset($msg->type0) && $msg->type0 == 'multipart')
 991            {
 992               $multipart = true;
 993            } else
 994            {
 995               $multipart = false;
 996            }
 997            if (!$multipart)
 998            {
 999               if ($arg_a[0] == 'text' ||
1000                   ($arg_a[0] == 'message' && $arg_a[1] == 'rfc822'))
1001               {
1002                  $shifted_args = true;
1003               } else
1004               {
1005                  $shifted_args = false;
1006               }
1007               $hdr->type0 = $arg_a[0];
1008               $hdr->type1 = $arg_a[1];
1009
1010               $msg->type0 = $arg_a[0];
1011               $msg->type1 = $arg_a[1];
1012
1013               $arr = $arg_a[2];
1014               if (is_array($arr))
1015               {
1016                  $hdr->parameters = $arg_a[2];
1017               }
1018               $hdr->id = str_replace( '<', '', str_replace( '>', '', $arg_a[3] ) );
1019               $hdr->description = $arg_a[4];
1020               $hdr->encoding = strtolower($arg_a[5]);
1021               $hdr->entity_id = $msg->entity_id;
1022               $hdr->size = $arg_a[6];
1023               if ($shifted_args)
1024               {
1025                  $hdr->lines = $arg_a[7];
1026                  if (isset($arg_a[8]))
1027                  {
1028                     $hdr->md5 = $arg_a[8];
1029                  }
1030                  if (isset($arg_a[9]))
1031                  {
1032                     $hdr->disposition = $arg_a[9];
1033                  }
1034                  if (isset($arg_a[10]))
1035                  {
1036                     $hdr->language = $arg_a[10];
1037                  }
1038               } else
1039               {
1040                  if (isset($arg_a[7]))
1041                  {
1042                     $hdr->md5 = $arg_a[7];
1043                  }
1044                  if (isset($arg_a[8]))
1045                  {
1046                     $hdr->disposition = $arg_a[8];
1047                  }
1048                  if (isset($arg_a[9]))
1049                  {
1050                     $hdr->language = $arg_a[9];
1051                  }
1052               }
1053               $msg->header = $hdr;
1054               $arg_no = 0;
1055               $i++;
1056               if (substr($msg->entity_id,-2) == '.0' && $msg->type0 !='multipart')
1057               {
1058                  $msg->entity_id++;
1059               }
1060               return (array($msg, $i));
1061            } else
1062            {
1063               $hdr->type0 = 'multipart';
1064               $hdr->type1 = $arg_a[0];
1065               $msg->type0 = 'multipart';
1066               $msg->type1 = $arg_a[0];
1067               if (is_array($arg_a[1]))
1068               {
1069                  $hdr->parameters = $arg_a[1];
1070               }
1071               if (isset($arg_a[2]))
1072               {
1073                  $hdr->disposition = $arg_a[2];
1074               }
1075               if (isset($arg_a[3]))
1076               {
1077                  $hdr->language = $arg_a[3];
1078               }
1079               $msg->header = $hdr;
1080               return (array($msg, $i));
1081            }
1082         default:
1083            break;
1084         } /* switch */
1085         $i++;
1086       } /* while */
1087     } /* parsestructure */
1088
1089     function parseProperties($read, $i)
1090     {
1091       $properties = array();
1092       $arg_s = '';
1093       $prop_name = '';
1094       while ($read{$i} != ')')
1095       {
1096          if ($read{$i} == '"')
1097          {
1098             $res = $this->parseQuote($read,$i);
1099             $arg_s = $res[0];
1100             $i = $res[1];
1101          } else if ($read{$i} == '{')
1102          {
1103             $res = $this->parseLiteral($read,$i);
1104             $arg_s = $res[0];
1105             $i = $res[1];
1106          }
1107          if ($prop_name == '' && $arg_s)
1108          {
1109             $prop_name = strtolower($arg_s);
1110             $properties[$prop_name] = '';
1111             $arg_s = '';
1112          } elseif ($prop_name != '' && $arg_s != '')
1113          {
1114             $properties[$prop_name] = $arg_s;
1115             $prop_name = '';
1116             $arg_s = '';
1117          }
1118          $i++;
1119       }
1120       return (array($properties, $i));
1121     }
1122
1123     function parseEnvelope($read, $i, $hdr)
1124     {
1125         $arg_no = 0;
1126         $arg_a = array();
1127         $cnt = strlen($read);
1128         while ($i< $cnt && $read{$i} != ')')
1129         {
1130            $i++;
1131            $char = strtoupper($read{$i});
1132            switch ($char)
1133            {
1134            case '"':
1135                $res = $this->parseQuote($read,$i);
1136                $arg_a[] = $res[0];
1137                $i = $res[1];
1138                $arg_no++;
1139                break;
1140            case '{':
1141                $res = $this->parseLiteral($read,$i);
1142                $arg_a[] = $res[0];
1143                $i = $res[1];
1144                $arg_no++;
1145                break;
1146            case 'N':
1147                /* probably NIL argument */
1148                if (strtoupper(substr($read,$i,3)) == 'NIL') {
1149                   $arg_a[] = '';
1150                   $arg_no++;
1151                   $i = $i+2;
1152                }
1153                break;
1154            case '(':
1155                /* Address structure
1156                 * With group support.
1157                 * Note: Group support is useless on SMTP connections
1158                 * because the protocol doesn't support it
1159                 */
1160                $addr_a = array();
1161                $group = '';
1162                $a=0;
1163                while ($i < $cnt && $read{$i} != ')')
1164                {
1165                   if ($read{$i} == '(')
1166                   {
1167                      $res = $this->parseAddress($read,$i);
1168                      $addr = $res[0];
1169                      $i = $res[1];
1170                      if ($addr->host == '' && $addr->mailbox != '')
1171                      {
1172                         /* start of group */
1173                         $group = $addr->mailbox;
1174                         $group_addr = $addr;
1175                         $j = $a;
1176                      } elseif ($group && $addr->host == '' && $addr->mailbox == '')
1177                      {
1178                         /* end group */
1179                         if ($a == $j+1) /* no group members */
1180                         {
1181                            $group_addr->group = $group;
1182                            $group_addr->mailbox = '';
1183                            $group_addr->personal = "$group: Undisclosed recipients;";
1184                            $addr_a[] = $group_addr;
1185                            $group ='';
1186                         }
1187                      } else
1188                      {
1189                         $addr->group = $group;
1190                         $addr_a[] = $addr;
1191                      }
1192                      $a++;
1193                   }
1194                   $i++;
1195                }
1196                $arg_a[] = $addr_a;
1197                break;
1198            default:
1199                break;
1200            }
1201            $i++;
1202         }
1203         if (count($arg_a) > 9)
1204         {
1205             /* argument 1: date */
1206             $d = strtr($arg_a[0], array('  ' => ' '));
1207             $d = explode(' ', $d);
1208             $hdr->date = getTimeStamp($d);
1209             /* argument 2: subject */
1210             if (!trim($arg_a[1]))
1211             {
1212                 $arg_a[1]= _("(no subject)");
1213             }
1214             $hdr->subject = $arg_a[1];
1215             /* argument 3: from */
1216             $hdr->from = $arg_a[2][0];
1217             /* argument 4: sender */
1218             $hdr->sender = $arg_a[3][0];
1219             /* argument 5: reply-to */
1220             $hdr->replyto = $arg_a[4][0];
1221             /* argument 6: to */
1222             $hdr->to = $arg_a[5];
1223             /* argument 7: cc */
1224             $hdr->cc = $arg_a[6];
1225             /* argument 8: bcc */
1226             $hdr->bcc = $arg_a[7];
1227             /* argument 9: in-reply-to */
1228             $hdr->inreplyto = $arg_a[8];
1229             /* argument 10: message-id */
1230             $hdr->message_id = $arg_a[9];
1231         }
1232         return (array($hdr,$i));
1233     }
1234
1235     function parseLiteral($read, $i)
1236     {
1237         $lit_cnt = '';
1238         $i++;
1239         while ($read{$i} != '}')
1240         {
1241            $lit_cnt .= $read{$i};
1242            $i++;
1243         }
1244         $lit_cnt +=2; /* add the { and } characters */
1245         $s = '';
1246         for ($j = 0; $j < $lit_cnt; $j++)
1247         {
1248            $i++;
1249            $s .= $read{$i};
1250         }
1251         return (array($s, $i));
1252     }
1253
1254     function parseQuote($read, $i)
1255     {
1256         $i++;
1257         $s = '';
1258         while ($read{$i} != '"')
1259         {
1260            if ($read{$i} == '\\')
1261            {
1262                $i++;
1263            }
1264            $s .= $read{$i};
1265            $i++;
1266         }
1267         return (array($s, $i));
1268     }
1269
1270     function parseAddress($read, $i)
1271     {
1272         $arg_a = array();
1273         while ($read{$i} != ')' )
1274         {
1275            $char = strtoupper($read{$i});
1276            switch ($char)
1277            {
1278            case '"':
1279                $res = $this->parseQuote($read,$i);
1280                $arg_a[] = $res[0];
1281                $i = $res[1];
1282                break;
1283            case '{':
1284                $res = $this->parseLiteral($read,$i);
1285                $arg_a[] = $res[0];
1286                $i = $res[1];
1287                break;
1288            case 'n':
1289            case 'N':
1290                if (strtoupper(substr($read,$i,3)) == 'NIL') {
1291                   $arg_a[] = '';
1292                   $i = $i+2;
1293                }
1294                break;
1295            default:
1296                break;
1297            }
1298            $i++;
1299         }
1300         if (count($arg_a) == 4)
1301         {
1302             $adr = new address_structure();
1303             $adr->personal = $arg_a[0];
1304             $adr->adl = $arg_a[1];
1305             $adr->mailbox = $arg_a[2];
1306             $adr->host = $arg_a[3];
1307         } else
1308         {
1309            $adr = '';
1310         }
1311         return (array($adr,$i));
1312     }
1313
1314     function parseDisposition($read,$i)
1315     {
1316         $arg_a = array();
1317         while ($read{$i} != ')')
1318         {
1319            switch ($read{$i})
1320            {
1321            case '"':
1322                $res = $this->parseQuote($read,$i);
1323                $arg_a[] = $res[0];
1324                $i = $res[1];
1325                break;
1326            case '{':
1327                $res = $this->parseLiteral($read,$i);
1328                $arg_a[] = $res[0];
1329                $i = $res[1];
1330                break;
1331            case '(':
1332                $res = $this->parseProperties($read,$i);
1333                $arg_a[] = $res[0];
1334                $i = $res[1];
1335                break;
1336            default:
1337                break;
1338            }
1339            $i++;
1340         }
1341         if (isset($arg_a[0]))
1342         {
1343            $disp = new disposition($arg_a[0]);
1344            if (isset($arg_a[1]))
1345            {
1346               $disp->properties = $arg_a[1];
1347            }
1348         }
1349         if (is_object($disp))
1350         {
1351            return (array($disp, $i));
1352         } else
1353         {
1354            return (array('',$i));
1355         }
1356     }
1357
1358     function parseLanguage($read,$i)
1359     {
1360         /* no idea how to process this one without examples */
1361         $arg_a = array();
1362         while ($read{$i} != ')')
1363         {
1364            switch ($read{$i})
1365            {
1366            case '"':
1367                $res = $this->parseQuote($read,$i);
1368                $arg_a[] = $res[0];
1369                $i = $res[1];
1370                break;
1371            case '{':
1372                $res = $this->parseLiteral($read,$i);
1373                $arg_a[] = $res[0];
1374                $i = $res[1];
1375                break;
1376            case '(':
1377                $res = $this->parseProperties($read,$i);
1378                $arg_a[] = $res[0];
1379                $i = $res[1];
1380                break;
1381            default:
1382                break;
1383            }
1384            $i++;
1385         }
1386         if (isset($arg_a[0]))
1387         {
1388            $lang = new language($arg_a[0]);
1389            if (isset($arg_a[1]))
1390            {
1391               $lang->properties = $arg_a[1];
1392            }
1393         }
1394         if (is_object($lang))
1395         {
1396            return (array($lang, $i));
1397         } else
1398         {
1399            return (array('', $i));
1400         }
1401     }
1402
1403     function parseParenthesis($read,$i)
1404     {
1405         while ($read{$i} != ')')
1406         {
1407            switch ($read{$i})
1408            {
1409            case '"':
1410                $res = $this->parseQuote($read,$i);
1411                $i = $res[1];
1412                break;
1413            case '{':
1414                $res = $this->parseLiteral($read,$i);
1415                $i = $res[1];
1416                break;
1417            case '(':
1418                $res = $this->parseParenthesis($read,$i);
1419                $i = $res[1];
1420                break;
1421            default:
1422                break;
1423            }
1424            $i++;
1425         }
1426         return $i;
1427     }
1428
1429     /* function to fill the message structure in case the bodystructure
1430     isn't available NOT FINISHED YET
1431     */
1432     function parseMessage($read, $type0, $type1)
1433     {
1434         switch ($type0)
1435         {
1436         case 'message':
1437             $rfc822_header = true;
1438             $mime_header = false;
1439             break;
1440         case 'multipart':
1441             $mime_header = true;
1442             $rfc822_header = false;
1443             break;
1444         default:
1445             return $read;
1446         }
1447
1448         for ($i=1; $i < $count; $i++)
1449         {
1450             $line = trim($body[$i]);
1451             if ( ( $mime_header || $rfc822_header) &&
1452                  (preg_match("/^.*boundary=\"?(.+(?=\")|.+).*/i",$line,$reg)) )
1453             {
1454                 $bnd = $reg[1];
1455                 $bndreg = $bnd;
1456                 $bndreg = str_replace("\\","\\\\",$bndreg);
1457                 $bndreg = str_replace("?","\\?",$bndreg);
1458                 $bndreg = str_replace("+","\\+",$bndreg);
1459                 $bndreg = str_replace(".","\\.",$bndreg);
1460                 $bndreg = str_replace("/","\\/",$bndreg);
1461                 $bndreg = str_replace("-","\\-",$bndreg);
1462                 $bndreg = str_replace("(","\\(",$bndreg);
1463                 $bndreg = str_replace(")","\\)",$bndreg);
1464             } elseif ( $rfc822_header && $line == '' )
1465             {
1466                 $rfc822_header = false;
1467                 if ($msg->type0 == 'multipart')
1468                 {
1469                     $mime_header = true;
1470                 }
1471             }
1472
1473             if (($line{0} == '-' || $rfc822_header)  && isset($boundaries[0]))
1474             {
1475                 $cnt=count($boundaries)-1;
1476                 $bnd = $boundaries[$cnt]['bnd'];
1477                 $bndreg = $boundaries[$cnt]['bndreg'];
1478
1479                 $regstr = '/^--'."($bndreg)".".*".'/';
1480                 if (preg_match($regstr,$line,$reg) )
1481                 {
1482                     $bndlen = strlen($reg[1]);
1483                     $bndend = false;
1484                     if (strlen($line) > ($bndlen + 3))
1485                     {
1486                         if ($line{$bndlen+2} == '-' && $line{$bndlen+3} == '-')
1487                             $bndend = true;
1488                     }
1489                     if ($bndend)
1490                     {
1491                         /* calc offset and return $msg */
1492         //              $entStr = CalcEntity("$entStr",-1);
1493                         array_pop($boundaries);
1494                         $mime_header = true;
1495                         $bnd_end = true;
1496                     } else
1497                     {
1498                         $mime_header = true;
1499                         $bnd_end = false;
1500 //              $entStr = CalcEntity("$entStr",0);
1501                         $content_indx++;
1502                     }
1503                 }  else
1504                 {
1505                     if ($header)
1506                     {
1507                     }
1508                 }
1509             }
1510         }
1511     }
1512
1513     function findDisplayEntity ($entity = array(), $alt_order = array('text/plain','text/html'))
1514     {
1515        $found = false;
1516        $type = $this->type0.'/'.$this->type1;
1517        if ( $type == 'multipart/alternative')
1518        {
1519             $msg = $this->findAlternativeEntity($alt_order);
1520             if (count($msg->entities) == 0)
1521             {
1522                 $entity[] = $msg->entity_id;
1523             } else
1524             {
1525                 $entity = $msg->findDisplayEntity($entity, $alt_order);
1526             }
1527             $found = true;
1528        } else if ( $type == 'multipart/related')
1529        {
1530             $msgs = $this->findRelatedEntity();
1531             for ($i = 0; $i < count($msgs); $i++)
1532             {
1533                 $msg = $msgs[$i];
1534                 if (count($msg->entities) == 0)
1535                 {
1536                     $entity[] = $msg->entity_id;
1537                 } else
1538                 {
1539                     $entity = $msg->findDisplayEntity($entity,$alt_order);
1540                 }
1541                 $found = true;
1542             }
1543        } else if ( $this->type0 == 'text' &&
1544              ( $this->type1 == 'plain' ||
1545                $this->type1 == 'html' ||
1546                $this->type1 == 'message') &&
1547                isset($this->entity_id) )
1548        {
1549           if (count($this->entities) == 0)
1550           {
1551             if (strtolower($this->header->disposition->name) != 'attachment')
1552             {
1553                 $entity[] = $this->entity_id;
1554             }
1555           }
1556        }
1557        $i = 0;
1558        while ( isset($this->entities[$i]) &&  !$found &&
1559               (strtolower($this->entities[$i]->header->disposition->name)
1560                 != 'attachment') &&
1561               ($this->entities[$i]->type0 != 'message' &&
1562               $this->entities[$i]->type1 != 'rfc822' )
1563              )
1564        {
1565             $entity = $this->entities[$i]->findDisplayEntity($entity, $alt_order);
1566             $i++;
1567        }
1568        return( $entity );
1569     }
1570
1571     function findAlternativeEntity ($alt_order)
1572     {
1573        /* if we are dealing with alternative parts then we choose the best
1574         * viewable message supported by SM.
1575         */
1576         $best_view = 0;
1577         $ent_id = 0;
1578         $k = 0;
1579         for ($i = 0; $i < count($this->entities); $i ++)
1580         {
1581             $type = $this->entities[$i]->header->type0.'/'.$this->entities[$i]->header->type1;
1582             if ($type == 'multipart/related')
1583             {
1584                $type = $this->entities[$i]->header->getParameter('type');
1585             }
1586             for ($j = $k; $j < count($alt_order); $j++)
1587             {
1588                 if ($alt_order[$j] == $type && $j > $best_view)
1589                 {
1590                     $best_view = $j;
1591                     $ent_id = $i;
1592                     $k = $j;
1593                 }
1594             }
1595         }
1596         return $this->entities[$ent_id];
1597     }
1598
1599     function findRelatedEntity ()
1600     {
1601         $msgs = array();
1602         for ($i = 0; $i < count($this->entities); $i ++)
1603         {
1604             $type = $this->entities[$i]->header->type0.'/'.$this->entities[$i]->header->type1;
1605             if ($this->header->getParameter('type') == $type)
1606             {
1607                 $msgs[] = $this->entities[$i];
1608             }
1609         }
1610         return $msgs;
1611     }
1612
1613     function getAttachments($exclude_id=array(), $result = array())
1614     {
1615        if ($this->type0 == 'message' && $this->type1 == 'rfc822')
1616        {
1617           $this = $this->entities[0];
1618        }
1619        if (count($this->entities))
1620        {
1621           foreach ($this->entities as $entity)
1622           {
1623             $exclude = false;
1624             foreach ($exclude_id as $excl)
1625             {
1626                if ($entity->entity_id === $excl)
1627                {
1628                   $exclude = true;
1629                }
1630             }
1631             if (!$exclude)
1632             {
1633                if ($entity->type0 == 'multipart' &&
1634                    $entity->type1 != 'related')
1635                {
1636                   $result = $entity->getAttachments($exclude_id, $result);
1637                } else if ($entity->type0 != 'multipart')
1638                {
1639                   $result[] = $entity;
1640                }
1641             }
1642           }
1643        } else
1644        {
1645           $exclude = false;
1646           foreach ($exclude_id as $excl)
1647           {
1648              if ($this->entity_id == $excl)
1649              {
1650                 $exclude = true;
1651              }
1652           }
1653           if (!$exclude)
1654           {
1655              $result[] = $this;
1656           }
1657        }
1658        return $result;
1659     }
1660 }
1661
1662 class smime_message
1663 {
1664 }
1665
1666 class disposition
1667 {
1668     function disposition($name)
1669     {
1670        $this->name = $name;
1671        $this->properties = array();
1672     }
1673
1674     function getProperty($par)
1675     {
1676         $value = strtolower($par);
1677         if (isset($this->properties[$par]))
1678         {
1679            return $this->properties[$par];
1680         }
1681         return '';
1682     }
1683
1684 }
1685
1686 class language
1687 {
1688     function language($name)
1689     {
1690        $this->name = $name;
1691        $this->properties = array();
1692     }
1693 }
1694
1695 class content_type
1696 {
1697     var $type0='text',
1698         $type1='plain',
1699         $properties='';
1700     function content_type($type)
1701     {
1702        $pos = strpos($type,'/');
1703        if ($pos > 0)
1704        {
1705           $this->type0 = substr($type,0,$pos);
1706           $this->type1 = substr($type,$pos+1);
1707        } else
1708        {
1709           $this->type0 = $type;
1710        }
1711        $this->properties = array();
1712     }
1713 }
1714
1715 ?>