Add sq_send_mail()
[squirrelmail.git] / functions / mime.php
CommitLineData
59177427 1<?php
2ba13803 2
35586184 3/**
8bd0068d 4 * mime.php
5 *
8bd0068d 6 * This contains the functions necessary to detect and decode MIME
7 * messages.
8 *
4b5049de 9 * @copyright &copy; 1999-2007 The SquirrelMail Project Team
4b4abf93 10 * @license http://opensource.org/licenses/gpl-license.php GNU Public License
8bd0068d 11 * @version $Id$
12 * @package squirrelmail
13 */
b74ba498 14
202bcbcc 15/**
16 * dependency information
17 functions dependency
18 mime_structure
19 class/mime/Message.class.php
20 Message::parseStructure
21 functions/page_header.php
22 displayPageHeader
23 functions/display_messages.php
24 plain_error_message
25 mime_fetch_body
26 functions/imap_general.php
27 sqimap_run_command
28 mime_print_body_lines
29
30
31
32functions/imap.php
33functions/attachment_common.php
34functions/display_messages.php
35
36magicHtml => url_parser
37translateText => url_parser
38
39*/
40
8beafbbc 41
7c7b74b3 42/* -------------------------------------------------------------------------- */
43/* MIME DECODING */
44/* -------------------------------------------------------------------------- */
b74ba498 45
d6c32258 46/**
8bd0068d 47 * Get the MIME structure
48 *
49 * This function gets the structure of a message and stores it in the "message" class.
50 * It will return this object for use with all relevant header information and
51 * fully parsed into the standard "message" object format.
52 */
a4a70693 53function mime_structure ($bodystructure, $flags=array()) {
c9d78ab4 54
3d8371be 55 /* Isolate the body structure and remove beginning and end parenthesis. */
a4a70693 56 $read = trim(substr ($bodystructure, strpos(strtolower($bodystructure), 'bodystructure') + 13));
451f74a2 57 $read = trim(substr ($read, 0, -1));
22efa9fb 58 $i = 0;
59 $msg = Message::parseStructure($read,$i);
2b665f28 60
9de42168 61 if (!is_object($msg)) {
3d8371be 62 global $color, $mailbox;
a48eba8f 63 displayPageHeader( $color, $mailbox );
5e8de8b6 64 $errormessage = _("SquirrelMail could not decode the bodystructure of the message");
8bd0068d 65 $errormessage .= '<br />'._("The bodystructure provided by your IMAP server:").'<br /><br />';
472e7acb 66 $errormessage .= '<pre>' . htmlspecialchars($read) . '</pre>';
ce8c6f42 67 plain_error_message( $errormessage );
3d8371be 68 echo '</body></html>';
9de42168 69 exit;
70 }
a4a70693 71 if (count($flags)) {
7a9e9c89 72 foreach ($flags as $flag) {
e1115979 73//FIXME: please document why it is we have to check the first char of the flag but we then go ahead and do a full string comparison anyway. Is this a speed enhancement? If not, let's keep it simple and just compare the full string and forget the switch block.
7a9e9c89 74 $char = strtoupper($flag{1});
75 switch ($char) {
3d8371be 76 case 'S':
77 if (strtolower($flag) == '\\seen') {
78 $msg->is_seen = true;
79 }
80 break;
81 case 'A':
82 if (strtolower($flag) == '\\answered') {
83 $msg->is_answered = true;
84 }
85 break;
86 case 'D':
87 if (strtolower($flag) == '\\deleted') {
88 $msg->is_deleted = true;
89 }
90 break;
91 case 'F':
92 if (strtolower($flag) == '\\flagged') {
93 $msg->is_flagged = true;
94 }
95 break;
96 case 'M':
97 if (strtolower($flag) == '$mdnsent') {
98 $msg->is_mdnsent = true;
99 }
100 break;
101 default:
102 break;
7a9e9c89 103 }
104 }
451f74a2 105 }
7a9e9c89 106 // listEntities($msg);
3d8371be 107 return $msg;
451f74a2 108}
b74ba498 109
22efa9fb 110
111
3d8371be 112/* This starts the parsing of a particular structure. It is called recursively,
8bd0068d 113 * so it can be passed different structures. It returns an object of type
114 * $message.
115 * First, it checks to see if it is a multipart message. If it is, then it
116 * handles that as it sees is necessary. If it is just a regular entity,
117 * then it parses it and adds the necessary header information (by calling out
118 * to mime_get_elements()
119 */
451f74a2 120
4d592352 121function mime_fetch_body($imap_stream, $id, $ent_id=1, $fetch_size=0) {
3d8371be 122 /* Do a bit of error correction. If we couldn't find the entity id, just guess
8bd0068d 123 * that it is the first one. That is usually the case anyway.
124 */
7c7b74b3 125
09a4bde3 126 if (!$ent_id) {
08b7f7cc 127 $cmd = "FETCH $id BODY[]";
1035e159 128 } else {
08b7f7cc 129 $cmd = "FETCH $id BODY[$ent_id]";
09a4bde3 130 }
3d8371be 131
4d592352 132 if ($fetch_size!=0) $cmd .= "<0.$fetch_size>";
da2415c1 133
6201339c 134 $data = sqimap_run_command ($imap_stream, $cmd, true, $response, $message, TRUE);
77b88425 135 do {
3d8371be 136 $topline = trim(array_shift($data));
137 } while($topline && ($topline[0] == '*') && !preg_match('/\* [0-9]+ FETCH.*/i', $topline)) ;
a4a70693 138
451f74a2 139 $wholemessage = implode('', $data);
140 if (ereg('\\{([^\\}]*)\\}', $topline, $regs)) {
3d8371be 141 $ret = substr($wholemessage, 0, $regs[1]);
142 /* There is some information in the content info header that could be important
8bd0068d 143 * in order to parse html messages. Let's get them here.
144 */
0600bdf1 145// if ($ret{0} == '<') {
6201339c 146// $data = sqimap_run_command ($imap_stream, "FETCH $id BODY[$ent_id.MIME]", true, $response, $message, TRUE);
0600bdf1 147// }
451f74a2 148 } else if (ereg('"([^"]*)"', $topline, $regs)) {
149 $ret = $regs[1];
06bcb9c3 150 } else if ((stristr($topline, 'nil') !== false) && (empty($wholemessage))) {
151 $ret = $wholemessage;
451f74a2 152 } else {
153 global $where, $what, $mailbox, $passed_id, $startMessage;
3d8371be 154 $par = 'mailbox=' . urlencode($mailbox) . '&amp;passed_id=' . $passed_id;
451f74a2 155 if (isset($where) && isset($what)) {
3d8371be 156 $par .= '&amp;where=' . urlencode($where) . '&amp;what=' . urlencode($what);
a3daaaf3 157 } else {
3d8371be 158 $par .= '&amp;startMessage=' . $startMessage . '&amp;show_more=0';
451f74a2 159 }
e5ea9327 160 $par .= '&amp;response=' . urlencode($response) .
8bd0068d 161 '&amp;message=' . urlencode($message) .
162 '&amp;topline=' . urlencode($topline);
a019eeb8 163
8bd0068d 164 echo '<tt><br />' .
02474e43 165 '<table width="80%"><tr>' .
166 '<tr><td colspan="2">' .
167 _("Body retrieval error. The reason for this is most probably that the message is malformed.") .
168 '</td></tr>' .
169 '<tr><td><b>' . _("Command:") . "</td><td>$cmd</td></tr>" .
170 '<tr><td><b>' . _("Response:") . "</td><td>$response</td></tr>" .
171 '<tr><td><b>' . _("Message:") . "</td><td>$message</td></tr>" .
172 '<tr><td><b>' . _("FETCH line:") . "</td><td>$topline</td></tr>" .
173 "</table><br /></tt></font><hr />";
346817d4 174
6201339c 175 $data = sqimap_run_command ($imap_stream, "FETCH $passed_id BODY[]", true, $response, $message, TRUE);
451f74a2 176 array_shift($data);
177 $wholemessage = implode('', $data);
a019eeb8 178
346817d4 179 $ret = $wholemessage;
a3daaaf3 180 }
3d8371be 181 return $ret;
451f74a2 182}
d4467150 183
6cc670de 184function mime_print_body_lines ($imap_stream, $id, $ent_id=1, $encoding, $rStream='php://stdout') {
1035e159 185
3d8371be 186 /* Don't kill the connection if the browser is over a dialup
8bd0068d 187 * and it would take over 30 seconds to download it.
188 * Don't call set_time_limit in safe mode.
189 */
b7206e1d 190
3d8371be 191 if (!ini_get('safe_mode')) {
b7206e1d 192 set_time_limit(0);
193 }
7c7b74b3 194 /* in case of base64 encoded attachments, do not buffer them.
8bd0068d 195 Instead, echo the decoded attachment directly to screen */
7c7b74b3 196 if (strtolower($encoding) == 'base64') {
197 if (!$ent_id) {
7591f143 198 $query = "FETCH $id BODY[]";
7c7b74b3 199 } else {
7591f143 200 $query = "FETCH $id BODY[$ent_id]";
7c7b74b3 201 }
7591f143 202 sqimap_run_command($imap_stream,$query,true,$response,$message,TRUE,'sqimap_base64_decode',$rStream,true);
1d142b8d 203 } else {
7591f143 204 $body = mime_fetch_body ($imap_stream, $id, $ent_id);
205 if (is_resource($rStream)) {
206 fputs($rStream,decodeBody($body,$encoding));
207 } else {
208 echo decodeBody($body, $encoding);
209 }
1d142b8d 210 }
346817d4 211
da2415c1 212 /*
8bd0068d 213 TODO, use the same method for quoted printable.
214 However, I assume that quoted printable attachments aren't that large
215 so the performancegain / memory usage drop will be minimal.
216 If we decide to add that then we need to adapt sqimap_fread because
217 we need to split te result on \n and fread doesn't stop at \n. That
218 means we also should provide $results from sqimap_fread (by ref) to
219 te function and set $no_return to false. The $filter function for
220 quoted printable should handle unsetting of $results.
221 */
da2415c1 222 /*
8bd0068d 223 TODO 2: find out how we write to the output stream php://stdout. fwrite
224 doesn't work because 'php://stdout isn't a stream.
225 */
7c7b74b3 226
5d9c6f73 227 return;
451f74a2 228}
beb9e459 229
451f74a2 230/* -[ END MIME DECODING ]----------------------------------------------------------- */
d4467150 231
3d8371be 232/* This is here for debugging purposes. It will print out a list
8bd0068d 233 * of all the entity IDs that are in the $message object.
234 */
451f74a2 235function listEntities ($message) {
3d8371be 236 if ($message) {
3c621ba1 237 echo "<tt>" . $message->entity_id . ' : ' . $message->type0 . '/' . $message->type1 . ' parent = '. $message->parent->entity_id. '<br />';
3d8371be 238 for ($i = 0; isset($message->entities[$i]); $i++) {
239 echo "$i : ";
240 $msg = listEntities($message->entities[$i]);
241
242 if ($msg) {
243 echo "return: ";
244 return $msg;
245 }
246 }
a4a70693 247 }
451f74a2 248}
f0c4dc12 249
f792c641 250function getPriorityStr($priority) {
3d8371be 251 $priority_level = substr($priority,0,1);
252
253 switch($priority_level) {
254 /* Check for a higher then normal priority. */
255 case '1':
256 case '2':
257 $priority_string = _("High");
258 break;
259
260 /* Check for a lower then normal priority. */
261 case '4':
262 case '5':
263 $priority_string = _("Low");
264 break;
265
266 /* Check for a normal priority. */
267 case '3':
268 default:
269 $priority_level = '3';
270 $priority_string = _("Normal");
271 break;
272
273 }
274 return $priority_string;
f792c641 275}
276
451f74a2 277/* returns a $message object for a particular entity id */
278function getEntity ($message, $ent_id) {
a4a70693 279 return $message->getEntity($ent_id);
451f74a2 280}
8beafbbc 281
3d8371be 282/* translateText
8bd0068d 283 * Extracted from strings.php 23/03/2002
284 */
da4c66e8 285
286function translateText(&$body, $wrap_at, $charset) {
3d8371be 287 global $where, $what; /* from searching */
288 global $color; /* color theme */
da4c66e8 289
202bcbcc 290 // require_once(SM_PATH . 'functions/url_parser.php');
da4c66e8 291
292 $body_ary = explode("\n", $body);
da4c66e8 293 for ($i=0; $i < count($body_ary); $i++) {
294 $line = $body_ary[$i];
295 if (strlen($line) - 2 >= $wrap_at) {
c7aff938 296 sqWordWrap($line, $wrap_at, $charset);
da4c66e8 297 }
298 $line = charset_decode($charset, $line);
299 $line = str_replace("\t", ' ', $line);
300
301 parseUrl ($line);
302
3d8371be 303 $quotes = 0;
da4c66e8 304 $pos = 0;
3d8371be 305 $j = strlen($line);
da4c66e8 306
3d8371be 307 while ($pos < $j) {
da4c66e8 308 if ($line[$pos] == ' ') {
3d8371be 309 $pos++;
da4c66e8 310 } else if (strpos($line, '&gt;', $pos) === $pos) {
311 $pos += 4;
3d8371be 312 $quotes++;
da4c66e8 313 } else {
314 break;
315 }
316 }
3d8371be 317
83c94382 318 if ($quotes % 2) {
d0814c02 319 $line = '<span class="quote1">' . $line . '</span>';
4c25967c 320 } elseif ($quotes) {
d0814c02 321 $line = '<span class="quote2">' . $line . '</span>';
da4c66e8 322 }
3d8371be 323
da4c66e8 324 $body_ary[$i] = $line;
325 }
326 $body = '<pre>' . implode("\n", $body_ary) . '</pre>';
327}
328
a2bfcbce 329/**
da1b55ad 330 * This returns a parsed string called $body. That string can then
331 * be displayed as the actual message in the HTML. It contains
332 * everything needed, including HTML Tags, Attachments at the
333 * bottom, etc.
f8a1ed5a 334 *
da1b55ad 335 * Since 1.2.0 function uses message_body hook.
336 * Till 1.3.0 function included output of formatAttachments().
337 *
338 * @param resource $imap_stream imap connection resource
339 * @param object $message squirrelmail message object
340 * @param array $color squirrelmail color theme array
341 * @param integer $wrap_at number of characters per line
342 * @param string $ent_num (since 1.3.0) message part id
343 * @param integer $id (since 1.3.0) message id
344 * @param string $mailbox (since 1.3.0) imap folder name
41f701c1 345 * @param boolean $clean (since 1.5.1) Do not output stuff that's irrelevant for the printable version.
da1b55ad 346 * @return string html formated message text
347 */
a2bfcbce 348function formatBody($imap_stream, $message, $color, $wrap_at, $ent_num, $id, $mailbox='INBOX', $clean=FALSE) {
3d8371be 349 /* This if statement checks for the entity to show as the
8bd0068d 350 * primary message. To add more of them, just put them in the
351 * order that is their priority.
352 */
ce68b76b 353 global $startMessage, $languages, $squirrelmail_language,
40a34e57 354 $show_html_default, $sort, $has_unsafe_images, $passed_ent_id,
14c85e39 355 $use_iframe, $iframe_height, $download_and_unsafe_link,
955bfc8f 356 $download_href, $unsafe_image_toggle_href, $unsafe_image_toggle_text,
551c7b53 357 $oTemplate, $nbsp;
2c25d36a 358
359 // workaround for not updated config.php
360 if (! isset($use_iframe)) $use_iframe = false;
77bfbd2e 361
5262d9a6 362 if( !sqgetGlobalVar('view_unsafe_images', $view_unsafe_images, SQ_GET) ) {
363 $view_unsafe_images = false;
77bfbd2e 364 }
d03c24f4 365
cc34b00d 366 $body = '';
23bcec6f 367 $urlmailbox = urlencode($mailbox);
451f74a2 368 $body_message = getEntity($message, $ent_num);
369 if (($body_message->header->type0 == 'text') ||
8bd0068d 370 ($body_message->header->type0 == 'rfc822')) {
3d8371be 371 $body = mime_fetch_body ($imap_stream, $id, $ent_num);
451f74a2 372 $body = decodeBody($body, $body_message->header->encoding);
e842b215 373
374 if (isset($languages[$squirrelmail_language]['XTRA_CODE']) &&
8bd0068d 375 function_exists($languages[$squirrelmail_language]['XTRA_CODE'] . '_decode')) {
e842b215 376 if (mb_detect_encoding($body) != 'ASCII') {
33a55f5a 377 $body = call_user_func($languages[$squirrelmail_language]['XTRA_CODE'] . '_decode',$body);
e842b215 378 }
379 }
d849b570 380
381 /* As of 1.5.2, $body is passed (and modified) by reference */
382 do_hook('message_body', $body);
23bcec6f 383
3d8371be 384 /* If there are other types that shouldn't be formatted, add
8bd0068d 385 * them here.
386 */
3d8371be 387
451f74a2 388 if ($body_message->header->type1 == 'html') {
3d8371be 389 if ($show_html_default <> 1) {
85015544 390 $entity_conv = array('&nbsp;' => ' ',
8bd0068d 391 '<p>' => "\n",
392 '<P>' => "\n",
393 '<br>' => "\n",
394 '<BR>' => "\n",
395 '<br />' => "\n",
396 '<BR />' => "\n",
397 '&gt;' => '>',
398 '&lt;' => '<');
85015544 399 $body = strtr($body, $entity_conv);
3d8371be 400 $body = strip_tags($body);
85015544 401 $body = trim($body);
402 translateText($body, $wrap_at,
8bd0068d 403 $body_message->header->getParameter('charset'));
2c25d36a 404 } elseif ($use_iframe && ! $clean) {
405 // $clean is used to remove iframe in printable view.
406
84410f31 407 /**
408 * If we don't add html message between iframe tags,
409 * we must detect unsafe images and modify $has_unsafe_images.
f8a1ed5a 410 */
758a7889 411 $html_body = magicHTML($body, $id, $message, $mailbox);
b6c52e61 412 // Convert character set in order to display html mails in different character set
413 $html_body = charset_decode($body_message->header->getParameter('charset'),$html_body,false,true);
84410f31 414
2c25d36a 415 // creating iframe url
416 $iframeurl=sqm_baseuri().'src/view_html.php?'
f8a1ed5a 417 . 'mailbox=' . $urlmailbox
2c25d36a 418 . '&amp;passed_id=' . $id
419 . '&amp;ent_id=' . $ent_num
420 . '&amp;view_unsafe_images=' . (int) $view_unsafe_images;
421
79d58d4c 422 global $oTemplate;
423 $oTemplate->assign('iframe_url', $iframeurl);
51554708 424 $oTemplate->assign('iframe_height', $iframe_height);
79d58d4c 425 $oTemplate->assign('html_body', $html_body);
2b665f28 426
79d58d4c 427 $body = $oTemplate->fetch('read_html_iframe.tpl');
a3daaaf3 428 } else {
2c25d36a 429 // old way of html rendering
b6c52e61 430 /**
758a7889 431 * convert character set. charset_decode does not remove html special chars
b6c52e61 432 * applied by magicHTML functions and does not sanitize them second time if
758a7889 433 * fourth argument is true.
434 */
567dc524 435 $charset = $body_message->header->getParameter('charset');
436 if (!empty($charset)) {
437 $body = charset_decode($charset,$body,false,true);
438 }
439 $body = magicHTML($body, $id, $message, $mailbox);
a3daaaf3 440 }
451f74a2 441 } else {
3d8371be 442 translateText($body, $wrap_at,
8bd0068d 443 $body_message->header->getParameter('charset'));
451f74a2 444 }
a2bfcbce 445
446 // if this is the clean display (i.e. printer friendly), stop here.
447 if ( $clean ) {
448 return $body;
449 }
450
40a34e57 451 $download_and_unsafe_link = '';
452
83cf04bd 453 $link = 'passed_id=' . $id . '&amp;ent_id='.$ent_num.
8bd0068d 454 '&amp;mailbox=' . $urlmailbox .'&amp;sort=' . $sort .
455 '&amp;startMessage=' . $startMessage . '&amp;show_more=0';
08b7f7cc 456 if (isset($passed_ent_id)) {
457 $link .= '&amp;passed_ent_id='.$passed_ent_id;
458 }
14c85e39 459 $download_href = SM_PATH . 'src/download.php?absolute_dl=true&amp;' . $link;
955bfc8f 460 $download_and_unsafe_link .= "$nbsp|$nbsp"
461 . create_hyperlink($download_href, _("Download this as a file"));
7aad7b77 462 if ($view_unsafe_images) {
23f617b8 463 $text = _("Hide Unsafe Images");
7aad7b77 464 } else {
08b7f7cc 465 if (isset($has_unsafe_images) && $has_unsafe_images) {
466 $link .= '&amp;view_unsafe_images=1';
467 $text = _("View Unsafe Images");
468 } else {
469 $text = '';
470 }
3d8371be 471 }
83cf04bd 472 if($text != '') {
14c85e39 473 $unsafe_image_toggle_href = SM_PATH . 'src/read_body.php?'.$link;
474 $unsafe_image_toggle_text = $text;
955bfc8f 475 $download_and_unsafe_link .= "$nbsp|$nbsp"
476 . create_hyperlink($unsafe_image_toggle_href, $text);
83cf04bd 477 }
3d8371be 478 }
479 return $body;
451f74a2 480}
b74ba498 481
da1b55ad 482/**
d67f519a 483 * Generate attachments array for passing to templates. Separated from
484 * formatAttachments() below so that the same array can be given to the
485 * print-friendly version.
2b665f28 486 *
d67f519a 487 * @since 1.5.2
da1b55ad 488 * @param object $message SquirrelMail message object
489 * @param array $exclude_id message parts that are not attachments.
490 * @param string $mailbox mailbox name
491 * @param integer $id message id
da1b55ad 492 */
d67f519a 493function buildAttachmentArray($message, $exclude_id, $mailbox, $id) {
494 global $where, $what, $startMessage, $color, $passed_ent_id, $base_uri;
451f74a2 495
23bcec6f 496 $att_ar = $message->getAttachments($exclude_id);
23bcec6f 497 $urlMailbox = urlencode($mailbox);
498
d67f519a 499 $attachments = array();
23bcec6f 500 foreach ($att_ar as $att) {
fdc9d9b5 501 $ent = $att->entity_id;
2e25760a 502 $header = $att->header;
f0c4dc12 503 $type0 = strtolower($header->type0);
504 $type1 = strtolower($header->type1);
2e25760a 505 $name = '';
d0187bd6 506 $links = array();
21dab2dc 507 $links['download link']['text'] = _("Download");
202bcbcc 508 $links['download link']['href'] = $base_uri .
8bd0068d 509 "src/download.php?absolute_dl=true&amp;passed_id=$id&amp;mailbox=$urlMailbox&amp;ent_id=$ent";
2b665f28 510
2e25760a 511 if ($type0 =='message' && $type1 == 'rfc822') {
202bcbcc 512 $default_page = $base_uri . 'src/read_body.php';
2e25760a 513 $rfc822_header = $att->rfc822_header;
098ea084 514 $filename = $rfc822_header->subject;
6cc08d8b 515 if (trim( $filename ) == '') {
516 $filename = 'untitled-[' . $ent . ']' ;
08b7f7cc 517 }
2e25760a 518 $from_o = $rfc822_header->from;
519 if (is_object($from_o)) {
04ea844e 520 $from_name = decodeHeader($from_o->getAddress(false));
7e697748 521 } elseif (is_array($from_o) && count($from_o) && is_object($from_o[0])) {
522 // something weird happens when a digest message is opened and you return to the digest
523 // now the from object is part of an array. Probably the parseHeader call overwrites the info
524 // retrieved from the bodystructure in a different way. We need to fix this later.
525 // possible starting point, do not fetch header we already have and inspect how
526 // the rfc822_header object behaves.
527 $from_name = decodeHeader($from_o[0]->getAddress(false));
2e25760a 528 } else {
529 $from_name = _("Unknown sender");
f0c4dc12 530 }
d0187bd6 531 $description = _("From").': '.$from_name;
23bcec6f 532 } else {
202bcbcc 533 $default_page = $base_uri . 'src/download.php';
02474e43 534 $filename = $att->getFilename();
f810c0b2 535 if ($header->description) {
098ea084 536 $description = decodeHeader($header->description);
f810c0b2 537 } else {
3d8371be 538 $description = '';
539 }
2e25760a 540 }
541
542 $display_filename = $filename;
3d8371be 543 if (isset($passed_ent_id)) {
544 $passed_ent_id_link = '&amp;passed_ent_id='.$passed_ent_id;
545 } else {
546 $passed_ent_id_link = '';
547 }
548 $defaultlink = $default_page . "?startMessage=$startMessage"
8bd0068d 549 . "&amp;passed_id=$id&amp;mailbox=$urlMailbox"
550 . '&amp;ent_id='.$ent.$passed_ent_id_link;
2e25760a 551 if ($where && $what) {
8bd0068d 552 $defaultlink .= '&amp;where='. urlencode($where).'&amp;what='.urlencode($what);
2e25760a 553 }
7e2ff844 554 // IE does make use of mime content sniffing. Forcing a download
555 // prohibit execution of XSS inside an application/octet-stream attachment
556 if ($type0 == 'application' && $type1 == 'octet-stream') {
557 $defaultlink .= '&amp;absolute_dl=true';
558 }
2b665f28 559
3d8371be 560 /* This executes the attachment hook with a specific MIME-type.
8bd0068d 561 * If that doesn't have results, it tries if there's a rule
9b94c54d 562 * for a more generic type. Finally, a hook for ALL attachment
563 * types is run as well.
8bd0068d 564 */
8dca4d22 565 // First remember the default link.
566 $defaultlink_orig = $defaultlink;
567
d849b570 568 /* The API for this hook has changed as of 1.5.2 so that all plugin
569 arguments are passed in an array instead of each their own plugin
570 argument, and arguments are passed by reference, so instead of
571 returning any changes, changes should simply be made to the original
572 arguments themselves. */
9c3b2d22 573 $temp = array(&$links, &$startMessage, &$id, &$urlMailbox, &$ent,
574 &$defaultlink, &$display_filename, &$where, &$what);
575 do_hook("attachment $type0/$type1", $temp);
8dca4d22 576 if(count($links) <= 1 && $defaultlink == $defaultlink_orig) {
d849b570 577 /* The API for this hook has changed as of 1.5.2 so that all plugin
578 arguments are passed in an array instead of each their own plugin
579 argument, and arguments are passed by reference, so instead of
580 returning any changes, changes should simply be made to the original
581 arguments themselves. */
9c3b2d22 582 $temp = array(&$links, &$startMessage, &$id, &$urlMailbox, &$ent,
583 &$defaultlink, &$display_filename, &$where, &$what);
584 do_hook("attachment $type0/*", $temp);
2e25760a 585 }
d849b570 586 /* The API for this hook has changed as of 1.5.2 so that all plugin
587 arguments are passed in an array instead of each their own plugin
588 argument, and arguments are passed by reference, so instead of
589 returning any changes, changes should simply be made to the original
590 arguments themselves. */
9c3b2d22 591 $temp = array(&$links, &$startMessage, &$id, &$urlMailbox, &$ent,
592 &$defaultlink, &$display_filename, &$where, &$what);
8dca4d22 593 // Do not let a generic plugin change the default link if a more
594 // specialized one already did it...
595 if ($defaultlink != $defaultlink_orig) {
596 $dummy = '';
597 $temp[5] = &$dummy;
598 }
9c3b2d22 599 do_hook("attachment */*", $temp);
77b88425 600
d67f519a 601 $this_attachment = array();
602 $this_attachment['Name'] = decodeHeader($display_filename);
603 $this_attachment['Description'] = $description;
604 $this_attachment['DefaultHREF'] = $defaultlink;
605 $this_attachment['DownloadHREF'] = $links['download link']['href'];
606 $this_attachment['ViewHREF'] = isset($links['attachment_common']) ? $links['attachment_common']['href'] : '';
607 $this_attachment['Size'] = $header->size;
608 $this_attachment['ContentType'] = htmlspecialchars($type0 .'/'. $type1);
609 $this_attachment['OtherLinks'] = array();
3d8371be 610 foreach ($links as $val) {
d0187bd6 611 if ($val['text']==_("Download") || $val['text'] == _("View"))
612 continue;
613 if (empty($val['text']) && empty($val['extra']))
614 continue;
2b665f28 615
d67f519a 616 $temp = array();
617 $temp['HREF'] = $val['href'];
618 $temp['Text'] = (empty($val['text']) ? '' : $val['text']) . (empty($val['extra']) ? '' : $val['extra']);
619 $this_attachment['OtherLinks'][] = $temp;
2e25760a 620 }
d67f519a 621 $attachments[] = $this_attachment;
2b665f28 622
3d8371be 623 unset($links);
2e25760a 624 }
2b665f28 625
d67f519a 626 return $attachments;
627}
628
629/**
630 * Displays attachment links and information
631 *
632 * Since 1.3.0 function is not included in formatBody() call.
633 *
634 * Since 1.0.2 uses attachment $type0/$type1 hook.
635 * Since 1.2.5 uses attachment $type0/* hook.
636 * Since 1.5.0 uses attachments_bottom hook.
637 * Since 1.5.2 uses templates and does *not* return a value.
638 *
639 * @param object $message SquirrelMail message object
640 * @param array $exclude_id message parts that are not attachments.
641 * @param string $mailbox mailbox name
642 * @param integer $id message id
643 */
644function formatAttachments($message, $exclude_id, $mailbox, $id) {
645 global $oTemplate;
2b665f28 646
d67f519a 647 $attach = buildAttachmentArray($message, $exclude_id, $mailbox, $id);
d0187bd6 648
649 $oTemplate->assign('attachments', $attach);
650 $oTemplate->display('read_attachments.tpl');
451f74a2 651}
b74ba498 652
7c7b74b3 653function sqimap_base64_decode(&$string) {
7c0ec1d8 654
b17a8968 655 // Base64 encoded data goes in pairs of 4 bytes. To achieve on the
7c0ec1d8 656 // fly decoding (to reduce memory usage) you have to check if the
657 // data has incomplete pairs
658
b17a8968 659 // Remove the noise in order to check if the 4 bytes pairs are complete
7c0ec1d8 660 $string = str_replace(array("\r\n","\n", "\r", " "),array('','','',''),$string);
661
42ce44f8 662 $sStringRem = '';
7c0ec1d8 663 $iMod = strlen($string) % 4;
664 if ($iMod) {
665 $sStringRem = substr($string,-$iMod);
b17a8968 666 // Check if $sStringRem contains padding characters
7c0ec1d8 667 if (substr($sStringRem,-1) != '=') {
668 $string = substr($string,0,-$iMod);
669 } else {
670 $sStringRem = '';
671 }
672 }
7c7b74b3 673 $string = base64_decode($string);
7c0ec1d8 674 return $sStringRem;
7c7b74b3 675}
676
fdf7cef1 677/**
678 * Decodes encoded message body
679 *
680 * This function decodes the body depending on the encoding type.
681 * Currently quoted-printable and base64 encodings are supported.
682 * decode_body hook was added to this function in 1.4.2/1.5.0
683 * @param string $body encoded message body
684 * @param string $encoding used encoding
685 * @return string decoded string
686 * @since 1.0
687 */
451f74a2 688function decodeBody($body, $encoding) {
83be314a 689
b583c3e8 690 $body = str_replace("\r\n", "\n", $body);
691 $encoding = strtolower($encoding);
3d8371be 692
d849b570 693 $encoding_handler = do_hook('decode_body', $encoding);
5166f86a 694
695
696 // plugins get first shot at decoding the body
697 //
698 if (!empty($encoding_handler) && function_exists($encoding_handler)) {
699 $body = $encoding_handler('decode', $body);
700
fdf7cef1 701 } elseif ($encoding == 'quoted-printable' ||
8bd0068d 702 $encoding == 'quoted_printable') {
fdf7cef1 703 /**
704 * quoted_printable_decode() function is broken in older
705 * php versions. Text with \r\n decoding was fixed only
758a7889 706 * in php 4.3.0. Minimal code requirement 4.0.4 +
fdf7cef1 707 * str_replace("\r\n", "\n", $body); call.
708 */
b583c3e8 709 $body = quoted_printable_decode($body);
fdf7cef1 710 } elseif ($encoding == 'base64') {
b583c3e8 711 $body = base64_decode($body);
712 }
3d8371be 713
b583c3e8 714 // All other encodings are returned raw.
3d8371be 715 return $body;
451f74a2 716}
717
9f7f68c3 718/**
8bd0068d 719 * Decodes headers
720 *
e1115979 721 * This function decodes strings that are encoded according to
8bd0068d 722 * RFC1522 (MIME Part Two: Message Header Extensions for Non-ASCII Text).
723 * Patched by Christian Schmidt <christian@ostenfeld.dk> 23/03/2002
724 *
725 * @param string $string header string that has to be made readable
726 * @param boolean $utfencode change message in order to be readable on user's charset. defaults to true
bcae324b 727 * @param boolean $htmlsafe preserve spaces and sanitize html special characters. defaults to true
8bd0068d 728 * @param boolean $decide decide if string can be utfencoded. defaults to false
729 * @return string decoded header string
730 */
bcae324b 731function decodeHeader ($string, $utfencode=true,$htmlsafe=true,$decide=false) {
d6f584fc 732 global $languages, $squirrelmail_language,$default_charset;
79e07c7e 733 if (is_array($string)) {
734 $string = implode("\n", $string);
735 }
da2415c1 736
10dec454 737 if (isset($languages[$squirrelmail_language]['XTRA_CODE']) &&
8bd0068d 738 function_exists($languages[$squirrelmail_language]['XTRA_CODE'] . '_decodeheader')) {
33a55f5a 739 $string = call_user_func($languages[$squirrelmail_language]['XTRA_CODE'] . '_decodeheader', $string);
08b7f7cc 740 // Do we need to return at this point?
741 // return $string;
83be314a 742 }
79e07c7e 743 $i = 0;
08b7f7cc 744 $iLastMatch = -2;
db65b6b0 745 $encoded = true;
0a06275a 746
098ea084 747 $aString = explode(' ',$string);
08b7f7cc 748 $ret = '';
098ea084 749 foreach ($aString as $chunk) {
358a78a1 750 if ($encoded && $chunk === '') {
08b7f7cc 751 continue;
358a78a1 752 } elseif ($chunk === '') {
08b7f7cc 753 $ret .= ' ';
754 continue;
755 }
098ea084 756 $encoded = false;
08b7f7cc 757 /* if encoded words are not separated by a linear-space-white we still catch them */
758 $j = $i-1;
7e6ca3e8 759
08b7f7cc 760 while ($match = preg_match('/^(.*)=\?([^?]*)\?(Q|B)\?([^?]*)\?=(.*)$/Ui',$chunk,$res)) {
761 /* if the last chunk isn't an encoded string then put back the space, otherwise don't */
762 if ($iLastMatch !== $j) {
bcae324b 763 if ($htmlsafe) {
9f7f68c3 764 $ret .= '&#32;';
08b7f7cc 765 } else {
766 $ret .= ' ';
767 }
768 }
769 $iLastMatch = $i;
770 $j = $i;
bcae324b 771 if ($htmlsafe) {
cb718de0 772 $ret .= htmlspecialchars($res[1]);
773 } else {
774 $ret .= $res[1];
775 }
098ea084 776 $encoding = ucfirst($res[3]);
d6f584fc 777
778 /* decide about valid decoding */
779 if ($decide && is_conversion_safe($res[2])) {
8bd0068d 780 $utfencode=true;
781 $can_be_encoded=true;
d6f584fc 782 } else {
8bd0068d 783 $can_be_encoded=false;
d6f584fc 784 }
098ea084 785 switch ($encoding)
786 {
8bd0068d 787 case 'B':
788 $replace = base64_decode($res[4]);
789 if ($utfencode) {
790 if ($can_be_encoded) {
791 /* convert string to different charset,
792 * if functions asks for it (usually in compose)
793 */
bcae324b 794 $ret .= charset_convert($res[2],$replace,$default_charset,$htmlsafe);
8bd0068d 795 } else {
796 // convert string to html codes in order to display it
797 $ret .= charset_decode($res[2],$replace);
798 }
fab65ca9 799 } else {
bcae324b 800 if ($htmlsafe) {
8bd0068d 801 $replace = htmlspecialchars($replace);
802 }
803 $ret.= $replace;
fab65ca9 804 }
8bd0068d 805 break;
806 case 'Q':
807 $replace = str_replace('_', ' ', $res[4]);
808 $replace = preg_replace('/=([0-9a-f]{2})/ie', 'chr(hexdec("\1"))',
809 $replace);
810 if ($utfencode) {
811 if ($can_be_encoded) {
812 /* convert string to different charset,
813 * if functions asks for it (usually in compose)
814 */
bcae324b 815 $replace = charset_convert($res[2], $replace,$default_charset,$htmlsafe);
8bd0068d 816 } else {
817 // convert string to html codes in order to display it
818 $replace = charset_decode($res[2], $replace);
819 }
820 } else {
bcae324b 821 if ($htmlsafe) {
8bd0068d 822 $replace = htmlspecialchars($replace);
823 }
098ea084 824 }
8bd0068d 825 $ret .= $replace;
826 break;
827 default:
828 break;
79e07c7e 829 }
098ea084 830 $chunk = $res[5];
831 $encoded = true;
08b7f7cc 832 }
833 if (!$encoded) {
bcae324b 834 if ($htmlsafe) {
9f7f68c3 835 $ret .= '&#32;';
08b7f7cc 836 } else {
837 $ret .= ' ';
da2415c1 838 }
08b7f7cc 839 }
dc3d13a7 840
bcae324b 841 if (!$encoded && $htmlsafe) {
dc3d13a7 842 $ret .= htmlspecialchars($chunk);
843 } else {
844 $ret .= $chunk;
845 }
098ea084 846 ++$i;
847 }
fd81e884 848 /* remove the first added space */
849 if ($ret) {
bcae324b 850 if ($htmlsafe) {
9f7f68c3 851 $ret = substr($ret,5);
fd81e884 852 } else {
853 $ret = substr($ret,1);
854 }
855 }
da2415c1 856
08b7f7cc 857 return $ret;
451f74a2 858}
859
9f7f68c3 860/**
a24cf710 861 * Encodes header
8bd0068d 862 *
a24cf710 863 * Function uses XTRA_CODE _encodeheader function, if such function exists.
a24cf710 864 *
758a7889 865 * Function uses Q encoding by default and encodes a string according to RFC
866 * 1522 for use in headers if it contains 8-bit characters or anything that
a24cf710 867 * looks like it should be encoded.
8bd0068d 868 *
758a7889 869 * Function switches to B encoding and encodeHeaderBase64() function, if
870 * string is 8bit and multibyte character set supported by mbstring extension
871 * is used. It can cause E_USER_NOTICE errors, if interface is used with
f270a6eb 872 * multibyte character set unsupported by mbstring extension.
873 *
8bd0068d 874 * @param string $string header string, that has to be encoded
875 * @return string quoted-printable encoded string
f270a6eb 876 * @todo make $mb_charsets system wide constant
8bd0068d 877 */
451f74a2 878function encodeHeader ($string) {
6fbd125b 879 global $default_charset, $languages, $squirrelmail_language;
83be314a 880
10dec454 881 if (isset($languages[$squirrelmail_language]['XTRA_CODE']) &&
8bd0068d 882 function_exists($languages[$squirrelmail_language]['XTRA_CODE'] . '_encodeheader')) {
33a55f5a 883 return call_user_func($languages[$squirrelmail_language]['XTRA_CODE'] . '_encodeheader', $string);
83be314a 884 }
793cc001 885
a24cf710 886 // Use B encoding for multibyte charsets
f270a6eb 887 $mb_charsets = array('utf-8','big5','gb2313','euc-kr');
888 if (in_array($default_charset,$mb_charsets) &&
889 in_array($default_charset,sq_mb_list_encodings()) &&
890 sq_is8bit($string)) {
891 return encodeHeaderBase64($string,$default_charset);
892 } elseif (in_array($default_charset,$mb_charsets) &&
893 sq_is8bit($string) &&
894 ! in_array($default_charset,sq_mb_list_encodings())) {
895 // Add E_USER_NOTICE error here (can cause 'Cannot add header information' warning in compose.php)
896 // trigger_error('encodeHeader: Multibyte character set unsupported by mbstring extension.',E_USER_NOTICE);
897 }
a24cf710 898
451f74a2 899 // Encode only if the string contains 8-bit characters or =?
3d8371be 900 $j = strlen($string);
098ea084 901 $max_l = 75 - strlen($default_charset) - 7;
902 $aRet = array();
451f74a2 903 $ret = '';
c96c32f4 904 $iEncStart = $enc_init = false;
0d53f0f9 905 $cur_l = $iOffset = 0;
3d8371be 906 for($i = 0; $i < $j; ++$i) {
c96c32f4 907 switch($string{$i})
908 {
8bd0068d 909 case '=':
910 case '<':
911 case '>':
912 case ',':
913 case '?':
914 case '_':
915 if ($iEncStart === false) {
916 $iEncStart = $i;
917 }
918 $cur_l+=3;
919 if ($cur_l > ($max_l-2)) {
920 /* if there is an stringpart that doesn't need encoding, add it */
08b7f7cc 921 $aRet[] = substr($string,$iOffset,$iEncStart-$iOffset);
c96c32f4 922 $aRet[] = "=?$default_charset?Q?$ret?=";
923 $iOffset = $i;
924 $cur_l = 0;
925 $ret = '';
926 $iEncStart = false;
08b7f7cc 927 } else {
8bd0068d 928 $ret .= sprintf("=%02X",ord($string{$i}));
c96c32f4 929 }
8bd0068d 930 break;
931 case '(':
932 case ')':
933 if ($iEncStart !== false) {
08b7f7cc 934 $aRet[] = substr($string,$iOffset,$iEncStart-$iOffset);
8bd0068d 935 $aRet[] = "=?$default_charset?Q?$ret?=";
c96c32f4 936 $iOffset = $i;
8bd0068d 937 $cur_l = 0;
938 $ret = '';
939 $iEncStart = false;
c96c32f4 940 }
8bd0068d 941 break;
942 case ' ':
c96c32f4 943 if ($iEncStart !== false) {
098ea084 944 $cur_l++;
945 if ($cur_l > $max_l) {
08b7f7cc 946 $aRet[] = substr($string,$iOffset,$iEncStart-$iOffset);
c96c32f4 947 $aRet[] = "=?$default_charset?Q?$ret?=";
c96c32f4 948 $iOffset = $i;
949 $cur_l = 0;
098ea084 950 $ret = '';
8bd0068d 951 $iEncStart = false;
08b7f7cc 952 } else {
8bd0068d 953 $ret .= '_';
c96c32f4 954 }
3d8371be 955 }
8bd0068d 956 break;
957 default:
958 $k = ord($string{$i});
959 if ($k > 126) {
960 if ($iEncStart === false) {
961 // do not start encoding in the middle of a string, also take the rest of the word.
962 $sLeadString = substr($string,0,$i);
963 $aLeadString = explode(' ',$sLeadString);
964 $sToBeEncoded = array_pop($aLeadString);
965 $iEncStart = $i - strlen($sToBeEncoded);
966 $ret .= $sToBeEncoded;
967 $cur_l += strlen($sToBeEncoded);
968 }
969 $cur_l += 3;
970 /* first we add the encoded string that reached it's max size */
971 if ($cur_l > ($max_l-2)) {
972 $aRet[] = substr($string,$iOffset,$iEncStart-$iOffset);
973 $aRet[] = "=?$default_charset?Q?$ret?= "; /* the next part is also encoded => separate by space */
974 $cur_l = 3;
975 $ret = '';
976 $iOffset = $i;
977 $iEncStart = $i;
978 }
979 $enc_init = true;
980 $ret .= sprintf("=%02X", $k);
981 } else {
982 if ($iEncStart !== false) {
983 $cur_l++;
984 if ($cur_l > $max_l) {
985 $aRet[] = substr($string,$iOffset,$iEncStart-$iOffset);
986 $aRet[] = "=?$default_charset?Q?$ret?=";
987 $iEncStart = false;
988 $iOffset = $i;
989 $cur_l = 0;
990 $ret = '';
991 } else {
992 $ret .= $string{$i};
993 }
994 }
995 }
996 break;
f7b3ba37 997 }
451f74a2 998 }
793cc001 999
c96c32f4 1000 if ($enc_init) {
1001 if ($iEncStart !== false) {
1002 $aRet[] = substr($string,$iOffset,$iEncStart-$iOffset);
1003 $aRet[] = "=?$default_charset?Q?$ret?=";
1004 } else {
1005 $aRet[] = substr($string,$iOffset);
1006 }
1007 $string = implode('',$aRet);
451f74a2 1008 }
3d8371be 1009 return $string;
451f74a2 1010}
b74ba498 1011
f270a6eb 1012/**
1013 * Encodes string according to rfc2047 B encoding header formating rules
1014 *
758a7889 1015 * It is recommended way to encode headers with character sets that store
f270a6eb 1016 * symbols in more than one byte.
1017 *
1018 * Function requires mbstring support. If required mbstring functions are missing,
1019 * function returns false and sets E_USER_WARNING level error message.
1020 *
758a7889 1021 * Minimal requirements - php 4.0.6 with mbstring extension. Please note,
1022 * that mbstring functions will generate E_WARNING errors, if unsupported
f270a6eb 1023 * character set is used. mb_encode_mimeheader function provided by php
1024 * mbstring extension is not used in order to get better control of header
1025 * encoding.
1026 *
758a7889 1027 * Used php code functions - function_exists(), trigger_error(), strlen()
1028 * (is used with charset names and base64 strings). Used php mbstring
f270a6eb 1029 * functions - mb_strlen and mb_substr.
1030 *
758a7889 1031 * Related documents: rfc 2045 (BASE64 encoding), rfc 2047 (mime header
f270a6eb 1032 * encoding), rfc 2822 (header folding)
1033 *
1034 * @param string $string header string that must be encoded
758a7889 1035 * @param string $charset character set. Must be supported by mbstring extension.
f270a6eb 1036 * Use sq_mb_list_encodings() to detect supported charsets.
1037 * @return string string encoded according to rfc2047 B encoding formating rules
1038 * @since 1.5.1
1039 * @todo First header line can be wrapped to $iMaxLength - $HeaderFieldLength - 1
1040 * @todo Do we want to control max length of header?
1041 * @todo Do we want to control EOL (end-of-line) marker?
1042 * @todo Do we want to translate error message?
1043 */
1044function encodeHeaderBase64($string,$charset) {
1045 /**
1046 * Check mbstring function requirements.
1047 */
1048 if (! function_exists('mb_strlen') ||
1049 ! function_exists('mb_substr')) {
1050 // set E_USER_WARNING
1051 trigger_error('encodeHeaderBase64: Required mbstring functions are missing.',E_USER_WARNING);
1052 // return false
1053 return false;
1054 }
1055
1056 // initial return array
1057 $aRet = array();
1058
1059 /**
1060 * header length = 75 symbols max (same as in encodeHeader)
1061 * remove $charset length
1062 * remove =? ? ?= (5 chars)
1063 * remove 2 more chars (\r\n ?)
1064 */
1065 $iMaxLength = 75 - strlen($charset) - 7;
1066
1067 // set first character position
1068 $iStartCharNum = 0;
1069
1070 // loop through all characters. count characters and not bytes.
1071 for ($iCharNum=1; $iCharNum<=mb_strlen($string,$charset); $iCharNum++) {
1072 // encode string from starting character to current character.
1073 $encoded_string = base64_encode(mb_substr($string,$iStartCharNum,$iCharNum-$iStartCharNum,$charset));
1074
1075 // Check encoded string length
1076 if(strlen($encoded_string)>$iMaxLength) {
1077 // if string exceeds max length, reduce number of encoded characters and add encoded string part to array
1078 $aRet[] = base64_encode(mb_substr($string,$iStartCharNum,$iCharNum-$iStartCharNum-1,$charset));
1079
1080 // set new starting character
1081 $iStartCharNum = $iCharNum-1;
1082
1083 // encode last char (in case it is last character in string)
1084 $encoded_string = base64_encode(mb_substr($string,$iStartCharNum,$iCharNum-$iStartCharNum,$charset));
1085 } // if string is shorter than max length - add next character
1086 }
1087
1088 // add last encoded string to array
1089 $aRet[] = $encoded_string;
1090
1091 // set initial return string
1092 $sRet = '';
1093
1094 // loop through encoded strings
1095 foreach($aRet as $string) {
1096 // TODO: Do we want to control EOL (end-of-line) marker
1097 if ($sRet!='') $sRet.= " ";
1098
1099 // add header tags and encoded string to return string
1100 $sRet.= '=?'.$charset.'?B?'.$string.'?=';
1101 }
1102
1103 return $sRet;
1104}
1105
691a2d25 1106/* This function trys to locate the entity_id of a specific mime element */
3d8371be 1107function find_ent_id($id, $message) {
a171b359 1108 for ($i = 0, $ret = ''; $ret == '' && $i < count($message->entities); $i++) {
1109 if ($message->entities[$i]->header->type0 == 'multipart') {
3d8371be 1110 $ret = find_ent_id($id, $message->entities[$i]);
451f74a2 1111 } else {
3d8371be 1112 if (strcasecmp($message->entities[$i]->header->id, $id) == 0) {
d8cffbab 1113// if (sq_check_save_extension($message->entities[$i])) {
8bd0068d 1114 return $message->entities[$i]->entity_id;
da2415c1 1115// }
c8f5f606 1116 } elseif (!empty($message->entities[$i]->header->parameters['name'])) {
1117 /**
1118 * This is part of a fix for Outlook Express 6.x generating
1119 * cid URLs without creating content-id headers
1120 * @@JA - 20050207
1121 */
1122 if (strcasecmp($message->entities[$i]->header->parameters['name'], $id) == 0) {
1123 return $message->entities[$i]->entity_id;
1124 }
3d8371be 1125 }
a3daaaf3 1126 }
451f74a2 1127 }
3d8371be 1128 return $ret;
451f74a2 1129}
a3daaaf3 1130
e5e9381a 1131function sq_check_save_extension($message) {
1132 $filename = $message->getFilename();
1133 $ext = substr($filename, strrpos($filename,'.')+1);
1134 $save_extensions = array('jpg','jpeg','gif','png','bmp');
3d8371be 1135 return in_array($ext, $save_extensions);
e5e9381a 1136}
1137
1138
691a2d25 1139/**
8bd0068d 1140 ** HTMLFILTER ROUTINES
1141 */
451f74a2 1142
691a2d25 1143/**
0493ed11 1144 * This function checks attribute values for entity-encoded values
1145 * and returns them translated into 8-bit strings so we can run
1146 * checks on them.
8bd0068d 1147 *
0493ed11 1148 * @param $attvalue A string to run entity check against.
1149 * @return Nothing, modifies a reference value.
8bd0068d 1150 */
0493ed11 1151function sq_defang(&$attvalue){
1152 $me = 'sq_defang';
2dd879b8 1153 /**
0493ed11 1154 * Skip this if there aren't ampersands or backslashes.
8bd0068d 1155 */
0493ed11 1156 if (strpos($attvalue, '&') === false
1157 && strpos($attvalue, '\\') === false){
1158 return;
2dd879b8 1159 }
0493ed11 1160 $m = false;
2b665f28 1161 // before deent, translate the dangerous unicode characters and ... to safe values
1162 // otherwise the regular expressions do not match.
1163
1164
1165
0493ed11 1166 do {
1167 $m = false;
1168 $m = $m || sq_deent($attvalue, '/\&#0*(\d+);*/s');
1169 $m = $m || sq_deent($attvalue, '/\&#x0*((\d|[a-f])+);*/si', true);
1170 $m = $m || sq_deent($attvalue, '/\\\\(\d+)/s', true);
1171 } while ($m == true);
1172 $attvalue = stripslashes($attvalue);
2dd879b8 1173}
1174
1175/**
8bd0068d 1176 * Kill any tabs, newlines, or carriage returns. Our friends the
1177 * makers of the browser with 95% market value decided that it'd
1178 * be funny to make "java[tab]script" be just as good as "javascript".
1179 *
1180 * @param attvalue The attribute value before extraneous spaces removed.
0493ed11 1181 * @return attvalue Nothing, modifies a reference value.
8bd0068d 1182 */
0493ed11 1183function sq_unspace(&$attvalue){
1184 $me = 'sq_unspace';
1185 if (strcspn($attvalue, "\t\r\n\0 ") != strlen($attvalue)){
1186 $attvalue = str_replace(Array("\t", "\r", "\n", "\0", " "),
1187 Array('', '', '', '', ''), $attvalue);
2dd879b8 1188 }
2dd879b8 1189}
1190
1191/**
88de4926 1192 * Translate all dangerous Unicode or Shift_JIS characters which are accepted by
2b665f28 1193 * IE as regular characters.
1194 *
1195 * @param attvalue The attribute value before dangerous characters are translated.
1196 * @return attvalue Nothing, modifies a reference value.
1197 * @author Marc Groot Koerkamp.
1198 */
1199function sq_fixIE_idiocy(&$attvalue) {
1200 // remove NUL
1201 $attvalue = str_replace("\0", "", $attvalue);
1202 // remove comments
1203 $attvalue = preg_replace("/(\/\*.*?\*\/)/","",$attvalue);
1204
88de4926 1205 // IE has the evil habit of accepting every possible value for the attribute expression.
1206 // The table below contains characters which are parsed by IE if they are used in the "expression"
2b665f28 1207 // attribute value.
1208 $aDangerousCharsReplacementTable = array(
1209 array('&#x029F;', '&#0671;' ,/* L UNICODE IPA Extension */
1210 '&#x0280;', '&#0640;' ,/* R UNICODE IPA Extension */
1211 '&#x0274;', '&#0628;' ,/* N UNICODE IPA Extension */
567dc524 1212 '&#xFF25;', '&#65317;' ,/* Unicode FULLWIDTH LATIN CAPITAL LETTER E */
1213 '&#xFF45;', '&#65349;' ,/* Unicode FULLWIDTH LATIN SMALL LETTER E */
2b665f28 1214 '&#xFF38;', '&#65336;',/* Unicode FULLWIDTH LATIN CAPITAL LETTER X */
1215 '&#xFF58;', '&#65368;',/* Unicode FULLWIDTH LATIN SMALL LETTER X */
1216 '&#xFF30;', '&#65328;',/* Unicode FULLWIDTH LATIN CAPITAL LETTER P */
1217 '&#xFF50;', '&#65360;',/* Unicode FULLWIDTH LATIN SMALL LETTER P */
1218 '&#xFF32;', '&#65330;',/* Unicode FULLWIDTH LATIN CAPITAL LETTER R */
1219 '&#xFF52;', '&#65362;',/* Unicode FULLWIDTH LATIN SMALL LETTER R */
1220 '&#xFF33;', '&#65331;',/* Unicode FULLWIDTH LATIN CAPITAL LETTER S */
1221 '&#xFF53;', '&#65363;',/* Unicode FULLWIDTH LATIN SMALL LETTER S */
1222 '&#xFF29;', '&#65321;',/* Unicode FULLWIDTH LATIN CAPITAL LETTER I */
1223 '&#xFF49;', '&#65353;',/* Unicode FULLWIDTH LATIN SMALL LETTER I */
1224 '&#xFF2F;', '&#65327;',/* Unicode FULLWIDTH LATIN CAPITAL LETTER O */
1225 '&#xFF4F;', '&#65359;',/* Unicode FULLWIDTH LATIN SMALL LETTER O */
1226 '&#xFF2E;', '&#65326;',/* Unicode FULLWIDTH LATIN CAPITAL LETTER N */
1227 '&#xFF4E;', '&#65358;',/* Unicode FULLWIDTH LATIN SMALL LETTER N */
1228 '&#xFF2C;', '&#65324;',/* Unicode FULLWIDTH LATIN CAPITAL LETTER L */
1229 '&#xFF4C;', '&#65356;',/* Unicode FULLWIDTH LATIN SMALL LETTER L */
1230 '&#xFF35;', '&#65333;',/* Unicode FULLWIDTH LATIN CAPITAL LETTER U */
1231 '&#xFF55;', '&#65365;',/* Unicode FULLWIDTH LATIN SMALL LETTER U */
1232 '&#x207F;', '&#8319;' ,/* Unicode SUPERSCRIPT LATIN SMALL LETTER N */
567dc524 1233 "\xEF\xBC\xA5", /* Shift JIS FULLWIDTH LATIN CAPITAL LETTER E */ // in unicode this is some Chinese char range
1234 "\xEF\xBD\x85", /* Shift JIS FULLWIDTH LATIN SMALL LETTER E */
1235 "\xEF\xBC\xB8", /* Shift JIS FULLWIDTH LATIN CAPITAL LETTER X */
1236 "\xEF\xBD\x98", /* Shift JIS FULLWIDTH LATIN SMALL LETTER X */
1237 "\xEF\xBC\xB0", /* Shift JIS FULLWIDTH LATIN CAPITAL LETTER P */
1238 "\xEF\xBD\x90", /* Shift JIS FULLWIDTH LATIN SMALL LETTER P */
1239 "\xEF\xBC\xB2", /* Shift JIS FULLWIDTH LATIN CAPITAL LETTER R */
1240 "\xEF\xBD\x92", /* Shift JIS FULLWIDTH LATIN SMALL LETTER R */
1241 "\xEF\xBC\xB3", /* Shift JIS FULLWIDTH LATIN CAPITAL LETTER S */
1242 "\xEF\xBD\x93", /* Shift JIS FULLWIDTH LATIN SMALL LETTER S */
1243 "\xEF\xBC\xA9", /* Shift JIS FULLWIDTH LATIN CAPITAL LETTER I */
1244 "\xEF\xBD\x89", /* Shift JIS FULLWIDTH LATIN SMALL LETTER I */
1245 "\xEF\xBC\xAF", /* Shift JIS FULLWIDTH LATIN CAPITAL LETTER O */
1246 "\xEF\xBD\x8F", /* Shift JIS FULLWIDTH LATIN SMALL LETTER O */
1247 "\xEF\xBC\xAE", /* Shift JIS FULLWIDTH LATIN CAPITAL LETTER N */
1248 "\xEF\xBD\x8E", /* Shift JIS FULLWIDTH LATIN SMALL LETTER N */
1249 "\xEF\xBC\xAC", /* Shift JIS FULLWIDTH LATIN CAPITAL LETTER L */
1250 "\xEF\xBD\x8C", /* Shift JIS FULLWIDTH LATIN SMALL LETTER L */
1251 "\xEF\xBC\xB5", /* Shift JIS FULLWIDTH LATIN CAPITAL LETTER U */
1252 "\xEF\xBD\x95", /* Shift JIS FULLWIDTH LATIN SMALL LETTER U */
1253 "\xE2\x81\xBF", /* Shift JIS FULLWIDTH SUPERSCRIPT N */
1254 "\xCA\x9F", /* L UNICODE IPA Extension */
1255 "\xCA\x80", /* R UNICODE IPA Extension */
1256 "\xC9\xB4"), /* N UNICODE IPA Extension */
2b665f28 1257 array('l', 'l', 'r','r','n','n',
567dc524 1258 'E','E','e','e','X','X','x','x','P','P','p','p','R','R','r','r','S','S','s','s','I','I',
1259 'i','i','O','O','o','o','N','N','n','n','L','L','l','l','U','U','u','u','n','n',
1260 'E','e','X','x','P','p','R','r','S','s','I','i','O','o','N','n','L','l','U','u','n','l','r','n'));
2b665f28 1261 $attvalue = str_replace($aDangerousCharsReplacementTable[0],$aDangerousCharsReplacementTable[1],$attvalue);
1262
88de4926 1263 // Escapes are useful for special characters like "{}[]()'&. In other cases they are
1264 // used for XSS.
2b665f28 1265 $attvalue = preg_replace("/(\\\\)([a-zA-Z]{1})/",'$2',$attvalue);
1266}
1267
1268/**
8bd0068d 1269 * This function returns the final tag out of the tag name, an array
1270 * of attributes, and the type of the tag. This function is called by
1271 * sq_sanitize internally.
1272 *
1273 * @param $tagname the name of the tag.
1274 * @param $attary the array of attributes and their values
1275 * @param $tagtype The type of the tag (see in comments).
1276 * @return a string with the final tag representation.
1277 */
691a2d25 1278function sq_tagprint($tagname, $attary, $tagtype){
b583c3e8 1279 $me = 'sq_tagprint';
3d8371be 1280
691a2d25 1281 if ($tagtype == 2){
1282 $fulltag = '</' . $tagname . '>';
1283 } else {
1284 $fulltag = '<' . $tagname;
1285 if (is_array($attary) && sizeof($attary)){
1286 $atts = Array();
1287 while (list($attname, $attvalue) = each($attary)){
1288 array_push($atts, "$attname=$attvalue");
1289 }
1290 $fulltag .= ' ' . join(" ", $atts);
1291 }
1292 if ($tagtype == 3){
b583c3e8 1293 $fulltag .= ' /';
691a2d25 1294 }
b583c3e8 1295 $fulltag .= '>';
451f74a2 1296 }
691a2d25 1297 return $fulltag;
451f74a2 1298}
a3daaaf3 1299
691a2d25 1300/**
8bd0068d 1301 * A small helper function to use with array_walk. Modifies a by-ref
1302 * value and makes it lowercase.
1303 *
1304 * @param $val a value passed by-ref.
1305 * @return void since it modifies a by-ref value.
1306 */
691a2d25 1307function sq_casenormalize(&$val){
1308 $val = strtolower($val);
1309}
451f74a2 1310
691a2d25 1311/**
8bd0068d 1312 * This function skips any whitespace from the current position within
1313 * a string and to the next non-whitespace value.
1314 *
1315 * @param $body the string
1316 * @param $offset the offset within the string where we should start
1317 * looking for the next non-whitespace character.
1318 * @return the location within the $body where the next
1319 * non-whitespace char is located.
1320 */
691a2d25 1321function sq_skipspace($body, $offset){
b583c3e8 1322 $me = 'sq_skipspace';
3d8371be 1323 preg_match('/^(\s*)/s', substr($body, $offset), $matches);
691a2d25 1324 if (sizeof($matches{1})){
1325 $count = strlen($matches{1});
1326 $offset += $count;
451f74a2 1327 }
691a2d25 1328 return $offset;
451f74a2 1329}
a3daaaf3 1330
691a2d25 1331/**
8bd0068d 1332 * This function looks for the next character within a string. It's
1333 * really just a glorified "strpos", except it catches if failures
1334 * nicely.
1335 *
1336 * @param $body The string to look for needle in.
1337 * @param $offset Start looking from this position.
1338 * @param $needle The character/string to look for.
1339 * @return location of the next occurance of the needle, or
1340 * strlen($body) if needle wasn't found.
1341 */
691a2d25 1342function sq_findnxstr($body, $offset, $needle){
3d8371be 1343 $me = 'sq_findnxstr';
691a2d25 1344 $pos = strpos($body, $needle, $offset);
1345 if ($pos === FALSE){
1346 $pos = strlen($body);
451f74a2 1347 }
691a2d25 1348 return $pos;
451f74a2 1349}
a3daaaf3 1350
691a2d25 1351/**
8bd0068d 1352 * This function takes a PCRE-style regexp and tries to match it
1353 * within the string.
1354 *
1355 * @param $body The string to look for needle in.
1356 * @param $offset Start looking from here.
1357 * @param $reg A PCRE-style regex to match.
1358 * @return Returns a false if no matches found, or an array
1359 * with the following members:
1360 * - integer with the location of the match within $body
1361 * - string with whatever content between offset and the match
1362 * - string with whatever it is we matched
1363 */
691a2d25 1364function sq_findnxreg($body, $offset, $reg){
b583c3e8 1365 $me = 'sq_findnxreg';
691a2d25 1366 $matches = Array();
1367 $retarr = Array();
7d06541f 1368 preg_match("%^(.*?)($reg)%si", substr($body, $offset), $matches);
1369 if (!isset($matches{0}) || !$matches{0}){
691a2d25 1370 $retarr = false;
1371 } else {
1372 $retarr{0} = $offset + strlen($matches{1});
1373 $retarr{1} = $matches{1};
1374 $retarr{2} = $matches{2};
1375 }
1376 return $retarr;
1377}
a3daaaf3 1378
691a2d25 1379/**
8bd0068d 1380 * This function looks for the next tag.
1381 *
1382 * @param $body String where to look for the next tag.
1383 * @param $offset Start looking from here.
1384 * @return false if no more tags exist in the body, or
1385 * an array with the following members:
1386 * - string with the name of the tag
1387 * - array with attributes and their values
1388 * - integer with tag type (1, 2, or 3)
1389 * - integer where the tag starts (starting "<")
1390 * - integer where the tag ends (ending ">")
1391 * first three members will be false, if the tag is invalid.
1392 */
691a2d25 1393function sq_getnxtag($body, $offset){
b583c3e8 1394 $me = 'sq_getnxtag';
691a2d25 1395 if ($offset > strlen($body)){
1396 return false;
1397 }
1398 $lt = sq_findnxstr($body, $offset, "<");
1399 if ($lt == strlen($body)){
1400 return false;
1401 }
1402 /**
8bd0068d 1403 * We are here:
1404 * blah blah <tag attribute="value">
1405 * \---------^
1406 */
691a2d25 1407 $pos = sq_skipspace($body, $lt+1);
1408 if ($pos >= strlen($body)){
1409 return Array(false, false, false, $lt, strlen($body));
1410 }
1411 /**
8bd0068d 1412 * There are 3 kinds of tags:
1413 * 1. Opening tag, e.g.:
1414 * <a href="blah">
1415 * 2. Closing tag, e.g.:
1416 * </a>
1417 * 3. XHTML-style content-less tag, e.g.:
1418 * <img src="blah" />
1419 */
691a2d25 1420 $tagtype = false;
1421 switch (substr($body, $pos, 1)){
3d8371be 1422 case '/':
1423 $tagtype = 2;
1424 $pos++;
1425 break;
1426 case '!':
1427 /**
8bd0068d 1428 * A comment or an SGML declaration.
1429 */
3d8371be 1430 if (substr($body, $pos+1, 2) == "--"){
1431 $gt = strpos($body, "-->", $pos);
1432 if ($gt === false){
1433 $gt = strlen($body);
1434 } else {
1435 $gt += 2;
1436 }
1437 return Array(false, false, false, $lt, $gt);
bb8d0799 1438 } else {
3d8371be 1439 $gt = sq_findnxstr($body, $pos, ">");
1440 return Array(false, false, false, $lt, $gt);
1441 }
1442 break;
1443 default:
1444 /**
8bd0068d 1445 * Assume tagtype 1 for now. If it's type 3, we'll switch values
1446 * later.
1447 */
3d8371be 1448 $tagtype = 1;
1449 break;
691a2d25 1450 }
a3daaaf3 1451
0493ed11 1452 $tag_start = $pos;
691a2d25 1453 $tagname = '';
1454 /**
8bd0068d 1455 * Look for next [\W-_], which will indicate the end of the tag name.
1456 */
691a2d25 1457 $regary = sq_findnxreg($body, $pos, "[^\w\-_]");
1458 if ($regary == false){
1459 return Array(false, false, false, $lt, strlen($body));
1460 }
1461 list($pos, $tagname, $match) = $regary;
1462 $tagname = strtolower($tagname);
1463
1464 /**
8bd0068d 1465 * $match can be either of these:
1466 * '>' indicating the end of the tag entirely.
1467 * '\s' indicating the end of the tag name.
1468 * '/' indicating that this is type-3 xhtml tag.
1469 *
1470 * Whatever else we find there indicates an invalid tag.
1471 */
691a2d25 1472 switch ($match){
3d8371be 1473 case '/':
691a2d25 1474 /**
8bd0068d 1475 * This is an xhtml-style tag with a closing / at the
1476 * end, like so: <img src="blah" />. Check if it's followed
1477 * by the closing bracket. If not, then this tag is invalid
1478 */
3d8371be 1479 if (substr($body, $pos, 2) == "/>"){
1480 $pos++;
1481 $tagtype = 3;
1482 } else {
1483 $gt = sq_findnxstr($body, $pos, ">");
1484 $retary = Array(false, false, false, $lt, $gt);
1485 return $retary;
1486 }
1487 case '>':
1488 return Array($tagname, false, $tagtype, $lt, $pos);
1489 break;
1490 default:
1491 /**
8bd0068d 1492 * Check if it's whitespace
1493 */
3d8371be 1494 if (!preg_match('/\s/', $match)){
1495 /**
8bd0068d 1496 * This is an invalid tag! Look for the next closing ">".
1497 */
7d06541f 1498 $gt = sq_findnxstr($body, $lt, ">");
3d8371be 1499 return Array(false, false, false, $lt, $gt);
1500 }
1501 break;
691a2d25 1502 }
3d8371be 1503
691a2d25 1504 /**
8bd0068d 1505 * At this point we're here:
1506 * <tagname attribute='blah'>
1507 * \-------^
1508 *
1509 * At this point we loop in order to find all attributes.
1510 */
691a2d25 1511 $attname = '';
0493ed11 1512 $atttype = false;
691a2d25 1513 $attary = Array();
1514
1515 while ($pos <= strlen($body)){
1516 $pos = sq_skipspace($body, $pos);
1517 if ($pos == strlen($body)){
1518 /**
8bd0068d 1519 * Non-closed tag.
1520 */
691a2d25 1521 return Array(false, false, false, $lt, $pos);
1522 }
1523 /**
8bd0068d 1524 * See if we arrived at a ">" or "/>", which means that we reached
1525 * the end of the tag.
1526 */
691a2d25 1527 $matches = Array();
164800ad 1528 if (preg_match("%^(\s*)(>|/>)%s", substr($body, $pos), $matches)) {
c828931c 1529 /**
8bd0068d 1530 * Yep. So we did.
1531 */
c828931c 1532 $pos += strlen($matches{1});
1533 if ($matches{2} == "/>"){
1534 $tagtype = 3;
1535 $pos++;
1536 }
1537 return Array($tagname, $attary, $tagtype, $lt, $pos);
1538 }
a3daaaf3 1539
cca46357 1540 /**
8bd0068d 1541 * There are several types of attributes, with optional
1542 * [:space:] between members.
1543 * Type 1:
1544 * attrname[:space:]=[:space:]'CDATA'
1545 * Type 2:
1546 * attrname[:space:]=[:space:]"CDATA"
1547 * Type 3:
1548 * attr[:space:]=[:space:]CDATA
1549 * Type 4:
1550 * attrname
1551 *
1552 * We leave types 1 and 2 the same, type 3 we check for
1553 * '"' and convert to "&quot" if needed, then wrap in
1554 * double quotes. Type 4 we convert into:
1555 * attrname="yes".
1556 */
3f7c623f 1557 $regary = sq_findnxreg($body, $pos, "[^:\w\-_]");
691a2d25 1558 if ($regary == false){
1559 /**
8bd0068d 1560 * Looks like body ended before the end of tag.
1561 */
691a2d25 1562 return Array(false, false, false, $lt, strlen($body));
cca46357 1563 }
691a2d25 1564 list($pos, $attname, $match) = $regary;
1565 $attname = strtolower($attname);
1566 /**
8bd0068d 1567 * We arrived at the end of attribute name. Several things possible
1568 * here:
1569 * '>' means the end of the tag and this is attribute type 4
1570 * '/' if followed by '>' means the same thing as above
1571 * '\s' means a lot of things -- look what it's followed by.
1572 * anything else means the attribute is invalid.
1573 */
691a2d25 1574 switch($match){
3d8371be 1575 case '/':
691a2d25 1576 /**
8bd0068d 1577 * This is an xhtml-style tag with a closing / at the
1578 * end, like so: <img src="blah" />. Check if it's followed
1579 * by the closing bracket. If not, then this tag is invalid
1580 */
3d8371be 1581 if (substr($body, $pos, 2) == "/>"){
691a2d25 1582 $pos++;
3d8371be 1583 $tagtype = 3;
691a2d25 1584 } else {
3d8371be 1585 $gt = sq_findnxstr($body, $pos, ">");
1586 $retary = Array(false, false, false, $lt, $gt);
1587 return $retary;
1588 }
1589 case '>':
1590 $attary{$attname} = '"yes"';
1591 return Array($tagname, $attary, $tagtype, $lt, $pos);
1592 break;
1593 default:
1594 /**
8bd0068d 1595 * Skip whitespace and see what we arrive at.
1596 */
3d8371be 1597 $pos = sq_skipspace($body, $pos);
1598 $char = substr($body, $pos, 1);
1599 /**
8bd0068d 1600 * Two things are valid here:
1601 * '=' means this is attribute type 1 2 or 3.
1602 * \w means this was attribute type 4.
1603 * anything else we ignore and re-loop. End of tag and
1604 * invalid stuff will be caught by our checks at the beginning
1605 * of the loop.
1606 */
3d8371be 1607 if ($char == "="){
1608 $pos++;
1609 $pos = sq_skipspace($body, $pos);
691a2d25 1610 /**
8bd0068d 1611 * Here are 3 possibilities:
1612 * "'" attribute type 1
1613 * '"' attribute type 2
1614 * everything else is the content of tag type 3
1615 */
3d8371be 1616 $quot = substr($body, $pos, 1);
1617 if ($quot == "'"){
1618 $regary = sq_findnxreg($body, $pos+1, "\'");
1619 if ($regary == false){
1620 return Array(false, false, false, $lt, strlen($body));
1621 }
1622 list($pos, $attval, $match) = $regary;
1623 $pos++;
1624 $attary{$attname} = "'" . $attval . "'";
1625 } else if ($quot == '"'){
1626 $regary = sq_findnxreg($body, $pos+1, '\"');
1627 if ($regary == false){
1628 return Array(false, false, false, $lt, strlen($body));
1629 }
1630 list($pos, $attval, $match) = $regary;
1631 $pos++;
1632 $attary{$attname} = '"' . $attval . '"';
1633 } else {
1634 /**
8bd0068d 1635 * These are hateful. Look for \s, or >.
1636 */
3d8371be 1637 $regary = sq_findnxreg($body, $pos, "[\s>]");
1638 if ($regary == false){
1639 return Array(false, false, false, $lt, strlen($body));
1640 }
1641 list($pos, $attval, $match) = $regary;
1642 /**
8bd0068d 1643 * If it's ">" it will be caught at the top.
1644 */
3d8371be 1645 $attval = preg_replace("/\"/s", "&quot;", $attval);
1646 $attary{$attname} = '"' . $attval . '"';
7e235a1a 1647 }
3d8371be 1648 } else if (preg_match("|[\w/>]|", $char)) {
691a2d25 1649 /**
8bd0068d 1650 * That was attribute type 4.
1651 */
3d8371be 1652 $attary{$attname} = '"yes"';
1653 } else {
1654 /**
8bd0068d 1655 * An illegal character. Find next '>' and return.
1656 */
3d8371be 1657 $gt = sq_findnxstr($body, $pos, ">");
1658 return Array(false, false, false, $lt, $gt);
451f74a2 1659 }
3d8371be 1660 break;
691a2d25 1661 }
1662 }
1663 /**
8bd0068d 1664 * The fact that we got here indicates that the tag end was never
1665 * found. Return invalid tag indication so it gets stripped.
1666 */
691a2d25 1667 return Array(false, false, false, $lt, strlen($body));
1668}
1669
1670/**
0493ed11 1671 * Translates entities into literal values so they can be checked.
8bd0068d 1672 *
0493ed11 1673 * @param $attvalue the by-ref value to check.
1674 * @param $regex the regular expression to check against.
1675 * @param $hex whether the entites are hexadecimal.
1676 * @return True or False depending on whether there were matches.
8bd0068d 1677 */
0493ed11 1678function sq_deent(&$attvalue, $regex, $hex=false){
b583c3e8 1679 $me = 'sq_deent';
0493ed11 1680 $ret_match = false;
2b665f28 1681 // remove comments
1682 //$attvalue = preg_replace("/(\/\*.*\*\/)/","",$attvalue);
0493ed11 1683 preg_match_all($regex, $attvalue, $matches);
1684 if (is_array($matches) && sizeof($matches[0]) > 0){
1685 $repl = Array();
1686 for ($i = 0; $i < sizeof($matches[0]); $i++){
1687 $numval = $matches[1][$i];
1688 if ($hex){
1689 $numval = hexdec($numval);
a3daaaf3 1690 }
0493ed11 1691 $repl{$matches[0][$i]} = chr($numval);
691a2d25 1692 }
0493ed11 1693 $attvalue = strtr($attvalue, $repl);
1694 return true;
1695 } else {
1696 return false;
691a2d25 1697 }
691a2d25 1698}
1699
1700/**
8bd0068d 1701 * This function runs various checks against the attributes.
1702 *
1703 * @param $tagname String with the name of the tag.
1704 * @param $attary Array with all tag attributes.
1705 * @param $rm_attnames See description for sq_sanitize
1706 * @param $bad_attvals See description for sq_sanitize
1707 * @param $add_attr_to_tag See description for sq_sanitize
1708 * @param $message message object
1709 * @param $id message id
1710 * @return Array with modified attributes.
1711 */
da2415c1 1712function sq_fixatts($tagname,
1713 $attary,
691a2d25 1714 $rm_attnames,
1715 $bad_attvals,
1716 $add_attr_to_tag,
1717 $message,
b3af12ef 1718 $id,
3d8371be 1719 $mailbox
691a2d25 1720 ){
b583c3e8 1721 $me = 'sq_fixatts';
691a2d25 1722 while (list($attname, $attvalue) = each($attary)){
1723 /**
8bd0068d 1724 * See if this attribute should be removed.
1725 */
691a2d25 1726 foreach ($rm_attnames as $matchtag=>$matchattrs){
1727 if (preg_match($matchtag, $tagname)){
1728 foreach ($matchattrs as $matchattr){
1729 if (preg_match($matchattr, $attname)){
1730 unset($attary{$attname});
1731 continue;
1732 }
451f74a2 1733 }
451f74a2 1734 }
691a2d25 1735 }
1736 /**
2b665f28 1737 * Workaround for IE quirks
1738 */
1739 sq_fixIE_idiocy($attvalue);
1740
1741 /**
8bd0068d 1742 * Remove any backslashes, entities, and extraneous whitespace.
1743 */
2b665f28 1744
1745 $oldattvalue = $attvalue;
0493ed11 1746 sq_defang($attvalue);
2b665f28 1747 if ($attname == 'style' && $attvalue !== $oldattvalue) {
1748 // entities are used in the attribute value. In 99% of the cases it's there as XSS
1749 // i.e.<div style="{ left:exp&#x0280;essio&#x0274;( alert('XSS') ) }">
1750 $attvalue = "idiocy";
1751 $attary{$attname} = $attvalue;
1752 }
0493ed11 1753 sq_unspace($attvalue);
af861a34 1754
1755 /**
8bd0068d 1756 * Now let's run checks on the attvalues.
1757 * I don't expect anyone to comprehend this. If you do,
1758 * get in touch with me so I can drive to where you live and
1759 * shake your hand personally. :)
1760 */
691a2d25 1761 foreach ($bad_attvals as $matchtag=>$matchattrs){
1762 if (preg_match($matchtag, $tagname)){
1763 foreach ($matchattrs as $matchattr=>$valary){
1764 if (preg_match($matchattr, $attname)){
1765 /**
8bd0068d 1766 * There are two arrays in valary.
1767 * First is matches.
1768 * Second one is replacements
1769 */
691a2d25 1770 list($valmatch, $valrepl) = $valary;
da2415c1 1771 $newvalue =
691a2d25 1772 preg_replace($valmatch, $valrepl, $attvalue);
1773 if ($newvalue != $attvalue){
1774 $attary{$attname} = $newvalue;
567dc524 1775 $attvalue = $newvalue;
691a2d25 1776 }
1777 }
1778 }
451f74a2 1779 }
a3daaaf3 1780 }
567dc524 1781 if ($attname == 'style') {
1782 if (preg_match('/[\0-\37\200-\377]+/',$attvalue)) {
1783 // 8bit and control characters in style attribute values can be used for XSS, remove them
1784 $attary{$attname} = '"disallowed character"';
1785 }
1786 preg_match_all("/url\s*\((.+)\)/si",$attvalue,$aMatch);
1787 if (count($aMatch)) {
1788 foreach($aMatch[1] as $sMatch) {
1789 // url value
1790 $urlvalue = $sMatch;
1791 sq_fix_url($attname, $urlvalue, $message, $id, $mailbox,"'");
1792 $attary{$attname} = str_replace($sMatch,$urlvalue,$attvalue);
1793 }
1794 }
691a2d25 1795 }
ff940ebc 1796 /**
567dc524 1797 * Use white list based filtering on attributes which can contain url's
ff940ebc 1798 */
567dc524 1799 else if ($attname == 'href' || $attname == 'src' || $attname == 'background') {
1800 sq_fix_url($attname, $attvalue, $message, $id, $mailbox);
1801 $attary{$attname} = $attvalue;
ff940ebc 1802 }
a3daaaf3 1803 }
691a2d25 1804 /**
8bd0068d 1805 * See if we need to append any attributes to this tag.
1806 */
691a2d25 1807 foreach ($add_attr_to_tag as $matchtag=>$addattary){
1808 if (preg_match($matchtag, $tagname)){
1809 $attary = array_merge($attary, $addattary);
1810 }
1811 }
1812 return $attary;
451f74a2 1813}
a3daaaf3 1814
691a2d25 1815/**
567dc524 1816 * This function filters url's
1817 *
1818 * @param $attvalue String with attribute value to filter
1819 * @param $message message object
1820 * @param $id message id
1821 * @param $mailbox mailbox
1822 * @param $sQuote quoting characters around url's
1823 */
1824function sq_fix_url($attname, &$attvalue, $message, $id, $mailbox,$sQuote = '"') {
1825 $attvalue = trim($attvalue);
1826 if ($attvalue && ($attvalue[0] =='"'|| $attvalue[0] == "'")) {
1827 // remove the double quotes
1828 $sQuote = $attvalue[0];
1829 $attvalue = trim(substr($attvalue,1,-1));
1830 }
1831
1832 if( !sqgetGlobalVar('view_unsafe_images', $view_unsafe_images, SQ_GET) ) {
1833 $view_unsafe_images = false;
1834 }
1835 $secremoveimg = '../images/' . _("sec_remove_eng.png");
1836
1837 /**
1838 * Replace empty src tags with the blank image. src is only used
1839 * for frames, images, and image inputs. Doing a replace should
1840 * not affect them working as should be, however it will stop
1841 * IE from being kicked off when src for img tags are not set
1842 */
1843 if ($attvalue == '') {
1844 $attvalue = '"' . SM_PATH . 'images/blank.png"';
1845 } else {
1846 // first, disallow 8 bit characters and control characters
1847 if (preg_match('/[\0-\37\200-\377]+/',$attvalue)) {
1848 switch ($attname) {
1849 case 'href':
1850 $attvalue = $sQuote . 'http://invalid-stuff-detected.example.com' . $sQuote;
1851 break;
1852 default:
1853 $attvalue = $sQuote . SM_PATH . 'images/blank.png'. $sQuote;
1854 break;
1855 }
1856 } else {
1857 $aUrl = parse_url($attvalue);
1858 if (isset($aUrl['scheme'])) {
1859 switch(strtolower($aUrl['scheme'])) {
d75e755b 1860 case 'mailto':
567dc524 1861 case 'http':
1862 case 'https':
1863 case 'ftp':
1864 if ($attname != 'href') {
1865 if ($view_unsafe_images == false) {
1866 $attvalue = $sQuote . $secremoveimg . $sQuote;
1867 } else {
1868 if (isset($aUrl['path'])) {
1869 // validate image extension.
1870 $ext = strtolower(substr($aUrl['path'],strrpos($aUrl['path'],'.')));
1871 if (!in_array($ext,array('.jpeg','.jpg','xjpeg','.gif','.bmp','.jpe','.png','.xbm'))) {
1872 $attvalue = $sQuote . SM_PATH . 'images/blank.png'. $sQuote;
1873 }
1874 } else {
1875 $attvalue = $sQuote . SM_PATH . 'images/blank.png'. $sQuote;
1876 }
1877 }
1878 }
1879 break;
1880 case 'outbind':
1881 /**
1882 * "Hack" fix for Outlook using propriatary outbind:// protocol in img tags.
1883 * One day MS might actually make it match something useful, for now, falling
1884 * back to using cid2http, so we can grab the blank.png.
1885 */
1886 $attvalue = sq_cid2http($message, $id, $attvalue, $mailbox);
1887 break;
1888 case 'cid':
1889 /**
1890 * Turn cid: urls into http-friendly ones.
1891 */
1892 $attvalue = sq_cid2http($message, $id, $attvalue, $mailbox);
1893 break;
1894 default:
1895 $attvalue = $sQuote . SM_PATH . 'images/blank.png' . $sQuote;
1896 break;
1897 }
1898 } else {
1899 if (!(isset($aUrl['path']) && $aUrl['path'] == $secremoveimg)) {
1900 // parse_url did not lead to satisfying result
1901 $attvalue = $sQuote . SM_PATH . 'images/blank.png' . $sQuote;
1902 }
1903 }
1904 }
1905 }
1906}
1907
1908/**
8bd0068d 1909 * This function edits the style definition to make them friendly and
1910 * usable in SquirrelMail.
1911 *
1912 * @param $message the message object
1913 * @param $id the message id
1914 * @param $content a string with whatever is between <style> and </style>
1915 * @param $mailbox the message mailbox
1916 * @return a string with edited content.
1917 */
e60a299a 1918function sq_fixstyle($body, $pos, $message, $id, $mailbox){
b583c3e8 1919 $me = 'sq_fixstyle';
7e2ff844 1920 // workaround for </style> in between comments
1921 $iCurrentPos = $pos;
1922 $content = '';
1923 $sToken = '';
1924 $bSucces = false;
1925 $bEndTag = false;
1926 for ($i=$pos,$iCount=strlen($body);$i<$iCount;++$i) {
1927 $char = $body{$i};
1928 switch ($char) {
1929 case '<':
10c0caeb 1930 $sToken = $char;
7e2ff844 1931 break;
1932 case '/':
1933 if ($sToken == '<') {
1934 $sToken .= $char;
1935 $bEndTag = true;
1936 } else {
1937 $content .= $char;
1938 }
1939 break;
1940 case '>':
1941 if ($bEndTag) {
1942 $sToken .= $char;
1943 if (preg_match('/\<\/\s*style\s*\>/i',$sToken,$aMatch)) {
1944 $newpos = $i + 1;
1945 $bSucces = true;
1946 break 2;
1947 } else {
1948 $content .= $sToken;
1949 }
1950 $bEndTag = false;
1951 } else {
1952 $content .= $char;
1953 }
1954 break;
1955 case '!':
1956 if ($sToken == '<') {
1957 // possible comment
1958 if (isset($body{$i+2}) && substr($body,$i,3) == '!--') {
1959 $i = strpos($body,'-->',$i+3);
2b665f28 1960 if ($i === false) { // no end comment
1961 $i = strlen($body);
1962 }
7e2ff844 1963 $sToken = '';
1964 }
1965 } else {
1966 $content .= $char;
1967 }
1968 break;
1969 default:
1970 if ($bEndTag) {
1971 $sToken .= $char;
1972 } else {
1973 $content .= $char;
1974 }
1975 break;
1976 }
1977 }
1978 if ($bSucces == FALSE){
7d06541f 1979 return array(FALSE, strlen($body));
1980 }
7e2ff844 1981
2b665f28 1982
1983
691a2d25 1984 /**
0493ed11 1985 * First look for general BODY style declaration, which would be
1986 * like so:
1987 * body {background: blah-blah}
1988 * and change it to .bodyclass so we can just assign it to a <div>
1989 */
691a2d25 1990 $content = preg_replace("|body(\s*\{.*?\})|si", ".bodyclass\\1", $content);
3d8371be 1991 $secremoveimg = '../images/' . _("sec_remove_eng.png");
691a2d25 1992 /**
0493ed11 1993 * Fix url('blah') declarations.
1994 */
1995 // $content = preg_replace("|url\s*\(\s*([\'\"])\s*\S+script\s*:.*?([\'\"])\s*\)|si",
1996 // "url(\\1$secremoveimg\\2)", $content);
2b665f28 1997
567dc524 1998 // first check for 8bit sequences and disallowed control characters
1999 if (preg_match('/[\16-\37\200-\377]+/',$content)) {
2000 $content = '<!-- style block removed by html filter due to presence of 8bit characters -->';
2001 return array($content, $newpos);
2002 }
2003
2b665f28 2004 // IE Sucks hard. We have a special function for it.
2005 sq_fixIE_idiocy($content);
2006
2007 // remove @import line
2008 $content = preg_replace("/^\s*(@import.*)$/mi","\n<!-- @import rules forbidden -->\n",$content);
2009
5b4884be 2010 // translate ur\l and variations (IE parses that)
2b665f28 2011 // TODO check if the sq_fixIE_idiocy function already handles this.
5b4884be 2012 $content = preg_replace("/(\\\\)?u(\\\\)?r(\\\\)?l(\\\\)?/i", 'url', $content);
567dc524 2013 preg_match_all("/url\s*\((.+)\)/si",$content,$aMatch);
2014 if (count($aMatch)) {
2015 $aValue = $aReplace = array();
2016 foreach($aMatch[1] as $sMatch) {
2017 // url value
2018 $urlvalue = $sMatch;
2019 sq_fix_url('style',$urlvalue, $message, $id, $mailbox,"'");
2020 $aValue[] = $sMatch;
2021 $aReplace[] = $urlvalue;
0493ed11 2022 }
567dc524 2023 $content = str_replace($aValue,$aReplace,$content);
691a2d25 2024 }
567dc524 2025
0493ed11 2026 /**
2027 * Remove any backslashes, entities, and extraneous whitespace.
2028 */
2029 $contentTemp = $content;
2030 sq_defang($contentTemp);
2031 sq_unspace($contentTemp);
a3daaaf3 2032
691a2d25 2033 /**
8bd0068d 2034 * Fix stupid css declarations which lead to vulnerabilities
2035 * in IE.
2036 */
5db90261 2037 $match = Array('/\/\*.*\*\//',
2038 '/expression/i',
0493ed11 2039 '/behaviou*r/i',
2040 '/binding/i',
2b665f28 2041 '/include-source/i',
2042 '/javascript/i',
2043 '/script/i');
2044 $replace = Array('','idiocy', 'idiocy', 'idiocy', 'idiocy', 'idiocy', 'idiocy');
0493ed11 2045 $contentNew = preg_replace($match, $replace, $contentTemp);
2046 if ($contentNew !== $contentTemp) {
2047 // insecure css declarations are used. From now on we don't care
2048 // anymore if the css is destroyed by sq_deent, sq_unspace or sq_unbackslash
2049 $content = $contentNew;
2050 }
7d06541f 2051 return array($content, $newpos);
691a2d25 2052}
a3daaaf3 2053
0493ed11 2054
691a2d25 2055/**
8bd0068d 2056 * This function converts cid: url's into the ones that can be viewed in
2057 * the browser.
2058 *
2059 * @param $message the message object
2060 * @param $id the message id
2061 * @param $cidurl the cid: url.
2062 * @param $mailbox the message mailbox
2063 * @return a string with a http-friendly url
2064 */
b3af12ef 2065function sq_cid2http($message, $id, $cidurl, $mailbox){
691a2d25 2066 /**
8bd0068d 2067 * Get rid of quotes.
2068 */
691a2d25 2069 $quotchar = substr($cidurl, 0, 1);
2dd879b8 2070 if ($quotchar == '"' || $quotchar == "'"){
2071 $cidurl = str_replace($quotchar, "", $cidurl);
2072 } else {
2073 $quotchar = '';
2074 }
691a2d25 2075 $cidurl = substr(trim($cidurl), 4);
0493ed11 2076
2077 $match_str = '/\{.*?\}\//';
2078 $str_rep = '';
2079 $cidurl = preg_replace($match_str, $str_rep, $cidurl);
2080
e5e9381a 2081 $linkurl = find_ent_id($cidurl, $message);
2082 /* in case of non-save cid links $httpurl should be replaced by a sort of
8bd0068d 2083 unsave link image */
e5e9381a 2084 $httpurl = '';
c8f5f606 2085
8bd0068d 2086 /**
2087 * This is part of a fix for Outlook Express 6.x generating
2088 * cid URLs without creating content-id headers. These images are
2089 * not part of the multipart/related html mail. The html contains
2090 * <img src="cid:{some_id}/image_filename.ext"> references to
2091 * attached images with as goal to render them inline although
2092 * the attachment disposition property is not inline.
2093 */
c8f5f606 2094
2095 if (empty($linkurl)) {
2096 if (preg_match('/{.*}\//', $cidurl)) {
2097 $cidurl = preg_replace('/{.*}\//','', $cidurl);
2098 if (!empty($cidurl)) {
2099 $linkurl = find_ent_id($cidurl, $message);
2100 }
2101 }
2102 }
f8a1ed5a 2103
c8f5f606 2104 if (!empty($linkurl)) {
6b04287c 2105 $httpurl = $quotchar . SM_PATH . 'src/download.php?absolute_dl=true&amp;' .
8bd0068d 2106 "passed_id=$id&amp;mailbox=" . urlencode($mailbox) .
2107 '&amp;ent_id=' . $linkurl . $quotchar;
c8f5f606 2108 } else {
2109 /**
2110 * If we couldn't generate a proper img url, drop in a blank image
2111 * instead of sending back empty, otherwise it causes unusual behaviour
2112 */
bc017c1d 2113 $httpurl = $quotchar . SM_PATH . 'images/blank.png' . $quotchar;
e5e9381a 2114 }
f8a1ed5a 2115
691a2d25 2116 return $httpurl;
2117}
2118
2119/**
8bd0068d 2120 * This function changes the <body> tag into a <div> tag since we
2121 * can't really have a body-within-body.
2122 *
2123 * @param $attary an array of attributes and values of <body>
2124 * @param $mailbox mailbox we're currently reading (for cid2http)
2125 * @param $message current message (for cid2http)
2126 * @param $id current message id (for cid2http)
2127 * @return a modified array of attributes to be set for <div>
2128 */
2dd879b8 2129function sq_body2div($attary, $mailbox, $message, $id){
b583c3e8 2130 $me = 'sq_body2div';
3d8371be 2131 $divattary = Array('class' => "'bodyclass'");
b583c3e8 2132 $text = '#000000';
c189a963 2133 $has_bgc_stl = $has_txt_stl = false;
b583c3e8 2134 $styledef = '';
691a2d25 2135 if (is_array($attary) && sizeof($attary) > 0){
2136 foreach ($attary as $attname=>$attvalue){
2137 $quotchar = substr($attvalue, 0, 1);
2138 $attvalue = str_replace($quotchar, "", $attvalue);
2139 switch ($attname){
3d8371be 2140 case 'background':
8bd0068d 2141 $attvalue = sq_cid2http($message, $id, $attvalue, $mailbox);
3d8371be 2142 $styledef .= "background-image: url('$attvalue'); ";
2143 break;
2144 case 'bgcolor':
c189a963 2145 $has_bgc_stl = true;
3d8371be 2146 $styledef .= "background-color: $attvalue; ";
2147 break;
2148 case 'text':
c189a963 2149 $has_txt_stl = true;
3d8371be 2150 $styledef .= "color: $attvalue; ";
2151 break;
691a2d25 2152 }
a3daaaf3 2153 }
c189a963 2154 // Outlook defines a white bgcolor and no text color. This can lead to
2155 // white text on a white bg with certain themes.
2156 if ($has_bgc_stl && !$has_txt_stl) {
2157 $styledef .= "color: $text; ";
2158 }
691a2d25 2159 if (strlen($styledef) > 0){
2160 $divattary{"style"} = "\"$styledef\"";
2161 }
2162 }
2163 return $divattary;
2164}
a3daaaf3 2165
691a2d25 2166/**
8bd0068d 2167 * This is the main function and the one you should actually be calling.
2168 * There are several variables you should be aware of an which need
2169 * special description.
2170 *
2171 * Since the description is quite lengthy, see it here:
2172 * http://linux.duke.edu/projects/mini/htmlfilter/
2173 *
2174 * @param $body the string with HTML you wish to filter
2175 * @param $tag_list see description above
2176 * @param $rm_tags_with_content see description above
2177 * @param $self_closing_tags see description above
2178 * @param $force_tag_closing see description above
2179 * @param $rm_attnames see description above
2180 * @param $bad_attvals see description above
2181 * @param $add_attr_to_tag see description above
2182 * @param $message message object
2183 * @param $id message id
2184 * @return sanitized html safe to show on your pages.
2185 */
da2415c1 2186function sq_sanitize($body,
8bd0068d 2187 $tag_list,
2188 $rm_tags_with_content,
2189 $self_closing_tags,
2190 $force_tag_closing,
2191 $rm_attnames,
2192 $bad_attvals,
2193 $add_attr_to_tag,
2194 $message,
2195 $id,
2196 $mailbox
2197 ){
b583c3e8 2198 $me = 'sq_sanitize';
7d06541f 2199 $rm_tags = array_shift($tag_list);
691a2d25 2200 /**
8bd0068d 2201 * Normalize rm_tags and rm_tags_with_content.
2202 */
7d06541f 2203 @array_walk($tag_list, 'sq_casenormalize');
691a2d25 2204 @array_walk($rm_tags_with_content, 'sq_casenormalize');
2205 @array_walk($self_closing_tags, 'sq_casenormalize');
2206 /**
8bd0068d 2207 * See if tag_list is of tags to remove or tags to allow.
2208 * false means remove these tags
2209 * true means allow these tags
2210 */
691a2d25 2211 $curpos = 0;
2212 $open_tags = Array();
2dd879b8 2213 $trusted = "\n<!-- begin sanitized html -->\n";
691a2d25 2214 $skip_content = false;
bb8d0799 2215 /**
8bd0068d 2216 * Take care of netscape's stupid javascript entities like
2217 * &{alert('boo')};
2218 */
bb8d0799 2219 $body = preg_replace("/&(\{.*?\};)/si", "&amp;\\1", $body);
691a2d25 2220
7d06541f 2221 while (($curtag = sq_getnxtag($body, $curpos)) != FALSE){
691a2d25 2222 list($tagname, $attary, $tagtype, $lt, $gt) = $curtag;
2223 $free_content = substr($body, $curpos, $lt-$curpos);
2224 /**
8bd0068d 2225 * Take care of <style>
2226 */
7d06541f 2227 if ($tagname == "style" && $tagtype == 1){
da2415c1 2228 list($free_content, $curpos) =
e60a299a 2229 sq_fixstyle($body, $gt+1, $message, $id, $mailbox);
7d06541f 2230 if ($free_content != FALSE){
2231 $trusted .= sq_tagprint($tagname, $attary, $tagtype);
2232 $trusted .= $free_content;
2233 $trusted .= sq_tagprint($tagname, false, 2);
2234 }
2235 continue;
691a2d25 2236 }
2237 if ($skip_content == false){
2238 $trusted .= $free_content;
691a2d25 2239 }
2240 if ($tagname != FALSE){
2241 if ($tagtype == 2){
2242 if ($skip_content == $tagname){
2243 /**
8bd0068d 2244 * Got to the end of tag we needed to remove.
2245 */
691a2d25 2246 $tagname = false;
2247 $skip_content = false;
2248 } else {
2249 if ($skip_content == false){
c828931c 2250 if ($tagname == "body"){
2251 $tagname = "div";
2dd879b8 2252 }
da2415c1 2253 if (isset($open_tags{$tagname}) &&
8bd0068d 2254 $open_tags{$tagname} > 0){
2dd879b8 2255 $open_tags{$tagname}--;
691a2d25 2256 } else {
2dd879b8 2257 $tagname = false;
691a2d25 2258 }
691a2d25 2259 }
2260 }
2261 } else {
2262 /**
8bd0068d 2263 * $rm_tags_with_content
2264 */
691a2d25 2265 if ($skip_content == false){
2266 /**
8bd0068d 2267 * See if this is a self-closing type and change
2268 * tagtype appropriately.
2269 */
691a2d25 2270 if ($tagtype == 1
8bd0068d 2271 && in_array($tagname, $self_closing_tags)){
2dd879b8 2272 $tagtype = 3;
691a2d25 2273 }
2274 /**
8bd0068d 2275 * See if we should skip this tag and any content
2276 * inside it.
2277 */
691a2d25 2278 if ($tagtype == 1 &&
8bd0068d 2279 in_array($tagname, $rm_tags_with_content)){
691a2d25 2280 $skip_content = $tagname;
2281 } else {
da2415c1 2282 if (($rm_tags == false
8bd0068d 2283 && in_array($tagname, $tag_list)) ||
2284 ($rm_tags == true &&
2285 !in_array($tagname, $tag_list))){
691a2d25 2286 $tagname = false;
2287 } else {
2dd879b8 2288 /**
8bd0068d 2289 * Convert body into div.
2290 */
2dd879b8 2291 if ($tagname == "body"){
2292 $tagname = "div";
da2415c1 2293 $attary = sq_body2div($attary, $mailbox,
8bd0068d 2294 $message, $id);
2dd879b8 2295 }
691a2d25 2296 if ($tagtype == 1){
2297 if (isset($open_tags{$tagname})){
2298 $open_tags{$tagname}++;
2299 } else {
2300 $open_tags{$tagname}=1;
2301 }
2302 }
2303 /**
8bd0068d 2304 * This is where we run other checks.
2305 */
691a2d25 2306 if (is_array($attary) && sizeof($attary) > 0){
2307 $attary = sq_fixatts($tagname,
8bd0068d 2308 $attary,
2309 $rm_attnames,
2310 $bad_attvals,
2311 $add_attr_to_tag,
2312 $message,
2313 $id,
2314 $mailbox
2315 );
691a2d25 2316 }
2317 }
2318 }
691a2d25 2319 }
2320 }
2321 if ($tagname != false && $skip_content == false){
2322 $trusted .= sq_tagprint($tagname, $attary, $tagtype);
2323 }
691a2d25 2324 }
2325 $curpos = $gt+1;
a3daaaf3 2326 }
691a2d25 2327 $trusted .= substr($body, $curpos, strlen($body)-$curpos);
2328 if ($force_tag_closing == true){
2329 foreach ($open_tags as $tagname=>$opentimes){
2330 while ($opentimes > 0){
2331 $trusted .= '</' . $tagname . '>';
2332 $opentimes--;
2333 }
2334 }
2335 $trusted .= "\n";
2336 }
2337 $trusted .= "<!-- end sanitized html -->\n";
2338 return $trusted;
2339}
451f74a2 2340
691a2d25 2341/**
8bd0068d 2342 * This is a wrapper function to call html sanitizing routines.
2343 *
2344 * @param $body the body of the message
2345 * @param $id the id of the message
c189a963 2346
2347 * @param $message
2348 * @param $mailbox
2349 * @param boolean $take_mailto_links When TRUE, converts mailto: links
2350 * into internal SM compose links
2351 * (optional; default = TRUE)
8bd0068d 2352 * @return a string with html safe to display in the browser.
2353 */
c189a963 2354function magicHTML($body, $id, $message, $mailbox = 'INBOX', $take_mailto_links =true) {
2355
202bcbcc 2356 // require_once(SM_PATH . 'functions/url_parser.php'); // for $MailTo_PReg_Match
c189a963 2357
691a2d25 2358 global $attachment_common_show_images, $view_unsafe_images,
8bd0068d 2359 $has_unsafe_images;
691a2d25 2360 /**
8bd0068d 2361 * Don't display attached images in HTML mode.
2b665f28 2362 *
d0187bd6 2363 * SB: why?
8bd0068d 2364 */
691a2d25 2365 $attachment_common_show_images = false;
2366 $tag_list = Array(
8bd0068d 2367 false,
2368 "object",
2369 "meta",
2370 "html",
2371 "head",
2372 "base",
2373 "link",
2374 "frame",
2375 "iframe",
2376 "plaintext",
2377 "marquee"
2378 );
691a2d25 2379
2380 $rm_tags_with_content = Array(
8bd0068d 2381 "script",
2382 "applet",
2383 "embed",
2384 "title",
2385 "frameset",
0493ed11 2386 "xmp",
8bd0068d 2387 "xml"
2388 );
691a2d25 2389
2390 $self_closing_tags = Array(
8bd0068d 2391 "img",
2392 "br",
2393 "hr",
2394 "input",
2395 "outbind"
2396 );
691a2d25 2397
2dd879b8 2398 $force_tag_closing = true;
691a2d25 2399
2400 $rm_attnames = Array(
8bd0068d 2401 "/.*/" =>
2402 Array(
2403 "/target/i",
2404 "/^on.*/i",
2405 "/^dynsrc/i",
2406 "/^data.*/i",
2407 "/^lowsrc.*/i"
2408 )
2409 );
691a2d25 2410
2411 $secremoveimg = "../images/" . _("sec_remove_eng.png");
2412 $bad_attvals = Array(
8bd0068d 2413 "/.*/" =>
691a2d25 2414 Array(
0a6ec9b5 2415 "/^src|background/i" =>
8bd0068d 2416 Array(
691a2d25 2417 Array(
8bd0068d 2418 "/^([\'\"])\s*\S+script\s*:.*([\'\"])/si",
2419 "/^([\'\"])\s*mocha\s*:*.*([\'\"])/si",
2420 "/^([\'\"])\s*about\s*:.*([\'\"])/si"
691a2d25 2421 ),
8bd0068d 2422 Array(
2423 "\\1$secremoveimg\\2",
2424 "\\1$secremoveimg\\2",
2425 "\\1$secremoveimg\\2",
8bd0068d 2426 )
2427 ),
0a6ec9b5 2428 "/^href|action/i" =>
8bd0068d 2429 Array(
0a6ec9b5 2430 Array(
8bd0068d 2431 "/^([\'\"])\s*\S+script\s*:.*([\'\"])/si",
2432 "/^([\'\"])\s*mocha\s*:*.*([\'\"])/si",
2433 "/^([\'\"])\s*about\s*:.*([\'\"])/si"
0a6ec9b5 2434 ),
691a2d25 2435 Array(
8bd0068d 2436 "\\1#\\1",
2437 "\\1#\\1",
8bd0068d 2438 "\\1#\\1"
02474e43 2439 )
8bd0068d 2440 ),
2441 "/^style/i" =>
2442 Array(
2443 Array(
5db90261 2444 "/\/\*.*\*\//",
8bd0068d 2445 "/expression/i",
2446 "/binding/i",
2447 "/behaviou*r/i",
2448 "/include-source/i",
2449 "/position\s*:\s*absolute/i",
1d935bc2 2450 "/(\\\\)?u(\\\\)?r(\\\\)?l(\\\\)?/i",
8bd0068d 2451 "/url\s*\(\s*([\'\"])\s*\S+script\s*:.*([\'\"])\s*\)/si",
2452 "/url\s*\(\s*([\'\"])\s*mocha\s*:.*([\'\"])\s*\)/si",
2453 "/url\s*\(\s*([\'\"])\s*about\s*:.*([\'\"])\s*\)/si",
2454 "/(.*)\s*:\s*url\s*\(\s*([\'\"]*)\s*\S+script\s*:.*([\'\"]*)\s*\)/si"
2455 ),
2456 Array(
5db90261 2457 "",
8bd0068d 2458 "idiocy",
2459 "idiocy",
2460 "idiocy",
2461 "idiocy",
567dc524 2462 "idiocy",
5b4884be 2463 "url",
8bd0068d 2464 "url(\\1#\\1)",
2465 "url(\\1#\\1)",
2466 "url(\\1#\\1)",
8bd0068d 2467 "\\1:url(\\2#\\3)"
2468 )
691a2d25 2469 )
8bd0068d 2470 )
691a2d25 2471 );
5262d9a6 2472 if( !sqgetGlobalVar('view_unsafe_images', $view_unsafe_images, SQ_GET) ) {
2dd879b8 2473 $view_unsafe_images = false;
45071bd6 2474 }
691a2d25 2475 if (!$view_unsafe_images){
2476 /**
8bd0068d 2477 * Remove any references to http/https if view_unsafe_images set
2478 * to false.
2479 */
02474e43 2480 array_push($bad_attvals{'/.*/'}{'/^src|background/i'}[0],
8bd0068d 2481 '/^([\'\"])\s*https*:.*([\'\"])/si');
02474e43 2482 array_push($bad_attvals{'/.*/'}{'/^src|background/i'}[1],
8bd0068d 2483 "\\1$secremoveimg\\1");
02474e43 2484 array_push($bad_attvals{'/.*/'}{'/^style/i'}[0],
7ef0b415 2485 '/url\([\'\"]?https?:[^\)]*[\'\"]?\)/si');
02474e43 2486 array_push($bad_attvals{'/.*/'}{'/^style/i'}[1],
8bd0068d 2487 "url(\\1$secremoveimg\\1)");
691a2d25 2488 }
451f74a2 2489
691a2d25 2490 $add_attr_to_tag = Array(
8bd0068d 2491 "/^a$/i" =>
c25f2fbb 2492 Array('target'=>'"_blank"',
02474e43 2493 'title'=>'"'._("This external link will open in a new window").'"'
8bd0068d 2494 )
2495 );
da2415c1 2496 $trusted = sq_sanitize($body,
8bd0068d 2497 $tag_list,
2498 $rm_tags_with_content,
2499 $self_closing_tags,
2500 $force_tag_closing,
2501 $rm_attnames,
2502 $bad_attvals,
2503 $add_attr_to_tag,
2504 $message,
2505 $id,
2506 $mailbox
2507 );
567dc524 2508 if (strpos($trusted,$secremoveimg)){
691a2d25 2509 $has_unsafe_images = true;
da2415c1 2510 }
c189a963 2511
2512 // we want to parse mailto's in HTML output, change to SM compose links
2513 // this is a modified version of code from url_parser.php... but Marc is
2514 // right: we need a better filtering implementation; adding this randomly
2515 // here is not a great solution
2516 //
2517 if ($take_mailto_links) {
2518 // parseUrl($trusted); // this even parses URLs inside of tags... too aggressive
2519 global $MailTo_PReg_Match;
202bcbcc 2520 $MailTo_PReg_Match = '/mailto:' . substr($MailTo_PReg_Match, 1) ;
c189a963 2521 if ((preg_match_all($MailTo_PReg_Match, $trusted, $regs)) && ($regs[0][0] != '')) {
2522 foreach ($regs[0] as $i => $mailto_before) {
2523 $mailto_params = $regs[10][$i];
2524 // get rid of any tailing quote since we have to add send_to to the end
2525 //
2526 if (substr($mailto_before, strlen($mailto_before) - 1) == '"')
2527 $mailto_before = substr($mailto_before, 0, strlen($mailto_before) - 1);
2528 if (substr($mailto_params, strlen($mailto_params) - 1) == '"')
2529 $mailto_params = substr($mailto_params, 0, strlen($mailto_params) - 1);
2530
2531 if ($regs[1][$i]) { //if there is an email addr before '?', we need to merge it with the params
2532 $to = 'to=' . $regs[1][$i];
2533 if (strpos($mailto_params, 'to=') > -1) //already a 'to='
2534 $mailto_params = str_replace('to=', $to . '%2C%20', $mailto_params);
2535 else {
2536 if ($mailto_params) //already some params, append to them
2537 $mailto_params .= '&amp;' . $to;
2538 else
2539 $mailto_params .= '?' . $to;
2540 }
2541 }
2542
2543 $url_str = preg_replace(array('/to=/i', '/(?<!b)cc=/i', '/bcc=/i'), array('send_to=', 'send_to_cc=', 'send_to_bcc='), $mailto_params);
2544
2545 // we'll already have target=_blank, no need to allow comp_in_new
2546 // here (which would be a lot more work anyway)
2547 //
2548 global $compose_new_win;
2549 $temp_comp_in_new = $compose_new_win;
2550 $compose_new_win = 0;
2551 $comp_uri = makeComposeLink('src/compose.php' . $url_str, $mailto_before);
2552 $compose_new_win = $temp_comp_in_new;
2553
2554 // remove <a href=" and anything after the next quote (we only
2555 // need the uri, not the link HTML) in compose uri
2556 //
2557 $comp_uri = substr($comp_uri, 9);
2558 $comp_uri = substr($comp_uri, 0, strpos($comp_uri, '"', 1));
2559 $trusted = str_replace($mailto_before, $comp_uri, $trusted);
2560 }
2561 }
2562 }
2563
691a2d25 2564 return $trusted;
451f74a2 2565}
a4a70693 2566
da2415c1 2567/**
8bd0068d 2568 * function SendDownloadHeaders - send file to the browser
2569 *
2570 * Original Source: SM core src/download.php
2571 * moved here to make it available to other code, and separate
2572 * front end from back end functionality.
2573 *
2574 * @param string $type0 first half of mime type
2575 * @param string $type1 second half of mime type
2576 * @param string $filename filename to tell the browser for downloaded file
2577 * @param boolean $force whether to force the download dialog to pop
2578 * @param optional integer $filesize send the Content-Header and length to the browser
2579 * @return void
2580 */
02474e43 2581function SendDownloadHeaders($type0, $type1, $filename, $force, $filesize=0) {
2582 global $languages, $squirrelmail_language;
cfffd60b 2583 $isIE = $isIE6plus = false;
02474e43 2584
2585 sqgetGlobalVar('HTTP_USER_AGENT', $HTTP_USER_AGENT, SQ_SERVER);
2586
2587 if (strstr($HTTP_USER_AGENT, 'compatible; MSIE ') !== false &&
8bd0068d 2588 strstr($HTTP_USER_AGENT, 'Opera') === false) {
cfffd60b 2589 $isIE = true;
02474e43 2590 }
2591
cfffd60b 2592 if (preg_match('/compatible; MSIE ([0-9]+)/', $HTTP_USER_AGENT, $match) &&
2593 ((int)$match[1]) >= 6 && strstr($HTTP_USER_AGENT, 'Opera') === false) {
2594 $isIE6plus = true;
02474e43 2595 }
2596
2597 if (isset($languages[$squirrelmail_language]['XTRA_CODE']) &&
8bd0068d 2598 function_exists($languages[$squirrelmail_language]['XTRA_CODE'] . '_downloadfilename')) {
02474e43 2599 $filename =
8bd0068d 2600 call_user_func($languages[$squirrelmail_language]['XTRA_CODE'] . '_downloadfilename', $filename, $HTTP_USER_AGENT);
02474e43 2601 } else {
2602 $filename = ereg_replace('[\\/:\*\?"<>\|;]', '_', str_replace('&nbsp;', ' ', $filename));
2603 }
2604
2605 // A Pox on Microsoft and it's Internet Explorer!
2606 //
2607 // IE has lots of bugs with file downloads.
2608 // It also has problems with SSL. Both of these cause problems
2609 // for us in this function.
2610 //
2611 // See this article on Cache Control headers and SSL
2612 // http://support.microsoft.com/default.aspx?scid=kb;en-us;323308
2613 //
2614 // The best thing you can do for IE is to upgrade to the latest
2615 // version
2616 //set all the Cache Control Headers for IE
2617 if ($isIE) {
2618 $filename=rawurlencode($filename);
2619 header ("Pragma: public");
8bd0068d 2620 header ("Cache-Control: no-store, max-age=0, no-cache, must-revalidate"); // HTTP/1.1
02474e43 2621 header ("Cache-Control: post-check=0, pre-check=0", false);
8bd0068d 2622 header ("Cache-Control: private");
02474e43 2623
2624 //set the inline header for IE, we'll add the attachment header later if we need it
2625 header ("Content-Disposition: inline; filename=$filename");
2626 }
2627
2628 if (!$force) {
2629 // Try to show in browser window
2630 header ("Content-Disposition: inline; filename=\"$filename\"");
2631 header ("Content-Type: $type0/$type1; name=\"$filename\"");
2632 } else {
2633 // Try to pop up the "save as" box
2634
2635 // IE makes this hard. It pops up 2 save boxes, or none.
2636 // http://support.microsoft.com/support/kb/articles/Q238/5/88.ASP
2637 // http://support.microsoft.com/default.aspx?scid=kb;EN-US;260519
2638 // But, according to Microsoft, it is "RFC compliant but doesn't
2639 // take into account some deviations that allowed within the
2640 // specification." Doesn't that mean RFC non-compliant?
2641 // http://support.microsoft.com/support/kb/articles/Q258/4/52.ASP
2642
2643 // all browsers need the application/octet-stream header for this
2644 header ("Content-Type: application/octet-stream; name=\"$filename\"");
2645
2646 // http://support.microsoft.com/support/kb/articles/Q182/3/15.asp
2647 // Do not have quotes around filename, but that applied to
2648 // "attachment"... does it apply to inline too?
2649 header ("Content-Disposition: attachment; filename=\"$filename\"");
2650
cfffd60b 2651 if ($isIE && !$isIE6plus) {
02474e43 2652 // This combination seems to work mostly. IE 5.5 SP 1 has
2653 // known issues (see the Microsoft Knowledge Base)
2654
2655 // This works for most types, but doesn't work with Word files
2656 header ("Content-Type: application/download; name=\"$filename\"");
7e2ff844 2657 header ("Content-Type: application/force-download; name=\"$filename\"");
02474e43 2658 // These are spares, just in case. :-)
2659 //header("Content-Type: $type0/$type1; name=\"$filename\"");
2660 //header("Content-Type: application/x-msdownload; name=\"$filename\"");
2661 //header("Content-Type: application/octet-stream; name=\"$filename\"");
7e2ff844 2662 } else if ($isIE) {
2663 // This is to prevent IE for MIME sniffing and auto open a file in IE
2664 header ("Content-Type: application/force-download; name=\"$filename\"");
02474e43 2665 } else {
2666 // another application/octet-stream forces download for Netscape
2667 header ("Content-Type: application/octet-stream; name=\"$filename\"");
2668 }
2669 }
2670
2671 //send the content-length header if the calling function provides it
2672 if ($filesize > 0) {
2673 header("Content-Length: $filesize");
2674 }
07c49f57 2675
8d863f64 2676} // end fn SendDownloadHeaders