WordPress.org

Make WordPress Core

Ticket #8051: wp-mail_working.diff

File wp-mail_working.diff, 32.0 KB (added by filosofo, 7 years ago)
  • wp-includes/class-pop3.php

     
    11<?php 
    2 /*~ class.pop3.php 
    3 .---------------------------------------------------------------------------. 
    4 |  Software: PHPMailer - PHP email class                                    | 
    5 |   Version: 2.0.2                                                          | 
    6 |   Contact: via sourceforge.net support pages (also www.codeworxtech.com)  | 
    7 |      Info: http://phpmailer.sourceforge.net                               | 
    8 |   Support: http://sourceforge.net/projects/phpmailer/                     | 
    9 | ------------------------------------------------------------------------- | 
    10 |    Author: Andy Prevost (project admininistrator)                         | 
    11 |    Author: Brent R. Matzelle (original founder)                           | 
    12 | Copyright (c) 2004-2007, Andy Prevost. All Rights Reserved.               | 
    13 | Copyright (c) 2001-2003, Brent R. Matzelle                                | 
    14 | ------------------------------------------------------------------------- | 
    15 |   License: Distributed under the Lesser General Public License (LGPL)     | 
    16 |            http://www.gnu.org/copyleft/lesser.html                        | 
    17 | This program is distributed in the hope that it will be useful - WITHOUT  | 
    18 | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or     | 
    19 | FITNESS FOR A PARTICULAR PURPOSE.                                         | 
    20 | ------------------------------------------------------------------------- | 
    21 | We offer a number of paid services (www.codeworxtech.com):                | 
    22 | - Web Hosting on highly optimized fast and secure servers                 | 
    23 | - Technology Consulting                                                   | 
    24 | - Oursourcing (highly qualified programmers and graphic designers)        | 
    25 '---------------------------------------------------------------------------' 
    26  */ 
    27  
    282/** 
    29  * POP Before SMTP Authentication Class 
     3 * mail_fetch/setup.php 
    304 * 
    31  * Author: Richard Davey (rich@corephp.co.uk) 
    32  * License: LGPL, see PHPMailer License 
     5 * @package SquirrelMail 
    336 * 
    34  * Specifically for PHPMailer to allow POP before SMTP authentication. 
    35  * Does not yet work with APOP - if you have an APOP account, contact me 
    36  * and we can test changes to this script. 
     7 * @copyright (c) 1999-2006 The SquirrelMail Project Team 
    378 * 
    38  * This class is based on the structure of the SMTP class by Chris Ryan 
     9 * @copyright (c) 1999 CDI (cdi@thewebmasters.net) All Rights Reserved 
     10 * Modified by Philippe Mingo 2001 mingo@rotedic.com 
     11 * An RFC 1939 compliant wrapper class for the POP3 protocol. 
    3912 * 
    40  * This class is rfc 1939 compliant and implements all the commands 
    41  * required for POP3 connection, authentication and disconnection. 
     13 * Licensed under the GNU GPL. For full terms see the file COPYING. 
    4214 * 
    43  * @package PHPMailer 
    44  * @author Richard Davey 
     15 * pop3 class 
     16 * 
     17 * $Id$ 
    4518 */ 
    46 class POP3 
    47 { 
    48   /** 
    49    * Default POP3 port 
    50    * @var int 
    51    */ 
    52   var $POP3_PORT = 110; 
    5319 
    54   /** 
    55    * Default Timeout 
    56    * @var int 
    57    */ 
    58   var $POP3_TIMEOUT = 30; 
     20class POP3 { 
     21    var $ERROR      = '';       //  Error string. 
    5922 
    60   /** 
    61    * POP3 Carriage Return + Line Feed 
    62    * @var string 
    63    */ 
    64   var $CRLF = "\r\n"; 
     23    var $TIMEOUT    = 60;       //  Default timeout before giving up on a 
     24                                //  network operation. 
    6525 
    66   /** 
    67    * Displaying Debug warnings? (0 = now, 1+ = yes) 
    68    * @var int 
    69    */ 
    70   var $do_debug = 2; 
     26    var $COUNT      = -1;       //  Mailbox msg count 
    7127 
    72   /** 
    73    * POP3 Mail Server 
    74    * @var string 
    75    */ 
    76   var $host; 
     28    var $BUFFER     = 512;      //  Socket buffer for socket fgets() calls. 
     29                                //  Per RFC 1939 the returned line a POP3 
     30                                //  server can send is 512 bytes. 
    7731 
    78   /** 
    79    * POP3 Port 
    80    * @var int 
    81    */ 
    82   var $port; 
     32    var $FP         = '';       //  The connection to the server's 
     33                                //  file descriptor 
    8334 
    84   /** 
    85    * POP3 Timeout Value 
    86    * @var int 
    87    */ 
    88   var $tval; 
     35    var $MAILSERVER = '';       // Set this to hard code the server name 
    8936 
    90   /** 
    91    * POP3 Username 
    92    * @var string 
    93    */ 
    94   var $username; 
     37    var $DEBUG      = FALSE;    // set to true to echo pop3 
     38                                // commands and responses to error_log 
     39                                // this WILL log passwords! 
    9540 
    96   /** 
    97    * POP3 Password 
    98    * @var string 
    99    */ 
    100   var $password; 
     41    var $BANNER     = '';       //  Holds the banner returned by the 
     42                                //  pop server - used for apop() 
    10143 
    102   /**#@+ 
    103    * @access private 
    104    */ 
    105   var $pop_conn; 
    106   var $connected; 
    107   var $error;     //  Error log array 
    108   /**#@-*/ 
     44    var $ALLOWAPOP  = FALSE;    //  Allow or disallow apop() 
     45                                //  This must be set to true 
     46                                //  manually 
    10947 
    110   /** 
    111    * Constructor, sets the initial values 
    112    * 
    113    * @return POP3 
    114    */ 
    115   function POP3 () 
    116     { 
    117       $this->pop_conn = 0; 
    118       $this->connected = false; 
    119       $this->error = null; 
     48    function POP3 ( $server = '', $timeout = '' ) { 
     49        settype($this->BUFFER,"integer"); 
     50        if( !empty($server) ) { 
     51            // Do not allow programs to alter MAILSERVER 
     52            // if it is already specified. They can get around 
     53            // this if they -really- want to, so don't count on it. 
     54            if(empty($this->MAILSERVER)) 
     55                $this->MAILSERVER = $server; 
     56        } 
     57        if(!empty($timeout)) { 
     58            settype($timeout,"integer"); 
     59            $this->TIMEOUT = $timeout; 
     60            if (!ini_get('safe_mode')) 
     61                set_time_limit($timeout); 
     62        } 
     63        return true; 
    12064    } 
    12165 
    122   /** 
    123    * Combination of public events - connect, login, disconnect 
    124    * 
    125    * @param string $host 
    126    * @param integer $port 
    127    * @param integer $tval 
    128    * @param string $username 
    129    * @param string $password 
    130    */ 
    131   function Authorise ($host, $port = false, $tval = false, $username, $password, $debug_level = 0) 
    132   { 
    133     $this->host = $host; 
    134  
    135     //  If no port value is passed, retrieve it 
    136     if ($port == false) 
    137     { 
    138       $this->port = $this->POP3_PORT; 
     66    function update_timer () { 
     67        if (!ini_get('safe_mode')) 
     68            set_time_limit($this->TIMEOUT); 
     69        return true; 
    13970    } 
    140     else 
    141     { 
    142       $this->port = $port; 
    143     } 
    14471 
    145     //  If no port value is passed, retrieve it 
    146     if ($tval == false) 
    147     { 
    148       $this->tval = $this->POP3_TIMEOUT; 
    149     } 
    150     else 
    151     { 
    152       $this->tval = $tval; 
    153     } 
     72    function connect ($server, $port = 110)  { 
     73        //  Opens a socket to the specified server. Unless overridden, 
     74        //  port defaults to 110. Returns true on success, false on fail 
    15475 
    155     $this->do_debug = $debug_level; 
    156     $this->username = $username; 
    157     $this->password = $password; 
     76        // If MAILSERVER is set, override $server with it's value 
    15877 
    159     //  Refresh the error log 
    160       $this->error = null; 
     78        if (!isset($port) || !$port) {$port = 110;} 
     79        if(!empty($this->MAILSERVER)) 
     80            $server = $this->MAILSERVER; 
    16181 
    162       //  Connect 
    163     $result = $this->Connect($this->host, $this->port, $this->tval); 
     82        if(empty($server)){ 
     83            $this->ERROR = "POP3 connect: " . _("No server specified"); 
     84            unset($this->FP); 
     85            return false; 
     86        } 
    16487 
    165     if ($result) 
    166     { 
    167       $login_result = $this->Login($this->username, $this->password); 
     88        $fp = @fsockopen("$server", $port, $errno, $errstr); 
    16889 
    169       if ($login_result) 
    170       { 
    171         $this->Disconnect(); 
     90        if(!$fp) { 
     91            $this->ERROR = "POP3 connect: " . _("Error ") . "[$errno] [$errstr]"; 
     92            unset($this->FP); 
     93            return false; 
     94        } 
    17295 
     96        socket_set_blocking($fp,-1); 
     97        $this->update_timer(); 
     98        $reply = fgets($fp,$this->BUFFER); 
     99        $reply = $this->strip_clf($reply); 
     100        if($this->DEBUG) 
     101            error_log("POP3 SEND [connect: $server] GOT [$reply]",0); 
     102        if(!$this->is_ok($reply)) { 
     103            $this->ERROR = "POP3 connect: " . _("Error ") . "[$reply]"; 
     104            unset($this->FP); 
     105            return false; 
     106        } 
     107        $this->FP = $fp; 
     108        $this->BANNER = $this->parse_banner($reply); 
    173109        return true; 
    174       } 
     110    } 
    175111 
     112    function user ($user = "") { 
     113        // Sends the USER command, returns true or false 
     114 
     115        if( empty($user) ) { 
     116            $this->ERROR = "POP3 user: " . _("no login ID submitted"); 
     117            return false; 
     118        } elseif(!isset($this->FP)) { 
     119            $this->ERROR = "POP3 user: " . _("connection not established"); 
     120            return false; 
     121        } else { 
     122            $reply = $this->send_cmd("USER $user"); 
     123            if(!$this->is_ok($reply)) { 
     124                $this->ERROR = "POP3 user: " . _("Error ") . "[$reply]"; 
     125                return false; 
     126            } else 
     127                return true; 
     128        } 
    176129    } 
    177130 
    178     //  We need to disconnect regardless if the login succeeded 
    179     $this->Disconnect(); 
     131    function pass ($pass = "")     { 
     132        // Sends the PASS command, returns # of msgs in mailbox, 
     133        // returns false (undef) on Auth failure 
    180134 
    181     return false; 
    182   } 
     135        if(empty($pass)) { 
     136            $this->ERROR = "POP3 pass: " . _("No password submitted"); 
     137            return false; 
     138        } elseif(!isset($this->FP)) { 
     139            $this->ERROR = "POP3 pass: " . _("connection not established"); 
     140            return false; 
     141        } else { 
     142            $reply = $this->send_cmd("PASS $pass"); 
     143            if(!$this->is_ok($reply)) { 
     144                $this->ERROR = "POP3 pass: " . _("Authentication failed") . " [$reply]"; 
     145                $this->quit(); 
     146                return false; 
     147            } else { 
     148                //  Auth successful. 
     149                $count = $this->last("count"); 
     150                $this->COUNT = $count; 
     151                return $count; 
     152            } 
     153        } 
     154    } 
    183155 
    184   /** 
    185    * Connect to the POP3 server 
    186    * 
    187    * @param string $host 
    188    * @param integer $port 
    189    * @param integer $tval 
    190    * @return boolean 
    191    */ 
    192   function Connect ($host, $port = false, $tval = 30) 
    193     { 
    194     //  Are we already connected? 
    195     if ($this->connected) 
    196     { 
    197       return true; 
     156    function apop ($login,$pass) { 
     157        //  Attempts an APOP login. If this fails, it'll 
     158        //  try a standard login. YOUR SERVER MUST SUPPORT 
     159        //  THE USE OF THE APOP COMMAND! 
     160        //  (apop is optional per rfc1939) 
     161 
     162        if(!isset($this->FP)) { 
     163            $this->ERROR = "POP3 apop: " . _("No connection to server"); 
     164            return false; 
     165        } elseif(!$this->ALLOWAPOP) { 
     166            $retVal = $this->login($login,$pass); 
     167            return $retVal; 
     168        } elseif(empty($login)) { 
     169            $this->ERROR = "POP3 apop: " . _("No login ID submitted"); 
     170            return false; 
     171        } elseif(empty($pass)) { 
     172            $this->ERROR = "POP3 apop: " . _("No password submitted"); 
     173            return false; 
     174        } else { 
     175            $banner = $this->BANNER; 
     176            if( (!$banner) or (empty($banner)) ) { 
     177                $this->ERROR = "POP3 apop: " . _("No server banner") . ' - ' . _("abort"); 
     178                $retVal = $this->login($login,$pass); 
     179                return $retVal; 
     180            } else { 
     181                $AuthString = $banner; 
     182                $AuthString .= $pass; 
     183                $APOPString = md5($AuthString); 
     184                $cmd = "APOP $login $APOPString"; 
     185                $reply = $this->send_cmd($cmd); 
     186                if(!$this->is_ok($reply)) { 
     187                    $this->ERROR = "POP3 apop: " . _("apop authentication failed") . ' - ' . _("abort"); 
     188                    $retVal = $this->login($login,$pass); 
     189                    return $retVal; 
     190                } else { 
     191                    //  Auth successful. 
     192                    $count = $this->last("count"); 
     193                    $this->COUNT = $count; 
     194                    return $count; 
     195                } 
     196            } 
     197        } 
    198198    } 
    199199 
    200     /* 
    201       On Windows this will raise a PHP Warning error if the hostname doesn't exist. 
    202       Rather than supress it with @fsockopen, let's capture it cleanly instead 
    203     */ 
     200    function login ($login = "", $pass = "") { 
     201        // Sends both user and pass. Returns # of msgs in mailbox or 
     202        // false on failure (or -1, if the error occurs while getting 
     203        // the number of messages.) 
    204204 
    205     set_error_handler(array(&$this, 'catchWarning')); 
     205        if( !isset($this->FP) ) { 
     206            $this->ERROR = "POP3 login: " . _("No connection to server"); 
     207            return false; 
     208        } else { 
     209            $fp = $this->FP; 
     210            if( !$this->user( $login ) ) { 
     211                //  Preserve the error generated by user() 
     212                return false; 
     213            } else { 
     214                $count = $this->pass($pass); 
     215                if( (!$count) || ($count == -1) ) { 
     216                    //  Preserve the error generated by last() and pass() 
     217                    return false; 
     218                } else 
     219                    return $count; 
     220            } 
     221        } 
     222    } 
    206223 
    207     //  Connect to the POP3 server 
    208     $this->pop_conn = fsockopen($host,    //  POP3 Host 
    209                   $port,    //  Port # 
    210                   $errno,   //  Error Number 
    211                   $errstr,  //  Error Message 
    212                   $tval);   //  Timeout (seconds) 
     224    function top ($msgNum, $numLines = "0") { 
     225        //  Gets the header and first $numLines of the msg body 
     226        //  returns data in an array with each returned line being 
     227        //  an array element. If $numLines is empty, returns 
     228        //  only the header information, and none of the body. 
    213229 
    214     //  Restore the error handler 
    215     restore_error_handler(); 
     230        if(!isset($this->FP)) { 
     231            $this->ERROR = "POP3 top: " . _("No connection to server"); 
     232            return false; 
     233        } 
     234        $this->update_timer(); 
    216235 
    217     //  Does the Error Log now contain anything? 
    218     if ($this->error && $this->do_debug >= 1) 
    219     { 
    220         $this->displayErrors(); 
     236        $fp = $this->FP; 
     237        $buffer = $this->BUFFER; 
     238        $cmd = "TOP $msgNum $numLines"; 
     239        fwrite($fp, "TOP $msgNum $numLines\r\n"); 
     240        $reply = fgets($fp, $buffer); 
     241        $reply = $this->strip_clf($reply); 
     242        if($this->DEBUG) { 
     243            @error_log("POP3 SEND [$cmd] GOT [$reply]",0); 
     244        } 
     245        if(!$this->is_ok($reply)) 
     246        { 
     247            $this->ERROR = "POP3 top: " . _("Error ") . "[$reply]"; 
     248            return false; 
     249        } 
     250 
     251        $count = 0; 
     252        $MsgArray = array(); 
     253 
     254        $line = fgets($fp,$buffer); 
     255        while ( !ereg("^\.\r\n",$line)) 
     256        { 
     257            $MsgArray[$count] = $line; 
     258            $count++; 
     259            $line = fgets($fp,$buffer); 
     260            if(empty($line))    { break; } 
     261        } 
     262 
     263        return $MsgArray; 
    221264    } 
    222265 
    223     //  Did we connect? 
    224       if ($this->pop_conn == false) 
    225       { 
    226         //  It would appear not... 
    227         $this->error = array( 
    228           'error' => "Failed to connect to server $host on port $port", 
    229           'errno' => $errno, 
    230           'errstr' => $errstr 
    231         ); 
     266    function pop_list ($msgNum = "") { 
     267        //  If called with an argument, returns that msgs' size in octets 
     268        //  No argument returns an associative array of undeleted 
     269        //  msg numbers and their sizes in octets 
    232270 
    233         if ($this->do_debug >= 1) 
     271        if(!isset($this->FP)) 
    234272        { 
    235           $this->displayErrors(); 
     273            $this->ERROR = "POP3 pop_list: " . _("No connection to server"); 
     274            return false; 
    236275        } 
     276        $fp = $this->FP; 
     277        $Total = $this->COUNT; 
     278        if( (!$Total) or ($Total == -1) ) 
     279        { 
     280            return false; 
     281        } 
     282        if($Total == 0) 
     283        { 
     284            return array("0","0"); 
     285            // return -1;   // mailbox empty 
     286        } 
    237287 
    238         return false; 
    239       } 
     288        $this->update_timer(); 
    240289 
    241       //  Increase the stream time-out 
     290        if(!empty($msgNum)) 
     291        { 
     292            $cmd = "LIST $msgNum"; 
     293            fwrite($fp,"$cmd\r\n"); 
     294            $reply = fgets($fp,$this->BUFFER); 
     295            $reply = $this->strip_clf($reply); 
     296            if($this->DEBUG) { 
     297                @error_log("POP3 SEND [$cmd] GOT [$reply]",0); 
     298            } 
     299            if(!$this->is_ok($reply)) 
     300            { 
     301                $this->ERROR = "POP3 pop_list: " . _("Error ") . "[$reply]"; 
     302                return false; 
     303            } 
     304            list($junk,$num,$size) = preg_split('/\s+/',$reply); 
     305            return $size; 
     306        } 
     307        $cmd = "LIST"; 
     308        $reply = $this->send_cmd($cmd); 
     309        if(!$this->is_ok($reply)) 
     310        { 
     311            $reply = $this->strip_clf($reply); 
     312            $this->ERROR = "POP3 pop_list: " . _("Error ") .  "[$reply]"; 
     313            return false; 
     314        } 
     315        $MsgArray = array(); 
     316        $MsgArray[0] = $Total; 
     317        for($msgC=1;$msgC <= $Total; $msgC++) 
     318        { 
     319            if($msgC > $Total) { break; } 
     320            $line = fgets($fp,$this->BUFFER); 
     321            $line = $this->strip_clf($line); 
     322            if(ereg("^\.",$line)) 
     323            { 
     324                $this->ERROR = "POP3 pop_list: " . _("Premature end of list"); 
     325                return false; 
     326            } 
     327            list($thisMsg,$msgSize) = preg_split('/\s+/',$line); 
     328            settype($thisMsg,"integer"); 
     329            if($thisMsg != $msgC) 
     330            { 
     331                $MsgArray[$msgC] = "deleted"; 
     332            } 
     333            else 
     334            { 
     335                $MsgArray[$msgC] = $msgSize; 
     336            } 
     337        } 
     338        return $MsgArray; 
     339    } 
    242340 
    243       //  Check for PHP 4.3.0 or later 
    244       if (version_compare(phpversion(), '4.3.0', 'ge')) 
    245       { 
    246         stream_set_timeout($this->pop_conn, $tval, 0); 
    247       } 
    248       else 
    249       { 
    250         //  Does not work on Windows 
    251         if (substr(PHP_OS, 0, 3) !== 'WIN') 
     341    function get ($msgNum) { 
     342        //  Retrieve the specified msg number. Returns an array 
     343        //  where each line of the msg is an array element. 
     344 
     345        if(!isset($this->FP)) 
    252346        { 
    253           socket_set_timeout($this->pop_conn, $tval, 0); 
     347            $this->ERROR = "POP3 get: " . _("No connection to server"); 
     348            return false; 
    254349        } 
    255       } 
    256350 
    257     //  Get the POP3 server response 
    258       $pop3_response = $this->getResponse(); 
     351        $this->update_timer(); 
    259352 
    260       //  Check for the +OK 
    261       if ($this->checkResponse($pop3_response)) 
    262       { 
    263       //  The connection is established and the POP3 server is talking 
    264       $this->connected = true; 
    265         return true; 
    266       } 
     353        $fp = $this->FP; 
     354        $buffer = $this->BUFFER; 
     355        $cmd = "RETR $msgNum"; 
     356        $reply = $this->send_cmd($cmd); 
    267357 
    268     } 
     358        if(!$this->is_ok($reply)) 
     359        { 
     360            $this->ERROR = "POP3 get: " . _("Error ") . "[$reply]"; 
     361            return false; 
     362        } 
    269363 
    270     /** 
    271      * Login to the POP3 server (does not support APOP yet) 
    272      * 
    273      * @param string $username 
    274      * @param string $password 
    275      * @return boolean 
    276      */ 
    277     function Login ($username = '', $password = '') 
    278     { 
    279       if ($this->connected == false) 
    280       { 
    281         $this->error = 'Not connected to POP3 server'; 
     364        $count = 0; 
     365        $MsgArray = array(); 
    282366 
    283         if ($this->do_debug >= 1) 
     367        $line = fgets($fp,$buffer); 
     368        while ( !ereg("^\.\r\n",$line)) 
    284369        { 
    285           $this->displayErrors(); 
     370            if ( $line{0} == '.' ) { $line = substr($line,1); } 
     371            $MsgArray[$count] = $line; 
     372            $count++; 
     373            $line = fgets($fp,$buffer); 
     374            if(empty($line))    { break; } 
    286375        } 
    287       } 
     376        return $MsgArray; 
     377    } 
    288378 
    289       if (empty($username)) 
    290       { 
    291         $username = $this->username; 
    292       } 
     379    function last ( $type = "count" ) { 
     380        //  Returns the highest msg number in the mailbox. 
     381        //  returns -1 on error, 0+ on success, if type != count 
     382        //  results in a popstat() call (2 element array returned) 
    293383 
    294       if (empty($password)) 
    295       { 
    296         $password = $this->password; 
    297       } 
     384        $last = -1; 
     385        if(!isset($this->FP)) 
     386        { 
     387            $this->ERROR = "POP3 last: " . _("No connection to server"); 
     388            return $last; 
     389        } 
    298390 
    299     $pop_username = "USER $username" . $this->CRLF; 
    300     $pop_password = "PASS $password" . $this->CRLF; 
     391        $reply = $this->send_cmd("STAT"); 
     392        if(!$this->is_ok($reply)) 
     393        { 
     394            $this->ERROR = "POP3 last: " . _("Error ") . "[$reply]"; 
     395            return $last; 
     396        } 
    301397 
    302       //  Send the Username 
    303       $this->sendString($pop_username); 
    304       $pop3_response = $this->getResponse(); 
     398        $Vars = preg_split('/\s+/',$reply); 
     399        $count = $Vars[1]; 
     400        $size = $Vars[2]; 
     401        settype($count,"integer"); 
     402        settype($size,"integer"); 
     403        if($type != "count") 
     404        { 
     405            return array($count,$size); 
     406        } 
     407        return $count; 
     408    } 
    305409 
    306       if ($this->checkResponse($pop3_response)) 
    307       { 
    308         //  Send the Password 
    309         $this->sendString($pop_password); 
    310         $pop3_response = $this->getResponse(); 
     410    function reset () { 
     411        //  Resets the status of the remote server. This includes 
     412        //  resetting the status of ALL msgs to not be deleted. 
     413        //  This method automatically closes the connection to the server. 
    311414 
    312         if ($this->checkResponse($pop3_response)) 
     415        if(!isset($this->FP)) 
    313416        { 
    314           return true; 
     417            $this->ERROR = "POP3 reset: " . _("No connection to server"); 
     418            return false; 
    315419        } 
    316         else 
     420        $reply = $this->send_cmd("RSET"); 
     421        if(!$this->is_ok($reply)) 
    317422        { 
    318           return false; 
     423            //  The POP3 RSET command -never- gives a -ERR 
     424            //  response - if it ever does, something truely 
     425            //  wild is going on. 
     426 
     427            $this->ERROR = "POP3 reset: " . _("Error ") . "[$reply]"; 
     428            @error_log("POP3 reset: ERROR [$reply]",0); 
    319429        } 
    320       } 
    321       else 
    322       { 
    323         return false; 
    324       } 
     430        $this->quit(); 
     431        return true; 
    325432    } 
    326433 
    327     /** 
    328      * Disconnect from the POP3 server 
    329      */ 
    330     function Disconnect () 
     434    function send_cmd ( $cmd = "" ) 
    331435    { 
    332       $this->sendString('QUIT'); 
     436        //  Sends a user defined command string to the 
     437        //  POP server and returns the results. Useful for 
     438        //  non-compliant or custom POP servers. 
     439        //  Do NOT includ the \r\n as part of your command 
     440        //  string - it will be appended automatically. 
    333441 
    334       fclose($this->pop_conn); 
     442        //  The return value is a standard fgets() call, which 
     443        //  will read up to $this->BUFFER bytes of data, until it 
     444        //  encounters a new line, or EOF, whichever happens first. 
     445 
     446        //  This method works best if $cmd responds with only 
     447        //  one line of data. 
     448 
     449        if(!isset($this->FP)) 
     450        { 
     451            $this->ERROR = "POP3 send_cmd: " . _("No connection to server"); 
     452            return false; 
     453        } 
     454 
     455        if(empty($cmd)) 
     456        { 
     457            $this->ERROR = "POP3 send_cmd: " . _("Empty command string"); 
     458            return ""; 
     459        } 
     460 
     461        $fp = $this->FP; 
     462        $buffer = $this->BUFFER; 
     463        $this->update_timer(); 
     464        fwrite($fp,"$cmd\r\n"); 
     465        $reply = fgets($fp,$buffer); 
     466        $reply = $this->strip_clf($reply); 
     467        if($this->DEBUG) { @error_log("POP3 SEND [$cmd] GOT [$reply]",0); } 
     468        return $reply; 
    335469    } 
    336470 
    337     /* 
    338       --------------- 
    339       Private Methods 
    340       --------------- 
    341     */ 
     471    function quit() { 
     472        //  Closes the connection to the POP3 server, deleting 
     473        //  any msgs marked as deleted. 
    342474 
    343     /** 
    344      * Get the socket response back. 
    345      * $size is the maximum number of bytes to retrieve 
    346      * 
    347      * @param integer $size 
    348      * @return string 
    349      */ 
    350     function getResponse ($size = 128) 
    351     { 
    352       $pop3_response = fgets($this->pop_conn, $size); 
     475        if(!isset($this->FP)) 
     476        { 
     477            $this->ERROR = "POP3 quit: " . _("connection does not exist"); 
     478            return false; 
     479        } 
     480        $fp = $this->FP; 
     481        $cmd = "QUIT"; 
     482        fwrite($fp,"$cmd\r\n"); 
     483        $reply = fgets($fp,$this->BUFFER); 
     484        $reply = $this->strip_clf($reply); 
     485        if($this->DEBUG) { @error_log("POP3 SEND [$cmd] GOT [$reply]",0); } 
     486        fclose($fp); 
     487        unset($this->FP); 
     488        return true; 
     489    } 
    353490 
    354       return $pop3_response; 
     491    function popstat () { 
     492        //  Returns an array of 2 elements. The number of undeleted 
     493        //  msgs in the mailbox, and the size of the mbox in octets. 
     494 
     495        $PopArray = $this->last("array"); 
     496 
     497        if($PopArray == -1) { return false; } 
     498 
     499        if( (!$PopArray) or (empty($PopArray)) ) 
     500        { 
     501            return false; 
     502        } 
     503        return $PopArray; 
    355504    } 
    356505 
    357     /** 
    358      * Send a string down the open socket connection to the POP3 server 
    359      * 
    360      * @param string $string 
    361      * @return integer 
    362      */ 
    363     function sendString ($string) 
     506    function uidl ($msgNum = "") 
    364507    { 
    365       $bytes_sent = fwrite($this->pop_conn, $string, strlen($string)); 
     508        //  Returns the UIDL of the msg specified. If called with 
     509        //  no arguments, returns an associative array where each 
     510        //  undeleted msg num is a key, and the msg's uidl is the element 
     511        //  Array element 0 will contain the total number of msgs 
    366512 
    367       return $bytes_sent; 
     513        if(!isset($this->FP)) { 
     514            $this->ERROR = "POP3 uidl: " . _("No connection to server"); 
     515            return false; 
     516        } 
    368517 
     518        $fp = $this->FP; 
     519        $buffer = $this->BUFFER; 
     520 
     521        if(!empty($msgNum)) { 
     522            $cmd = "UIDL $msgNum"; 
     523            $reply = $this->send_cmd($cmd); 
     524            if(!$this->is_ok($reply)) 
     525            { 
     526                $this->ERROR = "POP3 uidl: " . _("Error ") . "[$reply]"; 
     527                return false; 
     528            } 
     529            list ($ok,$num,$myUidl) = preg_split('/\s+/',$reply); 
     530            return $myUidl; 
     531        } else { 
     532            $this->update_timer(); 
     533 
     534            $UIDLArray = array(); 
     535            $Total = $this->COUNT; 
     536            $UIDLArray[0] = $Total; 
     537 
     538            if ($Total < 1) 
     539            { 
     540                return $UIDLArray; 
     541            } 
     542            $cmd = "UIDL"; 
     543            fwrite($fp, "UIDL\r\n"); 
     544            $reply = fgets($fp, $buffer); 
     545            $reply = $this->strip_clf($reply); 
     546            if($this->DEBUG) { @error_log("POP3 SEND [$cmd] GOT [$reply]",0); } 
     547            if(!$this->is_ok($reply)) 
     548            { 
     549                $this->ERROR = "POP3 uidl: " . _("Error ") . "[$reply]"; 
     550                return false; 
     551            } 
     552 
     553            $line = ""; 
     554            $count = 1; 
     555            $line = fgets($fp,$buffer); 
     556            while ( !ereg("^\.\r\n",$line)) { 
     557                if(ereg("^\.\r\n",$line)) { 
     558                    break; 
     559                } 
     560                list ($msg,$msgUidl) = preg_split('/\s+/',$line); 
     561                $msgUidl = $this->strip_clf($msgUidl); 
     562                if($count == $msg) { 
     563                    $UIDLArray[$msg] = $msgUidl; 
     564                } 
     565                else 
     566                { 
     567                    $UIDLArray[$count] = 'deleted'; 
     568                } 
     569                $count++; 
     570                $line = fgets($fp,$buffer); 
     571            } 
     572        } 
     573        return $UIDLArray; 
    369574    } 
    370575 
    371     /** 
    372      * Checks the POP3 server response for +OK or -ERR 
    373      * 
    374      * @param string $string 
    375      * @return boolean 
    376      */ 
    377     function checkResponse ($string) 
    378     { 
    379       if (substr($string, 0, 3) !== '+OK') 
    380       { 
    381         $this->error = array( 
    382           'error' => "Server reported an error: $string", 
    383           'errno' => 0, 
    384           'errstr' => '' 
    385         ); 
     576    function delete ($msgNum = "") { 
     577        //  Flags a specified msg as deleted. The msg will not 
     578        //  be deleted until a quit() method is called. 
    386579 
    387         if ($this->do_debug >= 1) 
     580        if(!isset($this->FP)) 
    388581        { 
    389           $this->displayErrors(); 
     582            $this->ERROR = "POP3 delete: " . _("No connection to server"); 
     583            return false; 
    390584        } 
    391  
    392         return false; 
    393       } 
    394       else 
    395       { 
     585        if(empty($msgNum)) 
     586        { 
     587            $this->ERROR = "POP3 delete: " . _("No msg number submitted"); 
     588            return false; 
     589        } 
     590        $reply = $this->send_cmd("DELE $msgNum"); 
     591        if(!$this->is_ok($reply)) 
     592        { 
     593            $this->ERROR = "POP3 delete: " . _("Command failed ") . "[$reply]"; 
     594            return false; 
     595        } 
    396596        return true; 
    397       } 
     597    } 
    398598 
     599    //  ********************************************************* 
     600 
     601    //  The following methods are internal to the class. 
     602 
     603    function is_ok ($cmd = "") { 
     604        //  Return true or false on +OK or -ERR 
     605 
     606        if( empty($cmd) ) 
     607            return false; 
     608        else 
     609            return( ereg ("^\+OK", $cmd ) ); 
    399610    } 
    400611 
    401     /** 
    402      * If debug is enabled, display the error message array 
    403      * 
    404      */ 
    405     function displayErrors () 
    406     { 
    407       echo '<pre>'; 
     612    function strip_clf ($text = "") { 
     613        // Strips \r\n from server responses 
    408614 
    409       foreach ($this->error as $single_error) 
    410     { 
    411         print_r($single_error); 
     615        if(empty($text)) 
     616            return $text; 
     617        else { 
     618            $stripped = str_replace("\r",'',$text); 
     619            $stripped = str_replace("\n",'',$stripped); 
     620            return $stripped; 
     621        } 
    412622    } 
    413623 
    414       echo '</pre>'; 
     624    function parse_banner ( $server_text ) { 
     625        $outside = true; 
     626        $banner = ""; 
     627        $length = strlen($server_text); 
     628        for($count =0; $count < $length; $count++) 
     629        { 
     630            $digit = substr($server_text,$count,1); 
     631            if(!empty($digit))             { 
     632                if( (!$outside) && ($digit != '<') && ($digit != '>') ) 
     633                { 
     634                    $banner .= $digit; 
     635                } 
     636                if ($digit == '<') 
     637                { 
     638                    $outside = false; 
     639                } 
     640                if($digit == '>') 
     641                { 
     642                    $outside = true; 
     643                } 
     644            } 
     645        } 
     646        $banner = $this->strip_clf($banner);    // Just in case 
     647        return "<$banner>"; 
    415648    } 
    416649 
    417   /** 
    418    * Takes over from PHP for the socket warning handler 
    419    * 
    420    * @param integer $errno 
    421    * @param string $errstr 
    422    * @param string $errfile 
    423    * @param integer $errline 
    424    */ 
    425   function catchWarning ($errno, $errstr, $errfile, $errline) 
    426   { 
    427     $this->error[] = array( 
    428       'error' => "Connecting to the POP3 server raised a PHP warning: ", 
    429       'errno' => $errno, 
    430       'errstr' => $errstr 
    431     ); 
    432   } 
    433  
    434   //  End of class 
    435 } 
     650}   // End class 
    436651?> 
  • wp-mail.php

     
    2828if (false === $count) 
    2929        wp_die(wp_specialchars($pop3->ERROR)); 
    3030if (0 == $count) 
    31         echo "<p>There doesn't seem to be any new mail.</p>\n"; // will fall-through to end of for loop 
     31        echo '<p>' . __("There doesn't seem to be any new mail.") . "</p>\n"; // will fall-through to end of for loop 
    3232 
    3333for ($i=1; $i <= $count; $i++) : 
    3434 
     
    185185 
    186186        do_action('publish_phone', $post_ID); 
    187187 
    188         echo "\n<p><b>Author:</b> " . wp_specialchars($post_author) . "</p>"; 
     188        echo "\n<p>" . sprintf(__('<strong>Author:</strong> %s'), wp_specialchars($post_author)) . '</p>'; 
     189        echo "\n<p>" . sprintf(__('<strong>Posted title:</strong> %s'), wp_specialchars($post_title)) . '</p>'; 
    189190        echo "\n<p><b>Posted title:</b> " . wp_specialchars($post_title) . "<br />"; 
    190191 
    191192        if(!$pop3->delete($i)) { 
    192                 echo '<p>Oops '.wp_specialchars($pop3->ERROR).'</p></div>'; 
     193                echo '<p>' . sprintf(__('Oops: %s'), wp_specialchars($pop3->ERROR)) . '</p>'; 
    193194                $pop3->reset(); 
    194195                exit; 
    195196        } else { 
    196                 echo "<p>Mission complete, message <strong>$i</strong> deleted.</p>"; 
     197                echo '<p>' . sprintf(__('Mission complete.  Message <strong>%s</strong> deleted.'), $i) . '</p>'; 
    197198        } 
    198199 
    199200endfor; 
    200201 
    201202$pop3->quit(); 
    202203