class/mime/Rfc822Header.class.php

   1 <?php
   2
   3 /**
   4  * Rfc822Header.class.php
   5  *
   6  * Copyright (c) 2003 The SquirrelMail Project Team
   7  * Licensed under the GNU GPL. For full terms see the file COPYING.
   8  *
   9  * This contains functions needed to handle mime messages.
  10  *
  11  * $Id$
  12  */
  13
  14 /*
  15  * rdc822_header class
  16  * input: header_string or array
  17  */
  18 class Rfc822Header {
  19     var $date = '',
  20         $subject = '',
  21         $from = array(),
  22         $sender = '',
  23         $reply_to = array(),
  24         $to = array(),
  25         $cc = array(),
  26         $bcc = array(),
  27         $in_reply_to = '',
  28         $message_id = '',
  29         $references = '',
  30         $mime = false,
  31         $content_type = '',
  32         $disposition = '',
  33         $xmailer = '',
  34         $priority = 3,
  35         $dnt = '',
  36         $mlist = array(),
  37         $more_headers = array(); /* only needed for constructing headers
  38                                     in smtp.php */
  39     function parseHeader($hdr) {
  40         if (is_array($hdr)) {
  41             $hdr = implode('', $hdr);
  42         }
  43
  44         /* First we unfold the header */
  45         $hdr = trim(str_replace(array("\r\n\t", "\r\n "),array('', ''), $hdr));
  46
  47         /* Now we can make a new header array with */
  48         /* each element representing a headerline  */
  49         $hdr = explode("\r\n" , $hdr);
  50         foreach ($hdr as $line) {
  51             $pos = strpos($line, ':');
  52             if ($pos > 0) {
  53                 $field = substr($line, 0, $pos);
  54                 if (!strstr($field,' ')) { /* valid field */
  55                         $value = trim(substr($line, $pos+1));
  56                         $this->parseField($field, $value);
  57                 }
  58             }
  59         }
  60         if ($this->content_type == '') {
  61             $this->parseContentType('text/plain; charset=us-ascii');
  62         }
  63     }
  64
  65     function stripComments($value) {
  66         $result = '';
  67         $cnt = strlen($value);
  68         for ($i = 0; $i < $cnt; ++$i) {
  69             switch ($value{$i}) {
  70                 case '"':
  71                     $result .= '"';
  72                     while ((++$i < $cnt) && ($value{$i} != '"')) {
  73                         if ($value{$i} == '\\') {
  74                             $result .= '\\';
  75                             ++$i;
  76                         }
  77                         $result .= $value{$i};
  78                     }
  79                     $result .= $value{$i};
  80                     break;
  81                 case '(':
  82                     $depth = 1;
  83                     while (($depth > 0) && (++$i < $cnt)) {
  84                         switch($value{$i}) {
  85                             case '\\':
  86                                 ++$i;
  87                                 break;
  88                             case '(':
  89                                 ++$depth;
  90                                 break;
  91                             case ')':
  92                                 --$depth;
  93                                 break;
  94                             default:
  95                                 break;
  96                         }
  97                     }
  98                     break;
  99                 default:
 100                     $result .= $value{$i};
 101                     break;
 102             }
 103         }
 104         return $result;
 105     }
 106
 107     function parseField($field, $value) {
 108         $field = strtolower($field);
 109         switch($field) {
 110             case 'date':
 111                 $value = $this->stripComments($value);
 112                 $d = strtr($value, array('  ' => ' '));
 113                 $d = explode(' ', $d);
 114                 $this->date = getTimeStamp($d);
 115                 break;
 116             case 'subject':
 117                 $this->subject = $value;
 118                 break;
 119             case 'from':
 120                 $this->from = $this->parseAddress($value,true);
 121                 break;
 122             case 'sender':
 123                 $this->sender = $this->parseAddress($value);
 124                 break;
 125             case 'reply-to':
 126                 $this->reply_to = $this->parseAddress($value, true);
 127                 break;
 128             case 'to':
 129                 $this->to = $this->parseAddress($value, true);
 130                 break;
 131             case 'cc':
 132                 $this->cc = $this->parseAddress($value, true);
 133                 break;
 134             case 'bcc':
 135                 $this->bcc = $this->parseAddress($value, true);
 136                 break;
 137             case 'in-reply-to':
 138                 $this->in_reply_to = $value;
 139                 break;
 140             case 'message-id':
 141                 $value = $this->stripComments($value);
 142                 $this->message_id = $value;
 143                 break;
 144             case 'references':
 145                 $value = $this->stripComments($value);
 146                 $this->references = $value;
 147                 break;
 148             case 'x-confirm-reading-to':
 149             case 'return-receipt-to':
 150             case 'disposition-notification-to':
 151                 $value = $this->stripComments($value);
 152                 $this->dnt = $this->parseAddress($value);
 153                 break;
 154             case 'mime-version':
 155                 $value = $this->stripComments($value);
 156                 $value = str_replace(' ', '', $value);
 157                 $this->mime = ($value == '1.0' ? true : $this->mime);
 158                 break;
 159             case 'content-type':
 160                 $value = $this->stripComments($value);
 161                 $this->parseContentType($value);
 162                 break;
 163             case 'content-disposition':
 164                 $value = $this->stripComments($value);
 165                 $this->parseDisposition($value);
 166                 break;
 167             case 'user-agent':
 168             case 'x-mailer':
 169                 $this->xmailer = $value;
 170                 break;
 171             case 'x-priority':
 172                 $this->priority = $value;
 173                 break;
 174             case 'list-post':
 175                 $value = $this->stripComments($value);
 176                 $this->mlist('post', $value);
 177                 break;
 178             case 'list-reply':
 179                 $value = $this->stripComments($value);
 180                 $this->mlist('reply', $value);
 181                 break;
 182             case 'list-subscribe':
 183                 $value = $this->stripComments($value);
 184                 $this->mlist('subscribe', $value);
 185                 break;
 186             case 'list-unsubscribe':
 187                 $value = $this->stripComments($value);
 188                 $this->mlist('unsubscribe', $value);
 189                 break;
 190             case 'list-archive':
 191                 $value = $this->stripComments($value);
 192                 $this->mlist('archive', $value);
 193                 break;
 194             case 'list-owner':
 195                 $value = $this->stripComments($value);
 196                 $this->mlist('owner', $value);
 197                 break;
 198             case 'list-help':
 199                 $value = $this->stripComments($value);
 200                 $this->mlist('help', $value);
 201                 break;
 202             case 'list-id':
 203                 $value = $this->stripComments($value);
 204                 $this->mlist('id', $value);
 205                 break;
 206             default:
 207                 break;
 208         }
 209     }
 210     /*
 211      * parseAddress: recursive function for parsing address strings and store
 212      *               them in an address stucture object.
 213      *               input: $address = string
 214      *                      $ar      = boolean (return array instead of only the
 215      *                                 first element)
 216      *                      $addr_ar = array with parsed addresses
 217      *                      $group   = string
 218      *                      $host    = string (default domainname in case of
 219      *                                 addresses without a domainname)
 220      *                      $lookup  = callback function (for lookup address
 221      *                                 strings which are probably nicks
 222      *                                 (without @ ) )
 223      *               output: array with addressstructure objects or only one
 224      *                       address_structure object.
 225      *  personal name: encoded: =?charset?Q|B?string?=
 226      *                 quoted:  "string"
 227      *                 normal:  string
 228      *  email        : <mailbox@host>
 229      *               : mailbox@host
 230      *  This function is also used for validating addresses returned from compose
 231      *  That's also the reason that the function became a little bit huge and horrible
 232      *  Todo: Find a way to clean up this mess a bit (Marc Groot Koerkamp)
 233      */
 234     function parseAddress
 235     ($address, $ar=false, $addr_ar = array(), $group = '', $host='',$lookup=false) {
 236         $pos = 0;
 237         $name = $addr = $comment = $is_encoded = '';
 238         /*
 239          * in case of 8 bit addresses some how <SPACE> is represented as
 240          * NON BRAKING SPACE
 241          * This only happens when we validate addresses from the compose form.
 242          *
 243          * Note: when other charsets have dificulties with characters
 244          * =,;:<>()"<SPACE>
 245          * then we should find out the value for those characters ans replace
 246          * them by proper ASCII values before we start parsing.
 247          *
 248          */
 249         $address = str_replace("\240",' ',$address);
 250
 251         $address = trim($address);
 252         $j = strlen($address);
 253
 254         while ($pos < $j) {
 255             $char = $address{$pos};
 256             switch ($char)
 257             {
 258             case '=':
 259                 /* get the encoded personal name */
 260                 if (preg_match('/^(=\?([^?]*)\?(Q|B)\?([^?]*)\?=)(.*)/Ui',substr($address,$pos),$reg)) {
 261                     $name .= $reg[1];
 262                     $pos += strlen($reg[1]);
 263                 } else {
 264                     ++$pos;
 265                 }
 266                 $addr_start = $pos;
 267                 $is_encoded = true;
 268                 break;
 269             case '"': /* get the personal name */
 270                 $start_encoded = $pos;
 271                 ++$pos;
 272                 if ($address{$pos} == '"') {
 273                     ++$pos;
 274                 } else {
 275                     $personal_start = $personal_end = $pos;
 276                     while ($pos < $j) {
 277                         $personal_end = strpos($address,'"',$pos);
 278                         if (($personal_end-2)>0 && (substr($address,$personal_end-2,2) === '\\"' ||
 279                             substr($address,$personal_end-2,2) === '\\\\')) {
 280                             $pos = $personal_end+1;
 281                         } else {
 282                             $name .= substr($address,$personal_start,$personal_end-$personal_start);
 283                             break;
 284                         }
 285                     }
 286                     if ($personal_end) {
 287                         $pos = $personal_end+1;
 288                     } else {
 289                         $pos = $j;
 290                     }
 291                 }
 292                 $addr_start = $pos;
 293                 break;
 294             case '<':  /* get email address */
 295                 $addr_start = $pos;
 296                 $addr_end = strpos($address,'>',$addr_start);
 297                 $addr = substr($address,$addr_start+1,$addr_end-$addr_start-1);
 298                 if ($addr_end) {
 299                     $pos = $addr_end+1;
 300                 } else {
 301                     $addr = substr($address,$addr_start+1);
 302                     $pos = $j;
 303                 }
 304                 break;
 305             case '(':  /* rip off comments */
 306                 $addr_start = $pos;
 307                 $pos = strpos($address,')');
 308                 if ($pos !== false) {
 309                     $comment = substr($address, $addr_start+1,($pos-$addr_start-1));
 310                     $address_start = substr($address, 0, $addr_start);
 311                     $address_end   = substr($address, $pos + 1);
 312                     $address       = $address_start . $address_end;
 313                 }
 314                 $j = strlen($address);
 315                 $pos = $addr_start + 1;
 316                 break;
 317             case ',':  /* we reached a delimiter */
 318                 if (!$name && !$addr) {
 319                     $addr = substr($address, 0, $pos);
 320                 } else if (!$addr) {
 321                     $addr = trim(substr($address, $addr_start, $pos));
 322                 } else if ($name == '') {
 323                     $name = trim(substr($address, 0, $addr_start));
 324                 }
 325                 $at = strpos($addr, '@');
 326                 $addr_structure = new AddressStructure();
 327                 if (!$name && $comment) $name = $comment;
 328                 if (!$is_encoded) {
 329                     $addr_structure->personal = encodeHeader($name);
 330                 } else {
 331                     $addr_structure->personal = $name;
 332                 }
 333                 $is_encoded = false;
 334                 $addr_structure->group = $group;
 335                 if ($at) {
 336                     $addr_structure->mailbox = substr($addr, 0, $at);
 337                     $addr_structure->host = substr($addr, $at+1);
 338                 } else {
 339                     /* if lookup function */
 340                     if ($lookup) {
 341                         $aAddr = call_user_func_array($lookup,array($addr));
 342                         if (isset($aAddr['email'])) {
 343                             $at = strpos($aAddr['email'], '@');
 344                             $addr_structure->mailbox = substr($aAddr['email'], 0, $at);
 345                             $addr_structure->host = substr($aAddr['email'], $at+1);
 346                             if (isset($aAddr['name'])) {
 347                                 $addr_structure->personal = $aAddr['name'];
 348                             } else {
 349                                 $addr_structure->personal = encodeHeader($addr);
 350                             }
 351                         }
 352                     }
 353                     if (!$addr_structure->mailbox) {
 354                         $addr_structure->mailbox = trim($addr);
 355                         if ($host) {
 356                             $addr_structure->host = $host;
 357                         }
 358                     }
 359                 }
 360                 $address = trim(substr($address, $pos+1));
 361                 $j = strlen($address);
 362                 $pos = 0;
 363                 $name = '';
 364                 $addr = '';
 365                 $addr_ar[] = $addr_structure;
 366                 break;
 367             case ':':  /* process the group addresses */
 368                 /* group marker */
 369                 $group = substr($address, 0, $pos);
 370                 $address = substr($address, $pos+1);
 371                 $result = $this->parseAddress($address, $ar, $addr_ar, $group);
 372                 $addr_ar = $result[0];
 373                 $pos = $result[1];
 374                 $address = substr($address, $pos++);
 375                 $j = strlen($address);
 376                 $group = '';
 377                 break;
 378             case ';':
 379                 if ($group) {
 380                     $address = substr($address, 0, $pos - 1);
 381                 }
 382                 ++$pos;
 383                 break;
 384             case ' ':
 385                 ++$pos;
 386                 break;
 387             default:
 388                 /*
 389                  * this happens in the folowing situations :
 390                  * 1: unquoted personal name
 391                  * 2: emailaddress without < and >
 392                  * 3: unquoted personal name from compose that should be encoded.
 393                  * if it's a personal name then an emailaddress should follow
 394                  * the personal name may not have ',' inside it
 395                  * If it's a emailaddress then the personal name is not set.
 396                  * we should look for the delimiter ',' or a SPACE
 397                  */
 398                 /* check for emailaddress */
 399                 $i_space = strpos($address,' ',$pos);
 400                 $i_del = strpos($address,',',$pos);
 401                 if ($i_space || $i_del) {
 402                     if ($i_del) {
 403                         $address_part = substr($address,$pos,$i_del-$pos);
 404                     } else {
 405                         $address_part = substr($address,$pos);
 406                     }
 407                     if ($i = strpos($address_part,'@')) {
 408                         /* an email address is following */
 409                         if (($i+$pos) < $i_space) {
 410                             $addr_start = $pos;
 411                             if ($i_space < $i_del && $i_del) {
 412                                 if ($i_space) {
 413                                     $addr = substr($address,$pos,$i_space-$pos);
 414                                     $pos = $i_space;
 415                                 } else {
 416                                     $addr = substr($address,$pos);
 417                                     $pos = $j;
 418                                 }
 419                             } else {
 420                                 if ($i_del) {
 421                                     $addr = substr($address,$pos,$i_del-$pos);
 422                                     $pos = $i_del;
 423                                 } else {
 424                                     $addr = substr($address,$pos);
 425                                     $pos = $j;
 426                                 }
 427                             }
 428                         } else {
 429                             if ($i_space) {
 430                                 $name .= substr($address,$pos,$i_space-$pos) .  ' ';
 431                                 $addr_start = $i_space+1;
 432                                 $pos = $i_space+1;
 433                             } else {
 434                                 $addr = substr($address,$pos,$i_del-$pos);
 435                                 $addr_start = $pos;
 436                                 if ($i_del) {
 437                                     $pos = $i_del;
 438                                 } else {
 439                                     $pos = $j;
 440                                 }
 441                             }
 442                         }
 443                     } else {
 444                         /* email address without domain name, could be an alias */
 445                         $addr_start = $pos;
 446                         $addr = $address_part;
 447                         $pos = strlen($address_part) + $pos;
 448                     }
 449                 } else {
 450                     $addr = substr($address,$pos);
 451                     $addr_start = $pos;
 452                     $pos = $j;
 453                 }
 454                 break;
 455             }
 456         }
 457         if (!$name && !$addr) {
 458             $addr = substr($address, 0, $pos);
 459         } else if (!$addr) {
 460             $addr = trim(substr($address, $addr_start, $pos));
 461         } else if ($name == '') {
 462             $name = trim(substr($address, 0, $addr_start));
 463         }
 464         if (!$name && $comment) {
 465             $name = $comment;
 466         } else if ($name && $comment) {
 467             $name = $name .' ('.$comment.')';
 468         }
 469         $at = strpos($addr, '@');
 470         $addr_structure = new AddressStructure();
 471         $addr_structure->group = $group;
 472         if ($at) {
 473             $addr_structure->mailbox = trim(substr($addr, 0, $at));
 474             $addr_structure->host = trim(substr($addr, $at+1));
 475         } else {
 476             /* if lookup function */
 477             if ($lookup) {
 478                 $aAddr = call_user_func_array($lookup,array($addr));
 479                 if (isset($aAddr['email'])) {
 480                     $at = strpos($aAddr['email'], '@');
 481                     $addr_structure->mailbox = substr($aAddr['email'], 0, $at);
 482                     $addr_structure->host = substr($aAddr['email'], $at+1);
 483                     if (isset($aAddr['name']) && $aAddr['name']) {
 484                         $name = $aAddr['name'];
 485                     } else {
 486                         $name = $addr;
 487                     }
 488                 }
 489             }
 490             if (!$addr_structure->mailbox) {
 491                 $addr_structure->mailbox = trim($addr);
 492                 if ($host) {
 493                     $addr_structure->host = $host;
 494                 }
 495             }
 496         }
 497         $name = trim($name);
 498         if (!$is_encoded && !$group) {
 499             $name = encodeHeader($name);
 500         }
 501         if ($group && $addr == '') { /* no addresses found in group */
 502             $name = $group;
 503             $addr_structure->personal = $name;
 504             $addr_ar[] = $addr_structure;
 505             return (array($addr_ar,$pos+1 ));
 506         } elseif ($group) {
 507             $addr_structure->personal = $name;
 508             $addr_ar[] = $addr_structure;
 509             return (array($addr_ar,$pos+1 ));
 510         } else {
 511             $addr_structure->personal = $name;
 512             if ($name || $addr) {
 513                 $addr_ar[] = $addr_structure;
 514             }
 515         }
 516         if ($ar) {
 517             return ($addr_ar);
 518         }
 519         return ($addr_ar[0]);
 520     }
 521
 522     function parseContentType($value) {
 523         $pos = strpos($value, ';');
 524         $props = '';
 525         if ($pos > 0) {
 526            $type = trim(substr($value, 0, $pos));
 527            $props = trim(substr($value, $pos+1));
 528         } else {
 529            $type = $value;
 530         }
 531         $content_type = new ContentType($type);
 532         if ($props) {
 533             $properties = $this->parseProperties($props);
 534             if (!isset($properties['charset'])) {
 535                 $properties['charset'] = 'us-ascii';
 536             }
 537             $content_type->properties = $this->parseProperties($props);
 538         }
 539         $this->content_type = $content_type;
 540     }
 541
 542     function parseProperties($value) {
 543         $propArray = explode(';', $value);
 544         $propResultArray = array();
 545         foreach ($propArray as $prop) {
 546             $prop = trim($prop);
 547             $pos = strpos($prop, '=');
 548             if ($pos > 0)  {
 549                 $key = trim(substr($prop, 0, $pos));
 550                 $val = trim(substr($prop, $pos+1));
 551                 if ($val{0} == '"') {
 552                     $val = substr($val, 1, -1);
 553                 }
 554                 $propResultArray[$key] = $val;
 555             }
 556         }
 557         return $propResultArray;
 558     }
 559
 560     function parseDisposition($value) {
 561         $pos = strpos($value, ';');
 562         $props = '';
 563         if ($pos > 0) {
 564             $name = trim(substr($value, 0, $pos));
 565             $props = trim(substr($value, $pos+1));
 566         } else {
 567             $name = $value;
 568         }
 569         $props_a = $this->parseProperties($props);
 570         $disp = new Disposition($name);
 571         $disp->properties = $props_a;
 572         $this->disposition = $disp;
 573     }
 574
 575     function mlist($field, $value) {
 576         $res_a = array();
 577         $value_a = explode(',', $value);
 578         foreach ($value_a as $val) {
 579             $val = trim($val);
 580             if ($val{0} == '<') {
 581                 $val = substr($val, 1, -1);
 582             }
 583             if (substr($val, 0, 7) == 'mailto:') {
 584                 $res_a['mailto'] = substr($val, 7);
 585             } else {
 586                 $res_a['href'] = $val;
 587             }
 588         }
 589         $this->mlist[$field] = $res_a;
 590     }
 591
 592     /*
 593      * function to get the addres strings out of the header.
 594      * Arguments: string or array of strings !
 595      * example1: header->getAddr_s('to').
 596      * example2: header->getAddr_s(array('to', 'cc', 'bcc'))
 597      */
 598     function getAddr_s($arr, $separator = ',',$encoded=false) {
 599         $s = '';
 600
 601         if (is_array($arr)) {
 602             foreach($arr as $arg) {
 603                 if ($this->getAddr_s($arg, $separator, $encoded)) {
 604                     $s .= $separator . $result;
 605                 }
 606             }
 607             $s = ($s ? substr($s, 2) : $s);
 608         } else {
 609             $addr = $this->{$arr};
 610             if (is_array($addr)) {
 611                 foreach ($addr as $addr_o) {
 612                     if (is_object($addr_o)) {
 613                         if ($encoded) {
 614                             $s .= $addr_o->getEncodedAddress() . $separator;
 615                         } else {
 616                             $s .= $addr_o->getAddress() . $separator;
 617                         }
 618                     }
 619                 }
 620                 $s = substr($s, 0, -strlen($separator));
 621             } else {
 622                 if (is_object($addr)) {
 623                     if ($encoded) {
 624                         $s .= $addr->getEncodedAddress();
 625                     } else {
 626                         $s .= $addr->getAddress();
 627                     }
 628                 }
 629             }
 630         }
 631         return $s;
 632     }
 633
 634     function getAddr_a($arg, $excl_arr = array(), $arr = array()) {
 635         if (is_array($arg)) {
 636             foreach($arg as $argument) {
 637                 $arr = $this->getAddr_a($argument, $excl_arr, $arr);
 638             }
 639         } else {
 640             $addr = $this->{$arg};
 641             if (is_array($addr)) {
 642                 foreach ($addr as $next_addr) {
 643                     if (is_object($next_addr)) {
 644                         if (isset($next_addr->host) && ($next_addr->host != '')) {
 645                             $email = $next_addr->mailbox . '@' . $next_addr->host;
 646                         } else {
 647                             $email = $next_addr->mailbox;
 648                         }
 649                         $email = strtolower($email);
 650                         if ($email && !isset($arr[$email]) && !isset($excl_arr[$email])) {
 651                             $arr[$email] = $next_addr->personal;
 652                         }
 653                     }
 654                 }
 655             } else {
 656                 if (is_object($addr)) {
 657                     $email  = $addr->mailbox;
 658                     $email .= (isset($addr->host) ? '@' . $addr->host : '');
 659                     $email  = strtolower($email);
 660                     if ($email && !isset($arr[$email]) && !isset($excl_arr[$email])) {
 661                         $arr[$email] = $addr->personal;
 662                     }
 663                 }
 664             }
 665         }
 666         return $arr;
 667     }
 668
 669     function findAddress($address, $recurs = false) {
 670         $result = false;
 671         if (is_array($address)) {
 672             $i=0;
 673             foreach($address as $argument) {
 674                 $match = $this->findAddress($argument, true);
 675                 $last = end($match);
 676                 if ($match[1]) {
 677                     return $i;
 678                 } else {
 679                     if (count($match[0]) && !$result) {
 680                         $result = $i;
 681                     }
 682                 }
 683                 ++$i;
 684             }
 685         } else {
 686             if (!is_array($this->cc)) $this->cc = array();
 687             $srch_addr = $this->parseAddress($address);
 688             $results = array();
 689             foreach ($this->to as $to) {
 690                 if ($to->host == $srch_addr->host) {
 691                     if ($to->mailbox == $srch_addr->mailbox) {
 692                         $results[] = $srch_addr;
 693                         if ($to->personal == $srch_addr->personal) {
 694                             if ($recurs) {
 695                                 return array($results, true);
 696                             } else {
 697                                 return true;
 698                             }
 699                         }
 700                     }
 701                 }
 702             }
 703              foreach ($this->cc as $cc) {
 704                 if ($cc->host == $srch_addr->host) {
 705                     if ($cc->mailbox == $srch_addr->mailbox) {
 706                         $results[] = $srch_addr;
 707                         if ($cc->personal == $srch_addr->personal) {
 708                             if ($recurs) {
 709                                 return array($results, true);
 710                             } else {
 711                                 return true;
 712                             }
 713                         }
 714                     }
 715                 }
 716             }
 717             if ($recurs) {
 718                 return array($results, false);
 719             } elseif (count($result)) {
 720                 return true;
 721             } else {
 722                 return false;
 723             }
 724         }
 725         //exit;
 726         return $result;
 727     }
 728
 729     function getContentType($type0, $type1) {
 730         $type0 = $this->content_type->type0;
 731         $type1 = $this->content_type->type1;
 732         return $this->content_type->properties;
 733     }
 734 }
 735
 736 ?>