interface/modules/zend_modules/library/Zend/Mail/Protocol/Pop3.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Mail\Protocol;
  11
  12 use Zend\Stdlib\ErrorHandler;
  13
  14 class Pop3
  15 {
  16     /**
  17      * Default timeout in seconds for initiating session
  18      */
  19     const TIMEOUT_CONNECTION = 30;
  20
  21     /**
  22      * saves if server supports top
  23      * @var null|bool
  24      */
  25     public $hasTop = null;
  26
  27     /**
  28      * socket to pop3
  29      * @var null|resource
  30      */
  31     protected $socket;
  32
  33     /**
  34      * greeting timestamp for apop
  35      * @var null|string
  36      */
  37     protected $timestamp;
  38
  39     /**
  40      * Public constructor
  41      *
  42      * @param  string      $host  hostname or IP address of POP3 server, if given connect() is called
  43      * @param  int|null    $port  port of POP3 server, null for default (110 or 995 for ssl)
  44      * @param  bool|string $ssl   use ssl? 'SSL', 'TLS' or false
  45      */
  46     public function __construct($host = '', $port = null, $ssl = false)
  47     {
  48         if ($host) {
  49             $this->connect($host, $port, $ssl);
  50         }
  51     }
  52
  53     /**
  54      * Public destructor
  55      */
  56     public function __destruct()
  57     {
  58         $this->logout();
  59     }
  60
  61     /**
  62      * Open connection to POP3 server
  63      *
  64      * @param  string      $host  hostname or IP address of POP3 server
  65      * @param  int|null    $port  of POP3 server, default is 110 (995 for ssl)
  66      * @param  string|bool $ssl   use 'SSL', 'TLS' or false
  67      * @throws Exception\RuntimeException
  68      * @return string welcome message
  69      */
  70     public function connect($host, $port = null, $ssl = false)
  71     {
  72         $isTls = false;
  73
  74         if ($ssl) {
  75             $ssl = strtolower($ssl);
  76         }
  77
  78         switch ($ssl) {
  79             case 'ssl':
  80                 $host = 'ssl://' . $host;
  81                 if (!$port) {
  82                     $port = 995;
  83                 }
  84                 break;
  85             case 'tls':
  86                 $isTls = true;
  87                 // break intentionally omitted
  88             default:
  89                 if (!$port) {
  90                     $port = 110;
  91                 }
  92         }
  93
  94         ErrorHandler::start();
  95         $this->socket = fsockopen($host, $port, $errno, $errstr, self::TIMEOUT_CONNECTION);
  96         $error = ErrorHandler::stop();
  97         if (!$this->socket) {
  98             throw new Exception\RuntimeException(sprintf(
  99                 'cannot connect to host %s',
 100                 ($error ? sprintf('; error = %s (errno = %d )', $error->getMessage(), $error->getCode()) : '')
 101             ), 0, $error);
 102         }
 103
 104         $welcome = $this->readResponse();
 105
 106         strtok($welcome, '<');
 107         $this->timestamp = strtok('>');
 108         if (!strpos($this->timestamp, '@')) {
 109             $this->timestamp = null;
 110         } else {
 111             $this->timestamp = '<' . $this->timestamp . '>';
 112         }
 113
 114         if ($isTls) {
 115             $this->request('STLS');
 116             $result = stream_socket_enable_crypto($this->socket, true, STREAM_CRYPTO_METHOD_TLS_CLIENT);
 117             if (!$result) {
 118                 throw new Exception\RuntimeException('cannot enable TLS');
 119             }
 120         }
 121
 122         return $welcome;
 123     }
 124
 125     /**
 126      * Send a request
 127      *
 128      * @param string $request your request without newline
 129      * @throws Exception\RuntimeException
 130      */
 131     public function sendRequest($request)
 132     {
 133         ErrorHandler::start();
 134         $result = fputs($this->socket, $request . "\r\n");
 135         $error  = ErrorHandler::stop();
 136         if (!$result) {
 137             throw new Exception\RuntimeException('send failed - connection closed?', 0, $error);
 138         }
 139     }
 140
 141     /**
 142      * read a response
 143      *
 144      * @param  bool $multiline response has multiple lines and should be read until "<nl>.<nl>"
 145      * @throws Exception\RuntimeException
 146      * @return string response
 147      */
 148     public function readResponse($multiline = false)
 149     {
 150         ErrorHandler::start();
 151         $result = fgets($this->socket);
 152         $error  = ErrorHandler::stop();
 153         if (!is_string($result)) {
 154             throw new Exception\RuntimeException('read failed - connection closed?', 0, $error);
 155         }
 156
 157         $result = trim($result);
 158         if (strpos($result, ' ')) {
 159             list($status, $message) = explode(' ', $result, 2);
 160         } else {
 161             $status = $result;
 162             $message = '';
 163         }
 164
 165         if ($status != '+OK') {
 166             throw new Exception\RuntimeException('last request failed');
 167         }
 168
 169         if ($multiline) {
 170             $message = '';
 171             $line = fgets($this->socket);
 172             while ($line && rtrim($line, "\r\n") != '.') {
 173                 if ($line[0] == '.') {
 174                     $line = substr($line, 1);
 175                 }
 176                 $message .= $line;
 177                 $line = fgets($this->socket);
 178             };
 179         }
 180
 181         return $message;
 182     }
 183
 184     /**
 185      * Send request and get response
 186      *
 187      * @see sendRequest()
 188      * @see readResponse()
 189      * @param  string $request    request
 190      * @param  bool   $multiline  multiline response?
 191      * @return string             result from readResponse()
 192      */
 193     public function request($request, $multiline = false)
 194     {
 195         $this->sendRequest($request);
 196         return $this->readResponse($multiline);
 197     }
 198
 199     /**
 200      * End communication with POP3 server (also closes socket)
 201      */
 202     public function logout()
 203     {
 204         if ($this->socket) {
 205             try {
 206                 $this->request('QUIT');
 207             } catch (Exception\ExceptionInterface $e) {
 208                 // ignore error - we're closing the socket anyway
 209             }
 210
 211             fclose($this->socket);
 212             $this->socket = null;
 213         }
 214     }
 215
 216
 217     /**
 218      * Get capabilities from POP3 server
 219      *
 220      * @return array list of capabilities
 221      */
 222     public function capa()
 223     {
 224         $result = $this->request('CAPA', true);
 225         return explode("\n", $result);
 226     }
 227
 228
 229     /**
 230      * Login to POP3 server. Can use APOP
 231      *
 232      * @param  string $user     username
 233      * @param  string $password password
 234      * @param  bool   $tryApop  should APOP be tried?
 235      */
 236     public function login($user, $password, $tryApop = true)
 237     {
 238         if ($tryApop && $this->timestamp) {
 239             try {
 240                 $this->request("APOP $user " . md5($this->timestamp . $password));
 241                 return;
 242             } catch (Exception\ExceptionInterface $e) {
 243                 // ignore
 244             }
 245         }
 246
 247         $this->request("USER $user");
 248         $this->request("PASS $password");
 249     }
 250
 251
 252     /**
 253      * Make STAT call for message count and size sum
 254      *
 255      * @param  int $messages  out parameter with count of messages
 256      * @param  int $octets    out parameter with size in octets of messages
 257      */
 258     public function status(&$messages, &$octets)
 259     {
 260         $messages = 0;
 261         $octets = 0;
 262         $result = $this->request('STAT');
 263
 264         list($messages, $octets) = explode(' ', $result);
 265     }
 266
 267
 268     /**
 269      * Make LIST call for size of message(s)
 270      *
 271      * @param  int|null $msgno number of message, null for all
 272      * @return int|array size of given message or list with array(num => size)
 273      */
 274     public function getList($msgno = null)
 275     {
 276         if ($msgno !== null) {
 277             $result = $this->request("LIST $msgno");
 278
 279             list(, $result) = explode(' ', $result);
 280             return (int) $result;
 281         }
 282
 283         $result = $this->request('LIST', true);
 284         $messages = array();
 285         $line = strtok($result, "\n");
 286         while ($line) {
 287             list($no, $size) = explode(' ', trim($line));
 288             $messages[(int) $no] = (int) $size;
 289             $line = strtok("\n");
 290         }
 291
 292         return $messages;
 293     }
 294
 295
 296     /**
 297      * Make UIDL call for getting a uniqueid
 298      *
 299      * @param  int|null $msgno number of message, null for all
 300      * @return string|array uniqueid of message or list with array(num => uniqueid)
 301      */
 302     public function uniqueid($msgno = null)
 303     {
 304         if ($msgno !== null) {
 305             $result = $this->request("UIDL $msgno");
 306
 307             list(, $result) = explode(' ', $result);
 308             return $result;
 309         }
 310
 311         $result = $this->request('UIDL', true);
 312
 313         $result = explode("\n", $result);
 314         $messages = array();
 315         foreach ($result as $line) {
 316             if (!$line) {
 317                 continue;
 318             }
 319             list($no, $id) = explode(' ', trim($line), 2);
 320             $messages[(int) $no] = $id;
 321         }
 322
 323         return $messages;
 324     }
 325
 326
 327     /**
 328      * Make TOP call for getting headers and maybe some body lines
 329      * This method also sets hasTop - before it it's not known if top is supported
 330      *
 331      * The fallback makes normal RETR call, which retrieves the whole message. Additional
 332      * lines are not removed.
 333      *
 334      * @param  int  $msgno    number of message
 335      * @param  int  $lines    number of wanted body lines (empty line is inserted after header lines)
 336      * @param  bool $fallback fallback with full retrieve if top is not supported
 337      * @throws Exception\RuntimeException
 338      * @throws Exception\ExceptionInterface
 339      * @return string message headers with wanted body lines
 340      */
 341     public function top($msgno, $lines = 0, $fallback = false)
 342     {
 343         if ($this->hasTop === false) {
 344             if ($fallback) {
 345                 return $this->retrieve($msgno);
 346             } else {
 347                 throw new Exception\RuntimeException('top not supported and no fallback wanted');
 348             }
 349         }
 350         $this->hasTop = true;
 351
 352         $lines = (!$lines || $lines < 1) ? 0 : (int) $lines;
 353
 354         try {
 355             $result = $this->request("TOP $msgno $lines", true);
 356         } catch (Exception\ExceptionInterface $e) {
 357             $this->hasTop = false;
 358             if ($fallback) {
 359                 $result = $this->retrieve($msgno);
 360             } else {
 361                 throw $e;
 362             }
 363         }
 364
 365         return $result;
 366     }
 367
 368     /**
 369      * Make a RETR call for retrieving a full message with headers and body
 370      *
 371      * @param  int $msgno  message number
 372      * @return string message
 373      */
 374     public function retrieve($msgno)
 375     {
 376         $result = $this->request("RETR $msgno", true);
 377         return $result;
 378     }
 379
 380     /**
 381      * Make a NOOP call, maybe needed for keeping the server happy
 382      */
 383     public function noop()
 384     {
 385         $this->request('NOOP');
 386     }
 387
 388     /**
 389      * Make a DELE count to remove a message
 390      *
 391      * @param $msgno
 392      */
 393     public function delete($msgno)
 394     {
 395         $this->request("DELE $msgno");
 396     }
 397
 398     /**
 399      * Make RSET call, which rollbacks delete requests
 400      */
 401     public function undelete()
 402     {
 403         $this->request('RSET');
 404     }
 405 }