functions/imap_mailbox.php

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