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