functions/imap_messages.php

   1 <?php
   2
   3 /**
   4  * imap_messages.php
   5  *
   6  * This implements functions that manipulate messages
   7  * NOTE: Quite a few functions in this file are obsolete
   8  *
   9  * @copyright &copy; 1999-2007 The SquirrelMail Project Team
  10  * @license http://opensource.org/licenses/gpl-license.php GNU Public License
  11  * @version $Id$
  12  * @package squirrelmail
  13  * @subpackage imap
  14  */
  15
  16
  17 /**
  18  * Copy a set of messages ($id) to another mailbox ($mailbox)
  19  * @param int $imap_stream The resource ID for the IMAP socket
  20  * @param string $id The list of messages to copy
  21  * @param string $mailbox The destination to copy to
  22  * @param bool $handle_errors Show error messages in case of a NO, BAD or BYE response
  23  * @return bool If the copy completed without errors
  24  */
  25 function sqimap_msgs_list_copy($imap_stream, $id, $mailbox, $handle_errors = true) {
  26     $msgs_id = sqimap_message_list_squisher($id);
  27     $read = sqimap_run_command ($imap_stream, "COPY $msgs_id " . sqimap_encode_mailbox_name($mailbox), $handle_errors, $response, $message, TRUE);
  28     if ($response == 'OK') {
  29         return true;
  30     } else {
  31         return false;
  32     }
  33 }
  34
  35
  36 /**
  37  * Move a set of messages ($id) to another mailbox. Deletes the originals.
  38  * @param int $imap_stream The resource ID for the IMAP socket
  39  * @param string $id The list of messages to move
  40  * @param string $mailbox The destination to move to
  41  * @param bool $handle_errors Show error messages in case of a NO, BAD or BYE response
  42  * @param string $source_mailbox (since 1.5.1) name of source mailbox. It is used to
  43  *  validate that target mailbox != source mailbox.
  44  * @return bool If the move completed without errors
  45  */
  46 function sqimap_msgs_list_move($imap_stream, $id, $mailbox, $handle_errors = true, $source_mailbox = false) {
  47     if ($source_mailbox!==false && $source_mailbox==$mailbox) {
  48         return false;
  49     }
  50     $msgs_id = sqimap_message_list_squisher($id);
  51     if (sqimap_msgs_list_copy ($imap_stream, $id, $mailbox, $handle_errors)) {
  52         return sqimap_toggle_flag($imap_stream, $id, '\\Deleted', true, true);
  53     } else {
  54         return false;
  55     }
  56 }
  57
  58
  59 /**
  60  * Deletes a message and move it to trash or expunge the mailbox
  61  * @param  resource imap connection
  62  * @param  string $mailbox mailbox, used for checking if it concerns the trash_folder
  63  * @param  array $id list with uid's
  64  * @param  bool   $bypass_trash (since 1.5.0) skip copy to trash
  65  * @return array  $aMessageList array with messages containing the new flags and UID @see parseFetch
  66  * @since 1.4.0
  67  */
  68 function sqimap_msgs_list_delete($imap_stream, $mailbox, $id, $bypass_trash=false) {
  69     // FIX ME, remove globals by introducing an associative array with properties
  70     // as 4th argument as replacement for the bypass_trash var
  71     global $move_to_trash, $trash_folder;
  72     if (($move_to_trash == true) && ($bypass_trash != true) &&
  73         (sqimap_mailbox_exists($imap_stream, $trash_folder) &&  ($mailbox != $trash_folder)) ) {
  74         /**
  75          * turn off internal error handling (fourth argument = false) and
  76          * ignore copy to trash errors (allows to delete messages when overquota)
  77          */
  78         sqimap_msgs_list_copy ($imap_stream, $id, $trash_folder, false);
  79     }
  80     return sqimap_toggle_flag($imap_stream, $id, '\\Deleted', true, true);
  81 }
  82
  83
  84 /**
  85  * Set a flag on the provided uid list
  86  * @param  resource imap connection
  87  * @param  array $id list with uid's
  88  * @param  string $flag Flags to set/unset flags can be i.e.'\Seen', '\Answered', '\Seen \Answered'
  89  * @param  bool   $set  add (true) or remove (false) the provided flag
  90  * @param  bool   $handle_errors Show error messages in case of a NO, BAD or BYE response
  91  * @return array  $aMessageList array with messages containing the new flags and UID @see parseFetch
  92  */
  93 function sqimap_toggle_flag($imap_stream, $id, $flag, $set, $handle_errors) {
  94     $msgs_id = sqimap_message_list_squisher($id);
  95     $set_string = ($set ? '+' : '-');
  96
  97     for ($i=0; $i<sizeof($id); $i++) {
  98         $aMessageList["$id[$i]"] = array();
  99     }
 100
 101     $aResponse = sqimap_run_command_list($imap_stream, "STORE $msgs_id ".$set_string."FLAGS ($flag)", $handle_errors, $response, $message, TRUE);
 102
 103     // parse the fetch response
 104     $parseFetchResults=parseFetch($aResponse,$aMessageList);
 105
 106     // some broken IMAP servers do not return UID elements on UID STORE
 107     // if this is the case, then we need to do a UID FETCH
 108     $testkey=$id[0];
 109     if (!isset($parseFetchResults[$testkey]['UID'])) {
 110         $aResponse = sqimap_run_command_list($imap_stream, "FETCH $msgs_id (FLAGS)", $handle_errors, $response, $message, TRUE);
 111         $parseFetchResults = parseFetch($aResponse,$aMessageList);
 112     }
 113
 114     return ($parseFetchResults);
 115 }
 116
 117
 118 /**
 119  * Sort the message list and crunch to be as small as possible
 120  * (overflow could happen, so make it small if possible)
 121  * @param array $aUid array with uid's
 122  * @return string $s message set string
 123  */
 124 function sqimap_message_list_squisher($aUid) {
 125     if( !is_array( $aUid ) ) {
 126         return $aUid;
 127     }
 128     sort($aUid, SORT_NUMERIC);
 129
 130     if (count($aUid)) {
 131         $s = '';
 132         for ($i=0,$iCnt=count($aUid);$i<$iCnt;++$i) {
 133             $iStart = $aUid[$i];
 134             $iEnd = $iStart;
 135             while ($i<($iCnt-1) && $aUid[$i+1] == $iEnd +1) {
 136                 $iEnd = $aUid[$i+1];
 137                 ++$i;
 138             }
 139             if ($s) {
 140                 $s .= ',';
 141             }
 142             $s .= $iStart;
 143             if ($iStart != $iEnd) {
 144                 $s .= ':' . $iEnd;
 145             }
 146         }
 147     }
 148     return $s;
 149 }
 150
 151
 152 /**
 153  * Retrieves an array with a sorted uid list. Sorting is done on the imap server
 154  * @link http://www.ietf.org/internet-drafts/draft-ietf-imapext-sort-17.txt
 155  * @param resource $imap_stream IMAP socket connection
 156  * @param string $sSortField Field to sort on
 157  * @param bool $reverse Reverse order search
 158  * @return array $id sorted uid list
 159  */
 160 function sqimap_get_sort_order($imap_stream, $sSortField, $reverse, $search='ALL') {
 161     global  $default_charset;
 162
 163     if ($sSortField) {
 164         if ($reverse) {
 165             $sSortField = 'REVERSE '.$sSortField;
 166         }
 167         $query = "SORT ($sSortField) ".strtoupper($default_charset)." $search";
 168         // FIX ME sqimap_run_command should return the parsed data accessible by $aDATA['SORT']
 169         // use sqimap_run_command_list in case of unsollicited responses. If we don't we could loose the SORT response
 170         $aData = sqimap_run_command_list ($imap_stream, $query, false, $response, $message, TRUE);
 171         /* fallback to default charset */
 172         if ($response == 'NO') {
 173             if (strpos($message,'BADCHARSET') !== false ||
 174                 strpos($message,'character') !== false) {
 175                 sqm_trigger_imap_error('SQM_IMAP_BADCHARSET',$query, $response, $message);
 176                 $query = "SORT ($sSortField) US-ASCII $search";
 177                 $aData = sqimap_run_command_list ($imap_stream, $query, true, $response, $message, TRUE);
 178             } else {
 179                 sqm_trigger_imap_error('SQM_IMAP_ERROR',$query, $response, $message);
 180             }
 181         } else if ($response == 'BAD') {
 182             sqm_trigger_imap_error('SQM_IMAP_NO_SORT',$query, $response, $message);
 183         }
 184     }
 185
 186     if ($response == 'OK') {
 187         return parseUidList($aData,'SORT');
 188     } else {
 189         return false;
 190     }
 191 }
 192
 193
 194 /**
 195  * Parses a UID list returned on a SORT or SEARCH request
 196  * @param array $aData imap response (retrieved from sqimap_run_command_list)
 197  * @param string $sCommand issued imap command (SEARCH or SORT)
 198  * @return array $aUid uid list
 199  */
 200 function parseUidList($aData,$sCommand) {
 201     $aUid = array();
 202     if (isset($aData) && count($aData)) {
 203         for ($i=0,$iCnt=count($aData);$i<$iCnt;++$i) {
 204             for ($j=0,$jCnt=count($aData[$i]);$j<$jCnt;++$j) {
 205                 if (preg_match("/^\* $sCommand (.+)$/", $aData[$i][$j], $aMatch)) {
 206                     $aUid += explode(' ', trim($aMatch[1]));
 207                 }
 208             }
 209         }
 210     }
 211     return array_unique($aUid);
 212 }
 213
 214 /**
 215  * Retrieves an array with a sorted uid list. Sorting is done by SquirrelMail
 216  *
 217  * @param resource $imap_stream IMAP socket connection
 218  * @param string $sSortField Field to sort on
 219  * @param bool $reverse Reverse order search
 220  * @param array $aUid limit the search to the provided array with uid's default sqimap_get_small_headers uses 1:*
 221  * @return array $aUid sorted uid list
 222  */
 223 function get_squirrel_sort($imap_stream, $sSortField, $reverse = false, $aUid = NULL) {
 224     if ($sSortField != 'RFC822.SIZE' && $sSortField != 'INTERNALDATE') {
 225         $msgs = sqimap_get_small_header_list($imap_stream, $aUid,
 226                                       array($sSortField), array());
 227     } else {
 228         $msgs = sqimap_get_small_header_list($imap_stream, $aUid,
 229                                       array(), array($sSortField));
 230     }
 231
 232     // sqimap_get_small_header (see above) returns fields in lower case,
 233     // but the code below uses all upper case
 234     foreach ($msgs as $k => $v) $msgs[$k][strtoupper($sSortField)] = $msgs[$k][strtolower($sSortField)];
 235
 236     $aUid = array();
 237     $walk = false;
 238     switch ($sSortField) {
 239       // natcasesort section
 240       case 'FROM':
 241       case 'TO':
 242       case 'CC':
 243         if(!$walk) {
 244             array_walk($msgs, create_function('&$v,&$k,$f',
 245                 '$v[$f] = (isset($v[$f])) ? $v[$f] : "";
 246                  $addr = reset(parseRFC822Address($v[$f],1));
 247                  $sPersonal = (isset($addr[SQM_ADDR_PERSONAL]) && $addr[SQM_ADDR_PERSONAL]) ?
 248                    $addr[SQM_ADDR_PERSONAL] : "";
 249                  $sEmail = ($addr[SQM_ADDR_HOST]) ?
 250                       $addr[SQM_ADDR_MAILBOX] . "@".$addr[SQM_ADDR_HOST] :
 251                       $addr[SQM_ADDR_HOST];
 252                  $v[$f] = ($sPersonal) ? decodeHeader($sPersonal, true, false):$sEmail;'),$sSortField);
 253             $walk = true;
 254         }
 255         // nobreak
 256       case 'SUBJECT':
 257         if(!$walk) {
 258             array_walk($msgs, create_function('&$v,&$k,$f',
 259                 '$v[$f] = (isset($v[$f])) ? $v[$f] : "";
 260                  $v[$f] = strtolower(decodeHeader(trim($v[$f]), true, false));
 261                  $v[$f] = (preg_match("/^(?:(?:vedr|sv|re|aw|fw|fwd|\[\w\]):\s*)*\s*(.*)$/si", $v[$f], $matches)) ?
 262                                     $matches[1] : $v[$f];'),$sSortField);
 263             $walk = true;
 264         }
 265         foreach ($msgs as $item) {
 266             $aUid[$item['UID']] = $item[$sSortField];
 267         }
 268         natcasesort($aUid);
 269         $aUid = array_keys($aUid);
 270         if ($reverse) {
 271              $aUid = array_reverse($aUid);
 272         }
 273         break;
 274         //  \natcasesort section
 275       // sort_numeric section
 276       case 'DATE':
 277       case 'INTERNALDATE':
 278         if(!$walk) {
 279             array_walk($msgs, create_function('&$v,$k,$f',
 280                 '$v[$f] = (isset($v[$f])) ? $v[$f] : "";
 281                  $v[$f] = getTimeStamp(explode(" ",$v[$f]));'),$sSortField);
 282             $walk = true;
 283         }
 284         // nobreak;
 285       case 'RFC822.SIZE':
 286         if(!$walk) {
 287             // redefine $sSortField to maintain the same namespace between
 288             // server-side sorting and SquirrelMail sorting
 289             $sSortField = 'SIZE';
 290         }
 291         foreach ($msgs as $item) {
 292             $aUid[$item['UID']] = (isset($item[$sSortField])) ? $item[$sSortField] : 0;
 293         }
 294         if ($reverse) {
 295             arsort($aUid,SORT_NUMERIC);
 296         } else {
 297             asort($aUid, SORT_NUMERIC);
 298         }
 299         $aUid = array_keys($aUid);
 300         break;
 301         // \sort_numeric section
 302       case 'UID':
 303         $aUid = array_reverse($msgs);
 304         break;
 305     }
 306     return $aUid;
 307 }
 308
 309 /**
 310  * Returns an array with each element as a string representing one
 311  * message-thread as returned by the IMAP server.
 312  * @param resource $imap_stream IMAP socket connection
 313  * @param string $search optional search string
 314  * @return array
 315  * @link http://www.ietf.org/internet-drafts/draft-ietf-imapext-sort-13.txt
 316  */
 317 function get_thread_sort($imap_stream, $search='ALL') {
 318     global $sort_by_ref, $default_charset;
 319
 320     if ($sort_by_ref == 1) {
 321         $sort_type = 'REFERENCES';
 322     } else {
 323         $sort_type = 'ORDEREDSUBJECT';
 324     }
 325     $query = "THREAD $sort_type ".strtoupper($default_charset)." $search";
 326
 327     // TODO use sqimap_run_command_list as we do in get_server_sort()
 328     $sRead = sqimap_run_command ($imap_stream, $query, false, $response, $message, TRUE);
 329
 330     /* fallback to default charset */
 331     if ($response == 'NO') {
 332         if (strpos($message,'BADCHARSET') !== false ||
 333             strpos($message,'character') !== false) {
 334             sqm_trigger_imap_error('SQM_IMAP_BADCHARSET',$query, $response, $message);
 335             $query = "THREAD $sort_type US-ASCII $search";
 336             $sRead = sqimap_run_command ($imap_stream, $query, true, $response, $message, TRUE);
 337         } else {
 338             sqm_trigger_imap_error('SQM_IMAP_ERROR',$query, $response, $message);
 339         }
 340     } elseif ($response == 'BAD') {
 341         sqm_trigger_imap_error('SQM_IMAP_NO_THREAD',$query, $response, $message);
 342     }
 343     $sThreadResponse = '';
 344     if (isset($sRead[0])) {
 345         for ($i=0,$iCnt=count($sRead);$i<$iCnt;++$i) {
 346             if (preg_match("/^\* THREAD (.+)$/", $sRead[$i], $aMatch)) {
 347                 $sThreadResponse = trim($aMatch[1]);
 348                 break;
 349             }
 350         }
 351     }
 352     unset($sRead);
 353
 354     if ($response !== 'OK') {
 355         return false;
 356     }
 357
 358     /* Example response
 359      *  S: * THREAD (2)(3 6 (4 23)(44 7 96))
 360      * -- 2
 361      *
 362      * -- 3
 363      *    \-- 6
 364      *        |-- 4
 365      *        |   \-- 23
 366      *        |
 367      *        \-- 44
 368      *             \-- 7
 369      *                 \-- 96
 370      */
 371 /*
 372  * Notes for future work:
 373  * indent_array should contain: indent_level, parent and flags,
 374  * sibling nodes ..
 375  * To achieve that we  need to define the following flags:
 376  * 0: hasnochildren
 377  * 1: haschildren
 378  * 2: is first
 379  * 4: is last
 380  * a node has sibling nodes if it's not the last node
 381  * a node has no sibling nodes if it's the last node
 382  * By using binary comparations we can store the flag in one var
 383  *
 384  * example:
 385  * -1      par = 0, level = 0, flag = 1 + 2 + 4 = 7 (haschildren,   isfirst, islast)
 386  *  \-2    par = 1, level = 1, flag = 0 + 2     = 2 (hasnochildren, isfirst)
 387  *  |-3    par = 1, level = 1, flag = 1 + 4     = 5 (haschildren,   islast)
 388  *   \-4   par = 3, level = 2, flag = 1 + 2 + 4 = 7 (haschildren,   isfirst, islast)
 389  *     \-5 par = 4, level = 3, flag = 0 + 2 + 4 = 6 (hasnochildren, isfirst, islast)
 390  */
 391
 392     $j = 0;
 393     $k = 0;
 394     $l = 0;
 395     $aUidThread = array();
 396     $aIndent = array();
 397     $aUidSubThread = array();
 398     $aDepthStack = array();
 399     $sUid = '';
 400
 401     if ($sThreadResponse) {
 402         for ($i=0,$iCnt = strlen($sThreadResponse);$i<$iCnt;++$i) {
 403             $cChar = $sThreadResponse{$i};
 404             switch ($cChar) {
 405                 case '(': // new sub thread
 406                     // correction for a subthread of a thread with no parents in thread
 407                     if (!count($aUidSubThread) && $j > 0) {
 408                        --$l;
 409                     }
 410                     $aDepthStack[$j] = $l;
 411                     ++$j;
 412                     break;
 413                 case ')': // close sub thread
 414                     if($sUid !== '') {
 415                         $aUidSubThread[] = $sUid;
 416                         $aIndent[$sUid] = $j + $l - 1;
 417                         ++$l;
 418                         $sUid = '';
 419                     }
 420                     --$j;
 421                     if ($j === 0) {
 422                         // show message that starts the thread first.
 423                         $aUidSubThread = array_reverse($aUidSubThread);
 424                         // do not use array_merge because it's extremely slow and is causing timeouts
 425                         foreach ($aUidSubThread as $iUid) {
 426                             $aUidThread[] = $iUid;
 427                         }
 428                         $aUidSubThread = array();
 429                         $l = 0;
 430                         $aDepthStack = array();
 431                     } else {
 432                         $l = $aDepthStack[$j];
 433                     }
 434                     break;
 435                 case ' ': // new child
 436                     if ($sUid !== '') {
 437                         $aUidSubThread[] = $sUid;
 438                         $aIndent[$sUid] = $j + $l - 1;
 439                         ++$l;
 440                         $sUid = '';
 441                     }
 442                     break;
 443                 default: // part of UID
 444                     $sUid .= $cChar;
 445                     break;
 446             }
 447         }
 448     }
 449     unset($sThreadResponse);
 450     // show newest threads first
 451     $aUidThread = array_reverse($aUidThread);
 452     return array($aUidThread,$aIndent);
 453 }
 454
 455
 456 function elapsedTime($start) {
 457     $stop = gettimeofday();
 458     $timepassed =  1000000 * ($stop['sec'] - $start['sec']) + $stop['usec'] - $start['usec'];
 459     return $timepassed;
 460 }
 461
 462 /**
 463  * Parses a string in an imap response. String starts with " or { which means it
 464  * can handle double quoted strings and literal strings
 465  *
 466  * @param string $read imap response
 467  * @param integer $i (reference) offset in string
 468  * @return string $s parsed string without the double quotes or literal count
 469  */
 470 function parseString($read,&$i) {
 471     $char = $read{$i};
 472     $s = '';
 473     if ($char == '"') {
 474         $iPos = ++$i;
 475         while (true) {
 476             $iPos = strpos($read,'"',$iPos);
 477             if (!$iPos) break;
 478             if ($iPos && $read{$iPos -1} != '\\') {
 479                 $s = substr($read,$i,($iPos-$i));
 480                 $i = $iPos;
 481                 break;
 482             }
 483             $iPos++;
 484             if ($iPos > strlen($read)) {
 485                 break;
 486             }
 487         }
 488     } else if ($char == '{') {
 489         $lit_cnt = '';
 490         ++$i;
 491         $iPos = strpos($read,'}',$i);
 492         if ($iPos) {
 493             $lit_cnt = substr($read, $i, $iPos - $i);
 494             $i += strlen($lit_cnt) + 3; /* skip } + \r + \n */
 495             /* Now read the literal */
 496             $s = ($lit_cnt ? substr($read,$i,$lit_cnt): '');
 497             $i += $lit_cnt;
 498             /* temp bugfix (SM 1.5 will have a working clean version)
 499                too much work to implement that version right now */
 500             --$i;
 501         } else { /* should never happen */
 502             $i += 3; /* } + \r + \n */
 503             $s = '';
 504         }
 505     } else {
 506         return false;
 507     }
 508     ++$i;
 509     return $s;
 510 }
 511
 512
 513 /**
 514  * Parses a string containing an array from an imap response. String starts with ( and end with )
 515  *
 516  * @param string $read imap response
 517  * @param integer $i (reference) offset in string
 518  * @return array $a
 519  */
 520 function parseArray($read,&$i) {
 521     $i = strpos($read,'(',$i);
 522     $i_pos = strpos($read,')',$i);
 523     $s = substr($read,$i+1,$i_pos - $i -1);
 524     $a = explode(' ',$s);
 525     if ($i_pos) {
 526         $i = $i_pos+1;
 527         return $a;
 528     } else {
 529         return false;
 530     }
 531 }
 532
 533
 534 /**
 535  * Retrieves a list with headers, flags, size or internaldate from the imap server
 536  *
 537  * WARNING: function is not portable between SquirrelMail 1.2.x, 1.4.x and 1.5.x.
 538  * Output format, third argument and $msg_list array format requirements differ.
 539  * @param stream $imap_stream imap connection
 540  * @param array  $msg_list array with id's to create a msgs set from
 541  * @param array  $aHeaderFields (since 1.5.0) requested header fields
 542  * @param array  $aFetchItems (since 1.5.0) requested other fetch items like FLAGS, RFC822.SIZE
 543  * @return array $aMessages associative array with messages. Key is the UID, value is an associative array
 544  * @since 1.1.3
 545  */
 546 function sqimap_get_small_header_list($imap_stream, $msg_list,
 547     $aHeaderFields = array('Date', 'To', 'Cc', 'From', 'Subject', 'X-Priority', 'Content-Type'),
 548     $aFetchItems = array('FLAGS', 'RFC822.SIZE', 'INTERNALDATE')) {
 549
 550     $aMessageList = array();
 551
 552     /**
 553      * Catch other priority headers as well
 554      */
 555     if (in_array('X-Priority',$aHeaderFields,true)) {
 556         $aHeaderFields[] = 'Importance';
 557         $aHeaderFields[] = 'Priority';
 558     }
 559
 560     $bUidFetch = ! in_array('UID', $aFetchItems, true);
 561
 562     /* Get the small headers for each message in $msg_list */
 563     if ($msg_list !== NULL) {
 564         $msgs_str = sqimap_message_list_squisher($msg_list);
 565         /*
 566         * We need to return the data in the same order as the caller supplied
 567         * in $msg_list, but IMAP servers are free to return responses in
 568         * whatever order they wish... So we need to re-sort manually
 569         */
 570         if ($bUidFetch) {
 571             for ($i = 0; $i < sizeof($msg_list); $i++) {
 572                 $aMessageList["$msg_list[$i]"] = array();
 573             }
 574         }
 575     } else {
 576         $msgs_str = '1:*';
 577     }
 578
 579     /*
 580      * Create the query
 581      */
 582
 583     $sFetchItems = '';
 584     $query = "FETCH $msgs_str (";
 585     if (count($aFetchItems)) {
 586         $sFetchItems = implode(' ',$aFetchItems);
 587     }
 588     if (count($aHeaderFields)) {
 589         $sHeaderFields = implode(' ',$aHeaderFields);
 590         $sFetchItems .= ' BODY.PEEK[HEADER.FIELDS ('.$sHeaderFields.')]';
 591     }
 592     $query .= trim($sFetchItems) . ')';
 593     $aResponse = sqimap_run_command_list ($imap_stream, $query, true, $response, $message, $bUidFetch);
 594     $aMessages = parseFetch($aResponse,$aMessageList);
 595     array_reverse($aMessages);
 596     return $aMessages;
 597 }
 598
 599
 600 /**
 601  * Parses a fetch response, currently it can hande FLAGS, HEADERS, RFC822.SIZE, INTERNALDATE and UID
 602  * @param array    $aResponse Imap response
 603  * @param array    $aMessageList Placeholder array for results. The keys of the
 604  *                 placeholder array should be the UID so we can reconstruct the order.
 605  * @return array   $aMessageList associative array with messages. Key is the UID, value is an associative array
 606  * @author Marc Groot Koerkamp
 607  */
 608 function parseFetch(&$aResponse,$aMessageList = array()) {
 609     for ($j=0,$iCnt=count($aResponse);$j<$iCnt;++$j) {
 610         $aMsg = array();
 611
 612         $read = implode('',$aResponse[$j]);
 613         // free up memmory
 614         unset($aResponse[$j]); /* unset does not reindex the array. the for loop is safe */
 615         /*
 616             * #id<space>FETCH<space>(
 617         */
 618
 619         /* extract the message id */
 620         $i_space = strpos($read,' ',2);/* position 2ed <space> */
 621         $id = substr($read,2/* skip "*<space>" */,$i_space -2);
 622         $aMsg['ID'] = $id;
 623         $fetch = substr($read,$i_space+1,5);
 624         if (!is_numeric($id) && $fetch !== 'FETCH') {
 625             $aMsg['ERROR'] = $read; // htmlspecialchars should be done just before display. this is backend code
 626             break;
 627         }
 628         $i = strpos($read,'(',$i_space+5);
 629         $read = substr($read,$i+1);
 630         $i_len = strlen($read);
 631         $i = 0;
 632         while ($i < $i_len && $i !== false) {
 633             /* get argument */
 634             $read = trim(substr($read,$i));
 635             $i_len = strlen($read);
 636             $i = strpos($read,' ');
 637             $arg = substr($read,0,$i);
 638             ++$i;
 639             /*
 640              * use allcaps for imap items and lowcaps for headers as key for the $aMsg array
 641              */
 642             switch ($arg)
 643             {
 644             case 'UID':
 645                 $i_pos = strpos($read,' ',$i);
 646                 if (!$i_pos) {
 647                     $i_pos = strpos($read,')',$i);
 648                 }
 649                 if ($i_pos) {
 650                     $unique_id = substr($read,$i,$i_pos-$i);
 651                     $i = $i_pos+1;
 652                 } else {
 653                     break 3;
 654                 }
 655                 break;
 656             case 'FLAGS':
 657                 $flags = parseArray($read,$i);
 658                 if (!$flags) break 3;
 659                 $aFlags = array();
 660                 foreach ($flags as $flag) {
 661                     $flag = strtolower($flag);
 662                     $aFlags[$flag] = true;
 663                 }
 664                 $aMsg['FLAGS'] = $aFlags;
 665                 break;
 666             case 'RFC822.SIZE':
 667                 $i_pos = strpos($read,' ',$i);
 668                 if (!$i_pos) {
 669                     $i_pos = strpos($read,')',$i);
 670                 }
 671                 if ($i_pos) {
 672                     $aMsg['SIZE'] = substr($read,$i,$i_pos-$i);
 673                     $i = $i_pos+1;
 674                 } else {
 675                     break 3;
 676                 }
 677                 break;
 678             case 'ENVELOPE':
 679                 // sqimap_parse_address($read,$i,$aMsg);
 680                 break; // to be implemented, moving imap code out of the Message class
 681             case 'BODYSTRUCTURE':
 682                 break; // to be implemented, moving imap code out of the Message class
 683             case 'INTERNALDATE':
 684                 $aMsg['INTERNALDATE'] = trim(str_replace('  ', ' ',parseString($read,$i)));
 685                 break;
 686             case 'BODY.PEEK[HEADER.FIELDS':
 687             case 'BODY[HEADER.FIELDS':
 688                 $i = strpos($read,'{',$i); // header is always returned as literal because it contain \n characters
 689                 $header = parseString($read,$i);
 690                 if ($header === false) break 2;
 691                 /* First we replace all \r\n by \n, and unfold the header */
 692                 $hdr = trim(str_replace(array("\r\n", "\n\t", "\n "),array("\n", ' ', ' '), $header));
 693                 /* Now we can make a new header array with
 694                    each element representing a headerline  */
 695                 $aHdr = explode("\n" , $hdr);
 696                 $aReceived = array();
 697                 foreach ($aHdr as $line) {
 698                     $pos = strpos($line, ':');
 699                     if ($pos > 0) {
 700                         $field = strtolower(substr($line, 0, $pos));
 701                         if (!strstr($field,' ')) { /* valid field */
 702                             $value = trim(substr($line, $pos+1));
 703                             switch($field) {
 704                                 case 'date':
 705                                     $aMsg['date'] = trim(str_replace('  ', ' ', $value));
 706                                     break;
 707                                 case 'x-priority': $aMsg['x-priority'] = ($value) ? (int) $value{0} : 3; break;
 708                                 case 'priority':
 709                                 case 'importance':
 710                                     // duplicate code with Rfc822Header.cls:parsePriority()
 711                                     if (!isset($aMsg['x-priority'])) {
 712                                         $aPrio = preg_split('/\s/',trim($value));
 713                                         $sPrio = strtolower(array_shift($aPrio));
 714                                         if  (is_numeric($sPrio)) {
 715                                             $iPrio = (int) $sPrio;
 716                                         } elseif ( $sPrio == 'non-urgent' || $sPrio == 'low' ) {
 717                                             $iPrio = 3;
 718                                         } elseif ( $sPrio == 'urgent' || $sPrio == 'high' ) {
 719                                             $iPrio = 1;
 720                                         } else {
 721                                             // default is normal priority
 722                                             $iPrio = 3;
 723                                         }
 724                                         $aMsg['x-priority'] = $iPrio;
 725                                     }
 726                                     break;
 727                                 case 'content-type':
 728                                     $type = $value;
 729                                     if ($pos = strpos($type, ";")) {
 730                                         $type = substr($type, 0, $pos);
 731                                     }
 732                                     $type = explode("/", $type);
 733                                     if(!is_array($type) || count($type) < 2) {
 734                                         $aMsg['content-type'] = array('text','plain');
 735                                     } else {
 736                                         $aMsg['content-type'] = array(strtolower($type[0]),strtolower($type[1]));
 737                                     }
 738                                     break;
 739                                 case 'received':
 740                                     $aMsg['received'][] = $value;
 741                                     break;
 742                                 default:
 743                                     $aMsg[$field] = $value;
 744                                     break;
 745                             }
 746                         }
 747                     }
 748                 }
 749                 break;
 750             default:
 751                 ++$i;
 752                 break;
 753             }
 754         }
 755         if (!empty($unique_id)) {
 756             $msgi = "$unique_id";
 757             $aMsg['UID'] = $unique_id;
 758        } else {
 759             $msgi = '';
 760        }
 761        $aMessageList[$msgi] = $aMsg;
 762        $aResponse[$j] = NULL;
 763     }
 764     return $aMessageList;
 765 }
 766
 767 /**
 768  * Work in process
 769  * @private
 770  * @author Marc Groot Koerkamp
 771  */
 772 function sqimap_parse_envelope($read, &$i, &$msg) {
 773     $arg_no = 0;
 774     $arg_a = array();
 775     ++$i;
 776     for ($cnt = strlen($read); ($i < $cnt) && ($read{$i} != ')'); ++$i) {
 777         $char = strtoupper($read{$i});
 778         switch ($char) {
 779             case '{':
 780             case '"':
 781                 $arg_a[] = parseString($read,$i);
 782                 ++$arg_no;
 783                 break;
 784             case 'N':
 785                 /* probably NIL argument */
 786                 if (strtoupper(substr($read, $i, 3)) == 'NIL') {
 787                     $arg_a[] = '';
 788                     ++$arg_no;
 789                     $i += 2;
 790                 }
 791                 break;
 792             case '(':
 793                 /* Address structure (with group support)
 794                 * Note: Group support is useless on SMTP connections
 795                 *       because the protocol doesn't support it
 796                 */
 797                 $addr_a = array();
 798                 $group = '';
 799                 $a=0;
 800                 for (; $i < $cnt && $read{$i} != ')'; ++$i) {
 801                     if ($read{$i} == '(') {
 802                         $addr = sqimap_parse_address($read, $i);
 803                         if (($addr[3] == '') && ($addr[2] != '')) {
 804                             /* start of group */
 805                             $group = $addr[2];
 806                             $group_addr = $addr;
 807                             $j = $a;
 808                         } else if ($group && ($addr[3] == '') && ($addr[2] == '')) {
 809                         /* end group */
 810                             if ($a == ($j+1)) { /* no group members */
 811                                 $group_addr[4] = $group;
 812                                 $group_addr[2] = '';
 813                                 $group_addr[0] = "$group: Undisclosed recipients;";
 814                                 $addr_a[] = $group_addr;
 815                                 $group ='';
 816                             }
 817                         } else {
 818                             $addr[4] = $group;
 819                             $addr_a[] = $addr;
 820                         }
 821                         ++$a;
 822                     }
 823                 }
 824                 $arg_a[] = $addr_a;
 825                 break;
 826             default: break;
 827         }
 828     }
 829
 830     if (count($arg_a) > 9) {
 831         $d = strtr($arg_a[0], array('  ' => ' '));
 832         $d = explode(' ', $d);
 833         if (!$arg_a[1]) $arg_a[1] = '';
 834         $msg['DATE'] = $d; /* argument 1: date */
 835         $msg['SUBJECT'] = $arg_a[1];     /* argument 2: subject */
 836         $msg['FROM'] = is_array($arg_a[2]) ? $arg_a[2][0] : '';     /* argument 3: from        */
 837         $msg['SENDER'] = is_array($arg_a[3]) ? $arg_a[3][0] : '';   /* argument 4: sender      */
 838         $msg['REPLY-TO'] = is_array($arg_a[4]) ? $arg_a[4][0] : '';  /* argument 5: reply-to    */
 839         $msg['TO'] = $arg_a[5];          /* argument 6: to          */
 840         $msg['CC'] = $arg_a[6];          /* argument 7: cc          */
 841         $msg['BCC'] = $arg_a[7];         /* argument 8: bcc         */
 842         $msg['IN-REPLY-TO'] = $arg_a[8];   /* argument 9: in-reply-to */
 843         $msg['MESSAGE-ID'] = $arg_a[9];  /* argument 10: message-id */
 844     }
 845 }
 846
 847
 848 /**
 849  * Work in process
 850  * @private
 851  * @author Marc Groot Koerkamp
 852  */
 853 function sqimap_parse_address($read, &$i) {
 854     $arg_a = array();
 855     for (; $read{$i} != ')'; ++$i) {
 856         $char = strtoupper($read{$i});
 857         switch ($char) {
 858             case '{':
 859             case '"': $arg_a[] =  parseString($read,$i); break;
 860             case 'n':
 861             case 'N':
 862                 if (strtoupper(substr($read, $i, 3)) == 'NIL') {
 863                     $arg_a[] = '';
 864                     $i += 2;
 865                 }
 866                 break;
 867             default: break;
 868         }
 869     }
 870
 871     if (count($arg_a) == 4) {
 872         return $arg_a;
 873
 874 //        $adr = new AddressStructure();
 875 //        $adr->personal = $arg_a[0];
 876 //        $adr->adl = $arg_a[1];
 877 //        $adr->mailbox = $arg_a[2];
 878 //        $adr->host = $arg_a[3];
 879     } else {
 880         $adr = '';
 881     }
 882     return $adr;
 883 }
 884
 885
 886 /**
 887  * Returns a message array with all the information about a message.
 888  * See the documentation folder for more information about this array.
 889  *
 890  * @param  resource $imap_stream imap connection
 891  * @param  integer  $id uid of the message
 892  * @param  string   $mailbox used for error handling, can be removed because we should return an error code and generate the message elsewhere
 893  * @param  int      $hide Indicates whether or not to hide any errors: 0 = don't hide, 1 = hide (just exit), 2 = hide (return FALSE), 3 = hide (return error string) (OPTIONAL; default don't hide)
 894  * @return mixed  Message object or FALSE/error string if error occurred and $hide is set to 2/3
 895  */
 896 function sqimap_get_message($imap_stream, $id, $mailbox, $hide=0) {
 897     // typecast to int to prohibit 1:* msgs sets
 898     $id = (int) $id;
 899     $flags = array();
 900     $read = sqimap_run_command($imap_stream, "FETCH $id (FLAGS BODYSTRUCTURE)", true, $response, $message, TRUE);
 901     if ($read) {
 902         if (preg_match('/.+FLAGS\s\((.*)\)\s/AUi',$read[0],$regs)) {
 903             if (trim($regs[1])) {
 904                 $flags = preg_split('/ /', $regs[1],-1,PREG_SPLIT_NO_EMPTY);
 905             }
 906         }
 907     } else {
 908
 909         if ($hide == 1) exit;
 910         if ($hide == 2) return FALSE;
 911
 912         /* the message was not found, maybe the mailbox was modified? */
 913         global $sort, $startMessage;
 914
 915         $errmessage = _("The server couldn't find the message you requested.");
 916
 917         if ($hide == 3) return $errmessage;
 918
 919         $errmessage .= '<p>'._("Most probably your message list was out of date and the message has been moved away or deleted (perhaps by another program accessing the same mailbox).");
 920
 921         /* this will include a link back to the message list */
 922         error_message($errmessage, $mailbox, $sort, (int) $startMessage);
 923         exit;
 924     }
 925     $bodystructure = implode('',$read);
 926     $msg =  mime_structure($bodystructure,$flags);
 927     $read = sqimap_run_command($imap_stream, "FETCH $id BODY[HEADER]", true, $response, $message, TRUE);
 928     $rfc822_header = new Rfc822Header();
 929     $rfc822_header->parseHeader($read);
 930     $msg->rfc822_header = $rfc822_header;
 931
 932     parse_message_entities($msg, $id, $imap_stream);
 933     return $msg;
 934  }
 935
 936
 937 /**
 938  * Recursively parse embedded messages (if any) in the given
 939  * message, building correct rfc822 headers for each one
 940  *
 941  * @param object $msg The message object to scan for attached messages
 942  *                    NOTE: this is passed by reference!  Changes made
 943  *                    within will affect the caller's copy of $msg!
 944  * @param int $id The top-level message UID on the IMAP server, even
 945  *                if the $msg being passed in is only an attached entity
 946  *                thereof.
 947  * @param resource $imap_stream A live connection to the IMAP server.
 948  *
 949  * @return void
 950  *
 951  * @since 1.5.2
 952  *
 953  */
 954 function parse_message_entities(&$msg, $id, $imap_stream) {
 955     global $uid_support;
 956     if (!empty($msg->entities)) foreach ($msg->entities as $i => $entity) {
 957         if (is_object($entity) && get_class($entity) == 'Message') {
 958             if (!empty($entity->rfc822_header)) {
 959                 $read = sqimap_run_command($imap_stream, "FETCH $id BODY[". $entity->entity_id .".HEADER]", true, $response, $message, $uid_support);
 960                 $rfc822_header = new Rfc822Header();
 961                 $rfc822_header->parseHeader($read);
 962                 $msg->entities[$i]->rfc822_header = $rfc822_header;
 963             }
 964             parse_message_entities($msg->entities[$i], $id, $imap_stream);
 965         }
 966     }
 967 }