Source for file imap_general.php

Documentation is available at 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: imap_general.php,v 1.237 2006/10/04 19:25:25 stekkel Exp $
  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.                         // check for numeric value to avoid that untagged responses like:
  520.                         // * OK [PARSE] Unexpected characters at end of address: {SET:debug=51}
  521.                         // will trigger literal fetching  ({SET:debug=51} !== int )
  522.                         if (is_numeric($iLit)) {
  523.                             $data[] = $read;
  524.                             $sLiteral = fread($imap_stream,$iLit);
  525.                             if ($sLiteral === false) { /* error */
  526.                                 $read = false;
  527.                                 break 3; /* while switch while */
  528.                             }
  529.                             $data[] = $sLiteral;
  530.                             $data[] = sqimap_fgets($imap_stream);
  531.                         } else {
  532.                             $data[] = $read;
  533.                         }
  534.                     } else {
  535.                          $data[] = $read;
  536.                     }
  537.                     $read = sqimap_fgets($imap_stream);
  538.                     if ($read === false) {
  539.                         break 3; /* while switch while */
  540.                     } else if ($read{0} == '*') {
  541.                         break;
  542.                     }
  543.                     $s = substr($read,-3);
  544.                 } while ($s === "}\r\n");
  545.                 break 1;
  546.             }
  547.             break;
  548.           } // end case '*'
  549.         }   // end switch
  550.     } // end while
  551.  
  552.     /* error processing in case $read is false */
  553.     if ($read === false) {
  554.         // try to retrieve an untagged bye respons from the results
  555.         $sResponse = array_pop($data);
  556.         if ($sResponse !== NULL && strpos($sResponse,'* BYE') !== false) {
  557.             if (!$handle_errors) {
  558.                 $query = '';
  559.             }
  560.             sqimap_error_box(_("ERROR: IMAP server closed the connection."), $query, _("Server responded:"),$sResponse);
  561.             echo '</body></html>';
  562.             exit;
  563.         } else if ($handle_errors) {
  564.             unset($data);
  565.             sqimap_error_box(_("ERROR: Connection dropped by IMAP server."), $query);
  566.             exit;
  567.         }
  568.     }
  569.  
  570.     /* Set $resultlist array */
  571.     if (!empty($data)) {
  572.         //$resultlist[] = $data;
  573.     }
  574.     elseif (empty($resultlist)) {
  575.         $resultlist[] = array();
  576.     }
  577.  
  578.     /* Return result or handle errors */
  579.     if ($handle_errors == false) {
  580.         return $aResponse;
  581.     }
  582.     switch ($response[$tag]) {
  583.     case 'OK':
  584.         return $aResponse;
  585.         break;
  586.     case 'NO':
  587.         /* ignore this error from M$ exchange, it is not fatal (aka bug) */
  588.         if (strstr($message[$tag], 'command resulted in') === false) {
  589.             sqimap_error_box(_("ERROR: Could not complete request."), $query, _("Reason Given:") . ' ', $message[$tag]);
  590.             echo '</body></html>';
  591.             exit;
  592.         }
  593.         break;
  594.     case 'BAD':
  595.         sqimap_error_box(_("ERROR: Bad or malformed request."), $query, _("Server responded:") . ' ', $message[$tag]);
  596.         echo '</body></html>';
  597.         exit;
  598.     case 'BYE':
  599.         sqimap_error_box(_("ERROR: IMAP server closed the connection."), $query, _("Server responded:") . ' ', $message[$tag]);
  600.         echo '</body></html>';
  601.         exit;
  602.     default:
  603.         sqimap_error_box(_("ERROR: Unknown IMAP response."), $query, _("Server responded:") . ' ', $message[$tag]);
  604.        /* the error is displayed but because we don't know the reponse we
  605.           return the result anyway */
  606.        return $aResponse;
  607.        break;
  608.     }
  609. }
  610.  
  611. /**
  612.  * @param stream $imap_stream imap string
  613.  * @param string $tag_uid 
  614.  * @param boolean $handle_errors 
  615.  * @param array $response 
  616.  * @param array $message 
  617.  * @param string $query (since 1.2.5)
  618.  * @param boolean $filter (since 1.4.1) see sqimap_fread()
  619.  * @param mixed $outputstream (since 1.4.1) see sqimap_fread()
  620.  * @param boolean $no_return (since 1.4.1) see sqimap_fread()
  621.  */
  622. function sqimap_read_data ($imap_stream, $tag_uid, $handle_errors,
  623.                            &$response, &$message, $query = '',
  624.                            $filter=false,$outputstream=false,$no_return=false) {
  625.  
  626.     $tag_uid_a = explode(' ',trim($tag_uid));
  627.     $tag = $tag_uid_a[0];
  628.  
  629.     $res = sqimap_retrieve_imap_response($imap_stream, $tag, $handle_errors,
  630.               $response, $message, $query,$filter,$outputstream,$no_return);
  631.     return $res;
  632. }
  633.  
  634. /**
  635.  * Connects to the IMAP server and returns a resource identifier for use with
  636.  * the other SquirrelMail IMAP functions. Does NOT login!
  637.  * @param string server hostname of IMAP server
  638.  * @param int port port number to connect to
  639.  * @param integer $tls whether to use plain text(0), TLS(1) or STARTTLS(2) when connecting.
  640.  *   Argument was boolean before 1.5.1.
  641.  * @return imap-stream resource identifier
  642.  * @since 1.5.0 (usable only in 1.5.1 or later)
  643.  */
  644. function sqimap_create_stream($server,$port,$tls=0) {
  645.     global $squirrelmail_language;
  646.  
  647.     if (strstr($server,':') && ! preg_match("/^\[.*\]$/",$server)) {
  648.         // numerical IPv6 address must be enclosed in square brackets
  649.         $server = '['.$server.']';
  650.     }
  651.  
  652.     if ($tls == 1) {
  653.         if ((check_php_version(4,3)) and (extension_loaded('openssl'))) {
  654.             /* Use TLS by prefixing "tls://" to the hostname */
  655.             $server = 'tls://' . $server;
  656.         } else {
  657.             require_once(SM_PATH . 'functions/display_messages.php');
  658.             logout_error( sprintf(_("Error connecting to IMAP server: %s."), $server).
  659.                 '<br />'.
  660.                 _("TLS is enabled, but this version of PHP does not support TLS sockets, or is missing the openssl extension.").
  661.                 '<br /><br />'.
  662.                 _("Please contact your system administrator and report this error."),
  663.                           sprintf(_("Error connecting to IMAP server: %s."), $server));
  664.         }
  665.     }
  666.  
  667.     $imap_stream = @fsockopen($server, $port, $error_number, $error_string, 15);
  668.  
  669.     /* Do some error correction */
  670.     if (!$imap_stream) {
  671.         set_up_language($squirrelmail_language, true);
  672.         require_once(SM_PATH . 'functions/display_messages.php');
  673.         logout_error( sprintf(_("Error connecting to IMAP server: %s."), $server).
  674.             "<br />\r\n$error_number : $error_string<br />\r\n",
  675.                       sprintf(_("Error connecting to IMAP server: %s."), $server) );
  676.         exit;
  677.     }
  678.     $server_info = fgets ($imap_stream, 1024);
  679.  
  680.     /**
  681.      * Implementing IMAP STARTTLS (rfc2595) in php 5.1.0+
  682.      * http://www.php.net/stream-socket-enable-crypto
  683.      */
  684.     if ($tls === 2) {
  685.         if (function_exists('stream_socket_enable_crypto')) {
  686.             // check starttls capability, don't use cached capability version
  687.             if (! sqimap_capability($imap_stream, 'STARTTLS', false)) {
  688.                 // imap server does not declare starttls support
  689.                 sqimap_error_box(sprintf(_("Error connecting to IMAP server: %s."), $server),
  690.                                  '','',
  691.                                  _("IMAP STARTTLS is enabled in SquirrelMail configuration, but used IMAP server does not support STARTTLS."));
  692.                 exit;
  693.             }
  694.  
  695.             // issue starttls command and check response
  696.             sqimap_run_command($imap_stream, 'STARTTLS', false, $starttls_response, $starttls_message);
  697.             // check response
  698.             if ($starttls_response!='OK') {
  699.                 // starttls command failed
  700.                 sqimap_error_box(sprintf(_("Error connecting to IMAP server: %s."), $server),
  701.                                  'STARTTLS',
  702.                                  _("Server replied:") . ' ',
  703.                                  $starttls_message);
  704.                 exit();
  705.             }
  706.  
  707.             // start crypto on connection. suppress function errors.
  708.             if (@stream_socket_enable_crypto($imap_stream,true,STREAM_CRYPTO_METHOD_TLS_CLIENT)) {
  709.                 // starttls was successful
  710.  
  711.                 /**
  712.                  * RFC 2595 requires to discard CAPABILITY information after successful
  713.                  * STARTTLS command. We don't follow RFC, because SquirrelMail stores CAPABILITY
  714.                  * information only after successful login (src/redirect.php) and cached information
  715.                  * is used only in other php script connections after successful STARTTLS. If script
  716.                  * issues sqimap_capability() call before sqimap_login() and wants to get initial
  717.                  * capability response, script should set third sqimap_capability() argument to false.
  718.                  */
  719.                 //sqsession_unregister('sqimap_capabilities');
  720.             } else {
  721.                 /**
  722.                  * stream_socket_enable_crypto() call failed. Possible issues:
  723.                  * - broken ssl certificate (uw drops connection, error is in syslog mail facility)
  724.                  * - some ssl error (can reproduce with STREAM_CRYPTO_METHOD_SSLv3_CLIENT, PHP E_WARNING
  725.                  *   suppressed in stream_socket_enable_crypto() call)
  726.                  */
  727.                 sqimap_error_box(sprintf(_("Error connecting to IMAP server: %s."), $server),
  728.                                  '','',
  729.                                  _("Unable to start TLS."));
  730.                 /**
  731.                  * Bug: stream_socket_enable_crypto() does not register SSL errors in
  732.                  * openssl_error_string() or stream notification wrapper and displays
  733.                  * them in E_WARNING level message. It is impossible to retrieve error
  734.                  * message without own error handler.
  735.                  */
  736.                 exit;
  737.             }
  738.         } else {
  739.             // php install does not support stream_socket_enable_crypto() function
  740.             sqimap_error_box(sprintf(_("Error connecting to IMAP server: %s."), $server),
  741.                              '','',
  742.                              _("IMAP STARTTLS is enabled in SquirrelMail configuration, but used PHP version does not support functions that allow to enable encryption on open socket."));
  743.             exit;
  744.         }
  745.     }
  746.     return $imap_stream;
  747. }
  748.  
  749. /**
  750.  * Logs the user into the IMAP server.  If $hide is set, no error messages
  751.  * will be displayed.  This function returns the IMAP connection handle.
  752.  * @param string $username user name
  753.  * @param string $password password encrypted with onetimepad. Since 1.5.2
  754.  *   function can use internal password functions, if parameter is set to
  755.  *   boolean false.
  756.  * @param string $imap_server_address address of imap server
  757.  * @param integer $imap_port port of imap server
  758.  * @param boolean $hide controls display connection errors
  759.  * @return stream 
  760.  */
  761. function sqimap_login ($username, $password, $imap_server_address, $imap_port, $hide) {
  762.     global $color, $squirrelmail_language, $onetimepad, $use_imap_tls,
  763.            $imap_auth_mech, $sqimap_capabilities;
  764.  
  765.     /* get imap login password */
  766.     if ($password===false) {
  767.         /* standard functions */
  768.         $password = sqauth_read_password();
  769.     } else {
  770.         /* old way. $key must be extracted from cookie */
  771.         if (!isset($onetimepad) || empty($onetimepad)) {
  772.             sqgetglobalvar('onetimepad' , $onetimepad , SQ_SESSION );
  773.         }
  774.         /* Decrypt the password */
  775.         $password = OneTimePadDecrypt($password, $onetimepad);
  776.     }
  777.  
  778.     if (!isset($sqimap_capabilities)) {
  779.         sqgetglobalvar('sqimap_capabilities' , $sqimap_capabilities , SQ_SESSION );
  780.     }
  781.  
  782.     $host = $imap_server_address;
  783.     $imap_server_address = sqimap_get_user_server($imap_server_address, $username);
  784.  
  785.     $imap_stream = sqimap_create_stream($imap_server_address,$imap_port,$use_imap_tls);
  786.  
  787.     if (($imap_auth_mech == 'cram-md5') OR ($imap_auth_mech == 'digest-md5')) {
  788.         // We're using some sort of authentication OTHER than plain or login
  789.         $tag=sqimap_session_id(false);
  790.         if ($imap_auth_mech == 'digest-md5') {
  791.             $query = $tag . " AUTHENTICATE DIGEST-MD5\r\n";
  792.         } elseif ($imap_auth_mech == 'cram-md5') {
  793.             $query = $tag . " AUTHENTICATE CRAM-MD5\r\n";
  794.         }
  795.         fputs($imap_stream,$query);
  796.         $answer=sqimap_fgets($imap_stream);
  797.         // Trim the "+ " off the front
  798.         $response=explode(" ",$answer,3);
  799.         if ($response[0] == '+') {
  800.             // Got a challenge back
  801.             $challenge=$response[1];
  802.             if ($imap_auth_mech == 'digest-md5') {
  803.                 $reply = digest_md5_response($username,$password,$challenge,'imap',$host);
  804.             } elseif ($imap_auth_mech == 'cram-md5') {
  805.                 $reply = cram_md5_response($username,$password,$challenge);
  806.             }
  807.             fputs($imap_stream,$reply);
  808.             $read=sqimap_fgets($imap_stream);
  809.             if ($imap_auth_mech == 'digest-md5') {
  810.                 // DIGEST-MD5 has an extra step..
  811.                 if (substr($read,0,1) == '+') { // OK so far..
  812.                     fputs($imap_stream,"\r\n");
  813.                     $read=sqimap_fgets($imap_stream);
  814.                 }
  815.             }
  816.             $results=explode(" ",$read,3);
  817.             $response=$results[1];
  818.             $message=$results[2];
  819.         } else {
  820.             // Fake the response, so the error trap at the bottom will work
  821.             $response="BAD";
  822.             $message='IMAP server does not appear to support the authentication method selected.';
  823.             $message .= '  Please contact your system administrator.';
  824.         }
  825.     } elseif ($imap_auth_mech == 'login') {
  826.     // Original IMAP login code
  827.         $query = 'LOGIN "' . quoteimap($username) .  '" "' . quoteimap($password) . '"';
  828.         $read = sqimap_run_command ($imap_stream, $query, false, $response, $message);
  829.     } elseif ($imap_auth_mech == 'plain') {
  830.         /***
  831.          * SASL PLAIN
  832.          *
  833.          *  RFC 2595 Chapter 6
  834.          *
  835.          *  The mechanism consists of a single message from the client to the
  836.          *  server.  The client sends the authorization identity (identity to
  837.          *  login as), followed by a US-ASCII NUL character, followed by the
  838.          *  authentication identity (identity whose password will be used),
  839.          *  followed by a US-ASCII NUL character, followed by the clear-text
  840.          *  password.  The client may leave the authorization identity empty to
  841.          *  indicate that it is the same as the authentication identity.
  842.          *
  843.          **/
  844.         $tag=sqimap_session_id(false);
  845.         $sasl = (isset($sqimap_capabilities['SASL-IR']) && $sqimap_capabilities['SASL-IR']) ? true : false;
  846.         $auth = base64_encode("$username\0$username\0$password");
  847.         if ($sasl) {
  848.             // IMAP Extension for SASL Initial Client Response
  849.             // <draft-siemborski-imap-sasl-initial-response-01b.txt>
  850.             $query = $tag . " AUTHENTICATE PLAIN $auth\r\n";
  851.             fputs($imap_stream, $query);
  852.             $read = sqimap_fgets($imap_stream);
  853.         } else {
  854.             $query = $tag . " AUTHENTICATE PLAIN\r\n";
  855.             fputs($imap_stream, $query);
  856.             $read=sqimap_fgets($imap_stream);
  857.             if (substr($read,0,1) == '+') { // OK so far..
  858.                 fputs($imap_stream, "$auth\r\n");
  859.                 $read = sqimap_fgets($imap_stream);
  860.             }
  861.         }
  862.         $results=explode(" ",$read,3);
  863.         $response=$results[1];
  864.         $message=$results[2];
  865.     } else {
  866.         $response="BAD";
  867.         $message="Internal SquirrelMail error - unknown IMAP authentication method chosen.  Please contact the developers.";
  868.     }
  869.  
  870.     /* If the connection was not successful, lets see why */
  871.     if ($response != 'OK') {
  872.         if (!$hide) {
  873.             if ($response != 'NO') {
  874.                 /* "BAD" and anything else gets reported here. */
  875.                 $message = htmlspecialchars($message);
  876.                 set_up_language($squirrelmail_language, true);
  877.                 if ($response == 'BAD') {
  878.                     $string = sprintf (_("Bad request: %s")."<br />\r\n", $message);
  879.                 } else {
  880.                     $string = sprintf (_("Unknown error: %s") . "<br />\n", $message);
  881.                 }
  882.                 if (isset($read) && is_array($read)) {
  883.                     $string .= '<br />' . _("Read data:") . "<br />\n";
  884.                     foreach ($read as $line) {
  885.                         $string .= htmlspecialchars($line) . "<br />\n";
  886.                     }
  887.                 }
  888.                 error_box($string);
  889.                 exit;
  890.             } else {
  891.                 /*
  892.                  * If the user does not log in with the correct
  893.                  * username and password it is not possible to get the
  894.                  * correct locale from the user's preferences.
  895.                  * Therefore, apply the same hack as on the login
  896.                  * screen.
  897.                  *
  898.                  * $squirrelmail_language is set by a cookie when
  899.                  * the user selects language and logs out
  900.                  */
  901.  
  902.                 set_up_language($squirrelmail_language, true);
  903.                 sqsession_destroy();
  904.                 sqsetcookieflush();
  905.                 /* terminate the session nicely */
  906.                 sqimap_logout($imap_stream);
  907.                 logout_error( _("Unknown user or password incorrect.") );
  908.                 exit;
  909.             }
  910.         } else {
  911.             exit;
  912.         }
  913.     }
  914.  
  915.     /* Special error case:
  916.      * Login referrals. The server returns:
  917.      * ? OK [REFERRAL <imap url>]
  918.      * Check RFC 2221 for details. Since we do not support login referrals yet
  919.      * we log the user out.
  920.      */
  921.     if ( stristr($message, 'REFERRAL imap') === TRUE ) {
  922.         sqimap_logout($imap_stream);
  923.         set_up_language($squirrelmail_language, true);
  924.         sqsession_destroy();
  925.         logout_error( _("Your mailbox is not located at this server. Try a different server or consult your system administrator") );
  926.         exit;
  927.     }
  928.  
  929.     return $imap_stream;
  930. }
  931.  
  932. /**
  933.  * Simply logs out the IMAP session
  934.  * @param stream $imap_stream the IMAP connection to log out.
  935.  * @return void 
  936.  */
  937. function sqimap_logout ($imap_stream) {
  938.     /* Logout is not valid until the server returns 'BYE'
  939.      * If we don't have an imap_ stream we're already logged out */
  940.     if(isset($imap_stream) && $imap_stream)
  941.         sqimap_run_command($imap_stream, 'LOGOUT', false, $response, $message);
  942. }
  943.  
  944. /**
  945.  * Retrieve the CAPABILITY string from the IMAP server.
  946.  * If capability is set, returns only that specific capability,
  947.  * else returns array of all capabilities.
  948.  * @param stream $imap_stream 
  949.  * @param string $capability (since 1.3.0)
  950.  * @param boolean $bUseCache (since 1.5.1) Controls use of capability data stored in session
  951.  * @return mixed (string if $capability is set and found,
  952.  *   false, if $capability is set and not found,
  953.  *   array if $capability not set)
  954.  */
  955. function sqimap_capability($imap_stream, $capability='', $bUseCache=true) {
  956.     // sqgetGlobalVar('sqimap_capabilities', $sqimap_capabilities, SQ_SESSION);
  957.  
  958.     if (!$bUseCache || ! sqgetGlobalVar('sqimap_capabilities', $sqimap_capabilities, SQ_SESSION)) {
  959.         $read = sqimap_run_command($imap_stream, 'CAPABILITY', true, $a, $b);
  960.         $c = explode(' ', $read[0]);
  961.         for ($i=2; $i < count($c); $i++) {
  962.             $cap_list = explode('=', $c[$i]);
  963.             if (isset($cap_list[1])) {
  964.                 if(isset($sqimap_capabilities[trim($cap_list[0])]) &&
  965.                  !is_array($sqimap_capabilities[trim($cap_list[0])])) {
  966.                     // Remove array key that was added in 'else' block below
  967.                     // This is to accomodate for capabilities like:
  968.                     // SORT SORT=MODSEQ
  969.                     unset($sqimap_capabilities[trim($cap_list[0])]);
  970.                 }
  971.                 $sqimap_capabilities[trim($cap_list[0])][] = $cap_list[1];
  972.             } else {
  973.                 if(!isset($sqimap_capabilities[trim($cap_list[0])])) {
  974.                     $sqimap_capabilities[trim($cap_list[0])] = TRUE;
  975.                 }
  976.             }
  977.         }
  978.     }
  979.     if ($capability) {
  980.         if (isset($sqimap_capabilities[$capability])) {
  981.                 return $sqimap_capabilities[$capability];
  982.         } else {
  983.                 return false;
  984.         }
  985.     }
  986.     return $sqimap_capabilities;
  987. }
  988.  
  989. /**
  990.  * Returns the delimiter between mailboxes: INBOX/Test, or INBOX.Test
  991.  * @param stream $imap_stream 
  992.  * @return string 
  993.  */
  994. function sqimap_get_delimiter ($imap_stream = false) {
  995.     global $sqimap_delimiter, $optional_delimiter;
  996.  
  997.     /* Use configured delimiter if set */
  998.     if((!empty($optional_delimiter)) && $optional_delimiter != 'detect') {
  999.         return $optional_delimiter;
  1000.     }
  1001.  
  1002.     /* Delimiter is stored in the session from redirect.  Try fetching from there first */
  1003.     if (empty($sqimap_delimiter)) {
  1004.         sqgetGlobalVar('delimiter',$sqimap_delimiter,SQ_SESSION);
  1005.     }
  1006.  
  1007.     /* Do some caching here */
  1008.     if (!$sqimap_delimiter) {
  1009.         if (sqimap_capability($imap_stream, 'NAMESPACE')) {
  1010.             /*
  1011.              * According to something that I can't find, this is supposed to work on all systems
  1012.              * OS: This won't work in Courier IMAP.
  1013.              * OS: According to rfc2342 response from NAMESPACE command is:
  1014.              * OS: * NAMESPACE (PERSONAL NAMESPACES) (OTHER_USERS NAMESPACE) (SHARED NAMESPACES)
  1015.              * OS: We want to lookup all personal NAMESPACES...
  1016.              */
  1017.             $read = sqimap_run_command($imap_stream, 'NAMESPACE', true, $a, $b);
  1018.             if (eregi('\\* NAMESPACE +(\\( *\\(.+\\) *\\)|NIL) +(\\( *\\(.+\\) *\\)|NIL) +(\\( *\\(.+\\) *\\)|NIL)', $read[0], $data)) {
  1019.                 if (eregi('^\\( *\\((.*)\\) *\\)', $data[1], $data2)) {
  1020.                     $pn = $data2[1];
  1021.                 }
  1022.                 $pna = explode(')(', $pn);
  1023.                 while (list($k, $v) = each($pna)) {
  1024.                     $lst = explode('"', $v);
  1025.                     if (isset($lst[3])) {
  1026.                         $pn[$lst[1]] = $lst[3];
  1027.                     } else {
  1028.                         $pn[$lst[1]] = '';
  1029.                     }
  1030.                 }
  1031.             }
  1032.             $sqimap_delimiter = $pn[0];
  1033.         } else {
  1034.             fputs ($imap_stream, ". LIST \"INBOX\" \"\"\r\n");
  1035.             $read = sqimap_read_data($imap_stream, '.', true, $a, $b);
  1036.             $read = $read['.'][0];    //sqimap_read_data() now returns a tag array of response array
  1037.             $quote_position = strpos ($read[0], '"');
  1038.             $sqimap_delimiter = substr ($read[0], $quote_position+1, 1);
  1039.         }
  1040.     }
  1041.     return $sqimap_delimiter;
  1042. }
  1043.  
  1044. /**
  1045.  * This encodes a mailbox name for use in IMAP commands.
  1046.  * @param string $what the mailbox to encode
  1047.  * @return string the encoded mailbox string
  1048.  * @since 1.5.0
  1049.  */
  1050. function sqimap_encode_mailbox_name($what)
  1051. {
  1052.     if (ereg("[\"\\\r\n]", $what))
  1053.         return '{' . strlen($what) . "}\r\n" . $what;        /* 4.3 literal form */
  1054.     return '"' . $what . '"';        /* 4.3 quoted string form */
  1055. }
  1056.  
  1057. /**
  1058.  * Gets the number of messages in the current mailbox.
  1059.  *
  1060.  * OBSOLETE use sqimap_status_messages instead.
  1061.  * @param stream $imap_stream imap stream
  1062.  * @param string $mailbox 
  1063.  * @deprecated
  1064.  */
  1065. function sqimap_get_num_messages ($imap_stream, $mailbox) {
  1066.     $aStatus = sqimap_status_messages($imap_stream,$mailbox,array('MESSAGES'));
  1067.     return $aStatus['MESSAGES'];
  1068. }
  1069.  
  1070. /**
  1071.  * OBSOLETE FUNCTION should be removed after mailbox_display,
  1072.  * printMessage function is adapted
  1073.  * $addr_ar = array(), $group = '' and $host='' arguments are used in 1.4.0
  1074.  * @param string $address 
  1075.  * @param integer $max 
  1076.  * @since 1.4.0
  1077.  * @deprecated See Rfc822Address.php
  1078.  */
  1079. function parseAddress($address, $max=0) {
  1080.     $aAddress = parseRFC822Address($address,array('limit'=> $max));
  1081.     /*
  1082.      * Because the expected format of the array element is changed we adapt it now.
  1083.      * This also implies that this function is obsolete and should be removed after the
  1084.      * rest of the source is adapted. See Rfc822Address.php for the new function.
  1085.      */
  1086.      array_walk($aAddress, '_adaptAddress');
  1087.      return $aAddress;
  1088. }
  1089.  
  1090. /**
  1091.  * OBSOLETE FUNCTION should be removed after mailbox_display,
  1092.  * printMessage function is adapted
  1093.  *
  1094.  * callback function used for formating of addresses array in
  1095.  * parseAddress() function
  1096.  * @param array $aAddr 
  1097.  * @param integer $k array key
  1098.  * @since 1.5.1
  1099.  * @deprecated
  1100.  */
  1101. function _adaptAddress(&$aAddr,$k) {
  1102.    $sPersonal = (isset($aAddr[SQM_ADDR_PERSONAL]) && $aAddr[SQM_ADDR_PERSONAL]) ?
  1103.        $aAddr[SQM_ADDR_PERSONAL] : '';
  1104.    $sEmail = ($aAddr[SQM_ADDR_HOST]) ?
  1105.        $aAddr[SQM_ADDR_MAILBOX] . '@'.$aAddr[SQM_ADDR_HOST] :
  1106.        $aAddr[SQM_ADDR_MAILBOX];
  1107.    $aAddr = array($sEmail,$sPersonal);
  1108. }
  1109.  
  1110. /**
  1111.  * Returns the number of unseen messages in this folder.
  1112.  * obsoleted by sqimap_status_messages !
  1113.  * Arguments differ in 1.0.x
  1114.  * @param stream $imap_stream 
  1115.  * @param string $mailbox 
  1116.  * @return integer 
  1117.  * @deprecated
  1118.  */
  1119. function sqimap_unseen_messages ($imap_stream, $mailbox) {
  1120.     $aStatus = sqimap_status_messages($imap_stream,$mailbox,array('UNSEEN'));
  1121.     return $aStatus['UNSEEN'];
  1122. }
  1123.  
  1124. /**
  1125.  * Returns the status items of a mailbox.
  1126.  * Default it returns MESSAGES,UNSEEN and RECENT
  1127.  * Supported status items are MESSAGES, UNSEEN, RECENT (since 1.4.0),
  1128.  * UIDNEXT (since 1.5.1) and UIDVALIDITY (since 1.5.1)
  1129.  * @param stream $imap_stream imap stream
  1130.  * @param string $mailbox mail folder
  1131.  * @param array $aStatusItems status items
  1132.  * @return array 
  1133.  * @since 1.3.2
  1134.  */
  1135. function sqimap_status_messages ($imap_stream, $mailbox,
  1136.                        $aStatusItems = array('MESSAGES','UNSEEN','RECENT')) {
  1137.  
  1138.     $aStatusItems = implode(' ',$aStatusItems);
  1139.     $read_ary = sqimap_run_command ($imap_stream, 'STATUS ' . sqimap_encode_mailbox_name($mailbox) .
  1140.                                     " ($aStatusItems)", false, $result, $message);
  1141.     $i = 0;
  1142.     $messages = $unseen = $recent = $uidnext = $uidvalidity = false;
  1143.     $regs = array(false,false);
  1144.     while (isset($read_ary[$i])) {
  1145.         if (preg_match('/UNSEEN\s+([0-9]+)/i', $read_ary[$i], $regs)) {
  1146.             $unseen = $regs[1];
  1147.         }
  1148.         if (preg_match('/MESSAGES\s+([0-9]+)/i', $read_ary[$i], $regs)) {
  1149.             $messages = $regs[1];
  1150.         }
  1151.         if (preg_match('/RECENT\s+([0-9]+)/i', $read_ary[$i], $regs)) {
  1152.             $recent = $regs[1];
  1153.         }
  1154.         if (preg_match('/UIDNEXT\s+([0-9]+)/i', $read_ary[$i], $regs)) {
  1155.             $uidnext = $regs[1];
  1156.         }
  1157.         if (preg_match('/UIDVALIDITY\s+([0-9]+)/i', $read_ary[$i], $regs)) {
  1158.             $uidvalidity = $regs[1];
  1159.         }
  1160.         $i++;
  1161.     }
  1162.  
  1163.     $status=array('MESSAGES' => $messages,
  1164.                  'UNSEEN'=>$unseen,
  1165.                  'RECENT' => $recent,
  1166.                  'UIDNEXT' => $uidnext,
  1167.                  'UIDVALIDITY' => $uidvalidity);
  1168.  
  1169.     if (!empty($messages)) { $hook_status['MESSAGES']=$messages; }
  1170.     if (!empty($unseen)) { $hook_status['UNSEEN']=$unseen; }
  1171.     if (!empty($recent)) { $hook_status['RECENT']=$recent; }
  1172.     if (!empty($hook_status)) {
  1173.          $hook_status['MAILBOX']=$mailbox;
  1174.          $hook_status['CALLER']='sqimap_status_messages';
  1175.          do_hook_function('folder_status',$hook_status);
  1176.     }
  1177.     return $status;
  1178. }
  1179.  
  1180.  
  1181. /**
  1182.  * Saves a message to a given folder -- used for saving sent messages
  1183.  * @param stream $imap_stream 
  1184.  * @param string $sent_folder 
  1185.  * @param $length 
  1186.  * @return string $sid
  1187.  */
  1188. function sqimap_append ($imap_stream, $sMailbox, $length) {
  1189.     $sid = sqimap_session_id();
  1190.     $query = $sid . ' APPEND ' . sqimap_encode_mailbox_name($sMailbox) . " (\\Seen) {".$length."}";
  1191.     fputs ($imap_stream, "$query\r\n");
  1192.     $tmp = fgets ($imap_stream, 1024);
  1193.     sqimap_append_checkresponse($tmp, $sMailbox,$sid, $query);
  1194.     return $sid;
  1195. }
  1196.  
  1197. /**
  1198.  * @param stream imap_stream
  1199.  * @param string $folder (since 1.3.2)
  1200.  */
  1201. function sqimap_append_done ($imap_stream, $sMailbox='') {
  1202.     fputs ($imap_stream, "\r\n");
  1203.     $tmp = fgets ($imap_stream, 1024);
  1204.     while (!sqimap_append_checkresponse($tmp, $sMailbox)) {
  1205.         $tmp = fgets ($imap_stream, 1024);
  1206.     }
  1207. }
  1208.  
  1209. /**
  1210.  * Displays error messages, if there are errors in responses to
  1211.  * commands issues by sqimap_append() and sqimap_append_done() functions.
  1212.  * @param string $response 
  1213.  * @param string $sMailbox 
  1214.  * @return bool $bDone
  1215.  * @since 1.5.1 and 1.4.5
  1216.  */
  1217. function sqimap_append_checkresponse($response, $sMailbox, $sid='', $query='') {
  1218.     // static vars to keep them available when sqimap_append_done calls this function.
  1219.     static $imapquery, $imapsid;
  1220.  
  1221.     $bDone = false;
  1222.  
  1223.     if ($query) {
  1224.         $imapquery = $query;
  1225.     }
  1226.     if ($sid) {
  1227.         $imapsid = $sid;
  1228.     }
  1229.     if ($response{0} == '+') {
  1230.         // continuation request triggerd by sqimap_append()
  1231.         $bDone = true;
  1232.     } else {
  1233.         $i = strpos($response, ' ');
  1234.         $sRsp = substr($response,0,$i);
  1235.         $sMsg = substr($response,$i+1);
  1236.         $aExtra = array('MAILBOX' => $sMailbox);
  1237.         switch ($sRsp) {
  1238.             case '*': //untagged response
  1239.                 $i = strpos($sMsg, ' ');
  1240.                 $sRsp = strtoupper(substr($sMsg,0,$i));
  1241.                 $sMsg = substr($sMsg,$i+1);
  1242.                 if ($sRsp == 'NO' || $sRsp == 'BAD') {
  1243.                     // for the moment disabled. Enable after 1.5.1 release.
  1244.                     // Notices could give valueable information about the mailbox
  1245.                     // sqm_trigger_imap_error('SQM_IMAP_APPEND_NOTICE',$imapquery,$sRsp,$sMsg);
  1246.                 }
  1247.                 $bDone = false;
  1248.             case $imapsid:
  1249.                 // A001 OK message
  1250.                 // $imapsid<space>$sRsp<space>$sMsg
  1251.                 $bDone = true;
  1252.                 $i = strpos($sMsg, ' ');
  1253.                 $sRsp = strtoupper(substr($sMsg,0,$i));
  1254.                 $sMsg = substr($sMsg,$i+1);
  1255.                 switch ($sRsp) {
  1256.                     case 'NO':
  1257.                         if (preg_match("/(.*)(quota)(.*)$/i", $sMsg, $aMatch)) {
  1258.                             sqm_trigger_imap_error('SQM_IMAP_APPEND_QUOTA_ERROR',$imapquery,$sRsp,$sMsg,$aExtra);
  1259.                         } else {
  1260.                             sqm_trigger_imap_error('SQM_IMAP_APPEND_ERROR',$imapquery,$sRsp,$sMsg,$aExtra);
  1261.                         }
  1262.                         break;
  1263.                     case 'BAD':
  1264.                         sqm_trigger_imap_error('SQM_IMAP_ERROR',$imapquery,$sRsp,$sMsg,$aExtra);
  1265.                         break;
  1266.                     case 'BYE':
  1267.                         sqm_trigger_imap_error('SQM_IMAP_BYE',$imapquery,$sRsp,$sMsg,$aExtra);
  1268.                         break;
  1269.                     case 'OK':
  1270.                         break;
  1271.                     default:
  1272.                         break;
  1273.                 }
  1274.                 break;
  1275.             default:
  1276.                 // should be false because of the unexpected response but i'm not sure if
  1277.                 // that will cause an endless loop in sqimap_append_done
  1278.                 $bDone = true;
  1279.         }
  1280.     }
  1281.     return $bDone;
  1282. }
  1283.  
  1284. /**
  1285.  * Allows mapping of IMAP server address with custom function
  1286.  * see map_yp_alias()
  1287.  * @param string $imap_server imap server address or mapping
  1288.  * @param string $username 
  1289.  * @return string 
  1290.  * @since 1.3.0
  1291.  */
  1292. function sqimap_get_user_server ($imap_server, $username) {
  1293.    if (substr($imap_server, 0, 4) != "map:") {
  1294.        return $imap_server;
  1295.    }
  1296.    $function = substr($imap_server, 4);
  1297.    return $function($username);
  1298. }
  1299.  
  1300. /**
  1301.  * This is an example that gets IMAP servers from yellowpages (NIS).
  1302.  * you can simple put map:map_yp_alias in your $imap_server_address
  1303.  * in config.php use your own function instead map_yp_alias to map your
  1304.  * LDAP whatever way to find the users IMAP server.
  1305.  *
  1306.  * Requires access to external ypmatch program
  1307.  * FIXME: it can be implemented in php yp extension or pecl (since php 5.1.0)
  1308.  * @param string $username 
  1309.  * @return string 
  1310.  * @since 1.3.0
  1311.  */
  1312. function map_yp_alias($username) {
  1313.    $yp = `ypmatch $username aliases`;
  1314.    return chop(substr($yp, strlen($username)+1));
  1315. }

Documentation generated on Sat, 07 Oct 2006 16:11:39 +0300 by phpDocumentor 1.3.0RC6