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         $encoding = '',
  37         $mlist = array(),
  38         $more_headers = array(); /* only needed for constructing headers
  39                                     in smtp.php */
  40     function parseHeader($hdr) {
  41         if (is_array($hdr)) {
  42             $hdr = implode('', $hdr);
  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                 //$name .= parseString($address,$pos);
 271                 $start_encoded = $pos;
 272                 ++$pos;
 273                 if ($address{$pos} == '"') {
 274                     ++$pos;
 275                 } else {
 276                     $personal_start = $personal_end = $pos;
 277                     while ($pos < $j) {
 278                         $personal_end = strpos($address,'"',$pos);
 279                         if (($personal_end-2)>0 && (substr($address,$personal_end-2,2) === '\\"' ||
 280                             substr($address,$personal_end-2,2) === '\\\\')) {
 281                             $pos = $personal_end+1;
 282                         } else {
 283                             $name .= substr($address,$personal_start,$personal_end-$personal_start);
 284                             break;
 285                         }
 286                     }
 287                     if ($personal_end) {
 288                         $pos = $personal_end+1;
 289                     } else {
 290                         $pos = $j;
 291                     }
 292                 }
 293                 $addr_start = $pos;
 294                 break;
 295             case '<':  /* get email address */
 296                 $addr_start = $pos;
 297                 $addr_end = strpos($address,'>',$addr_start);
 298                 $addr = substr($address,$addr_start+1,$addr_end-$addr_start-1);
 299                 if ($addr_end) {
 300                     $pos = $addr_end+1;
 301                 } else {
 302                     $addr = substr($address,$addr_start+1);
 303                     $pos = $j;
 304                 }
 305                 break;
 306             case '(':  /* rip off comments */
 307                 $comment_start = $pos;
 308                 $pos = strpos($address,')');
 309                 if ($pos !== false) {
 310                     $comment = substr($address, $comment_start+1,($pos-$comment_start-1));
 311                     $address_start = substr($address, 0, $comment_start);
 312                     $address_end   = substr($address, $pos + 1);
 313                     $address       = $address_start . $address_end;
 314                 }
 315                 $j = strlen($address);
 316                 if ($comment_start) {
 317                     $pos = $comment_start-1;
 318                 } else {
 319                     $pos = 0;
 320                 }
 321                 break;
 322             case ';':
 323                 if ($group) {
 324                     $address = substr($address, 0, $pos - 1);
 325                     ++$pos;
 326                     break;
 327                 }
 328             case ',':  /* we reached a delimiter */
 329                 if (!$name && !$addr) {
 330                     $addr = substr($address, 0, $pos);
 331                 } else if (!$addr) {
 332                     $addr = trim(substr($address, $addr_start, $pos));
 333                 } else if ($name == '') {
 334                     $name = trim(substr($address, 0, $addr_start));
 335                 }
 336                 $at = strpos($addr, '@');
 337                 $addr_structure = new AddressStructure();
 338                 if (!$name && $comment) $name = $comment;
 339                 if (!$is_encoded) {
 340                     $addr_structure->personal = encodeHeader($name);
 341                 } else {
 342                     $addr_structure->personal = $name;
 343                 }
 344                 $is_encoded = false;
 345                 $addr_structure->group = $group;
 346                 $grouplookup = false;
 347                 if ($at) {
 348                     $addr_structure->mailbox = substr($addr, 0, $at);
 349                     $addr_structure->host = substr($addr, $at+1);
 350                 } else {
 351                     /* if lookup function */
 352                     if ($lookup) {
 353                         $aAddr = call_user_func_array($lookup,array($addr));
 354                         if (isset($aAddr['email'])) {
 355                             if (strpos($aAddr['email'],',')) {
 356                                 $grouplookup = true;
 357                                 $addr_ar = $this->parseAddress($aAddr['email'], $ar, $addr_ar, $group, $host,$lookup);
 358                             } else {
 359                                 $at = strpos($aAddr['email'], '@');
 360                                 $addr_structure->mailbox = substr($aAddr['email'], 0, $at);
 361                                 $addr_structure->host = substr($aAddr['email'], $at+1);
 362                                 if (isset($aAddr['name'])) {
 363                                     $addr_structure->personal = $aAddr['name'];
 364                                 } else {
 365                                     $addr_structure->personal = encodeHeader($addr);
 366                                 }
 367                             }
 368                         }
 369                     }
 370                     if (!$grouplookup && !$addr_structure->mailbox) {
 371                         $addr_structure->mailbox = trim($addr);
 372                         if ($host) {
 373                             $addr_structure->host = $host;
 374                         }
 375                     }
 376                 }
 377                 $address = trim(substr($address, $pos+1));
 378                 $j = strlen($address);
 379                 $pos = 0;
 380                 $name = '';
 381                 $addr = '';
 382                 if (!$grouplookup) {
 383                     $addr_ar[] = $addr_structure;
 384                 }
 385                 break;
 386             case ':':  /* process the group addresses */
 387                 /* group marker */
 388                 $group = substr($address, 0, $pos);
 389                 $address = substr($address, $pos+1);
 390                 $result = $this->parseAddress($address, $ar, $addr_ar, $group, $lookup);
 391                 $addr_ar = $result[0];
 392                 $pos = $result[1];
 393                 $address = substr($address, $pos++);
 394                 $j = strlen($address);
 395                 $group = '';
 396                 break;
 397             case ' ':
 398                 ++$pos;
 399                 break;
 400             default:
 401                 /*
 402                  * this happens in the folowing situations :
 403                  * 1: unquoted personal name
 404                  * 2: emailaddress without < and >
 405                  * 3: unquoted personal name from compose that should be encoded.
 406                  * if it's a personal name then an emailaddress should follow
 407                  * the personal name may not have ',' inside it
 408                  * If it's a emailaddress then the personal name is not set.
 409                  * we should look for the delimiter ',' or a SPACE
 410                  */
 411                 /* check for emailaddress */
 412                 $i_space = strpos($address,' ',$pos);
 413                 $i_del = strpos($address,',',$pos);
 414                 if ($i_space || $i_del) {
 415                     if ($i_del) {
 416                         $address_part = substr($address,$pos,$i_del-$pos);
 417                     } else {
 418                         $address_part = substr($address,$pos);
 419                     }
 420                     if ($i = strpos($address_part,'@')) {
 421                         /* an email address is following */
 422                         if (($i+$pos) < $i_space) {
 423                             $addr_start = $pos;
 424                             if ($i_space < $i_del && $i_del) {
 425                                 if ($i_space) {
 426                                     $addr = substr($address,$pos,$i_space-$pos);
 427                                     $pos = $i_space;
 428                                 } else {
 429                                     $addr = substr($address,$pos);
 430                                     $pos = $j;
 431                                 }
 432                             } else {
 433                                 if ($i_del) {
 434                                     $addr = substr($address,$pos,$i_del-$pos);
 435                                     $pos = $i_del;
 436                                 } else if ($i_space) {
 437                                     $addr = substr($address,$pos,$i_space-$pos);
 438                                     $pos = $i_space+1;
 439                                 } else {
 440                                     $addr = substr($address,$pos);
 441                                     $pos = $j;
 442                                 }
 443                             }
 444                         } else {
 445                             if ($i_space) {
 446                                 $name .= substr($address,$pos,$i_space-$pos) . ' ';
 447                                 $addr_start = $i_space+1;
 448                                 $pos = $i_space+1;
 449                             } else {
 450                                 $addr = substr($address,$pos,$i_del-$pos);
 451                                 $addr_start = $pos;
 452                                 if ($i_del) {
 453                                     $pos = $i_del;
 454                                 } else {
 455                                     $pos = $j;
 456                                 }
 457                             }
 458                         }
 459                     } else {
 460                         /* email address without domain name, could be an alias */
 461                         $addr_start = $pos;
 462                         $addr = $address_part;
 463                         $pos = strlen($address_part) + $pos;
 464                     }
 465                 } else {
 466                     $addr = substr($address,$pos);
 467                     $addr_start = $pos;
 468                     $pos = $j;
 469                 }
 470                 break;
 471             }
 472         }
 473         if (!$name && !$addr) {
 474             $addr = substr($address, 0, $pos);
 475         } else if (!$addr) {
 476             $addr = trim(substr($address, $addr_start, $pos));
 477         } else if ($name == '') {
 478             $name = trim(substr($address, 0, $addr_start));
 479         }
 480         if (!$name && $comment) {
 481             $name = $comment;
 482         } else if ($name && $comment) {
 483             $name = $name .' ('.$comment.')';
 484         }
 485         $at = strpos($addr, '@');
 486         $addr_structure = new AddressStructure();
 487         $addr_structure->group = $group;
 488         if ($at) {
 489             $addr_structure->mailbox = trim(substr($addr, 0, $at));
 490             $addr_structure->host = trim(substr($addr, $at+1));
 491         } else {
 492             /* if lookup function */
 493             if ($lookup) {
 494                 $aAddr = call_user_func_array($lookup,array($addr));
 495                 if (isset($aAddr['email'])) {
 496                     if (strpos($aAddr['email'],',')) {
 497                         return $this->parseAddress($aAddr['email'], $ar, $addr_ar, $group, $host,$lookup);
 498                     } else {
 499                         $at = strpos($aAddr['email'], '@');
 500                         $addr_structure->mailbox = substr($aAddr['email'], 0, $at);
 501                         $addr_structure->host = substr($aAddr['email'], $at+1);
 502                         if (isset($aAddr['name']) && $aAddr['name']) {
 503                             $name = $aAddr['name'];
 504                         } else {
 505                             $name = $addr;
 506                         }
 507                     }
 508                 }
 509             }
 510             if (!$addr_structure->mailbox) {
 511                 $addr_structure->mailbox = trim($addr);
 512                 if ($host) {
 513                     $addr_structure->host = $host;
 514                 }
 515             }
 516         }
 517         $name = trim($name);
 518         if (!$is_encoded && !$group) {
 519             $name = encodeHeader($name);
 520         }
 521         if ($group && $addr == '') { /* no addresses found in group */
 522             $name = $group;
 523             $addr_structure->personal = $name;
 524             $addr_ar[] = $addr_structure;
 525             return (array($addr_ar,$pos+1 ));
 526         } elseif ($group) {
 527             $addr_structure->personal = $name;
 528             $addr_ar[] = $addr_structure;
 529             return (array($addr_ar,$pos+1 ));
 530         } else {
 531             $addr_structure->personal = $name;
 532             if ($name || $addr) {
 533                 $addr_ar[] = $addr_structure;
 534             }
 535         }
 536         if ($ar) {
 537             return ($addr_ar);
 538         }
 539         return ($addr_ar[0]);
 540     }
 541
 542     function parseContentType($value) {
 543         $pos = strpos($value, ';');
 544         $props = '';
 545         if ($pos > 0) {
 546            $type = trim(substr($value, 0, $pos));
 547            $props = trim(substr($value, $pos+1));
 548         } else {
 549            $type = $value;
 550         }
 551         $content_type = new ContentType($type);
 552         if ($props) {
 553             $properties = $this->parseProperties($props);
 554             if (!isset($properties['charset'])) {
 555                 $properties['charset'] = 'us-ascii';
 556             }
 557             $content_type->properties = $this->parseProperties($props);
 558         }
 559         $this->content_type = $content_type;
 560     }
 561
 562     function parseProperties($value) {
 563         $propArray = explode(';', $value);
 564         $propResultArray = array();
 565         foreach ($propArray as $prop) {
 566             $prop = trim($prop);
 567             $pos = strpos($prop, '=');
 568             if ($pos > 0)  {
 569                 $key = trim(substr($prop, 0, $pos));
 570                 $val = trim(substr($prop, $pos+1));
 571                 if ($val{0} == '"') {
 572                     $val = substr($val, 1, -1);
 573                 }
 574                 $propResultArray[$key] = $val;
 575             }
 576         }
 577         return $propResultArray;
 578     }
 579
 580     function parseDisposition($value) {
 581         $pos = strpos($value, ';');
 582         $props = '';
 583         if ($pos > 0) {
 584             $name = trim(substr($value, 0, $pos));
 585             $props = trim(substr($value, $pos+1));
 586         } else {
 587             $name = $value;
 588         }
 589         $props_a = $this->parseProperties($props);
 590         $disp = new Disposition($name);
 591         $disp->properties = $props_a;
 592         $this->disposition = $disp;
 593     }
 594
 595     function mlist($field, $value) {
 596         $res_a = array();
 597         $value_a = explode(',', $value);
 598         foreach ($value_a as $val) {
 599             $val = trim($val);
 600             if ($val{0} == '<') {
 601                 $val = substr($val, 1, -1);
 602             }
 603             if (substr($val, 0, 7) == 'mailto:') {
 604                 $res_a['mailto'] = substr($val, 7);
 605             } else {
 606                 $res_a['href'] = $val;
 607             }
 608         }
 609         $this->mlist[$field] = $res_a;
 610     }
 611
 612     /*
 613      * function to get the addres strings out of the header.
 614      * Arguments: string or array of strings !
 615      * example1: header->getAddr_s('to').
 616      * example2: header->getAddr_s(array('to', 'cc', 'bcc'))
 617      */
 618     function getAddr_s($arr, $separator = ',',$encoded=false) {
 619         $s = '';
 620
 621         if (is_array($arr)) {
 622             foreach($arr as $arg) {
 623                 if ($this->getAddr_s($arg, $separator, $encoded)) {
 624                     $s .= $separator . $result;
 625                 }
 626             }
 627             $s = ($s ? substr($s, 2) : $s);
 628         } else {
 629             $addr = $this->{$arr};
 630             if (is_array($addr)) {
 631                 foreach ($addr as $addr_o) {
 632                     if (is_object($addr_o)) {
 633                         if ($encoded) {
 634                             $s .= $addr_o->getEncodedAddress() . $separator;
 635                         } else {
 636                             $s .= $addr_o->getAddress() . $separator;
 637                         }
 638                     }
 639                 }
 640                 $s = substr($s, 0, -strlen($separator));
 641             } else {
 642                 if (is_object($addr)) {
 643                     if ($encoded) {
 644                         $s .= $addr->getEncodedAddress();
 645                     } else {
 646                         $s .= $addr->getAddress();
 647                     }
 648                 }
 649             }
 650         }
 651         return $s;
 652     }
 653
 654     function getAddr_a($arg, $excl_arr = array(), $arr = array()) {
 655         if (is_array($arg)) {
 656             foreach($arg as $argument) {
 657                 $arr = $this->getAddr_a($argument, $excl_arr, $arr);
 658             }
 659         } else {
 660             $addr = $this->{$arg};
 661             if (is_array($addr)) {
 662                 foreach ($addr as $next_addr) {
 663                     if (is_object($next_addr)) {
 664                         if (isset($next_addr->host) && ($next_addr->host != '')) {
 665                             $email = $next_addr->mailbox . '@' . $next_addr->host;
 666                         } else {
 667                             $email = $next_addr->mailbox;
 668                         }
 669                         $email = strtolower($email);
 670                         if ($email && !isset($arr[$email]) && !isset($excl_arr[$email])) {
 671                             $arr[$email] = $next_addr->personal;
 672                         }
 673                     }
 674                 }
 675             } else {
 676                 if (is_object($addr)) {
 677                     $email  = $addr->mailbox;
 678                     $email .= (isset($addr->host) ? '@' . $addr->host : '');
 679                     $email  = strtolower($email);
 680                     if ($email && !isset($arr[$email]) && !isset($excl_arr[$email])) {
 681                         $arr[$email] = $addr->personal;
 682                     }
 683                 }
 684             }
 685         }
 686         return $arr;
 687     }
 688
 689     function findAddress($address, $recurs = false) {
 690         $result = false;
 691         if (is_array($address)) {
 692             $i=0;
 693             foreach($address as $argument) {
 694                 $match = $this->findAddress($argument, true);
 695                 $last = end($match);
 696                 if ($match[1]) {
 697                     return $i;
 698                 } else {
 699                     if (count($match[0]) && !$result) {
 700                         $result = $i;
 701                     }
 702                 }
 703                 ++$i;
 704             }
 705         } else {
 706             if (!is_array($this->cc)) $this->cc = array();
 707             $srch_addr = $this->parseAddress($address);
 708             $results = array();
 709             foreach ($this->to as $to) {
 710                 if ($to->host == $srch_addr->host) {
 711                     if ($to->mailbox == $srch_addr->mailbox) {
 712                         $results[] = $srch_addr;
 713                         if ($to->personal == $srch_addr->personal) {
 714                             if ($recurs) {
 715                                 return array($results, true);
 716                             } else {
 717                                 return true;
 718                             }
 719                         }
 720                     }
 721                 }
 722             }
 723              foreach ($this->cc as $cc) {
 724                 if ($cc->host == $srch_addr->host) {
 725                     if ($cc->mailbox == $srch_addr->mailbox) {
 726                         $results[] = $srch_addr;
 727                         if ($cc->personal == $srch_addr->personal) {
 728                             if ($recurs) {
 729                                 return array($results, true);
 730                             } else {
 731                                 return true;
 732                             }
 733                         }
 734                     }
 735                 }
 736             }
 737             if ($recurs) {
 738                 return array($results, false);
 739             } elseif (count($result)) {
 740                 return true;
 741             } else {
 742                 return false;
 743             }
 744         }
 745         //exit;
 746         return $result;
 747     }
 748
 749     function getContentType($type0, $type1) {
 750         $type0 = $this->content_type->type0;
 751         $type1 = $this->content_type->type1;
 752         return $this->content_type->properties;
 753     }
 754 }
 755
 756 ?>