functions/imap_mailbox.php

   1 <?php
   2
   3 /**
   4  * imap_mailbox.php
   5  *
   6  * Copyright (c) 1999-2005 The SquirrelMail Project Team
   7  * Licensed under the GNU GPL. For full terms see the file COPYING.
   8  *
   9  * This impliments all functions that manipulate mailboxes
  10  *
  11  * @version $Id$
  12  * @package squirrelmail
  13  * @subpackage imap
  14  */
  15
  16 /** UTF7 support */
  17 require_once(SM_PATH . 'functions/imap_utf7_local.php');
  18
  19 global $boxesnew;
  20
  21 /**
  22  * Mailboxes class
  23  *
  24  * FIXME. This class should be extracted and placed in a separate file that
  25  * can be included before we start the session. That makes caching of the tree
  26  * possible. On a refresh mailboxes from left_main.php the only function that
  27  * should be called is the sqimap_get_status_mbx_tree. In case of subscribe
  28  * / rename / delete / new we have to create methods for adding/changing the
  29  * mailbox in the mbx_tree without the need for a refresh.
  30  * @package squirrelmail
  31  * @subpackage imap
  32  * @since 1.3.0
  33  */
  34 class mailboxes {
  35     var $mailboxname_full = '', $mailboxname_sub= '', $is_noselect = false, $is_noinferiors = false,
  36         $is_special = false, $is_root = false, $is_inbox = false, $is_sent = false,
  37         $is_trash = false, $is_draft = false,  $mbxs = array(),
  38         $unseen = false, $total = false;
  39
  40     function addMbx($mbx, $delimiter, $start, $specialfirst) {
  41         $ary = explode($delimiter, $mbx->mailboxname_full);
  42         $mbx_parent =& $this;
  43         for ($i = $start, $c = count($ary)-1; $i < $c; $i++) {
  44             $mbx_childs =& $mbx_parent->mbxs;
  45             $found = false;
  46             if ($mbx_childs) {
  47                 foreach ($mbx_childs as $key => $parent) {
  48                     if ($parent->mailboxname_sub == $ary[$i]) {
  49                         $mbx_parent =& $mbx_parent->mbxs[$key];
  50                         $found = true;
  51                         break;
  52                     }
  53                 }
  54             }
  55             if (!$found) {
  56                 $no_select_mbx = new mailboxes();
  57                 if (isset($mbx_parent->mailboxname_full) && $mbx_parent->mailboxname_full != '') {
  58                     $no_select_mbx->mailboxname_full = $mbx_parent->mailboxname_full.$delimiter.$ary[$i];
  59                 } else {
  60                     $no_select_mbx->mailboxname_full = $ary[$i];
  61                 }
  62                 $no_select_mbx->mailboxname_sub = $ary[$i];
  63                 $no_select_mbx->is_noselect = true;
  64                 $mbx_parent->mbxs[] = $no_select_mbx;
  65                 $i--;
  66             }
  67         }
  68         $mbx_parent->mbxs[] = $mbx;
  69         if ($mbx->is_special && $specialfirst) {
  70             usort($mbx_parent->mbxs, 'sortSpecialMbx');
  71         }
  72     }
  73 }
  74
  75 /**
  76  * array callback used for sorting in mailboxes class
  77  * @param object $a
  78  * @param object $b
  79  * @return integer see php strnatcasecmp()
  80  * @since 1.3.0
  81  */
  82 function sortSpecialMbx($a, $b) {
  83     if ($a->is_inbox) {
  84         $acmp = '0'. $a->mailboxname_full;
  85     } else if ($a->is_special) {
  86         $acmp = '1'. $a->mailboxname_full;
  87     } else {
  88         $acmp = '2' . $a->mailboxname_full;
  89     }
  90     if ($b->is_inbox) {
  91         $bcmp = '0'. $b->mailboxname_full;
  92     }else if ($b->is_special) {
  93         $bcmp = '1' . $b->mailboxname_full;
  94     } else {
  95         $bcmp = '2' . $b->mailboxname_full;
  96     }
  97     return strnatcasecmp($acmp, $bcmp);
  98 }
  99
 100 /**
 101  * @param array $ary
 102  * @return array
 103  * @since 1.5.0
 104  */
 105 function compact_mailboxes_response($ary) {
 106     /*
 107      * Workaround for mailboxes returned as literal
 108      * FIXME : Doesn't work if the mailbox name is multiple lines
 109      * (larger then fgets buffer)
 110      */
 111     for ($i = 0, $iCnt=count($ary); $i < $iCnt; $i++) {
 112         if (isset($ary[$i + 1]) && substr($ary[$i], -3) == "}\r\n") {
 113             if (ereg("^(\\* [A-Z]+.*)\\{[0-9]+\\}([ \n\r\t]*)$",
 114                  $ary[$i], $regs)) {
 115                 $ary[$i] = $regs[1] . '"' . addslashes(trim($ary[$i+1])) . '"' . $regs[2];
 116                 array_splice($ary, $i+1, 2);
 117             }
 118         }
 119     }
 120     /* remove duplicates and ensure array is contiguous */
 121     return array_values(array_unique($ary));
 122 }
 123
 124 /**
 125  * Extract the mailbox name from an untagged LIST (7.2.2) or LSUB (7.2.3) answer
 126  * (LIST|LSUB) (<Flags list>) (NIL|"<separator atom>") <mailbox name string>\r\n
 127  * mailbox name in quoted string MUST be unquoted and stripslashed (sm API)
 128  *
 129  * Originally stored in functions/strings.php. Since 1.2.6 stored in
 130  * functions/imap_mailbox.php
 131  * @param string $line imap LIST/LSUB response line
 132  * @return string mailbox name
 133  */
 134 function find_mailbox_name($line) {
 135     if (preg_match('/^\* (?:LIST|LSUB) \([^\)]*\) (?:NIL|\"[^\"]*\") ([^\r\n]*)[\r\n]*$/i', $line, $regs)) {
 136         if (substr($regs[1], 0, 1) == '"')
 137             return stripslashes(substr($regs[1], 1, -1));
 138         return $regs[1];
 139     }
 140     return '';
 141 }
 142
 143 /**
 144  * Detects if mailbox has noselect flag (can't store messages)
 145  * In versions older than 1.4.5 function checks only LSUB responses
 146  * and can produce pcre warnings.
 147  * @param string $lsub_line mailbox line from untagged LIST or LSUB response
 148  * @return bool whether this is a Noselect mailbox.
 149  * @since 1.3.2
 150  */
 151 function check_is_noselect ($lsub_line) {
 152     return preg_match("/^\* (LSUB|LIST) \([^\)]*\\\\Noselect[^\)]*\)/i", $lsub_line);
 153 }
 154
 155 /**
 156  * Detects if mailbox has noinferiors flag (can't store subfolders)
 157  * @param string $lsub_line mailbox line from untagged LIST or LSUB response
 158  * @return bool whether this is a Noinferiors mailbox.
 159  * @since 1.5.0
 160  */
 161 function check_is_noinferiors ($lsub_line) {
 162     return preg_match("/^\* (LSUB|LIST) \([^\)]*\\\\Noinferiors[^\)]*\)/i", $lsub_line);
 163 }
 164
 165 /**
 166  * Detects mailbox's parent folder
 167  *
 168  * If $haystack is a full mailbox name, and $needle is the mailbox
 169  * separator character, returns the second last part of the full
 170  * mailbox name (i.e. the mailbox's parent mailbox)
 171  *
 172  * Originally stored in functions/strings.php. Since 1.2.6 stored in
 173  * functions/imap_mailbox.php
 174  * @param string $haystack full mailbox name
 175  * @param string $needle delimiter
 176  * @return string parent mailbox
 177  */
 178 function readMailboxParent($haystack, $needle) {
 179     if ($needle == '') {
 180         $ret = '';
 181     } else {
 182         $parts = explode($needle, $haystack);
 183         $elem = array_pop($parts);
 184         while ($elem == '' && count($parts)) {
 185             $elem = array_pop($parts);
 186         }
 187         $ret = join($needle, $parts);
 188     }
 189     return( $ret );
 190 }
 191
 192 /**
 193  * Check if $subbox is below the specified $parentbox
 194  * @param string $subbox potential sub folder
 195  * @param string $parentbox potential parent
 196  * @return boolean
 197  * @since 1.2.3
 198  */
 199 function isBoxBelow( $subbox, $parentbox ) {
 200     global $delimiter;
 201     /*
 202      * Eliminate the obvious mismatch, where the
 203      * subfolder path is shorter than that of the potential parent
 204      */
 205     if ( strlen($subbox) < strlen($parentbox) ) {
 206       return false;
 207     }
 208     /* check for delimiter */
 209     if (substr($parentbox,-1) != $delimiter) {
 210         $parentbox .= $delimiter;
 211     }
 212
 213     return (substr($subbox,0,strlen($parentbox)) == $parentbox);
 214 }
 215
 216 /**
 217  * Defines special mailboxes: given a mailbox name, it checks if this is a
 218  * "special" one: INBOX, Trash, Sent or Draft.
 219  *
 220  * Since 1.2.5 function includes special_mailbox hook.<br>
 221  * Since 1.4.3 hook supports more than one plugin.
 222  * @param string $box mailbox name
 223  * @return boolean
 224  * @since 1.2.3
 225  */
 226 function isSpecialMailbox( $box ) {
 227     $ret = ( (strtolower($box) == 'inbox') ||
 228              isTrashMailbox($box) || isSentMailbox($box) || isDraftMailbox($box) );
 229
 230     if ( !$ret ) {
 231         $ret = boolean_hook_function('special_mailbox',$box,1);
 232     }
 233     return $ret;
 234 }
 235
 236 /**
 237  * Detects if mailbox is a Trash folder or subfolder of Trash
 238  * @param string $box mailbox name
 239  * @return bool whether this is a Trash folder
 240  * @since 1.4.0
 241  */
 242 function isTrashMailbox ($box) {
 243     global $trash_folder, $move_to_trash;
 244     return $move_to_trash && $trash_folder &&
 245            ( $box == $trash_folder || isBoxBelow($box, $trash_folder) );
 246 }
 247
 248 /**
 249  * Detects if mailbox is a Sent folder or subfolder of Sent
 250  * @param string $box mailbox name
 251  * @return bool whether this is a Sent folder
 252  * @since 1.4.0
 253  */
 254 function isSentMailbox($box) {
 255    global $sent_folder, $move_to_sent;
 256    return $move_to_sent && $sent_folder &&
 257           ( $box == $sent_folder || isBoxBelow($box, $sent_folder) );
 258 }
 259
 260 /**
 261  * Detects if mailbox is a Drafts folder or subfolder of Drafts
 262  * @param string $box mailbox name
 263  * @return bool whether this is a Draft folder
 264  * @since 1.4.0
 265  */
 266 function isDraftMailbox($box) {
 267    global $draft_folder, $save_as_draft;
 268    return $save_as_draft &&
 269           ( $box == $draft_folder || isBoxBelow($box, $draft_folder) );
 270 }
 271
 272 /**
 273  * Expunges a mailbox
 274  *
 275  * WARNING: Select mailbox before calling this function.
 276  *
 277  * permanently removes all messages that have the \Deleted flag
 278  * set from the selected mailbox. See EXPUNGE command chapter in
 279  * IMAP RFC.
 280  * @param stream $imap_stream imap connection resource
 281  * @param string $mailbox mailbox name (unused since 1.1.3).
 282  * @param boolean $handle_errors error handling control (displays error_box on error).
 283  * @param mixed $id (since 1.3.0) integer message id or array with integer ids
 284  * @return integer number of expunged messages
 285  * @since 1.0 or older
 286  */
 287 function sqimap_mailbox_expunge ($imap_stream, $mailbox, $handle_errors = true, $id='') {
 288     if ($id) {
 289         if (is_array($id)) {
 290             $id = sqimap_message_list_squisher($id);
 291         }
 292         $id = ' '.$id;
 293         $uid = TRUE;
 294     } else {
 295         $uid = false;
 296     }
 297     $read = sqimap_run_command($imap_stream, 'EXPUNGE'.$id, $handle_errors,
 298                                $response, $message, $uid);
 299     $cnt = 0;
 300
 301     if (is_array($read)) {
 302         foreach ($read as $r) {
 303             if (preg_match('/^\*\s[0-9]+\sEXPUNGE/AUi',$r,$regs)) {
 304                 $cnt++;
 305             }
 306         }
 307     }
 308     return $cnt;
 309 }
 310
 311 /**
 312  * Checks whether or not the specified mailbox exists
 313  * @param stream $imap_stream imap connection resource
 314  * @param string $mailbox mailbox name
 315  * @return boolean
 316  * @since 1.0 or older
 317  */
 318 function sqimap_mailbox_exists ($imap_stream, $mailbox) {
 319     if (!isset($mailbox) || empty($mailbox)) {
 320         return false;
 321     }
 322     $mbx = sqimap_run_command($imap_stream, 'LIST "" ' . sqimap_encode_mailbox_name($mailbox),
 323                               true, $response, $message);
 324     return isset($mbx[0]);
 325 }
 326
 327 /**
 328  * Selects a mailbox
 329  * Before 1.3.0 used more arguments and returned data depended on those argumements.
 330  * @param stream $imap_stream imap connection resource
 331  * @param string $mailbox mailbox name
 332  * @return array results of select command (on success - permanentflags, flags and rights)
 333  * @since 1.0 or older
 334  */
 335 function sqimap_mailbox_select ($imap_stream, $mailbox) {
 336     if ($mailbox == 'None') {
 337         return;
 338     }
 339
 340     $read = sqimap_run_command($imap_stream, 'SELECT ' . sqimap_encode_mailbox_name($mailbox),
 341                                true, $response, $message);
 342     $result = array();
 343     for ($i = 0, $cnt = count($read); $i < $cnt; $i++) {
 344         if (preg_match('/^\*\s+OK\s\[(\w+)\s(\w+)\]/',$read[$i], $regs)) {
 345             $result[strtoupper($regs[1])] = $regs[2];
 346         } else if (preg_match('/^\*\s([0-9]+)\s(\w+)/',$read[$i], $regs)) {
 347             $result[strtoupper($regs[2])] = $regs[1];
 348         } else {
 349             if (preg_match("/PERMANENTFLAGS(.*)/i",$read[$i], $regs)) {
 350                 $regs[1]=trim(preg_replace (  array ("/\(/","/\)/","/\]/") ,'', $regs[1])) ;
 351                 $result['PERMANENTFLAGS'] = explode(' ',strtolower($regs[1]));
 352             } else if (preg_match("/FLAGS(.*)/i",$read[$i], $regs)) {
 353                 $regs[1]=trim(preg_replace (  array ("/\(/","/\)/") ,'', $regs[1])) ;
 354                 $result['FLAGS'] = explode(' ',strtolower($regs[1]));
 355             }
 356         }
 357     }
 358     if (!isset($result['PERMANENTFLAGS'])) {
 359         $result['PERMANENTFLAGS'] = $result['FLAGS'];
 360     }
 361     if (preg_match('/^\[(.+)\]/',$message, $regs)) {
 362         $result['RIGHTS']=strtoupper($regs[1]);
 363     }
 364
 365     return $result;
 366 }
 367
 368 /**
 369  * Creates a folder.
 370  *
 371  * Mailbox is automatically subscribed.
 372  *
 373  * Set $type to string that does not match 'noselect' (case insensitive),
 374  * if you don't want to prepend delimiter to mailbox name. Please note
 375  * that 'noinferiors' might be used someday as keyword for folders
 376  * that store only messages.
 377  * @param stream $imap_steam imap connection resource
 378  * @param string $mailbox mailbox name
 379  * @param string $type folder type.
 380  * @since 1.0 or older
 381  */
 382 function sqimap_mailbox_create ($imap_stream, $mailbox, $type) {
 383     global $delimiter;
 384     if (strtolower($type) == 'noselect') {
 385         $mailbox .= $delimiter;
 386     }
 387
 388     $read_ary = sqimap_run_command($imap_stream, 'CREATE ' .
 389                                    sqimap_encode_mailbox_name($mailbox),
 390                                    true, $response, $message);
 391     sqimap_subscribe ($imap_stream, $mailbox);
 392 }
 393
 394 /**
 395  * Subscribes to an existing folder.
 396  * @param stream $imap_stream imap connection resource
 397  * @param string $mailbox mailbox name
 398  * @param boolean $debug (since 1.5.1)
 399  * @since 1.0 or older
 400  */
 401 function sqimap_subscribe ($imap_stream, $mailbox,$debug=true) {
 402     $read_ary = sqimap_run_command($imap_stream, 'SUBSCRIBE ' .
 403                                    sqimap_encode_mailbox_name($mailbox),
 404                                    $debug, $response, $message);
 405 }
 406
 407 /**
 408  * Unsubscribes from an existing folder
 409  * @param stream $imap_stream imap connection resource
 410  * @param string $mailbox mailbox name
 411  * @since 1.0 or older
 412  */
 413 function sqimap_unsubscribe ($imap_stream, $mailbox) {
 414     $read_ary = sqimap_run_command($imap_stream, 'UNSUBSCRIBE ' .
 415                                    sqimap_encode_mailbox_name($mailbox),
 416                                    false, $response, $message);
 417 }
 418
 419 /**
 420  * Deletes the given folder
 421  * Since 1.2.6 and 1.3.0 contains rename_or_delete_folder hook
 422  * @param stream $imap_stream imap connection resource
 423  * @param string $mailbox mailbox name
 424  * @since 1.0 or older
 425  */
 426 function sqimap_mailbox_delete ($imap_stream, $mailbox) {
 427     global $data_dir, $username;
 428     sqimap_unsubscribe ($imap_stream, $mailbox);
 429     $read_ary = sqimap_run_command($imap_stream, 'DELETE ' .
 430                                    sqimap_encode_mailbox_name($mailbox),
 431                                    true, $response, $message);
 432     if ($response !== 'OK') {
 433         // subscribe again
 434         sqimap_subscribe ($imap_stream, $mailbox);
 435     } else {
 436         do_hook_function('rename_or_delete_folder', $args = array($mailbox, 'delete', ''));
 437         removePref($data_dir, $username, "thread_$mailbox");
 438         removePref($data_dir, $username, "collapse_folder_$mailbox");
 439     }
 440 }
 441
 442 /**
 443  * Determines if the user is subscribed to the folder or not
 444  * @param stream $imap_stream imap connection resource
 445  * @param string $mailbox mailbox name
 446  * @return boolean
 447  * @since 1.2.0
 448  */
 449 function sqimap_mailbox_is_subscribed($imap_stream, $folder) {
 450     $boxesall = sqimap_mailbox_list ($imap_stream);
 451     foreach ($boxesall as $ref) {
 452         if ($ref['unformatted'] == $folder) {
 453             return true;
 454         }
 455     }
 456     return false;
 457 }
 458
 459 /**
 460  * Renames a mailbox.
 461  * Since 1.2.6 and 1.3.0 contains rename_or_delete_folder hook
 462  * @param stream $imap_stream imap connection resource
 463  * @param string $old_name mailbox name
 464  * @param string $new_name new mailbox name
 465  * @since 1.2.3
 466  */
 467 function sqimap_mailbox_rename( $imap_stream, $old_name, $new_name ) {
 468     if ( $old_name != $new_name ) {
 469         global $delimiter, $imap_server_type, $data_dir, $username;
 470         if ( substr( $old_name, -1 ) == $delimiter  ) {
 471             $old_name = substr( $old_name, 0, strlen( $old_name ) - 1 );
 472             $new_name = substr( $new_name, 0, strlen( $new_name ) - 1 );
 473             $postfix = $delimiter;
 474         } else {
 475             $postfix = '';
 476         }
 477
 478         $boxesall = sqimap_mailbox_list_all($imap_stream);
 479         $cmd = 'RENAME ' . sqimap_encode_mailbox_name($old_name) .
 480                      ' ' . sqimap_encode_mailbox_name($new_name);
 481         $data = sqimap_run_command($imap_stream, $cmd, true, $response, $message);
 482         sqimap_unsubscribe($imap_stream, $old_name.$postfix);
 483         $oldpref_thread = getPref($data_dir, $username, 'thread_'.$old_name.$postfix);
 484         $oldpref_collapse = getPref($data_dir, $username, 'collapse_folder_'.$old_name.$postfix);
 485         removePref($data_dir, $username, 'thread_'.$old_name.$postfix);
 486         removePref($data_dir, $username, 'collapse_folder_'.$old_name.$postfix);
 487         sqimap_subscribe($imap_stream, $new_name.$postfix);
 488         setPref($data_dir, $username, 'thread_'.$new_name.$postfix, $oldpref_thread);
 489         setPref($data_dir, $username, 'collapse_folder_'.$new_name.$postfix, $oldpref_collapse);
 490         do_hook_function('rename_or_delete_folder',$args = array($old_name, 'rename', $new_name));
 491         $l = strlen( $old_name ) + 1;
 492         $p = 'unformatted';
 493
 494         foreach ($boxesall as $box) {
 495             if (substr($box[$p], 0, $l) == $old_name . $delimiter) {
 496                 $new_sub = $new_name . $delimiter . substr($box[$p], $l);
 497                 /* With Cyrus IMAPd >= 2.0 rename is recursive, so don't check for errors here */
 498                 if ($imap_server_type == 'cyrus') {
 499                     $cmd = 'RENAME "' . $box[$p] . '" "' . $new_sub . '"';
 500                     $data = sqimap_run_command($imap_stream, $cmd, false,
 501                                                $response, $message);
 502                 }
 503                 $was_subscribed = sqimap_mailbox_is_subscribed($imap_stream, $box[$p]);
 504                 if ( $was_subscribed ) {
 505                     sqimap_unsubscribe($imap_stream, $box[$p]);
 506                 }
 507                 $oldpref_thread = getPref($data_dir, $username, 'thread_'.$box[$p]);
 508                 $oldpref_collapse = getPref($data_dir, $username, 'collapse_folder_'.$box[$p]);
 509                 removePref($data_dir, $username, 'thread_'.$box[$p]);
 510                 removePref($data_dir, $username, 'collapse_folder_'.$box[$p]);
 511                 if ( $was_subscribed ) {
 512                     sqimap_subscribe($imap_stream, $new_sub);
 513                 }
 514                 setPref($data_dir, $username, 'thread_'.$new_sub, $oldpref_thread);
 515                 setPref($data_dir, $username, 'collapse_folder_'.$new_sub, $oldpref_collapse);
 516                 do_hook_function('rename_or_delete_folder',
 517                                  $args = array($box[$p], 'rename', $new_sub));
 518             }
 519         }
 520     }
 521 }
 522
 523 /**
 524  * Formats a mailbox into parts for the $boxesall array
 525  *
 526  * The parts are:
 527  * <ul>
 528  *   <li>raw            - Raw LIST/LSUB response from the IMAP server
 529  *   <li>formatted      - nicely formatted folder name
 530  *   <li>unformatted    - unformatted, but with delimiter at end removed
 531  *   <li>unformatted-dm - folder name as it appears in raw response
 532  *   <li>unformatted-disp - unformatted without $folder_prefix
 533  *   <li>id             - TODO: document me
 534  *   <li>flags          - TODO: document me
 535  * </ul>
 536  * Before 1.2.0 used third argument for delimiter.
 537  * @param $line
 538  * @param $line_lsub
 539  * @return array
 540  * @since 1.0 or older
 541  * @todo document id and flags keys in boxes array and function arguments.
 542  */
 543 function sqimap_mailbox_parse ($line, $line_lsub) {
 544     global $folder_prefix, $delimiter;
 545
 546     /* Process each folder line */
 547     for ($g = 0, $cnt = count($line); $g < $cnt; ++$g) {
 548         /* Store the raw IMAP reply */
 549         if (isset($line[$g])) {
 550             $boxesall[$g]['raw'] = $line[$g];
 551         } else {
 552             $boxesall[$g]['raw'] = '';
 553         }
 554
 555         /* Count number of delimiters ($delimiter) in folder name */
 556         $mailbox  = /*trim(*/$line_lsub[$g]/*)*/;
 557         $dm_count = substr_count($mailbox, $delimiter);
 558         if (substr($mailbox, -1) == $delimiter) {
 559             /* If name ends in delimiter, decrement count by one */
 560             $dm_count--;
 561         }
 562
 563         /* Format folder name, but only if it's a INBOX.* or has a parent. */
 564         $boxesallbyname[$mailbox] = $g;
 565         $parentfolder = readMailboxParent($mailbox, $delimiter);
 566         if ( (strtolower(substr($mailbox, 0, 5)) == "inbox") ||
 567              (substr($mailbox, 0, strlen($folder_prefix)) == $folder_prefix) ||
 568              (isset($boxesallbyname[$parentfolder]) &&
 569               (strlen($parentfolder) > 0) ) ) {
 570             $indent = $dm_count - (substr_count($folder_prefix, $delimiter));
 571             if ($indent > 0) {
 572                 $boxesall[$g]['formatted'] = str_repeat('&nbsp;&nbsp;', $indent);
 573             } else {
 574                 $boxesall[$g]['formatted'] = '';
 575             }
 576             $boxesall[$g]['formatted'] .= imap_utf7_decode_local(readShortMailboxName($mailbox, $delimiter));
 577         } else {
 578             $boxesall[$g]['formatted']  = imap_utf7_decode_local($mailbox);
 579         }
 580
 581         $boxesall[$g]['unformatted-dm'] = $mailbox;
 582         if (substr($mailbox, -1) == $delimiter) {
 583             $mailbox = substr($mailbox, 0, strlen($mailbox) - 1);
 584         }
 585         $boxesall[$g]['unformatted'] = $mailbox;
 586         if (substr($mailbox,0,strlen($folder_prefix))==$folder_prefix) {
 587             $mailbox = substr($mailbox, strlen($folder_prefix));
 588         }
 589         $boxesall[$g]['unformatted-disp'] = $mailbox;
 590         $boxesall[$g]['id'] = $g;
 591
 592         $boxesall[$g]['flags'] = array();
 593         if (isset($line[$g])) {
 594             ereg("\(([^)]*)\)",$line[$g],$regs);
 595             // FIXME Flags do contain the \ character. \NoSelect \NoInferiors
 596             // and $MDNSent <= last one doesn't have the \
 597             // It's better to follow RFC3501 instead of using our own naming.
 598             $flags = trim(strtolower(str_replace('\\', '',$regs[1])));
 599             if ($flags) {
 600                 $boxesall[$g]['flags'] = explode(' ', $flags);
 601             }
 602         }
 603     }
 604     return $boxesall;
 605 }
 606
 607 /**
 608  * Returns list of options (to be echoed into select statement
 609  * based on available mailboxes and separators
 610  * Caller should surround options with <select ...> </select> and
 611  * any formatting.
 612  * @param stream $imap_stream imap connection resource to query for mailboxes
 613  * @param array $show_selected array containing list of mailboxes to pre-select (0 if none)
 614  * @param array $folder_skip array of folders to keep out of option list (compared in lower)
 615  * @param $boxes list of already fetched boxes (for places like folder panel, where
 616  *            you know these options will be shown 3 times in a row.. (most often unset).
 617  * @param string $flag (since 1.4.1) flag to check for in mailbox flags, used to filter out mailboxes.
 618  *           'noselect' by default to remove unselectable mailboxes.
 619  *           'noinferiors' used to filter out folders that can not contain subfolders.
 620  *           NULL to avoid flag check entirely.
 621  *           NOTE: noselect and noiferiors are used internally. The IMAP representation is
 622  *                 \NoSelect and \NoInferiors
 623  * @param boolean $use_long_format (since 1.4.1) override folder display preference and always show full folder name.
 624  * @return string html formated mailbox selection options
 625  * @since 1.3.2
 626  */
 627 function sqimap_mailbox_option_list($imap_stream, $show_selected = 0, $folder_skip = 0, $boxes = 0,
 628                                     $flag = 'noselect', $use_long_format = false ) {
 629     global $username, $data_dir;
 630     $mbox_options = '';
 631     if ( $use_long_format ) {
 632         $shorten_box_names = 0;
 633     } else {
 634         $shorten_box_names = getPref($data_dir, $username, 'mailbox_select_style', SMPREF_OFF);
 635     }
 636
 637     if ($boxes == 0) {
 638         $boxes = sqimap_mailbox_list($imap_stream);
 639     }
 640
 641     foreach ($boxes as $boxes_part) {
 642         if ($flag == NULL || (is_array($boxes_part['flags'])
 643                       && !in_array($flag, $boxes_part['flags']))) {
 644             $box = $boxes_part['unformatted'];
 645
 646             if ($folder_skip != 0 && in_array($box, $folder_skip) ) {
 647                 continue;
 648             }
 649             $lowerbox = strtolower($box);
 650             // mailboxes are casesensitive => inbox.sent != inbox.Sent
 651             // nevermind, to many dependencies this should be fixed!
 652
 653             if (strtolower($box) == 'inbox') { // inbox is special and not casesensitive
 654                 $box2 = _("INBOX");
 655             } else {
 656                 switch ($shorten_box_names)
 657                 {
 658                   case 2:   /* delimited, style = 2 */
 659                     $box2 = str_replace('&amp;nbsp;&amp;nbsp;', '.&nbsp;', htmlspecialchars($boxes_part['formatted']));
 660                     break;
 661                   case 1:   /* indent, style = 1 */
 662                     $box2 = str_replace('&amp;nbsp;&amp;nbsp;', '&nbsp;&nbsp;', htmlspecialchars($boxes_part['formatted']));
 663                     break;
 664                   default:  /* default, long names, style = 0 */
 665                     $box2 = str_replace(' ', '&nbsp;', htmlspecialchars(imap_utf7_decode_local($boxes_part['unformatted-disp'])));
 666                     break;
 667                 }
 668             }
 669             if ($show_selected != 0 && in_array($lowerbox, $show_selected) ) {
 670                 $mbox_options .= '<option value="' . htmlspecialchars($box) .'" selected="selected">'.$box2.'</option>' . "\n";
 671             } else {
 672                 $mbox_options .= '<option value="' . htmlspecialchars($box) .'">'.$box2.'</option>' . "\n";
 673             }
 674         }
 675     }
 676     return $mbox_options;
 677 }
 678
 679 /**
 680  * Returns sorted mailbox lists in several different ways.
 681  * See comment on sqimap_mailbox_parse() for info about the returned array.
 682  * @param resource $imap_stream imap connection resource
 683  * @param boolean $force force update of mailbox listing. available since 1.4.2 and 1.5.0
 684  * @return array list of mailboxes
 685  * @since 1.0 or older
 686  */
 687 function sqimap_mailbox_list($imap_stream, $force=false) {
 688     if (!sqgetGlobalVar('boxesnew',$boxesnew,SQ_SESSION) || $force) {
 689         global $data_dir, $username, $list_special_folders_first,
 690                $folder_prefix, $trash_folder, $sent_folder, $draft_folder,
 691                $move_to_trash, $move_to_sent, $save_as_draft,
 692                $delimiter, $noselect_fix_enable, $imap_server_type,
 693                $show_only_subscribed_folders;
 694         $inbox_subscribed = false;
 695         $listsubscribed = sqimap_capability($imap_stream,'LIST-SUBSCRIBED');
 696
 697         require_once(SM_PATH . 'include/load_prefs.php');
 698
 699         if (!$show_only_subscribed_folders) {
 700             $lsub = 'LIST';
 701         } elseif ($listsubscribed) {
 702             $lsub = 'LIST (SUBSCRIBED)';
 703         } else {
 704             $lsub = 'LSUB';
 705         }
 706
 707         if ($noselect_fix_enable) {
 708             $lsub_args = "$lsub \"$folder_prefix\" \"*%\"";
 709         } else {
 710             $lsub_args = "$lsub \"$folder_prefix\" \"*\"";
 711         }
 712         /* LSUB array */
 713         $lsub_ary = sqimap_run_command ($imap_stream, $lsub_args,
 714                                         true, $response, $message);
 715         $lsub_ary = compact_mailboxes_response($lsub_ary);
 716
 717         $sorted_lsub_ary = array();
 718         for ($i = 0, $cnt = count($lsub_ary);$i < $cnt; $i++) {
 719
 720             $temp_mailbox_name = find_mailbox_name($lsub_ary[$i]);
 721             $sorted_lsub_ary[] = $temp_mailbox_name;
 722             if (!$inbox_subscribed && strtoupper($temp_mailbox_name) == 'INBOX') {
 723                 $inbox_subscribed = true;
 724             }
 725         }
 726
 727         /* natural sort mailboxes */
 728         if (isset($sorted_lsub_ary)) {
 729             usort($sorted_lsub_ary, 'strnatcasecmp');
 730         }
 731         /*
 732          * The LSUB response doesn't provide us information about \Noselect
 733          * mail boxes. The LIST response does, that's why we need to do a LIST
 734          * call to retrieve the flags for the mailbox
 735            * Note: according RFC2060 an imap server may provide \NoSelect flags in the LSUB response.
 736            * in other words, we cannot rely on it.
 737          */
 738         $sorted_list_ary = array();
 739  //       if (!$listsubscribed) {
 740           for ($i=0; $i < count($sorted_lsub_ary); $i++) {
 741             if (substr($sorted_lsub_ary[$i], -1) == $delimiter) {
 742                 $mbx = substr($sorted_lsub_ary[$i], 0, strlen($sorted_lsub_ary[$i])-1);
 743             }
 744             else {
 745                 $mbx = $sorted_lsub_ary[$i];
 746             }
 747
 748             $read = sqimap_run_command ($imap_stream, 'LIST "" ' . sqimap_encode_mailbox_name($mbx),
 749                                         true, $response, $message);
 750
 751             $read = compact_mailboxes_response($read);
 752
 753             if (isset($read[0])) {
 754                 $sorted_list_ary[$i] = $read[0];
 755             } else {
 756                 $sorted_list_ary[$i] = '';
 757             }
 758           }
 759  //       }
 760         /*
 761          * Just in case they're not subscribed to their inbox,
 762          * we'll get it for them anyway
 763          */
 764         if (!$inbox_subscribed) {
 765             $inbox_ary = sqimap_run_command ($imap_stream, 'LIST "" "INBOX"',
 766                                              true, $response, $message);
 767             $sorted_list_ary[] = implode('',compact_mailboxes_response($inbox_ary));
 768             $sorted_lsub_ary[] = find_mailbox_name($inbox_ary[0]);
 769         }
 770
 771         $boxesall = sqimap_mailbox_parse ($sorted_list_ary, $sorted_lsub_ary);
 772
 773         /* Now, lets sort for special folders */
 774         $boxesnew = $used = array();
 775
 776         /* Find INBOX */
 777         $cnt = count($boxesall);
 778         $used = array_pad($used,$cnt,false);
 779         for($k = 0; $k < $cnt; ++$k) {
 780             if (strtolower($boxesall[$k]['unformatted']) == 'inbox') {
 781                 $boxesnew[] = $boxesall[$k];
 782                 $used[$k] = true;
 783                 break;
 784             }
 785         }
 786         /* List special folders and their subfolders, if requested. */
 787         if ($list_special_folders_first) {
 788             for($k = 0; $k < $cnt; ++$k) {
 789                 if (!$used[$k] && isSpecialMailbox($boxesall[$k]['unformatted'])) {
 790                     $boxesnew[] = $boxesall[$k];
 791                     $used[$k]   = true;
 792                 }
 793             }
 794         }
 795
 796         /* Find INBOX's children */
 797         for($k = 0; $k < $cnt; ++$k) {
 798             if (!$used[$k] && isBoxBelow(strtolower($boxesall[$k]['unformatted']), 'inbox') &&
 799             strtolower($boxesall[$k]['unformatted']) != 'inbox') {
 800                 $boxesnew[] = $boxesall[$k];
 801                 $used[$k] = true;
 802             }
 803         }
 804
 805         /* Rest of the folders */
 806         for($k = 0; $k < $cnt; $k++) {
 807             if (!$used[$k]) {
 808                 $boxesnew[] = $boxesall[$k];
 809             }
 810         }
 811         sqsession_register($boxesnew,'boxesnew');
 812     }
 813     return $boxesnew;
 814 }
 815
 816 /**
 817  * Returns a list of all folders, subscribed or not
 818  * @param stream $imap_stream imap connection resource
 819  * @return array see sqimap_mailbox_parse()
 820  * @since 1.0 or older
 821  */
 822 function sqimap_mailbox_list_all($imap_stream) {
 823     global $list_special_folders_first, $folder_prefix, $delimiter;
 824
 825     $read_ary = sqimap_run_command($imap_stream,"LIST \"$folder_prefix\" *",true,$response, $message,false);
 826     $read_ary = compact_mailboxes_response($read_ary);
 827
 828     $g = 0;
 829     $fld_pre_length = strlen($folder_prefix);
 830     for ($i = 0, $cnt = count($read_ary); $i < $cnt; $i++) {
 831         /* Store the raw IMAP reply */
 832         $boxes[$g]['raw'] = $read_ary[$i];
 833
 834         /* Count number of delimiters ($delimiter) in folder name */
 835         $mailbox = find_mailbox_name($read_ary[$i]);
 836         $dm_count =  substr_count($mailbox, $delimiter);
 837         if (substr($mailbox, -1) == $delimiter) {
 838             /* If name ends in delimiter - decrement count by one */
 839             $dm_count--;
 840         }
 841
 842         /* Format folder name, but only if it's a INBOX.* or has a parent. */
 843         $boxesallbyname[$mailbox] = $g;
 844         $parentfolder = readMailboxParent($mailbox, $delimiter);
 845         if((eregi('^inbox'.quotemeta($delimiter), $mailbox)) ||
 846            (ereg('^'.$folder_prefix, $mailbox)) ||
 847            ( isset($boxesallbyname[$parentfolder]) && (strlen($parentfolder) > 0) ) ) {
 848             if ($dm_count) {
 849                 $boxes[$g]['formatted']  = str_repeat('&nbsp;&nbsp;', $dm_count);
 850             } else {
 851                 $boxes[$g]['formatted'] = '';
 852             }
 853             $boxes[$g]['formatted'] .= imap_utf7_decode_local(readShortMailboxName($mailbox, $delimiter));
 854         } else {
 855             $boxes[$g]['formatted']  = imap_utf7_decode_local($mailbox);
 856         }
 857
 858         $boxes[$g]['unformatted-dm'] = $mailbox;
 859         if (substr($mailbox, -1) == $delimiter) {
 860             $mailbox = substr($mailbox, 0, strlen($mailbox) - 1);
 861         }
 862         $boxes[$g]['unformatted'] = $mailbox;
 863         $boxes[$g]['unformatted-disp'] = substr($mailbox,$fld_pre_length);
 864
 865         $boxes[$g]['id'] = $g;
 866
 867         /* Now lets get the flags for this mailbox */
 868         $read_mlbx = $read_ary[$i];
 869         $flags = substr($read_mlbx, strpos($read_mlbx, '(')+1);
 870         $flags = substr($flags, 0, strpos($flags, ')'));
 871         $flags = str_replace('\\', '', $flags);
 872         $flags = trim(strtolower($flags));
 873         if ($flags) {
 874             $boxes[$g]['flags'] = explode(' ', $flags);
 875         } else {
 876             $boxes[$g]['flags'] = array();
 877         }
 878         $g++;
 879     }
 880     if(is_array($boxes)) {
 881         sort ($boxes);
 882     }
 883
 884     return $boxes;
 885 }
 886
 887 /**
 888  * @param stream $imap_stream imap connection resource
 889  * @return object see mailboxes class.
 890  * @since 1.3.0
 891  */
 892 function sqimap_mailbox_tree($imap_stream) {
 893     global $default_folder_prefix;
 894     if (true) {
 895         global $data_dir, $username, $list_special_folders_first,
 896                $folder_prefix, $delimiter, $trash_folder, $move_to_trash,
 897                $imap_server_type, $show_only_subscribed_folders;
 898
 899         $noselect = false;
 900         $noinferiors = false;
 901
 902         require_once(SM_PATH . 'include/load_prefs.php');
 903
 904         if ($show_only_subscribed_folders) {
 905             $lsub_cmd = 'LSUB';
 906         } else {
 907             $lsub_cmd = 'LIST';
 908         }
 909
 910         /* LSUB array */
 911         $lsub_ary = sqimap_run_command ($imap_stream, "$lsub_cmd \"$folder_prefix\" \"*\"",
 912                                         true, $response, $message);
 913         $lsub_ary = compact_mailboxes_response($lsub_ary);
 914
 915         /* Check to see if we have an INBOX */
 916         $has_inbox = false;
 917
 918         for ($i = 0, $cnt = count($lsub_ary); $i < $cnt; $i++) {
 919             if (preg_match("/^\*\s+$lsub_cmd.*\s\"?INBOX\"?[^(\/\.)].*$/i",$lsub_ary[$i])) {
 920                 $lsub_ary[$i] = strtoupper($lsub_ary[$i]);
 921                 // in case of an unsubscribed inbox an imap server can
 922                 // return the inbox in the lsub results with a \NoSelect
 923                 // flag.
 924                 if (!preg_match("/\*\s+$lsub_cmd\s+\(.*\\\\NoSelect.*\).*/i",$lsub_ary[$i])) {
 925                     $has_inbox = true;
 926                 } else {
 927                     // remove the result and request it again  with a list
 928                     // response at a later stage.
 929                     unset($lsub_ary[$i]);
 930                     // re-index the array otherwise the addition of the LIST
 931                     // response will fail in PHP 4.1.2 and probably other older versions
 932                     $lsub_ary = array_values($lsub_ary);
 933                 }
 934                 break;
 935             }
 936         }
 937
 938         if ($has_inbox == false) {
 939             // do a list request for inbox because we should always show
 940             // inbox even if the user isn't subscribed to it.
 941             $inbox_ary = sqimap_run_command ($imap_stream, 'LIST "" "INBOX"',
 942                                              true, $response, $message);
 943             $inbox_ary = compact_mailboxes_response($inbox_ary);
 944             if (count($inbox_ary)) {
 945                 $lsub_ary[] = $inbox_ary[0];
 946             }
 947         }
 948
 949         /*
 950          * Section about removing the last element was removed
 951          * We don't return "* OK" anymore from sqimap_read_data
 952          */
 953
 954         $sorted_lsub_ary = array();
 955         $cnt = count($lsub_ary);
 956         for ($i = 0; $i < $cnt; $i++) {
 957             $mbx = find_mailbox_name($lsub_ary[$i]);
 958
 959             // only do the noselect test if !uw, is checked later. FIX ME see conf.pl setting
 960             if ($imap_server_type != "uw") {
 961                 $noselect = check_is_noselect($lsub_ary[$i]);
 962                 $noinferiors = check_is_noinferiors($lsub_ary[$i]);
 963             }
 964             if (substr($mbx, -1) == $delimiter) {
 965                 $mbx = substr($mbx, 0, strlen($mbx) - 1);
 966             }
 967             $sorted_lsub_ary[] = array ('mbx' => $mbx, 'noselect' => $noselect, 'noinferiors' => $noinferiors);
 968         }
 969         // FIX ME this requires a config setting inside conf.pl instead of checking on server type
 970         if ($imap_server_type == "uw") {
 971            $aQuery = array();
 972            $aTag = array();
 973            // prepare an array with queries
 974            foreach ($sorted_lsub_ary as $aMbx) {
 975                $mbx = stripslashes($aMbx['mbx']);
 976                sqimap_prepare_pipelined_query('LIST "" ' . sqimap_encode_mailbox_name($mbx), $tag, $aQuery, false);
 977                $aTag[$tag] = $mbx;
 978            }
 979            $sorted_lsub_ary = array();
 980            // execute all the queries at once
 981            $aResponse = sqimap_run_pipelined_command ($imap_stream, $aQuery, false, $aServerResponse, $aServerMessage);
 982            foreach($aTag as $tag => $mbx) {
 983                if ($aServerResponse[$tag] == 'OK') {
 984                    $sResponse = implode('', $aResponse[$tag]);
 985                    $noselect = check_is_noselect($sResponse);
 986                    $noinferiors = check_is_noinferiors($sResponse);
 987                    $sorted_lsub_ary[] = array ('mbx' => $mbx, 'noselect' => $noselect, 'noinferiors' => $noinferiors);
 988                }
 989            }
 990            $cnt = count($sorted_lsub_ary);
 991        }
 992        $sorted_lsub_ary = array_values($sorted_lsub_ary);
 993        usort($sorted_lsub_ary, 'mbxSort');
 994        $boxestree = sqimap_fill_mailbox_tree($sorted_lsub_ary,false,$imap_stream);
 995        return $boxestree;
 996     }
 997 }
 998
 999 /**
1000  * Callback function used for sorting mailboxes in sqimap_mailbox_tree
1001  * @param string $a
1002  * @param string $b
1003  * @return integer see php strnatcasecmp()
1004  * @since 1.5.1
1005  */
1006 function mbxSort($a, $b) {
1007     return strnatcasecmp($a['mbx'], $b['mbx']);
1008 }
1009
1010 /**
1011  * @param array $mbx_ary
1012  * @param $mbxs
1013  * @param stream $imap_stream (since 1.5.0) imap connection resource
1014  * @return object see mailboxes class
1015  * @since 1.3.0
1016  */
1017 function sqimap_fill_mailbox_tree($mbx_ary, $mbxs=false,$imap_stream) {
1018     global $data_dir, $username, $list_special_folders_first,
1019            $folder_prefix, $trash_folder, $sent_folder, $draft_folder,
1020            $move_to_trash, $move_to_sent, $save_as_draft,
1021            $delimiter, $imap_server_type;
1022
1023     // $special_folders = array ('INBOX', $sent_folder, $draft_folder, $trash_folder);
1024
1025     /* create virtual root node */
1026     $mailboxes= new mailboxes();
1027     $mailboxes->is_root = true;
1028     $trail_del = false;
1029     $start = 0;
1030
1031
1032     if (isset($folder_prefix) && ($folder_prefix != '')) {
1033         $start = substr_count($folder_prefix,$delimiter);
1034         if (strrpos($folder_prefix, $delimiter) == (strlen($folder_prefix)-1)) {
1035             $mailboxes->mailboxname_full = substr($folder_prefix,0, (strlen($folder_prefix)-1));
1036         } else {
1037             $mailboxes->mailboxname_full = $folder_prefix;
1038             $start++;
1039         }
1040         $mailboxes->mailboxname_sub = $mailboxes->mailboxname_full;
1041     } else {
1042         $start = 0;
1043     }
1044
1045     $cnt = count($mbx_ary);
1046     for ($i=0; $i < $cnt; $i++) {
1047         if ($mbx_ary[$i]['mbx'] !='' ) {
1048             $mbx = new mailboxes();
1049             $mailbox = $mbx_ary[$i]['mbx'];
1050
1051             /*
1052              * Set the is_special flag if it concerned a special mailbox.
1053              * Used for displaying the special folders on top in the mailbox
1054              * tree displaying code.
1055              */
1056             $mbx->is_special |= ($mbx->is_inbox = (strtoupper($mailbox) == 'INBOX'));
1057             $mbx->is_special |= ($mbx->is_trash = isTrashMailbox($mailbox));
1058             $mbx->is_special |= ($mbx->is_sent = isSentMailbox($mailbox));
1059             $mbx->is_special |= ($mbx->is_draft = isDraftMailbox($mailbox));
1060
1061             if (!$mbx->is_special)
1062                 $mbx->is_special = boolean_hook_function('special_mailbox', $mailbox, 1);
1063
1064             if (isset($mbx_ary[$i]['unseen'])) {
1065                 $mbx->unseen = $mbx_ary[$i]['unseen'];
1066             }
1067             if (isset($mbx_ary[$i]['nummessages'])) {
1068                 $mbx->total = $mbx_ary[$i]['nummessages'];
1069             }
1070
1071             $mbx->is_noselect = $mbx_ary[$i]['noselect'];
1072             $mbx->is_noinferiors = $mbx_ary[$i]['noinferiors'];
1073
1074             $r_del_pos = strrpos($mbx_ary[$i]['mbx'], $delimiter);
1075             if ($r_del_pos) {
1076                 $mbx->mailboxname_sub = substr($mbx_ary[$i]['mbx'],$r_del_pos+1);
1077             } else {   /* mailbox is root folder */
1078                 $mbx->mailboxname_sub = $mbx_ary[$i]['mbx'];
1079             }
1080             $mbx->mailboxname_full = $mbx_ary[$i]['mbx'];
1081
1082             $mailboxes->addMbx($mbx, $delimiter, $start, $list_special_folders_first);
1083         }
1084     }
1085     sqimap_utf7_decode_mbx_tree($mailboxes);
1086     sqimap_get_status_mbx_tree($imap_stream,$mailboxes);
1087     return $mailboxes;
1088 }
1089
1090 /**
1091  * @param object $mbx_tree
1092  * @since 1.5.0
1093  */
1094 function sqimap_utf7_decode_mbx_tree(&$mbx_tree) {
1095    if (strtoupper($mbx_tree->mailboxname_full) == 'INBOX')
1096        $mbx_tree->mailboxname_sub = _("INBOX");
1097    else
1098        $mbx_tree->mailboxname_sub = imap_utf7_decode_local($mbx_tree->mailboxname_sub);
1099    if ($mbx_tree->mbxs) {
1100       $iCnt = count($mbx_tree->mbxs);
1101       for ($i=0;$i<$iCnt;++$i) {
1102           $mbxs_tree->mbxs[$i] = sqimap_utf7_decode_mbx_tree($mbx_tree->mbxs[$i]);
1103       }
1104    }
1105 }
1106
1107 /**
1108  * @param object $mbx_tree
1109  * @param array $aMbxs
1110  * @since 1.5.0
1111  */
1112 function sqimap_tree_to_ref_array(&$mbx_tree,&$aMbxs) {
1113    if ($mbx_tree)
1114    $aMbxs[] =& $mbx_tree;
1115    if ($mbx_tree->mbxs) {
1116       $iCnt = count($mbx_tree->mbxs);
1117       for ($i=0;$i<$iCnt;++$i) {
1118          sqimap_tree_to_ref_array($mbx_tree->mbxs[$i],$aMbxs);
1119       }
1120    }
1121 }
1122
1123 /**
1124  * @param stream $imap_stream imap connection resource
1125  * @param object $mbx_tree
1126  * @since since 1.5.0
1127  */
1128 function sqimap_get_status_mbx_tree($imap_stream,&$mbx_tree) {
1129     global $unseen_notify, $unseen_type, $trash_folder,$move_to_trash;
1130     $aMbxs = $aQuery = array();
1131     sqimap_tree_to_ref_array($mbx_tree,$aMbxs);
1132     // remove the root node
1133     array_shift($aMbxs);
1134
1135     if($unseen_notify == 3) {
1136         $cnt = count($aMbxs);
1137         for($i=0;$i<$cnt;++$i) {
1138             $oMbx =& $aMbxs[$i];
1139             if (!$oMbx->is_noselect) {
1140                 $mbx = $oMbx->mailboxname_full;
1141                 if ($unseen_type == 2 ||
1142                    ($move_to_trash && $oMbx->mailboxname_full == $trash_folder)) {
1143                    $query = 'STATUS ' . sqimap_encode_mailbox_name($mbx) . ' (MESSAGES UNSEEN)';
1144                 } else {
1145                    $query = 'STATUS ' . sqimap_encode_mailbox_name($mbx) . ' (UNSEEN)';
1146                 }
1147                 sqimap_prepare_pipelined_query($query,$tag,$aQuery,false);
1148             } else {
1149                 $oMbx->unseen = $oMbx->total = false;
1150                 $tag = false;
1151             }
1152             $oMbx->tag = $tag;
1153             $aMbxs[$i] =& $oMbx;
1154         }
1155         // execute all the queries at once
1156         $aResponse = sqimap_run_pipelined_command ($imap_stream, $aQuery, false, $aServerResponse, $aServerMessage);
1157         $cnt = count($aMbxs);
1158         for($i=0;$i<$cnt;++$i) {
1159             $oMbx =& $aMbxs[$i];
1160             $tag = $oMbx->tag;
1161             if ($tag && $aServerResponse[$tag] == 'OK') {
1162                 $sResponse = implode('', $aResponse[$tag]);
1163                 if (preg_match('/UNSEEN\s+([0-9]+)/i', $sResponse, $regs)) {
1164                     $oMbx->unseen = $regs[1];
1165                 }
1166                 if (preg_match('/MESSAGES\s+([0-9]+)/i', $sResponse, $regs)) {
1167                     $oMbx->total = $regs[1];
1168                 }
1169            }
1170            unset($oMbx->tag);
1171         }
1172     } else if ($unseen_notify == 2) { // INBOX only
1173         $cnt = count($aMbxs);
1174         for($i=0;$i<$cnt;++$i) {
1175             $oMbx =& $aMbxs[$i];
1176             if (strtoupper($oMbx->mailboxname_full) == 'INBOX' ||
1177                ($move_to_trash && $oMbx->mailboxname_full == $trash_folder)) {
1178                  if ($unseen_type == 2 ||
1179                    ($oMbx->mailboxname_full == $trash_folder && $move_to_trash)) {
1180                     $aStatus = sqimap_status_messages($imap_stream,$oMbx->mailboxname_full);
1181                     $oMbx->unseen = $aStatus['UNSEEN'];
1182                     $oMbx->total  = $aStatus['MESSAGES'];
1183                 } else {
1184                     $oMbx->unseen = sqimap_unseen_messages($imap_stream,$oMbx->mailboxname_full);
1185                 }
1186                 $aMbxs[$i] =& $oMbx;
1187                 if (!$move_to_trash && $trash_folder) {
1188                     break;
1189                 } else {
1190                    // trash comes after INBOX
1191                    if ($oMbx->mailboxname_full == $trash_folder) {
1192                       break;
1193                    }
1194                 }
1195             }
1196         }
1197     }
1198 }
1199
1200 ?>