program/lib/imap.inc

   1 <?php
   2 /////////////////////////////////////////////////////////
   3 //
   4 //      Iloha IMAP Library (IIL)
   5 //
   6 //      (C)Copyright 2002 Ryo Chijiiwa <Ryo@IlohaMail.org>
   7 //
   8 //      This file is part of IlohaMail. IlohaMail is free software released
   9 //      under the GPL license.  See enclosed file COPYING for details, or
  10 //      see http://www.fsf.org/copyleft/gpl.html
  11 //
  12 /////////////////////////////////////////////////////////
  13
  14 /********************************************************
  15
  16         FILE: include/imap.inc
  17         PURPOSE:
  18                 Provide alternative IMAP library that doesn't rely on the standard
  19                 C-Client based version.  This allows IlohaMail to function regardless
  20                 of whether or not the PHP build it's running on has IMAP functionality
  21                 built-in.
  22         USEAGE:
  23                 Function containing "_C_" in name require connection handler to be
  24                 passed as one of the parameters.  To obtain connection handler, use
  25                 iil_Connect()
  26         VERSION:
  27                 IlohaMail-0.9-20050415
  28         CHANGES:
  29                 File altered by Thomas Bruederli <roundcube@gmail.com>
  30                 to fit enhanced equirements by the RoundCube Webmail:
  31                 - Added list of server capabilites and check these before invoking commands
  32                 - Added junk flag to iilBasicHeader
  33                 - Enhanced error reporting on fsockopen()
  34                 - Additional parameter for SORT command
  35                 - Removed Call-time pass-by-reference because deprecated
  36                 - Parse charset from content-type in iil_C_FetchHeaders()
  37                 - Enhanced heaer sorting
  38                 - Pass message as reference in iil_C_Append (to save memory)
  39                 - Added BCC and REFERENCE to the list of headers to fetch in iil_C_FetchHeaders()
  40                 - Leave messageID unchanged in iil_C_FetchHeaders()
  41                 - Avoid stripslahes in iil_Connect()
  42                 - Escape quotes and backslashes in iil_C_Login()
  43                 - Added patch to iil_SortHeaders() by Richard Green
  44                 - Removed <br> from error messages (better for logging)
  45                 - Added patch to iil_C_Sort() enabling UID SORT commands
  46                 - Added function iil_C_ID2UID()
  47                 - Casting date parts in iil_StrToTime() to avoid mktime() warnings
  48                 - Also acceppt LIST responses in iil_C_ListSubscribed()
  49                 - Sanity check of $message_set in iil_C_FetchHeaders(), iil_C_FetchHeaderIndex(), iil_C_FetchThreadHeaders()
  50                 - Implemented UID FETCH in iil_C_FetchHeaders()
  51                 - Abort do-loop on socket errors (fgets returns false)
  52                 - $ICL_SSL is not boolean anymore but contains the connection schema (ssl or tls)
  53                 - Removed some debuggers (echo ...)
  54                 File altered by Aleksander Machniak <alec@alec.pl>
  55                 - trim(chop()) replaced by trim()
  56                 - added iil_Escape()/iil_UnEscape() with support for " and \ in folder names
  57                 - support \ character in username in iil_C_Login()
  58                 - fixed iil_MultLine(): use iil_ReadBytes() instead of iil_ReadLine()
  59                 - fixed iil_C_FetchStructureString() to handle many literal strings in response
  60                 - removed hardcoded data size in iil_ReadLine()
  61                 - added iil_PutLine() wrapper for fputs()
  62                 - code cleanup and identation fixes
  63                 - removed flush() calls in iil_C_HandlePartBody() to prevent from memory leak (#1485187)
  64                 - don't return "??" from iil_C_GetQuota()
  65                 - RFC3501 [7.1] don't call CAPABILITY if was returned in server
  66                   optional resposne in iil_Connect(), added iil_C_GetCapability()
  67                 - remove 'undisclosed-recipients' string from 'To' header
  68                 - iil_C_HandlePartBody(): added 6th argument and fixed endless loop
  69                 - added iil_PutLineC()
  70                 - fixed iil_C_Sort() to support very long and/or divided responses
  71                 - added BYE/BAD response simple support for endless loop prevention
  72                 - added 3rd argument in iil_StartsWith* functions
  73                 - fix iil_C_FetchPartHeader() in some cases by use of iil_C_HandlePartBody()
  74                 - allow iil_C_HandlePartBody() to fetch whole message
  75                 - optimize iil_C_FetchHeaders() to use only one FETCH command
  76                 - added 4th argument to iil_Connect()
  77                 - allow setting rootdir and delimiter before connect
  78                 - support multiquota result
  79                 - include BODYSTRUCTURE in iil_C_FetchHeaders()
  80                 - added iil_C_FetchMIMEHeaders() function
  81                 - added \* flag support
  82                 - use PREG instead of EREG
  83                 - removed caching functions
  84                 - handling connection startup response
  85                 - added UID EXPUNGE support
  86                 - fixed problem with double quotes and spaces in folder names in LIST and LSUB
  87                 - rewritten iil_C_FetchHeaderIndex()
  88
  89 ********************************************************/
  90
  91 /**
  92  * @todo Possibly clean up more CS.
  93  * @todo Try to replace most double-quotes with single-quotes.
  94  * @todo Split this file into smaller files.
  95  * @todo Refactor code.
  96  * @todo Replace echo-debugging (make it adhere to config setting and log)
  97  */
  98
  99
 100 if (!isset($IMAP_USE_HEADER_DATE) || !$IMAP_USE_HEADER_DATE) {
 101     $IMAP_USE_INTERNAL_DATE = true;
 102 }
 103
 104 $GLOBALS['IMAP_FLAGS'] = array(
 105     'SEEN'     => '\\Seen',
 106     'DELETED'  => '\\Deleted',
 107     'RECENT'   => '\\Recent',
 108     'ANSWERED' => '\\Answered',
 109     'DRAFT'    => '\\Draft',
 110     'FLAGGED'  => '\\Flagged',
 111     'FORWARDED' => '$Forwarded',
 112     'MDNSENT'  => '$MDNSent',
 113     '*'        => '\\*',
 114 );
 115
 116 $iil_error;
 117 $iil_errornum;
 118 $iil_selected;
 119
 120 /**
 121  * @todo Change class vars to public/private
 122  */
 123 class iilConnection
 124 {
 125         var $fp;
 126         var $error;
 127         var $errorNum;
 128         var $selected;
 129         var $message;
 130         var $host;
 131         var $exists;
 132         var $recent;
 133         var $rootdir;
 134         var $delimiter;
 135         var $capability = array();
 136         var $permanentflags = array();
 137         var $capability_readed = false;
 138 }
 139
 140 /**
 141  * @todo Change class vars to public/private
 142  */
 143 class iilBasicHeader
 144 {
 145         var $id;
 146         var $uid;
 147         var $subject;
 148         var $from;
 149         var $to;
 150         var $cc;
 151         var $replyto;
 152         var $in_reply_to;
 153         var $date;
 154         var $messageID;
 155         var $size;
 156         var $encoding;
 157         var $charset;
 158         var $ctype;
 159         var $flags;
 160         var $timestamp;
 161         var $f;
 162         var $body_structure;
 163         var $internaldate;
 164         var $references;
 165         var $priority;
 166         var $mdn_to;
 167         var $mdn_sent = false;
 168         var $is_draft = false;
 169         var $seen = false;
 170         var $deleted = false;
 171         var $recent = false;
 172         var $answered = false;
 173         var $forwarded = false;
 174         var $junk = false;
 175         var $flagged = false;
 176         var $others = array();
 177 }
 178
 179 /**
 180  * @todo Change class vars to public/private
 181  */
 182 class iilThreadHeader
 183 {
 184         var $id;
 185         var $sbj;
 186         var $irt;
 187         var $mid;
 188 }
 189
 190 function iil_xor($string, $string2) {
 191         $result = '';
 192         $size = strlen($string);
 193         for ($i=0; $i<$size; $i++) {
 194                 $result .= chr(ord($string[$i]) ^ ord($string2[$i]));
 195         }
 196         return $result;
 197 }
 198
 199 function iil_PutLine($fp, $string, $endln=true) {
 200         global $my_prefs;
 201
 202         if (!empty($my_prefs['debug_mode']))
 203                 write_log('imap', 'C: '. rtrim($string));
 204
 205         return fputs($fp, $string . ($endln ? "\r\n" : ''));
 206 }
 207
 208 // iil_PutLine replacement with Command Continuation Requests (RFC3501 7.5) support
 209 function iil_PutLineC($fp, $string, $endln=true) {
 210         if ($endln)
 211                 $string .= "\r\n";
 212
 213         $res = 0;
 214         if ($parts = preg_split('/(\{[0-9]+\}\r\n)/m', $string, -1, PREG_SPLIT_DELIM_CAPTURE)) {
 215                 for($i=0, $cnt=count($parts); $i<$cnt; $i++) {
 216                         if(preg_match('/^\{[0-9]+\}\r\n$/', $parts[$i+1])) {
 217                                 $res += iil_PutLine($fp, $parts[$i].$parts[$i+1], false);
 218                                 $line = iil_ReadLine($fp, 1000);
 219                                 // handle error in command
 220                                 if ($line[0] != '+')
 221                                         return false;
 222                                 $i++;
 223                         }
 224                         else
 225                                 $res += iil_PutLine($fp, $parts[$i], false);
 226                 }
 227         }
 228         return $res;
 229 }
 230
 231 function iil_ReadLine($fp, $size=1024) {
 232         global $my_prefs;
 233
 234         $line = '';
 235
 236         if (!$fp) {
 237                 return $line;
 238         }
 239
 240         if (!$size) {
 241                 $size = 1024;
 242         }
 243
 244         do {
 245                 $buffer = fgets($fp, $size);
 246
 247                 if ($buffer === false) {
 248                         break;
 249                 }
 250                 if (!empty($my_prefs['debug_mode']))
 251                         write_log('imap', 'S: '. chop($buffer));
 252                 $line .= $buffer;
 253         } while ($buffer[strlen($buffer)-1] != "\n");
 254
 255         return $line;
 256 }
 257
 258 function iil_MultLine($fp, $line, $escape=false) {
 259         $line = chop($line);
 260         if (preg_match('/\{[0-9]+\}$/', $line)) {
 261                 $out = '';
 262
 263                 preg_match_all('/(.*)\{([0-9]+)\}$/', $line, $a);
 264                 $bytes = $a[2][0];
 265                 while (strlen($out) < $bytes) {
 266                         $line = iil_ReadBytes($fp, $bytes);
 267                         $out .= $line;
 268                 }
 269
 270                 $line = $a[1][0] . '"' . ($escape ? iil_Escape($out) : $out) . '"';
 271         }
 272         return $line;
 273 }
 274
 275 function iil_ReadBytes($fp, $bytes) {
 276         global $my_prefs;
 277         $data = '';
 278         $len  = 0;
 279         do {
 280                 $d = fread($fp, $bytes-$len);
 281                 if (!empty($my_prefs['debug_mode']))
 282                         write_log('imap', 'S: '. $d);
 283                 $data .= $d;
 284                 $data_len = strlen($data);
 285                 if ($len == $data_len) {
 286                         break; //nothing was read -> exit to avoid apache lockups
 287                 }
 288                 $len = $data_len;
 289         } while ($len < $bytes);
 290
 291         return $data;
 292 }
 293
 294 // don't use it in loops, until you exactly know what you're doing
 295 function iil_ReadReply($fp) {
 296         do {
 297                 $line = trim(iil_ReadLine($fp, 1024));
 298         } while ($line[0] == '*');
 299
 300         return $line;
 301 }
 302
 303 function iil_ParseResult($string) {
 304         $a = explode(' ', trim($string));
 305         if (count($a) >= 2) {
 306                 if (strcasecmp($a[1], 'OK') == 0) {
 307                         return 0;
 308                 } else if (strcasecmp($a[1], 'NO') == 0) {
 309                         return -1;
 310                 } else if (strcasecmp($a[1], 'BAD') == 0) {
 311                         return -2;
 312                 } else if (strcasecmp($a[1], 'BYE') == 0) {
 313                         return -3;
 314                 }
 315         }
 316         return -4;
 317 }
 318
 319 // check if $string starts with $match (or * BYE/BAD)
 320 function iil_StartsWith($string, $match, $error=false) {
 321         $len = strlen($match);
 322         if ($len == 0) {
 323                 return false;
 324         }
 325         if (strncmp($string, $match, $len) == 0) {
 326                 return true;
 327         }
 328         if ($error && preg_match('/^\* (BYE|BAD) /i', $string)) {
 329                 return true;
 330         }
 331         return false;
 332 }
 333
 334 function iil_StartsWithI($string, $match, $error=false) {
 335         $len = strlen($match);
 336         if ($len == 0) {
 337                 return false;
 338         }
 339         if (strncasecmp($string, $match, $len) == 0) {
 340                 return true;
 341         }
 342         if ($error && preg_match('/^\* (BYE|BAD) /i', $string)) {
 343                 return true;
 344
 345         }
 346         return false;
 347 }
 348
 349 function iil_Escape($string)
 350 {
 351         return strtr($string, array('"'=>'\\"', '\\' => '\\\\'));
 352 }
 353
 354 function iil_UnEscape($string)
 355 {
 356         return strtr($string, array('\\"'=>'"', '\\\\' => '\\'));
 357 }
 358
 359 function iil_C_GetCapability(&$conn, $name)
 360 {
 361         if (in_array($name, $conn->capability)) {
 362                 return true;
 363         }
 364         else if ($conn->capability_readed) {
 365                 return false;
 366         }
 367
 368         // get capabilities (only once) because initial
 369         // optional CAPABILITY response may differ
 370         $conn->capability = array();
 371
 372         iil_PutLine($conn->fp, "cp01 CAPABILITY");
 373         do {
 374                 $line = trim(iil_ReadLine($conn->fp, 1024));
 375                 $a = explode(' ', $line);
 376                 if ($line[0] == '*') {
 377                         while (list($k, $w) = each($a)) {
 378                                 if ($w != '*' && $w != 'CAPABILITY')
 379                                         $conn->capability[] = strtoupper($w);
 380                         }
 381                 }
 382         } while ($a[0] != 'cp01');
 383
 384         $conn->capability_readed = true;
 385
 386         if (in_array($name, $conn->capability)) {
 387                 return true;
 388         }
 389
 390         return false;
 391 }
 392
 393 function iil_C_ClearCapability(&$conn)
 394 {
 395         $conn->capability = array();
 396         $conn->capability_readed = false;
 397 }
 398
 399 function iil_C_Authenticate(&$conn, $user, $pass, $encChallenge) {
 400
 401     $ipad = '';
 402     $opad = '';
 403
 404     // initialize ipad, opad
 405     for ($i=0;$i<64;$i++) {
 406         $ipad .= chr(0x36);
 407         $opad .= chr(0x5C);
 408     }
 409
 410     // pad $pass so it's 64 bytes
 411     $padLen = 64 - strlen($pass);
 412     for ($i=0;$i<$padLen;$i++) {
 413         $pass .= chr(0);
 414     }
 415
 416     // generate hash
 417     $hash  = md5(iil_xor($pass,$opad) . pack("H*", md5(iil_xor($pass, $ipad) . base64_decode($encChallenge))));
 418
 419     // generate reply
 420     $reply = base64_encode($user . ' ' . $hash);
 421
 422     // send result, get reply
 423     iil_PutLine($conn->fp, $reply);
 424     $line = iil_ReadLine($conn->fp, 1024);
 425
 426     // process result
 427     $result = iil_ParseResult($line);
 428     if ($result == 0) {
 429         $conn->error    .= '';
 430         $conn->errorNum  = 0;
 431         return $conn->fp;
 432     }
 433
 434     if ($result == -3) fclose($conn->fp); // BYE response
 435
 436     $conn->error    .= 'Authentication for ' . $user . ' failed (AUTH): "';
 437     $conn->error    .= htmlspecialchars($line) . '"';
 438     $conn->errorNum  = $result;
 439
 440     return $result;
 441 }
 442
 443 function iil_C_Login(&$conn, $user, $password) {
 444
 445     iil_PutLine($conn->fp, 'a001 LOGIN "'.iil_Escape($user).'" "'.iil_Escape($password).'"');
 446
 447     $line = iil_ReadReply($conn->fp);
 448
 449     // process result
 450     $result = iil_ParseResult($line);
 451
 452     if ($result == 0) {
 453         $conn->error    .= '';
 454         $conn->errorNum  = 0;
 455         return $conn->fp;
 456     }
 457
 458     fclose($conn->fp);
 459
 460     $conn->error    .= 'Authentication for ' . $user . ' failed (LOGIN): "';
 461     $conn->error    .= htmlspecialchars($line)."\"";
 462     $conn->errorNum  = $result;
 463
 464     return $result;
 465 }
 466
 467 function iil_ParseNamespace2($str, &$i, $len=0, $l) {
 468         if (!$l) {
 469             $str = str_replace('NIL', '()', $str);
 470         }
 471         if (!$len) {
 472             $len = strlen($str);
 473         }
 474         $data      = array();
 475         $in_quotes = false;
 476         $elem      = 0;
 477         for ($i;$i<$len;$i++) {
 478                 $c = (string)$str[$i];
 479                 if ($c == '(' && !$in_quotes) {
 480                         $i++;
 481                         $data[$elem] = iil_ParseNamespace2($str, $i, $len, $l++);
 482                         $elem++;
 483                 } else if ($c == ')' && !$in_quotes) {
 484                         return $data;
 485                 } else if ($c == '\\') {
 486                         $i++;
 487                         if ($in_quotes) {
 488                                 $data[$elem] .= $c.$str[$i];
 489                         }
 490                 } else if ($c == '"') {
 491                         $in_quotes = !$in_quotes;
 492                         if (!$in_quotes) {
 493                                 $elem++;
 494                         }
 495                 } else if ($in_quotes) {
 496                         $data[$elem].=$c;
 497                 }
 498         }
 499         return $data;
 500 }
 501
 502 function iil_C_NameSpace(&$conn) {
 503         global $my_prefs;
 504
 505         if (isset($my_prefs['rootdir']) && is_string($my_prefs['rootdir'])) {
 506                 $conn->rootdir = $my_prefs['rootdir'];
 507                 return true;
 508         }
 509
 510         if (!iil_C_GetCapability($conn, 'NAMESPACE')) {
 511             return false;
 512         }
 513
 514         iil_PutLine($conn->fp, "ns1 NAMESPACE");
 515         do {
 516                 $line = iil_ReadLine($conn->fp, 1024);
 517                 if (iil_StartsWith($line, '* NAMESPACE')) {
 518                         $i    = 0;
 519                         $line = iil_UnEscape($line);
 520                         $data = iil_ParseNamespace2(substr($line,11), $i, 0, 0);
 521                 }
 522         } while (!iil_StartsWith($line, 'ns1', true));
 523
 524         if (!is_array($data)) {
 525             return false;
 526         }
 527
 528         $user_space_data = $data[0];
 529         if (!is_array($user_space_data)) {
 530             return false;
 531         }
 532
 533         $first_userspace = $user_space_data[0];
 534         if (count($first_userspace)!=2) {
 535             return false;
 536         }
 537
 538         $conn->rootdir       = $first_userspace[0];
 539         $conn->delimiter     = $first_userspace[1];
 540         $my_prefs['rootdir'] = substr($conn->rootdir, 0, -1);
 541         $my_prefs['delimiter'] = $conn->delimiter;
 542
 543         return true;
 544 }
 545
 546 function iil_Connect($host, $user, $password, $options=null) {
 547         global $iil_error, $iil_errornum;
 548         global $ICL_SSL, $ICL_PORT;
 549         global $my_prefs, $IMAP_USE_INTERNAL_DATE;
 550
 551         $iil_error = '';
 552         $iil_errornum = 0;
 553
 554         // set some imap options
 555         if (is_array($options)) {
 556                 foreach($options as $optkey => $optval) {
 557                         if ($optkey == 'imap') {
 558                                 $auth_method = $optval;
 559                         } else if ($optkey == 'rootdir') {
 560                                 $my_prefs['rootdir'] = $optval;
 561                         } else if ($optkey == 'delimiter') {
 562                                 $my_prefs['delimiter'] = $optval;
 563                         } else if ($optkey == 'debug_mode') {
 564                                 $my_prefs['debug_mode'] = $optval;
 565                         }
 566                 }
 567         }
 568
 569         if (empty($auth_method))
 570                 $auth_method = 'check';
 571
 572         $message = "INITIAL: $auth_method\n";
 573
 574         $result = false;
 575
 576         // initialize connection
 577         $conn              = new iilConnection;
 578         $conn->error       = '';
 579         $conn->errorNum    = 0;
 580         $conn->selected    = '';
 581         $conn->user        = $user;
 582         $conn->host        = $host;
 583
 584         if ($my_prefs['sort_field'] == 'INTERNALDATE') {
 585                 $IMAP_USE_INTERNAL_DATE = true;
 586         } else if ($my_prefs['sort_field'] == 'DATE') {
 587                 $IMAP_USE_INTERNAL_DATE = false;
 588         }
 589
 590         //check input
 591         if (empty($host)) {
 592                 $iil_error = "Empty host";
 593                 $iil_errornum = -1;
 594                 return false;
 595         }
 596         if (empty($user)) {
 597                 $iil_error = "Empty user";
 598                 $iil_errornum = -1;
 599                 return false;
 600         }
 601         if (empty($password)) {
 602                 $iil_error = "Empty password";
 603                 $iil_errornum = -1;
 604                 return false;
 605         }
 606
 607         if (!$ICL_PORT) {
 608                 $ICL_PORT = 143;
 609         }
 610         //check for SSL
 611         if ($ICL_SSL && $ICL_SSL != 'tls') {
 612                 $host = $ICL_SSL . '://' . $host;
 613         }
 614
 615         $conn->fp = fsockopen($host, $ICL_PORT, $errno, $errstr, 10);
 616         if (!$conn->fp) {
 617                 $iil_error = "Could not connect to $host at port $ICL_PORT: $errstr";
 618                 $iil_errornum = -2;
 619                 return false;
 620         }
 621
 622         stream_set_timeout($conn->fp, 10);
 623         $line = stream_get_line($conn->fp, 8192, "\r\n");
 624
 625         if ($my_prefs['debug_mode'] && $line)
 626                 write_log('imap', 'S: '. $line);
 627
 628         // Connected to wrong port or connection error?
 629         if (!preg_match('/^\* (OK|PREAUTH)/i', $line)) {
 630                 if ($line)
 631                         $iil_error = "Wrong startup greeting ($host:$ICL_PORT): $line";
 632                 else
 633                         $iil_error = "Empty startup greeting ($host:$ICL_PORT)";
 634                 $iil_errornum = -2;
 635                 return false;
 636         }
 637
 638         // RFC3501 [7.1] optional CAPABILITY response
 639         if (preg_match('/\[CAPABILITY ([^]]+)\]/i', $line, $matches)) {
 640                 $conn->capability = explode(' ', strtoupper($matches[1]));
 641         }
 642
 643         $conn->message .= $line;
 644
 645         // TLS connection
 646         if ($ICL_SSL == 'tls' && iil_C_GetCapability($conn, 'STARTTLS')) {
 647                 if (version_compare(PHP_VERSION, '5.1.0', '>=')) {
 648                         iil_PutLine($conn->fp, 'stls000 STARTTLS');
 649
 650                         $line = iil_ReadLine($conn->fp, 4096);
 651                         if (!iil_StartsWith($line, 'stls000 OK')) {
 652                                 $iil_error = "Server responded to STARTTLS with: $line";
 653                                 $iil_errornum = -2;
 654                                 return false;
 655                         }
 656
 657                         if (!stream_socket_enable_crypto($conn->fp, true, STREAM_CRYPTO_METHOD_TLS_CLIENT)) {
 658                                 $iil_error = "Unable to negotiate TLS";
 659                                 $iil_errornum = -2;
 660                                 return false;
 661                         }
 662
 663                         // Now we're authenticated, capabilities need to be reread
 664                         iil_C_ClearCapability($conn);
 665                 }
 666         }
 667
 668         if (strcasecmp($auth_method, "check") == 0) {
 669                 //check for supported auth methods
 670                 if (iil_C_GetCapability($conn, 'AUTH=CRAM-MD5') || iil_C_GetCapability($conn, 'AUTH=CRAM_MD5')) {
 671                         $auth_method = 'auth';
 672                 }
 673                 else {
 674                         //default to plain text auth
 675                         $auth_method = 'plain';
 676                 }
 677         }
 678
 679         if (strcasecmp($auth_method, 'auth') == 0) {
 680                 $conn->message .= "Trying CRAM-MD5\n";
 681
 682                 //do CRAM-MD5 authentication
 683                 iil_PutLine($conn->fp, "a000 AUTHENTICATE CRAM-MD5");
 684                 $line = trim(iil_ReadLine($conn->fp, 1024));
 685
 686                 $conn->message .= "$line\n";
 687
 688                 if ($line[0] == '+') {
 689                         $conn->message .= 'Got challenge: ' . htmlspecialchars($line) . "\n";
 690
 691                         //got a challenge string, try CRAM-5
 692                         $result = iil_C_Authenticate($conn, $user, $password, substr($line,2));
 693
 694                         // stop if server sent BYE response
 695                         if($result == -3) {
 696                                 $iil_error = $conn->error;
 697                                 $iil_errornum = $conn->errorNum;
 698                                 return false;
 699                         }
 700                         $conn->message .= "Tried CRAM-MD5: $result \n";
 701                 } else {
 702                         $conn->message .='No challenge ('.htmlspecialchars($line)."), try plain\n";
 703                         $auth = 'plain';
 704                 }
 705         }
 706
 707         if ((!$result)||(strcasecmp($auth, "plain") == 0)) {
 708                 //do plain text auth
 709                 $result = iil_C_Login($conn, $user, $password);
 710                 $conn->message .= "Tried PLAIN: $result \n";
 711         }
 712
 713         $conn->message .= $auth;
 714
 715         if (!is_int($result)) {
 716                 iil_C_Namespace($conn);
 717                 return $conn;
 718         } else {
 719                 $iil_error = $conn->error;
 720                 $iil_errornum = $conn->errorNum;
 721                 return false;
 722         }
 723 }
 724
 725 function iil_Close(&$conn) {
 726         if (iil_PutLine($conn->fp, "I LOGOUT")) {
 727                 fgets($conn->fp, 1024);
 728                 fclose($conn->fp);
 729                 $conn->fp = false;
 730         }
 731 }
 732
 733 function iil_ExplodeQuotedString($delimiter, $string) {
 734         $result = array();
 735         $strlen = strlen($string);
 736
 737         for ($q=$p=$i=0; $i < $strlen; $i++) {
 738                 if ($string[$i] == "\"" && $string[$i-1] != "\\") {
 739                         $q = $q ? false : true;
 740                 }
 741                 else if (!$q && preg_match("/$delimiter/", $string[$i])) {
 742                         $result[] = substr($string, $p, $i - $p);
 743                         $p = $i + 1;
 744                 }
 745         }
 746
 747         $result[] = substr($string, $p);
 748         return $result;
 749 }
 750
 751 function iil_CheckForRecent($host, $user, $password, $mailbox) {
 752         if (empty($mailbox)) {
 753                 $mailbox = 'INBOX';
 754         }
 755
 756         $conn = iil_Connect($host, $user, $password, 'plain');
 757         $fp   = $conn->fp;
 758         if ($fp) {
 759                 iil_PutLine($fp, "a002 EXAMINE \"".iil_Escape($mailbox)."\"");
 760                 do {
 761                         $line=chop(iil_ReadLine($fp, 300));
 762                         $a=explode(' ', $line);
 763                         if (($a[0] == '*') && (strcasecmp($a[2], 'RECENT') == 0)) {
 764                             $result = (int) $a[1];
 765                         }
 766                 } while (!iil_StartsWith($a[0], 'a002', true));
 767
 768                 iil_PutLine($fp, "a003 LOGOUT");
 769                 fclose($fp);
 770         } else {
 771             $result = -2;
 772         }
 773
 774         return $result;
 775 }
 776
 777 function iil_C_Select(&$conn, $mailbox) {
 778
 779         if (empty($mailbox)) {
 780                 return false;
 781         }
 782         if (strcmp($conn->selected, $mailbox) == 0) {
 783                 return true;
 784         }
 785
 786         if (iil_PutLine($conn->fp, "sel1 SELECT \"".iil_Escape($mailbox).'"')) {
 787                 do {
 788                         $line = chop(iil_ReadLine($conn->fp, 300));
 789                         $a = explode(' ', $line);
 790                         if (count($a) == 3) {
 791                                 if (strcasecmp($a[2], 'EXISTS') == 0) {
 792                                         $conn->exists = (int) $a[1];
 793                                 }
 794                                 else if (strcasecmp($a[2], 'RECENT') == 0) {
 795                                         $conn->recent = (int) $a[1];
 796                                 }
 797                         }
 798                         else if (preg_match('/\[?PERMANENTFLAGS\s+\(([^\)]+)\)\]/U', $line, $match)) {
 799                                 $conn->permanentflags = explode(' ', $match[1]);
 800                         }
 801                 } while (!iil_StartsWith($line, 'sel1', true));
 802
 803                 $a = explode(' ', $line);
 804
 805                 if (strcasecmp($a[1], 'OK') == 0) {
 806                         $conn->selected = $mailbox;
 807                         return true;
 808                 }
 809         }
 810         return false;
 811 }
 812
 813 function iil_C_CheckForRecent(&$conn, $mailbox) {
 814         if (empty($mailbox)) {
 815                 $mailbox = 'INBOX';
 816         }
 817
 818         iil_C_Select($conn, $mailbox);
 819         if ($conn->selected == $mailbox) {
 820                 return $conn->recent;
 821         }
 822         return false;
 823 }
 824
 825 function iil_C_CountMessages(&$conn, $mailbox, $refresh = false) {
 826         if ($refresh) {
 827                 $conn->selected = '';
 828         }
 829
 830         iil_C_Select($conn, $mailbox);
 831         if ($conn->selected == $mailbox) {
 832                 return $conn->exists;
 833         }
 834         return false;
 835 }
 836
 837 function iil_SplitHeaderLine($string) {
 838         $pos=strpos($string, ':');
 839         if ($pos>0) {
 840                 $res[0] = substr($string, 0, $pos);
 841                 $res[1] = trim(substr($string, $pos+1));
 842                 return $res;
 843         }
 844         return $string;
 845 }
 846
 847 function iil_StrToTime($date) {
 848
 849         // support non-standard "GMTXXXX" literal
 850         $date = preg_replace('/GMT\s*([+-][0-9]+)/', '\\1', $date);
 851         // if date parsing fails, we have a date in non-rfc format.
 852         // remove token from the end and try again
 853         while ((($ts = @strtotime($date))===false) || ($ts < 0))
 854         {
 855                 $d = explode(' ', $date);
 856                 array_pop($d);
 857                 if (!$d) break;
 858                 $date = implode(' ', $d);
 859         }
 860
 861         $ts = (int) $ts;
 862
 863         return $ts < 0 ? 0 : $ts;
 864 }
 865
 866 function iil_C_Sort(&$conn, $mailbox, $field, $add='', $is_uid=FALSE,
 867     $encoding = 'US-ASCII') {
 868
 869         $field = strtoupper($field);
 870         if ($field == 'INTERNALDATE') {
 871             $field = 'ARRIVAL';
 872         }
 873
 874         $fields = array('ARRIVAL' => 1,'CC' => 1,'DATE' => 1,
 875         'FROM' => 1, 'SIZE' => 1, 'SUBJECT' => 1, 'TO' => 1);
 876
 877         if (!$fields[$field]) {
 878             return false;
 879         }
 880
 881         /*  Do "SELECT" command */
 882         if (!iil_C_Select($conn, $mailbox)) {
 883             return false;
 884         }
 885
 886         $is_uid = $is_uid ? 'UID ' : '';
 887
 888         if (!empty($add)) {
 889             $add = " $add";
 890         }
 891
 892         $command  = 's ' . $is_uid . 'SORT (' . $field . ') ';
 893         $command .= $encoding . ' ALL' . $add;
 894         $line     = $data = '';
 895
 896         if (!iil_PutLineC($conn->fp, $command)) {
 897             return false;
 898         }
 899         do {
 900                 $line = chop(iil_ReadLine($conn->fp));
 901                 if (iil_StartsWith($line, '* SORT')) {
 902                         $data .= substr($line, 7);
 903                 } else if (preg_match('/^[0-9 ]+$/', $line)) {
 904                         $data .= $line;
 905                 }
 906         } while (!iil_StartsWith($line, 's ', true));
 907
 908         $result_code = iil_ParseResult($line);
 909
 910         if ($result_code != 0) {
 911                 $conn->error = 'iil_C_Sort: ' . $line . "\n";
 912                 return false;
 913         }
 914
 915         return preg_split('/\s+/', $data, -1, PREG_SPLIT_NO_EMPTY);
 916 }
 917
 918 function iil_C_FetchHeaderIndex(&$conn, $mailbox, $message_set, $index_field='', $skip_deleted=true) {
 919
 920         list($from_idx, $to_idx) = explode(':', $message_set);
 921         if (empty($message_set) ||
 922                 (isset($to_idx) && $to_idx != '*' && (int)$from_idx > (int)$to_idx)) {
 923                 return false;
 924         }
 925
 926         $index_field = empty($index_field) ? 'DATE' : strtoupper($index_field);
 927
 928         $fields_a['DATE']         = 1;
 929         $fields_a['INTERNALDATE'] = 4;
 930         $fields_a['FROM']         = 1;
 931         $fields_a['REPLY-TO']     = 1;
 932         $fields_a['SENDER']       = 1;
 933         $fields_a['TO']           = 1;
 934         $fields_a['SUBJECT']      = 1;
 935         $fields_a['UID']          = 2;
 936         $fields_a['SIZE']         = 2;
 937         $fields_a['SEEN']         = 3;
 938         $fields_a['RECENT']       = 3;
 939         $fields_a['DELETED']      = 3;
 940
 941         if (!($mode = $fields_a[$index_field])) {
 942                 return false;
 943         }
 944
 945         /*  Do "SELECT" command */
 946         if (!iil_C_Select($conn, $mailbox)) {
 947                 return false;
 948         }
 949
 950         // build FETCH command string
 951         $key     = 'fhi0';
 952         $deleted = $skip_deleted ? ' FLAGS' : '';
 953
 954         if ($mode == 1)
 955                 $request = " FETCH $message_set (BODY.PEEK[HEADER.FIELDS ($index_field)]$deleted)";
 956         else if ($mode == 2) {
 957                 if ($index_field == 'SIZE')
 958                         $request = " FETCH $message_set (RFC822.SIZE$deleted)";
 959                 else
 960                         $request = " FETCH $message_set ($index_field$deleted)";
 961         } else if ($mode == 3)
 962                 $request = " FETCH $message_set (FLAGS)";
 963         else // 4
 964                 $request = " FETCH $message_set (INTERNALDATE$deleted)";
 965
 966         $request = $key . $request;
 967
 968         if (!iil_PutLine($conn->fp, $request))
 969                 return false;
 970
 971         $result = array();
 972
 973         do {
 974                 $line = chop(iil_ReadLine($conn->fp, 200));
 975                 $line = iil_MultLine($conn->fp, $line);
 976
 977                 if (preg_match('/^\* ([0-9]+) FETCH/', $line, $m)) {
 978
 979                         $id = $m[1];
 980                         $flags = NULL;
 981
 982                         if ($skip_deleted && preg_match('/FLAGS \(([^)]+)\)/', $line, $matches)) {
 983                                 $flags = explode(' ', strtoupper($matches[1]));
 984                                 if (in_array('\\DELETED', $flags)) {
 985                                         $deleted[$id] = $id;
 986                                         continue;
 987                                 }
 988                         }
 989
 990                         if ($mode == 1) {
 991                                 if (preg_match('/BODY\[HEADER\.FIELDS \("?(DATE|FROM|REPLY-TO|SENDER|TO|SUBJECT)"?\)\] (.*)/', $line, $matches)) {
 992                                         $value = preg_replace(array('/^"*[a-z]+:/i', '/\s+$/sm'), array('', ''), $matches[2]);
 993                                         $value = trim($value);
 994                                         if ($index_field == 'DATE') {
 995                                                 $result[$id] = iil_StrToTime($value);
 996                                         } else {
 997                                                 $result[$id] = $value;
 998                                         }
 999                                 } else {
1000                                         $result[$id] = '';
1001                                 }
1002                         } else if ($mode == 2) {
1003                                 if (preg_match('/\((UID|RFC822\.SIZE) ([0-9]+)/', $line, $matches)) {
1004                                         $result[$id] = trim($matches[2]);
1005                                 } else {
1006                                         $result[$id] = 0;
1007                                 }
1008                         } else if ($mode == 3) {
1009                                 if (!$flags && preg_match('/FLAGS \(([^)]+)\)/', $line, $matches)) {
1010                                         $flags = explode(' ', $matches[1]);
1011                                 }
1012                                 $result[$id] = in_array('\\'.$index_field, $flags) ? 1 : 0;
1013                         } else if ($mode == 4) {
1014                                 if (preg_match('/INTERNALDATE "([^"]+)"/', $line, $matches)) {
1015                                         $result[$id] = iil_StrToTime($matches[1]);
1016                                 } else {
1017                                         $result[$id] = 0;
1018                                 }
1019                         }
1020                 }
1021         } while (!iil_StartsWith($line, $key, true));
1022
1023 /*
1024         //check number of elements...
1025         if (is_numeric($from_idx) && is_numeric($to_idx)) {
1026                 //count how many we should have
1027                 $should_have = $to_idx - $from_idx + 1;
1028
1029                 //if we have less, try and fill in the "gaps"
1030                 if (count($result) < $should_have) {
1031                         for ($i=$from_idx; $i<=$to_idx; $i++) {
1032                                 if (!isset($result[$i])) {
1033                                         $result[$i] = '';
1034                                 }
1035                         }
1036                 }
1037         }
1038 */
1039         return $result;
1040 }
1041
1042 function iil_CompressMessageSet($message_set) {
1043         //given a comma delimited list of independent mid's,
1044         //compresses by grouping sequences together
1045
1046         //if less than 255 bytes long, let's not bother
1047         if (strlen($message_set)<255) {
1048             return $message_set;
1049         }
1050
1051         //see if it's already been compress
1052         if (strpos($message_set, ':') !== false) {
1053             return $message_set;
1054         }
1055
1056         //separate, then sort
1057         $ids = explode(',', $message_set);
1058         sort($ids);
1059
1060         $result = array();
1061         $start  = $prev = $ids[0];
1062
1063         foreach ($ids as $id) {
1064                 $incr = $id - $prev;
1065                 if ($incr > 1) {                        //found a gap
1066                         if ($start == $prev) {
1067                             $result[] = $prev;  //push single id
1068                         } else {
1069                             $result[] = $start . ':' . $prev;   //push sequence as start_id:end_id
1070                         }
1071                         $start = $id;                   //start of new sequence
1072                 }
1073                 $prev = $id;
1074         }
1075
1076         //handle the last sequence/id
1077         if ($start==$prev) {
1078             $result[] = $prev;
1079         } else {
1080             $result[] = $start.':'.$prev;
1081         }
1082
1083         //return as comma separated string
1084         return implode(',', $result);
1085 }
1086
1087 function iil_C_UIDsToMIDs(&$conn, $mailbox, $uids) {
1088         if (!is_array($uids) || count($uids) == 0) {
1089             return array();
1090         }
1091         return iil_C_Search($conn, $mailbox, 'UID ' . implode(',', $uids));
1092 }
1093
1094 function iil_C_UIDToMID(&$conn, $mailbox, $uid) {
1095         $result = iil_C_UIDsToMIDs($conn, $mailbox, array($uid));
1096         if (count($result) == 1) {
1097             return $result[0];
1098         }
1099         return false;
1100 }
1101
1102 function iil_C_FetchUIDs(&$conn,$mailbox) {
1103         global $clock;
1104
1105         $num = iil_C_CountMessages($conn, $mailbox);
1106         if ($num == 0) {
1107             return array();
1108         }
1109         $message_set = '1' . ($num>1?':' . $num:'');
1110
1111         return iil_C_FetchHeaderIndex($conn, $mailbox, $message_set, 'UID');
1112 }
1113
1114 function iil_SortThreadHeaders($headers, $index_a, $uids) {
1115         asort($index_a);
1116         $result = array();
1117         foreach ($index_a as $mid=>$foobar) {
1118                 $uid = $uids[$mid];
1119                 $result[$uid] = $headers[$uid];
1120         }
1121         return $result;
1122 }
1123
1124 function iil_C_FetchThreadHeaders(&$conn, $mailbox, $message_set) {
1125         global $clock;
1126         global $index_a;
1127
1128         list($from_idx, $to_idx) = explode(':', $message_set);
1129         if (empty($message_set) || (isset($to_idx)
1130         && (int)$from_idx > (int)$to_idx)) {
1131                 return false;
1132         }
1133
1134         $result = array();
1135         $uids   = iil_C_FetchUIDs($conn, $mailbox);
1136         $debug  = false;
1137
1138         $message_set = iil_CompressMessageSet($message_set);
1139
1140         /* if we're missing any, get them */
1141         if ($message_set) {
1142                 /* FETCH date,from,subject headers */
1143                 $key        = 'fh';
1144                 $fp         = $conn->fp;
1145                 $request    = $key . " FETCH $message_set ";
1146                 $request   .= "(BODY.PEEK[HEADER.FIELDS (SUBJECT MESSAGE-ID IN-REPLY-TO)])";
1147                 $mid_to_id  = array();
1148                 if (!iil_PutLine($fp, $request)) {
1149                     return false;
1150                 }
1151                 do {
1152                         $line = chop(iil_ReadLine($fp, 1024));
1153                         if ($debug) {
1154                             echo $line . "\n";
1155                         }
1156                         if (preg_match('/\{[0-9]+\}$/', $line)) {
1157                                 $a       = explode(' ', $line);
1158                                 $new = array();
1159
1160                                 $new_thhd = new iilThreadHeader;
1161                                 $new_thhd->id = $a[1];
1162                                 do {
1163                                         $line = chop(iil_ReadLine($fp, 1024), "\r\n");
1164                                         if (iil_StartsWithI($line, 'Message-ID:')
1165                                                 || (iil_StartsWithI($line,'In-Reply-To:'))
1166                                                 || (iil_StartsWithI($line,'SUBJECT:'))) {
1167
1168                                                 $pos        = strpos($line, ':');
1169                                                 $field_name = substr($line, 0, $pos);
1170                                                 $field_val  = substr($line, $pos+1);
1171
1172                                                 $new[strtoupper($field_name)] = trim($field_val);
1173
1174                                         } else if (preg_match('/^\s+/', $line)) {
1175                                                 $new[strtoupper($field_name)] .= trim($line);
1176                                         }
1177                                 } while ($line[0] != ')');
1178
1179                                 $new_thhd->sbj = $new['SUBJECT'];
1180                                 $new_thhd->mid = substr($new['MESSAGE-ID'], 1, -1);
1181                                 $new_thhd->irt = substr($new['IN-REPLY-TO'], 1, -1);
1182
1183                                 $result[$uids[$new_thhd->id]] = $new_thhd;
1184                         }
1185                 } while (!iil_StartsWith($line, 'fh'));
1186         }
1187
1188         /* sort headers */
1189         if (is_array($index_a)) {
1190                 $result = iil_SortThreadHeaders($result, $index_a, $uids);
1191         }
1192
1193         //echo 'iil_FetchThreadHeaders:'."\n";
1194         //print_r($result);
1195
1196         return $result;
1197 }
1198
1199 function iil_C_BuildThreads2(&$conn, $mailbox, $message_set, &$clock) {
1200         global $index_a;
1201
1202         list($from_idx, $to_idx) = explode(':', $message_set);
1203         if (empty($message_set) || (isset($to_idx)
1204                 && (int)$from_idx > (int)$to_idx)) {
1205                 return false;
1206         }
1207
1208         $result    = array();
1209         $roots     = array();
1210         $root_mids = array();
1211         $sub_mids  = array();
1212         $strays    = array();
1213         $messages  = array();
1214         $fp        = $conn->fp;
1215         $debug     = false;
1216
1217         $sbj_filter_pat = '/[a-z]{2,3}(\[[0-9]*\])?:(\s*)/i';
1218
1219         /*  Do "SELECT" command */
1220         if (!iil_C_Select($conn, $mailbox)) {
1221             return false;
1222         }
1223
1224         /* FETCH date,from,subject headers */
1225         $mid_to_id = array();
1226         $messages  = array();
1227         $headers   = iil_C_FetchThreadHeaders($conn, $mailbox, $message_set);
1228         if ($clock) {
1229             $clock->register('fetched headers');
1230         }
1231
1232         if ($debug) {
1233             print_r($headers);
1234         }
1235
1236         /* go through header records */
1237         foreach ($headers as $header) {
1238                 //$id = $header['i'];
1239                 //$new = array('id'=>$id, 'MESSAGE-ID'=>$header['m'],
1240                 //                      'IN-REPLY-TO'=>$header['r'], 'SUBJECT'=>$header['s']);
1241                 $id  = $header->id;
1242                 $new = array('id' => $id, 'MESSAGE-ID' => $header->mid,
1243                         'IN-REPLY-TO' => $header->irt, 'SUBJECT' => $header->sbj);
1244
1245                 /* add to message-id -> mid lookup table */
1246                 $mid_to_id[$new['MESSAGE-ID']] = $id;
1247
1248                 /* if no subject, use message-id */
1249                 if (empty($new['SUBJECT'])) {
1250                     $new['SUBJECT'] = $new['MESSAGE-ID'];
1251                 }
1252
1253                 /* if subject contains 'RE:' or has in-reply-to header, it's a reply */
1254                 $sbj_pre = '';
1255                 $has_re = false;
1256                 if (preg_match($sbj_filter_pat, $new['SUBJECT'])) {
1257                     $has_re = true;
1258                 }
1259                 if ($has_re || $new['IN-REPLY-TO']) {
1260                     $sbj_pre = 'RE:';
1261                 }
1262
1263                 /* strip out 're:', 'fw:' etc */
1264                 if ($has_re) {
1265                     $sbj = preg_replace($sbj_filter_pat, '', $new['SUBJECT']);
1266                 } else {
1267                     $sbj = $new['SUBJECT'];
1268                 }
1269                 $new['SUBJECT'] = $sbj_pre.$sbj;
1270
1271
1272                 /* if subject not a known thread-root, add to list */
1273                 if ($debug) {
1274                     echo $id . ' ' . $new['SUBJECT'] . "\t" . $new['MESSAGE-ID'] . "\n";
1275                 }
1276                 $root_id = $roots[$sbj];
1277
1278                 if ($root_id && ($has_re || !$root_in_root[$root_id])) {
1279                         if ($debug) {
1280                             echo "\tfound root: $root_id\n";
1281                         }
1282                         $sub_mids[$new['MESSAGE-ID']] = $root_id;
1283                         $result[$root_id][]           = $id;
1284                 } else if (!isset($roots[$sbj]) || (!$has_re && $root_in_root[$root_id])) {
1285                         /* try to use In-Reply-To header to find root
1286                                 unless subject contains 'Re:' */
1287                         if ($has_re&&$new['IN-REPLY-TO']) {
1288                                 if ($debug) {
1289                                     echo "\tlooking: ".$new['IN-REPLY-TO']."\n";
1290                                 }
1291                                 //reply to known message?
1292                                 $temp = $sub_mids[$new['IN-REPLY-TO']];
1293
1294                                 if ($temp) {
1295                                         //found it, root:=parent's root
1296                                         if ($debug) {
1297                                             echo "\tfound parent: ".$new['SUBJECT']."\n";
1298                                         }
1299                                         $result[$temp][]              = $id;
1300                                         $sub_mids[$new['MESSAGE-ID']] = $temp;
1301                                         $sbj                          = '';
1302                                 } else {
1303                                         //if we can't find referenced parent, it's a "stray"
1304                                         $strays[$id] = $new['IN-REPLY-TO'];
1305                                 }
1306                         }
1307
1308                         //add subject as root
1309                         if ($sbj) {
1310                                 if ($debug) {
1311                                     echo "\t added to root\n";
1312                                 }
1313                                 $roots[$sbj]                  = $id;
1314                                 $root_in_root[$id]            = !$has_re;
1315                                 $sub_mids[$new['MESSAGE-ID']] = $id;
1316                                 $result[$id]                  = array($id);
1317                         }
1318                         if ($debug) {
1319                             echo $new['MESSAGE-ID'] . "\t" . $sbj . "\n";
1320                         }
1321                 }
1322         }
1323
1324         //now that we've gone through all the messages,
1325         //go back and try and link up the stray threads
1326         if (count($strays) > 0) {
1327                 foreach ($strays as $id=>$irt) {
1328                         $root_id = $sub_mids[$irt];
1329                         if (!$root_id || $root_id==$id) {
1330                             continue;
1331                         }
1332                         $result[$root_id] = array_merge($result[$root_id],$result[$id]);
1333                         unset($result[$id]);
1334                 }
1335         }
1336
1337         if ($clock) {
1338             $clock->register('data prepped');
1339         }
1340
1341         if ($debug) {
1342             print_r($roots);
1343         }
1344
1345         return $result;
1346 }
1347
1348 function iil_SortThreads(&$tree, $index, $sort_order = 'ASC') {
1349         if (!is_array($tree) || !is_array($index)) {
1350             return false;
1351         }
1352
1353         //create an id to position lookup table
1354         $i = 0;
1355         foreach ($index as $id=>$val) {
1356                 $i++;
1357                 $index[$id] = $i;
1358         }
1359         $max = $i+1;
1360
1361         //for each tree, set array key to position
1362         $itree = array();
1363         foreach ($tree as $id=>$node) {
1364                 if (count($tree[$id])<=1) {
1365                         //for "threads" with only one message, key is position of that message
1366                         $n         = $index[$id];
1367                         $itree[$n] = array($n=>$id);
1368                 } else {
1369                         //for "threads" with multiple messages,
1370                         $min   = $max;
1371                         $new_a = array();
1372                         foreach ($tree[$id] as $mid) {
1373                                 $new_a[$index[$mid]] = $mid;            //create new sub-array mapping position to id
1374                                 $pos                 = $index[$mid];
1375                                 if ($pos&&$pos<$min) {
1376                                     $min = $index[$mid];        //find smallest position
1377                                 }
1378                         }
1379                         $n = $min;      //smallest position of child is thread position
1380
1381                         //assign smallest position to root level key
1382                         //set children array to one created above
1383                         ksort($new_a);
1384                         $itree[$n] = $new_a;
1385                 }
1386         }
1387
1388         //sort by key, this basically sorts all threads
1389         ksort($itree);
1390         $i   = 0;
1391         $out = array();
1392         foreach ($itree as $k=>$node) {
1393                 $out[$i] = $itree[$k];
1394                 $i++;
1395         }
1396
1397         return $out;
1398 }
1399
1400 function iil_IndexThreads(&$tree) {
1401         /* creates array mapping mid to thread id */
1402
1403         if (!is_array($tree)) {
1404             return false;
1405         }
1406
1407         $t_index = array();
1408         foreach ($tree as $pos=>$kids) {
1409                 foreach ($kids as $kid) $t_index[$kid] = $pos;
1410         }
1411
1412         return $t_index;
1413 }
1414
1415 function iil_C_FetchHeaders(&$conn, $mailbox, $message_set, $uidfetch=false, $bodystr=false, $add='')
1416 {
1417         global $IMAP_USE_INTERNAL_DATE;
1418
1419         $result = array();
1420         $fp     = $conn->fp;
1421
1422         /*  Do "SELECT" command */
1423         if (!iil_C_Select($conn, $mailbox)) {
1424                 $conn->error = "Couldn't select $mailbox";
1425                 return false;
1426         }
1427
1428         $message_set = iil_CompressMessageSet($message_set);
1429
1430         if ($add)
1431                 $add = ' '.strtoupper(trim($add));
1432
1433         /* FETCH uid, size, flags and headers */
1434         $key      = 'FH12';
1435         $request  = $key . ($uidfetch ? ' UID' : '') . " FETCH $message_set ";
1436         $request .= "(UID RFC822.SIZE FLAGS INTERNALDATE ";
1437         if ($bodystr)
1438                 $request .= "BODYSTRUCTURE ";
1439         $request .= "BODY.PEEK[HEADER.FIELDS ";
1440         $request .= "(DATE FROM TO SUBJECT REPLY-TO IN-REPLY-TO CC BCC ";
1441         $request .= "CONTENT-TRANSFER-ENCODING CONTENT-TYPE MESSAGE-ID ";
1442         $request .= "REFERENCES DISPOSITION-NOTIFICATION-TO X-PRIORITY".$add.")])";
1443
1444         if (!iil_PutLine($fp, $request)) {
1445                 return false;
1446         }
1447         do {
1448                 $line = iil_ReadLine($fp, 1024);
1449                 $line = iil_MultLine($fp, $line);
1450
1451                 $a    = explode(' ', $line);
1452                 if (($line[0] == '*') && ($a[2] == 'FETCH')) {
1453                         $id = $a[1];
1454
1455                         $result[$id]            = new iilBasicHeader;
1456                         $result[$id]->id        = $id;
1457                         $result[$id]->subject   = '';
1458                         $result[$id]->messageID = 'mid:' . $id;
1459
1460                         $lines = array();
1461                         $ln = 0;
1462                         /*
1463                             Sample reply line:
1464                             * 321 FETCH (UID 2417 RFC822.SIZE 2730 FLAGS (\Seen)
1465                             INTERNALDATE "16-Nov-2008 21:08:46 +0100" BODYSTRUCTURE (...)
1466                             BODY[HEADER.FIELDS ...
1467                         */
1468
1469                         if (preg_match('/^\* [0-9]+ FETCH \((.*) BODY/s', $line, $matches)) {
1470                                 $str = $matches[1];
1471
1472                                 // swap parents with quotes, then explode
1473                                 $str = preg_replace('/[()]/', '"', $str);
1474                                 $a = iil_ExplodeQuotedString(' ', $str);
1475
1476                                 // did we get the right number of replies?
1477                                 $parts_count = count($a);
1478                                 if ($parts_count>=6) {
1479                                         for ($i=0; $i<$parts_count; $i=$i+2) {
1480                                                 if (strcasecmp($a[$i],'UID') == 0)
1481                                                         $result[$id]->uid = $a[$i+1];
1482                                                 else if (strcasecmp($a[$i],'RFC822.SIZE') == 0)
1483                                                         $result[$id]->size = $a[$i+1];
1484                                                 else if (strcasecmp($a[$i],'INTERNALDATE') == 0)
1485                                                         $time_str = $a[$i+1];
1486                                                 else if (strcasecmp($a[$i],'FLAGS') == 0)
1487                                                         $flags_str = $a[$i+1];
1488                                         }
1489
1490                                         $time_str = str_replace('"', '', $time_str);
1491
1492                                         // if time is gmt...
1493                                         $time_str = str_replace('GMT','+0000',$time_str);
1494
1495                                         $result[$id]->internaldate = $time_str;
1496                                         $result[$id]->timestamp = iil_StrToTime($time_str);
1497                                         $result[$id]->date = $time_str;
1498                                 }
1499
1500                                 // BODYSTRUCTURE
1501                                 if($bodystr) {
1502                                         while (!preg_match('/ BODYSTRUCTURE (.*) BODY\[HEADER.FIELDS/s', $line, $m)) {
1503                                                 $line2 = iil_ReadLine($fp, 1024);
1504                                                 $line .= iil_MultLine($fp, $line2, true);
1505                                         }
1506                                         $result[$id]->body_structure = $m[1];
1507                                 }
1508
1509                                 // the rest of the result
1510                                 preg_match('/ BODY\[HEADER.FIELDS \(.*?\)\]\s*(.*)$/s', $line, $m);
1511                                 $reslines = explode("\n", trim($m[1], '"'));
1512                                 // re-parse (see below)
1513                                 foreach ($reslines as $line) {
1514                                         if (ord($line[0])<=32) {
1515                                                 $lines[$ln] .= (empty($lines[$ln])?'':"\n").trim($line);
1516                                         } else {
1517                                                 $lines[++$ln] = trim($line);
1518                                         }
1519                                 }
1520                         }
1521
1522                         /*
1523                                 Start parsing headers.  The problem is, some header "lines" take up multiple lines.
1524                                 So, we'll read ahead, and if the one we're reading now is a valid header, we'll
1525                                 process the previous line.  Otherwise, we'll keep adding the strings until we come
1526                                 to the next valid header line.
1527                         */
1528
1529                         do {
1530                                 $line = chop(iil_ReadLine($fp, 300), "\r\n");
1531
1532                                 // The preg_match below works around communigate imap, which outputs " UID <number>)".
1533                                 // Without this, the while statement continues on and gets the "FH0 OK completed" message.
1534                                 // If this loop gets the ending message, then the outer loop does not receive it from radline on line 1249.
1535                                 // This in causes the if statement on line 1278 to never be true, which causes the headers to end up missing
1536                                 // If the if statement was changed to pick up the fh0 from this loop, then it causes the outer loop to spin
1537                                 // An alternative might be:
1538                                 // if (!preg_match("/:/",$line) && preg_match("/\)$/",$line)) break;
1539                                 // however, unsure how well this would work with all imap clients.
1540                                 if (preg_match("/^\s*UID [0-9]+\)$/", $line)) {
1541                                     break;
1542                                 }
1543
1544                                 // handle FLAGS reply after headers (AOL, Zimbra?)
1545                                 if (preg_match('/\s+FLAGS \((.*)\)\)$/', $line, $matches)) {
1546                                         $flags_str = $matches[1];
1547                                         break;
1548                                 }
1549
1550                                 if (ord($line[0])<=32) {
1551                                         $lines[$ln] .= (empty($lines[$ln])?'':"\n").trim($line);
1552                                 } else {
1553                                         $lines[++$ln] = trim($line);
1554                                 }
1555                         // patch from "Maksim Rubis" <siburny@hotmail.com>
1556                         } while (trim($line[0]) != ')' && strncmp($line, $key, strlen($key)));
1557
1558                         if (strncmp($line, $key, strlen($key))) {
1559                                 // process header, fill iilBasicHeader obj.
1560                                 // initialize
1561                                 if (is_array($headers)) {
1562                                         reset($headers);
1563                                         while (list($k, $bar) = each($headers)) {
1564                                                 $headers[$k] = '';
1565                                         }
1566                                 }
1567
1568                                 // create array with header field:data
1569                                 while ( list($lines_key, $str) = each($lines) ) {
1570                                         list($field, $string) = iil_SplitHeaderLine($str);
1571
1572                                         $field  = strtolower($field);
1573                                         $string = preg_replace('/\n\s*/', ' ', $string);
1574
1575                                         switch ($field) {
1576                                         case 'date';
1577                                                 if (!$IMAP_USE_INTERNAL_DATE) {
1578                                                         $result[$id]->date = $string;
1579                                                         $result[$id]->timestamp = iil_StrToTime($string);
1580                                                 }
1581                                                 break;
1582                                         case 'from':
1583                                                 $result[$id]->from = $string;
1584                                                 break;
1585                                         case 'to':
1586                                                 $result[$id]->to = preg_replace('/undisclosed-recipients:[;,]*/', '', $string);
1587                                                 break;
1588                                         case 'subject':
1589                                                 $result[$id]->subject = $string;
1590                                                 break;
1591                                         case 'reply-to':
1592                                                 $result[$id]->replyto = $string;
1593                                                 break;
1594                                         case 'cc':
1595                                                 $result[$id]->cc = $string;
1596                                                 break;
1597                                         case 'bcc':
1598                                                 $result[$id]->bcc = $string;
1599                                                 break;
1600                                         case 'content-transfer-encoding':
1601                                                 $result[$id]->encoding = $string;
1602                                                 break;
1603                                         case 'content-type':
1604                                                 $ctype_parts = explode(";", $string);
1605                                                 $result[$id]->ctype = array_shift($ctype_parts);
1606                                                 foreach ($ctype_parts as $ctype_add) {
1607                                                         if (preg_match('/charset="?([a-z0-9\-\.\_]+)"?/i',
1608                                                                 $ctype_add, $regs)) {
1609                                                                 $result[$id]->charset = $regs[1];
1610                                                         }
1611                                                 }
1612                                                 break;
1613                                         case 'in-reply-to':
1614                                                 $result[$id]->in_reply_to = preg_replace('/[\n<>]/', '', $string);
1615                                                 break;
1616                                         case 'references':
1617                                                 $result[$id]->references = $string;
1618                                                 break;
1619                                         case 'return-receipt-to':
1620                                         case 'disposition-notification-to':
1621                                         case 'x-confirm-reading-to':
1622                                                 $result[$id]->mdn_to = $string;
1623                                                 break;
1624                                         case 'message-id':
1625                                                 $result[$id]->messageID = $string;
1626                                                 break;
1627                                         case 'x-priority':
1628                                                 if (preg_match('/^(\d+)/', $string, $matches))
1629                                                         $result[$id]->priority = intval($matches[1]);
1630                                                 break;
1631                                         default:
1632                                                 if (strlen($field) > 2)
1633                                                         $result[$id]->others[$field] = $string;
1634                                                 break;
1635                                         } // end switch ()
1636                                 } // end while ()
1637                         } else {
1638                                 $a = explode(' ', $line);
1639                         }
1640
1641                         // process flags
1642                         if (!empty($flags_str)) {
1643                                 $flags_str = preg_replace('/[\\\"]/', '', $flags_str);
1644                                 $flags_a   = explode(' ', $flags_str);
1645
1646                                 if (is_array($flags_a)) {
1647                                         reset($flags_a);
1648                                         while (list(,$val)=each($flags_a)) {
1649                                                 if (strcasecmp($val,'Seen') == 0) {
1650                                                     $result[$id]->seen = true;
1651                                                 } else if (strcasecmp($val, 'Deleted') == 0) {
1652                                                     $result[$id]->deleted=true;
1653                                                 } else if (strcasecmp($val, 'Recent') == 0) {
1654                                                     $result[$id]->recent = true;
1655                                                 } else if (strcasecmp($val, 'Answered') == 0) {
1656                                                         $result[$id]->answered = true;
1657                                                 } else if (strcasecmp($val, '$Forwarded') == 0) {
1658                                                         $result[$id]->forwarded = true;
1659                                                 } else if (strcasecmp($val, 'Draft') == 0) {
1660                                                         $result[$id]->is_draft = true;
1661                                                 } else if (strcasecmp($val, '$MDNSent') == 0) {
1662                                                         $result[$id]->mdn_sent = true;
1663                                                 } else if (strcasecmp($val, 'Flagged') == 0) {
1664                                                          $result[$id]->flagged = true;
1665                                                 }
1666                                         }
1667                                         $result[$id]->flags = $flags_a;
1668                                 }
1669                         }
1670                 }
1671         } while (strcmp($a[0], $key) != 0);
1672
1673         return $result;
1674 }
1675
1676 function iil_C_FetchHeader(&$conn, $mailbox, $id, $uidfetch=false, $bodystr=false, $add='') {
1677
1678         $a  = iil_C_FetchHeaders($conn, $mailbox, $id, $uidfetch, $bodystr, $add);
1679         if (is_array($a)) {
1680                 return array_shift($a);
1681         }
1682         return false;
1683 }
1684
1685 function iil_SortHeaders($a, $field, $flag) {
1686         if (empty($field)) {
1687             $field = 'uid';
1688         }
1689         $field = strtolower($field);
1690         if ($field == 'date' || $field == 'internaldate') {
1691             $field = 'timestamp';
1692         }
1693         if (empty($flag)) {
1694             $flag = 'ASC';
1695         }
1696
1697         $flag     = strtoupper($flag);
1698         $stripArr = ($field=='subject') ? array('Re: ','Fwd: ','Fw: ','"') : array('"');
1699
1700         $c=count($a);
1701         if ($c > 0) {
1702                 /*
1703                         Strategy:
1704                         First, we'll create an "index" array.
1705                         Then, we'll use sort() on that array,
1706                         and use that to sort the main array.
1707                 */
1708
1709                 // create "index" array
1710                 $index = array();
1711                 reset($a);
1712                 while (list($key, $val)=each($a)) {
1713
1714                         if ($field == 'timestamp') {
1715                                 $data = iil_StrToTime($val->date);
1716                                 if (!$data) {
1717                                         $data = $val->timestamp;
1718                                 }
1719                         } else {
1720                                 $data = $val->$field;
1721                                 if (is_string($data)) {
1722                                         $data=strtoupper(str_replace($stripArr, '', $data));
1723                                 }
1724                         }
1725                         $index[$key]=$data;
1726                 }
1727
1728                 // sort index
1729                 $i = 0;
1730                 if ($flag == 'ASC') {
1731                         asort($index);
1732                 } else {
1733                         arsort($index);
1734                 }
1735
1736                 // form new array based on index
1737                 $result = array();
1738                 reset($index);
1739                 while (list($key, $val)=each($index)) {
1740                         $result[$key]=$a[$key];
1741                         $i++;
1742                 }
1743         }
1744
1745         return $result;
1746 }
1747
1748 function iil_C_Expunge(&$conn, $mailbox, $messages=NULL) {
1749
1750         if (iil_C_Select($conn, $mailbox)) {
1751                 $c = 0;
1752                 $command = $messages ? "UID EXPUNGE $messages" : "EXPUNGE";
1753
1754                 iil_PutLine($conn->fp, "exp1 $command");
1755                 do {
1756                         $line=chop(iil_ReadLine($conn->fp, 100));
1757                         if ($line[0] == '*') {
1758                                 $c++;
1759                         }
1760                 } while (!iil_StartsWith($line, 'exp1', true));
1761
1762                 if (iil_ParseResult($line) == 0) {
1763                         $conn->selected = ''; //state has changed, need to reselect
1764                         //$conn->exists-=$c;
1765                         return $c;
1766                 }
1767                 $conn->error = $line;
1768         }
1769
1770         return -1;
1771 }
1772
1773 function iil_C_ModFlag(&$conn, $mailbox, $messages, $flag, $mod) {
1774         if ($mod != '+' && $mod != '-') {
1775             return -1;
1776         }
1777
1778         $fp    = $conn->fp;
1779         $flags = $GLOBALS['IMAP_FLAGS'];
1780
1781         $flag = strtoupper($flag);
1782         $flag = $flags[$flag];
1783
1784         if (iil_C_Select($conn, $mailbox)) {
1785                 $c = 0;
1786                 iil_PutLine($fp, "flg UID STORE $messages " . $mod . "FLAGS (" . $flag . ")");
1787                 do {
1788                         $line=chop(iil_ReadLine($fp, 100));
1789                         if ($line[0] == '*') {
1790                             $c++;
1791                         }
1792                 } while (!iil_StartsWith($line, 'flg', true));
1793
1794                 if (iil_ParseResult($line) == 0) {
1795                         return $c;
1796                 }
1797                 $conn->error = $line;
1798                 return -1;
1799         }
1800         $conn->error = 'Select failed';
1801         return -1;
1802 }
1803
1804 function iil_C_Flag(&$conn, $mailbox, $messages, $flag) {
1805         return iil_C_ModFlag($conn, $mailbox, $messages, $flag, '+');
1806 }
1807
1808 function iil_C_Unflag(&$conn, $mailbox, $messages, $flag) {
1809         return iil_C_ModFlag($conn, $mailbox, $messages, $flag, '-');
1810 }
1811
1812 function iil_C_Delete(&$conn, $mailbox, $messages) {
1813         return iil_C_ModFlag($conn, $mailbox, $messages, 'DELETED', '+');
1814 }
1815
1816 function iil_C_Copy(&$conn, $messages, $from, $to) {
1817         $fp = $conn->fp;
1818
1819         if (empty($from) || empty($to)) {
1820             return -1;
1821         }
1822
1823         if (iil_C_Select($conn, $from)) {
1824                 $c=0;
1825
1826                 iil_PutLine($fp, "cpy1 UID COPY $messages \"".iil_Escape($to)."\"");
1827                 $line = iil_ReadReply($fp);
1828                 return iil_ParseResult($line);
1829         } else {
1830                 return -1;
1831         }
1832 }
1833
1834 function iil_C_CountUnseen(&$conn, $folder) {
1835         $index = iil_C_Search($conn, $folder, 'ALL UNSEEN');
1836         if (is_array($index))
1837                 return count($index);
1838         return false;
1839 }
1840
1841 function iil_C_UID2ID(&$conn, $folder, $uid) {
1842         if ($uid > 0) {
1843                 $id_a = iil_C_Search($conn, $folder, "UID $uid");
1844                 if (is_array($id_a) && count($id_a) == 1) {
1845                         return $id_a[0];
1846                 }
1847         }
1848         return false;
1849 }
1850
1851 function iil_C_ID2UID(&$conn, $folder, $id) {
1852
1853         if ($id == 0) {
1854             return      -1;
1855         }
1856         $result = -1;
1857         if (iil_C_Select($conn, $folder)) {
1858                 $key = 'fuid';
1859                 if (iil_PutLine($conn->fp, "$key FETCH $id (UID)")) {
1860                         do {
1861                                 $line = chop(iil_ReadLine($conn->fp, 1024));
1862                                 if (preg_match("/^\* $id FETCH \(UID (.*)\)/i", $line, $r)) {
1863                                         $result = $r[1];
1864                                 }
1865                         } while (!iil_StartsWith($line, $key, true));
1866                 }
1867         }
1868         return $result;
1869 }
1870
1871 function iil_C_Search(&$conn, $folder, $criteria) {
1872
1873         if (iil_C_Select($conn, $folder)) {
1874                 $data = '';
1875
1876                 $query = 'srch1 SEARCH ' . chop($criteria);
1877                 if (!iil_PutLineC($conn->fp, $query)) {
1878                         return false;
1879                 }
1880                 do {
1881                         $line = trim(iil_ReadLine($conn->fp));
1882                         if (iil_StartsWith($line, '* SEARCH')) {
1883                                 $data .= substr($line, 8);
1884                         } else if (preg_match('/^[0-9 ]+$/', $line)) {
1885                                 $data .= $line;
1886                         }
1887                 } while (!iil_StartsWith($line, 'srch1', true));
1888
1889                 $result_code = iil_ParseResult($line);
1890                 if ($result_code == 0) {
1891                     return preg_split('/\s+/', $data, -1, PREG_SPLIT_NO_EMPTY);
1892                 }
1893                 $conn->error = 'iil_C_Search: ' . $line . "\n";
1894                 return false;
1895         }
1896         $conn->error = "iil_C_Search: Couldn't select \"$folder\"\n";
1897         return false;
1898 }
1899
1900 function iil_C_Move(&$conn, $messages, $from, $to) {
1901
1902     if (!$from || !$to) {
1903         return -1;
1904     }
1905
1906     $r = iil_C_Copy($conn, $messages, $from, $to);
1907
1908     if ($r==0) {
1909         return iil_C_Delete($conn, $from, $messages);
1910     }
1911     return $r;
1912 }
1913
1914 /**
1915  * Gets the delimiter, for example:
1916  * INBOX.foo -> .
1917  * INBOX/foo -> /
1918  * INBOX\foo -> \
1919  *
1920  * @return mixed A delimiter (string), or false.
1921  * @param object $conn The current connection.
1922  * @see iil_Connect()
1923  */
1924 function iil_C_GetHierarchyDelimiter(&$conn) {
1925
1926         global $my_prefs;
1927
1928         if ($conn->delimiter) {
1929                 return $conn->delimiter;
1930         }
1931         if (!empty($my_prefs['delimiter'])) {
1932             return ($conn->delimiter = $my_prefs['delimiter']);
1933         }
1934
1935         $fp        = $conn->fp;
1936         $delimiter = false;
1937
1938         //try (LIST "" ""), should return delimiter (RFC2060 Sec 6.3.8)
1939         if (!iil_PutLine($fp, 'ghd LIST "" ""')) {
1940             return false;
1941         }
1942
1943         do {
1944                 $line=iil_ReadLine($fp, 500);
1945                 if ($line[0] == '*') {
1946                         $line = rtrim($line);
1947                         $a=iil_ExplodeQuotedString(' ', iil_UnEscape($line));
1948                         if ($a[0] == '*') {
1949                             $delimiter = str_replace('"', '', $a[count($a)-2]);
1950                         }
1951                 }
1952         } while (!iil_StartsWith($line, 'ghd', true));
1953
1954         if (strlen($delimiter)>0) {
1955             return $delimiter;
1956         }
1957
1958         //if that fails, try namespace extension
1959         //try to fetch namespace data
1960         iil_PutLine($conn->fp, "ns1 NAMESPACE");
1961         do {
1962                 $line = iil_ReadLine($conn->fp, 1024);
1963                 if (iil_StartsWith($line, '* NAMESPACE')) {
1964                         $i = 0;
1965                         $line = iil_UnEscape($line);
1966                         $data = iil_ParseNamespace2(substr($line,11), $i, 0, 0);
1967                 }
1968         } while (!iil_StartsWith($line, 'ns1', true));
1969
1970         if (!is_array($data)) {
1971             return false;
1972         }
1973
1974         //extract user space data (opposed to global/shared space)
1975         $user_space_data = $data[0];
1976         if (!is_array($user_space_data)) {
1977             return false;
1978         }
1979
1980         //get first element
1981         $first_userspace = $user_space_data[0];
1982         if (!is_array($first_userspace)) {
1983             return false;
1984         }
1985
1986         //extract delimiter
1987         $delimiter = $first_userspace[1];
1988
1989         return $delimiter;
1990 }
1991
1992 function iil_C_ListMailboxes(&$conn, $ref, $mailbox) {
1993         global $IGNORE_FOLDERS;
1994
1995         $ignore = $IGNORE_FOLDERS[strtolower($conn->host)];
1996
1997         $fp = $conn->fp;
1998
1999         if (empty($mailbox)) {
2000             $mailbox = '*';
2001         }
2002
2003         if (empty($ref) && $conn->rootdir) {
2004             $ref = $conn->rootdir;
2005         }
2006
2007         // send command
2008         if (!iil_PutLine($fp, "lmb LIST \"".$ref."\" \"".iil_Escape($mailbox)."\"")) {
2009             return false;
2010         }
2011
2012         $i = 0;
2013         // get folder list
2014         do {
2015                 $line = iil_ReadLine($fp, 500);
2016                 $line = iil_MultLine($fp, $line, true);
2017
2018                 $a = explode(' ', $line);
2019                 if (($line[0] == '*') && ($a[1] == 'LIST')) {
2020                         $line = rtrim($line);
2021                         // split one line
2022                         $a = iil_ExplodeQuotedString(' ', $line);
2023                         // last string is folder name
2024                         $folder = preg_replace(array('/^"/', '/"$/'), '', iil_UnEscape($a[count($a)-1]));
2025
2026                         if (empty($ignore) || (!empty($ignore)
2027                                 && !preg_match('/'.preg_quote(ignore, '/').'/i', $folder))) {
2028                                 $folders[$i] = $folder;
2029                         }
2030
2031                         // second from last is delimiter
2032                         $delim = trim($a[count($a)-2], '"');
2033                         // is it a container?
2034                         $i++;
2035                 }
2036         } while (!iil_StartsWith($line, 'lmb', true));
2037
2038         if (is_array($folders)) {
2039             if (!empty($ref)) {
2040                 // if rootdir was specified, make sure it's the first element
2041                 // some IMAP servers (i.e. Courier) won't return it
2042                 if ($ref[strlen($ref)-1]==$delim)
2043                     $ref = substr($ref, 0, strlen($ref)-1);
2044                 if ($folders[0]!=$ref)
2045                     array_unshift($folders, $ref);
2046             }
2047             return $folders;
2048         } else if (iil_ParseResult($line) == 0) {
2049                 return array('INBOX');
2050         } else {
2051                 $conn->error = $line;
2052                 return false;
2053         }
2054 }
2055
2056 function iil_C_ListSubscribed(&$conn, $ref, $mailbox) {
2057         global $IGNORE_FOLDERS;
2058
2059         $ignore = $IGNORE_FOLDERS[strtolower($conn->host)];
2060
2061         $fp = $conn->fp;
2062         if (empty($mailbox)) {
2063                 $mailbox = '*';
2064         }
2065         if (empty($ref) && $conn->rootdir) {
2066                 $ref = $conn->rootdir;
2067         }
2068         $folders = array();
2069
2070         // send command
2071         if (!iil_PutLine($fp, 'lsb LSUB "' . $ref . '" "' . iil_Escape($mailbox).'"')) {
2072                 $conn->error = "Couldn't send LSUB command\n";
2073                 return false;
2074         }
2075
2076         $i = 0;
2077
2078         // get folder list
2079         do {
2080                 $line = iil_ReadLine($fp, 500);
2081                 $line = iil_MultLine($fp, $line, true);
2082                 $a    = explode(' ', $line);
2083
2084                 if (($line[0] == '*') && ($a[1] == 'LSUB' || $a[1] == 'LIST')) {
2085                         $line = rtrim($line);
2086
2087                         // split one line
2088                         $a = iil_ExplodeQuotedString(' ', $line);
2089                         // last string is folder name
2090                         $folder = preg_replace(array('/^"/', '/"$/'), '', iil_UnEscape($a[count($a)-1]));
2091
2092                         if ((!in_array($folder, $folders)) && (empty($ignore)
2093                                 || (!empty($ignore) && !preg_match('/'.preg_quote(ignore, '/').'/i', $folder)))) {
2094                             $folders[$i] = $folder;
2095                         }
2096
2097                         // second from last is delimiter
2098                         $delim = trim($a[count($a)-2], '"');
2099
2100                         // is it a container?
2101                         $i++;
2102                 }
2103         } while (!iil_StartsWith($line, 'lsb', true));
2104
2105         if (is_array($folders)) {
2106             if (!empty($ref)) {
2107                 // if rootdir was specified, make sure it's the first element
2108                 // some IMAP servers (i.e. Courier) won't return it
2109                 if ($ref[strlen($ref)-1]==$delim) {
2110                     $ref = substr($ref, 0, strlen($ref)-1);
2111                 }
2112                 if ($folders[0]!=$ref) {
2113                     array_unshift($folders, $ref);
2114                 }
2115             }
2116             return $folders;
2117         }
2118         $conn->error = $line;
2119         return false;
2120 }
2121
2122 function iil_C_Subscribe(&$conn, $folder) {
2123         $fp = $conn->fp;
2124
2125         $query = 'sub1 SUBSCRIBE "' . iil_Escape($folder). '"';
2126         iil_PutLine($fp, $query);
2127
2128         $line = trim(iil_ReadLine($fp, 512));
2129         return (iil_ParseResult($line) == 0);
2130 }
2131
2132 function iil_C_UnSubscribe(&$conn, $folder) {
2133         $fp = $conn->fp;
2134
2135         $query = 'usub1 UNSUBSCRIBE "' . iil_Escape($folder) . '"';
2136         iil_PutLine($fp, $query);
2137
2138         $line = trim(iil_ReadLine($fp, 512));
2139         return (iil_ParseResult($line) == 0);
2140 }
2141
2142 function iil_C_FetchMIMEHeaders(&$conn, $mailbox, $id, $parts) {
2143
2144         $fp     = $conn->fp;
2145
2146         if (!iil_C_Select($conn, $mailbox)) {
2147                 return false;
2148         }
2149
2150         $result = false;
2151         $parts = (array) $parts;
2152         $key = 'fmh0';
2153         $peeks = '';
2154         $idx = 0;
2155
2156         // format request
2157         foreach($parts as $part)
2158                 $peeks[] = "BODY.PEEK[$part.MIME]";
2159
2160         $request = "$key FETCH $id (" . implode(' ', $peeks) . ')';
2161
2162         // send request
2163         if (!iil_PutLine($fp, $request)) {
2164             return false;
2165         }
2166
2167         do {
2168                 $line = iil_ReadLine($fp, 1000);
2169                 $line = iil_MultLine($fp, $line);
2170
2171                 if (preg_match('/BODY\[([0-9\.]+)\.MIME\]/', $line, $matches)) {
2172                         $idx = $matches[1];
2173                         $result[$idx] = preg_replace('/^(\* '.$id.' FETCH \()?\s*BODY\['.$idx.'\.MIME\]\s+/', '', $line);
2174                         $result[$idx] = trim($result[$idx], '"');
2175                         $result[$idx] = rtrim($result[$idx], "\t\r\n\0\x0B");
2176                 }
2177         } while (!iil_StartsWith($line, $key, true));
2178
2179         return $result;
2180 }
2181
2182 function iil_C_FetchPartHeader(&$conn, $mailbox, $id, $is_uid=false, $part=NULL) {
2183
2184         $part = empty($part) ? 'HEADER' : $part.'.MIME';
2185
2186         return iil_C_HandlePartBody($conn, $mailbox, $id, $is_uid, $part);
2187 }
2188
2189 function iil_C_HandlePartBody(&$conn, $mailbox, $id, $is_uid=false, $part='', $encoding=NULL, $print=NULL, $file=NULL) {
2190
2191         $fp     = $conn->fp;
2192         $result = false;
2193
2194         switch ($encoding) {
2195                 case 'base64':
2196                         $mode = 1;
2197                 break;
2198                 case 'quoted-printable':
2199                         $mode = 2;
2200                 break;
2201                 case 'x-uuencode':
2202                 case 'x-uue':
2203                 case 'uue':
2204                 case 'uuencode':
2205                         $mode = 3;
2206                 break;
2207                 default:
2208                         $mode = 0;
2209         }
2210
2211         if (iil_C_Select($conn, $mailbox)) {
2212                 $reply_key = '* ' . $id;
2213
2214                 // format request
2215                 $key     = 'ftch0';
2216                 $request = $key . ($is_uid ? ' UID' : '') . " FETCH $id (BODY.PEEK[$part])";
2217                 // send request
2218                 if (!iil_PutLine($fp, $request)) {
2219                     return false;
2220                 }
2221
2222                 // receive reply line
2223                 do {
2224                         $line = chop(iil_ReadLine($fp, 1000));
2225                         $a    = explode(' ', $line);
2226                 } while (!($end = iil_StartsWith($line, $key, true)) && $a[2] != 'FETCH');
2227                 $len = strlen($line);
2228
2229                 // handle empty "* X FETCH ()" response
2230                 if ($line[$len-1] == ')' && $line[$len-2] != '(') {
2231                         // one line response, get everything between first and last quotes
2232                         if (substr($line, -4, 3) == 'NIL') {
2233                                 // NIL response
2234                                 $result = '';
2235                         } else {
2236                                 $from = strpos($line, '"') + 1;
2237                                 $to   = strrpos($line, '"');
2238                                 $len  = $to - $from;
2239                                 $result = substr($line, $from, $len);
2240                         }
2241
2242                         if ($mode == 1)
2243                                 $result = base64_decode($result);
2244                         else if ($mode == 2)
2245                                 $result = quoted_printable_decode($result);
2246                         else if ($mode == 3)
2247                                 $result = convert_uudecode($result);
2248
2249                 } else if ($line[$len-1] == '}') {
2250                         //multi-line request, find sizes of content and receive that many bytes
2251                         $from     = strpos($line, '{') + 1;
2252                         $to       = strrpos($line, '}');
2253                         $len      = $to - $from;
2254                         $sizeStr  = substr($line, $from, $len);
2255                         $bytes    = (int)$sizeStr;
2256                         $prev     = '';
2257
2258                         while ($bytes > 0) {
2259                                 $line      = iil_ReadLine($fp, 1024);
2260                                 $len       = strlen($line);
2261
2262                                 if ($len > $bytes) {
2263                                         $line = substr($line, 0, $bytes);
2264                                         $len = strlen($line);
2265                                 }
2266                                 $bytes -= $len;
2267
2268                                 if ($mode == 1) {
2269                                         $line = rtrim($line, "\t\r\n\0\x0B");
2270                                         // create chunks with proper length for base64 decoding
2271                                         $line = $prev.$line;
2272                                         $length = strlen($line);
2273                                         if ($length % 4) {
2274                                                 $length = floor($length / 4) * 4;
2275                                                 $prev = substr($line, $length);
2276                                                 $line = substr($line, 0, $length);
2277                                         }
2278                                         else
2279                                                 $prev = '';
2280
2281                                         if ($file)
2282                                                 fwrite($file, base64_decode($line));
2283                                         else if ($print)
2284                                                 echo base64_decode($line);
2285                                         else
2286                                                 $result .= base64_decode($line);
2287                                 } else if ($mode == 2) {
2288                                         $line = rtrim($line, "\t\r\0\x0B");
2289                                         if ($file)
2290                                                 fwrite($file, quoted_printable_decode($line));
2291                                         else if ($print)
2292                                                 echo quoted_printable_decode($line);
2293                                         else
2294                                                 $result .= quoted_printable_decode($line);
2295                                 } else if ($mode == 3) {
2296                                         $line = rtrim($line, "\t\r\n\0\x0B");
2297                                         if ($line == 'end' || preg_match('/^begin\s+[0-7]+\s+.+$/', $line))
2298                                                 continue;
2299                                         if ($file)
2300                                                 fwrite($file, convert_uudecode($line));
2301                                         else if ($print)
2302                                                 echo convert_uudecode($line);
2303                                         else
2304                                                 $result .= convert_uudecode($line);
2305                                 } else {
2306                                         $line = rtrim($line, "\t\r\n\0\x0B");
2307                                         if ($file)
2308                                                 fwrite($file, $line . "\n");
2309                                         else if ($print)
2310                                                 echo $line . "\n";
2311                                         else
2312                                                 $result .= $line . "\n";
2313                                 }
2314                         }
2315                 }
2316
2317                 // read in anything up until last line
2318                 if (!$end)
2319                         do {
2320                                 $line = iil_ReadLine($fp, 1024);
2321                         } while (!iil_StartsWith($line, $key, true));
2322
2323                 if ($result) {
2324                         $result = rtrim($result, "\t\r\n\0\x0B");
2325                         if ($file) {
2326                                 fwrite($file, $result);
2327                         } else if ($print) {
2328                                 echo $result;
2329                         } else
2330                                 return $result; // substr($result, 0, strlen($result)-1);
2331
2332                         return true;
2333                 }
2334         }
2335
2336         return false;
2337 }
2338
2339 function iil_C_CreateFolder(&$conn, $folder) {
2340         $fp = $conn->fp;
2341         if (iil_PutLine($fp, 'c CREATE "' . iil_Escape($folder) . '"')) {
2342                 do {
2343                         $line=iil_ReadLine($fp, 300);
2344                 } while (!iil_StartsWith($line, 'c ', true));
2345                 return (iil_ParseResult($line) == 0);
2346         }
2347         return false;
2348 }
2349
2350 function iil_C_RenameFolder(&$conn, $from, $to) {
2351         $fp = $conn->fp;
2352         if (iil_PutLine($fp, 'r RENAME "' . iil_Escape($from) . '" "' . iil_Escape($to) . '"')) {
2353                 do {
2354                         $line = iil_ReadLine($fp, 300);
2355                 } while (!iil_StartsWith($line, 'r ', true));
2356                 return (iil_ParseResult($line) == 0);
2357         }
2358         return false;
2359 }
2360
2361 function iil_C_DeleteFolder(&$conn, $folder) {
2362         $fp = $conn->fp;
2363         if (iil_PutLine($fp, 'd DELETE "' . iil_Escape($folder). '"')) {
2364                 do {
2365                         $line=iil_ReadLine($fp, 300);
2366                 } while (!iil_StartsWith($line, 'd ', true));
2367                 return (iil_ParseResult($line) == 0);
2368         }
2369         return false;
2370 }
2371
2372 function iil_C_Append(&$conn, $folder, &$message) {
2373         if (!$folder) {
2374                 return false;
2375         }
2376         $fp = $conn->fp;
2377
2378         $message = str_replace("\r", '', $message);
2379         $message = str_replace("\n", "\r\n", $message);
2380
2381         $len = strlen($message);
2382         if (!$len) {
2383                 return false;
2384         }
2385
2386         $request = 'a APPEND "' . iil_Escape($folder) .'" (\\Seen) {' . $len . '}';
2387
2388         if (iil_PutLine($fp, $request)) {
2389                 $line = iil_ReadLine($fp, 512);
2390
2391                 if ($line[0] != '+') {
2392                         // $errornum = iil_ParseResult($line);
2393                         $conn->error .= "Cannot write to folder: $line\n";
2394                         return false;
2395                 }
2396
2397                 iil_PutLine($fp, $message);
2398
2399                 do {
2400                         $line = iil_ReadLine($fp);
2401                 } while (!iil_StartsWith($line, 'a ', true));
2402
2403                 $result = (iil_ParseResult($line) == 0);
2404                 if (!$result) {
2405                     $conn->error .= $line . "\n";
2406                 }
2407                 return $result;
2408         }
2409
2410         $conn->error .= "Couldn't send command \"$request\"\n";
2411         return false;
2412 }
2413
2414 function iil_C_AppendFromFile(&$conn, $folder, $path) {
2415         if (!$folder) {
2416             return false;
2417         }
2418
2419         //open message file
2420         $in_fp = false;
2421         if (file_exists(realpath($path))) {
2422                 $in_fp = fopen($path, 'r');
2423         }
2424         if (!$in_fp) {
2425                 $conn->error .= "Couldn't open $path for reading\n";
2426                 return false;
2427         }
2428
2429         $fp  = $conn->fp;
2430         $len = filesize($path);
2431         if (!$len) {
2432                 return false;
2433         }
2434
2435         //send APPEND command
2436         $request    = 'a APPEND "' . iil_Escape($folder) . '" (\\Seen) {' . $len . '}';
2437         if (iil_PutLine($fp, $request)) {
2438                 $line = iil_ReadLine($fp, 512);
2439
2440                 if ($line[0] != '+') {
2441                         //$errornum = iil_ParseResult($line);
2442                         $conn->error .= "Cannot write to folder: $line\n";
2443                         return false;
2444                 }
2445
2446                 //send file
2447                 while (!feof($in_fp)) {
2448                         $buffer      = fgets($in_fp, 4096);
2449                         iil_PutLine($fp, $buffer, false);
2450                 }
2451                 fclose($in_fp);
2452
2453                 iil_PutLine($fp, ''); // \r\n
2454
2455                 //read response
2456                 do {
2457                         $line = iil_ReadLine($fp);
2458                 } while (!iil_StartsWith($line, 'a ', true));
2459
2460                 $result = (iil_ParseResult($line) == 0);
2461                 if (!$result) {
2462                     $conn->error .= $line . "\n";
2463                 }
2464
2465                 return $result;
2466         }
2467
2468         $conn->error .= "Couldn't send command \"$request\"\n";
2469         return false;
2470 }
2471
2472 function iil_C_FetchStructureString(&$conn, $folder, $id, $is_uid=false) {
2473         $fp     = $conn->fp;
2474         $result = false;
2475
2476         if (iil_C_Select($conn, $folder)) {
2477                 $key = 'F1247';
2478
2479                 if (iil_PutLine($fp, $key . ($is_uid ? ' UID' : '') ." FETCH $id (BODYSTRUCTURE)")) {
2480                         do {
2481                                 $line = iil_ReadLine($fp, 5000);
2482                                 $line = iil_MultLine($fp, $line, true);
2483                                 if (!preg_match("/^$key/", $line))
2484                                         $result .= $line;
2485                         } while (!iil_StartsWith($line, $key, true));
2486
2487                         $result = trim(substr($result, strpos($result, 'BODYSTRUCTURE')+13, -1));
2488                 }
2489         }
2490         return $result;
2491 }
2492
2493 function iil_C_GetQuota(&$conn) {
2494 /*
2495  * GETQUOTAROOT "INBOX"
2496  * QUOTAROOT INBOX user/rchijiiwa1
2497  * QUOTA user/rchijiiwa1 (STORAGE 654 9765)
2498  * OK Completed
2499  */
2500         $fp         = $conn->fp;
2501         $result     = false;
2502         $quota_lines = array();
2503
2504         // get line(s) containing quota info
2505         if (iil_PutLine($fp, 'QUOT1 GETQUOTAROOT "INBOX"')) {
2506                 do {
2507                         $line=chop(iil_ReadLine($fp, 5000));
2508                         if (iil_StartsWith($line, '* QUOTA ')) {
2509                                 $quota_lines[] = $line;
2510                         }
2511                 } while (!iil_StartsWith($line, 'QUOT1', true));
2512         }
2513
2514         // return false if not found, parse if found
2515         $min_free = PHP_INT_MAX;
2516         foreach ($quota_lines as $key => $quota_line) {
2517                 $quota_line   = preg_replace('/[()]/', '', $quota_line);
2518                 $parts        = explode(' ', $quota_line);
2519                 $storage_part = array_search('STORAGE', $parts);
2520
2521                 if (!$storage_part) continue;
2522
2523                 $used   = intval($parts[$storage_part+1]);
2524                 $total  = intval($parts[$storage_part+2]);
2525                 $free   = $total - $used;
2526
2527                 // return lowest available space from all quotas
2528                 if ($free < $min_free) {
2529                         $min_free = $free;
2530                         $result['used']    = $used;
2531                         $result['total']   = $total;
2532                         $result['percent'] = min(100, round(($used/max(1,$total))*100));
2533                         $result['free']    = 100 - $result['percent'];
2534                 }
2535         }
2536         return $result;
2537 }
2538
2539 function iil_C_ClearFolder(&$conn, $folder) {
2540         $num_in_trash = iil_C_CountMessages($conn, $folder);
2541         if ($num_in_trash > 0) {
2542                 iil_C_Delete($conn, $folder, '1:*');
2543         }
2544         return (iil_C_Expunge($conn, $folder) >= 0);
2545 }
2546
2547 ?>