functions/imap_general.php

   1 <?php
   2
   3 /**
   4  * imap_general.php
   5  *
   6  * Copyright (c) 1999-2003 The SquirrelMail Project Team
   7  * Licensed under the GNU GPL. For full terms see the file COPYING.
   8  *
   9  * This implements all functions that do general imap functions.
  10  *
  11  * $Id$
  12  */
  13
  14 require_once(SM_PATH . 'functions/page_header.php');
  15 require_once(SM_PATH . 'functions/auth.php');
  16
  17
  18 global $sqimap_session_id;
  19 $sqimap_session_id = 1;
  20
  21 /* Sets an unique session id in order to avoid simultanous sessions crash. */
  22 function sqimap_session_id($unique_id = false) {
  23     global $data_dir, $username, $sqimap_session_id;
  24     if (!$unique_id) {
  25         return( sprintf("A%03d", $sqimap_session_id++) );
  26     } else {
  27         return( sprintf("A%03d", $sqimap_session_id++) . ' UID' );
  28     }
  29 }
  30
  31 /*
  32  * Both send a command and accept the result from the command.
  33  * This is to allow proper session number handling.
  34  */
  35 function sqimap_run_command_list ($imap_stream, $query, $handle_errors, &$response, &$message, $unique_id = false) {
  36     if ($imap_stream) {
  37         $sid = sqimap_session_id($unique_id);
  38         fputs ($imap_stream, $sid . ' ' . $query . "\r\n");
  39         $tag_uid_a = explode(' ',trim($sid));
  40         $tag = $tag_uid_a[0];
  41         $read = sqimap_retrieve_imap_response ($imap_stream, $tag, $handle_errors, $response, $message, $query );
  42         /* get the response and the message */
  43         $message = $message[$tag];
  44         $response = $response[$tag];
  45         return $read[$tag];
  46     } else {
  47         global $squirrelmail_language, $color;
  48         set_up_language($squirrelmail_language);
  49         require_once(SM_PATH . 'functions/display_messages.php');
  50         $string = "<b><font color=$color[2]>\n" .
  51                 _("ERROR : No available imapstream.") .
  52                 "</b></font>\n";
  53         error_box($string,$color);
  54         return false;
  55     }
  56 }
  57
  58 function sqimap_run_command ($imap_stream, $query, $handle_errors, &$response,
  59                             &$message, $unique_id = false,$filter=false,
  60                              $outputstream=false,$no_return=false) {
  61     if ($imap_stream) {
  62         $sid = sqimap_session_id($unique_id);
  63         fputs ($imap_stream, $sid . ' ' . $query . "\r\n");
  64         $tag_uid_a = explode(' ',trim($sid));
  65         $tag = $tag_uid_a[0];
  66
  67         $read = sqimap_read_data ($imap_stream, $tag, $handle_errors, $response,
  68                                   $message, $query,$filter,$outputstream,$no_return);
  69         /* retrieve the response and the message */
  70         $response = $response[$tag];
  71         $message  = $message[$tag];
  72
  73         if (!empty($read[$tag])) {
  74             return $read[$tag][0];
  75         } else {
  76             return $read[$tag];
  77         }
  78     } else {
  79         global $squirrelmail_language, $color;
  80         set_up_language($squirrelmail_language);
  81         require_once(SM_PATH . 'functions/display_messages.php');
  82         $string = "<b><font color=$color[2]>\n" .
  83                 _("ERROR : No available imapstream.") .
  84                 "</b></font>\n";
  85         error_box($string,$color);
  86         return false;
  87     }
  88 }
  89 function sqimap_prepare_pipelined_query($new_query,&$tag,&$aQuery,$unique_id) {
  90     $sid = sqimap_session_id($unique_id);
  91     $tag_uid_a = explode(' ',trim($sid));
  92     $tag = $tag_uid_a[0];
  93     $query = $sid . ' '.$new_query."\r\n";
  94     $aQuery[$tag] = $query;
  95 }
  96
  97 function sqimap_run_pipelined_command ($imap_stream, $aQueryList, $handle_errors,
  98                        &$aServerResponse, &$aServerMessage, $unique_id = false,
  99                        $filter=false,$outputstream=false,$no_return=false) {
 100     $aResponse = false;
 101
 102     /*
 103        Do not fire all calls at once to the imap-server but split the calls up
 104        in portions of $iChunkSize. If we do not do that I think we misbehave as
 105        IMAP client or should handle BYE calls if the IMAP-server drops the
 106        connection because the number of queries is to large. This isn't tested
 107        but a wild guess how it could work in the field.
 108
 109        After testing it on Exchange 2000 we discovered that a chunksize of 32
 110        was quicker then when we raised it to 128.
 111     */
 112     $iQueryCount = count($aQueryList);
 113     $iChunkSize = 32;
 114     // array_chunk would also do the job but it's supported from php > 4.2
 115     $aQueryChunks = array();
 116     $iLoops = floor($iQueryCount / $iChunkSize);
 117
 118     if ($iLoops * $iChunkSize != $iQueryCount) ++$iLoops;
 119
 120     if (!function_exists('array_chunk')) { // arraychunk replacement
 121         reset($aQueryList);
 122         for($i=0;$i<$iLoops;++$i) {
 123             for($j=0;$j<$iChunkSize;++$j) {
 124                 $key = key($aQueryList);
 125                 $aTmp[$key] = $aQueryList[$key];
 126                 if (next($aQueryList) === false) break;
 127             }
 128             $aQueryChunks[] = $aTmp;
 129         }
 130     } else {
 131         $aQueryChunks = array_chunk($aQueryList,$iChunkSize,true);
 132     }
 133
 134     for ($i=0;$i<$iLoops;++$i) {
 135         $aQuery = $aQueryChunks[$i];
 136         foreach($aQuery as $tag => $query) {
 137             fputs($imap_stream,$query);
 138             $aResults[$tag] = false;
 139         }
 140         foreach($aQuery as $tag => $query) {
 141             if ($aResults[$tag] == false) {
 142                 $aReturnedResponse = sqimap_retrieve_imap_response ($imap_stream, $tag,
 143                                     $handle_errors, $response, $message, $query,
 144                                     $filter,$outputstream,$no_return);
 145                 foreach ($aReturnedResponse as $returned_tag => $aResponse) {
 146                     if (!empty($aResponse)) {
 147                         $aResults[$returned_tag] = $aResponse[0];
 148                     } else {
 149                         $aResults[$returned_tag] = $aResponse;
 150                     }
 151                     $aServerResponse[$returned_tag] = $response[$returned_tag];
 152                     $aServerMessage[$returned_tag] = $message[$returned_tag];
 153                 }
 154             }
 155         }
 156     }
 157     return $aResults;
 158 }
 159
 160 /*
 161  * custom fgets function. gets a line from IMAP
 162  * no matter how big it may be
 163  */
 164
 165 function sqimap_fgets($imap_stream) {
 166     $read = '';
 167     $buffer = 4096;
 168     $results = '';
 169     $offset = 0;
 170     while (strpos($results, "\r\n", $offset) === false) {
 171         if (!($read = fgets($imap_stream, $buffer))) {
 172         /* this happens in case of an error */
 173         /* reset $results because it's useless */
 174         $results = false;
 175             break;
 176         }
 177         if ( $results != '' ) {
 178             $offset = strlen($results) - 1;
 179         }
 180         $results .= $read;
 181     }
 182     return $results;
 183 }
 184
 185 function sqimap_fread($imap_stream,$iSize,$filter=false,
 186                       $outputstream=false, $no_return=false) {
 187     if (!$filter || !$outputstream) {
 188         $iBufferSize = $iSize;
 189     } else {
 190         // see php bug 24033. They changed fread behaviour %$^&$%
 191         $iBufferSize = 7800; // multiple of 78 in case of base64 decoding.
 192     }
 193     if ($iSize < $iBufferSize) {
 194         $iBufferSize = $iSize;
 195     }
 196     $iRetrieved = 0;
 197     $results = '';
 198     $sRead = $sReadRem = '';
 199     // NB: fread can also stop at end of a packet on sockets.
 200     while ($iRetrieved < $iSize) {
 201         $sRead = fread($imap_stream,$iBufferSize);
 202         $iLength = strlen($sRead);
 203         $iRetrieved += $iLength ;
 204         $iRemaining = $iSize - $iRetrieved;
 205         if ($iRemaining < $iBufferSize) {
 206             $iBufferSize = $iRemaining;
 207         }
 208         if (!$sRead) {
 209             $results = false;
 210             break;
 211         }
 212         if ($sReadRem) {
 213             $sRead = $sReadRem . $sRead;
 214             $sReadRem = '';
 215         }
 216         if (substr($sRead,-1) !== "\n") {
 217             $i = strrpos($sRead,"\n");
 218             if ($i !== false && $iRetrieved<$iSize) {
 219                 ++$i;
 220                 $sReadRem = substr($sRead,$i);
 221                 $sRead = substr($sRead,0,$i);
 222             } else if ($iLength && $iRetrieved<$iSize) { // linelength > received buffer
 223                 $sReadRem = $sRead;
 224                 $sRead = '';
 225             }
 226         }
 227         if ($filter && $sRead) {
 228            $filter($sRead);
 229         }
 230         if ($outputstream && $sRead) {
 231            if (is_resource($outputstream)) {
 232                fwrite($outputstream,$sRead);
 233            } else if ($outputstream == 'php://stdout') {
 234                echo $sRead;
 235            }
 236         }
 237         if ($no_return) {
 238             $sRead = '';
 239         } else {
 240             $results .= $sRead;
 241         }
 242     }
 243     return $results;
 244 }
 245
 246 /* obsolete function, inform plugins that use it */
 247 function sqimap_read_data_list($imap_stream, $tag, $handle_errors,
 248           &$response, &$message, $query = '') {
 249     global $color, $squirrelmail_language;
 250     set_up_language($squirrelmail_language);
 251     require_once(SM_PATH . 'functions/display_messages.php');
 252     $string = "<b><font color=$color[2]>\n" .
 253         _("ERROR : Bad function call.") .
 254         "</b><br>\n" .
 255         _("Reason:") . ' '.
 256           'There is a plugin installed which make use of the  <br>' .
 257           'SquirrelMail internal function sqimap_read_data_list.<br>'.
 258           'Please adapt the installed plugin and let it use<br>'.
 259           'sqimap_run_command or sqimap_run_command_list instead<br><br>'.
 260           'The following query was issued:<br>'.
 261            htmlspecialchars($query) . '<br>' . "</font><br>\n";
 262     error_box($string,$color);
 263     echo '</body></html>';
 264     exit;
 265 }
 266
 267 function sqimap_error_box($title, $query = '', $message_title = '', $message = '')
 268 {
 269     global $color, $squirrelmail_language;
 270
 271     set_up_language($squirrelmail_language);
 272     require_once(SM_PATH . 'functions/display_messages.php');
 273     $string = "<font color=$color[2]><b>\n" . $title . "</b><br>\n";
 274     $cmd = explode(' ',$query);
 275     $cmd= strtolower($cmd[0]);
 276
 277     if ($query != '' &&  $cmd != 'login')
 278         $string .= _("Query:") . ' ' . htmlspecialchars($query) . '<br>';
 279     if ($message_title != '')
 280         $string .= $message_title;
 281     if ($message != '')
 282         $string .= htmlspecialchars($message);
 283     $string .= "</font><br>\n";
 284     error_box($string,$color);
 285 }
 286
 287 /*
 288  * Reads the output from the IMAP stream.  If handle_errors is set to true,
 289  * this will also handle all errors that are received.  If it is not set,
 290  * the errors will be sent back through $response and $message
 291  */
 292
 293 function sqimap_retrieve_imap_response($imap_stream, $tag, $handle_errors,
 294           &$response, &$message, $query = '',
 295            $filter = false, $outputstream = false, $no_return = false) {
 296     global $color, $squirrelmail_language;
 297     $read = '';
 298     if (!is_array($message)) $message = array();
 299     if (!is_array($response)) $response = array();
 300     $resultlist = array();
 301     $data = array();
 302     $read = sqimap_fgets($imap_stream);
 303     $i = $k = 0;
 304     while ($read) {
 305         $char = $read{0};
 306         switch ($char)
 307         {
 308           case '+':
 309           default:
 310             $read = sqimap_fgets($imap_stream);
 311             break;
 312
 313           case $tag{0}:
 314           {
 315             /* get the command */
 316             $arg = '';
 317             $i = strlen($tag)+1;
 318             $s = substr($read,$i);
 319             if (($j = strpos($s,' ')) || ($j = strpos($s,"\n"))) {
 320                 $arg = substr($s,0,$j);
 321             }
 322             $found_tag = substr($read,0,$i-1);
 323             if ($found_tag) {
 324                 switch ($arg)
 325                 {
 326                   case 'OK':
 327                   case 'BAD':
 328                   case 'NO':
 329                   case 'BYE':
 330                   case 'PREAUTH':
 331                     $response[$found_tag] = $arg;
 332                     $message[$found_tag] = trim(substr($read,$i+strlen($arg)));
 333                     if (!empty($data)) {
 334                         $resultlist[] = $data;
 335                     }
 336                     $aResponse[$found_tag] = $resultlist;
 337                     $data = $resultlist = array();
 338                     if ($found_tag == $tag) {
 339                         break 3; /* switch switch while */
 340                     }
 341                   break;
 342                   default:
 343                     /* this shouldn't happen */
 344                     $response[$found_tag] = $arg;
 345                     $message[$found_tag] = trim(substr($read,$i+strlen($arg)));
 346                     if (!empty($data)) {
 347                         $resultlist[] = $data;
 348                     }
 349                     $aResponse[$found_tag] = $resultlist;
 350                     $data = $resultlist = array();
 351                     if ($found_tag == $tag) {
 352                         break 3; /* switch switch while */
 353                     }
 354                 }
 355             }
 356             $read = sqimap_fgets($imap_stream);
 357             if ($read === false) { /* error */
 358                  break 3; /* switch switch while */
 359             }
 360             break;
 361           } // end case $tag{0}
 362
 363           case '*':
 364           {
 365             if (preg_match('/^\*\s\d+\sFETCH/',$read)) {
 366                 /* check for literal */
 367                 $s = substr($read,-3);
 368                 $fetch_data = array();
 369                 do { /* outer loop, continue until next untagged fetch
 370                         or tagged reponse */
 371                     do { /* innerloop for fetching literals. with this loop
 372                             we prohibid that literal responses appear in the
 373                             outer loop so we can trust the untagged and
 374                             tagged info provided by $read */
 375                         if ($s === "}\r\n") {
 376                             $j = strrpos($read,'{');
 377                             $iLit = substr($read,$j+1,-3);
 378                             $fetch_data[] = $read;
 379                             $sLiteral = sqimap_fread($imap_stream,$iLit,$filter,$outputstream,$no_return);
 380                             if ($sLiteral === false) { /* error */
 381                                 break 4; /* while while switch while */
 382                             }
 383                             /* backwards compattibility */
 384                             $aLiteral = explode("\n", $sLiteral);
 385                             /* release not neaded data */
 386                             unset($sLiteral);
 387                             foreach ($aLiteral as $line) {
 388                                 $fetch_data[] = $line ."\n";
 389                             }
 390                             /* release not neaded data */
 391                             unset($aLiteral);
 392                             /* next fgets belongs to this fetch because
 393                                we just got the exact literalsize and there
 394                                must follow data to complete the response */
 395                             $read = sqimap_fgets($imap_stream);
 396                             if ($read === false) { /* error */
 397                                 break 4; /* while while switch while */
 398                             }
 399                             $fetch_data[] = $read;
 400                         } else {
 401                             $fetch_data[] = $read;
 402                         }
 403                         /* retrieve next line and check in the while
 404                            statements if it belongs to this fetch response */
 405                         $read = sqimap_fgets($imap_stream);
 406                         if ($read === false) { /* error */
 407                             break 4; /* while while switch while */
 408                         }
 409                         /* check for next untagged reponse and break */
 410                         if ($read{0} == '*') break 2;
 411                         $s = substr($read,-3);
 412                     } while ($s === "}\r\n");
 413                     $s = substr($read,-3);
 414                 } while ($read{0} !== '*' &&
 415                          substr($read,0,strlen($tag)) !== $tag);
 416                 $resultlist[] = $fetch_data;
 417                 /* release not neaded data */
 418                 unset ($fetch_data);
 419             } else {
 420                 $s = substr($read,-3);
 421                 do {
 422                     if ($s === "}\r\n") {
 423                         $j = strrpos($read,'{');
 424                         $iLit = substr($read,$j+1,-3);
 425                         $data[] = $read;
 426                         $sLiteral = fread($imap_stream,$iLit);
 427                         if ($sLiteral === false) { /* error */
 428                             $read = false;
 429                             break 3; /* while switch while */
 430                         }
 431                         $data[] = $sLiteral;
 432                         $data[] = sqimap_fgets($imap_stream);
 433                     } else {
 434                          $data[] = $read;
 435                     }
 436                     $read = sqimap_fgets($imap_stream);
 437                     if ($read === false) {
 438                         break 3; /* while switch while */
 439                     } else if ($read{0} == '*') {
 440                         break;
 441                     }
 442                     $s = substr($read,-3);
 443                 } while ($s === "}\r\n");
 444                 break 1;
 445             }
 446             break;
 447           } // end case '*'
 448         }   // end switch
 449     } // end while
 450
 451     /* error processing in case $read is false */
 452     if ($read === false) {
 453         unset($data);
 454         sqimap_error_box(_("ERROR : Connection dropped by imap-server."), $query);
 455         exit;
 456     }
 457
 458     /* Set $resultlist array */
 459     if (!empty($data)) {
 460         //$resultlist[] = $data;
 461     }
 462     elseif (empty($resultlist)) {
 463         $resultlist[] = array();
 464     }
 465
 466     /* Return result or handle errors */
 467     if ($handle_errors == false) {
 468         return $aResponse;
 469         return( $resultlist );  //?? Why this?
 470     }
 471     switch ($response[$tag]) {
 472     case 'OK':
 473         return $aResponse;
 474         break;
 475     case 'NO':
 476         /* ignore this error from M$ exchange, it is not fatal (aka bug) */
 477         if (strstr($message[$tag], 'command resulted in') === false) {
 478             sqimap_error_box(_("ERROR : Could not complete request."), $query, _("Reason Given: "), $message[$tag]);
 479             echo '</body></html>';
 480             exit;
 481         }
 482         break;
 483     case 'BAD':
 484         sqimap_error_box(_("ERROR : Bad or malformed request."), $query, _("Server responded: "), $message[$tag]);
 485         echo '</body></html>';
 486         exit;
 487     case 'BYE':
 488         sqimap_error_box(_("ERROR : Imap server closed the connection."), $query, _("Server responded: "), $message[$tag]);
 489         echo '</body></html>';
 490         exit;
 491     default:
 492         sqimap_error_box(_("ERROR : Unknown imap response."), $query, _("Server responded: "), $message[$tag]);
 493        /* the error is displayed but because we don't know the reponse we
 494           return the result anyway */
 495        return $aResponse;
 496        break;
 497     }
 498 }
 499
 500 function sqimap_read_data ($imap_stream, $tag_uid, $handle_errors,
 501                            &$response, &$message, $query = '',
 502                            $filter=false,$outputstream=false,$no_return=false) {
 503
 504     $tag_uid_a = explode(' ',trim($tag_uid));
 505     $tag = $tag_uid_a[0];
 506
 507     $res = sqimap_retrieve_imap_response($imap_stream, $tag, $handle_errors,
 508               $response, $message, $query,$filter,$outputstream,$no_return);
 509     /* sqimap_read_data should be called for one response
 510        but since it just calls sqimap_retrieve_imap_response which
 511        handles multiple responses we need to check for that
 512        and merge the $res array IF they are seperated and
 513        IF it was a FETCH response. */
 514
 515 //    if (isset($res[1]) && is_array($res[1]) && isset($res[1][0])
 516 //        && preg_match('/^\* \d+ FETCH/', $res[1][0])) {
 517 //        $result = array();
 518 //        foreach($res as $index=>$value) {
 519 //            $result = array_merge($result, $res["$index"]);
 520 //        }
 521 //    }
 522     if (isset($result)) {
 523         return $result[$tag];
 524     }
 525     else {
 526         return $res;
 527     }
 528 }
 529
 530 /** sqimap_create_stream()
 531  * @return imap-stream resource identifier
 532  * Connects to the IMAP server and returns a resource identifier for use with
 533  * the other SquirrelMail IMAP functions.  Does NOT login!
 534  */
 535 function sqimap_create_stream($server,$port,$tls=false) {
 536     global $username, $use_imap_tls;
 537
 538     if ($use_imap_tls == true) {
 539         if ((check_php_version(4,3)) and (extension_loaded('openssl'))) {
 540             /* Use TLS by prefixing "tls://" to the hostname */
 541             $server = 'tls://' . $imap_server_address;
 542         } else {
 543             require_once(SM_PATH . 'functions/display_messages.php');
 544             $string = "Unable to connect to IMAP server!<br>TLS is enabled, but this " .
 545               "version of PHP does not support TLS sockets, or is missing the openssl " .
 546               "extension.<br><br>Please contact your system administrator.";
 547             logout_error($string,$color);
 548         }
 549     }
 550
 551     $imap_stream = fsockopen($server, $port, $error_number, $error_string, 15);
 552
 553     /* Do some error correction */
 554     if (!$imap_stream) {
 555         set_up_language($squirrelmail_language, true);
 556         require_once(SM_PATH . 'functions/display_messages.php');
 557         $string = sprintf (_("Error connecting to IMAP server: %s.") .
 558            "<br>\r\n", $server) .
 559            "$error_number : $error_string<br>\r\n";
 560         logout_error($string,$color);
 561         exit;
 562     }
 563     $server_info = fgets ($imap_stream, 1024);
 564     return $imap_stream;
 565 }
 566
 567 /*
 568  * Logs the user into the imap server.  If $hide is set, no error messages
 569  * will be displayed.  This function returns the imap connection handle.
 570  */
 571 function sqimap_login ($username, $password, $imap_server_address, $imap_port, $hide) {
 572     global $color, $squirrelmail_language, $onetimepad, $use_imap_tls,
 573            $imap_auth_mech, $sqimap_capabilities;
 574
 575     if (!isset($onetimepad) || empty($onetimepad)) {
 576         sqgetglobalvar('onetimepad' , $onetimepad , SQ_SESSION );
 577     }
 578     if (!isset($sqimap_capabilities)) {
 579         sqgetglobalvar('sqimap_capabilities' , $capability , SQ_SESSION );
 580     }
 581
 582     $host = $imap_server_address;
 583     $imap_server_address = sqimap_get_user_server($imap_server_address, $username);
 584
 585     $imap_stream = sqimap_create_stream($imap_server_address,$imap_port,$use_imap_tls);
 586
 587     /* Decrypt the password */
 588     $password = OneTimePadDecrypt($password, $onetimepad);
 589
 590     if (($imap_auth_mech == 'cram-md5') OR ($imap_auth_mech == 'digest-md5')) {
 591     // We're using some sort of authentication OTHER than plain or login
 592         $tag=sqimap_session_id(false);
 593         if ($imap_auth_mech == 'digest-md5') {
 594             $query = $tag . " AUTHENTICATE DIGEST-MD5\r\n";
 595         } elseif ($imap_auth_mech == 'cram-md5') {
 596             $query = $tag . " AUTHENTICATE CRAM-MD5\r\n";
 597         }
 598         fputs($imap_stream,$query);
 599         $answer=sqimap_fgets($imap_stream);
 600         // Trim the "+ " off the front
 601         $response=explode(" ",$answer,3);
 602         if ($response[0] == '+') {
 603             // Got a challenge back
 604             $challenge=$response[1];
 605             if ($imap_auth_mech == 'digest-md5') {
 606                 $reply = digest_md5_response($username,$password,$challenge,'imap',$host);
 607             } elseif ($imap_auth_mech == 'cram-md5') {
 608                 $reply = cram_md5_response($username,$password,$challenge);
 609             }
 610             fputs($imap_stream,$reply);
 611             $read=sqimap_fgets($imap_stream);
 612             if ($imap_auth_mech == 'digest-md5') {
 613             // DIGEST-MD5 has an extra step..
 614                 if (substr($read,0,1) == '+') { // OK so far..
 615                     fputs($imap_stream,"\r\n");
 616                     $read=sqimap_fgets($imap_stream);
 617                 }
 618             }
 619             $results=explode(" ",$read,3);
 620             $response=$results[1];
 621             $message=$results[2];
 622         } else {
 623         // Fake the response, so the error trap at the bottom will work
 624             $response="BAD";
 625             $message='IMAP server does not appear to support the authentication method selected.';
 626             $message .= '  Please contact your system administrator.';
 627         }
 628     } elseif ($imap_auth_mech == 'login') {
 629     // Original IMAP login code
 630         $query = 'LOGIN "' . quoteimap($username) .  '" "' . quoteimap($password) . '"';
 631         $read = sqimap_run_command ($imap_stream, $query, false, $response, $message);
 632     } elseif ($imap_auth_mech == 'plain') {
 633         /***
 634          * SASL PLAIN
 635          *
 636          *  RFC 2595 Chapter 6
 637          *
 638          *  The mechanism consists of a single message from the client to the
 639          *  server.  The client sends the authorization identity (identity to
 640          *  login as), followed by a US-ASCII NUL character, followed by the
 641          *  authentication identity (identity whose password will be used),
 642          *  followed by a US-ASCII NUL character, followed by the clear-text
 643          *  password.  The client may leave the authorization identity empty to
 644          *  indicate that it is the same as the authentication identity.
 645          *
 646          **/
 647         $tag=sqimap_session_id(false);
 648         $sasl = (isset($capability['SASL']) && $capability['SASL']) ? true : false;
 649         $auth = base64_encode("$username\0$username\0$password");
 650         if ($sasl) {
 651             // IMAP Extension for SASL Initial Client Response
 652             // <draft-siemborski-imap-sasl-initial-response-00.txt>
 653             $query = $tag . " AUTHENTICATE PLAIN $auth\r\n";
 654             fputs($imap_stream, $query);
 655             $read = sqimap_fgets($imap_stream);
 656         } else {
 657             $query = $tag . " AUTHENTICATE PLAIN\r\n";
 658             fputs($imap_stream, $query);
 659             $read=sqimap_fgets($imap_stream);
 660             if (substr($read,0,1) == '+') { // OK so far..
 661                 fputs($imap_stream, "$auth\r\n");
 662                 $read = sqimap_fgets($imap_stream);
 663             }
 664         }
 665         $results=explode(" ",$read,3);
 666         $response=$results[1];
 667         $message=$results[2];
 668     } else {
 669         $response="BAD";
 670         $message="Internal SquirrelMail error - unknown IMAP authentication method chosen.  Please contact the developers.";
 671     }
 672
 673     /* If the connection was not successful, lets see why */
 674     if ($response != 'OK') {
 675         if (!$hide) {
 676             if ($response != 'NO') {
 677                 /* "BAD" and anything else gets reported here. */
 678                 $message = htmlspecialchars($message);
 679                 set_up_language($squirrelmail_language, true);
 680                 require_once(SM_PATH . 'functions/display_messages.php');
 681                 if ($response == 'BAD') {
 682                     $string = sprintf (_("Bad request: %s")."<br>\r\n", $message);
 683                 } else {
 684                     $string = sprintf (_("Unknown error: %s") . "<br>\n", $message);
 685                 }
 686                 if (isset($read) && is_array($read)) {
 687                     $string .= '<br>' . _("Read data:") . "<br>\n";
 688                     foreach ($read as $line) {
 689                         $string .= htmlspecialchars($line) . "<br>\n";
 690                     }
 691                 }
 692                 error_box($string,$color);
 693                 exit;
 694             } else {
 695                 /*
 696                  * If the user does not log in with the correct
 697                  * username and password it is not possible to get the
 698                  * correct locale from the user's preferences.
 699                  * Therefore, apply the same hack as on the login
 700                  * screen.
 701                  *
 702                  * $squirrelmail_language is set by a cookie when
 703                  * the user selects language and logs out
 704                  */
 705
 706                 set_up_language($squirrelmail_language, true);
 707                 include_once(SM_PATH . 'functions/display_messages.php' );
 708                 sqsession_destroy();
 709                 logout_error( _("Unknown user or password incorrect.") );
 710                 exit;
 711             }
 712         } else {
 713             exit;
 714         }
 715     }
 716     return $imap_stream;
 717 }
 718
 719 /* Simply logs out the IMAP session */
 720 function sqimap_logout ($imap_stream) {
 721     /* Logout is not valid until the server returns 'BYE'
 722      * If we don't have an imap_ stream we're already logged out */
 723     if(isset($imap_stream) && $imap_stream)
 724         sqimap_run_command($imap_stream, 'LOGOUT', false, $response, $message);
 725 }
 726
 727 function sqimap_capability($imap_stream, $capability='') {
 728     global $sqimap_capabilities;
 729     if (!is_array($sqimap_capabilities)) {
 730         $read = sqimap_run_command($imap_stream, 'CAPABILITY', true, $a, $b);
 731
 732         $c = explode(' ', $read[0]);
 733         for ($i=2; $i < count($c); $i++) {
 734             $cap_list = explode('=', $c[$i]);
 735             if (isset($cap_list[1])) {
 736                 $sqimap_capabilities[$cap_list[0]] = $cap_list[1];
 737             } else {
 738                 $sqimap_capabilities[$cap_list[0]] = TRUE;
 739             }
 740         }
 741     }
 742     if ($capability) {
 743         if (isset($sqimap_capabilities[$capability])) {
 744                 return $sqimap_capabilities[$capability];
 745         } else {
 746                 return false;
 747         }
 748     }
 749     return $sqimap_capabilities;
 750 }
 751
 752 /* Returns the delimeter between mailboxes: INBOX/Test, or INBOX.Test */
 753 function sqimap_get_delimiter ($imap_stream = false) {
 754     global $sqimap_delimiter, $optional_delimiter;
 755
 756     /* Use configured delimiter if set */
 757     if((!empty($optional_delimiter)) && $optional_delimiter != 'detect') {
 758         return $optional_delimiter;
 759     }
 760
 761     /* Do some caching here */
 762     if (!$sqimap_delimiter) {
 763         if (sqimap_capability($imap_stream, 'NAMESPACE')) {
 764             /*
 765              * According to something that I can't find, this is supposed to work on all systems
 766              * OS: This won't work in Courier IMAP.
 767              * OS: According to rfc2342 response from NAMESPACE command is:
 768              * OS: * NAMESPACE (PERSONAL NAMESPACES) (OTHER_USERS NAMESPACE) (SHARED NAMESPACES)
 769              * OS: We want to lookup all personal NAMESPACES...
 770              */
 771             $read = sqimap_run_command($imap_stream, 'NAMESPACE', true, $a, $b);
 772             if (eregi('\\* NAMESPACE +(\\( *\\(.+\\) *\\)|NIL) +(\\( *\\(.+\\) *\\)|NIL) +(\\( *\\(.+\\) *\\)|NIL)', $read[0], $data)) {
 773                 if (eregi('^\\( *\\((.*)\\) *\\)', $data[1], $data2)) {
 774                     $pn = $data2[1];
 775                 }
 776                 $pna = explode(')(', $pn);
 777                 while (list($k, $v) = each($pna)) {
 778                     $lst = explode('"', $v);
 779                     if (isset($lst[3])) {
 780                         $pn[$lst[1]] = $lst[3];
 781                     } else {
 782                         $pn[$lst[1]] = '';
 783                     }
 784                 }
 785             }
 786             $sqimap_delimiter = $pn[0];
 787         } else {
 788             fputs ($imap_stream, ". LIST \"INBOX\" \"\"\r\n");
 789             $read = sqimap_read_data($imap_stream, '.', true, $a, $b);
 790             $read = $read['.'][0];      //sqimap_read_data() now returns a tag array of response array
 791             $quote_position = strpos ($read[0], '"');
 792             $sqimap_delimiter = substr ($read[0], $quote_position+1, 1);
 793         }
 794     }
 795     return $sqimap_delimiter;
 796 }
 797
 798
 799 function sqimap_encode_mailbox_name($what)
 800 {
 801         if (ereg("[\"\\\r\n]", $what))
 802                 return '{' . strlen($what) . "}\r\n" . $what;   /* 4.3 literal form */
 803         return '"' . $what . '"';       /* 4.3 quoted string form */
 804 }
 805
 806
 807 /* Gets the number of messages in the current mailbox. */
 808 function sqimap_get_num_messages ($imap_stream, $mailbox) {
 809     $read_ary = sqimap_run_command ($imap_stream, 'EXAMINE ' . sqimap_encode_mailbox_name($mailbox), false, $result, $message);
 810     for ($i = 0; $i < count($read_ary); $i++) {
 811         if (ereg("[^ ]+ +([^ ]+) +EXISTS", $read_ary[$i], $regs)) {
 812             return $regs[1];
 813         }
 814     }
 815     return false; //"BUG! Couldn't get number of messages in $mailbox!";
 816 }
 817
 818
 819 function parseAddress($address, $max=0) {
 820     $aTokens = array();
 821     $aAddress = array();
 822     $iCnt = strlen($address);
 823     $aSpecials = array('(' ,'<' ,',' ,';' ,':');
 824     $aReplace =  array(' (',' <',' ,',' ;',' :');
 825     $address = str_replace($aSpecials,$aReplace,$address);
 826     $i = $iAddrFound = $bGroup = 0;
 827     while ($i < $iCnt) {
 828         $cChar = $address{$i};
 829         switch($cChar)
 830         {
 831         case '<':
 832             $iEnd = strpos($address,'>',$i+1);
 833             if (!$iEnd) {
 834                $sToken = substr($address,$i);
 835                $i = $iCnt;
 836             } else {
 837                $sToken = substr($address,$i,$iEnd - $i +1);
 838                $i = $iEnd;
 839             }
 840             $sToken = str_replace($aReplace, $aSpecials,$sToken);
 841             $aTokens[] = $sToken;
 842             break;
 843         case '"':
 844             $iEnd = strpos($address,$cChar,$i+1);
 845             if ($iEnd) {
 846                // skip escaped quotes
 847                $prev_char = $address{$iEnd-1};
 848                while ($prev_char === '\\' && substr($address,$iEnd-2,2) !== '\\\\') {
 849                    $iEnd = strpos($address,$cChar,$iEnd+1);
 850                    if ($iEnd) {
 851                       $prev_char = $address{$iEnd-1};
 852                    } else {
 853                       $prev_char = false;
 854                    }
 855                }
 856             }
 857             if (!$iEnd) {
 858                 $sToken = substr($address,$i);
 859                 $i = $iCnt;
 860             } else {
 861                 // also remove the surrounding quotes
 862                 $sToken = substr($address,$i+1,$iEnd - $i -1);
 863                 $i = $iEnd;
 864             }
 865             $sToken = str_replace($aReplace, $aSpecials,$sToken);
 866             if ($sToken) $aTokens[] = $sToken;
 867             break;
 868         case '(':
 869             $iEnd = strpos($address,')',$i);
 870             if (!$iEnd) {
 871                 $sToken = substr($address,$i);
 872                 $i = $iCnt;
 873             } else {
 874                 $sToken = substr($address,$i,$iEnd - $i + 1);
 875                 $i = $iEnd;
 876             }
 877             $sToken = str_replace($aReplace, $aSpecials,$sToken);
 878             $aTokens[] = $sToken;
 879             break;
 880         case ',':
 881             ++$iAddrFound;
 882         case ';':
 883             if (!$bGroup) {
 884                ++$iAddrFound;
 885             } else {
 886                $bGroup = false;
 887             }
 888             if ($max && $max == $iAddrFound) {
 889                break 2;
 890             } else {
 891                $aTokens[] = $cChar;
 892                break;
 893             }
 894         case ':':
 895            $bGroup = true;
 896         case ' ':
 897             $aTokens[] = $cChar;
 898             break;
 899         default:
 900             $iEnd = strpos($address,' ',$i+1);
 901             if ($iEnd) {
 902                 $sToken = trim(substr($address,$i,$iEnd - $i));
 903                 $i = $iEnd-1;
 904             } else {
 905                 $sToken = trim(substr($address,$i));
 906                 $i = $iCnt;
 907             }
 908             if ($sToken) $aTokens[] = $sToken;
 909         }
 910         ++$i;
 911     }
 912     $sPersonal = $sEmail = $sComment = $sGroup = '';
 913     $aStack = $aComment = array();
 914     foreach ($aTokens as $sToken) {
 915         if ($max && $max == count($aAddress)) {
 916             return $aAddress;
 917         }
 918         $cChar = $sToken{0};
 919         switch ($cChar)
 920         {
 921           case '=':
 922           case '"':
 923           case ' ':
 924             $aStack[] = $sToken;
 925             break;
 926           case '(':
 927             $aComment[] = substr($sToken,1,-1);
 928             break;
 929           case ';':
 930             if ($sGroup) {
 931                 $sEmail = trim(implode(' ',$aStack));
 932                 $aAddress[] = array($sGroup,$sEmail);
 933                 $aStack = $aComment = array();
 934                 $sGroup = '';
 935                 break;
 936             }
 937           case ',':
 938             if (!$sEmail) {
 939                 while (count($aStack) && !$sEmail) {
 940                     $sEmail = trim(array_pop($aStack));
 941                 }
 942             }
 943             if (count($aStack)) {
 944                 $sPersonal = trim(implode('',$aStack));
 945             } else {
 946                 $sPersonal = '';
 947             }
 948             if (!$sPersonal && count($aComment)) {
 949                 $sComment = implode(' ',$aComment);
 950                 $sPersonal .= $sComment;
 951             }
 952             $aAddress[] = array($sEmail,$sPersonal);
 953             $sPersonal = $sComment = $sEmail = '';
 954             $aStack = $aComment = array();
 955             break;
 956           case ':':
 957             $sGroup = implode(' ',$aStack); break;
 958             $aStack = array();
 959             break;
 960           case '<':
 961             $sEmail = trim(substr($sToken,1,-1));
 962             break;
 963           case '>':
 964             /* skip */
 965             break;
 966           default: $aStack[] = $sToken; break;
 967         }
 968     }
 969     /* now do the action again for the last address */
 970     if (!$sEmail) {
 971         while (count($aStack) && !$sEmail) {
 972             $sEmail = trim(array_pop($aStack));
 973         }
 974     }
 975     if (count($aStack)) {
 976         $sPersonal = trim(implode('',$aStack));
 977     } else {
 978         $sPersonal = '';
 979     }
 980     if (!$sPersonal && count($aComment)) {
 981         $sComment = implode(' ',$aComment);
 982         $sPersonal .= $sComment;
 983     }
 984     $aAddress[] = array($sEmail,$sPersonal);
 985     return $aAddress;
 986 }
 987
 988
 989
 990 /*
 991  * Returns the number of unseen messages in this folder
 992  */
 993 function sqimap_unseen_messages ($imap_stream, $mailbox) {
 994     $read_ary = sqimap_run_command ($imap_stream, 'STATUS ' . sqimap_encode_mailbox_name($mailbox) . ' (UNSEEN)', false, $result, $message);
 995     $i = 0;
 996     $regs = array(false, false);
 997     while (isset($read_ary[$i])) {
 998         if (ereg("UNSEEN ([0-9]+)", $read_ary[$i], $regs)) {
 999             break;
1000         }
1001         $i++;
1002     }
1003     return $regs[1];
1004 }
1005
1006 /*
1007  * Returns the number of total/unseen/recent messages in this folder
1008  */
1009 function sqimap_status_messages ($imap_stream, $mailbox) {
1010     $read_ary = sqimap_run_command ($imap_stream, 'STATUS ' . sqimap_encode_mailbox_name($mailbox) . ' (MESSAGES UNSEEN RECENT)', false, $result, $message);
1011     $i = 0;
1012     $messages = $unseen = $recent = false;
1013     $regs = array(false,false);
1014     while (isset($read_ary[$i])) {
1015         if (preg_match('/UNSEEN\s+([0-9]+)/i', $read_ary[$i], $regs)) {
1016             $unseen = $regs[1];
1017         }
1018         if (preg_match('/MESSAGES\s+([0-9]+)/i', $read_ary[$i], $regs)) {
1019             $messages = $regs[1];
1020         }
1021         if (preg_match('/RECENT\s+([0-9]+)/i', $read_ary[$i], $regs)) {
1022             $recent = $regs[1];
1023         }
1024         $i++;
1025     }
1026     return array('MESSAGES' => $messages, 'UNSEEN'=>$unseen, 'RECENT' => $recent);
1027 }
1028
1029
1030 /*
1031  *  Saves a message to a given folder -- used for saving sent messages
1032  */
1033 function sqimap_append ($imap_stream, $sent_folder, $length) {
1034     fputs ($imap_stream, sqimap_session_id() . ' APPEND ' . sqimap_encode_mailbox_name($sent_folder) . " (\\Seen) \{$length}\r\n");
1035     $tmp = fgets ($imap_stream, 1024);
1036 }
1037
1038 function sqimap_append_done ($imap_stream, $folder='') {
1039     global $squirrelmail_language, $color;
1040     fputs ($imap_stream, "\r\n");
1041     $tmp = fgets ($imap_stream, 1024);
1042     if (preg_match("/(.*)(BAD|NO)(.*)$/", $tmp, $regs)) {
1043         set_up_language($squirrelmail_language);
1044         require_once(SM_PATH . 'functions/display_messages.php');
1045         $reason = $regs[3];
1046         if ($regs[2] == 'NO') {
1047            $string = "<b><font color=$color[2]>\n" .
1048                   _("ERROR : Could not append message to") ." $folder." .
1049                   "</b><br>\n" .
1050                   _("Server responded: ") .
1051                   $reason . "<br>\n";
1052            if (preg_match("/(.*)(quota)(.*)$/i", $reason, $regs)) {
1053               $string .= _("Solution: ") .
1054             _("Remove unneccessary messages from your folder and start with your Trash folder.")
1055               ."<br>\n";
1056            }
1057            $string .= "</font>\n";
1058            error_box($string,$color);
1059         } else {
1060            $string = "<b><font color=$color[2]>\n" .
1061                   _("ERROR : Bad or malformed request.") .
1062                   "</b><br>\n" .
1063                   _("Server responded: ") .
1064                   $tmp . "</font><br>\n";
1065            error_box($string,$color);
1066            exit;
1067         }
1068     }
1069 }
1070
1071 function sqimap_get_user_server ($imap_server, $username) {
1072    if (substr($imap_server, 0, 4) != "map:") {
1073        return $imap_server;
1074    }
1075    $function = substr($imap_server, 4);
1076    return $function($username);
1077 }
1078
1079 /* This is an example that gets imapservers from yellowpages (NIS).
1080  * you can simple put map:map_yp_alias in your $imap_server_address
1081  * in config.php use your own function instead map_yp_alias to map your
1082  * LDAP whatever way to find the users imapserver. */
1083
1084 function map_yp_alias($username) {
1085    $yp = `ypmatch $username aliases`;
1086    return chop(substr($yp, strlen($username)+1));
1087 }
1088
1089 ?>