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

Documentation generated on Tue, 16 Sep 2014 04:21:03 +0200 by phpDocumentor 1.4.3