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