functions/imap_general.php

   1 <?php
   2
   3 /**
   4  * imap_general.php
   5  *
   6  * This implements all functions that do general IMAP functions.
   7  *
   8  * @copyright &copy; 1999-2006 The SquirrelMail Project Team
   9  * @license http://opensource.org/licenses/gpl-license.php GNU Public License
  10  * @version $Id$
  11  * @package squirrelmail
  12  * @subpackage imap
  13  */
  14
  15 /** Includes.. */
  16
  17 require_once(SM_PATH . 'functions/rfc822address.php');
  18
  19
  20 /**
  21  * Generates a new session ID by incrementing the last one used;
  22  * this ensures that each command has a unique ID.
  23  * @param bool $unique_id (since 1.3.0) controls use of unique
  24  *  identifiers/message sequence numbers in IMAP commands. See IMAP
  25  *  rfc 'UID command' chapter.
  26  * @return string IMAP session id of the form 'A000'.
  27  * @since 1.2.0
  28  */
  29 function sqimap_session_id($unique_id = FALSE) {
  30     static $sqimap_session_id = 1;
  31
  32     if (!$unique_id) {
  33         return( sprintf("A%03d", $sqimap_session_id++) );
  34     } else {
  35         return( sprintf("A%03d", $sqimap_session_id++) . ' UID' );
  36     }
  37 }
  38
  39 /**
  40  * Both send a command and accept the result from the command.
  41  * This is to allow proper session number handling.
  42  * @param stream $imap_stream imap connection resource
  43  * @param string $query imap command
  44  * @param boolean $handle_errors see sqimap_retrieve_imap_response()
  45  * @param array $response
  46  * @param array $message
  47  * @param boolean $unique_id (since 1.3.0) see sqimap_session_id().
  48  * @return mixed returns false on imap error. displays error message
  49  *  if imap stream is not available.
  50  * @since 1.2.3
  51  */
  52 function sqimap_run_command_list ($imap_stream, $query, $handle_errors, &$response, &$message, $unique_id = false) {
  53     if ($imap_stream) {
  54         $sid = sqimap_session_id($unique_id);
  55         fputs ($imap_stream, $sid . ' ' . $query . "\r\n");
  56         $tag_uid_a = explode(' ',trim($sid));
  57         $tag = $tag_uid_a[0];
  58         $read = sqimap_retrieve_imap_response ($imap_stream, $tag, $handle_errors, $response, $message, $query );
  59         /* get the response and the message */
  60         $message = $message[$tag];
  61         $response = $response[$tag];
  62         return $read[$tag];
  63     } else {
  64         global $squirrelmail_language, $color;
  65         set_up_language($squirrelmail_language);
  66         $string = "<b><font color=\"$color[2]\">\n" .
  67                 _("ERROR: No available IMAP stream.") .
  68                 "</b></font>\n";
  69         error_box($string);
  70         return false;
  71     }
  72 }
  73
  74 /**
  75  * @param stream $imap_stream imap connection resource
  76  * @param string $query imap command
  77  * @param boolean $handle_errors see sqimap_retrieve_imap_response()
  78  * @param array $response empty string, if return = false
  79  * @param array $message empty string, if return = false
  80  * @param boolean $unique_id (since 1.3.0) see sqimap_session_id()
  81  * @param boolean $filter (since 1.4.1 and 1.5.0) see sqimap_fread()
  82  * @param mixed $outputstream (since 1.4.1 and 1.5.0) see sqimap_fread()
  83  * @param boolean $no_return (since 1.4.1 and 1.5.0) see sqimap_fread()
  84  * @return mixed returns false on imap error. displays error message
  85  *  if imap stream is not available.
  86  * @since 1.2.3
  87  */
  88 function sqimap_run_command ($imap_stream, $query, $handle_errors, &$response,
  89                             &$message, $unique_id = false,$filter=false,
  90                              $outputstream=false,$no_return=false) {
  91     if ($imap_stream) {
  92         $sid = sqimap_session_id($unique_id);
  93         fputs ($imap_stream, $sid . ' ' . $query . "\r\n");
  94         $tag_uid_a = explode(' ',trim($sid));
  95         $tag = $tag_uid_a[0];
  96
  97         $read = sqimap_read_data ($imap_stream, $tag, $handle_errors, $response,
  98                                   $message, $query,$filter,$outputstream,$no_return);
  99         if (empty($read)) {    //IMAP server dropped its connection
 100             $response = '';
 101             $message = '';
 102             return false;
 103         }
 104         /* retrieve the response and the message */
 105         $response = $response[$tag];
 106         $message  = $message[$tag];
 107
 108         if (!empty($read[$tag])) {
 109             return $read[$tag][0];
 110         } else {
 111             return $read[$tag];
 112         }
 113     } else {
 114         global $squirrelmail_language, $color;
 115         set_up_language($squirrelmail_language);
 116         $string = "<b><font color=\"$color[2]\">\n" .
 117                 _("ERROR: No available IMAP stream.") .
 118                 "</b></font>\n";
 119         error_box($string);
 120         return false;
 121     }
 122 }
 123
 124 /**
 125  * @param mixed $new_query
 126  * @param string $tag
 127  * @param array $aQuery
 128  * @param boolean $unique_id see sqimap_session_id()
 129  * @since 1.5.0
 130  */
 131 function sqimap_prepare_pipelined_query($new_query,&$tag,&$aQuery,$unique_id) {
 132     $sid = sqimap_session_id($unique_id);
 133     $tag_uid_a = explode(' ',trim($sid));
 134     $tag = $tag_uid_a[0];
 135     $query = $sid . ' '.$new_query."\r\n";
 136     $aQuery[$tag] = $query;
 137 }
 138
 139 /**
 140  * @param stream $imap_stream imap stream
 141  * @param array $aQueryList
 142  * @param boolean $handle_errors
 143  * @param array $aServerResponse
 144  * @param array $aServerMessage
 145  * @param boolean $unique_id see sqimap_session_id()
 146  * @param boolean $filter see sqimap_fread()
 147  * @param mixed $outputstream see sqimap_fread()
 148  * @param boolean $no_return see sqimap_fread()
 149  * @since 1.5.0
 150  */
 151 function sqimap_run_pipelined_command ($imap_stream, $aQueryList, $handle_errors,
 152                        &$aServerResponse, &$aServerMessage, $unique_id = false,
 153                        $filter=false,$outputstream=false,$no_return=false) {
 154     $aResponse = false;
 155
 156     /*
 157        Do not fire all calls at once to the IMAP server but split the calls up
 158        in portions of $iChunkSize. If we do not do that I think we misbehave as
 159        IMAP client or should handle BYE calls if the IMAP server drops the
 160        connection because the number of queries is to large. This isn't tested
 161        but a wild guess how it could work in the field.
 162
 163        After testing it on Exchange 2000 we discovered that a chunksize of 32
 164        was quicker then when we raised it to 128.
 165     */
 166     $iQueryCount = count($aQueryList);
 167     $iChunkSize = 32;
 168     // array_chunk would also do the job but it's supported from php > 4.2
 169     $aQueryChunks = array();
 170     $iLoops = floor($iQueryCount / $iChunkSize);
 171
 172     if ($iLoops * $iChunkSize != $iQueryCount) ++$iLoops;
 173
 174     if (!function_exists('array_chunk')) { // arraychunk replacement
 175         reset($aQueryList);
 176         for($i=0;$i<$iLoops;++$i) {
 177             for($j=0;$j<$iChunkSize;++$j) {
 178                 $key = key($aQueryList);
 179                 $aTmp[$key] = $aQueryList[$key];
 180                 if (next($aQueryList) === false) break;
 181             }
 182             $aQueryChunks[] = $aTmp;
 183         }
 184     } else {
 185         $aQueryChunks = array_chunk($aQueryList,$iChunkSize,true);
 186     }
 187
 188     for ($i=0;$i<$iLoops;++$i) {
 189         $aQuery = $aQueryChunks[$i];
 190         foreach($aQuery as $tag => $query) {
 191             fputs($imap_stream,$query);
 192             $aResults[$tag] = false;
 193         }
 194         foreach($aQuery as $tag => $query) {
 195             if ($aResults[$tag] == false) {
 196                 $aReturnedResponse = sqimap_retrieve_imap_response ($imap_stream, $tag,
 197                                     $handle_errors, $response, $message, $query,
 198                                     $filter,$outputstream,$no_return);
 199                 foreach ($aReturnedResponse as $returned_tag => $aResponse) {
 200                     if (!empty($aResponse)) {
 201                         $aResults[$returned_tag] = $aResponse[0];
 202                     } else {
 203                         $aResults[$returned_tag] = $aResponse;
 204                     }
 205                     $aServerResponse[$returned_tag] = $response[$returned_tag];
 206                     $aServerMessage[$returned_tag] = $message[$returned_tag];
 207                 }
 208             }
 209         }
 210     }
 211     return $aResults;
 212 }
 213
 214 /**
 215  * Custom fgets function: gets a line from the IMAP server,
 216  * no matter how big it may be.
 217  * @param stream $imap_stream the stream to read from
 218  * @return string a line
 219  * @since 1.2.8
 220  */
 221 function sqimap_fgets($imap_stream) {
 222     $read = '';
 223     $buffer = 4096;
 224     $results = '';
 225     $offset = 0;
 226     while (strpos($results, "\r\n", $offset) === false) {
 227         if (!($read = fgets($imap_stream, $buffer))) {
 228         /* this happens in case of an error */
 229         /* reset $results because it's useless */
 230         $results = false;
 231             break;
 232         }
 233         if ( $results != '' ) {
 234             $offset = strlen($results) - 1;
 235         }
 236         $results .= $read;
 237     }
 238     return $results;
 239 }
 240
 241 /**
 242  * @param stream $imap_stream
 243  * @param integer $iSize
 244  * @param boolean $filter
 245  * @param mixed $outputstream stream or 'php://stdout' string
 246  * @param boolean $no_return controls data returned by function
 247  * @return string
 248  * @since 1.4.1
 249  */
 250 function sqimap_fread($imap_stream,$iSize,$filter=false,
 251                       $outputstream=false, $no_return=false) {
 252     if (!$filter || !$outputstream) {
 253         $iBufferSize = $iSize;
 254     } else {
 255         // see php bug 24033. They changed fread behaviour %$^&$%
 256         $iBufferSize = 7800; // multiple of 78 in case of base64 decoding.
 257     }
 258     if ($iSize < $iBufferSize) {
 259         $iBufferSize = $iSize;
 260     }
 261
 262     $iRetrieved = 0;
 263     $results = '';
 264     $sRead = $sReadRem = '';
 265     // NB: fread can also stop at end of a packet on sockets.
 266     while ($iRetrieved < $iSize) {
 267         $sRead = fread($imap_stream,$iBufferSize);
 268         $iLength = strlen($sRead);
 269         $iRetrieved += $iLength ;
 270         $iRemaining = $iSize - $iRetrieved;
 271         if ($iRemaining < $iBufferSize) {
 272             $iBufferSize = $iRemaining;
 273         }
 274         if ($sRead == '') {
 275             $results = false;
 276             break;
 277         }
 278         if ($sReadRem != '') {
 279             $sRead = $sReadRem . $sRead;
 280             $sReadRem = '';
 281         }
 282
 283         if ($filter && $sRead != '') {
 284            // in case the filter is base64 decoding we return a remainder
 285            $sReadRem = $filter($sRead);
 286         }
 287         if ($outputstream && $sRead != '') {
 288            if (is_resource($outputstream)) {
 289                fwrite($outputstream,$sRead);
 290            } else if ($outputstream == 'php://stdout') {
 291                echo $sRead;
 292            }
 293         }
 294         if ($no_return) {
 295             $sRead = '';
 296         } else {
 297             $results .= $sRead;
 298         }
 299     }
 300     return $results;
 301 }
 302
 303
 304 /**
 305  * Obsolete function, inform plugins that use it
 306  * @param stream $imap_stream
 307  * @param string $tag
 308  * @param boolean $handle_errors
 309  * @param array $response
 310  * @param array $message
 311  * @param string $query
 312  * @since 1.1.3
 313  * @deprecated (since 1.5.0) use sqimap_run_command or sqimap_run_command_list instead
 314  */
 315 function sqimap_read_data_list($imap_stream, $tag, $handle_errors,
 316           &$response, &$message, $query = '') {
 317     global $color, $oTemplate, $squirrelmail_language;
 318     set_up_language($squirrelmail_language);
 319     $string = "<b><font color=\"$color[2]\">\n" .
 320         _("ERROR: Bad function call.") .
 321         "</b><br />\n" .
 322         _("Reason:") . ' '.
 323           'There is a plugin installed which make use of the  <br />' .
 324           'SquirrelMail internal function sqimap_read_data_list.<br />'.
 325           'Please adapt the installed plugin and let it use<br />'.
 326           'sqimap_run_command or sqimap_run_command_list instead<br /><br />'.
 327           'The following query was issued:<br />'.
 328            htmlspecialchars($query) . '<br />' . "</font><br />\n";
 329     error_box($string);
 330     $oTemplate->display('footer.tpl');
 331     exit;
 332 }
 333
 334 /**
 335  * Function to display an error related to an IMAP query.
 336  * @param string title the caption of the error box
 337  * @param string query the query that went wrong
 338  * @param string message_title optional message title
 339  * @param string message optional error message
 340  * @param string $link an optional link to try again
 341  * @return void
 342  * @since 1.5.0
 343  */
 344 function sqimap_error_box($title, $query = '', $message_title = '', $message = '', $link = '')
 345 {
 346     global $color, $squirrelmail_language;
 347
 348     set_up_language($squirrelmail_language);
 349     $string = "<font color=\"$color[2]\"><b>\n" . $title . "</b><br />\n";
 350     $cmd = explode(' ',$query);
 351     $cmd= strtolower($cmd[0]);
 352
 353     if ($query != '' &&  $cmd != 'login')
 354         $string .= _("Query:") . ' ' . htmlspecialchars($query) . '<br />';
 355     if ($message_title != '')
 356         $string .= $message_title;
 357     if ($message != '')
 358         $string .= htmlspecialchars($message);
 359     $string .= "</font><br />\n";
 360     if ($link != '')
 361         $string .= $link;
 362     error_box($string);
 363 }
 364
 365 /**
 366  * Reads the output from the IMAP stream.  If handle_errors is set to true,
 367  * this will also handle all errors that are received.  If it is not set,
 368  * the errors will be sent back through $response and $message.
 369  * @param stream $imap_stream imap stream
 370  * @param string $tag
 371  * @param boolean $handle_errors handle errors internally or send them in $response and $message.
 372  * @param array $response
 373  * @param array $message
 374  * @param string $query command that can be printed if something fails
 375  * @param boolean $filter see sqimap_fread()
 376  * @param mixed $outputstream  see sqimap_fread()
 377  * @param boolean $no_return  see sqimap_fread()
 378  * @since 1.5.0
 379  */
 380 function sqimap_retrieve_imap_response($imap_stream, $tag, $handle_errors,
 381           &$response, &$message, $query = '',
 382            $filter = false, $outputstream = false, $no_return = false) {
 383     global $color, $squirrelmail_language;
 384     $read = '';
 385     if (!is_array($message)) $message = array();
 386     if (!is_array($response)) $response = array();
 387     $aResponse = '';
 388     $resultlist = array();
 389     $data = array();
 390     $sCommand = '';
 391     if (preg_match("/^(\w+)\s*/",$query,$aMatch)) {
 392         $sCommand = strtoupper($aMatch[1]);
 393     } else {
 394         // error reporting (shouldn't happen)
 395     }
 396     $read = sqimap_fgets($imap_stream);
 397     $i = 0;
 398     while ($read) {
 399         $char = $read{0};
 400         switch ($char)
 401         {
 402           case '+':
 403           default:
 404             $read = sqimap_fgets($imap_stream);
 405             break;
 406
 407           case $tag{0}:
 408           {
 409             /* get the command */
 410             $arg = '';
 411             $i = strlen($tag)+1;
 412             $s = substr($read,$i);
 413             if (($j = strpos($s,' ')) || ($j = strpos($s,"\n"))) {
 414                 $arg = substr($s,0,$j);
 415             }
 416             $found_tag = substr($read,0,$i-1);
 417             if ($found_tag) {
 418                 switch ($arg)
 419                 {
 420                   case 'OK':
 421                   case 'BAD':
 422                   case 'NO':
 423                   case 'BYE':
 424                   case 'PREAUTH':
 425                     $response[$found_tag] = $arg;
 426                     $message[$found_tag] = trim(substr($read,$i+strlen($arg)));
 427                     if (!empty($data)) {
 428                         $resultlist[] = $data;
 429                     }
 430                     $aResponse[$found_tag] = $resultlist;
 431                     $data = $resultlist = array();
 432                     if ($found_tag == $tag) {
 433                         break 3; /* switch switch while */
 434                     }
 435                   break;
 436                   default:
 437                     /* this shouldn't happen */
 438                     $response[$found_tag] = $arg;
 439                     $message[$found_tag] = trim(substr($read,$i+strlen($arg)));
 440                     if (!empty($data)) {
 441                         $resultlist[] = $data;
 442                     }
 443                     $aResponse[$found_tag] = $resultlist;
 444                     $data = $resultlist = array();
 445                     if ($found_tag == $tag) {
 446                         break 3; /* switch switch while */
 447                     }
 448                 }
 449             }
 450             $read = sqimap_fgets($imap_stream);
 451             if ($read === false) { /* error */
 452                  break 2; /* switch while */
 453             }
 454             break;
 455           } // end case $tag{0}
 456
 457           case '*':
 458           {
 459             if (($sCommand == "FETCH" || $sCommand == "STORE")  && preg_match('/^\*\s\d+\sFETCH/',$read)) {
 460                 /* check for literal */
 461                 $s = substr($read,-3);
 462                 $fetch_data = array();
 463                 do { /* outer loop, continue until next untagged fetch
 464                         or tagged reponse */
 465                     do { /* innerloop for fetching literals. with this loop
 466                             we prohibid that literal responses appear in the
 467                             outer loop so we can trust the untagged and
 468                             tagged info provided by $read */
 469                         if ($s === "}\r\n") {
 470                             $j = strrpos($read,'{');
 471                             $iLit = substr($read,$j+1,-3);
 472                             $fetch_data[] = $read;
 473                             $sLiteral = sqimap_fread($imap_stream,$iLit,$filter,$outputstream,$no_return);
 474                             if ($sLiteral === false) { /* error */
 475                                 break 4; /* while while switch while */
 476                             }
 477                             /* backwards compattibility */
 478                             $aLiteral = explode("\n", $sLiteral);
 479                             /* release not neaded data */
 480                             unset($sLiteral);
 481                             foreach ($aLiteral as $line) {
 482                                 $fetch_data[] = $line ."\n";
 483                             }
 484                             /* release not neaded data */
 485                             unset($aLiteral);
 486                             /* next fgets belongs to this fetch because
 487                                we just got the exact literalsize and there
 488                                must follow data to complete the response */
 489                             $read = sqimap_fgets($imap_stream);
 490                             if ($read === false) { /* error */
 491                                 break 4; /* while while switch while */
 492                             }
 493                             $fetch_data[] = $read;
 494                         } else {
 495                             $fetch_data[] = $read;
 496                         }
 497                         /* retrieve next line and check in the while
 498                            statements if it belongs to this fetch response */
 499                         $read = sqimap_fgets($imap_stream);
 500                         if ($read === false) { /* error */
 501                             break 4; /* while while switch while */
 502                         }
 503                         /* check for next untagged reponse and break */
 504                         if ($read{0} == '*') break 2;
 505                         $s = substr($read,-3);
 506                     } while ($s === "}\r\n");
 507                     $s = substr($read,-3);
 508                 } while ($read{0} !== '*' &&
 509                          substr($read,0,strlen($tag)) !== $tag);
 510                 $resultlist[] = $fetch_data;
 511                 /* release not neaded data */
 512                 unset ($fetch_data);
 513             } else {
 514                 $s = substr($read,-3);
 515                 do {
 516                     if ($s === "}\r\n") {
 517                         $j = strrpos($read,'{');
 518                         $iLit = substr($read,$j+1,-3);
 519                         $data[] = $read;
 520                         $sLiteral = fread($imap_stream,$iLit);
 521                         if ($sLiteral === false) { /* error */
 522                             $read = false;
 523                             break 3; /* while switch while */
 524                         }
 525                         $data[] = $sLiteral;
 526                         $data[] = sqimap_fgets($imap_stream);
 527                     } else {
 528                          $data[] = $read;
 529                     }
 530                     $read = sqimap_fgets($imap_stream);
 531                     if ($read === false) {
 532                         break 3; /* while switch while */
 533                     } else if ($read{0} == '*') {
 534                         break;
 535                     }
 536                     $s = substr($read,-3);
 537                 } while ($s === "}\r\n");
 538                 break 1;
 539             }
 540             break;
 541           } // end case '*'
 542         }   // end switch
 543     } // end while
 544
 545     /* error processing in case $read is false */
 546     if ($read === false) {
 547         // try to retrieve an untagged bye respons from the results
 548         $sResponse = array_pop($data);
 549         if ($sResponse !== NULL && strpos($sResponse,'* BYE') !== false) {
 550             if (!$handle_errors) {
 551                 $query = '';
 552             }
 553             sqimap_error_box(_("ERROR: IMAP server closed the connection."), $query, _("Server responded:"),$sResponse);
 554             echo '</body></html>';
 555             exit;
 556         } else if ($handle_errors) {
 557             unset($data);
 558             sqimap_error_box(_("ERROR: Connection dropped by IMAP server."), $query);
 559             exit;
 560         }
 561     }
 562
 563     /* Set $resultlist array */
 564     if (!empty($data)) {
 565         //$resultlist[] = $data;
 566     }
 567     elseif (empty($resultlist)) {
 568         $resultlist[] = array();
 569     }
 570
 571     /* Return result or handle errors */
 572     if ($handle_errors == false) {
 573         return $aResponse;
 574     }
 575     switch ($response[$tag]) {
 576     case 'OK':
 577         return $aResponse;
 578         break;
 579     case 'NO':
 580         /* ignore this error from M$ exchange, it is not fatal (aka bug) */
 581         if (strstr($message[$tag], 'command resulted in') === false) {
 582             sqimap_error_box(_("ERROR: Could not complete request."), $query, _("Reason Given:") . ' ', $message[$tag]);
 583             echo '</body></html>';
 584             exit;
 585         }
 586         break;
 587     case 'BAD':
 588         sqimap_error_box(_("ERROR: Bad or malformed request."), $query, _("Server responded:") . ' ', $message[$tag]);
 589         echo '</body></html>';
 590         exit;
 591     case 'BYE':
 592         sqimap_error_box(_("ERROR: IMAP server closed the connection."), $query, _("Server responded:") . ' ', $message[$tag]);
 593         echo '</body></html>';
 594         exit;
 595     default:
 596         sqimap_error_box(_("ERROR: Unknown IMAP response."), $query, _("Server responded:") . ' ', $message[$tag]);
 597        /* the error is displayed but because we don't know the reponse we
 598           return the result anyway */
 599        return $aResponse;
 600        break;
 601     }
 602 }
 603
 604 /**
 605  * @param stream $imap_stream imap string
 606  * @param string $tag_uid
 607  * @param boolean $handle_errors
 608  * @param array $response
 609  * @param array $message
 610  * @param string $query (since 1.2.5)
 611  * @param boolean $filter (since 1.4.1) see sqimap_fread()
 612  * @param mixed $outputstream (since 1.4.1) see sqimap_fread()
 613  * @param boolean $no_return (since 1.4.1) see sqimap_fread()
 614  */
 615 function sqimap_read_data ($imap_stream, $tag_uid, $handle_errors,
 616                            &$response, &$message, $query = '',
 617                            $filter=false,$outputstream=false,$no_return=false) {
 618
 619     $tag_uid_a = explode(' ',trim($tag_uid));
 620     $tag = $tag_uid_a[0];
 621
 622     $res = sqimap_retrieve_imap_response($imap_stream, $tag, $handle_errors,
 623               $response, $message, $query,$filter,$outputstream,$no_return);
 624     return $res;
 625 }
 626
 627 /**
 628  * Connects to the IMAP server and returns a resource identifier for use with
 629  * the other SquirrelMail IMAP functions. Does NOT login!
 630  * @param string server hostname of IMAP server
 631  * @param int port port number to connect to
 632  * @param integer $tls whether to use plain text(0), TLS(1) or STARTTLS(2) when connecting.
 633  *  Argument was boolean before 1.5.1.
 634  * @return imap-stream resource identifier
 635  * @since 1.5.0 (usable only in 1.5.1 or later)
 636  */
 637 function sqimap_create_stream($server,$port,$tls=0) {
 638     global $squirrelmail_language;
 639
 640     if (strstr($server,':') && ! preg_match("/^\[.*\]$/",$server)) {
 641         // numerical IPv6 address must be enclosed in square brackets
 642         $server = '['.$server.']';
 643     }
 644
 645     if ($tls == 1) {
 646         if ((check_php_version(4,3)) and (extension_loaded('openssl'))) {
 647             /* Use TLS by prefixing "tls://" to the hostname */
 648             $server = 'tls://' . $server;
 649         } else {
 650             require_once(SM_PATH . 'functions/display_messages.php');
 651             logout_error( sprintf(_("Error connecting to IMAP server: %s."), $server).
 652                 '<br />'.
 653                 _("TLS is enabled, but this version of PHP does not support TLS sockets, or is missing the openssl extension.").
 654                 '<br /><br />'.
 655                 _("Please contact your system administrator and report this error."),
 656                           sprintf(_("Error connecting to IMAP server: %s."), $server));
 657         }
 658     }
 659
 660     $imap_stream = @fsockopen($server, $port, $error_number, $error_string, 15);
 661
 662     /* Do some error correction */
 663     if (!$imap_stream) {
 664         set_up_language($squirrelmail_language, true);
 665         require_once(SM_PATH . 'functions/display_messages.php');
 666         logout_error( sprintf(_("Error connecting to IMAP server: %s."), $server).
 667             "<br />\r\n$error_number : $error_string<br />\r\n",
 668                       sprintf(_("Error connecting to IMAP server: %s."), $server) );
 669         exit;
 670     }
 671     $server_info = fgets ($imap_stream, 1024);
 672
 673     /**
 674      * Implementing IMAP STARTTLS (rfc2595) in php 5.1.0+
 675      * http://www.php.net/stream-socket-enable-crypto
 676      */
 677     if ($tls === 2) {
 678         if (function_exists('stream_socket_enable_crypto')) {
 679             // check starttls capability, don't use cached capability version
 680             if (! sqimap_capability($imap_stream, 'STARTTLS', false)) {
 681                 // imap server does not declare starttls support
 682                 sqimap_error_box(sprintf(_("Error connecting to IMAP server: %s."), $server),
 683                                  '','',
 684                                  _("IMAP STARTTLS is enabled in SquirrelMail configuration, but used IMAP server does not support STARTTLS."));
 685                 exit;
 686             }
 687
 688             // issue starttls command and check response
 689             sqimap_run_command($imap_stream, 'STARTTLS', false, $starttls_response, $starttls_message);
 690             // check response
 691             if ($starttls_response!='OK') {
 692                 // starttls command failed
 693                 sqimap_error_box(sprintf(_("Error connecting to IMAP server: %s."), $server),
 694                                  'STARTTLS',
 695                                  _("Server replied:") . ' ',
 696                                  $starttls_message);
 697                 exit();
 698             }
 699
 700             // start crypto on connection. suppress function errors.
 701             if (@stream_socket_enable_crypto($imap_stream,true,STREAM_CRYPTO_METHOD_TLS_CLIENT)) {
 702                 // starttls was successful
 703
 704                 /**
 705                  * RFC 2595 requires to discard CAPABILITY information after successful
 706                  * STARTTLS command. We don't follow RFC, because SquirrelMail stores CAPABILITY
 707                  * information only after successful login (src/redirect.php) and cached information
 708                  * is used only in other php script connections after successful STARTTLS. If script
 709                  * issues sqimap_capability() call before sqimap_login() and wants to get initial
 710                  * capability response, script should set third sqimap_capability() argument to false.
 711                  */
 712                 //sqsession_unregister('sqimap_capabilities');
 713             } else {
 714                 /**
 715                  * stream_socket_enable_crypto() call failed. Possible issues:
 716                  * - broken ssl certificate (uw drops connection, error is in syslog mail facility)
 717                  * - some ssl error (can reproduce with STREAM_CRYPTO_METHOD_SSLv3_CLIENT, PHP E_WARNING
 718                  *   suppressed in stream_socket_enable_crypto() call)
 719                  */
 720                 sqimap_error_box(sprintf(_("Error connecting to IMAP server: %s."), $server),
 721                                  '','',
 722                                  _("Unable to start TLS."));
 723                 /**
 724                  * Bug: stream_socket_enable_crypto() does not register SSL errors in
 725                  * openssl_error_string() or stream notification wrapper and displays
 726                  * them in E_WARNING level message. It is impossible to retrieve error
 727                  * message without own error handler.
 728                  */
 729                 exit;
 730             }
 731         } else {
 732             // php install does not support stream_socket_enable_crypto() function
 733             sqimap_error_box(sprintf(_("Error connecting to IMAP server: %s."), $server),
 734                              '','',
 735                              _("IMAP STARTTLS is enabled in SquirrelMail configuration, but used PHP version does not support functions that allow to enable encryption on open socket."));
 736             exit;
 737         }
 738     }
 739     return $imap_stream;
 740 }
 741
 742 /**
 743  * Logs the user into the IMAP server.  If $hide is set, no error messages
 744  * will be displayed.  This function returns the IMAP connection handle.
 745  * @param string $username user name
 746  * @param string $password password encrypted with onetimepad. Since 1.5.2
 747  *  function can use internal password functions, if parameter is set to
 748  *  boolean false.
 749  * @param string $imap_server_address address of imap server
 750  * @param integer $imap_port port of imap server
 751  * @param boolean $hide controls display connection errors
 752  * @return stream
 753  */
 754 function sqimap_login ($username, $password, $imap_server_address, $imap_port, $hide) {
 755     global $color, $squirrelmail_language, $onetimepad, $use_imap_tls,
 756            $imap_auth_mech, $sqimap_capabilities;
 757
 758     /* get imap login password */
 759     if ($password===false) {
 760         /* standard functions */
 761         $password = sqauth_read_password();
 762     } else {
 763         /* old way. $key must be extracted from cookie */
 764         if (!isset($onetimepad) || empty($onetimepad)) {
 765             sqgetglobalvar('onetimepad' , $onetimepad , SQ_SESSION );
 766         }
 767         /* Decrypt the password */
 768         $password = OneTimePadDecrypt($password, $onetimepad);
 769     }
 770
 771     if (!isset($sqimap_capabilities)) {
 772         sqgetglobalvar('sqimap_capabilities' , $capability , SQ_SESSION );
 773     }
 774
 775     $host = $imap_server_address;
 776     $imap_server_address = sqimap_get_user_server($imap_server_address, $username);
 777
 778     $imap_stream = sqimap_create_stream($imap_server_address,$imap_port,$use_imap_tls);
 779
 780     if (($imap_auth_mech == 'cram-md5') OR ($imap_auth_mech == 'digest-md5')) {
 781         // We're using some sort of authentication OTHER than plain or login
 782         $tag=sqimap_session_id(false);
 783         if ($imap_auth_mech == 'digest-md5') {
 784             $query = $tag . " AUTHENTICATE DIGEST-MD5\r\n";
 785         } elseif ($imap_auth_mech == 'cram-md5') {
 786             $query = $tag . " AUTHENTICATE CRAM-MD5\r\n";
 787         }
 788         fputs($imap_stream,$query);
 789         $answer=sqimap_fgets($imap_stream);
 790         // Trim the "+ " off the front
 791         $response=explode(" ",$answer,3);
 792         if ($response[0] == '+') {
 793             // Got a challenge back
 794             $challenge=$response[1];
 795             if ($imap_auth_mech == 'digest-md5') {
 796                 $reply = digest_md5_response($username,$password,$challenge,'imap',$host);
 797             } elseif ($imap_auth_mech == 'cram-md5') {
 798                 $reply = cram_md5_response($username,$password,$challenge);
 799             }
 800             fputs($imap_stream,$reply);
 801             $read=sqimap_fgets($imap_stream);
 802             if ($imap_auth_mech == 'digest-md5') {
 803                 // DIGEST-MD5 has an extra step..
 804                 if (substr($read,0,1) == '+') { // OK so far..
 805                     fputs($imap_stream,"\r\n");
 806                     $read=sqimap_fgets($imap_stream);
 807                 }
 808             }
 809             $results=explode(" ",$read,3);
 810             $response=$results[1];
 811             $message=$results[2];
 812         } else {
 813             // Fake the response, so the error trap at the bottom will work
 814             $response="BAD";
 815             $message='IMAP server does not appear to support the authentication method selected.';
 816             $message .= '  Please contact your system administrator.';
 817         }
 818     } elseif ($imap_auth_mech == 'login') {
 819     // Original IMAP login code
 820         $query = 'LOGIN "' . quoteimap($username) .  '" "' . quoteimap($password) . '"';
 821         $read = sqimap_run_command ($imap_stream, $query, false, $response, $message);
 822     } elseif ($imap_auth_mech == 'plain') {
 823         /***
 824          * SASL PLAIN
 825          *
 826          *  RFC 2595 Chapter 6
 827          *
 828          *  The mechanism consists of a single message from the client to the
 829          *  server.  The client sends the authorization identity (identity to
 830          *  login as), followed by a US-ASCII NUL character, followed by the
 831          *  authentication identity (identity whose password will be used),
 832          *  followed by a US-ASCII NUL character, followed by the clear-text
 833          *  password.  The client may leave the authorization identity empty to
 834          *  indicate that it is the same as the authentication identity.
 835          *
 836          **/
 837         $tag=sqimap_session_id(false);
 838         $sasl = (isset($capability['SASL-IR']) && $capability['SASL-IR']) ? true : false;
 839         $auth = base64_encode("$username\0$username\0$password");
 840         if ($sasl) {
 841             // IMAP Extension for SASL Initial Client Response
 842             // <draft-siemborski-imap-sasl-initial-response-01b.txt>
 843             $query = $tag . " AUTHENTICATE PLAIN $auth\r\n";
 844             fputs($imap_stream, $query);
 845             $read = sqimap_fgets($imap_stream);
 846         } else {
 847             $query = $tag . " AUTHENTICATE PLAIN\r\n";
 848             fputs($imap_stream, $query);
 849             $read=sqimap_fgets($imap_stream);
 850             if (substr($read,0,1) == '+') { // OK so far..
 851                 fputs($imap_stream, "$auth\r\n");
 852                 $read = sqimap_fgets($imap_stream);
 853             }
 854         }
 855         $results=explode(" ",$read,3);
 856         $response=$results[1];
 857         $message=$results[2];
 858     } else {
 859         $response="BAD";
 860         $message="Internal SquirrelMail error - unknown IMAP authentication method chosen.  Please contact the developers.";
 861     }
 862
 863     /* If the connection was not successful, lets see why */
 864     if ($response != 'OK') {
 865         if (!$hide) {
 866             if ($response != 'NO') {
 867                 /* "BAD" and anything else gets reported here. */
 868                 $message = htmlspecialchars($message);
 869                 set_up_language($squirrelmail_language, true);
 870                 if ($response == 'BAD') {
 871                     $string = sprintf (_("Bad request: %s")."<br />\r\n", $message);
 872                 } else {
 873                     $string = sprintf (_("Unknown error: %s") . "<br />\n", $message);
 874                 }
 875                 if (isset($read) && is_array($read)) {
 876                     $string .= '<br />' . _("Read data:") . "<br />\n";
 877                     foreach ($read as $line) {
 878                         $string .= htmlspecialchars($line) . "<br />\n";
 879                     }
 880                 }
 881                 error_box($string);
 882                 exit;
 883             } else {
 884                 /*
 885                  * If the user does not log in with the correct
 886                  * username and password it is not possible to get the
 887                  * correct locale from the user's preferences.
 888                  * Therefore, apply the same hack as on the login
 889                  * screen.
 890                  *
 891                  * $squirrelmail_language is set by a cookie when
 892                  * the user selects language and logs out
 893                  */
 894
 895                 set_up_language($squirrelmail_language, true);
 896                 sqsession_destroy();
 897                 sqsetcookieflush();
 898                 /* terminate the session nicely */
 899                 sqimap_logout($imap_stream);
 900                 logout_error( _("Unknown user or password incorrect.") );
 901                 exit;
 902             }
 903         } else {
 904             exit;
 905         }
 906     }
 907
 908     /* Special error case:
 909      * Login referrals. The server returns:
 910      * ? OK [REFERRAL <imap url>]
 911      * Check RFC 2221 for details. Since we do not support login referrals yet
 912      * we log the user out.
 913      */
 914     if ( stristr($message, 'REFERRAL imap') === TRUE ) {
 915         sqimap_logout($imap_stream);
 916         set_up_language($squirrelmail_language, true);
 917         sqsession_destroy();
 918         logout_error( _("Your mailbox is not located at this server. Try a different server or consult your system administrator") );
 919         exit;
 920     }
 921
 922     return $imap_stream;
 923 }
 924
 925 /**
 926  * Simply logs out the IMAP session
 927  * @param stream $imap_stream the IMAP connection to log out.
 928  * @return void
 929  */
 930 function sqimap_logout ($imap_stream) {
 931     /* Logout is not valid until the server returns 'BYE'
 932      * If we don't have an imap_ stream we're already logged out */
 933     if(isset($imap_stream) && $imap_stream)
 934         sqimap_run_command($imap_stream, 'LOGOUT', false, $response, $message);
 935 }
 936
 937 /**
 938  * Retrieve the CAPABILITY string from the IMAP server.
 939  * If capability is set, returns only that specific capability,
 940  * else returns array of all capabilities.
 941  * @param stream $imap_stream
 942  * @param string $capability (since 1.3.0)
 943  * @param boolean $bUseCache (since 1.5.1) Controls use of capability data stored in session
 944  * @return mixed (string if $capability is set and found,
 945  *  false, if $capability is set and not found,
 946  *  array if $capability not set)
 947  */
 948 function sqimap_capability($imap_stream, $capability='', $bUseCache=true) {
 949     // sqgetGlobalVar('sqimap_capabilities', $sqimap_capabilities, SQ_SESSION);
 950
 951     if (!$bUseCache || ! sqgetGlobalVar('sqimap_capabilities', $sqimap_capabilities, SQ_SESSION)) {
 952         $read = sqimap_run_command($imap_stream, 'CAPABILITY', true, $a, $b);
 953         $c = explode(' ', $read[0]);
 954         for ($i=2; $i < count($c); $i++) {
 955             $cap_list = explode('=', $c[$i]);
 956             if (isset($cap_list[1])) {
 957                 if(isset($sqimap_capabilities[trim($cap_list[0])]) &&
 958                  !is_array($sqimap_capabilities[trim($cap_list[0])])) {
 959                     // Remove array key that was added in 'else' block below
 960                     // This is to accomodate for capabilities like:
 961                     // SORT SORT=MODSEQ
 962                     unset($sqimap_capabilities[trim($cap_list[0])]);
 963                 }
 964                 $sqimap_capabilities[trim($cap_list[0])][] = $cap_list[1];
 965             } else {
 966                 if(!isset($sqimap_capabilities[trim($cap_list[0])])) {
 967                     $sqimap_capabilities[trim($cap_list[0])] = TRUE;
 968                 }
 969             }
 970         }
 971     }
 972     if ($capability) {
 973         if (isset($sqimap_capabilities[$capability])) {
 974                 return $sqimap_capabilities[$capability];
 975         } else {
 976                 return false;
 977         }
 978     }
 979     return $sqimap_capabilities;
 980 }
 981
 982 /**
 983  * Returns the delimiter between mailboxes: INBOX/Test, or INBOX.Test
 984  * @param stream $imap_stream
 985  * @return string
 986  */
 987 function sqimap_get_delimiter ($imap_stream = false) {
 988     global $sqimap_delimiter, $optional_delimiter;
 989
 990     /* Use configured delimiter if set */
 991     if((!empty($optional_delimiter)) && $optional_delimiter != 'detect') {
 992         return $optional_delimiter;
 993     }
 994
 995     /* Delimiter is stored in the session from redirect.  Try fetching from there first */
 996     if (empty($sqimap_delimiter)) {
 997         sqgetGlobalVar('delimiter',$sqimap_delimiter,SQ_SESSION);
 998     }
 999
1000     /* Do some caching here */
1001     if (!$sqimap_delimiter) {
1002         if (sqimap_capability($imap_stream, 'NAMESPACE')) {
1003             /*
1004              * According to something that I can't find, this is supposed to work on all systems
1005              * OS: This won't work in Courier IMAP.
1006              * OS: According to rfc2342 response from NAMESPACE command is:
1007              * OS: * NAMESPACE (PERSONAL NAMESPACES) (OTHER_USERS NAMESPACE) (SHARED NAMESPACES)
1008              * OS: We want to lookup all personal NAMESPACES...
1009              */
1010             $read = sqimap_run_command($imap_stream, 'NAMESPACE', true, $a, $b);
1011             if (eregi('\\* NAMESPACE +(\\( *\\(.+\\) *\\)|NIL) +(\\( *\\(.+\\) *\\)|NIL) +(\\( *\\(.+\\) *\\)|NIL)', $read[0], $data)) {
1012                 if (eregi('^\\( *\\((.*)\\) *\\)', $data[1], $data2)) {
1013                     $pn = $data2[1];
1014                 }
1015                 $pna = explode(')(', $pn);
1016                 while (list($k, $v) = each($pna)) {
1017                     $lst = explode('"', $v);
1018                     if (isset($lst[3])) {
1019                         $pn[$lst[1]] = $lst[3];
1020                     } else {
1021                         $pn[$lst[1]] = '';
1022                     }
1023                 }
1024             }
1025             $sqimap_delimiter = $pn[0];
1026         } else {
1027             fputs ($imap_stream, ". LIST \"INBOX\" \"\"\r\n");
1028             $read = sqimap_read_data($imap_stream, '.', true, $a, $b);
1029             $read = $read['.'][0];    //sqimap_read_data() now returns a tag array of response array
1030             $quote_position = strpos ($read[0], '"');
1031             $sqimap_delimiter = substr ($read[0], $quote_position+1, 1);
1032         }
1033     }
1034     return $sqimap_delimiter;
1035 }
1036
1037 /**
1038  * This encodes a mailbox name for use in IMAP commands.
1039  * @param string $what the mailbox to encode
1040  * @return string the encoded mailbox string
1041  * @since 1.5.0
1042  */
1043 function sqimap_encode_mailbox_name($what)
1044 {
1045     if (ereg("[\"\\\r\n]", $what))
1046         return '{' . strlen($what) . "}\r\n" . $what;        /* 4.3 literal form */
1047     return '"' . $what . '"';        /* 4.3 quoted string form */
1048 }
1049
1050 /**
1051  * Gets the number of messages in the current mailbox.
1052  *
1053  * OBSOLETE use sqimap_status_messages instead.
1054  * @param stream $imap_stream imap stream
1055  * @param string $mailbox
1056  * @deprecated
1057  */
1058 function sqimap_get_num_messages ($imap_stream, $mailbox) {
1059     $aStatus = sqimap_status_messages($imap_stream,$mailbox,array('MESSAGES'));
1060     return $aStatus['MESSAGES'];
1061 }
1062
1063 /**
1064  * OBSOLETE FUNCTION should be removed after mailbox_display,
1065  * printMessage function is adapted
1066  * $addr_ar = array(), $group = '' and $host='' arguments are used in 1.4.0
1067  * @param string $address
1068  * @param integer $max
1069  * @since 1.4.0
1070  * @deprecated See Rfc822Address.php
1071  */
1072 function parseAddress($address, $max=0) {
1073     $aAddress = parseRFC822Address($address,array('limit'=> $max));
1074     /*
1075      * Because the expected format of the array element is changed we adapt it now.
1076      * This also implies that this function is obsolete and should be removed after the
1077      * rest of the source is adapted. See Rfc822Address.php for the new function.
1078      */
1079      array_walk($aAddress, '_adaptAddress');
1080      return $aAddress;
1081 }
1082
1083 /**
1084  * OBSOLETE FUNCTION should be removed after mailbox_display,
1085  * printMessage function is adapted
1086  *
1087  * callback function used for formating of addresses array in
1088  * parseAddress() function
1089  * @param array $aAddr
1090  * @param integer $k array key
1091  * @since 1.5.1
1092  * @deprecated
1093  */
1094 function _adaptAddress(&$aAddr,$k) {
1095    $sPersonal = (isset($aAddr[SQM_ADDR_PERSONAL]) && $aAddr[SQM_ADDR_PERSONAL]) ?
1096        $aAddr[SQM_ADDR_PERSONAL] : '';
1097    $sEmail = ($aAddr[SQM_ADDR_HOST]) ?
1098        $aAddr[SQM_ADDR_MAILBOX] . '@'.$aAddr[SQM_ADDR_HOST] :
1099        $aAddr[SQM_ADDR_MAILBOX];
1100    $aAddr = array($sEmail,$sPersonal);
1101 }
1102
1103 /**
1104  * Returns the number of unseen messages in this folder.
1105  * obsoleted by sqimap_status_messages !
1106  * Arguments differ in 1.0.x
1107  * @param stream $imap_stream
1108  * @param string $mailbox
1109  * @return integer
1110  * @deprecated
1111  */
1112 function sqimap_unseen_messages ($imap_stream, $mailbox) {
1113     $aStatus = sqimap_status_messages($imap_stream,$mailbox,array('UNSEEN'));
1114     return $aStatus['UNSEEN'];
1115 }
1116
1117 /**
1118  * Returns the status items of a mailbox.
1119  * Default it returns MESSAGES,UNSEEN and RECENT
1120  * Supported status items are MESSAGES, UNSEEN, RECENT (since 1.4.0),
1121  * UIDNEXT (since 1.5.1) and UIDVALIDITY (since 1.5.1)
1122  * @param stream $imap_stream imap stream
1123  * @param string $mailbox mail folder
1124  * @param array $aStatusItems status items
1125  * @return array
1126  * @since 1.3.2
1127  */
1128 function sqimap_status_messages ($imap_stream, $mailbox,
1129                        $aStatusItems = array('MESSAGES','UNSEEN','RECENT')) {
1130
1131     $aStatusItems = implode(' ',$aStatusItems);
1132     $read_ary = sqimap_run_command ($imap_stream, 'STATUS ' . sqimap_encode_mailbox_name($mailbox) .
1133                                     " ($aStatusItems)", false, $result, $message);
1134     $i = 0;
1135     $messages = $unseen = $recent = $uidnext = $uidvalidity = false;
1136     $regs = array(false,false);
1137     while (isset($read_ary[$i])) {
1138         if (preg_match('/UNSEEN\s+([0-9]+)/i', $read_ary[$i], $regs)) {
1139             $unseen = $regs[1];
1140         }
1141         if (preg_match('/MESSAGES\s+([0-9]+)/i', $read_ary[$i], $regs)) {
1142             $messages = $regs[1];
1143         }
1144         if (preg_match('/RECENT\s+([0-9]+)/i', $read_ary[$i], $regs)) {
1145             $recent = $regs[1];
1146         }
1147         if (preg_match('/UIDNEXT\s+([0-9]+)/i', $read_ary[$i], $regs)) {
1148             $uidnext = $regs[1];
1149         }
1150         if (preg_match('/UIDVALIDITY\s+([0-9]+)/i', $read_ary[$i], $regs)) {
1151             $uidvalidity = $regs[1];
1152         }
1153         $i++;
1154     }
1155
1156     $status=array('MESSAGES' => $messages,
1157                  'UNSEEN'=>$unseen,
1158                  'RECENT' => $recent,
1159                  'UIDNEXT' => $uidnext,
1160                  'UIDVALIDITY' => $uidvalidity);
1161
1162     if (!empty($messages)) { $hook_status['MESSAGES']=$messages; }
1163     if (!empty($unseen)) { $hook_status['UNSEEN']=$unseen; }
1164     if (!empty($recent)) { $hook_status['RECENT']=$recent; }
1165     if (!empty($hook_status)) {
1166          $hook_status['MAILBOX']=$mailbox;
1167          $hook_status['CALLER']='sqimap_status_messages';
1168          do_hook_function('folder_status',$hook_status);
1169     }
1170     return $status;
1171 }
1172
1173
1174 /**
1175  * Saves a message to a given folder -- used for saving sent messages
1176  * @param stream $imap_stream
1177  * @param string $sent_folder
1178  * @param $length
1179  * @return string $sid
1180  */
1181 function sqimap_append ($imap_stream, $sMailbox, $length) {
1182     $sid = sqimap_session_id();
1183     $query = $sid . ' APPEND ' . sqimap_encode_mailbox_name($sMailbox) . " (\\Seen) {".$length."}";
1184     fputs ($imap_stream, "$query\r\n");
1185     $tmp = fgets ($imap_stream, 1024);
1186     sqimap_append_checkresponse($tmp, $sMailbox,$sid, $query);
1187     return $sid;
1188 }
1189
1190 /**
1191  * @param stream imap_stream
1192  * @param string $folder (since 1.3.2)
1193  */
1194 function sqimap_append_done ($imap_stream, $sMailbox='') {
1195     fputs ($imap_stream, "\r\n");
1196     $tmp = fgets ($imap_stream, 1024);
1197     while (!sqimap_append_checkresponse($tmp, $sMailbox)) {
1198         $tmp = fgets ($imap_stream, 1024);
1199     }
1200 }
1201
1202 /**
1203  * Displays error messages, if there are errors in responses to
1204  * commands issues by sqimap_append() and sqimap_append_done() functions.
1205  * @param string $response
1206  * @param string $sMailbox
1207  * @return bool $bDone
1208  * @since 1.5.1 and 1.4.5
1209  */
1210 function sqimap_append_checkresponse($response, $sMailbox, $sid='', $query='') {
1211     // static vars to keep them available when sqimap_append_done calls this function.
1212     static $imapquery, $imapsid;
1213
1214     $bDone = false;
1215
1216     if ($query) {
1217         $imapquery = $query;
1218     }
1219     if ($sid) {
1220         $imapsid = $sid;
1221     }
1222     if ($response{0} == '+') {
1223         // continuation request triggerd by sqimap_append()
1224         $bDone = true;
1225     } else {
1226         $i = strpos($response, ' ');
1227         $sRsp = substr($response,0,$i);
1228         $sMsg = substr($response,$i+1);
1229         $aExtra = array('MAILBOX' => $sMailbox);
1230         switch ($sRsp) {
1231             case '*': //untagged response
1232                 $i = strpos($sMsg, ' ');
1233                 $sRsp = strtoupper(substr($sMsg,0,$i));
1234                 $sMsg = substr($sMsg,$i+1);
1235                 if ($sRsp == 'NO' || $sRsp == 'BAD') {
1236                     // for the moment disabled. Enable after 1.5.1 release.
1237                     // Notices could give valueable information about the mailbox
1238                     // sqm_trigger_imap_error('SQM_IMAP_APPEND_NOTICE',$imapquery,$sRsp,$sMsg);
1239                 }
1240                 $bDone = false;
1241             case $imapsid:
1242                 // A001 OK message
1243                 // $imapsid<space>$sRsp<space>$sMsg
1244                 $bDone = true;
1245                 $i = strpos($sMsg, ' ');
1246                 $sRsp = strtoupper(substr($sMsg,0,$i));
1247                 $sMsg = substr($sMsg,$i+1);
1248                 switch ($sRsp) {
1249                     case 'NO':
1250                         if (preg_match("/(.*)(quota)(.*)$/i", $sMsg, $aMatch)) {
1251                             sqm_trigger_imap_error('SQM_IMAP_APPEND_QUOTA_ERROR',$imapquery,$sRsp,$sMsg,$aExtra);
1252                         } else {
1253                             sqm_trigger_imap_error('SQM_IMAP_APPEND_ERROR',$imapquery,$sRsp,$sMsg,$aExtra);
1254                         }
1255                         break;
1256                     case 'BAD':
1257                         sqm_trigger_imap_error('SQM_IMAP_ERROR',$imapquery,$sRsp,$sMsg,$aExtra);
1258                         break;
1259                     case 'BYE':
1260                         sqm_trigger_imap_error('SQM_IMAP_BYE',$imapquery,$sRsp,$sMsg,$aExtra);
1261                         break;
1262                     case 'OK':
1263                         break;
1264                     default:
1265                         break;
1266                 }
1267                 break;
1268             default:
1269                 // should be false because of the unexpected response but i'm not sure if
1270                 // that will cause an endless loop in sqimap_append_done
1271                 $bDone = true;
1272         }
1273     }
1274     return $bDone;
1275 }
1276
1277 /**
1278  * Allows mapping of IMAP server address with custom function
1279  * see map_yp_alias()
1280  * @param string $imap_server imap server address or mapping
1281  * @param string $username
1282  * @return string
1283  * @since 1.3.0
1284  */
1285 function sqimap_get_user_server ($imap_server, $username) {
1286    if (substr($imap_server, 0, 4) != "map:") {
1287        return $imap_server;
1288    }
1289    $function = substr($imap_server, 4);
1290    return $function($username);
1291 }
1292
1293 /**
1294  * This is an example that gets IMAP servers from yellowpages (NIS).
1295  * you can simple put map:map_yp_alias in your $imap_server_address
1296  * in config.php use your own function instead map_yp_alias to map your
1297  * LDAP whatever way to find the users IMAP server.
1298  *
1299  * Requires access to external ypmatch program
1300  * FIXME: it can be implemented in php yp extension or pecl (since php 5.1.0)
1301  * @param string $username
1302  * @return string
1303  * @since 1.3.0
1304  */
1305 function map_yp_alias($username) {
1306    $yp = `ypmatch $username aliases`;
1307    return chop(substr($yp, strlen($username)+1));
1308 }