functions/imap_mailbox.php

   1 <?php
   2
   3 /**
   4  * imap_mailbox.php
   5  *
   6  * Copyright (c) 1999-2003 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  * $Id$
  12  */
  13 require_once(SM_PATH . 'functions/imap_utf7_local.php');
  14
  15 global $boxesnew;
  16
  17 class mailboxes {
  18     var $mailboxname_full = '', $mailboxname_sub= '', $is_noselect = false,
  19         $is_special = false, $is_root = false, $is_inbox = false, $is_sent = false,
  20         $is_trash = false, $is_draft = false,  $mbxs = array(),
  21         $unseen = false, $total = false;
  22
  23     function addMbx($mbx, $delimiter, $start, $specialfirst) {
  24         $ary = explode($delimiter, $mbx->mailboxname_full);
  25         $mbx_parent =& $this;
  26         for ($i = $start, $c = count($ary)-1; $i < $c; $i++) {
  27             $mbx_childs =& $mbx_parent->mbxs;
  28             $found = false;
  29             if ($mbx_childs) {
  30                 foreach ($mbx_childs as $key => $parent) {
  31                     if ($parent->mailboxname_sub == $ary[$i]) {
  32                         $mbx_parent =& $mbx_parent->mbxs[$key];
  33                         $found = true;
  34                         break;
  35                     }
  36                 }
  37             }
  38             if (!$found) {
  39                 $no_select_mbx = new mailboxes();
  40                 if (isset($mbx_parent->mailboxname_full) && $mbx_parent->mailboxname_full != '') {
  41                     $no_select_mbx->mailboxname_full = $mbx_parent->mailboxname_full.$delimiter.$ary[$i];
  42                 } else {
  43                     $no_select_mbx->mailboxname_full = $ary[$i];
  44                 }
  45                 $no_select_mbx->mailboxname_sub = $ary[$i];
  46                 $no_select_mbx->is_noselect = true;
  47                 $mbx_parent->mbxs[] = $no_select_mbx;
  48                 $i--;
  49             }
  50         }
  51         $mbx_parent->mbxs[] = $mbx;
  52         if ($mbx->is_special && $specialfirst) {
  53             usort($mbx_parent->mbxs, 'sortSpecialMbx');
  54         }
  55     }
  56 }
  57
  58 function sortSpecialMbx($a, $b) {
  59     if ($a->is_inbox) {
  60         $acmp = '0'. $a->mailboxname_full;
  61     } else if ($a->is_special) {
  62         $acmp = '1'. $a->mailboxname_full;
  63     } else {
  64         $acmp = '2' . $a->mailboxname_full;
  65     }
  66     if ($b->is_inbox) {
  67         $bcmp = '0'. $b->mailboxname_full;
  68     }else if ($b->is_special) {
  69         $bcmp = '1' . $b->mailboxname_full;
  70     } else {
  71         $bcmp = '2' . $b->mailboxname_full;
  72     }
  73     if ($acmp == $bcmp) return 0;
  74     return ($acmp > $bcmp) ? 1: -1;
  75 }
  76
  77 function find_mailbox_name ($mailbox) {
  78     if (preg_match('/\*.+\"([^\r\n\"]*)\"[\s\r\n]*$/', $mailbox, $regs))
  79         return $regs[1];
  80     if (ereg(" *\"([^\r\n\"]*)\"[ \r\n]*$", $mailbox, $regs))
  81         return $regs[1];
  82     ereg(" *([^ \r\n\"]*)[ \r\n]*$",$mailbox,$regs);
  83     return $regs[1];
  84 }
  85
  86 function check_is_noselect ($lsub_line) {
  87     return preg_match("/^\* (LSUB|LIST) \([^\)]*\\Noselect[^\)]*\)/i", $lsub_line);
  88 }
  89
  90 /**
  91  * If $haystack is a full mailbox name, and $needle is the mailbox
  92  * separator character, returns the second last part of the full
  93  * mailbox name (i.e. the mailbox's parent mailbox)
  94  */
  95 function readMailboxParent($haystack, $needle) {
  96     if ($needle == '') {
  97         $ret = '';
  98     } else {
  99         $parts = explode($needle, $haystack);
 100         $elem = array_pop($parts);
 101         while ($elem == '' && count($parts)) {
 102             $elem = array_pop($parts);
 103         }
 104         $ret = join($needle, $parts);
 105     }
 106     return( $ret );
 107 }
 108
 109 /**
 110  * Check if $subbox is below the specified $parentbox
 111  */
 112 function isBoxBelow( $subbox, $parentbox ) {
 113     global $delimiter;
 114     /*
 115      * Eliminate the obvious mismatch, where the
 116      * subfolder path is shorter than that of the potential parent
 117      */
 118     if ( strlen($subbox) < strlen($parentbox) ) {
 119       return false;
 120     }
 121     /* check for delimiter */
 122         if (!substr($parentbox,-1) == $delimiter) {
 123             $parentbox.=$delimiter;
 124         }
 125         if (substr($subbox,0,strlen($parentbox)) == $parentbox) {
 126             return true;
 127         } else {
 128             return false;
 129         }
 130 }
 131
 132 /* Defines special mailboxes */
 133 function isSpecialMailbox( $box ) {
 134     global $trash_folder, $sent_folder, $draft_folder,
 135            $move_to_trash, $move_to_sent, $save_as_draft;
 136
 137     $ret = ( (strtolower($box) == 'inbox') ||
 138              isTrashMailbox($box) || isSentMailbox($box) || isDraftMailbox($box) );
 139
 140     if ( !$ret ) {
 141         $ret = do_hook_function( 'special_mailbox', $box );
 142     }
 143     return $ret;
 144 }
 145
 146 function isTrashMailbox ($box) {
 147     global $trash_folder, $move_to_trash;
 148     return $move_to_trash && $trash_folder &&
 149            ( $box == $trash_folder || isBoxBelow($box, $trash_folder) );
 150 }
 151
 152 function isSentMailbox($box) {
 153    global $sent_folder, $move_to_sent;
 154    return $move_to_sent && $sent_folder &&
 155           ( $box == $sent_folder || isBoxBelow($box, $sent_folder) );
 156 }
 157
 158 function isDraftMailbox($box) {
 159    global $draft_folder, $save_as_draft;
 160    return $save_as_draft &&
 161           ( $box == $draft_folder || isBoxBelow($box, $draft_folder) );
 162 }
 163
 164 /* Expunges a mailbox */
 165 function sqimap_mailbox_expunge ($imap_stream, $mailbox, $handle_errors = true, $id='') {
 166     global $uid_support;
 167     if ($id) {
 168         if (is_array($id)) {
 169             $id = sqimap_message_list_squisher($id);
 170         }
 171         $id = ' '.$id;
 172         $uid = $uid_support;
 173     } else {
 174         $uid = false;
 175     }
 176     $read = sqimap_run_command($imap_stream, 'EXPUNGE'.$id, $handle_errors,
 177                                $response, $message, $uid);
 178     $cnt = 0;
 179
 180     if (is_array($read)) {
 181         foreach ($read as $r) {
 182             if (preg_match('/^\*\s[0-9]+\sEXPUNGE/AUi',$r,$regs)) {
 183                 $cnt++;
 184             }
 185         }
 186     }
 187     return $cnt;
 188 }
 189
 190 /* Checks whether or not the specified mailbox exists */
 191 function sqimap_mailbox_exists ($imap_stream, $mailbox) {
 192     if (!isset($mailbox) || empty($mailbox)) {
 193         return false;
 194     }
 195     $mbx = sqimap_run_command($imap_stream, "LIST \"\" \"$mailbox\"",
 196                               true, $response, $message);
 197     return isset($mbx[0]);
 198 }
 199
 200 /* Selects a mailbox */
 201 function sqimap_mailbox_select ($imap_stream, $mailbox) {
 202     global $auto_expunge;
 203
 204     if ($mailbox == 'None') {
 205         return;
 206     }
 207
 208     $read = sqimap_run_command($imap_stream, "SELECT \"$mailbox\"",
 209                                true, $response, $message);
 210     $result = array();
 211     for ($i = 0, $cnt = count($read); $i < $cnt; $i++) {
 212         if (preg_match('/^\*\s+OK\s\[(\w+)\s(\w+)\]/',$read[$i], $regs)) {
 213             $result[strtoupper($regs[1])] = $regs[2];
 214         } else if (preg_match('/^\*\s([0-9]+)\s(\w+)/',$read[$i], $regs)) {
 215             $result[strtoupper($regs[2])] = $regs[1];
 216         } else {
 217             if (preg_match("/PERMANENTFLAGS(.*)/i",$read[$i], $regs)) {
 218                 $regs[1]=trim(preg_replace (  array ("/\(/","/\)/","/\]/") ,'', $regs[1])) ;
 219                 $result['PERMANENTFLAGS'] = $regs[1];
 220             } else if (preg_match("/FLAGS(.*)/i",$read[$i], $regs)) {
 221                 $regs[1]=trim(preg_replace (  array ("/\(/","/\)/") ,'', $regs[1])) ;
 222                 $result['FLAGS'] = $regs[1];
 223             }
 224         }
 225     }
 226     if (preg_match('/^\[(.+)\]/',$message, $regs)) {
 227         $result['RIGHTS']=$regs[1];
 228     }
 229
 230     if ($auto_expunge) {
 231         $tmp = sqimap_run_command($imap_stream, 'EXPUNGE', false, $a, $b);
 232     }
 233     return $result;
 234 }
 235
 236 /* Creates a folder */
 237 function sqimap_mailbox_create ($imap_stream, $mailbox, $type) {
 238     global $delimiter;
 239     if (strtolower($type) == 'noselect') {
 240         $mailbox .= $delimiter;
 241     }
 242
 243     $read_ary = sqimap_run_command($imap_stream, "CREATE \"$mailbox\"",
 244                                    true, $response, $message);
 245     sqimap_subscribe ($imap_stream, $mailbox);
 246 }
 247
 248 /* Subscribes to an existing folder */
 249 function sqimap_subscribe ($imap_stream, $mailbox) {
 250     $read_ary = sqimap_run_command($imap_stream, "SUBSCRIBE \"$mailbox\"",
 251                                    true, $response, $message);
 252 }
 253
 254 /* Unsubscribes to an existing folder */
 255 function sqimap_unsubscribe ($imap_stream, $mailbox) {
 256     $read_ary = sqimap_run_command($imap_stream, "UNSUBSCRIBE \"$mailbox\"",
 257                                    true, $response, $message);
 258 }
 259
 260 /* Deletes the given folder */
 261 function sqimap_mailbox_delete ($imap_stream, $mailbox) {
 262     global $data_dir, $username;
 263     $read_ary = sqimap_run_command($imap_stream, "DELETE \"$mailbox\"",
 264                                    true, $response, $message);
 265     sqimap_unsubscribe ($imap_stream, $mailbox);
 266     do_hook_function('rename_or_delete_folder', $args = array($mailbox, 'delete', ''));
 267     removePref($data_dir, $username, "thread_$mailbox");
 268 }
 269
 270 /* Determines if the user is subscribed to the folder or not */
 271 function sqimap_mailbox_is_subscribed($imap_stream, $folder) {
 272     $boxesall = sqimap_mailbox_list ($imap_stream);
 273     foreach ($boxesall as $ref) {
 274         if ($ref['unformatted'] == $folder) {
 275             return true;
 276         }
 277     }
 278     return false;
 279 }
 280
 281 /* Renames a mailbox */
 282 function sqimap_mailbox_rename( $imap_stream, $old_name, $new_name ) {
 283     if ( $old_name != $new_name ) {
 284         global $delimiter, $imap_server_type, $data_dir, $username;
 285         if ( substr( $old_name, -1 ) == $delimiter  ) {
 286             $old_name = substr( $old_name, 0, strlen( $old_name ) - 1 );
 287             $new_name = substr( $new_name, 0, strlen( $new_name ) - 1 );
 288             $postfix = $delimiter;
 289         } else {
 290             $postfix = '';
 291         }
 292
 293         $boxesall = sqimap_mailbox_list($imap_stream);
 294         $cmd = 'RENAME "' . $old_name . '" "' . $new_name . '"';
 295         $data = sqimap_run_command($imap_stream, $cmd, true, $response, $message);
 296         sqimap_unsubscribe($imap_stream, $old_name.$postfix);
 297         $oldpref = getPref($data_dir, $username, 'thread_'.$old_name.$postfix);
 298         removePref($data_dir, $username, 'thread_'.$old_name.$postfix);
 299         sqimap_subscribe($imap_stream, $new_name.$postfix);
 300         setPref($data_dir, $username, 'thread_'.$new_name.$postfix, $oldpref);
 301         do_hook_function('rename_or_delete_folder',$args = array($old_name, 'rename', $new_name));
 302         $l = strlen( $old_name ) + 1;
 303         $p = 'unformatted';
 304
 305         foreach ($boxesall as $box) {
 306             if (substr($box[$p], 0, $l) == $old_name . $delimiter) {
 307                 $new_sub = $new_name . $delimiter . substr($box[$p], $l);
 308                 if ($imap_server_type == 'cyrus') {
 309                     $cmd = 'RENAME "' . $box[$p] . '" "' . $new_sub . '"';
 310                     $data = sqimap_run_command($imap_stream, $cmd, true,
 311                                                $response, $message);
 312                 }
 313                 sqimap_unsubscribe($imap_stream, $box[$p]);
 314                 $oldpref = getPref($data_dir, $username, 'thread_'.$box[$p]);
 315                 removePref($data_dir, $username, 'thread_'.$box[$p]);
 316                 sqimap_subscribe($imap_stream, $new_sub);
 317                 setPref($data_dir, $username, 'thread_'.$new_sub, $oldpref);
 318                 do_hook_function('rename_or_delete_folder',
 319                                  $args = array($box[$p], 'rename', $new_sub));
 320             }
 321         }
 322     }
 323 }
 324
 325 /*
 326  * Formats a mailbox into 4 parts for the $boxesall array
 327  *
 328  * The four parts are:
 329  *
 330  *     raw            - Raw LIST/LSUB response from the IMAP server
 331  *     formatted      - nicely formatted folder name
 332  *     unformatted    - unformatted, but with delimiter at end removed
 333  *     unformatted-dm - folder name as it appears in raw response
 334  *     unformatted-disp - unformatted without $folder_prefix
 335  */
 336 function sqimap_mailbox_parse ($line, $line_lsub) {
 337     global $folder_prefix, $delimiter;
 338
 339     /* Process each folder line */
 340     for ($g = 0, $cnt = count($line); $g < $cnt; ++$g) {
 341         /* Store the raw IMAP reply */
 342         if (isset($line[$g])) {
 343             $boxesall[$g]['raw'] = $line[$g];
 344         } else {
 345             $boxesall[$g]['raw'] = '';
 346         }
 347
 348         /* Count number of delimiters ($delimiter) in folder name */
 349         $mailbox  = trim($line_lsub[$g]);
 350         $dm_count = substr_count($mailbox, $delimiter);
 351         if (substr($mailbox, -1) == $delimiter) {
 352             /* If name ends in delimiter, decrement count by one */
 353             $dm_count--;
 354         }
 355
 356         /* Format folder name, but only if it's a INBOX.* or has a parent. */
 357         $boxesallbyname[$mailbox] = $g;
 358         $parentfolder = readMailboxParent($mailbox, $delimiter);
 359         if ( (strtolower(substr($mailbox, 0, 5)) == "inbox") ||
 360              (substr($mailbox, 0, strlen($folder_prefix)) == $folder_prefix) ||
 361              (isset($boxesallbyname[$parentfolder]) &&
 362               (strlen($parentfolder) > 0) ) ) {
 363             $indent = $dm_count - (substr_count($folder_prefix, $delimiter));
 364             if ($indent > 0) {
 365                 $boxesall[$g]['formatted'] = str_repeat('&nbsp;&nbsp;', $indent);
 366             } else {
 367                 $boxesall[$g]['formatted'] = '';
 368             }
 369             $boxesall[$g]['formatted'] .= imap_utf7_decode_local(readShortMailboxName($mailbox, $delimiter));
 370         } else {
 371             $boxesall[$g]['formatted']  = imap_utf7_decode_local($mailbox);
 372         }
 373
 374         $boxesall[$g]['unformatted-dm'] = $mailbox;
 375         if (substr($mailbox, -1) == $delimiter) {
 376             $mailbox = substr($mailbox, 0, strlen($mailbox) - 1);
 377         }
 378         $boxesall[$g]['unformatted'] = $mailbox;
 379         if (substr($mailbox,0,strlen($folder_prefix))==$folder_prefix) {
 380             $mailbox = substr($mailbox, strlen($folder_prefix));
 381         }
 382         $boxesall[$g]['unformatted-disp'] = $mailbox;
 383         $boxesall[$g]['id'] = $g;
 384
 385         $boxesall[$g]['flags'] = array();
 386         if (isset($line[$g])) {
 387             ereg("\(([^)]*)\)",$line[$g],$regs);
 388             $flags = trim(strtolower(str_replace('\\', '',$regs[1])));
 389             if ($flags) {
 390                 $boxesall[$g]['flags'] = explode(' ', $flags);
 391             }
 392         }
 393     }
 394     return $boxesall;
 395 }
 396
 397 /*
 398  * Sorting function used to sort mailbox names.
 399  *     + Original patch from dave_michmerhuizen@yahoo.com
 400  *     + Allows case insensitivity when sorting folders
 401  *     + Takes care of the delimiter being sorted to the end, causing
 402  *       subfolders to be listed in below folders that are prefixed
 403  *       with their parent folders name.
 404  *
 405  *       For example: INBOX.foo, INBOX.foobar, and INBOX.foo.bar
 406  *       Without special sort function: foobar between foo and foo.bar
 407  *       With special sort function: foobar AFTER foo and foo.bar :)
 408  */
 409 function user_strcasecmp($a, $b) {
 410     return  strnatcasecmp($a, $b);
 411 }
 412
 413 /*
 414  * Returns list of options (to be echoed into select statement
 415  * based on available mailboxes and separators
 416  * Caller should surround options with <SELECT..> </SELECT> and
 417  * any formatting.
 418  *   $imap_stream - $imapConnection to query for mailboxes
 419  *   $show_selected - array containing list of mailboxes to pre-select (0 if none)
 420  *   $folder_skip - array of folders to keep out of option list (compared in lower)
 421  *   $boxes - list of already fetched boxes (for places like folder panel, where
 422  *            you know these options will be shown 3 times in a row.. (most often unset).
 423  *   $flag - flag to check for in mailbox flags, used to filter out mailboxes.
 424  *           'noselect' by default to remove unselectable mailboxes.
 425  *           'noinferiors' used to filter out folders that can not contain subfolders.
 426  *           NULL to avoid flag check entirely.
 427  *   $use_long_format - override folder display preference and always show full folder name.
 428  */
 429 function sqimap_mailbox_option_list($imap_stream, $show_selected = 0, $folder_skip = 0, $boxes = 0,
 430                                     $flag = 'noselect', $use_long_format = false ) {
 431     global $username, $data_dir;
 432     $mbox_options = '';
 433
 434     if ( $use_long_format ) {
 435         $shorten_box_names = 0;
 436     } else {
 437         $shorten_box_names = getPref($data_dir, $username, 'mailbox_select_style', SMPREF_OFF);
 438     }
 439
 440     if ($boxes == 0) {
 441         $boxes = sqimap_mailbox_list($imap_stream);
 442     }
 443
 444     foreach ($boxes as $boxes_part) {
 445         if ($flag == NULL || !in_array($flag, $boxes_part['flags'])) {
 446             $box = $boxes_part['unformatted'];
 447             $lowerbox = strtolower($box);
 448
 449             if ($folder_skip != 0 && in_array($lowerbox, $folder_skip) ) {
 450                 continue;
 451             }
 452             if ($lowerbox == 'inbox'){
 453                 $box2 = _("INBOX");
 454             } else if ( $shorten_box_names == 2 ) {  /* delimited, style = 2 */
 455                 $box2 = str_replace('&nbsp;&nbsp;', '.&nbsp;', $boxes_part['formatted']);
 456             } else if ( $shorten_box_names == 1 ) {     /* indent, style = 1 */
 457                 $box2 = $boxes_part['formatted'];
 458             } else  {                      /* default, long names, style = 0 */
 459                 $box2 = str_replace(' ', '&nbsp;', imap_utf7_decode_local($boxes_part['unformatted-disp']));
 460             }
 461             if ($show_selected != 0 && in_array($lowerbox, $show_selected) ) {
 462                 $mbox_options .= '<OPTION VALUE="'.$box.'" SELECTED>'.$box2.'</OPTION>' . "\n";
 463             } else {
 464                 $mbox_options .= '<OPTION VALUE="'.$box.'">'.$box2.'</OPTION>' . "\n";
 465             }
 466         }
 467     }
 468     return $mbox_options;
 469 }
 470
 471 /*
 472  * Returns sorted mailbox lists in several different ways.
 473  * See comment on sqimap_mailbox_parse() for info about the returned array.
 474  */
 475 function sqimap_mailbox_list($imap_stream) {
 476     global $default_folder_prefix;
 477
 478     if (!isset($boxesnew)) {
 479         global $data_dir, $username, $list_special_folders_first,
 480                $folder_prefix, $trash_folder, $sent_folder, $draft_folder,
 481                $move_to_trash, $move_to_sent, $save_as_draft,
 482                $delimiter, $noselect_fix_enable;
 483
 484         $inbox_in_list = false;
 485         $inbox_subscribed = false;
 486
 487         require_once(SM_PATH . 'include/load_prefs.php');
 488
 489         if ($noselect_fix_enable) {
 490             $lsub_args = "LSUB \"$folder_prefix\" \"*%\"";
 491         } else {
 492             $lsub_args = "LSUB \"$folder_prefix\" \"*\"";
 493         }
 494         /* LSUB array */
 495         $lsub_ary = sqimap_run_command ($imap_stream, $lsub_args,
 496                                         true, $response, $message);
 497
 498         $sorted_lsub_ary = array();
 499         for ($i = 0, $cnt = count($lsub_ary);$i < $cnt; $i++) {
 500             /*
 501              * Workaround for mailboxes returned as literal
 502              * Doesn't work if the mailbox name is multiple lines
 503              * (larger then fgets buffer)
 504              */
 505             if (isset($lsub_ary[$i + 1]) && substr($lsub_ary[$i],-3) == "}\r\n") {
 506                 if (ereg("^(\\* [A-Z]+.*)\\{[0-9]+\\}([ \n\r\t]*)$",
 507                      $lsub_ary[$i], $regs)) {
 508                     $i++;
 509                     $lsub_ary[$i] = $regs[1] . '"' . addslashes(trim($lsub_ary[$i])) . '"' . $regs[2];
 510                 }
 511             }
 512             $temp_mailbox_name = find_mailbox_name($lsub_ary[$i]);
 513             $sorted_lsub_ary[] = $temp_mailbox_name;
 514             if (!$inbox_subscribed && strtoupper($temp_mailbox_name) == 'INBOX') {
 515                 $inbox_subscribed = true;
 516             }
 517         }
 518         /* remove duplicates */
 519         $sorted_lsub_ary = array_unique($sorted_lsub_ary);
 520
 521         /* natural sort mailboxes */
 522         if (isset($sorted_lsub_ary)) {
 523             usort($sorted_lsub_ary, 'user_strcasecmp');
 524         }
 525         /*
 526          * The LSUB response doesn't provide us information about \Noselect
 527          * mail boxes. The LIST response does, that's why we need to do a LIST
 528          * call to retrieve the flags for the mailbox
 529            * Note: according RFC2060 an imap server may provide \NoSelect flags in the LSUB response.
 530            * in other words, we cannot rely on it.
 531          */
 532         $sorted_list_ary = array();
 533         for ($i=0; $i < count($sorted_lsub_ary); $i++) {
 534             if (substr($sorted_lsub_ary[$i], -1) == $delimiter) {
 535                 $mbx = substr($sorted_lsub_ary[$i], 0, strlen($sorted_lsub_ary[$i])-1);
 536             }
 537             else {
 538                 $mbx = $sorted_lsub_ary[$i];
 539             }
 540
 541             $read = sqimap_run_command ($imap_stream, "LIST \"\" \"$mbx\"",
 542                                         true, $response, $message);
 543
 544             /* Another workaround for literals */
 545
 546             if (isset($read[1]) && substr($read[1],-3) == "}\r\n") {
 547                 if (ereg("^(\\* [A-Z]+.*)\\{[0-9]+\\}([ \n\r\t]*)$",
 548                      $read[0], $regs)) {
 549                     $read[0] = $regs[1] . '"' . addslashes(trim($read[1])) . '"' . $regs[2];
 550                 }
 551             }
 552
 553             if (isset($read[0])) {
 554                 $sorted_list_ary[$i] = $read[0];
 555             } else {
 556                 $sorted_list_ary[$i] = '';
 557             }
 558         }
 559
 560         /*
 561          * Just in case they're not subscribed to their inbox,
 562          * we'll get it for them anyway
 563          */
 564         if (!$inbox_subscribed) {
 565             $inbox_ary = sqimap_run_command ($imap_stream, "LIST \"\" \"INBOX\"",
 566                                              true, $response, $message);
 567             /* Another workaround for literals */
 568             if (isset($inbox_ary[1]) && substr($inbox_ary[0],-3) == "}\r\n") {
 569                 if (ereg("^(\\* [A-Z]+.*)\\{[0-9]+\\}([ \n\r\t]*)$",
 570                      $inbox_ary[0], $regs)) {
 571                     $inbox_ary[0] = $regs[1] . '"' . addslashes(trim($inbox_ary[1])) .
 572                                 '"' . $regs[2];
 573                 }
 574             }
 575             $sorted_list_ary[] = $inbox_ary[0];
 576             $sorted_lsub_ary[] = find_mailbox_name($inbox_ary[0]);
 577         }
 578
 579         $boxesall = sqimap_mailbox_parse ($sorted_list_ary, $sorted_lsub_ary);
 580
 581         /* Now, lets sort for special folders */
 582         $boxesnew = $used = array();
 583
 584         /* Find INBOX */
 585         $cnt = count($boxesall);
 586         $used = array_pad($used,$cnt,false);
 587         for($k = 0; $k < $cnt; ++$k) {
 588             if (strtolower($boxesall[$k]['unformatted']) == 'inbox') {
 589                 $boxesnew[] = $boxesall[$k];
 590                 $used[$k] = true;
 591                 break;
 592             }
 593         }
 594         /* List special folders and their subfolders, if requested. */
 595         if ($list_special_folders_first) {
 596             for($k = 0; $k < $cnt; ++$k) {
 597                 if (!$used[$k] && isSpecialMailbox($boxesall[$k]['unformatted'])) {
 598                     $boxesnew[] = $boxesall[$k];
 599                     $used[$k]   = true;
 600                 }
 601             }
 602         }
 603
 604         /* Rest of the folders */
 605         for($k = 0; $k < $cnt; $k++) {
 606             if (!$used[$k]) {
 607                 $boxesnew[] = $boxesall[$k];
 608             }
 609         }
 610     }
 611     return $boxesnew;
 612 }
 613
 614 /*
 615  *  Returns a list of all folders, subscribed or not
 616  */
 617 function sqimap_mailbox_list_all($imap_stream) {
 618     global $list_special_folders_first, $folder_prefix, $delimiter;
 619     $read_ary = sqimap_run_command($imap_stream,"LIST \"$folder_prefix\" *",true,$response, $message,false);
 620     $g = 0;
 621     $phase = 'inbox';
 622     $fld_pre_length = strlen($folder_prefix);
 623     for ($i = 0, $cnt = count($read_ary); $i < $cnt; $i++) {
 624         /* Another workaround for EIMS */
 625         if (isset($read_ary[$i + 1]) &&
 626             ereg("^(\\* [A-Z]+.*)\\{[0-9]+\\}([ \n\r\t]*)$",
 627                  $read_ary[$i], $regs)) {
 628             $i ++;
 629             $read_ary[$i] = $regs[1] . '"' . addslashes(trim($read_ary[$i])) . '"' . $regs[2];
 630         }
 631         /* Store the raw IMAP reply */
 632         $boxes[$g]['raw'] = $read_ary[$i];
 633
 634         /* Count number of delimiters ($delimiter) in folder name */
 635         $mailbox = find_mailbox_name($read_ary[$i]);
 636         $dm_count =  substr_count($mailbox, $delimiter);
 637         if (substr($mailbox, -1) == $delimiter) {
 638             /* If name ends in delimiter - decrement count by one */
 639             $dm_count--;
 640         }
 641
 642         /* Format folder name, but only if it's a INBOX.* or has a parent. */
 643         $boxesallbyname[$mailbox] = $g;
 644         $parentfolder = readMailboxParent($mailbox, $delimiter);
 645         if((eregi('^inbox'.quotemeta($delimiter), $mailbox)) ||
 646            (ereg('^'.$folder_prefix, $mailbox)) ||
 647            ( isset($boxesallbyname[$parentfolder]) && (strlen($parentfolder) > 0) ) ) {
 648             if ($dm_count) {
 649                 $boxes[$g]['formatted']  = str_repeat('&nbsp;&nbsp;', $dm_count);
 650             } else {
 651                 $boxes[$g]['formatted'] = '';
 652             }
 653             $boxes[$g]['formatted'] .= imap_utf7_decode_local(readShortMailboxName($mailbox, $delimiter));
 654         } else {
 655             $boxes[$g]['formatted']  = imap_utf7_decode_local($mailbox);
 656         }
 657
 658         $boxes[$g]['unformatted-dm'] = $mailbox;
 659         if (substr($mailbox, -1) == $delimiter) {
 660             $mailbox = substr($mailbox, 0, strlen($mailbox) - 1);
 661         }
 662         $boxes[$g]['unformatted'] = $mailbox;
 663         $boxes[$g]['unformatted-disp'] = substr($mailbox,$fld_pre_length);
 664
 665         $boxes[$g]['id'] = $g;
 666
 667         /* Now lets get the flags for this mailbox */
 668         $read_mlbx = $read_ary[$i];
 669         $flags = substr($read_mlbx, strpos($read_mlbx, '(')+1);
 670         $flags = substr($flags, 0, strpos($flags, ')'));
 671         $flags = str_replace('\\', '', $flags);
 672         $flags = trim(strtolower($flags));
 673         if ($flags) {
 674             $boxes[$g]['flags'] = explode(' ', $flags);
 675         } else {
 676             $boxes[$g]['flags'] = array();
 677         }
 678         $g++;
 679     }
 680     if(is_array($boxes)) {
 681         sort ($boxes);
 682     }
 683
 684     return $boxes;
 685 }
 686
 687 function sqimap_mailbox_tree($imap_stream) {
 688     global $boxesnew, $default_folder_prefix, $unseen_notify, $unseen_type;
 689     if (!isset($boxesnew)) {
 690
 691         global $data_dir, $username, $list_special_folders_first,
 692                $folder_prefix, $delimiter, $trash_folder, $move_to_trash,
 693                $imap_server_type;
 694
 695
 696         $inbox_in_list = false;
 697         $inbox_subscribed = false;
 698
 699         require_once(SM_PATH . 'include/load_prefs.php');
 700
 701         /* LSUB array */
 702         $lsub_ary = sqimap_run_command ($imap_stream, "LSUB \"$folder_prefix\" \"*\"",
 703                                         true, $response, $message);
 704
 705         /* Check to see if we have an INBOX */
 706         $has_inbox = false;
 707
 708         for ($i = 0, $cnt = count($lsub_ary); $i < $cnt; $i++) {
 709             if (preg_match("/^\*\s+LSUB\s+(.*)\"?INBOX\"?[^(\/\.)].*$/",$lsub_ary[$i])) {
 710                 $has_inbox = true;
 711                 break;
 712             }
 713         }
 714
 715         if ($has_inbox == false) {
 716             $lsub_ibx = sqimap_run_command( $imap_stream, "LSUB \"\" \"INBOX\"", true, $response, $message );
 717             if (isset($lsub_ibx[0]) && (preg_match("/^\*\s+LSUB\s+(.*)\"?INBOX\"?[^(\/\.)].*$/",$lsub_ibx[0]))) {
 718                 $lsub_ary[] = $lsub_ibx[0];
 719             } else {
 720                 $lsub_ibx = sqimap_run_command( $imap_stream, "LIST \"\" \"INBOX\"", true, $response, $message );
 721                 if (preg_match("/^\*\s+LIST\s+(.*)\"?INBOX\"?[^(\/\.)].*$/",$lsub_ibx[0])) {
 722                     sqimap_run_command( $imap_stream, "SUBSCRIBE \"INBOX\"", true, $response, $message );
 723                     $lsub_ibx[0] = str_replace("LIST","LSUB",$lsub_ibx[0]);
 724                     $lsub_ary[] = $lsub_ibx[0];
 725                 }
 726             }
 727         }
 728
 729         /*
 730          * Section about removing the last element was removed
 731          * We don't return "* OK" anymore from sqimap_read_data
 732          */
 733         $sorted_lsub_ary = array();
 734         $cnt = count($lsub_ary);
 735
 736         for ($i = 0; $i < $cnt; $i++) {
 737             /*
 738              * Workaround for EIMS
 739              * Doesn't work if the mailbox name is multiple lines
 740              */
 741             if (isset($lsub_ary[$i + 1]) &&
 742                 ereg("^(\\* [A-Z]+.*)\\{[0-9]+\\}([ \n\r\t]*)$",
 743                      $lsub_ary[$i], $regs)) {
 744                 $i++;
 745                 $lsub_ary[$i] = $regs[1] . '"' . addslashes(trim($lsub_ary[$i])) . '"' . $regs[2];
 746             }
 747
 748             $mbx = find_mailbox_name($lsub_ary[$i]);
 749
 750             // Force a list for UW as it returns \NoSelect in LIST and not LSUB //
 751             if ($imap_server_type == "uw") {
 752                 $tmp_str = sqimap_run_command( $imap_stream , "LIST \"\" \"$mbx\"" , true, $response, $message );
 753                 if (isset($tmp_str[0])) {
 754                     $lsub_ary[$i] = $tmp_str[0];
 755                 }
 756             }
 757             $noselect = check_is_noselect($lsub_ary[$i]);
 758             if (substr($mbx, -1) == $delimiter) {
 759                 $mbx = substr($mbx, 0, strlen($mbx) - 1);
 760             }
 761             $sorted_lsub_ary[] = array ('mbx' => $mbx, 'noselect' => $noselect);
 762         }
 763         array_multisort($sorted_lsub_ary, SORT_ASC, SORT_REGULAR);
 764
 765         for ($i = 0 ; $i < $cnt; $i++) {
 766             $mbx = $sorted_lsub_ary[$i]['mbx'];
 767             if (($unseen_notify == 2 && $mbx == 'INBOX') ||
 768                 ($unseen_notify == 3) ||
 769                 ($move_to_trash && ($mbx == $trash_folder))) {
 770                 if( $sorted_lsub_ary[$i]['noselect'] ) {
 771                     $sorted_lsub_ary[$i]['unseen'] = 0;
 772                 } else {
 773                     $sorted_lsub_ary[$i]['unseen'] =
 774                         sqimap_unseen_messages($imap_stream, $mbx);
 775                 }
 776                 if (($unseen_type == 2) ||
 777                     ($move_to_trash && ($mbx == $trash_folder)) ||
 778                     ($mbx == $trash_folder)) {
 779                     if($sorted_lsub_ary[$i]['noselect']) {
 780                         $sorted_lsub_ary[$i]['nummessages'] = 0;
 781                     } else {
 782                         $sorted_lsub_ary[$i]['nummessages'] =
 783                             sqimap_get_num_messages($imap_stream, $mbx);
 784                     }
 785                 }
 786             }
 787         }
 788         $boxesnew = sqimap_fill_mailbox_tree($sorted_lsub_ary);
 789         return $boxesnew;
 790     }
 791 }
 792
 793
 794 function sqimap_fill_mailbox_tree($mbx_ary, $mbxs=false) {
 795     global $data_dir, $username, $list_special_folders_first,
 796            $folder_prefix, $trash_folder, $sent_folder, $draft_folder,
 797            $move_to_trash, $move_to_sent, $save_as_draft,
 798            $delimiter, $imap_server_type;
 799
 800     $special_folders = array ('INBOX', $sent_folder, $draft_folder, $trash_folder);
 801
 802     /* create virtual root node */
 803     $mailboxes= new mailboxes();
 804     $mailboxes->is_root = true;
 805     $trail_del = false;
 806     $start = 0;
 807
 808
 809     if (isset($folder_prefix) && ($folder_prefix != '')) {
 810         $start = substr_count($folder_prefix,$delimiter);
 811         if (strrpos($folder_prefix, $delimiter) == (strlen($folder_prefix)-1)) {
 812             $trail_del = true;
 813             $mailboxes->mailboxname_full = substr($folder_prefix,0, (strlen($folder_prefix)-1));
 814         } else {
 815             $mailboxes->mailboxname_full = $folder_prefix;
 816             $start++;
 817         }
 818         $mailboxes->mailboxname_sub = $mailboxes->mailboxname_full;
 819     } else {
 820         $start = 0;
 821     }
 822
 823     $cnt =  count($mbx_ary);
 824     for ($i=0; $i < $cnt; $i++) {
 825         if ($mbx_ary[$i]['mbx'] !='' ) {
 826             $mbx = new mailboxes();
 827             $mailbox = $mbx_ary[$i]['mbx'];
 828             switch ($mailbox) {
 829                 case 'INBOX':
 830                     $mbx->is_inbox = true;
 831                     $mbx->is_special = true;
 832                     break;
 833                 case $trash_folder:
 834                     $mbx->is_trash = true;
 835                     $mbx->is_special = true;
 836                     break;
 837                 case $sent_folder:
 838                     $mbx->is_sent = true;
 839                     $mbx->is_special = true;
 840                     break;
 841                 case $draft_folder:
 842                     $mbx->is_draft = true;
 843                     $mbx->is_special = true;
 844                     break;
 845             }
 846
 847             if (isset($mbx_ary[$i]['unseen'])) {
 848                 $mbx->unseen = $mbx_ary[$i]['unseen'];
 849             }
 850             if (isset($mbx_ary[$i]['nummessages'])) {
 851                 $mbx->total = $mbx_ary[$i]['nummessages'];
 852             }
 853
 854             $mbx->is_noselect = $mbx_ary[$i]['noselect'];
 855
 856             $r_del_pos = strrpos($mbx_ary[$i]['mbx'], $delimiter);
 857             if ($r_del_pos) {
 858                 $mbx->mailboxname_sub = substr($mbx_ary[$i]['mbx'],$r_del_pos+1);
 859             } else {   /* mailbox is root folder */
 860                 $mbx->mailboxname_sub = $mbx_ary[$i]['mbx'];
 861             }
 862             $mbx->mailboxname_full = $mbx_ary[$i]['mbx'];
 863
 864             $mailboxes->addMbx($mbx, $delimiter, $start, $list_special_folders_first);
 865         }
 866     }
 867     sqimap_utf7_decode_mbx_tree($mailboxes);
 868     return $mailboxes;
 869 }
 870
 871 function sqimap_utf7_decode_mbx_tree(&$mbx_tree) {
 872    $mbx_tree->mailboxname_sub=imap_utf7_decode_local($mbx_tree->mailboxname_sub);
 873    if ($mbx_tree->mbxs) {
 874       $iCnt = count($mbx_tree->mbxs);
 875       for ($i=0;$i<$iCnt;++$i) {
 876          $mbxs_tree->mbxs[$i] = sqimap_utf7_decode_mbx_tree($mbx_tree->mbxs[$i]);
 877       }
 878    }
 879 }
 880
 881 ?>