functions/imap_general.php

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