functions/mime.php

   1 <?php
   2
   3 /**
   4  * mime.php
   5  *
   6  * Copyright (c) 1999-2002 The SquirrelMail Project Team
   7  * Licensed under the GNU GPL. For full terms see the file COPYING.
   8  *
   9  * This contains the functions necessary to detect and decode MIME
  10  * messages.
  11  *
  12  * $Id$
  13  */
  14
  15 require_once('../functions/imap.php');
  16 require_once('../functions/attachment_common.php');
  17
  18 /** Setting up the objects that have the structure for the message **/
  19 class msg_header {
  20     /** msg_header contains generic variables for values that **/
  21     /** could be in a header.                                 **/
  22
  23     var $type0 = '', $type1 = '', $boundary = '', $charset = '',
  24         $encoding = '', $size = 0, $to = array(), $from = '', $date = '',
  25         $cc = array(), $bcc = array(), $reply_to = '', $subject = '',
  26         $id = 0, $mailbox = '', $description = '', $filename = '',
  27         $entity_id = 0, $message_id = 0, $name = '', $priority = 3;
  28 }
  29
  30 class message {
  31     /** message is the object that contains messages.  It is a recursive
  32       object in that through the $entities variable, it can contain
  33       more objects of type message.  See documentation in mime.txt for
  34       a better description of how this works.
  35     **/
  36     var $header = '', $entities = array();
  37
  38     function addEntity ($msg) {
  39         $this->entities[] = $msg;
  40     }
  41 }
  42
  43 /* --------------------------------------------------------------------------------- */
  44 /* MIME DECODING                                                                     */
  45 /* --------------------------------------------------------------------------------- */
  46
  47 /* This function gets the structure of a message and stores it in the "message" class.
  48  * It will return this object for use with all relevant header information and
  49  * fully parsed into the standard "message" object format.
  50  */
  51 function mime_structure ($imap_stream, $header) {
  52
  53     sqimap_messages_flag ($imap_stream, $header->id, $header->id, 'Seen');
  54     $ssid = sqimap_session_id();
  55     $lsid = strlen( $ssid );
  56     $id = $header->id;
  57     fputs ($imap_stream, "$ssid FETCH $id BODYSTRUCTURE\r\n");
  58     //
  59     // This should use sqimap_read_data instead of reading it itself
  60     //
  61     $read = fgets ($imap_stream, 9216);
  62     $bodystructure = '';
  63     while ( substr($read, 0, $lsid) <> $ssid &&
  64          !feof( $imap_stream ) ) {
  65         $bodystructure .= $read;
  66         $read = fgets ($imap_stream, 9216);
  67     }
  68     $read = $bodystructure;
  69
  70     // isolate the body structure and remove beginning and end parenthesis
  71     $read = trim(substr ($read, strpos(strtolower($read), 'bodystructure') + 13));
  72     $read = trim(substr ($read, 0, -1));
  73     $end = mime_match_parenthesis(0, $read);
  74     while ($end == strlen($read)-1) {
  75         $read = trim(substr ($read, 0, -1));
  76         $read = trim(substr ($read, 1));
  77         $end = mime_match_parenthesis(0, $read);
  78     }
  79
  80     $msg = mime_parse_structure ($read, 0);
  81     $msg->header = $header;
  82
  83     return( $msg );
  84 }
  85
  86 /* this starts the parsing of a particular structure.  It is called recursively,
  87  * so it can be passed different structures.  It returns an object of type
  88  * $message.
  89  * First, it checks to see if it is a multipart message.  If it is, then it
  90  * handles that as it sees is necessary.  If it is just a regular entity,
  91  * then it parses it and adds the necessary header information (by calling out
  92  * to mime_get_elements()
  93  */
  94 function mime_parse_structure ($structure, $ent_id) {
  95
  96   $msg = new message();
  97   if ($structure{0} == '(') {
  98      $ent_id = mime_new_element_level($ent_id);
  99      $start = $end = -1;
 100      do {
 101         $start = $end+1;
 102         $end = mime_match_parenthesis ($start, $structure);
 103
 104         $element = substr($structure, $start+1, ($end - $start)-1);
 105         $ent_id = mime_increment_id ($ent_id);
 106         $newmsg = mime_parse_structure ($element, $ent_id);
 107         $msg->addEntity ($newmsg);
 108      } while ($structure{$end+1} == '(');
 109   } else {
 110      // parse the elements
 111      $msg = mime_get_element ($structure, $msg, $ent_id);
 112   }
 113   return $msg;
 114 }
 115
 116 /* Increments the element ID.  An element id can look like any of
 117  * the following:  1, 1.2, 4.3.2.4.1, etc.  This function increments
 118  * the last number of the element id, changing 1.2 to 1.3.
 119  */
 120 function mime_increment_id ($id) {
 121
 122     if (strpos($id, '.')) {
 123         $first = substr($id, 0, strrpos($id, '.'));
 124         $last = substr($id, strrpos($id, '.')+1);
 125         $last++;
 126         $new = $first . '.' .$last;
 127     } else {
 128         $new = $id + 1;
 129     }
 130
 131     return $new;
 132 }
 133
 134 /*
 135  * See comment for mime_increment_id().
 136  * This adds another level on to the entity_id changing 1.3 to 1.3.0
 137  * NOTE:  1.3.0 is not a valid element ID.  It MUST be incremented
 138  *        before it can be used.  I left it this way so as not to have
 139  *        to make a special case if it is the first entity_id.  It
 140  *        always increments it, and that works fine.
 141  */
 142 function mime_new_element_level ($id) {
 143
 144     if (!$id) {
 145         $id = 0;
 146     } else {
 147         $id = $id . '.0';
 148     }
 149
 150     return( $id );
 151 }
 152
 153 function mime_get_element (&$structure, $msg, $ent_id) {
 154
 155   $elem_num = 1;
 156   $msg->header = new msg_header();
 157   $msg->header->entity_id = $ent_id;
 158   $properties = array();
 159
 160   while (strlen($structure) > 0) {
 161      $structure = trim($structure);
 162      $char = $structure{0};
 163
 164      if (strtolower(substr($structure, 0, 3)) == 'nil') {
 165         $text = '';
 166         $structure = substr($structure, 3);
 167      } else if ($char == '"') {
 168         // loop through until we find the matching quote, and return that as a string
 169         $pos = 1;
 170         $text = '';
 171         while ( ($char = $structure{$pos} ) <> '"' && $pos < strlen($structure)) {
 172            $text .= $char;
 173            $pos++;
 174         }
 175         $structure = substr($structure, strlen($text) + 2);
 176      } else if ($char == '(') {
 177         // comment me
 178         $end = mime_match_parenthesis (0, $structure);
 179         $sub = substr($structure, 1, $end-1);
 180         $properties = mime_get_props($properties, $sub);
 181         $structure = substr($structure, strlen($sub) + 2);
 182      } else {
 183         // loop through until we find a space or an end parenthesis
 184         $pos = 0;
 185         $char = $structure{$pos};
 186         $text = '';
 187         while ($char != ' ' && $char != ')' && $pos < strlen($structure)) {
 188            $text .= $char;
 189            $pos++;
 190            $char = $structure{$pos};
 191         }
 192         $structure = substr($structure, strlen($text));
 193      }
 194
 195      // This is where all the text parts get put into the header
 196      switch ($elem_num) {
 197         case 1:
 198            $msg->header->type0 = strtolower($text);
 199            break;
 200         case 2:
 201            $msg->header->type1 = strtolower($text);
 202            break;
 203         case 4: // Id
 204            // Invisimail enclose images with <>
 205            $msg->header->id = str_replace( '<', '', str_replace( '>', '', $text ) );
 206            break;
 207         case 5:
 208            $msg->header->description = $text;
 209            break;
 210         case 6:
 211            $msg->header->encoding = strtolower($text);
 212            break;
 213         case 7:
 214            $msg->header->size = $text;
 215            break;
 216         default:
 217            if ($msg->header->type0 == 'text' && $elem_num == 8) {
 218               // This is a plain text message, so lets get the number of lines
 219               // that it contains.
 220               $msg->header->num_lines = $text;
 221
 222            } else if ($msg->header->type0 == 'message' && $msg->header->type1 == 'rfc822' && $elem_num == 8) {
 223               // This is an encapsulated message, so lets start all over again and
 224               // parse this message adding it on to the existing one.
 225               $structure = trim($structure);
 226               if ( $structure{0} == '(' ) {
 227                  $e = mime_match_parenthesis (0, $structure);
 228                  $structure = substr($structure, 0, $e);
 229                  $structure = substr($structure, 1);
 230                  $m = mime_parse_structure($structure, $msg->header->entity_id);
 231
 232                  // the following conditional is there to correct a bug that wasn't
 233                  // incrementing the entity IDs correctly because of the special case
 234                  // that message/rfc822 is.  This fixes it fine.
 235                  if (substr($structure, 1, 1) != '(')
 236                     $m->header->entity_id = mime_increment_id(mime_new_element_level($ent_id));
 237
 238                  // Now we'll go through and reformat the results.
 239                  if ($m->entities) {
 240                     for ($i=0; $i < count($m->entities); $i++) {
 241                        $msg->addEntity($m->entities[$i]);
 242                     }
 243                  } else {
 244                     $msg->addEntity($m);
 245                  }
 246                  $structure = "";
 247               }
 248            }
 249            break;
 250      }
 251      $elem_num++;
 252      $text = "";
 253   }
 254   // loop through the additional properties and put those in the various headers
 255   if ($msg->header->type0 != 'message') {
 256      for ($i=0; $i < count($properties); $i++) {
 257         $msg->header->{$properties[$i]['name']} = $properties[$i]['value'];
 258      }
 259   }
 260
 261   return $msg;
 262 }
 263
 264 /*
 265  * I did most of the MIME stuff yesterday (June 20, 2000), but I couldn't
 266  * figure out how to do this part, so I decided to go to bed.  I woke up
 267  * in the morning and had a flash of insight.  I went to the white-board
 268  * and scribbled it out, then spent a bit programming it, and this is the
 269  * result.  Nothing complicated, but I think my brain was fried yesterday.
 270  * Funny how that happens some times.
 271  *
 272  * This gets properties in a nested parenthesisized list.  For example,
 273  * this would get passed something like:  ("attachment" ("filename" "luke.tar.gz"))
 274  * This returns an array called $props with all paired up properties.
 275  * It ignores the "attachment" for now, maybe that should change later
 276  * down the road.  In this case, what is returned is:
 277  *    $props[0]["name"] = "filename";
 278  *    $props[0]["value"] = "luke.tar.gz";
 279  */
 280 function mime_get_props ($props, $structure) {
 281
 282   while (strlen($structure) > 0) {
 283      $structure = trim($structure);
 284      $char = $structure{0};
 285
 286      if ($char == '"') {
 287         $pos = 1;
 288         $tmp = '';
 289         while ( ( $char = $structure{$pos} ) != '"' &&
 290                 $pos < strlen($structure)) {
 291            $tmp .= $char;
 292            $pos++;
 293         }
 294         $structure = trim(substr($structure, strlen($tmp) + 2));
 295         $char = $structure{0};
 296
 297         if ($char == '"') {
 298            $pos = 1;
 299            $value = '';
 300            while ( ( $char = $structure{$pos} ) != '"' &&
 301                    $pos < strlen($structure) ) {
 302               $value .= $char;
 303               $pos++;
 304            }
 305            $structure = trim(substr($structure, strlen($tmp) + 2));
 306
 307            $k = count($props);
 308            $props[$k]['name'] = strtolower($tmp);
 309            $props[$k]['value'] = $value;
 310         } else if ($char == '(') {
 311            $end = mime_match_parenthesis (0, $structure);
 312            $sub = substr($structure, 1, $end-1);
 313        if (! isset($props))
 314            $props = array();
 315            $props = mime_get_props($props, $sub);
 316            $structure = substr($structure, strlen($sub) + 2);
 317         }
 318         return $props;
 319      } else if ($char == '(') {
 320         $end = mime_match_parenthesis (0, $structure);
 321         $sub = substr($structure, 1, $end-1);
 322         $props = mime_get_props($props, $sub);
 323         $structure = substr($structure, strlen($sub) + 2);
 324         return $props;
 325      } else {
 326         return $props;
 327      }
 328   }
 329 }
 330
 331 /*
 332  *  Matches parenthesis.  It will return the position of the matching
 333  *  parenthesis in $structure.  For instance, if $structure was:
 334  *     ("text" "plain" ("val1name", "1") nil ... )
 335  *     x                                         x
 336  *  then this would return 42 to match up those two.
 337  */
 338 function mime_match_parenthesis ($pos, $structure) {
 339
 340     $j = strlen( $structure );
 341
 342     // ignore all extra characters
 343     // If inside of a string, skip string -- Boundary IDs and other
 344     // things can have ) in them.
 345     if ( $structure{$pos} != '(' ) {
 346         return( $j );
 347     }
 348
 349     while ( $pos < $j ) {
 350         $pos++;
 351         if ($structure{$pos} == ')') {
 352             return $pos;
 353         } elseif ($structure{$pos} == '"') {
 354             $pos++;
 355             while ( $structure{$pos} != '"' &&
 356                     $pos < $j ) {
 357                if (substr($structure, $pos, 2) == '\\"') {
 358                   $pos++;
 359                } elseif (substr($structure, $pos, 2) == '\\\\') {
 360                   $pos++;
 361                }
 362                $pos++;
 363             }
 364         } elseif ( $structure{$pos} == '(' ) {
 365             $pos = mime_match_parenthesis ($pos, $structure);
 366         }
 367     }
 368     echo _("Error decoding mime structure.  Report this as a bug!") . '<br>';
 369     return( $pos );
 370 }
 371
 372 function mime_fetch_body($imap_stream, $id, $ent_id ) {
 373
 374     /*
 375      * do a bit of error correction.  If we couldn't find the entity id, just guess
 376      * that it is the first one.  That is usually the case anyway.
 377      */
 378     if (!$ent_id) {
 379         $ent_id = 1;
 380     }
 381
 382     $cmd = "FETCH $id BODY[$ent_id]";
 383     $data = sqimap_run_command ($imap_stream, $cmd, true, $response, $message);
 384
 385     do {
 386         $topline = array_shift( $data );
 387     } while( $topline && $topline == '*' && !preg_match( '/\\* [0-9] FETCH.*/i', $topline )) ;
 388     $wholemessage = implode('', $data);
 389     if (ereg('\\{([^\\}]*)\\}', $topline, $regs)) {
 390
 391         $ret = substr( $wholemessage, 0, $regs[1] );
 392         /*
 393             There is some information in the content info header that could be important
 394             in order to parse html messages. Let's get them here.
 395         */
 396         if ( $ret{0} == '<' ) {
 397             $data = sqimap_run_command ($imap_stream, "FETCH $id BODY[$ent_id.MIME]", true, $response, $message);
 398             /* BASE within HTML documents is illegal (see w3 spec)
 399 *            $base = '';
 400 *            $k = 10;
 401 *            foreach( $data as $d ) {
 402 *                if ( substr( $d, 0, 13 ) == 'Content-Base:' ) {
 403 *                    $j = strlen( $d );
 404 *                    $i = 13;
 405 *                    $base = '';
 406 *                    while ( $i < $j &&
 407 *                           ( !isNoSep( $d{$i} ) || $d{$i} == '"' )  )
 408 *                        $i++;
 409 *                    while ( $i < $j ) {
 410 *                        if ( isNoSep( $d{$i} ) )
 411 *                            $base .= $d{$i};
 412 *                        $i++;
 413 *                    }
 414 *                    $k = 0;
 415 *                } elseif ( $k == 1 && !isnosep( $d{0} ) ) {
 416 *                    $base .= substr( $d, 1 );
 417 *                }
 418 *                $k++;
 419 *            }
 420 *            if ( $base <> '' ) {
 421 *                $ret = "<base href=\"$base\">" . $ret;
 422 *            }
 423 *           */
 424         }
 425     } else if (ereg('"([^"]*)"', $topline, $regs)) {
 426         $ret = $regs[1];
 427     } else {
 428         global $where, $what, $mailbox, $passed_id, $startMessage;
 429         $par = 'mailbox=' . urlencode($mailbox) . "&amp;passed_id=$passed_id";
 430         if (isset($where) && isset($what)) {
 431             $par .= '&amp;where='. urlencode($where) . "&amp;what=" . urlencode($what);
 432         } else {
 433             $par .= "&amp;startMessage=$startMessage&amp;show_more=0";
 434         }
 435         $par .= '&amp;response=' . urlencode($response) .
 436                 '&amp;message=' . urlencode($message).
 437                 '&amp;topline=' . urlencode($topline);
 438
 439         echo   '<tt><br>' .
 440                '<table width="80%"><tr>' .
 441                '<tr><td colspan=2>' .
 442                _("Body retrieval error. The reason for this is most probably that the message is malformed. Please help us making future versions better by submitting this message to the developers knowledgebase!") .
 443                " <A HREF=\"../src/retrievalerror.php?$par\"><br>" .
 444                _("Submit message") . '</A><BR>&nbsp;' .
 445                '</td></tr>' .
 446                '<td><b>' . _("Command:") . "</td><td>$cmd</td></tr>" .
 447                '<td><b>' . _("Response:") . "</td><td>$response</td></tr>" .
 448                '<td><b>' . _("Message:") . "</td><td>$message</td></tr>" .
 449                '<td><b>' . _("FETCH line:") . "</td><td>$topline</td></tr>" .
 450                "</table><BR></tt></font><hr>";
 451
 452         $data = sqimap_run_command ($imap_stream, "FETCH $passed_id BODY[]", true, $response, $message);
 453         array_shift($data);
 454         $wholemessage = implode('', $data);
 455
 456         $ret = $wholemessage;
 457     }
 458     return( $ret );
 459 }
 460
 461 function mime_print_body_lines ($imap_stream, $id, $ent_id, $encoding) {
 462     // do a bit of error correction.  If we couldn't find the entity id, just guess
 463     // that it is the first one.  That is usually the case anyway.
 464     if (!$ent_id) {
 465         $ent_id = 1;
 466     }
 467     $sid = sqimap_session_id();
 468     // Don't kill the connection if the browser is over a dialup
 469     // and it would take over 30 seconds to download it.
 470
 471     // don´t call set_time_limit in safe mode.
 472     if (!ini_get("safe_mode")) {
 473         set_time_limit(0);
 474     }
 475
 476     fputs ($imap_stream, "$sid FETCH $id BODY[$ent_id]\r\n");
 477     $cnt = 0;
 478     $continue = true;
 479     $read = fgets ($imap_stream,4096);
 480     // This could be bad -- if the section has sqimap_session_id() . ' OK'
 481     // or similar, it will kill the download.
 482     while (!ereg("^".$sid." (OK|BAD|NO)(.*)$", $read, $regs)) {
 483       if (trim($read) == ')==') {
 484           $read1 = $read;
 485           $read = fgets ($imap_stream,4096);
 486           if (ereg("^".$sid." (OK|BAD|NO)(.*)$", $read, $regs)) {
 487               return;
 488           } else {
 489               echo decodeBody($read1, $encoding) .
 490                    decodeBody($read, $encoding);
 491           }
 492       } else if ($cnt) {
 493           echo decodeBody($read, $encoding);
 494       }
 495       $read = fgets ($imap_stream,4096);
 496       $cnt++;
 497     }
 498 }
 499
 500 /* -[ END MIME DECODING ]----------------------------------------------------------- */
 501
 502
 503
 504 /* This is the first function called.  It decides if this is a multipart
 505    message or if it should be handled as a single entity
 506  */
 507 function decodeMime ($imap_stream, &$header) {
 508     global $username, $key, $imapServerAddress, $imapPort;
 509     return mime_structure ($imap_stream, $header);
 510 }
 511
 512 // This is here for debugging purposese.  It will print out a list
 513 // of all the entity IDs that are in the $message object.
 514 /*
 515 function listEntities ($message) {
 516 if ($message) {
 517  if ($message->header->entity_id)
 518  echo "<tt>" . $message->header->entity_id . ' : ' . $message->header->type0 . '/' . $message->header->type1 . '<br>';
 519  for ($i = 0; $message->entities[$i]; $i++) {
 520     $msg = listEntities($message->entities[$i], $ent_id);
 521     if ($msg)
 522        return $msg;
 523  }
 524 }
 525 }
 526 */
 527
 528 /* returns a $message object for a particular entity id */
 529 function getEntity ($message, $ent_id) {
 530     if ($message) {
 531         if ($message->header->entity_id == $ent_id && strlen($ent_id) == strlen($message->header->entity_id)) {
 532             return $message;
 533         } else {
 534             for ($i = 0; isset($message->entities[$i]); $i++) {
 535                 $msg = getEntity ($message->entities[$i], $ent_id);
 536                 if ($msg) {
 537                     return $msg;
 538                 }
 539             }
 540         }
 541     }
 542 }
 543
 544 /*
 545  * figures out what entity to display and returns the $message object
 546  * for that entity.
 547  */
 548 function findDisplayEntity ($message, $textOnly = 1)   {
 549     global $show_html_default;
 550
 551     $entity = 0;
 552
 553     if ($message) {
 554         if ( $message->header->type0 == 'multipart' &&
 555              ( $message->header->type1 == 'alternative' ||
 556                $message->header->type1 == 'mixed' ||
 557                $message->header->type1 == 'related' ) &&
 558              $show_html_default && ! $textOnly ) {
 559             $entity = findDisplayEntityHTML($message);
 560         }
 561
 562         // Show text/plain or text/html -- the first one we find.
 563         if ( $entity == 0 &&
 564              $message->header->type0 == 'text' &&
 565              ( $message->header->type1 == 'plain' ||
 566                $message->header->type1 == 'html' ) &&
 567              isset($message->header->entity_id) ) {
 568             $entity = $message->header->entity_id;
 569         }
 570
 571         $i = 0;
 572         while ($entity == 0 && isset($message->entities[$i]) ) {
 573             $entity = findDisplayEntity($message->entities[$i], $textOnly);
 574             $i++;
 575         }
 576     }
 577
 578     return( $entity );
 579 }
 580
 581 /* Shows the HTML version */
 582 function findDisplayEntityHTML ($message) {
 583
 584     if ( $message->header->type0 == 'text' &&
 585          $message->header->type1 == 'html' &&
 586          isset($message->header->entity_id)) {
 587         return $message->header->entity_id;
 588     }
 589     for ($i = 0; isset($message->entities[$i]); $i ++) {
 590         $entity = findDisplayEntityHTML($message->entities[$i]);
 591         if ($entity != 0) {
 592             return $entity;
 593         }
 594     }
 595
 596     return 0;
 597 }
 598
 599 /* This returns a parsed string called $body. That string can then
 600 be displayed as the actual message in the HTML. It contains
 601 everything needed, including HTML Tags, Attachments at the
 602 bottom, etc.
 603 */
 604 function formatBody($imap_stream, $message, $color, $wrap_at) {
 605     // this if statement checks for the entity to show as the
 606     // primary message. To add more of them, just put them in the
 607     // order that is their priority.
 608     global $startMessage, $username, $key, $imapServerAddress, $imapPort,
 609            $show_html_default, $has_unsafe_images, $view_unsafe_images, $sort;
 610
 611     $has_unsafe_images = 0;
 612
 613     $id = $message->header->id;
 614     $urlmailbox = urlencode($message->header->mailbox);
 615
 616     // Get the right entity and redefine message to be this entity
 617     // Pass the 0 to mean that we want the 'best' viewable one
 618     $ent_num = findDisplayEntity ($message, 0);
 619     $body_message = getEntity($message, $ent_num);
 620     if (($body_message->header->type0 == 'text') ||
 621         ($body_message->header->type0 == 'rfc822')) {
 622
 623         $body = mime_fetch_body ($imap_stream, $id, $ent_num);
 624         $body = decodeBody($body, $body_message->header->encoding);
 625         $hookResults = do_hook("message_body", $body);
 626         $body = $hookResults[1];
 627
 628         // If there are other types that shouldn't be formatted, add
 629         // them here
 630         if ($body_message->header->type1 == 'html') {
 631             if ( $show_html_default <> 1 ) {
 632                 $body = strip_tags( $body );
 633                 translateText($body, $wrap_at, $body_message->header->charset);
 634             } else {
 635                 $body = MagicHTML( $body, $id );
 636             }
 637         } else {
 638             translateText($body, $wrap_at, $body_message->header->charset);
 639         }
 640
 641         $body .= "<CENTER><SMALL><A HREF=\"../src/download.php?absolute_dl=true&amp;passed_id=$id&amp;passed_ent_id=$ent_num&amp;mailbox=$urlmailbox&amp;showHeaders=1\">". _("Download this as a file") ."</A></SMALL></CENTER><BR>";
 642         if ($has_unsafe_images) {
 643             if ($view_unsafe_images) {
 644                 $body .= "<CENTER><SMALL><A HREF=\"read_body.php?passed_id=$id&amp;mailbox=$urlmailbox&amp;sort=$sort&amp;startMessage=$startMessage&amp;show_more=0\">". _("Hide Unsafe Images") ."</A></SMALL></CENTER><BR>\n";
 645             } else {
 646                 $body .= "<CENTER><SMALL><A HREF=\"read_body.php?passed_id=$id&amp;mailbox=$urlmailbox&amp;sort=$sort&amp;startMessage=$startMessage&amp;show_more=0&amp;view_unsafe_images=1\">". _("View Unsafe Images") ."</A></SMALL></CENTER><BR>\n";
 647             }
 648         }
 649
 650         /** Display the ATTACHMENTS: message if there's more than one part **/
 651         if (isset($message->entities[0])) {
 652             $body .= formatAttachments ($message, $ent_num, $message->header->mailbox, $id);
 653         }
 654     } else {
 655         $body = formatAttachments ($message, -1, $message->header->mailbox, $id);
 656     }
 657     return ($body);
 658 }
 659
 660 /*
 661  * A recursive function that returns a list of attachments with links
 662  * to where to download these attachments
 663  */
 664 function formatAttachments($message, $ent_id, $mailbox, $id) {
 665     global $where, $what;
 666     global $startMessage, $color;
 667     static $ShownHTML = 0;
 668
 669     $body = '';
 670     if ($ShownHTML == 0) {
 671
 672         $ShownHTML = 1;
 673         $body .= "<TABLE WIDTH=\"100%\" CELLSPACING=0 CELLPADDING=2 BORDER=0 BGCOLOR=\"$color[0]\"><TR>\n" .
 674                 "<TH ALIGN=\"left\" BGCOLOR=\"$color[9]\"><B>\n" .
 675                 _("Attachments") . ':' .
 676                 "</B></TH></TR><TR><TD>\n" .
 677                 "<TABLE CELLSPACING=0 CELLPADDING=1 BORDER=0>\n" .
 678                 formatAttachments($message, $ent_id, $mailbox, $id) .
 679                 "</TABLE></TD></TR></TABLE>";
 680
 681     } else if ($message) {
 682
 683         if (!$message->entities) {
 684
 685             $type0 = strtolower($message->header->type0);
 686             $type1 = strtolower($message->header->type1);
 687             $name = decodeHeader($message->header->name);
 688
 689             if ($message->header->entity_id != $ent_id) {
 690             $filename = decodeHeader($message->header->filename);
 691             if (trim($filename) == '') {
 692                 if (trim($name) == '') {
 693                     if ( trim( $message->header->id ) == '' )
 694                         $display_filename = 'untitled-[' . $message->header->entity_id . ']' ;
 695                     else
 696                         $display_filename = 'cid: ' . $message->header->id;
 697                     // $display_filename = 'untitled-[' . $message->header->entity_id . ']' ;
 698                 } else {
 699                     $display_filename = $name;
 700                     $filename = $name;
 701                 }
 702             } else {
 703                 $display_filename = $filename;
 704             }
 705
 706             $urlMailbox = urlencode($mailbox);
 707             $ent = urlencode($message->header->entity_id);
 708
 709             $DefaultLink =
 710                 "../src/download.php?startMessage=$startMessage&amp;passed_id=$id&amp;mailbox=$urlMailbox&amp;passed_ent_id=$ent";
 711             if ($where && $what) {
 712                 $DefaultLink .= '&amp;where=' . urlencode($where) . '&amp;what=' . urlencode($what);
 713             }
 714             $Links['download link']['text'] = _("download");
 715             $Links['download link']['href'] =
 716                 "../src/download.php?absolute_dl=true&amp;passed_id=$id&amp;mailbox=$urlMailbox&amp;passed_ent_id=$ent";
 717             $ImageURL = '';
 718
 719             /* this executes the attachment hook with a specific MIME-type.
 720                 * if that doens't have results, it tries if there's a rule
 721                 * for a more generic type. */
 722             $HookResults = do_hook("attachment $type0/$type1", $Links,
 723                 $startMessage, $id, $urlMailbox, $ent, $DefaultLink,
 724                 $display_filename, $where, $what);
 725             if(count($HookResults[1]) <= 1) {
 726                 $HookResults = do_hook("attachment $type0/*", $Links,
 727                 $startMessage, $id, $urlMailbox, $ent, $DefaultLink,
 728                 $display_filename, $where, $what);
 729             }
 730
 731             $Links = $HookResults[1];
 732             $DefaultLink = $HookResults[6];
 733
 734             $body .= '<TR><TD>&nbsp;&nbsp;</TD><TD>' .
 735                         "<A HREF=\"$DefaultLink\">$display_filename</A>&nbsp;</TD>" .
 736                         '<TD><SMALL><b>' . show_readable_size($message->header->size) .
 737                         '</b>&nbsp;&nbsp;</small></TD>' .
 738                         "<TD><SMALL>[ $type0/$type1 ]&nbsp;</SMALL></TD>" .
 739                         '<TD><SMALL>';
 740             if ($message->header->description) {
 741                 $body .= '<b>' . htmlspecialchars(_($message->header->description)) . '</b>';
 742             }
 743             $body .= '</SMALL></TD><TD><SMALL>&nbsp;';
 744
 745
 746             $SkipSpaces = 1;
 747             foreach ($Links as $Val) {
 748                 if ($SkipSpaces) {
 749                     $SkipSpaces = 0;
 750                 } else {
 751                     $body .= '&nbsp;&nbsp;|&nbsp;&nbsp;';
 752                 }
 753                 $body .= '<a href="' . $Val['href'] . '">' .  $Val['text'] . '</a>';
 754             }
 755
 756             unset($Links);
 757
 758             $body .= "</SMALL></TD></TR>\n";
 759             }
 760         } else {
 761             for ($i = 0; $i < count($message->entities); $i++) {
 762                 $body .= formatAttachments($message->entities[$i], $ent_id, $mailbox, $id);
 763             }
 764         }
 765     }
 766     return( $body );
 767 }
 768
 769
 770 /** this function decodes the body depending on the encoding type. **/
 771 function decodeBody($body, $encoding) {
 772   $body = str_replace("\r\n", "\n", $body);
 773   $encoding = strtolower($encoding);
 774
 775   global $show_html_default;
 776
 777   if ($encoding == 'quoted-printable') {
 778      $body = quoted_printable_decode($body);
 779
 780
 781      while (ereg("=\n", $body))
 782         $body = ereg_replace ("=\n", "", $body);
 783
 784   } else if ($encoding == 'base64') {
 785      $body = base64_decode($body);
 786   }
 787
 788   // All other encodings are returned raw.
 789   return $body;
 790 }
 791
 792 /*
 793  * This functions decode strings that is encoded according to
 794  * RFC1522 (MIME Part Two: Message Header Extensions for Non-ASCII Text).
 795  */
 796 function decodeHeader ($string, $utfencode=true) {
 797
 798 if ( is_array( $string ) ) {
 799     $string = implode("\n", $string );
 800 }
 801
 802 if (eregi('=\\?([^?]+)\\?(q|b)\\?([^?]+)\\?=',
 803             $string, $res)) {
 804     if (ucfirst($res[2]) == 'B') {
 805         $replace = base64_decode($res[3]);
 806     } else {
 807         $replace = str_replace('_', ' ', $res[3]);
 808         // Convert lowercase Quoted Printable to uppercase for
 809         // quoted_printable_decode to understand it.
 810         while (ereg("(=(([0-9][abcdef])|([abcdef][0-9])|([abcdef][abcdef])))",
 811                $replace, $res)) {
 812             $replace = str_replace($res[1], strtoupper($res[1]), $replace);
 813         }
 814         $replace = quoted_printable_decode($replace);
 815     }
 816     /* Only encode into entities by default. Some places
 817         don't need the encoding, like the compose form. */
 818     if ($utfencode){
 819         $replace = charset_decode ($res[1], $replace);
 820     }
 821
 822     // Remove the name of the character set.
 823     $string = eregi_replace ('=\\?([^?]+)\\?(q|b)\\?([^?]+)\\?=',
 824               $replace, $string);
 825
 826     // In case there should be more encoding in the string: recurse
 827     $string = decodeHeader($string);
 828 }
 829
 830 return ($string);
 831 }
 832
 833 /*
 834  * Encode a string according to RFC 1522 for use in headers if it
 835  * contains 8-bit characters or anything that looks like it should
 836  * be encoded.
 837  */
 838 function encodeHeader ($string) {
 839     global $default_charset;
 840
 841     // Encode only if the string contains 8-bit characters or =?
 842     $j = strlen( $string  );
 843     $l = strstr($string, '=?');         // Must be encoded ?
 844     $ret = '';
 845     for( $i=0; $i < $j; ++$i) {
 846         switch( $string{$i} ) {
 847            case '=':
 848           $ret .= '=3D';
 849           break;
 850         case '?':
 851           $ret .= '=3F';
 852           break;
 853         case '_':
 854           $ret .= '=5F';
 855           break;
 856         case ' ':
 857           $ret .= '_';
 858           break;
 859         default:
 860           $k = ord( $string{$i} );
 861           if ( $k > 126 ) {
 862              $ret .= sprintf("=%02X", $k);
 863              $l = TRUE;
 864           } else
 865              $ret .= $string{$i};
 866         }
 867     }
 868
 869     if ( $l ) {
 870         $string = "=?$default_charset?Q?$ret?=";
 871     }
 872
 873     return( $string );
 874 }
 875
 876 /*
 877     Strips dangerous tags from html messages.
 878 */
 879 function MagicHTML( $body, $id ) {
 880
 881     global $message, $HTTP_SERVER_VARS,
 882            $attachment_common_show_images;
 883
 884     $attachment_common_show_images =
 885                      FALSE; // Don't display attached images in HTML mode
 886     $j = strlen( $body );   // Legnth of the HTML
 887     $ret = '';              // Returned string
 888     $bgcolor = '#ffffff';   // Background style color (defaults to white)
 889     $textcolor = '#000000'; // Foreground style color (defaults to black)
 890     $leftmargin = '';       // Left margin style
 891     $title = '';            // HTML title if any
 892
 893     $i = 0;
 894     while ( $i < $j ) {
 895         if ( $body{$i} == '<' ) {
 896             $pos = $i + 1;
 897             $tag = '';
 898             while ($body{$pos} == ' ' || $body{$pos} == "\t" ||
 899                    $body{$pos} == "\n" ) {
 900                 $pos ++;
 901             }
 902             while (strlen($tag) < 4 && $body{$pos} != ' ' &&
 903                    $body{$pos} != "\t" && $body{$pos} != "\n" &&
 904                    $pos < $j ) {
 905                 $tag .= $body{$pos};
 906                 $pos ++;
 907             }
 908             switch( strtoupper( $tag ) ) {
 909             // Strips the entire tag and contents
 910             case 'APPL':
 911             case 'EMBB':
 912             case 'FRAM':
 913             case 'SCRI':
 914             case 'OBJE':
 915                 $etg = '/' . $tag;
 916                 while ( $body{$i+1}.$body{$i+2}.$body{$i+3}.$body{$i+4}.$body{$i+5} <> $etg  &&
 917                        $i < $j  ) $i++;
 918                 while ( $i < $j && $body{++$i} <> '>' );
 919                 // $ret .= "<!-- $tag removed -->";
 920                 break;
 921             // Substitute Title
 922             case 'TITL':
 923                 $i += 5;
 924                 while ( $body{$i} <> '>' &&  // </title>
 925                        $i < $j )
 926                         $i++;
 927                 $i++;
 928                 $title = '';
 929                 while ( $body{$i} <> '<' &&  // </title>
 930                        $i < $j ) {
 931                     $title .= $body{$i};
 932                     $i++;
 933                 }
 934                 $i += 7;
 935                 break;
 936             // Destroy these tags
 937             case 'HTML':
 938             case 'HEAD':
 939             case '/HTM':
 940             case '/HEA':
 941             case '!DOC':
 942             case 'META':
 943             //case 'DIV ':
 944             //case '/DIV':
 945             case '!-- ':
 946                 $i += 4;
 947                 while ( $body{$i}  <> '>' &&
 948                        $i < $j )
 949                     $i++;
 950                 // $i++;
 951                 break;
 952             case 'STYL':
 953                 $i += 5;
 954                 while ( $body{$i} <> '>' &&  // </title>
 955                        $i < $j )
 956                         $i++;
 957                 $i++;
 958                 // We parse the style to look for interesting stuff
 959                 $styleblk = '';
 960                 while ( $body{$i} <> '>' &&
 961                        $i < $j ) {
 962                     // First we get the name of the style
 963                     $style = '';
 964                     while ( $body{$i} <> '>' &&
 965                            $body{$i} <> '<' &&
 966                            $body{$i} <> '{' &&
 967                            $i < $j ) {
 968                        if ( isnoSep( $body{$i} ) )
 969                            $style .= $body{$i};
 970                        $i++;
 971                     }
 972                     stripComments( $i, $j, $body );
 973                     $style = strtoupper( trim( $style ) );
 974                     if ( $style == 'BODY' ) {
 975                         // Next we look into the definitions of the body style
 976                         while ( $body{$i} <> '>' &&
 977                                $body{$i} <> '}' &&
 978                                $i < $j ) {
 979                             // We look for the background color if any.
 980                             if ( substr( $body, $i, 17 ) == 'BACKGROUND-COLOR:' ) {
 981                                 $i += 17;
 982                                 $bgcolor = getStyleData( $i, $j, $body );
 983                             } elseif ( substr( $body, $i, 12 ) == 'MARGIN-LEFT:' ) {
 984                                 $i += 12;
 985                                 $leftmargin = getStyleData( $i, $j, $body );
 986                             }
 987                             $i++;
 988                         }
 989                     } else {
 990                         // Other style are mantained
 991                         $styleblk .= "$style ";
 992                         while ( $body{$i} <> '>' &&
 993                                $body{$i} <> '<' &&
 994                                $body{$i} <> '}' &&
 995                                $i < $j ) {
 996                             $styleblk .= $body{$i};
 997                             $i++;
 998                         }
 999                         $styleblk .= $body{$i};
1000                     }
1001                     stripComments( $i, $j, $body );
1002                     if ( $body{$i} <> '>' )
1003                         $i++;
1004                 }
1005                 if ( $styleblk <> '' )
1006                     $ret .= "<style>$styleblk";
1007                 break;
1008             case 'BODY':
1009                 if ( $title <> '' )
1010                     $ret .= '<b>' . _("Title:") . " </b>$title<br>\n";
1011                 $ret .= "<TABLE";
1012                 $i += 5;
1013                 if (! isset($base)) {
1014                     $base = '';
1015                 }
1016                 $ret .= stripEvent( $i, $j, $body, $id, $base );
1017                 $ret .= " bgcolor=$bgcolor width=\"100%\"><tr>";
1018                 if ( $leftmargin <> '' )
1019                     $ret .= "<td width=$leftmargin>&nbsp;</td>";
1020                 $ret .= '<td>';
1021                 if (strtolower($bgcolor) == 'ffffff' ||
1022                     strtolower($bgcolor) == '#ffffff')
1023                     $ret .= '<font color=#000000>';
1024                 break;
1025             case 'BASE':
1026                 $i += 5;
1027                 $base = '';
1028                 while ( !isNoSep( $body{$i} ) &&
1029                        $i < $j ) {
1030                         $i++;
1031                 }
1032                 if ( strcasecmp( substr( $base, 0, 4 ), 'href'  ) ) {
1033                         $i += 5;
1034                         while ( !isNoSep( $body{$i} ) &&
1035                                $i < $j ) {
1036                                 $i++;
1037                         }
1038                         while ( $body{$i} <> '>' &&
1039                                $i < $j ) {
1040                             if ( $body{$i} <> '"' ) {
1041                                 $base .= $body{$i};
1042                             }
1043                             $i++;
1044                         }
1045                         // Debuging $ret .= "<!-- base == $base -->";
1046                         if ( strcasecmp( substr( $base, 0, 4 ), 'file' ) <> 0 ) {
1047                             $ret .= "\n<BASE HREF=\"$base\">\n";
1048                         }
1049                 }
1050                 break;
1051             case '/BOD':
1052                 $ret .= '</font></td></tr></TABLE>';
1053                 $i += 6;
1054                 break;
1055             default:
1056                 // Following tags can contain some event handler, lets search it
1057                 stripComments( $i, $j, $body );
1058                 if (! isset($base)) {
1059                    $base = '';
1060                 }
1061                 $ret .= stripEvent( $i, $j, $body, $id, $base ) . '>';
1062                         // $ret .= "<!-- $tag detected -->";
1063             }
1064         } else {
1065             $ret .= $body{$i};
1066         }
1067     $i++;
1068     }
1069
1070 return( "\n\n<!-- HTML Output ahead -->\n" .
1071         $ret .
1072         /* Base is illegal within HTML
1073         "\n<!-- END of HTML Output --><base href=\"".
1074         get_location() . '/'.
1075         "\">\n\n" );
1076         */
1077         "\n<!-- END of HTML Output -->\n\n" );
1078 }
1079
1080 function isNoSep( $char ) {
1081
1082     switch( $char ) {
1083     case ' ':
1084     case "\n":
1085     case "\t":
1086     case "\r":
1087     case '>':
1088     case '"':
1089         return( FALSE );
1090         break;
1091     default:
1092         return( TRUE );
1093     }
1094
1095 }
1096
1097 /*
1098   The following function is usefull to remove extra data that can cause
1099   html not to display properly. Especialy with MS stuff.
1100 */
1101
1102 function stripComments( &$i, $j, &$body ) {
1103
1104     while ( $body{$i}.$body{$i+1}.$body{$i+2}.$body{$i+3} == '<!--' &&
1105            $i < $j ) {
1106         $i += 5;
1107         while ( $body{$i-2}.$body{$i-1}.$body{$i} <> '-->' &&
1108                $i < $j )
1109             $i++;
1110         $i++;
1111     }
1112
1113     return;
1114
1115 }
1116
1117 /* Gets the style data of a specific style */
1118
1119 function getStyleData( &$i, $j, &$body ) {
1120
1121     // We skip spaces
1122     while ( $body{$i} <> '>' && !isNoSep( $body{$i} ) &&
1123            $i < $j ) {
1124         $i++;
1125     }
1126     // And get the color
1127     $ret = '';
1128     while ( isNoSep( $body{$i} ) &&
1129            $i < $j ) {
1130         $ret .= $body{$i};
1131         $i++;
1132     }
1133
1134     return( $ret );
1135 }
1136
1137 /*
1138 Private function for strip_dangerous_tag. Look for event based coded and "remove" it
1139 change on with no (onload -> noload)
1140 */
1141
1142 function stripEvent( &$i, $j, &$body, $id, $base ) {
1143
1144     global $message, $base_uri, $has_unsafe_images, $view_unsafe_images;
1145
1146     $ret = '';
1147
1148     while ( $body{$i} <> '>' &&
1149            $i < $j ) {
1150         $etg = strtolower($body{$i}.$body{$i+1}.$body{$i+2});
1151         switch( $etg ) {
1152         case 'src':
1153             // This is probably a src specification
1154             $k = $i + 3;
1155             while( !isNoSep( $body{$k} )) {
1156                 $k++;
1157             }
1158             if ( $body{$k} == '=' ) {
1159                 /* It is indeed */
1160                 $k++;
1161                 while( !isNoSep( $body{$k} ) &&
1162                        $k < $j ) {
1163                     $k++;
1164                 }
1165                 $src = '';
1166                 while ( $body{$k} <> '>' && isNoSep( $body{$k} ) &&
1167                        $k < $j ) {
1168                     $src .= $body{$k};
1169                     $k++;
1170                 }
1171                 $k++;
1172                 while( !isNoSep( $body{$k} ) &&
1173                        $k < $j ) {
1174                     $k++;
1175                 }
1176                 $k++;
1177                 if ( strtolower( substr( $src, 0, 4 ) ) == 'cid:' ) {
1178                     $src = substr( $src, 4 );
1179                     $src = "../src/download.php?absolute_dl=true&amp;passed_id=$id&amp;mailbox=" .
1180                            urlencode( $message->header->mailbox ) .
1181                            "&amp;passed_ent_id=" . find_ent_id( $src, $message );
1182                 } else if ( strtolower( substr( $src, 0, 4 ) ) <> 'http' ||
1183                             stristr( $src, $base_uri ) ) {
1184                     /* Javascript and local urls goes out */
1185                     if (!$view_unsafe_images) {
1186                         $src = '../images/' . _("sec_remove_eng.png");
1187                     }
1188                     $has_unsafe_images = 1;
1189                 }
1190                 $ret .= 'src="' . $src . '" ';
1191                 $i = $k - 2;
1192             } else {
1193                 $ret .= 'src';
1194                 $i = $i + 3;
1195             }
1196
1197             break;
1198         case '../':
1199             // Retrolinks are not allowed without a base because they mess with SM security
1200             if ( $base == '' ) {
1201                     $i += 2;
1202             } else {
1203                     $ret .= '.';
1204             }
1205             break;
1206         case 'cid':
1207             // Internal link
1208             $k = $i-1;
1209             if ( $body{$i+3} == ':') {
1210                 $i +=4;
1211                 $name = '';
1212                 while ( isNoSep( $body{$i} ) &&
1213                        $i < $j  ) {
1214                     $name .= $body{$i++};
1215                 }
1216                 if ( $name <> '' ) {
1217                     $ret .= "../src/download.php?absolute_dl=true&amp;passed_id=$id&amp;mailbox=" .
1218                                 urlencode( $message->header->mailbox ) .
1219                                 "&amp;passed_ent_id=" . find_ent_id( $name, $message );
1220                     if ( $body{$k} == '"' )
1221                         $ret .= '" ';
1222                     else
1223                         $ret .= ' ';
1224                 }
1225                 if ( $body{$i} == '>' )
1226                     $i -= 1;
1227             }
1228             break;
1229         case ' on':
1230         case "\non":
1231         case "\ron":
1232         case "\ton":
1233             $ret .= ' no';
1234             $i += 2;
1235             break;
1236         case 'pt:':
1237             if ( strcasecmp( $body{$i-4}.$body{$i-3}.$body{$i-2}.$body{$i-1}.$body{$i}.$body{$i+1}.$body{$i+2}, 'script:') == 0 ) {
1238                 $ret .= '_no/';
1239             } else {
1240                 $ret .= $etg;
1241             }
1242             $i += 2;
1243             break;
1244         default:
1245             $ret .= $body{$i};
1246         }
1247         $i++;
1248     }
1249     return( $ret );
1250 }
1251
1252
1253 /* This function trys to locate the entity_id of a specific mime element */
1254
1255 function find_ent_id( $id, $message ) {
1256
1257     $ret = '';
1258     for ($i=0; $ret == '' && $i < count($message->entities); $i++) {
1259
1260         if ( $message->entities[$i]->header->entity_id == '' ) {
1261             $ret = find_ent_id( $id, $message->entities[$i] );
1262         } else {
1263             if ( strcasecmp( $message->entities[$i]->header->id, $id ) == 0 )
1264                 $ret = $message->entities[$i]->header->entity_id;
1265         }
1266
1267     }
1268
1269     return( $ret );
1270
1271 }
1272 ?>