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-2020 The SquirrelMail Project Team
  9.  * @license http://opensource.org/licenses/gpl-license.php GNU Public License
  10.  * @version $Id: imap_general.php 14840 2020-01-07 07:42:38Z 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.         return( sprintf("A%03d", $sqimap_session_id++) );
  31.     } else {
  32.         return( sprintf("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($results) - 1;
  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_mech) ? strtolower($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.     // for backward compatibility: boolean $use_imap_tls set
  528.     // to TRUE means to use plain TLS (as opposed to STARTTLS)
  529.     //
  530.     if ($use_imap_tls === TRUE)
  531.         $use_imap_tls = 1;
  532.  
  533.     if (!isset($sqimap_capabilities)) {
  534.         sqgetglobalvar('sqimap_capabilities' , $sqimap_capabilities , SQ_SESSION );
  535.     }
  536.  
  537.     list($imap_stream, $server_info) = sqimap_create_stream($imap_server_address,$imap_port,$use_imap_tls,$stream_options,$hide);
  538.  
  539.     /* Decrypt the password */
  540.     $password = OneTimePadDecrypt($password, $onetimepad);
  541.  
  542.     if (($imap_auth_mech == 'cram-md5') OR ($imap_auth_mech == 'digest-md5')) {
  543.         // We're using some sort of authentication OTHER than plain or login
  544.         $tag=sqimap_session_id(false);
  545.         if ($imap_auth_mech == 'digest-md5') {
  546.             $query = $tag . " AUTHENTICATE DIGEST-MD5\r\n";
  547.         } elseif ($imap_auth_mech == 'cram-md5') {
  548.             $query = $tag . " AUTHENTICATE CRAM-MD5\r\n";
  549.         }
  550.         fputs($imap_stream,$query);
  551.         $answer=sqimap_fgets($imap_stream);
  552.         // Trim the "+ " off the front
  553.         $response=explode(" ",$answer,3);
  554.         if ($response[0] == '+') {
  555.             // Got a challenge back
  556.             $challenge=$response[1];
  557.             if ($imap_auth_mech == 'digest-md5') {
  558.                 $reply = digest_md5_response($username,$password,$challenge,'imap',$host,$authz);
  559.             } elseif ($imap_auth_mech == 'cram-md5') {
  560.                 $reply = cram_md5_response($username,$password,$challenge);
  561.             }
  562.             fputs($imap_stream,$reply);
  563.             $read=sqimap_fgets($imap_stream);
  564.             if ($imap_auth_mech == 'digest-md5') {
  565.                 // DIGEST-MD5 has an extra step..
  566.                 if (substr($read,0,1) == '+') { // OK so far..
  567.                     fputs($imap_stream,"\r\n");
  568.                     $read=sqimap_fgets($imap_stream);
  569.                 }
  570.             }
  571.             $results=explode(" ",$read,3);
  572.             $response=$results[1];
  573.             $message=$results[2];
  574.         } else {
  575.             // Fake the response, so the error trap at the bottom will work
  576.             $response="BAD";
  577.             $message='IMAP server does not appear to support the authentication method selected.';
  578.             $message .= '  Please contact your system administrator.';
  579.         }
  580.     } elseif ($imap_auth_mech == 'login') {
  581.         // this is a workaround to alert users of LOGINDISABLED, which is done "right" in
  582.         // devel but requires functions not available in stable. RFC requires us to
  583.         // not send LOGIN when LOGINDISABLED is advertised.
  584.         if(stristr($server_info, 'LOGINDISABLED')) {
  585.             $response = 'BAD';
  586.             $message = _("The IMAP server is reporting that plain text logins are disabled.").' '.
  587.                 _("Using CRAM-MD5 or DIGEST-MD5 authentication instead may work.").' ';
  588.             if (!$use_imap_tls) {
  589.                 $message .= _("Also, the use of TLS may allow SquirrelMail to login.").' ';
  590.             }
  591.             $message .= _("Please contact your system administrator and report this error.");
  592.         } else {
  593.             // Original IMAP login code
  594.             if(sq_is8bit($username) || sq_is8bit($password)) {
  595.                 $query['commands'][0] = 'LOGIN';
  596.                 $query['literal_args'][0] = $username;
  597.                 $query['commands'][1] = '';
  598.                 $query['literal_args'][1] = $password;
  599.                 $read = sqimap_run_literal_command($imap_stream, $query, false, $response, $message);
  600.             } else {
  601.                 $query = 'LOGIN "' . quoteimap($username) . '"'
  602.                        . ' "' . quoteimap($password) . '"';
  603.                 $read = sqimap_run_command ($imap_stream, $query, false, $response, $message);
  604.             }
  605.         }
  606.     } elseif ($imap_auth_mech == 'plain') {
  607.         /***
  608.          * SASL PLAIN, RFC 4616 (updates 2595)
  609.          *
  610.          * The mechanism consists of a single message, a string of [UTF-8]
  611.          * encoded [Unicode] characters, from the client to the server.  The
  612.          * client presents the authorization identity (identity to act as),
  613.          * followed by a NUL (U+0000) character, followed by the authentication
  614.          * identity (identity whose password will be used), followed by a NUL
  615.          * (U+0000) character, followed by the clear-text password.  As with
  616.          * other SASL mechanisms, the client does not provide an authorization
  617.          * identity when it wishes the server to derive an identity from the
  618.          * credentials and use that as the authorization identity.
  619.          */
  620.         $tag=sqimap_session_id(false);
  621.         $sasl = (isset($sqimap_capabilities['SASL-IR']) && $sqimap_capabilities['SASL-IR']) ? true : false;
  622.         if(!empty($authz)) {
  623.             $auth = base64_encode("$username\0$authz\0$password");
  624.         } else {
  625.             $auth = base64_encode("$username\0$username\0$password");
  626.         }
  627.         if ($sasl) {
  628.             // IMAP Extension for SASL Initial Client Response
  629.             // <draft-siemborski-imap-sasl-initial-response-01b.txt>
  630.             $query = $tag . " AUTHENTICATE PLAIN $auth\r\n";
  631.             fputs($imap_stream, $query);
  632.             $read = sqimap_fgets($imap_stream);
  633.         } else {
  634.             $query = $tag . " AUTHENTICATE PLAIN\r\n";
  635.             fputs($imap_stream, $query);
  636.             $read=sqimap_fgets($imap_stream);
  637.             if (substr($read,0,1) == '+') { // OK so far..
  638.                 fputs($imap_stream, "$auth\r\n");
  639.                 $read = sqimap_fgets($imap_stream);
  640.             }
  641.         }
  642.         $results=explode(" ",$read,3);
  643.         $response=$results[1];
  644.         $message=$results[2];
  645.  
  646.     } else {
  647.         $response="BAD";
  648.         $message="Internal SquirrelMail error - unknown IMAP authentication method chosen.  Please contact the developers.";
  649.     }
  650.  
  651.     /* If the connection was not successful, lets see why */
  652.     if ($response != 'OK') {
  653.         if (!$hide) {
  654.             if ($response != 'NO') {
  655.                 /* "BAD" and anything else gets reported here. */
  656.                 $message = sm_encode_html_special_chars($message);
  657.                 set_up_language($squirrelmail_language, true);
  658.                 require_once(SM_PATH . 'functions/display_messages.php');
  659.                 if ($response == 'BAD') {
  660.                     $string = sprintf (_("Bad request: %s")."<br />\r\n", $message);
  661.                 } else {
  662.                     $string = sprintf (_("Unknown error: %s") . "<br />\n", $message);
  663.                 }
  664.                 if (isset($read) && is_array($read)) {
  665.                     $string .= '<br />' . _("Read data:") . "<br />\n";
  666.                     foreach ($read as $line) {
  667.                         $string .= sm_encode_html_special_chars($line) . "<br />\n";
  668.                     }
  669.                 }
  670.                 error_box($string,$color);
  671.                 exit;
  672.             } else {
  673.                 /*
  674.                  * If the user does not log in with the correct
  675.                  * username and password it is not possible to get the
  676.                  * correct locale from the user's preferences.
  677.                  * Therefore, apply the same hack as on the login
  678.                  * screen.
  679.                  *
  680.                  * $squirrelmail_language is set by a cookie when
  681.                  * the user selects language and logs out
  682.                  */
  683.  
  684.                 set_up_language($squirrelmail_language, true);
  685.                 include_once(SM_PATH . 'functions/display_messages.php' );
  686.                 sqsession_destroy();
  687.                 /* terminate the session nicely */
  688.                 sqimap_logout($imap_stream);
  689.  
  690.                 // determine what error message to show to the user
  691.                 //
  692.                 $fail_msg = _("Unknown user or password incorrect.");
  693.                 if ($display_imap_login_error) {
  694.                     // See if there is an error message from the server
  695.                     // Skip any rfc5530 response code: '[something]' at the
  696.                     // start of the message
  697.                     if (!empty($message)
  698.                      && $message{0} == '['
  699.                      && ($end = strstr($message, ']'))
  700.                      && $end != ']') {
  701.                         $message = substr($end, 1);
  702.                     }
  703.                     // Remove surrounding spaces and if there
  704.                     // is anything left, display that as the
  705.                     // error message:
  706.                     $message = trim($message);
  707.                     if (strlen($message))
  708.                         $fail_msg = _($message);
  709.                 }
  710.  
  711.                 logout_error($fail_msg);
  712.                 exit;
  713.             }
  714.         } else {
  715.             exit;
  716.         }
  717.     }
  718.  
  719.     // Run ID command if configured - RFC 2971
  720.     //
  721.     // Administrator must declare a configuration variable called
  722.     // $imap_id_command_args in config/config_local.php which must
  723.     // be an array, where each key is an attibute to be sent in the
  724.     // IMAP ID command to the server.  Values will be sent as-is
  725.     // except if the value is "###REMOTE ADDRESS###" (without quotes)
  726.     // in which case the current user's real IP address will be
  727.     // substituted.  If "###X-FORWARDED-FOR###" is used and a
  728.     // "X-FORWARDED-FOR" header is present in the client request,
  729.     // the contents of that header are used (careful, this can be
  730.     // forged).  If "###X-FORWARDED-FOR OR REMOTE ADDRESS###" is
  731.     // used, then the "X-FORWARDED-FOR" header is used if it is
  732.     // present in the request, otherwise, the client's connecting
  733.     // IP address is used.  The following attributes will always be
  734.     // added unless they are specifically overridden with a blank
  735.     // value:
  736.     //    name, vendor, support-url, version
  737.     // A parsed representation of server's response is made available
  738.     // to plugins as both a global and session variable named
  739.     // "imap_server_id_response" (a simple key/value array) unless
  740.     // response parsing is turned off by way of setting a variable
  741.     // named $do_not_parse_imap_id_command_response in
  742.     // config/config_local.php to TRUE, in which case, the stored
  743.     // response will be the unparsed IMAP response.
  744.     //
  745.     global $imap_id_command_args, $do_not_parse_imap_id_command_response;
  746.     if (!empty($imap_id_command_args) && is_array($imap_id_command_args)
  747.      && sqimap_capability($imap_stream, 'ID')) {
  748.  
  749.         static $args = array();
  750.         if (empty($args)) {
  751.             if (!isset($imap_id_command_args['name']))
  752.                 $imap_id_command_args['name'] = 'SquirrelMail';
  753.             if (!isset($imap_id_command_args['vendor']))
  754.                 $imap_id_command_args['vendor'] = 'SquirrelMail Project Team';
  755.             if (!isset($imap_id_command_args['support-url']))
  756.                 $imap_id_command_args['support-url'] = 'https://squirrelmail.org';
  757.             if (!isset($imap_id_command_args['version'])) {
  758.                 global $version;
  759.                 $imap_id_command_args['version'] = $version;
  760.             }
  761.             foreach ($imap_id_command_args as $key => $value) {
  762.                 $key = trim($key);
  763.                 $value = trim($value);
  764.                 if ($key === '' || $value === '')
  765.                    continue;
  766.                 if ($value === '###REMOTE ADDRESS###' && sqGetGlobalVar('REMOTE_ADDR', $remote_addr, SQ_SERVER))
  767.                     $value = $remote_addr;
  768.                 else if ($value === '###X-FORWARDED-FOR###' && sqGetGlobalVar('HTTP_X_FORWARDED_FOR', $remote_addr, SQ_SERVER))
  769.                     $value = $remote_addr;
  770.                 else if ($value === '###X-FORWARDED-FOR OR REMOTE ADDRESS###') {
  771.                     if (sqGetGlobalVar('HTTP_X_FORWARDED_FOR', $remote_addr, SQ_SERVER))
  772.                         $value = $remote_addr;
  773.                     else if (sqGetGlobalVar('REMOTE_ADDR', $remote_addr, SQ_SERVER))
  774.                         $value = $remote_addr;
  775.                 }
  776.                 else if ($value === '###REMOTE ADDRESS###' && sqGetGlobalVar('REMOTE_ADDR', $remote_addr, SQ_SERVER)) {
  777.                     $value = $remote_addr;
  778.                 }
  779.                 $args[] = '"' . str_replace(array('"', '\\'), array('\\"', '\\\\'), $key)
  780.                                . '" "' . str_replace(array('"', '\\'), array('\\"', '\\\\'), $value) . '"';
  781.             }
  782.         }
  783.         $read_ary = sqimap_run_command($imap_stream, 'ID (' . implode(' ', $args) . ')', false, $response, $message);
  784.         if (!empty($read_ary) && is_array($read_ary)) {
  785.             global $imap_server_id_response;
  786.             if ($do_not_parse_imap_id_command_response)
  787.                $imap_server_id_response = $read_ary;
  788.             else
  789.             {
  790.                $imap_server_id_response = array();
  791.  
  792.                // NOTE that this parser ignores closing ) sign, so
  793.                //      technically some kind of malformed server
  794.                //      response could cause extra junk to be included here
  795.                foreach ($read_ary as $info)
  796.                {
  797.                   $parsed_info = explode('(', $info, 2);
  798.                   if (!empty($parsed_info[1]))
  799.                   {
  800.                      // find opening quote for the next key name
  801.                      while ($parsed_info = explode('"', $parsed_info[1], 2))
  802.                      {
  803.                         if (empty($parsed_info[1]))
  804.                            break;
  805.                         else
  806.                         {
  807.                            // find closing quote for the key name
  808.                            $pos = strpos($parsed_info[1], '"');
  809.                            if ($pos === FALSE)
  810.                               break;
  811.                            else
  812.                            {
  813.                               $key = substr($parsed_info[1], 0, $pos);
  814.                               $parsed_info[1] = substr($parsed_info[1], $pos + 1);
  815.  
  816.                               // find opening quote for the key's value
  817.                               $parsed_info = explode('"', $parsed_info[1], 2);
  818.                               if (empty($parsed_info[1]))
  819.                                  break;
  820.                               else
  821.                               {
  822.                                  // find closing quote for the key's value
  823.                                  $pos = strpos($parsed_info[1], '"');
  824.                                  if ($pos === FALSE)
  825.                                     break;
  826.                                  else
  827.                                  {
  828.                                     $imap_server_id_response[$key] = substr($parsed_info[1], 0, $pos);
  829.                                     $parsed_info[1] = substr($parsed_info[1], $pos + 1);
  830.                                  }
  831.                               }
  832.                            }
  833.                         }
  834.                      }
  835.                   }
  836.                }
  837.             }
  838.             sqsession_register($imap_server_id_response, 'imap_server_id_response');
  839.         }
  840.     }
  841.  
  842.     return $imap_stream;
  843. }
  844.  
  845. /**
  846.  * Simply logs out the IMAP session
  847.  * @param stream imap_stream the IMAP connection to log out.
  848.  * @return void 
  849.  */
  850. function sqimap_logout ($imap_stream) {
  851.     /* Logout is not valid until the server returns 'BYE'
  852.      * If we don't have an imap_stream we're already logged out */
  853.     if(isset($imap_stream) && $imap_stream) {
  854.         sqimap_run_command($imap_stream, 'LOGOUT', false, $response, $message);
  855.         fclose($imap_stream);
  856.     }
  857. }
  858.  
  859. /**
  860.  * Connects to the IMAP server and returns a resource identifier for use with
  861.  * the other SquirrelMail IMAP functions. Does NOT login!
  862.  * @param string server hostname of IMAP server
  863.  * @param int port port number to connect to
  864.  * @param integer $tls whether to use plain text(0), TLS(1) or STARTTLS(2) when connecting.
  865.  * @param array $stream_options Stream context options, see config_local.php
  866.  *                            for more details (OPTIONAL)
  867.  * @param boolean $hide Whether or not to show error output
  868.  * @return array with two elements: imap-stream resource identifier
  869.  *                and IMAP server response string
  870.  *
  871.  * @since 1.4.23 and 1.5.0 (usable only in 1.5.1 or later) (1.4.23 has a couple subtle differences from 1.5.x)
  872.  */
  873. function sqimap_create_stream($server,$port,$tls=0,$stream_options=array(),$hide=FALSE) {
  874.     global $squirrelmail_language;
  875.  
  876.     if (strstr($server,':') && ! preg_match("/^\[.*\]$/",$server)) {
  877.         // numerical IPv6 address must be enclosed in square brackets
  878.         $server = '['.$server.']';
  879.     }
  880.  
  881.     // NB: Using "ssl://" ensures the highest possible TLS version
  882.     // will be negotiated with the server (whereas "tls://" only
  883.     // uses TLS version 1.0)
  884.     //
  885.     if ($tls == 1) {
  886.         if ((check_php_version(4,3)) and (extension_loaded('openssl'))) {
  887.             if (function_exists('stream_socket_client')) {
  888.                 $server_address = 'ssl://' . $server . ':' . $port;
  889.                 $ssl_context = @stream_context_create($stream_options);
  890.                 $connect_timeout = ini_get('default_socket_timeout');
  891.                 // null timeout is broken
  892.                 if ($connect_timeout == 0)
  893.                     $connect_timeout = 15;
  894.                 $imap_stream = @stream_socket_client($server_address, $error_number, $error_string, $connect_timeout, STREAM_CLIENT_CONNECT, $ssl_context);
  895.             } else {
  896.                 $imap_stream = @fsockopen('ssl://' . $server, $port, $error_number, $error_string, 15);
  897.             }
  898.         } else {
  899.             require_once(SM_PATH . 'functions/display_messages.php');
  900.             logout_error( sprintf(_("Error connecting to IMAP server: %s."), $server).
  901.                 '<br />'.
  902.                 _("TLS is enabled, but this version of PHP does not support TLS sockets, or is missing the openssl extension.").
  903.                 '<br /><br />'.
  904.                 _("Please contact your system administrator and report this error."),
  905.                           sprintf(_("Error connecting to IMAP server: %s."), $server));
  906.         }
  907.     } else {
  908.         $imap_stream = @fsockopen($server, $port, $error_number, $error_string, 15);
  909.     }
  910.  
  911.  
  912.     /* Do some error correction */
  913.     if (!$imap_stream) {
  914.         if (!$hide) {
  915.             set_up_language($squirrelmail_language, true);
  916.             require_once(SM_PATH . 'functions/display_messages.php');
  917.             logout_error( sprintf(_("Error connecting to IMAP server: %s."), $server).
  918.                 "<br />\r\n$error_number : $error_string<br />\r\n",
  919.                 sprintf(_("Error connecting to IMAP server: %s."), $server) );
  920.         }
  921.         exit;
  922.     }
  923.     $server_info = fgets ($imap_stream, 1024);
  924.  
  925.     /**
  926.      * Implementing IMAP STARTTLS (rfc2595) in php 5.1.0+
  927.      * http://www.php.net/stream-socket-enable-crypto
  928.      */
  929.     if ($tls === 2) {
  930.         if (function_exists('stream_socket_enable_crypto')) {
  931.             // check starttls capability, don't use cached capability version
  932.             if (! sqimap_capability($imap_stream, 'STARTTLS', false)) {
  933.                 // imap server does not declare starttls support
  934.                 sqimap_error_box(sprintf(_("Error connecting to IMAP server: %s."), $server),
  935.                                  '','',
  936.                                  _("IMAP STARTTLS is enabled in SquirrelMail configuration, but used IMAP server does not support STARTTLS."));
  937.                 exit;
  938.             }
  939.  
  940.             // issue starttls command and check response
  941.             sqimap_run_command($imap_stream, 'STARTTLS', false, $starttls_response, $starttls_message);
  942.             // check response
  943.             if ($starttls_response!='OK') {
  944.                 // starttls command failed
  945.                 sqimap_error_box(sprintf(_("Error connecting to IMAP server: %s."), $server),
  946.                                  'STARTTLS',
  947.                                  _("Server replied:") . ' ',
  948.                                  $starttls_message);
  949.                 exit();
  950.             }
  951.  
  952.             // start crypto on connection. suppress function errors.
  953.             if (@stream_socket_enable_crypto($imap_stream,true,STREAM_CRYPTO_METHOD_TLS_CLIENT)) {
  954.                 // starttls was successful
  955.  
  956.                 /**
  957.                  * RFC 2595 requires to discard CAPABILITY information after successful
  958.                  * STARTTLS command. We don't follow RFC, because SquirrelMail stores CAPABILITY
  959.                  * information only after successful login (src/redirect.php) and cached information
  960.                  * is used only in other php script connections after successful STARTTLS. If script
  961.                  * issues sqimap_capability() call before sqimap_login() and wants to get initial
  962.                  * capability response, script should set third sqimap_capability() argument to false.
  963.                  */
  964.                 //sqsession_unregister('sqimap_capabilities');
  965.             } else {
  966.                 /**
  967.                  * stream_socket_enable_crypto() call failed. Possible issues:
  968.                  * - broken ssl certificate (uw drops connection, error is in syslog mail facility)
  969.                  * - some ssl error (can reproduce with STREAM_CRYPTO_METHOD_SSLv3_CLIENT, PHP E_WARNING
  970.                  *   suppressed in stream_socket_enable_crypto() call)
  971.                  */
  972.                 sqimap_error_box(sprintf(_("Error connecting to IMAP server: %s."), $server),
  973.                                  '','',
  974.                                  _("Unable to start TLS."));
  975.                 /**
  976.                  * Bug: stream_socket_enable_crypto() does not register SSL errors in
  977.                  * openssl_error_string() or stream notification wrapper and displays
  978.                  * them in E_WARNING level message. It is impossible to retrieve error
  979.                  * message without own error handler.
  980.                  */
  981.                 exit;
  982.             }
  983.         } else {
  984.             // php install does not support stream_socket_enable_crypto() function
  985.             sqimap_error_box(sprintf(_("Error connecting to IMAP server: %s."), $server),
  986.                              '','',
  987.                              _("IMAP STARTTLS is enabled in SquirrelMail configuration, but used PHP version does not support functions that allow to enable encryption on open socket."));
  988.             exit;
  989.         }
  990.     }
  991.     return array($imap_stream, $server_info);
  992. }
  993.  
  994. /**
  995.  * Retreive the CAPABILITY string from the IMAP server.
  996.  * If capability is set, returns only that specific capability,
  997.  * else returns array of all capabilities.
  998.  */
  999. function sqimap_capability($imap_stream, $capability='', $use_cache=TRUE) {
  1000.  
  1001.     global $sqimap_capabilities;
  1002.     $capabilities = $sqimap_capabilities; // don't overwrite global value
  1003.  
  1004.     if (!$use_cache || !is_array($capabilities)) {
  1005.         $read = sqimap_run_command($imap_stream, 'CAPABILITY', true, $a, $b);
  1006.  
  1007.         $c = explode(' ', $read[0]);
  1008.         for ($i=2; $i < count($c); $i++) {
  1009.             $cap_list = explode('=', $c[$i]);
  1010.             if (isset($cap_list[1])) {
  1011.                 // FIX ME. capabilities can occure multiple times.
  1012.                 // THREAD=REFERENCES THREAD=ORDEREDSUBJECT
  1013.                 $capabilities[$cap_list[0]] = $cap_list[1];
  1014.             } else {
  1015.                 $capabilities[$cap_list[0]] = TRUE;
  1016.             }
  1017.         }
  1018.     }
  1019.  
  1020.     // this was terrible design in the first place, but we have
  1021.     // to do this since there may be expectations in the calling
  1022.     // code that the global value gets set if it was empty
  1023.     if (!is_array($sqimap_capabilities)) {
  1024.        $sqimap_capabilities = $capabilities;
  1025.     }
  1026.  
  1027.     if ($capability) {
  1028.         if (isset($capabilities[$capability])) {
  1029.                 return $capabilities[$capability];
  1030.         } else {
  1031.                 return false;
  1032.         }
  1033.     }
  1034.     return $capabilities;
  1035. }
  1036.  
  1037. /**
  1038.  * Returns the delimeter between mailboxes: INBOX/Test, or INBOX.Test
  1039.  */
  1040. function sqimap_get_delimiter ($imap_stream = false) {
  1041.     global $sqimap_delimiter, $optional_delimiter;
  1042.  
  1043.     /* Use configured delimiter if set */
  1044.     if((!empty($optional_delimiter)) && $optional_delimiter != 'detect') {
  1045.         return $optional_delimiter;
  1046.     }
  1047.  
  1048.     /* Do some caching here */
  1049.     if (!$sqimap_delimiter) {
  1050.         if (sqimap_capability($imap_stream, 'NAMESPACE')
  1051.             /*
  1052.              * According to something that I can't find, this is supposed to work on all systems
  1053.              * OS: This won't work in Courier IMAP.
  1054.              * OS: According to rfc2342 response from NAMESPACE command is:
  1055.              * OS: * NAMESPACE (PERSONAL NAMESPACES) (OTHER_USERS NAMESPACE) (SHARED NAMESPACES)
  1056.              * OS: We want to lookup all personal NAMESPACES...
  1057.              */
  1058.          && ($read = sqimap_run_command($imap_stream, 'NAMESPACE', true, $a, $b))
  1059.          && preg_match('/\* NAMESPACE +(\( *\(.+\) *\)|NIL) +(\( *\(.+\) *\)|NIL) +(\( *\(.+\) *\)|NIL)/i', $read[0], $data)
  1060.          && preg_match('/^\( *\((.*)\) *\)/', $data[1], $data2)) {
  1061.             $pn = $data2[1];
  1062.             $pna = explode(')(', $pn);
  1063.             $delnew = array();
  1064.             while (list($k, $v) = each($pna)) {
  1065.                 $lst = explode('"', $v);
  1066.                 if (isset($lst[3])) {
  1067.                     $delnew[$lst[1]] = $lst[3];
  1068.                 } else {
  1069.                     $delnew[$lst[1]] = '';
  1070.                 }
  1071.             }
  1072.             $sqimap_delimiter = array_shift($delnew);
  1073.         } else {
  1074.             fputs ($imap_stream, ". LIST \"INBOX\" \"\"\r\n");
  1075.             $read = sqimap_read_data($imap_stream, '.', true, $a, $b);
  1076.             $quote_position = strpos ($read[0], '"');
  1077.             $sqimap_delimiter = substr ($read[0], $quote_position+1, 1);
  1078.         }
  1079.     }
  1080.     return $sqimap_delimiter;
  1081. }
  1082.  
  1083.  
  1084. /**
  1085.  * Gets the number of messages in the current mailbox.
  1086.  */
  1087. function sqimap_get_num_messages ($imap_stream, $mailbox) {
  1088.     $read_ary = sqimap_run_command ($imap_stream, "EXAMINE \"$mailbox\"", false, $result, $message);
  1089.     for ($i = 0; $i < count($read_ary); $i++) {
  1090.         if (preg_match('/[^ ]+ +([^ ]+) +EXISTS/', $read_ary[$i], $regs)) {
  1091.             return $regs[1];
  1092.         }
  1093.     }
  1094.     return false; //"BUG! Couldn't get number of messages in $mailbox!";
  1095. }
  1096.  
  1097. /**
  1098.  * Parses an address string.
  1099. 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
  1100.  *
  1101.  * @param string $address Generic email address(es) in any format, including
  1102.  *                         possible personal information as well as the
  1103.  *                         actual address (such as "Jose" <[email protected]>
  1104.  *                         or "Jose" <[email protected]>, "Keiko" <[email protected]>)
  1105.  * @param int $max        The most email addresses to parse out of the given string
  1106.  *
  1107.  * @return array An array with one sub-array for each address found in the
  1108.  *                given string.  Each sub-array contains two (?) entries, the
  1109.  *                first containing the actual email address, the second
  1110.  *                containing any personal information that was in the address
  1111.  *                string
  1112.  *
  1113.  */
  1114. function parseAddress($address, $max=0) {
  1115.     $aTokens = array();
  1116.     $aAddress = array();
  1117.     $iCnt = strlen($address);
  1118.     $aSpecials = array('(' ,'<' ,',' ,';' ,':');
  1119.     $aReplace =  array(' (',' <',' ,',' ;',' :');
  1120.     $address = str_replace($aSpecials,$aReplace,$address);
  1121.     $i = 0;
  1122.     while ($i < $iCnt) {
  1123.         $cChar = $address{$i};
  1124.         switch($cChar)
  1125.         {
  1126.         case '<':
  1127.             $iEnd = strpos($address,'>',$i+1);
  1128.             if (!$iEnd) {
  1129.                $sToken = substr($address,$i);
  1130.                $i = $iCnt;
  1131.             } else {
  1132.                $sToken = substr($address,$i,$iEnd - $i +1);
  1133.                $i = $iEnd;
  1134.             }
  1135.             $sToken = str_replace($aReplace, $aSpecials,$sToken);
  1136.             $aTokens[] = $sToken;
  1137.             break;
  1138.         case '"':
  1139.             $iEnd = strpos($address,$cChar,$i+1);
  1140.             if ($iEnd) {
  1141.                 // skip escaped quotes
  1142.                 $prev_char = $address{$iEnd-1};
  1143.                 while ($prev_char === '\\' && substr($address,$iEnd-2,2) !== '\\\\') {
  1144.                     $iEnd = strpos($address,$cChar,$iEnd+1);
  1145.                     if ($iEnd) {
  1146.                         $prev_char = $address{$iEnd-1};
  1147.                     } else {
  1148.                         $prev_char = false;
  1149.                     }
  1150.                 }
  1151.             }
  1152.             if (!$iEnd) {
  1153.                 $sToken = substr($address,$i);
  1154.                 $i = $iCnt;
  1155.             } else {
  1156.                 // also remove the surrounding quotes
  1157.                 $sToken = substr($address,$i+1,$iEnd - $i -1);
  1158.                 $i = $iEnd;
  1159.             }
  1160.             $sToken = str_replace($aReplace, $aSpecials,$sToken);
  1161.             if ($sToken) $aTokens[] = $sToken;
  1162.             break;
  1163.         case '(':
  1164.             $iEnd = strrpos($address,')');
  1165.             if (!$iEnd || $iEnd < $i) {
  1166.                 $sToken = substr($address,$i);
  1167.                 $i = $iCnt;
  1168.             } else {
  1169.                 $sToken = substr($address,$i,$iEnd - $i + 1);
  1170.                 $i = $iEnd;
  1171.             }
  1172.             $sToken = str_replace($aReplace, $aSpecials,$sToken);
  1173.             $aTokens[] = $sToken;
  1174.             break;
  1175.         case ',':
  1176.         case ';':
  1177.         case ';':
  1178.         case ' ':
  1179.             $aTokens[] = $cChar;
  1180.             break;
  1181.         default:
  1182.             $iEnd = strpos($address,' ',$i+1);
  1183.             if ($iEnd) {
  1184.                 $sToken = trim(substr($address,$i,$iEnd - $i));
  1185.                 $i = $iEnd-1;
  1186.             } else {
  1187.                 $sToken = trim(substr($address,$i));
  1188.                 $i = $iCnt;
  1189.             }
  1190.             if ($sToken) $aTokens[] = $sToken;
  1191.         }
  1192.         ++$i;
  1193.     }
  1194.     $sPersonal = $sEmail = $sComment = $sGroup = '';
  1195.     $aStack = $aComment = array();
  1196.     foreach ($aTokens as $sToken) {
  1197.         if ($max && $max == count($aAddress)) {
  1198.             return $aAddress;
  1199.         }
  1200.         $cChar = $sToken{0};
  1201.         switch ($cChar)
  1202.         {
  1203.           case '=':
  1204.           case '"':
  1205.           case ' ':
  1206.             $aStack[] = $sToken;
  1207.             break;
  1208.           case '(':
  1209.             $aComment[] = substr($sToken,1,-1);
  1210.             break;
  1211.           case ';':
  1212.             if ($sGroup) {
  1213.                 $sEmail = trim(implode(' ',$aStack));
  1214.                 $aAddress[] = array($sGroup,$sEmail);
  1215.                 $aStack = $aComment = array();
  1216.                 $sGroup = '';
  1217.                 break;
  1218.             }
  1219.           case ',':
  1220.             if (!$sEmail) {
  1221.                 while (count($aStack) && !$sEmail) {
  1222.                     $sEmail = trim(array_pop($aStack));
  1223.                 }
  1224.             }
  1225.             if (count($aStack)) {
  1226.                 $sPersonal = trim(implode('',$aStack));
  1227.             } else {
  1228.                 $sPersonal = '';
  1229.             }
  1230.             if (!$sPersonal && count($aComment)) {
  1231.                 $sComment = implode(' ',$aComment);
  1232.                 $sPersonal .= $sComment;
  1233.             }
  1234.             $aAddress[] = array($sEmail,$sPersonal);
  1235.             $sPersonal = $sComment = $sEmail = '';
  1236.             $aStack = $aComment = array();
  1237.             break;
  1238.           case ':':
  1239.             $sGroup = implode(' ',$aStack); break;
  1240.             $aStack = array();
  1241.             break;
  1242.           case '<':
  1243.             $sEmail = trim(substr($sToken,1,-1));
  1244.             break;
  1245.           case '>':
  1246.             /* skip */
  1247.             break;
  1248.           default: $aStack[] = $sToken; break;
  1249.         }
  1250.     }
  1251.     /* now do the action again for the last address */
  1252.     if (!$sEmail) {
  1253.         while (count($aStack) && !$sEmail) {
  1254.             $sEmail = trim(array_pop($aStack));
  1255.         }
  1256.     }
  1257.     if (count($aStack)) {
  1258.         $sPersonal = trim(implode('',$aStack));
  1259.     } else {
  1260.         $sPersonal = '';
  1261.     }
  1262.     if (!$sPersonal && count($aComment)) {
  1263.         $sComment = implode(' ',$aComment);
  1264.         $sPersonal .= $sComment;
  1265.     }
  1266.     $aAddress[] = array($sEmail,$sPersonal);
  1267.     return $aAddress;
  1268. }
  1269.  
  1270.  
  1271. /**
  1272.  * Returns the number of unseen messages in this folder.
  1273.  */
  1274. function sqimap_unseen_messages ($imap_stream, $mailbox) {
  1275.     $read_ary = sqimap_run_command ($imap_stream, "STATUS \"$mailbox\" (UNSEEN)", false, $result, $message);
  1276.     $i = 0;
  1277.     $regs = array(false, false);
  1278.     while (isset($read_ary[$i])) {
  1279.         if (preg_match('/UNSEEN\s+([0-9]+)/i', $read_ary[$i], $regs)) {
  1280.             break;
  1281.         }
  1282.         $i++;
  1283.     }
  1284.     return $regs[1];
  1285. }
  1286.  
  1287. /**
  1288.  * Returns the number of unseen/total messages in this folder
  1289.  */
  1290. function sqimap_status_messages ($imap_stream, $mailbox) {
  1291.     $read_ary = sqimap_run_command ($imap_stream, "STATUS \"$mailbox\" (MESSAGES UNSEEN RECENT)", false, $result, $message);
  1292.     $i = 0;
  1293.     $messages = $unseen = $recent = false;
  1294.     $regs = array(false,false);
  1295.     while (isset($read_ary[$i])) {
  1296.         if (preg_match('/UNSEEN\s+([0-9]+)/i', $read_ary[$i], $regs)) {
  1297.             $unseen = $regs[1];
  1298.         }
  1299.         if (preg_match('/MESSAGES\s+([0-9]+)/i', $read_ary[$i], $regs)) {
  1300.             $messages = $regs[1];
  1301.         }
  1302.         if (preg_match('/RECENT\s+([0-9]+)/i', $read_ary[$i], $regs)) {
  1303.             $recent = $regs[1];
  1304.         }
  1305.         $i++;
  1306.     }
  1307.     return array('MESSAGES' => $messages, 'UNSEEN'=>$unseen, 'RECENT' => $recent);
  1308. }
  1309.  
  1310.  
  1311. /**
  1312.  * Saves a message to a given folder -- used for saving sent messages
  1313.  */
  1314. function sqimap_append ($imap_stream, $sent_folder, $length) {
  1315.     fputs ($imap_stream, sqimap_session_id() . " APPEND \"$sent_folder\" (\\Seen) {".$length."}\r\n");
  1316.     $tmp = fgets ($imap_stream, 1024);
  1317.     sqimap_append_checkresponse($tmp, $sent_folder);
  1318. }
  1319.  
  1320. function sqimap_append_done ($imap_stream, $folder='') {
  1321.     fputs ($imap_stream, "\r\n");
  1322.     $tmp = fgets ($imap_stream, 1024);
  1323.     sqimap_append_checkresponse($tmp, $folder);
  1324. }
  1325.  
  1326. function sqimap_append_checkresponse($response, $folder) {
  1327.  
  1328.     if (preg_match("/(.*)(BAD|NO)(.*)$/", $response, $regs)) {
  1329.         global $squirrelmail_language, $color;
  1330.         set_up_language($squirrelmail_language);
  1331.         require_once(SM_PATH . 'functions/display_messages.php');
  1332.  
  1333.         $reason = $regs[3];
  1334.         if ($regs[2] == 'NO') {
  1335.            $string = "<b><font color=\"$color[2]\">\n" .
  1336.                   _("ERROR: Could not append message to") ." $folder." .
  1337.                   "</b><br />\n" .
  1338.                   _("Server responded:") . ' ' .
  1339.                   $reason . "<br />\n";
  1340.            if (preg_match("/(.*)(quota)(.*)$/i", $reason, $regs)) {
  1341.               $string .= _("Solution:") . ' ' .
  1342.             _("Remove unneccessary messages from your folders. Start with your Trash folder.")
  1343.               ."<br />\n";
  1344.            }
  1345.            $string .= "</font>\n";
  1346.            error_box($string,$color);
  1347.         } else {
  1348.            $string = "<b><font color=\"$color[2]\">\n" .
  1349.                   _("ERROR: Bad or malformed request.") .
  1350.                   "</b><br />\n" .
  1351.                   _("Server responded:") . ' ' .
  1352.                   $reason . "</font><br />\n";
  1353.            error_box($string,$color);
  1354.            exit;
  1355.         }
  1356.     }
  1357. }
  1358.  
  1359. function sqimap_get_user_server ($imap_server, $username) {
  1360.    if (substr($imap_server, 0, 4) != "map:") {
  1361.        return $imap_server;
  1362.    }
  1363.    $function = substr($imap_server, 4);
  1364.    return $function($username);
  1365. }
  1366.  
  1367. /**
  1368.  * This is an example that gets IMAP servers from yellowpages (NIS).
  1369.  * you can simple put map:map_yp_alias in your $imap_server_address
  1370.  * in config.php use your own function instead map_yp_alias to map your
  1371.  * LDAP whatever way to find the users IMAP server.
  1372.  */
  1373. function map_yp_alias($username) {
  1374.    $safe_username = escapeshellarg($username);
  1375.    $yp = `ypmatch $safe_username aliases`;
  1376.    return chop(substr($yp, strlen($username)+1));
  1377. }
  1378.  
  1379. /**
  1380.  * Function to display an error related to an IMAP query.
  1381.  * @param string title the caption of the error box
  1382.  * @param string query the query that went wrong
  1383.  * @param string message_title optional message title
  1384.  * @param string message optional error message
  1385.  * @param string $link an optional link to try again
  1386.  * @return void 
  1387.  * @since 1.4.23 and 1.5.0
  1388.  */
  1389. function sqimap_error_box($title, $query = '', $message_title = '', $message = '', $link = '')
  1390. {
  1391.     global $color, $squirrelmail_language;
  1392.  
  1393.     set_up_language($squirrelmail_language);
  1394. //FIXME: NO HTML IN CORE!
  1395.     $string = "<font color=\"$color[2]\"><b>\n" . $title . "</b><br />\n";
  1396.     $cmd = explode(' ',$query);
  1397.     $cmd= strtolower($cmd[0]);
  1398.  
  1399.     if ($query != '' &&  $cmd != 'login')
  1400.         $string .= _("Query:") . ' ' . sm_encode_html_special_chars($query) . '<br />';
  1401.     if ($message_title != '')
  1402.         $string .= $message_title;
  1403.     if ($message != '')
  1404.         $string .= sm_encode_html_special_chars($message);
  1405. //FIXME: NO HTML IN CORE!
  1406.     $string .= "</font><br />\n";
  1407.     if ($link != '')
  1408.         $string .= $link;
  1409.     error_box($string);
  1410. }

Documentation generated on Mon, 13 Jan 2020 04:24:45 +0100 by phpDocumentor 1.4.3