← All changes | back/Libraries/Imap2/Roundcube/ImapClient.php +0 -3898 11.0.3 → 11.1.1 View file →

		@@ -1,3898 +1,0 @@
1		-<?php
2		-
3		-/**
4		- * +-----------------------------------------------------------------------+
5		- * | This file is part of the Roundcube Webmail client |
6		- * | |
7		- * | Copyright (C) The Roundcube Dev Team |
8		- * | Copyright (C) Kolab Systems AG |
9		- * | |
10		- * | Licensed under the GNU General Public License version 3 or |
11		- * | any later version with exceptions for skins & plugins. |
12		- * | See the README file for a full license statement. |
13		- * | |
14		- * | PURPOSE: |
15		- * | Provide alternative IMAP library that doesn't rely on the standard |
16		- * | C-Client based version. This allows to function regardless |
17		- * | of whether or not the PHP build it's running on has IMAP |
18		- * | functionality built-in. |
19		- * | |
20		- * | Based on Iloha IMAP Library. See http://ilohamail.org/ for details |
21		- * +-----------------------------------------------------------------------+
22		- * | Author: Aleksander Machniak <[email protected]> |
23		- * | Author: Ryo Chijiiwa <[email protected]> |
24		- * +-----------------------------------------------------------------------+
25		- */
26		-
27		-namespace AcyMailing\Libraries\Imap2\Roundcube;
28		-
29		-/**
30		- * PHP based wrapper class to connect to an IMAP server
31		- *
32		- * @package Framework
33		- * @subpackage Storage
34		- */
35		-class ImapClient
36		-{
37		- public $error;
38		- public $errornum;
39		- public $result;
40		- public $resultcode;
41		- public $selected;
42		- public $data = [];
43		- public $flags = [
44		- 'SEEN' => '\\Seen',
45		- 'DELETED' => '\\Deleted',
46		- 'ANSWERED' => '\\Answered',
47		- 'DRAFT' => '\\Draft',
48		- 'FLAGGED' => '\\Flagged',
49		- 'FORWARDED' => '$Forwarded',
50		- 'MDNSENT' => '$MDNSent',
51		- '*' => '\\*',
52		- ];
53		-
54		- protected $fp;
55		- protected $host;
56		- protected $user;
57		- protected $cmd_tag;
58		- protected $cmd_num = 0;
59		- protected $resourceid;
60		- protected $prefs = [];
61		- protected $logged = false;
62		- protected $capability = [];
63		- protected $capability_readed = false;
64		- protected $debug = false;
65		- protected $debug_handler = false;
66		- protected $rawLastLine;
67		-
68		- const ERROR_OK = 0;
69		- const ERROR_NO = -1;
70		- const ERROR_BAD = -2;
71		- const ERROR_BYE = -3;
72		- const ERROR_UNKNOWN = -4;
73		- const ERROR_COMMAND = -5;
74		- const ERROR_READONLY = -6;
75		-
76		- const COMMAND_NORESPONSE = 1;
77		- const COMMAND_CAPABILITY = 2;
78		- const COMMAND_LASTLINE = 4;
79		- const COMMAND_ANONYMIZED = 8;
80		- const COMMAND_RAW_LASTLINE = 16;
81		-
82		- const DEBUG_LINE_LENGTH = 4098; // 4KB + 2B for \r\n
83		-
84		-
85		- /**
86		- * Send simple (one line) command to the connection stream
87		- *
88		- * @param string $string Command string
89		- * @param bool $endln True if CRLF need to be added at the end of command
90		- * @param bool $anonymized Don't write the given data to log but a placeholder
91		- *
92		- * @param int Number of bytes sent, False on error
93		- */
94		- protected function putLine($string, $endln = true, $anonymized = false)
95		- {
96		- if (!$this->fp) {
97		- return false;
98		- }
99		-
100		- if ($this->debug) {
101		- // anonymize the sent command for logging
102		- $cut = $endln ? 2 : 0;
103		- if ($anonymized && preg_match('/^(A\d+ (?:[A-Z]+ )+)(.+)/', $string, $m)) {
104		- $log = $m[1].sprintf('****** [%d]', strlen($m[2]) - $cut);
105		- } elseif ($anonymized) {
106		- $log = sprintf('****** [%d]', strlen($string) - $cut);
107		- } else {
108		- $log = rtrim($string);
109		- }
110		-
111		- $this->debug('C: '.$log);
112		- }
113		-
114		- if ($endln) {
115		- $string .= "\r\n";
116		- }
117		-
118		- $res = fwrite($this->fp, $string);
119		-
120		- if ($res === false) {
121		- $this->closeSocket();
122		- }
123		-
124		- return $res;
125		- }
126		-
127		- /**
128		- * Send command to the connection stream with Command Continuation
129		- * Requests (RFC3501 7.5) and LITERAL+ (RFC2088) support
130		- *
131		- * @param string $string Command string
132		- * @param bool $endln True if CRLF need to be added at the end of command
133		- * @param bool $anonymized Don't write the given data to log but a placeholder
134		- *
135		- * @return int|bool Number of bytes sent, False on error
136		- */
137		- protected function putLineC($string, $endln = true, $anonymized = false)
138		- {
139		- if (!$this->fp) {
140		- return false;
141		- }
142		-
143		- if ($endln) {
144		- $string .= "\r\n";
145		- }
146		-
147		- $res = 0;
148		- if ($parts = preg_split('/(\{[0-9]+\}\r\n)/m', $string, -1, PREG_SPLIT_DELIM_CAPTURE)) {
149		- for ($i = 0, $cnt = count($parts) ; $i < $cnt ; $i++) {
150		- if (isset($parts[$i + 1]) && preg_match('/^\{([0-9]+)\}\r\n$/', $parts[$i + 1], $matches)) {
151		- // LITERAL+ support
152		- if ($this->prefs['literal+']) {
153		- $parts[$i + 1] = sprintf("{%d+}\r\n", $matches[1]);
154		- }
155		-
156		- $bytes = $this->putLine($parts[$i].$parts[$i + 1], false, $anonymized);
157		- if ($bytes === false) {
158		- return false;
159		- }
160		-
161		- $res += $bytes;
162		-
163		- // don't wait if server supports LITERAL+ capability
164		- if (!$this->prefs['literal+']) {
165		- $line = $this->readLine(1000);
166		- // handle error in command
167		- if ($line[0] != '+') {
168		- return false;
169		- }
170		- }
171		-
172		- $i++;
173		- } else {
174		- $bytes = $this->putLine($parts[$i], false, $anonymized);
175		- if ($bytes === false) {
176		- return false;
177		- }
178		-
179		- $res += $bytes;
180		- }
181		- }
182		- }
183		-
184		- return $res;
185		- }
186		-
187		- /**
188		- * Reads line from the connection stream
189		- *
190		- * @param int $size Buffer size
191		- *
192		- * @return string Line of text response
193		- */
194		- protected function readLine($size = 1024)
195		- {
196		- $line = '';
197		-
198		- if (!$size) {
199		- $size = 1024;
200		- }
201		-
202		- do {
203		- if ($this->eof()) {
204		- return $line ? : null;
205		- }
206		-
207		- $buffer = fgets($this->fp, $size);
208		-
209		- if ($buffer === false) {
210		- $this->closeSocket();
211		- break;
212		- }
213		-
214		- if ($this->debug) {
215		- $this->debug('S: '.rtrim($buffer));
216		- }
217		-
218		- $line .= $buffer;
219		- } while (substr($buffer, -1) != "\n");
220		-
221		- return $line;
222		- }
223		-
224		- /**
225		- * Reads a line of data from the connection stream inluding all
226		- * string continuation literals.
227		- *
228		- * @param int $size Buffer size
229		- *
230		- * @return string Line of text response
231		- */
232		- protected function readFullLine($size = 1024)
233		- {
234		- $line = $this->readLine($size);
235		-
236		- // include all string literels untile the real end of "line"
237		- while (preg_match('/\{([0-9]+)\}\r\n$/', $line, $m)) {
238		- $bytes = $m[1];
239		- $out = '';
240		-
241		- while (strlen($out) < $bytes) {
242		- $out = $this->readBytes($bytes);
243		- if ($out === null) {
244		- break;
245		- }
246		-
247		- $line .= $out;
248		- }
249		-
250		- $line .= $this->readLine($size);
251		- }
252		-
253		- return $line;
254		- }
255		-
256		- /**
257		- * Reads more data from the connection stream when provided
258		- * data contain string literal
259		- *
260		- * @param string $line Response text
261		- * @param bool $escape Enables escaping
262		- *
263		- * @return string Line of text response
264		- */
265		- protected function multLine($line, $escape = false)
266		- {
267		- $line = rtrim($line);
268		- if (preg_match('/\{([0-9]+)\}$/', $line, $m)) {
269		- $out = '';
270		- $str = substr($line, 0, -strlen($m[0]));
271		- $bytes = $m[1];
272		-
273		- while (strlen($out) < $bytes) {
274		- $line = $this->readBytes($bytes);
275		- if ($line === null) {
276		- break;
277		- }
278		-
279		- $out .= $line;
280		- }
281		-
282		- $line = $str.($escape ? $this->escape($out) : $out);
283		- }
284		-
285		- return $line;
286		- }
287		-
288		- /**
289		- * Reads specified number of bytes from the connection stream
290		- *
291		- * @param int $bytes Number of bytes to get
292		- *
293		- * @return string Response text
294		- */
295		- protected function readBytes($bytes)
296		- {
297		- $data = '';
298		- $len = 0;
299		-
300		- while ($len < $bytes && !$this->eof()) {
301		- $d = fread($this->fp, $bytes - $len);
302		- if ($this->debug) {
303		- $this->debug('S: '.$d);
304		- }
305		- $data .= $d;
306		- $data_len = strlen($data);
307		- if ($len == $data_len) {
308		- break; // nothing was read -> exit to avoid apache lockups
309		- }
310		- $len = $data_len;
311		- }
312		-
313		- return $data;
314		- }
315		-
316		- /**
317		- * Reads complete response to the IMAP command
318		- *
319		- * @param array $untagged Will be filled with untagged response lines
320		- *
321		- * @return string Response text
322		- */
323		- protected function readReply(&$untagged = null)
324		- {
325		- do {
326		- $line = trim($this->readLine(1024));
327		- // store untagged response lines
328		- if (!empty($line) && $line[0] == '*') {
329		- $untagged[] = $line;
330		- }
331		- } while (!empty($line) && $line[0] == '*');
332		-
333		- if ($untagged) {
334		- $untagged = implode("\n", $untagged);
335		- }
336		-
337		- return $line;
338		- }
339		-
340		- /**
341		- * Response parser.
342		- *
343		- * @param string $string Response text
344		- * @param string $err_prefix Error message prefix
345		- *
346		- * @return int Response status
347		- */
348		- protected function parseResult($string, $err_prefix = '')
349		- {
350		- if (preg_match('/^[a-z0-9*]+ (OK|NO|BAD|BYE)(.*)$/i', trim($string), $matches)) {
351		- $res = strtoupper($matches[1]);
352		- $str = trim($matches[2]);
353		-
354		- if ($res == 'OK') {
355		- $this->errornum = self::ERROR_OK;
356		- } elseif ($res == 'NO') {
357		- $this->errornum = self::ERROR_NO;
358		- } elseif ($res == 'BAD') {
359		- $this->errornum = self::ERROR_BAD;
360		- } elseif ($res == 'BYE') {
361		- $this->closeSocket();
362		- $this->errornum = self::ERROR_BYE;
363		- }
364		-
365		- if ($str) {
366		- $str = trim($str);
367		- // get response string and code (RFC5530)
368		- if (preg_match("/^\[([a-z-]+)\]/i", $str, $m)) {
369		- $this->resultcode = strtoupper($m[1]);
370		- $str = trim(substr($str, strlen($m[1]) + 2));
371		- } else {
372		- $this->resultcode = null;
373		- // parse response for [APPENDUID 1204196876 3456]
374		- if (preg_match("/^\[APPENDUID [0-9]+ ([0-9]+)\]/i", $str, $m)) {
375		- $this->data['APPENDUID'] = $m[1];
376		- } // parse response for [COPYUID 1204196876 3456:3457 123:124]
377		- elseif (preg_match("/^\[COPYUID [0-9]+ ([0-9,:]+) ([0-9,:]+)\]/i", $str, $m)) {
378		- $this->data['COPYUID'] = [$m[1], $m[2]];
379		- }
380		- }
381		-
382		- $this->result = $str;
383		-
384		- if ($this->errornum != self::ERROR_OK) {
385		- $this->error = $err_prefix ? $err_prefix.$str : $str;
386		- }
387		- }
388		-
389		- return $this->errornum;
390		- }
391		-
392		- return self::ERROR_UNKNOWN;
393		- }
394		-
395		- /**
396		- * Checks connection stream state.
397		- *
398		- * @return bool True if connection is closed
399		- */
400		- protected function eof()
401		- {
402		- if (!is_resource($this->fp)) {
403		- return true;
404		- }
405		-
406		- // If a connection opened by fsockopen() wasn't closed
407		- // by the server, feof() will hang.
408		- $start = microtime(true);
409		-
410		- if (feof($this->fp) ||
411		- ($this->prefs['timeout'] && (microtime(true) - $start > $this->prefs['timeout']))
412		- ) {
413		- $this->closeSocket();
414		-
415		- return true;
416		- }
417		-
418		- return false;
419		- }
420		-
421		- /**
422		- * Closes connection stream.
423		- */
424		- protected function closeSocket()
425		- {
426		- if (!empty($this->fp)) {
427		- @fclose($this->fp);
428		- }
429		- $this->fp = null;
430		- }
431		-
432		- /**
433		- * Error code/message setter.
434		- */
435		- public function setError($code, $msg = '')
436		- {
437		- $this->errornum = $code;
438		- $this->error = $msg;
439		-
440		- return $code;
441		- }
442		-
443		- /**
444		- * Checks response status.
445		- * Checks if command response line starts with specified prefix (or * BYE/BAD)
446		- *
447		- * @param string $string Response text
448		- * @param string $match Prefix to match with (case-sensitive)
449		- * @param bool $error Enables BYE/BAD checking
450		- * @param bool $nonempty Enables empty response checking
451		- *
452		- * @return bool True any check is true or connection is closed.
453		- */
454		- protected function startsWith($string, $match, $error = false, $nonempty = false)
455		- {
456		- if (!$this->fp) {
457		- return true;
458		- }
459		-
460		- if (strncmp($string, $match, strlen($match)) == 0) {
461		- return true;
462		- }
463		-
464		- if ($error && preg_match('/^\* (BYE|BAD) /i', $string, $m)) {
465		- if (strtoupper($m[1]) == 'BYE') {
466		- $this->closeSocket();
467		- }
468		-
469		- return true;
470		- }
471		-
472		- if ($nonempty && !strlen($string)) {
473		- return true;
474		- }
475		-
476		- return false;
477		- }
478		-
479		- /**
480		- * Capabilities checker
481		- */
482		- protected function hasCapability($name)
483		- {
484		- if (empty($this->capability) || $name == '') {
485		- return false;
486		- }
487		-
488		- if (in_array($name, $this->capability)) {
489		- return true;
490		- } elseif (strpos($name, '=')) {
491		- return false;
492		- }
493		-
494		- $result = [];
495		- foreach ($this->capability as $cap) {
496		- $entry = explode('=', $cap);
497		- if ($entry[0] == $name) {
498		- $result[] = $entry[1];
499		- }
500		- }
501		-
502		- return $result ? : false;
503		- }
504		-
505		- /**
506		- * Capabilities checker
507		- *
508		- * @param string $name Capability name
509		- *
510		- * @return mixed Capability values array for key=value pairs, true/false for others
511		- */
512		- public function getCapability($name)
513		- {
514		- $result = $this->hasCapability($name);
515		-
516		- if (!empty($result)) {
517		- return $result;
518		- } elseif ($this->capability_readed) {
519		- return false;
520		- }
521		-
522		- // get capabilities (only once) because initial
523		- // optional CAPABILITY response may differ
524		- $result = $this->execute('CAPABILITY');
525		- if ($result[0] == self::ERROR_OK) {
526		- $this->parseCapability($result[1]);
527		- }
528		-
529		- $this->capability_readed = true;
530		-
531		- return $this->hasCapability($name);
532		- }
533		-
534		- /**
535		- * Clears detected server capabilities
536		- */
537		- public function clearCapability()
538		- {
539		- $this->capability = [];
540		- $this->capability_readed = false;
541		- }
542		-
543		- /**
544		- * Authentication
545		- *
546		- * @return resource|string Connection resource on success, error code on error
547		- */
548		- protected function authenticate(string $user, string $pass)
549		- {
550		- $auth = base64_encode("user=$user\1auth=Bearer $pass\1\1");
551		- $this->putLine($this->nextTag()." AUTHENTICATE XOAUTH2 $auth", true, true);
552		-
553		- $line = trim($this->readReply());
554		- if (!empty($line) && $line[0] == '+') {
555		- // send empty line
556		- $this->putLine('', true, true);
557		- $line = $this->readReply();
558		- }
559		-
560		- $result = $this->parseResult($line);
561		-
562		- if ($result === self::ERROR_OK) {
563		- // optional CAPABILITY response
564		- if ($line && preg_match('/\[CAPABILITY ([^]]+)\]/i', $line, $matches)) {
565		- $this->parseCapability($matches[1], true);
566		- }
567		-
568		- return $this->fp;
569		- }
570		-
571		- return $this->setError($result, "AUTHENTICATE XOAUTH2: $line");
572		- }
573		-
574		- /**
575		- * LOGIN Authentication
576		- *
577		- * @param string $user Username
578		- * @param string $pass Password
579		- *
580		- * @return resource Connection resourse on success, error code on error
581		- */
582		- protected function login($user, $password)
583		- {
584		- // Prevent from sending credentials in plain text when connection is not secure
585		- if ($this->getCapability('LOGINDISABLED')) {
586		- return $this->setError(self::ERROR_BAD, "Login disabled by IMAP server");
587		- }
588		-
589		- [$code, $response] = $this->execute('LOGIN', [
590		- $this->escape($user),
591		- $this->escape($password),
592		- ], self::COMMAND_CAPABILITY | self::COMMAND_ANONYMIZED);
593		-
594		- // re-set capabilities list if untagged CAPABILITY response provided
595		- if (preg_match('/\* CAPABILITY (.+)/i', $response, $matches)) {
596		- $this->parseCapability($matches[1], true);
597		- }
598		-
599		- if ($code == self::ERROR_OK) {
600		- return $this->fp;
601		- }
602		-
603		- return $code;
604		- }
605		-
606		- /**
607		- * Detects hierarchy delimiter
608		- *
609		- * @return string The delimiter
610		- */
611		- public function getHierarchyDelimiter()
612		- {
613		- if (isset($this->prefs['delimiter']) && $this->prefs['delimiter']) {
614		- return $this->prefs['delimiter'];
615		- }
616		-
617		- // try (LIST "" ""), should return delimiter (RFC2060 Sec 6.3.8)
618		- [$code, $response] = $this->execute(
619		- 'LIST',
620		- [$this->escape(''), $this->escape('')]
621		- );
622		-
623		- if ($code == self::ERROR_OK) {
624		- $args = $this->tokenizeResponse($response, 4);
625		- $delimiter = $args[3];
626		-
627		- if (strlen($delimiter) > 0) {
628		- return ($this->prefs['delimiter'] = $delimiter);
629		- }
630		- }
631		- }
632		-
633		- /**
634		- * NAMESPACE handler (RFC 2342)
635		- *
636		- * @return array Namespace data hash (personal, other, shared)
637		- */
638		- public function getNamespace()
639		- {
640		- if (array_key_exists('namespace', $this->prefs)) {
641		- return $this->prefs['namespace'];
642		- }
643		-
644		- if (!$this->getCapability('NAMESPACE')) {
645		- return self::ERROR_BAD;
646		- }
647		-
648		- [$code, $response] = $this->execute('NAMESPACE');
649		-
650		- if ($code == self::ERROR_OK && preg_match('/^\* NAMESPACE /', $response)) {
651		- $response = substr($response, 11);
652		- $data = $this->tokenizeResponse($response);
653		- }
654		-
655		- if (!is_array($data)) {
656		- return $code;
657		- }
658		-
659		- $this->prefs['namespace'] = [
660		- 'personal' => $data[0],
661		- 'other' => $data[1],
662		- 'shared' => $data[2],
663		- ];
664		-
665		- return $this->prefs['namespace'];
666		- }
667		-
668		- /**
669		- * Connects to IMAP server and authenticates.
670		- *
671		- * @param string $host Server hostname or IP
672		- * @param string $user User name
673		- * @param string $password Password
674		- * @param array $options Connection and class options
675		- *
676		- * @return bool True on success, False on failure
677		- */
678		- public function connect($host, $user, $password, $options = [])
679		- {
680		- // configure
681		- $this->set_prefs($options);
682		-
683		- $this->host = $host;
684		- $this->user = $user;
685		- $this->logged = false;
686		- $this->selected = null;
687		-
688		- // check input
689		- if (empty($host)) {
690		- $this->setError(self::ERROR_BAD, "Empty host");
691		-
692		- return false;
693		- }
694		-
695		- if (empty($user)) {
696		- $this->setError(self::ERROR_NO, "Empty user");
697		-
698		- return false;
699		- }
700		-
701		- if (empty($password) && empty($options['gssapi_cn'])) {
702		- $this->setError(self::ERROR_NO, "Empty password");
703		-
704		- return false;
705		- }
706		-
707		- // Connect
708		- if (!$this->_connect($host)) {
709		- return false;
710		- }
711		-
712		- // Send ID info
713		- if (!empty($this->prefs['ident']) && $this->getCapability('ID')) {
714		- $this->data['ID'] = $this->id($this->prefs['ident']);
715		- }
716		-
717		- // pre-login capabilities can be not complete
718		- $this->capability_readed = false;
719		- $result = $this->authenticate($user, $password);
720		-
721		- // Connected and authenticated
722		- if (is_resource($result)) {
723		- if ($this->prefs['force_caps']) {
724		- $this->clearCapability();
725		- }
726		- $this->logged = true;
727		-
728		- return true;
729		- }
730		-
731		- $this->closeConnection();
732		-
733		- return false;
734		- }
735		-
736		- /**
737		- * Connects to IMAP server.
738		- *
739		- * @param string $host Server hostname or IP
740		- *
741		- * @return bool True on success, False on failure
742		- */
743		- protected function _connect($host)
744		- {
745		- // initialize connection
746		- $this->error = '';
747		- $this->errornum = self::ERROR_OK;
748		-
749		- if (!$this->prefs['port']) {
750		- $this->prefs['port'] = 143;
751		- }
752		-
753		- // check for SSL
754		- if ($this->prefs['ssl_mode'] && $this->prefs['ssl_mode'] != 'tls') {
755		- $host = $this->prefs['ssl_mode'].'://'.$host;
756		- }
757		-
758		- if ($this->prefs['timeout'] <= 0) {
759		- $this->prefs['timeout'] = max(0, intval(ini_get('default_socket_timeout')));
760		- }
761		-
762		- if ($this->debug) {
763		- // set connection identifier for debug output
764		- $this->resourceid = strtoupper(substr(md5(microtime().$host.$this->user), 0, 4));
765		-
766		- $_host = ($this->prefs['ssl_mode'] == 'tls' ? 'tls://' : '').$host.':'.$this->prefs['port'];
767		- $this->debug("Connecting to $_host...");
768		- }
769		-
770		- if (!empty($this->prefs['socket_options'])) {
771		- $context = stream_context_create($this->prefs['socket_options']);
772		- $this->fp = stream_socket_client(
773		- $host.':'.$this->prefs['port'],
774		- $errno,
775		- $errstr,
776		- $this->prefs['timeout'],
777		- STREAM_CLIENT_CONNECT,
778		- $context
779		- );
780		- } else {
781		- $this->fp = @fsockopen($host, $this->prefs['port'], $errno, $errstr, $this->prefs['timeout']);
782		- }
783		-
784		- if (!$this->fp) {
785		- $this->setError(
786		- self::ERROR_BAD,
787		- sprintf(
788		- "Could not connect to %s:%d: %s",
789		- $host,
790		- $this->prefs['port'],
791		- $errstr ? : "Unknown reason"
792		- )
793		- );
794		-
795		- return false;
796		- }
797		-
798		- if ($this->prefs['timeout'] > 0) {
799		- stream_set_timeout($this->fp, $this->prefs['timeout']);
800		- }
801		-
802		- $line = trim(fgets($this->fp, 8192));
803		-
804		- if ($this->debug && $line) {
805		- $this->debug('S: '.$line);
806		- }
807		-
808		- // Connected to wrong port or connection error?
809		- if (!preg_match('/^\* (OK|PREAUTH)/i', $line)) {
810		- if ($line) {
811		- $error = sprintf("Wrong startup greeting (%s:%d): %s", $host, $this->prefs['port'], $line);
812		- } else {
813		- $error = sprintf("Empty startup greeting (%s:%d)", $host, $this->prefs['port']);
814		- }
815		-
816		- $this->setError(self::ERROR_BAD, $error);
817		- $this->closeConnection();
818		-
819		- return false;
820		- }
821		-
822		- $this->data['GREETING'] = trim(preg_replace('/\[[^\]]+\]\s*/', '', $line));
823		-
824		- // RFC3501 [7.1] optional CAPABILITY response
825		- if (preg_match('/\[CAPABILITY ([^]]+)\]/i', $line, $matches)) {
826		- $this->parseCapability($matches[1], true);
827		- }
828		-
829		- // TLS connection
830		- if ($this->prefs['ssl_mode'] == 'tls' && $this->getCapability('STARTTLS')) {
831		- $res = $this->execute('STARTTLS');
832		-
833		- if ($res[0] != self::ERROR_OK) {
834		- $this->closeConnection();
835		-
836		- return false;
837		- }
838		-
839		- if (isset($this->prefs['socket_options']['ssl']['crypto_method'])) {
840		- $crypto_method = $this->prefs['socket_options']['ssl']['crypto_method'];
841		- } else {
842		- // There is no flag to enable all TLS methods. Net_SMTP
843		- // handles enabling TLS similarly.
844		- $crypto_method = STREAM_CRYPTO_METHOD_TLS_CLIENT
845		- | @STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT
846		- | @STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT;
847		- }
848		-
849		- if (!stream_socket_enable_crypto($this->fp, true, $crypto_method)) {
850		- $this->setError(self::ERROR_BAD, "Unable to negotiate TLS");
851		- $this->closeConnection();
852		-
853		- return false;
854		- }
855		-
856		- // Now we're secure, capabilities need to be reread
857		- $this->clearCapability();
858		- }
859		-
860		- return true;
861		- }
862		-
863		- /**
864		- * Initializes environment
865		- */
866		- protected function set_prefs($prefs)
867		- {
868		- // set preferences
869		- if (is_array($prefs)) {
870		- $this->prefs = $prefs;
871		- }
872		-
873		- // set auth method
874		- if (!empty($this->prefs['auth_type'])) {
875		- $this->prefs['auth_type'] = strtoupper($this->prefs['auth_type']);
876		- } else {
877		- $this->prefs['auth_type'] = 'CHECK';
878		- }
879		-
880		- // disabled capabilities
881		- if (!empty($this->prefs['disabled_caps'])) {
882		- $this->prefs['disabled_caps'] = array_map('strtoupper', (array)$this->prefs['disabled_caps']);
883		- }
884		-
885		- // additional message flags
886		- if (!empty($this->prefs['message_flags'])) {
887		- $this->flags = array_merge($this->flags, $this->prefs['message_flags']);
888		- unset($this->prefs['message_flags']);
889		- }
890		- }
891		-
892		- /**
893		- * Checks connection status
894		- *
895		- * @return bool True if connection is active and user is logged in, False otherwise.
896		- */
897		- public function connected()
898		- {
899		- return $this->fp && $this->logged;
900		- }
901		-
902		- /**
903		- * Closes connection with logout.
904		- */
905		- public function closeConnection()
906		- {
907		- if ($this->logged && $this->putLine($this->nextTag().' LOGOUT')) {
908		- $this->readReply();
909		- }
910		-
911		- $this->closeSocket();
912		- }
913		-
914		- /**
915		- * Executes SELECT command (if mailbox is already not in selected state)
916		- *
917		- * @param string $mailbox Mailbox name
918		- * @param array $qresync_data QRESYNC data (RFC5162)
919		- *
920		- * @return boolean True on success, false on error
921		- */
922		- public function select($mailbox, $qresync_data = null)
923		- {
924		- if (!strlen($mailbox)) {
925		- return false;
926		- }
927		-
928		- if ($this->selected === $mailbox) {
929		- return true;
930		- }
931		-
932		- $params = [$this->escape($mailbox)];
933		-
934		- // QRESYNC data items
935		- // 0. the last known UIDVALIDITY,
936		- // 1. the last known modification sequence,
937		- // 2. the optional set of known UIDs, and
938		- // 3. an optional parenthesized list of known sequence ranges and their
939		- // corresponding UIDs.
940		- if (!empty($qresync_data)) {
941		- if (!empty($qresync_data[2])) {
942		- $qresync_data[2] = self::compressMessageSet($qresync_data[2]);
943		- }
944		-
945		- $params[] = ['QRESYNC', $qresync_data];
946		- }
947		-
948		- [$code, $response] = $this->execute('SELECT', $params);
949		-
950		- if ($code == self::ERROR_OK) {
951		- $this->clear_mailbox_cache();
952		-
953		- $response = explode("\r\n", $response);
954		- foreach ($response as $line) {
955		- if (preg_match('/^\* OK \[/i', $line)) {
956		- $pos = strcspn($line, ' ]', 6);
957		- $token = strtoupper(substr($line, 6, $pos));
958		- $pos += 7;
959		-
960		- switch ($token) {
961		- case 'UIDNEXT':
962		- case 'UIDVALIDITY':
963		- case 'UNSEEN':
964		- if ($len = strspn($line, '0123456789', $pos)) {
965		- $this->data[$token] = (int)substr($line, $pos, $len);
966		- }
967		- break;
968		-
969		- case 'HIGHESTMODSEQ':
970		- if ($len = strspn($line, '0123456789', $pos)) {
971		- $this->data[$token] = (string)substr($line, $pos, $len);
972		- }
973		- break;
974		-
975		- case 'NOMODSEQ':
976		- $this->data[$token] = true;
977		- break;
978		-
979		- case 'PERMANENTFLAGS':
980		- $start = strpos($line, '(', $pos);
981		- $end = strrpos($line, ')');
982		- if ($start && $end) {
983		- $flags = substr($line, $start + 1, $end - $start - 1);
984		- $this->data[$token] = explode(' ', $flags);
985		- }
986		- break;
987		- }
988		- } elseif (preg_match('/^\* ([0-9]+) (EXISTS|RECENT|FETCH)/i', $line, $match)) {
989		- $token = strtoupper($match[2]);
990		- switch ($token) {
991		- case 'EXISTS':
992		- case 'RECENT':
993		- $this->data[$token] = (int)$match[1];
994		- break;
995		-
996		- case 'FETCH':
997		- // QRESYNC FETCH response (RFC5162)
998		- $line = substr($line, strlen($match[0]));
999		- $fetch_data = $this->tokenizeResponse($line, 1);
1000		- $data = ['id' => $match[1]];
1001		-
1002		- for ($i = 0, $size = count($fetch_data) ; $i < $size ; $i += 2) {
1003		- $data[strtolower($fetch_data[$i])] = $fetch_data[$i + 1];
1004		- }
1005		-
1006		- $this->data['QRESYNC'][$data['uid']] = $data;
1007		- break;
1008		- }
1009		- } // QRESYNC VANISHED response (RFC5162)
1010		- elseif (preg_match('/^\* VANISHED [()EARLIER]*/i', $line, $match)) {
1011		- $line = substr($line, strlen($match[0]));
1012		- $v_data = $this->tokenizeResponse($line, 1);
1013		-
1014		- $this->data['VANISHED'] = $v_data;
1015		- }
1016		- }
1017		-
1018		- $this->data['READ-WRITE'] = $this->resultcode != 'READ-ONLY';
1019		- $this->selected = $mailbox;
1020		-
1021		- return true;
1022		- }
1023		-
1024		- return false;
1025		- }
1026		-
1027		- /**
1028		- * Executes STATUS command
1029		- *
1030		- * @param string $mailbox Mailbox name
1031		- * @param array $items Additional requested item names. By default
1032		- * MESSAGES and UNSEEN are requested. Other defined
1033		- * in RFC3501: UIDNEXT, UIDVALIDITY, RECENT
1034		- *
1035		- * @return array Status item-value hash
1036		- * @since 0.5-beta
1037		- */
1038		- public function status($mailbox, $items = [])
1039		- {
1040		- if (!strlen($mailbox)) {
1041		- return false;
1042		- }
1043		-
1044		- if (!in_array('MESSAGES', $items)) {
1045		- $items[] = 'MESSAGES';
1046		- }
1047		- if (!in_array('UNSEEN', $items)) {
1048		- $items[] = 'UNSEEN';
1049		- }
1050		-
1051		- [$code, $response] = $this->execute(
1052		- 'STATUS',
1053		- [$this->escape($mailbox), '('.implode(' ', $items).')'],
1054		- 0,
1055		- '/^\* STATUS /i'
1056		- );
1057		-
1058		- if ($code == self::ERROR_OK && $response) {
1059		- $result = [];
1060		- $response = substr($response, 9); // remove prefix "* STATUS "
1061		-
1062		- [$mbox, $items] = $this->tokenizeResponse($response, 2);
1063		-
1064		- // Fix for #1487859. Some buggy server returns not quoted
1065		- // folder name with spaces. Let's try to handle this situation
1066		- if (!is_array($items) && ($pos = strpos($response, '(')) !== false) {
1067		- $response = substr($response, $pos);
1068		- $items = $this->tokenizeResponse($response, 1);
1069		- }
1070		-
1071		- if (!is_array($items)) {
1072		- return $result;
1073		- }
1074		-
1075		- for ($i = 0, $len = count($items) ; $i < $len ; $i += 2) {
1076		- $result[$items[$i]] = $items[$i + 1];
1077		- }
1078		-
1079		- $this->data['STATUS:'.$mailbox] = $result;
1080		-
1081		- return $result;
1082		- }
1083		-
1084		- return false;
1085		- }
1086		-
1087		- /**
1088		- * Executes EXPUNGE command
1089		- *
1090		- * @param string $mailbox Mailbox name
1091		- * @param string|array $messages Message UIDs to expunge
1092		- *
1093		- * @return boolean True on success, False on error
1094		- */
1095		- public function expunge($mailbox, $messages = null)
1096		- {
1097		- if (!$this->select($mailbox)) {
1098		- return false;
1099		- }
1100		-
1101		- if (!$this->data['READ-WRITE']) {
1102		- $this->setError(self::ERROR_READONLY, "Mailbox is read-only");
1103		-
1104		- return false;
1105		- }
1106		-
1107		- // Clear internal status cache
1108		- $this->clear_status_cache($mailbox);
1109		-
1110		- if (!empty($messages) && $messages != '*' && $this->hasCapability('UIDPLUS')) {
1111		- $messages = self::compressMessageSet($messages);
1112		- $result = $this->execute('UID EXPUNGE', [$messages], self::COMMAND_NORESPONSE);
1113		- } else {
1114		- $result = $this->execute('EXPUNGE', null, self::COMMAND_NORESPONSE);
1115		- }
1116		-
1117		- if ($result == self::ERROR_OK) {
1118		- $this->selected = null; // state has changed, need to reselect
1119		-
1120		- return true;
1121		- }
1122		-
1123		- return false;
1124		- }
1125		-
1126		- /**
1127		- * Executes CLOSE command
1128		- *
1129		- * @return boolean True on success, False on error
1130		- * @since 0.5
1131		- */
1132		- public function close()
1133		- {
1134		- $result = $this->execute('CLOSE', null, self::COMMAND_NORESPONSE);
1135		-
1136		- if ($result == self::ERROR_OK) {
1137		- $this->selected = null;
1138		-
1139		- return true;
1140		- }
1141		-
1142		- return false;
1143		- }
1144		-
1145		- /**
1146		- * Folder subscription (SUBSCRIBE)
1147		- *
1148		- * @param string $mailbox Mailbox name
1149		- *
1150		- * @return boolean True on success, False on error
1151		- */
1152		- public function subscribe($mailbox)
1153		- {
1154		- $result = $this->execute(
1155		- 'SUBSCRIBE',
1156		- [$this->escape($mailbox)],
1157		- self::COMMAND_NORESPONSE
1158		- );
1159		-
1160		- return $result == self::ERROR_OK;
1161		- }
1162		-
1163		- /**
1164		- * Folder unsubscription (UNSUBSCRIBE)
1165		- *
1166		- * @param string $mailbox Mailbox name
1167		- *
1168		- * @return boolean True on success, False on error
1169		- */
1170		- public function unsubscribe($mailbox)
1171		- {
1172		- $result = $this->execute(
1173		- 'UNSUBSCRIBE',
1174		- [$this->escape($mailbox)],
1175		- self::COMMAND_NORESPONSE
1176		- );
1177		-
1178		- return $result == self::ERROR_OK;
1179		- }
1180		-
1181		- /**
1182		- * Folder creation (CREATE)
1183		- *
1184		- * @param string $mailbox Mailbox name
1185		- * @param array $types Optional folder types (RFC 6154)
1186		- *
1187		- * @return bool True on success, False on error
1188		- */
1189		- public function createFolder($mailbox, $types = null)
1190		- {
1191		- $args = [$this->escape($mailbox)];
1192		-
1193		- // RFC 6154: CREATE-SPECIAL-USE
1194		- if (!empty($types) && $this->getCapability('CREATE-SPECIAL-USE')) {
1195		- $args[] = '(USE ('.implode(' ', $types).'))';
1196		- }
1197		-
1198		- $result = $this->execute('CREATE', $args, self::COMMAND_RAW_LASTLINE);
1199		-
1200		- $this->rawLastLine = $result[1];
1201		-
1202		- return $result[0] == self::ERROR_OK;
1203		- }
1204		-
1205		- /**
1206		- * Folder renaming (RENAME)
1207		- *
1208		- * @param string $mailbox Mailbox name
1209		- *
1210		- * @return bool True on success, False on error
1211		- */
1212		- public function renameFolder($from, $to)
1213		- {
1214		- $result = $this->execute(
1215		- 'RENAME',
1216		- [$this->escape($from), $this->escape($to)],
1217		- self::COMMAND_NORESPONSE
1218		- );
1219		-
1220		- return $result == self::ERROR_OK;
1221		- }
1222		-
1223		- /**
1224		- * Executes DELETE command
1225		- *
1226		- * @param string $mailbox Mailbox name
1227		- *
1228		- * @return boolean True on success, False on error
1229		- */
1230		- public function deleteFolder($mailbox)
1231		- {
1232		- $result = $this->execute(
1233		- 'DELETE',
1234		- [$this->escape($mailbox)],
1235		- self::COMMAND_NORESPONSE
1236		- );
1237		-
1238		- return $result == self::ERROR_OK;
1239		- }
1240		-
1241		- /**
1242		- * Removes all messages in a folder
1243		- *
1244		- * @param string $mailbox Mailbox name
1245		- *
1246		- * @return boolean True on success, False on error
1247		- */
1248		- public function clearFolder($mailbox)
1249		- {
1250		- if ($this->countMessages($mailbox) > 0) {
1251		- $res = $this->flag($mailbox, '1:*', 'DELETED');
1252		- }
1253		-
1254		- if ($res) {
1255		- if ($this->selected === $mailbox) {
1256		- $res = $this->close();
1257		- } else {
1258		- $res = $this->expunge($mailbox);
1259		- }
1260		- }
1261		-
1262		- return $res;
1263		- }
1264		-
1265		- /**
1266		- * Returns list of mailboxes
1267		- *
1268		- * @param string $ref Reference name
1269		- * @param string $mailbox Mailbox name
1270		- * @param array $return_opts (see self::_listMailboxes)
1271		- * @param array $select_opts (see self::_listMailboxes)
1272		- *
1273		- * @return array|bool List of mailboxes or hash of options if STATUS/MYROGHTS response
1274		- * is requested, False on error.
1275		- */
1276		- public function listMailboxes($ref, $mailbox, $return_opts = [], $select_opts = [])
1277		- {
1278		- return $this->_listMailboxes($ref, $mailbox, false, $return_opts, $select_opts);
1279		- }
1280		-
1281		- /**
1282		- * Returns list of subscribed mailboxes
1283		- *
1284		- * @param string $ref Reference name
1285		- * @param string $mailbox Mailbox name
1286		- * @param array $return_opts (see self::_listMailboxes)
1287		- *
1288		- * @return array|bool List of mailboxes or hash of options if STATUS/MYROGHTS response
1289		- * is requested, False on error.
1290		- */
1291		- public function listSubscribed($ref, $mailbox, $return_opts = [])
1292		- {
1293		- return $this->_listMailboxes($ref, $mailbox, true, $return_opts, null);
1294		- }
1295		-
1296		- /**
1297		- * IMAP LIST/LSUB command
1298		- *
1299		- * @param string $ref Reference name
1300		- * @param string $mailbox Mailbox name
1301		- * @param bool $subscribed Enables returning subscribed mailboxes only
1302		- * @param array $return_opts List of RETURN options (RFC5819: LIST-STATUS, RFC5258: LIST-EXTENDED)
1303		- * Possible: MESSAGES, RECENT, UIDNEXT, UIDVALIDITY, UNSEEN,
1304		- * MYRIGHTS, SUBSCRIBED, CHILDREN
1305		- * @param array $select_opts List of selection options (RFC5258: LIST-EXTENDED)
1306		- * Possible: SUBSCRIBED, RECURSIVEMATCH, REMOTE,
1307		- * SPECIAL-USE (RFC6154)
1308		- *
1309		- * @return array|bool List of mailboxes or hash of options if STATUS/MYROGHTS response
1310		- * is requested, False on error.
1311		- */
1312		- protected function _listMailboxes(
1313		- $ref,
1314		- $mailbox,
1315		- $subscribed = false,
1316		- $return_opts = [],
1317		- $select_opts = []
1318		- ) {
1319		- if (!strlen($mailbox)) {
1320		- $mailbox = '*';
1321		- }
1322		-
1323		- $args = [];
1324		- $rets = [];
1325		-
1326		- if (!empty($select_opts) && $this->getCapability('LIST-EXTENDED')) {
1327		- $select_opts = (array)$select_opts;
1328		-
1329		- $args[] = '('.implode(' ', $select_opts).')';
1330		- }
1331		-
1332		- $args[] = $this->escape($ref);
1333		- $args[] = $this->escape($mailbox);
1334		-
1335		- if (!empty($return_opts) && $this->getCapability('LIST-EXTENDED')) {
1336		- $ext_opts = ['SUBSCRIBED', 'CHILDREN'];
1337		- $rets = array_intersect($return_opts, $ext_opts);
1338		- $return_opts = array_diff($return_opts, $rets);
1339		- }
1340		-
1341		- if (!empty($return_opts) && $this->getCapability('LIST-STATUS')) {
1342		- $lstatus = true;
1343		- $status_opts = ['MESSAGES', 'RECENT', 'UIDNEXT', 'UIDVALIDITY', 'UNSEEN'];
1344		- $opts = array_diff($return_opts, $status_opts);
1345		- $status_opts = array_diff($return_opts, $opts);
1346		-
1347		- if (!empty($status_opts)) {
1348		- $rets[] = 'STATUS ('.implode(' ', $status_opts).')';
1349		- }
1350		-
1351		- if (!empty($opts)) {
1352		- $rets = array_merge($rets, $opts);
1353		- }
1354		- } else {
1355		- $lstatus = false;
1356		- }
1357		-
1358		- if (!empty($rets)) {
1359		- $args[] = 'RETURN ('.implode(' ', $rets).')';
1360		- }
1361		-
1362		- [$code, $response] = $this->execute($subscribed ? 'LSUB' : 'LIST', $args);
1363		-
1364		- if ($code == self::ERROR_OK) {
1365		- $folders = [];
1366		- $last = 0;
1367		- $pos = 0;
1368		- $response .= "\r\n";
1369		-
1370		- while ($pos = strpos($response, "\r\n", $pos + 1)) {
1371		- // literal string, not real end-of-command-line
1372		- if ($response[$pos - 1] == '}') {
1373		- continue;
1374		- }
1375		-
1376		- $line = substr($response, $last, $pos - $last);
1377		- $last = $pos + 2;
1378		-
1379		- if (!preg_match('/^\* (LIST|LSUB|STATUS|MYRIGHTS) /i', $line, $m)) {
1380		- continue;
1381		- }
1382		-
1383		- $cmd = strtoupper($m[1]);
1384		- $line = substr($line, strlen($m[0]));
1385		-
1386		- // * LIST (<options>) <delimiter> <mailbox>
1387		- if ($cmd == 'LIST' || $cmd == 'LSUB') {
1388		- [$opts, $delim, $mailbox] = $this->tokenizeResponse($line, 3);
1389		-
1390		- // Remove redundant separator at the end of folder name, UW-IMAP bug? (#1488879)
1391		- if ($delim) {
1392		- $mailbox = rtrim($mailbox, $delim);
1393		- }
1394		-
1395		- // Add to result array
1396		- if (!$lstatus) {
1397		- $folders[] = $mailbox;
1398		- } else {
1399		- $folders[$mailbox] = [];
1400		- }
1401		-
1402		- // store folder options
1403		- if ($cmd == 'LIST') {
1404		- // Add to options array
1405		- if (empty($this->data['LIST'][$mailbox])) {
1406		- $this->data['LIST'][$mailbox] = $opts;
1407		- } elseif (!empty($opts)) {
1408		- $this->data['LIST'][$mailbox] = array_unique(
1409		- array_merge(
1410		- $this->data['LIST'][$mailbox],
1411		- $opts
1412		- )
1413		- );
1414		- }
1415		- }
1416		- } elseif ($lstatus) {
1417		- // * STATUS <mailbox> (<result>)
1418		- if ($cmd == 'STATUS') {
1419		- [$mailbox, $status] = $this->tokenizeResponse($line, 2);
1420		-
1421		- for ($i = 0, $len = count($status) ; $i < $len ; $i += 2) {
1422		- [$name, $value] = $this->tokenizeResponse($status, 2);
1423		- $folders[$mailbox][$name] = $value;
1424		- }
1425		- } // * MYRIGHTS <mailbox> <acl>
1426		- elseif ($cmd == 'MYRIGHTS') {
1427		- [$mailbox, $acl] = $this->tokenizeResponse($line, 2);
1428		- $folders[$mailbox]['MYRIGHTS'] = $acl;
1429		- }
1430		- }
1431		- }
1432		-
1433		- return $folders;
1434		- }
1435		-
1436		- return false;
1437		- }
1438		-
1439		- /**
1440		- * Returns count of all messages in a folder
1441		- *
1442		- * @param string $mailbox Mailbox name
1443		- *
1444		- * @return int Number of messages, False on error
1445		- */
1446		- public function countMessages($mailbox)
1447		- {
1448		- if ($this->selected === $mailbox && isset($this->data['EXISTS'])) {
1449		- return $this->data['EXISTS'];
1450		- }
1451		-
1452		- // Check internal cache
1453		- $cache = $this->data['STATUS:'.$mailbox];
1454		- if (!empty($cache) && isset($cache['MESSAGES'])) {
1455		- return (int)$cache['MESSAGES'];
1456		- }
1457		-
1458		- // Try STATUS (should be faster than SELECT)
1459		- $counts = $this->status($mailbox);
1460		- if (is_array($counts)) {
1461		- return (int)$counts['MESSAGES'];
1462		- }
1463		-
1464		- return false;
1465		- }
1466		-
1467		- /**
1468		- * Returns count of messages with \Recent flag in a folder
1469		- *
1470		- * @param string $mailbox Mailbox name
1471		- *
1472		- * @return int Number of messages, False on error
1473		- */
1474		- public function countRecent($mailbox)
1475		- {
1476		- if ($this->selected === $mailbox && isset($this->data['RECENT'])) {
1477		- return $this->data['RECENT'];
1478		- }
1479		-
1480		- // Check internal cache
1481		- $cache = $this->data['STATUS:'.$mailbox];
1482		- if (!empty($cache) && isset($cache['RECENT'])) {
1483		- return (int)$cache['RECENT'];
1484		- }
1485		-
1486		- // Try STATUS (should be faster than SELECT)
1487		- $counts = $this->status($mailbox, ['RECENT']);
1488		- if (is_array($counts)) {
1489		- return (int)$counts['RECENT'];
1490		- }
1491		-
1492		- return false;
1493		- }
1494		-
1495		- /**
1496		- * Returns count of messages without \Seen flag in a specified folder
1497		- *
1498		- * @param string $mailbox Mailbox name
1499		- *
1500		- * @return int Number of messages, False on error
1501		- */
1502		- public function countUnseen($mailbox)
1503		- {
1504		- // Check internal cache
1505		- $cache = $this->data['STATUS:'.$mailbox];
1506		- if (!empty($cache) && isset($cache['UNSEEN'])) {
1507		- return (int)$cache['UNSEEN'];
1508		- }
1509		-
1510		- // Try STATUS (should be faster than SELECT+SEARCH)
1511		- $counts = $this->status($mailbox);
1512		- if (is_array($counts)) {
1513		- return (int)$counts['UNSEEN'];
1514		- }
1515		-
1516		- // Invoke SEARCH as a fallback
1517		- $index = $this->search($mailbox, 'ALL UNSEEN', false, ['COUNT']);
1518		- if (!$index->is_error()) {
1519		- return $index->count();
1520		- }
1521		-
1522		- return false;
1523		- }
1524		-
1525		- /**
1526		- * Executes ID command (RFC2971)
1527		- *
1528		- * @param array $items Client identification information key/value hash
1529		- *
1530		- * @return array|false Server identification information key/value hash, False on error
1531		- * @since 0.6
1532		- */
1533		- public function id($items = [])
1534		- {
1535		- if (is_array($items) && !empty($items)) {
1536		- foreach ($items as $key => $value) {
1537		- $args[] = $this->escape($key, true);
1538		- $args[] = $this->escape($value, true);
1539		- }
1540		- }
1541		-
1542		- [$code, $response] = $this->execute(
1543		- 'ID',
1544		- [!empty($args) ? '('.implode(' ', (array)$args).')' : $this->escape(null)],
1545		- 0,
1546		- '/^\* ID /i'
1547		- );
1548		-
1549		- if ($code == self::ERROR_OK && $response) {
1550		- $response = substr($response, 5); // remove prefix "* ID "
1551		- $items = $this->tokenizeResponse($response, 1);
1552		- $result = [];
1553		-
1554		- if (is_array($items)) {
1555		- for ($i = 0, $len = count($items) ; $i < $len ; $i += 2) {
1556		- $result[$items[$i]] = $items[$i + 1];
1557		- }
1558		- }
1559		-
1560		- return $result;
1561		- }
1562		-
1563		- return false;
1564		- }
1565		-
1566		- /**
1567		- * Executes ENABLE command (RFC5161)
1568		- *
1569		- * @param mixed $extension Extension name to enable (or array of names)
1570		- *
1571		- * @return array|bool List of enabled extensions, False on error
1572		- * @since 0.6
1573		- */
1574		- public function enable($extension)
1575		- {
1576		- if (empty($extension)) {
1577		- return false;
1578		- }
1579		-
1580		- if (!$this->hasCapability('ENABLE')) {
1581		- return false;
1582		- }
1583		-
1584		- if (!is_array($extension)) {
1585		- $extension = [$extension];
1586		- }
1587		-
1588		- if (!empty($this->extensions_enabled)) {
1589		- // check if all extensions are already enabled
1590		- $diff = array_diff($extension, $this->extensions_enabled);
1591		-
1592		- if (empty($diff)) {
1593		- return $extension;
1594		- }
1595		-
1596		- // Make sure the mailbox isn't selected, before enabling extension(s)
1597		- if ($this->selected !== null) {
1598		- $this->close();
1599		- }
1600		- }
1601		-
1602		- [$code, $response] = $this->execute('ENABLE', $extension, 0, '/^\* ENABLED /i');
1603		-
1604		- if ($code == self::ERROR_OK && $response) {
1605		- $response = substr($response, 10); // remove prefix "* ENABLED "
1606		- $result = (array)$this->tokenizeResponse($response);
1607		-
1608		- $this->extensions_enabled = array_unique(array_merge((array)$this->extensions_enabled, $result));
1609		-
1610		- return $this->extensions_enabled;
1611		- }
1612		-
1613		- return false;
1614		- }
1615		-
1616		- /**
1617		- * Executes SORT command
1618		- *
1619		- * @param string $mailbox Mailbox name
1620		- * @param string $field Field to sort by (ARRIVAL, CC, DATE, FROM, SIZE, SUBJECT, TO)
1621		- * @param string $criteria Searching criteria
1622		- * @param bool $return_uid Enables UID SORT usage
1623		- * @param string $encoding Character set
1624		- *
1625		- * @return ResultIndex Response data
1626		- */
1627		- public function sort($mailbox, $field = 'ARRIVAL', $criteria = '', $return_uid = false, $encoding = 'US-ASCII')
1628		- {
1629		- $old_sel = $this->selected;
1630		- $supported = ['ARRIVAL', 'CC', 'DATE', 'FROM', 'SIZE', 'SUBJECT', 'TO'];
1631		- $field = strtoupper($field);
1632		-
1633		- if ($field == 'INTERNALDATE') {
1634		- $field = 'ARRIVAL';
1635		- }
1636		-
1637		- if (!in_array($field, $supported)) {
1638		- return new ResultIndex($mailbox);
1639		- }
1640		-
1641		- if (!$this->select($mailbox)) {
1642		- return new ResultIndex($mailbox);
1643		- }
1644		-
1645		- // return empty result when folder is empty and we're just after SELECT
1646		- if ($old_sel != $mailbox && !$this->data['EXISTS']) {
1647		- return new ResultIndex($mailbox, '* SORT');
1648		- }
1649		-
1650		- // RFC 5957: SORT=DISPLAY
1651		- if (($field == 'FROM' || $field == 'TO') && $this->getCapability('SORT=DISPLAY')) {
1652		- $field = 'DISPLAY'.$field;
1653		- }
1654		-
1655		- $encoding = $encoding ? trim($encoding) : 'US-ASCII';
1656		- $criteria = $criteria ? 'ALL '.trim($criteria) : 'ALL';
1657		-
1658		- [$code, $response] = $this->execute(
1659		- $return_uid ? 'UID SORT' : 'SORT',
1660		- ["($field)", $encoding, $criteria]
1661		- );
1662		-
1663		- if ($code != self::ERROR_OK) {
1664		- $response = null;
1665		- }
1666		-
1667		- return new ResultIndex($mailbox, $response);
1668		- }
1669		-
1670		- /**
1671		- * Executes THREAD command
1672		- *
1673		- * @param string $mailbox Mailbox name
1674		- * @param string $algorithm Threading algorithm (ORDEREDSUBJECT, REFERENCES, REFS)
1675		- * @param string $criteria Searching criteria
1676		- * @param bool $return_uid Enables UIDs in result instead of sequence numbers
1677		- * @param string $encoding Character set
1678		- *
1679		- * @return ResultThread Thread data
1680		- */
1681		- public function thread($mailbox, $algorithm = 'REFERENCES', $criteria = '', $return_uid = false, $encoding = 'US-ASCII')
1682		- {
1683		- $old_sel = $this->selected;
1684		-
1685		- if (!$this->select($mailbox)) {
1686		- return new ResultThread($mailbox);
1687		- }
1688		-
1689		- // return empty result when folder is empty and we're just after SELECT
1690		- if ($old_sel != $mailbox && !$this->data['EXISTS']) {
1691		- return new ResultThread($mailbox, '* THREAD');
1692		- }
1693		-
1694		- $encoding = $encoding ? trim($encoding) : 'US-ASCII';
1695		- $algorithm = $algorithm ? trim($algorithm) : 'REFERENCES';
1696		- $criteria = $criteria ? 'ALL '.trim($criteria) : 'ALL';
1697		-
1698		- [$code, $response] = $this->execute(
1699		- $return_uid ? 'UID THREAD' : 'THREAD',
1700		- [$algorithm, $encoding, $criteria]
1701		- );
1702		-
1703		- if ($code != self::ERROR_OK) {
1704		- $response = null;
1705		- }
1706		-
1707		- return new ResultThread($mailbox, $response);
1708		- }
1709		-
1710		- /**
1711		- * Executes SEARCH command
1712		- *
1713		- * @param string $mailbox Mailbox name
1714		- * @param string $criteria Searching criteria
1715		- * @param bool $return_uid Enable UID in result instead of sequence ID
1716		- * @param array $items Return items (MIN, MAX, COUNT, ALL)
1717		- *
1718		- * @return ResultIndex Result data
1719		- */
1720		- public function search($mailbox, $criteria, $return_uid = false, $items = [])
1721		- {
1722		- $old_sel = $this->selected;
1723		-
1724		- if (!$this->select($mailbox)) {
1725		- return new ResultIndex($mailbox);
1726		- }
1727		-
1728		- // return empty result when folder is empty and we're just after SELECT
1729		- if ($old_sel != $mailbox && !$this->data['EXISTS']) {
1730		- return new ResultIndex($mailbox, '* SEARCH');
1731		- }
1732		-
1733		- // If ESEARCH is supported always use ALL
1734		- // but not when items are specified or using simple id2uid search
1735		- if (empty($items) && preg_match('/[^0-9]/', $criteria)) {
1736		- $items = ['ALL'];
1737		- }
1738		-
1739		- $esearch = empty($items) ? false : $this->getCapability('ESEARCH');
1740		- $criteria = trim($criteria);
1741		- $params = '';
1742		-
1743		- // RFC4731: ESEARCH
1744		- if (!empty($items) && $esearch) {
1745		- $params .= 'RETURN ('.implode(' ', $items).')';
1746		- }
1747		-
1748		- if (!empty($criteria)) {
1749		- $params .= ($params ? ' ' : '').$criteria;
1750		- } else {
1751		- $params .= 'ALL';
1752		- }
1753		-
1754		- [$code, $response] = $this->execute(
1755		- $return_uid ? 'UID SEARCH' : 'SEARCH',
1756		- [$params]
1757		- );
1758		-
1759		- if ($code != self::ERROR_OK) {
1760		- $response = null;
1761		- }
1762		-
1763		- return new ResultIndex($mailbox, $response);
1764		- }
1765		-
1766		- /**
1767		- * Simulates SORT command by using FETCH and sorting.
1768		- *
1769		- * @param string $mailbox Mailbox name
1770		- * @param string|array $message_set Searching criteria (list of messages to return)
1771		- * @param string $index_field Field to sort by (ARRIVAL, CC, DATE, FROM, SIZE, SUBJECT, TO)
1772		- * @param bool $skip_deleted Makes that DELETED messages will be skipped
1773		- * @param bool $uidfetch Enables UID FETCH usage
1774		- * @param bool $return_uid Enables returning UIDs instead of IDs
1775		- *
1776		- * @return ResultIndex Response data
1777		- */
1778		- public function index(
1779		- $mailbox,
1780		- $message_set,
1781		- $index_field = '',
1782		- $skip_deleted = true,
1783		- $uidfetch = false,
1784		- $return_uid = false
1785		- ) {
1786		- $msg_index = $this->fetchHeaderIndex(
1787		- $mailbox,
1788		- $message_set,
1789		- $index_field,
1790		- $skip_deleted,
1791		- $uidfetch,
1792		- $return_uid
1793		- );
1794		-
1795		- if (!empty($msg_index)) {
1796		- asort($msg_index); // ASC
1797		- $msg_index = array_keys($msg_index);
1798		- $msg_index = '* SEARCH '.implode(' ', $msg_index);
1799		- } else {
1800		- $msg_index = is_array($msg_index) ? '* SEARCH' : null;
1801		- }
1802		-
1803		- return new ResultIndex($mailbox, $msg_index);
1804		- }
1805		-
1806		- /**
1807		- * Fetches specified header/data value for a set of messages.
1808		- *
1809		- * @param string $mailbox Mailbox name
1810		- * @param string|array $message_set Searching criteria (list of messages to return)
1811		- * @param string $index_field Field to sort by (ARRIVAL, CC, DATE, FROM, SIZE, SUBJECT, TO)
1812		- * @param bool $skip_deleted Makes that DELETED messages will be skipped
1813		- * @param bool $uidfetch Enables UID FETCH usage
1814		- * @param bool $return_uid Enables returning UIDs instead of IDs
1815		- *
1816		- * @return array|bool List of header values or False on failure
1817		- */
1818		- public function fetchHeaderIndex(
1819		- $mailbox,
1820		- $message_set,
1821		- $index_field = '',
1822		- $skip_deleted = true,
1823		- $uidfetch = false,
1824		- $return_uid = false
1825		- ) {
1826		- if (is_array($message_set)) {
1827		- if (!($message_set = $this->compressMessageSet($message_set))) {
1828		- return false;
1829		- }
1830		- } else {
1831		- [$from_idx, $to_idx] = explode(':', $message_set);
1832		- if (empty($message_set) ||
1833		- (isset($to_idx) && $to_idx != '*' && (int)$from_idx > (int)$to_idx)
1834		- ) {
1835		- return false;
1836		- }
1837		- }
1838		-
1839		- $index_field = empty($index_field) ? 'DATE' : strtoupper($index_field);
1840		-
1841		- $fields_a['DATE'] = 1;
1842		- $fields_a['INTERNALDATE'] = 4;
1843		- $fields_a['ARRIVAL'] = 4;
1844		- $fields_a['FROM'] = 1;
1845		- $fields_a['REPLY-TO'] = 1;
1846		- $fields_a['SENDER'] = 1;
1847		- $fields_a['TO'] = 1;
1848		- $fields_a['CC'] = 1;
1849		- $fields_a['SUBJECT'] = 1;
1850		- $fields_a['UID'] = 2;
1851		- $fields_a['SIZE'] = 2;
1852		- $fields_a['SEEN'] = 3;
1853		- $fields_a['RECENT'] = 3;
1854		- $fields_a['DELETED'] = 3;
1855		-
1856		- if (!($mode = $fields_a[$index_field])) {
1857		- return false;
1858		- }
1859		-
1860		- // Select the mailbox
1861		- if (!$this->select($mailbox)) {
1862		- return false;
1863		- }
1864		-
1865		- // build FETCH command string
1866		- $key = $this->nextTag();
1867		- $cmd = $uidfetch ? 'UID FETCH' : 'FETCH';
1868		- $fields = [];
1869		-
1870		- if ($return_uid) {
1871		- $fields[] = 'UID';
1872		- }
1873		- if ($skip_deleted) {
1874		- $fields[] = 'FLAGS';
1875		- }
1876		-
1877		- if ($mode == 1) {
1878		- if ($index_field == 'DATE') {
1879		- $fields[] = 'INTERNALDATE';
1880		- }
1881		- $fields[] = "BODY.PEEK[HEADER.FIELDS ($index_field)]";
1882		- } elseif ($mode == 2) {
1883		- if ($index_field == 'SIZE') {
1884		- $fields[] = 'RFC822.SIZE';
1885		- } elseif (!$return_uid || $index_field != 'UID') {
1886		- $fields[] = $index_field;
1887		- }
1888		- } elseif ($mode == 3 && !$skip_deleted) {
1889		- $fields[] = 'FLAGS';
1890		- } elseif ($mode == 4) {
1891		- $fields[] = 'INTERNALDATE';
1892		- }
1893		-
1894		- $request = "$key $cmd $message_set (".implode(' ', $fields).")";
1895		-
1896		- if (!$this->putLine($request)) {
1897		- $this->setError(self::ERROR_COMMAND, "Failed to send $cmd command");
1898		-
1899		- return false;
1900		- }
1901		-
1902		- $result = [];
1903		-
1904		- do {
1905		- $line = rtrim($this->readLine(200));
1906		- $line = $this->multLine($line);
1907		-
1908		- if (preg_match('/^\* ([0-9]+) FETCH/', $line, $m)) {
1909		- $id = $m[1];
1910		- $flags = null;
1911		-
1912		- if ($return_uid) {
1913		- if (preg_match('/UID ([0-9]+)/', $line, $matches)) {
1914		- $id = (int)$matches[1];
1915		- } else {
1916		- continue;
1917		- }
1918		- }
1919		- if ($skip_deleted && preg_match('/FLAGS \(([^)]+)\)/', $line, $matches)) {
1920		- $flags = explode(' ', strtoupper($matches[1]));
1921		- if (in_array('\\DELETED', $flags)) {
1922		- continue;
1923		- }
1924		- }
1925		-
1926		- if ($mode == 1 && $index_field == 'DATE') {
1927		- if (preg_match('/BODY\[HEADER\.FIELDS \("*DATE"*\)\] (.*)/', $line, $matches)) {
1928		- $value = preg_replace(['/^"*[a-z]+:/i'], '', $matches[1]);
1929		- $value = trim($value);
1930		- $result[$id] = Utils::strtotime($value);
1931		- }
1932		- // non-existent/empty Date: header, use INTERNALDATE
1933		- if (empty($result[$id])) {
1934		- if (preg_match('/INTERNALDATE "([^"]+)"/', $line, $matches)) {
1935		- $result[$id] = Utils::strtotime($matches[1]);
1936		- } else {
1937		- $result[$id] = 0;
1938		- }
1939		- }
1940		- } elseif ($mode == 1) {
1941		- if (preg_match('/BODY\[HEADER\.FIELDS \("?(FROM|REPLY-TO|SENDER|TO|SUBJECT)"?\)\] (.*)/', $line, $matches)) {
1942		- $value = preg_replace(['/^"*[a-z]+:/i', '/\s+$/sm'], ['', ''], $matches[2]);
1943		- $result[$id] = trim($value);
1944		- } else {
1945		- $result[$id] = '';
1946		- }
1947		- } elseif ($mode == 2) {
1948		- if (preg_match('/'.$index_field.' ([0-9]+)/', $line, $matches)) {
1949		- $result[$id] = trim($matches[1]);
1950		- } else {
1951		- $result[$id] = 0;
1952		- }
1953		- } elseif ($mode == 3) {
1954		- if (!$flags && preg_match('/FLAGS \(([^)]+)\)/', $line, $matches)) {
1955		- $flags = explode(' ', $matches[1]);
1956		- }
1957		- $result[$id] = in_array("\\".$index_field, (array)$flags) ? 1 : 0;
1958		- } elseif ($mode == 4) {
1959		- if (preg_match('/INTERNALDATE "([^"]+)"/', $line, $matches)) {
1960		- $result[$id] = Utils::strtotime($matches[1]);
1961		- } else {
1962		- $result[$id] = 0;
1963		- }
1964		- }
1965		- }
1966		- } while (!$this->startsWith($line, $key, true, true));
1967		-
1968		- return $result;
1969		- }
1970		-
1971		- /**
1972		- * Returns message sequence identifier
1973		- *
1974		- * @param string $mailbox Mailbox name
1975		- * @param int $uid Message unique identifier (UID)
1976		- *
1977		- * @return int Message sequence identifier
1978		- */
1979		- public function UID2ID($mailbox, $uid)
1980		- {
1981		- if ($uid > 0) {
1982		- $index = $this->search($mailbox, "UID $uid");
1983		-
1984		- if ($index->count() == 1) {
1985		- $arr = $index->get();
1986		-
1987		- return (int)$arr[0];
1988		- }
1989		- }
1990		- }
1991		-
1992		- /**
1993		- * Returns message unique identifier (UID)
1994		- *
1995		- * @param string $mailbox Mailbox name
1996		- * @param int $uid Message sequence identifier
1997		- *
1998		- * @return int Message unique identifier
1999		- */
2000		- public function ID2UID($mailbox, $id)
2001		- {
2002		- if (empty($id) || $id < 0) {
2003		- return null;
2004		- }
2005		-
2006		- if (!$this->select($mailbox)) {
2007		- return null;
2008		- }
2009		-
2010		- if ($uid = $this->data['UID-MAP'][$id]) {
2011		- return $uid;
2012		- }
2013		-
2014		- if (isset($this->data['EXISTS']) && $id > $this->data['EXISTS']) {
2015		- return null;
2016		- }
2017		-
2018		- $index = $this->search($mailbox, $id, true);
2019		-
2020		- if ($index->count() == 1) {
2021		- $arr = $index->get();
2022		-
2023		- return $this->data['UID-MAP'][$id] = (int)$arr[0];
2024		- }
2025		- }
2026		-
2027		- /**
2028		- * Sets flag of the message(s)
2029		- *
2030		- * @param string $mailbox Mailbox name
2031		- * @param string|array $messages Message UID(s)
2032		- * @param string $flag Flag name
2033		- *
2034		- * @return bool True on success, False on failure
2035		- */
2036		- public function flag($mailbox, $messages, $flag)
2037		- {
2038		- return $this->modFlag($mailbox, $messages, $flag, '+');
2039		- }
2040		-
2041		- /**
2042		- * Unsets flag of the message(s)
2043		- *
2044		- * @param string $mailbox Mailbox name
2045		- * @param string|array $messages Message UID(s)
2046		- * @param string $flag Flag name
2047		- *
2048		- * @return bool True on success, False on failure
2049		- */
2050		- public function unflag($mailbox, $messages, $flag)
2051		- {
2052		- return $this->modFlag($mailbox, $messages, $flag, '-');
2053		- }
2054		-
2055		- /**
2056		- * Changes flag of the message(s)
2057		- *
2058		- * @param string $mailbox Mailbox name
2059		- * @param string|array $messages Message UID(s)
2060		- * @param string $flag Flag name
2061		- * @param string $mod Modifier [+|-]. Default: "+".
2062		- *
2063		- * @return bool True on success, False on failure
2064		- */
2065		- protected function modFlag($mailbox, $messages, $flag, $mod = '+')
2066		- {
2067		- if (!$flag) {
2068		- return false;
2069		- }
2070		-
2071		- if (!$this->select($mailbox)) {
2072		- return false;
2073		- }
2074		-
2075		- if (!$this->data['READ-WRITE']) {
2076		- $this->setError(self::ERROR_READONLY, "Mailbox is read-only");
2077		-
2078		- return false;
2079		- }
2080		-
2081		- if (isset($this->flags[strtoupper($flag)]) && $this->flags[strtoupper($flag)]) {
2082		- $flag = $this->flags[strtoupper($flag)];
2083		- }
2084		-
2085		- // if PERMANENTFLAGS is not specified all flags are allowed
2086		- if (!empty($this->data['PERMANENTFLAGS'])
2087		- && !in_array($flag, (array)$this->data['PERMANENTFLAGS'])
2088		- && !in_array('\\*', (array)$this->data['PERMANENTFLAGS'])
2089		- ) {
2090		- return false;
2091		- }
2092		-
2093		- // Clear internal status cache
2094		- if ($flag == 'SEEN') {
2095		- unset($this->data['STATUS:'.$mailbox]['UNSEEN']);
2096		- }
2097		-
2098		- if ($mod != '+' && $mod != '-') {
2099		- $mod = '+';
2100		- }
2101		-
2102		- $result = $this->execute(
2103		- 'UID STORE',
2104		- [
2105		- $this->compressMessageSet($messages),
2106		- $mod.'FLAGS.SILENT',
2107		- "($flag)",
2108		- ],
2109		- self::COMMAND_NORESPONSE
2110		- );
2111		-
2112		- return $result == self::ERROR_OK;
2113		- }
2114		-
2115		- /**
2116		- * Copies message(s) from one folder to another
2117		- *
2118		- * @param string|array $messages Message UID(s)
2119		- * @param string $from Mailbox name
2120		- * @param string $to Destination mailbox name
2121		- *
2122		- * @return bool True on success, False on failure
2123		- */
2124		- public function copy($messages, $from, $to)
2125		- {
2126		- // Clear last COPYUID data
2127		- unset($this->data['COPYUID']);
2128		-
2129		- if (!$this->select($from)) {
2130		- return false;
2131		- }
2132		-
2133		- // Clear internal status cache
2134		- unset($this->data['STATUS:'.$to]);
2135		-
2136		- $result = $this->execute(
2137		- 'UID COPY',
2138		- [
2139		- $this->compressMessageSet($messages),
2140		- $this->escape($to),
2141		- ],
2142		- self::COMMAND_NORESPONSE
2143		- );
2144		-
2145		- return $result == self::ERROR_OK;
2146		- }
2147		-
2148		- /**
2149		- * Moves message(s) from one folder to another.
2150		- *
2151		- * @param string|array $messages Message UID(s)
2152		- * @param string $from Mailbox name
2153		- * @param string $to Destination mailbox name
2154		- *
2155		- * @return bool True on success, False on failure
2156		- */
2157		- public function move($messages, $from, $to)
2158		- {
2159		- if (!$this->select($from)) {
2160		- return false;
2161		- }
2162		-
2163		- if (!$this->data['READ-WRITE']) {
2164		- $this->setError(self::ERROR_READONLY, "Mailbox is read-only");
2165		-
2166		- return false;
2167		- }
2168		-
2169		- // use MOVE command (RFC 6851)
2170		- if ($this->hasCapability('MOVE')) {
2171		- // Clear last COPYUID data
2172		- unset($this->data['COPYUID']);
2173		-
2174		- // Clear internal status cache
2175		- unset($this->data['STATUS:'.$to]);
2176		- $this->clear_status_cache($from);
2177		-
2178		- $result = $this->execute(
2179		- 'UID MOVE',
2180		- [
2181		- $this->compressMessageSet($messages),
2182		- $this->escape($to),
2183		- ],
2184		- self::COMMAND_NORESPONSE
2185		- );
2186		-
2187		- return $result == self::ERROR_OK;
2188		- }
2189		-
2190		- // use COPY + STORE +FLAGS.SILENT \Deleted + EXPUNGE
2191		- $result = $this->copy($messages, $from, $to);
2192		-
2193		- if ($result) {
2194		- // Clear internal status cache
2195		- unset($this->data['STATUS:'.$from]);
2196		-
2197		- $result = $this->flag($from, $messages, 'DELETED');
2198		-
2199		- if ($messages == '*') {
2200		- // CLOSE+SELECT should be faster than EXPUNGE
2201		- $this->close();
2202		- } else {
2203		- $this->expunge($from, $messages);
2204		- }
2205		- }
2206		-
2207		- return $result;
2208		- }
2209		-
2210		- /**
2211		- * FETCH command (RFC3501)
2212		- *
2213		- * @param string $mailbox Mailbox name
2214		- * @param mixed $message_set Message(s) sequence identifier(s) or UID(s)
2215		- * @param bool $is_uid True if $message_set contains UIDs
2216		- * @param array $query_items FETCH command data items
2217		- * @param string $mod_seq Modification sequence for CHANGEDSINCE (RFC4551) query
2218		- * @param bool $vanished Enables VANISHED parameter (RFC5162) for CHANGEDSINCE query
2219		- *
2220		- * @return array List of MessageHeader elements, False on error
2221		- * @since 0.6
2222		- */
2223		- public function fetch(
2224		- $mailbox,
2225		- $message_set,
2226		- $is_uid = false,
2227		- $query_items = [],
2228		- $mod_seq = null,
2229		- $vanished = false
2230		- ) {
2231		- if (!$this->select($mailbox)) {
2232		- return false;
2233		- }
2234		-
2235		- $message_set = $this->compressMessageSet($message_set);
2236		- $result = [];
2237		-
2238		- $key = $this->nextTag();
2239		- $cmd = ($is_uid ? 'UID ' : '').'FETCH';
2240		- $request = "$key $cmd $message_set (".implode(' ', $query_items).")";
2241		-
2242		- if ($mod_seq !== null && $this->hasCapability('CONDSTORE')) {
2243		- $request .= " (CHANGEDSINCE $mod_seq".($vanished ? " VANISHED" : '').")";
2244		- }
2245		-
2246		- if (!$this->putLine($request)) {
2247		- $this->setError(self::ERROR_COMMAND, "Failed to send $cmd command");
2248		-
2249		- return false;
2250		- }
2251		-
2252		- do {
2253		- $line = $this->readFullLine(4096);
2254		-
2255		- if (!$line) {
2256		- break;
2257		- }
2258		-
2259		- // Sample reply line:
2260		- // * 321 FETCH (UID 2417 RFC822.SIZE 2730 FLAGS (\Seen)
2261		- // INTERNALDATE "16-Nov-2008 21:08:46 +0100" BODYSTRUCTURE (...)
2262		- // BODY[HEADER.FIELDS ...
2263		-
2264		- if (preg_match('/^\* ([0-9]+) FETCH/', $line, $m)) {
2265		- $id = intval($m[1]);
2266		-
2267		- $result[$id] = new MessageHeader;
2268		- $result[$id]->id = $id;
2269		- $result[$id]->subject = '';
2270		- $result[$id]->messageID = 'mid:'.$id;
2271		-
2272		- $headers = null;
2273		- $lines = [];
2274		- $line = substr($line, strlen($m[0]) + 2);
2275		- $ln = 0;
2276		-
2277		- // Tokenize response and assign to object properties
2278		- while (@list($name, $value) = $this->tokenizeResponse($line, 2)) {
2279		- if ($name == 'UID') {
2280		- $result[$id]->uid = intval($value);
2281		- } elseif ($name == 'RFC822.SIZE') {
2282		- $result[$id]->size = intval($value);
2283		- } elseif ($name == 'RFC822.TEXT') {
2284		- $result[$id]->body = $value;
2285		- } elseif ($name == 'INTERNALDATE') {
2286		- $result[$id]->internaldate = $value;
2287		- $result[$id]->date = $value;
2288		- $result[$id]->timestamp = Utils::strtotime($value);
2289		- } elseif ($name == 'FLAGS') {
2290		- if (!empty($value)) {
2291		- foreach ((array)$value as $flag) {
2292		- $flag = str_replace(['$', "\\"], '', $flag);
2293		- $flag = strtoupper($flag);
2294		-
2295		- $result[$id]->flags[$flag] = true;
2296		- }
2297		- }
2298		- } elseif ($name == 'MODSEQ') {
2299		- $result[$id]->modseq = $value[0];
2300		- } elseif ($name == 'ENVELOPE') {
2301		- $result[$id]->envelope = $value;
2302		- } elseif ($name == 'BODYSTRUCTURE' || ($name == 'BODY' && count($value) > 2)) {
2303		- if (!is_array($value[0]) && (strtolower($value[0]) == 'message' && strtolower($value[1]) == 'rfc822')) {
2304		- $value = [$value];
2305		- }
2306		- $result[$id]->bodystructure = $value;
2307		- } elseif ($name == 'RFC822') {
2308		- $result[$id]->body = $value;
2309		- } elseif (stripos($name, 'BODY[') === 0) {
2310		- $name = str_replace(']', '', substr($name, 5));
2311		-
2312		- if ($name == 'HEADER.FIELDS') {
2313		- // skip ']' after headers list
2314		- $this->tokenizeResponse($line, 1);
2315		- $headers = $this->tokenizeResponse($line, 1);
2316		- } elseif (strlen($name)) {
2317		- $result[$id]->bodypart[$name] = $value;
2318		- } else {
2319		- $result[$id]->body = $value;
2320		- }
2321		- }
2322		- }
2323		-
2324		- // create array with header field:data
2325		- if (!empty($headers)) {
2326		- $headers = explode("\n", trim($headers));
2327		- foreach ($headers as $resln) {
2328		- if (ord($resln[0]) <= 32) {
2329		- $lines[$ln] .= (empty($lines[$ln]) ? '' : "\n").trim($resln);
2330		- } else {
2331		- $lines[++$ln] = trim($resln);
2332		- }
2333		- }
2334		-
2335		- foreach ($lines as $str) {
2336		- [$field, $string] = explode(':', $str, 2);
2337		-
2338		- $field = strtolower($field);
2339		- $string = preg_replace('/\n[\t\s]*/', ' ', trim($string));
2340		-
2341		- switch ($field) {
2342		- case 'date':
2343		- $string = substr($string, 0, 128);
2344		- $result[$id]->date = $string;
2345		- $result[$id]->timestamp = Utils::strtotime($string);
2346		- break;
2347		- case 'to':
2348		- $result[$id]->to = preg_replace('/undisclosed-recipients:[;,]*/', '', $string);
2349		- break;
2350		- case 'from':
2351		- case 'subject':
2352		- $string = substr($string, 0, 2048);
2353		- case 'cc':
2354		- case 'bcc':
2355		- case 'references':
2356		- $result[$id]->{$field} = $string;
2357		- break;
2358		- case 'reply-to':
2359		- $result[$id]->replyto = $string;
2360		- break;
2361		- case 'content-transfer-encoding':
2362		- $result[$id]->encoding = substr($string, 0, 32);
2363		- break;
2364		- case 'content-type':
2365		- $ctype_parts = preg_split('/[; ]+/', $string);
2366		- $result[$id]->ctype = strtolower(array_shift($ctype_parts));
2367		- if (preg_match('/charset\s*=\s*"?([a-z0-9\-\.\_]+)"?/i', $string, $regs)) {
2368		- $result[$id]->charset = $regs[1];
2369		- }
2370		- break;
2371		- case 'in-reply-to':
2372		- $result[$id]->in_reply_to = str_replace(["\n", '<', '>'], '', $string);
2373		- break;
2374		- case 'return-receipt-to':
2375		- case 'disposition-notification-to':
2376		- case 'x-confirm-reading-to':
2377		- $result[$id]->mdn_to = substr($string, 0, 2048);
2378		- break;
2379		- case 'message-id':
2380		- $result[$id]->messageID = substr($string, 0, 2048);
2381		- break;
2382		- case 'x-priority':
2383		- if (preg_match('/^(\d+)/', $string, $matches)) {
2384		- $result[$id]->priority = intval($matches[1]);
2385		- }
2386		- break;
2387		- default:
2388		- if (strlen($field) < 3) {
2389		- break;
2390		- }
2391		- if ($result[$id]->others[$field]) {
2392		- $string = array_merge((array)$result[$id]->others[$field], (array)$string);
2393		- }
2394		- $result[$id]->others[$field] = $string;
2395		- }
2396		- }
2397		- }
2398		- }
2399		- // VANISHED response (QRESYNC RFC5162)
2400		- // Sample: * VANISHED (EARLIER) 300:310,405,411
2401		- elseif (preg_match('/^\* VANISHED [()EARLIER]*/i', $line, $match)) {
2402		- $line = substr($line, strlen($match[0]));
2403		- $v_data = $this->tokenizeResponse($line, 1);
2404		-
2405		- $this->data['VANISHED'] = $v_data;
2406		- }
2407		- } while (!$this->startsWith($line, $key, true));
2408		-
2409		- return $result;
2410		- }
2411		-
2412		- /**
2413		- * Returns message(s) data (flags, headers, etc.)
2414		- *
2415		- * @param string $mailbox Mailbox name
2416		- * @param mixed $message_set Message(s) sequence identifier(s) or UID(s)
2417		- * @param bool $is_uid True if $message_set contains UIDs
2418		- * @param bool $bodystr Enable to add BODYSTRUCTURE data to the result
2419		- * @param array $add_headers List of additional headers
2420		- *
2421		- * @return bool|array List of MessageHeader elements, False on error
2422		- */
2423		- public function fetchHeaders($mailbox, $message_set, $is_uid = false, $bodystr = false, $add_headers = [])
2424		- {
2425		- $query_items = ['UID', 'RFC822.SIZE', 'FLAGS', 'INTERNALDATE'];
2426		- $headers = [
2427		- 'DATE',
2428		- 'FROM',
2429		- 'TO',
2430		- 'SUBJECT',
2431		- 'CONTENT-TYPE',
2432		- 'CC',
2433		- 'REPLY-TO',
2434		- 'LIST-POST',
2435		- 'DISPOSITION-NOTIFICATION-TO',
2436		- 'X-PRIORITY',
2437		- ];
2438		-
2439		- if (!empty($add_headers)) {
2440		- $add_headers = array_map('strtoupper', $add_headers);
2441		- $headers = array_unique(array_merge($headers, $add_headers));
2442		- }
2443		-
2444		- if ($bodystr) {
2445		- $query_items[] = 'BODYSTRUCTURE';
2446		- }
2447		-
2448		- $query_items[] = 'BODY.PEEK[HEADER.FIELDS ('.implode(' ', $headers).')]';
2449		-
2450		- return $this->fetch($mailbox, $message_set, $is_uid, $query_items);
2451		- }
2452		-
2453		- /**
2454		- * Returns message data (flags, headers, etc.)
2455		- *
2456		- * @param string $mailbox Mailbox name
2457		- * @param int $id Message sequence identifier or UID
2458		- * @param bool $is_uid True if $id is an UID
2459		- * @param bool $bodystr Enable to add BODYSTRUCTURE data to the result
2460		- * @param array $add_headers List of additional headers
2461		- *
2462		- * @return bool|MessageHeader Message data, False on error
2463		- */
2464		- public function fetchHeader($mailbox, $id, $is_uid = false, $bodystr = false, $add_headers = [])
2465		- {
2466		- $a = $this->fetchHeaders($mailbox, $id, $is_uid, $bodystr, $add_headers);
2467		- if (is_array($a)) {
2468		- return array_shift($a);
2469		- }
2470		-
2471		- return false;
2472		- }
2473		-
2474		- /**
2475		- * Sort messages by specified header field
2476		- *
2477		- * @param array $messages Array of MessageHeader objects
2478		- * @param string $field Name of the property to sort by
2479		- * @param string $flag Sorting order (ASC|DESC)
2480		- *
2481		- * @return array Sorted input array
2482		- */
2483		- public static function sortHeaders($messages, $field, $flag)
2484		- {
2485		- $field = empty($field) ? 'uid' : strtolower($field);
2486		- $order = empty($flag) ? 'ASC' : strtoupper($flag);
2487		- $index = [];
2488		-
2489		- reset($messages);
2490		-
2491		- // Create an index
2492		- foreach ($messages as $key => $headers) {
2493		- switch ($field) {
2494		- case 'arrival':
2495		- $field = 'internaldate';
2496		- // no-break
2497		- case 'date':
2498		- case 'internaldate':
2499		- case 'timestamp':
2500		- $value = Utils::strtotime($headers->$field);
2501		- if (!$value && $field != 'timestamp') {
2502		- $value = $headers->timestamp;
2503		- }
2504		-
2505		- break;
2506		-
2507		- default:
2508		- // @TODO: decode header value, convert to UTF-8
2509		- $value = $headers->$field;
2510		- if (is_string($value)) {
2511		- $value = str_replace('"', '', $value);
2512		-
2513		- if ($field == 'subject') {
2514		- $value = preg_replace('/^(Re:\s*|Fwd:\s*|Fw:\s*)+/i', '', $value);
2515		- }
2516		- }
2517		- }
2518		-
2519		- $index[$key] = $value;
2520		- }
2521		-
2522		- $sort_order = $flag == 'ASC' ? SORT_ASC : SORT_DESC;
2523		- $sort_flags = SORT_STRING | SORT_FLAG_CASE;
2524		-
2525		- if (in_array($field, ['arrival', 'date', 'internaldate', 'timestamp'])) {
2526		- $sort_flags = SORT_NUMERIC;
2527		- }
2528		-
2529		- array_multisort($index, $sort_order, $sort_flags, $messages);
2530		-
2531		- return $messages;
2532		- }
2533		-
2534		- /**
2535		- * Fetch MIME headers of specified message parts
2536		- *
2537		- * @param string $mailbox Mailbox name
2538		- * @param int $uid Message UID
2539		- * @param array $parts Message part identifiers
2540		- * @param bool $mime Use MIME instad of HEADER
2541		- *
2542		- * @return array|bool Array containing headers string for each specified body
2543		- * False on failure.
2544		- */
2545		- public function fetchMIMEHeaders($mailbox, $uid, $parts, $mime = true)
2546		- {
2547		- if (!$this->select($mailbox)) {
2548		- return false;
2549		- }
2550		-
2551		- $result = false;
2552		- $parts = (array)$parts;
2553		- $key = $this->nextTag();
2554		- $peeks = [];
2555		- $type = $mime ? 'MIME' : 'HEADER';
2556		-
2557		- // format request
2558		- foreach ($parts as $part) {
2559		- $peeks[] = "BODY.PEEK[$part.$type]";
2560		- }
2561		-
2562		- $request = "$key UID FETCH $uid (".implode(' ', $peeks).')';
2563		-
2564		- // send request
2565		- if (!$this->putLine($request)) {
2566		- $this->setError(self::ERROR_COMMAND, "Failed to send UID FETCH command");
2567		-
2568		- return false;
2569		- }
2570		-
2571		- do {
2572		- $line = $this->readLine(1024);
2573		-
2574		- if (preg_match('/^\* [0-9]+ FETCH [0-9UID( ]+/', $line, $m)) {
2575		- $line = ltrim(substr($line, strlen($m[0])));
2576		- while (preg_match('/^BODY\[([0-9\.]+)\.'.$type.'\]/', $line, $matches)) {
2577		- $line = substr($line, strlen($matches[0]));
2578		- $result[$matches[1]] = trim($this->multLine($line));
2579		- $line = $this->readLine(1024);
2580		- }
2581		- }
2582		- } while (!$this->startsWith($line, $key, true));
2583		-
2584		- return $result;
2585		- }
2586		-
2587		- /**
2588		- * Fetches message part header
2589		- */
2590		- public function fetchPartHeader($mailbox, $id, $is_uid = false, $part = null)
2591		- {
2592		- $part = empty($part) ? 'HEADER' : $part.'.MIME';
2593		-
2594		- return $this->handlePartBody($mailbox, $id, $is_uid, $part);
2595		- }
2596		-
2597		- /**
2598		- * Fetches body of the specified message part
2599		- */
2600		- public function handlePartBody($mailbox, $id, $is_uid = false, $part = '', $encoding = null, $print = null, $file = null, $formatted = false, $max_bytes = 0)
2601		- {
2602		- if (!$this->select($mailbox)) {
2603		- return false;
2604		- }
2605		-
2606		- $binary = true;
2607		-
2608		- do {
2609		- if (!$initiated) {
2610		- switch ($encoding) {
2611		- case 'base64':
2612		- $mode = 1;
2613		- break;
2614		- case 'quoted-printable':
2615		- $mode = 2;
2616		- break;
2617		- case 'x-uuencode':
2618		- case 'x-uue':
2619		- case 'uue':
2620		- case 'uuencode':
2621		- $mode = 3;
2622		- break;
2623		- default:
2624		- $mode = 0;
2625		- }
2626		-
2627		- // Use BINARY extension when possible (and safe)
2628		- $binary = $binary && $mode && preg_match('/^[0-9.]+$/', $part) && $this->hasCapability('BINARY');
2629		- $fetch_mode = $binary ? 'BINARY' : 'BODY';
2630		- $partial = $max_bytes ? sprintf('<0.%d>', $max_bytes) : '';
2631		-
2632		- // format request
2633		- $key = $this->nextTag();
2634		- $cmd = ($is_uid ? 'UID ' : '').'FETCH';
2635		- $request = "$key $cmd $id ($fetch_mode.PEEK[$part]$partial)";
2636		- $result = false;
2637		- $found = false;
2638		- $initiated = true;
2639		-
2640		- // send request
2641		- if (!$this->putLine($request)) {
2642		- $this->setError(self::ERROR_COMMAND, "Failed to send $cmd command");
2643		-
2644		- return false;
2645		- }
2646		-
2647		- if ($binary) {
2648		- // WARNING: Use $formatted argument with care, this may break binary data stream
2649		- $mode = -1;
2650		- }
2651		- }
2652		-
2653		- $line = trim($this->readLine(1024));
2654		-
2655		- if (!$line) {
2656		- break;
2657		- }
2658		-
2659		- // handle UNKNOWN-CTE response - RFC 3516, try again with standard BODY request
2660		- if ($binary && !$found && preg_match('/^'.$key.' NO \[(UNKNOWN-CTE|PARSE)\]/i', $line)) {
2661		- $binary = $initiated = false;
2662		- continue;
2663		- }
2664		-
2665		- // skip irrelevant untagged responses (we have a result already)
2666		- if ($found || !preg_match('/^\* ([0-9]+) FETCH (.*)$/', $line, $m)) {
2667		- continue;
2668		- }
2669		-
2670		- $line = $m[2];
2671		-
2672		- // handle one line response
2673		- if ($line[0] == '(' && substr($line, -1) == ')') {
2674		- // tokenize content inside brackets
2675		- // the content can be e.g.: (UID 9844 BODY[2.4] NIL)
2676		- $preg_replace = preg_replace('/(^\(|\)$)/', '', $line);
2677		- $tokens = $this->tokenizeResponse($preg_replace);
2678		-
2679		- for ($i = 0 ; $i < count($tokens) ; $i += 2) {
2680		- if (preg_match('/^(BODY|BINARY)/i', $tokens[$i])) {
2681		- $result = $tokens[$i + 1];
2682		- $found = true;
2683		- break;
2684		- }
2685		- }
2686		-
2687		- if ($result !== false) {
2688		- if ($mode == 1) {
2689		- $result = base64_decode($result);
2690		- } elseif ($mode == 2) {
2691		- $result = quoted_printable_decode($result);
2692		- } elseif ($mode == 3) {
2693		- $result = convert_uudecode($result);
2694		- }
2695		- }
2696		- } // response with string literal
2697		- elseif (preg_match('/\{([0-9]+)\}$/', $line, $m)) {
2698		- $bytes = (int)$m[1];
2699		- $prev = '';
2700		- $found = true;
2701		-
2702		- // empty body
2703		- if (!$bytes) {
2704		- $result = '';
2705		- } else {
2706		- while ($bytes > 0) {
2707		- $line = $this->readLine(8192);
2708		-
2709		- if ($line === null) {
2710		- break;
2711		- }
2712		-
2713		- $len = strlen($line);
2714		-
2715		- if ($len > $bytes) {
2716		- $line = substr($line, 0, $bytes);
2717		- $len = strlen($line);
2718		- }
2719		- $bytes -= $len;
2720		-
2721		- // BASE64
2722		- if ($mode == 1) {
2723		- $line = preg_replace('|[^a-zA-Z0-9+=/]|', '', $line);
2724		- // create chunks with proper length for base64 decoding
2725		- $line = $prev.$line;
2726		- $length = strlen($line);
2727		- if ($length % 4) {
2728		- $length = floor($length / 4) * 4;
2729		- $prev = substr($line, $length);
2730		- $line = substr($line, 0, $length);
2731		- } else {
2732		- $prev = '';
2733		- }
2734		- $line = base64_decode($line);
2735		- } // QUOTED-PRINTABLE
2736		- elseif ($mode == 2) {
2737		- $line = rtrim($line, "\t\r\0\x0B");
2738		- $line = quoted_printable_decode($line);
2739		- } // UUENCODE
2740		- elseif ($mode == 3) {
2741		- $line = rtrim($line, "\t\r\n\0\x0B");
2742		- if ($line == 'end' || preg_match('/^begin\s+[0-7]+\s+.+$/', $line)) {
2743		- continue;
2744		- }
2745		- $line = convert_uudecode($line);
2746		- } // default
2747		- elseif ($formatted) {
2748		- $line = rtrim($line, "\t\r\n\0\x0B")."\n";
2749		- }
2750		-
2751		- if ($file) {
2752		- if (fwrite($file, $line) === false) {
2753		- break;
2754		- }
2755		- } elseif ($print) {
2756		- echo $line;
2757		- } else {
2758		- $result .= $line;
2759		- }
2760		- }
2761		- }
2762		- }
2763		- } while (!$this->startsWith($line, $key, true) || !$initiated);
2764		-
2765		- if ($result !== false) {
2766		- if ($file) {
2767		- return fwrite($file, $result);
2768		- } elseif ($print) {
2769		- echo $result;
2770		-
2771		- return true;
2772		- }
2773		-
2774		- return $result;
2775		- }
2776		-
2777		- return false;
2778		- }
2779		-
2780		- /**
2781		- * Handler for IMAP APPEND command
2782		- *
2783		- * @param string $mailbox Mailbox name
2784		- * @param string|array $message The message source string or array (of strings and file pointers)
2785		- * @param array $flags Message flags
2786		- * @param string $date Message internal date
2787		- * @param bool $binary Enable BINARY append (RFC3516)
2788		- *
2789		- * @return string|bool On success APPENDUID response (if available) or True, False on failure
2790		- */
2791		- public function append($mailbox, &$message, $flags = [], $date = null, $binary = false)
2792		- {
2793		- unset($this->data['APPENDUID']);
2794		-
2795		- if ($mailbox === null || $mailbox === '') {
2796		- return false;
2797		- }
2798		-
2799		- $binary = $binary && $this->getCapability('BINARY');
2800		- $literal_plus = !$binary && isset($this->prefs['literal+']) && $this->prefs['literal+'];
2801		- $len = 0;
2802		- $msg = is_array($message) ? $message : [&$message];
2803		- $chunk_size = 512000;
2804		-
2805		- for ($i = 0, $cnt = count($msg) ; $i < $cnt ; $i++) {
2806		- if (is_resource($msg[$i])) {
2807		- $stat = fstat($msg[$i]);
2808		- if ($stat === false) {
2809		- return false;
2810		- }
2811		- $len += $stat['size'];
2812		- } else {
2813		- if (!$binary) {
2814		- $msg[$i] = str_replace("\r", '', $msg[$i]);
2815		- $msg[$i] = str_replace("\n", "\r\n", $msg[$i]);
2816		- }
2817		-
2818		- $len += strlen($msg[$i]);
2819		- }
2820		- }
2821		-
2822		- if (!$len) {
2823		- return false;
2824		- }
2825		-
2826		- // build APPEND command
2827		- $key = $this->nextTag();
2828		- $request = "$key APPEND ".$this->escape($mailbox).' ('.$this->flagsToStr($flags).')';
2829		- if (!empty($date)) {
2830		- $request .= ' '.$this->escape($date);
2831		- }
2832		- $request .= ' '.($binary ? '~' : '').'{'.$len.($literal_plus ? '+' : '').'}';
2833		-
2834		- // send APPEND command
2835		- if (!$this->putLine($request)) {
2836		- $this->setError(self::ERROR_COMMAND, "Failed to send APPEND command");
2837		-
2838		- return false;
2839		- }
2840		-
2841		- // Do not wait when LITERAL+ is supported
2842		- if (!$literal_plus) {
2843		- $line = $this->readReply();
2844		-
2845		- if ($line[0] != '+') {
2846		- $this->parseResult($line, 'APPEND: ');
2847		-
2848		- return false;
2849		- }
2850		- }
2851		-
2852		- foreach ($msg as $msg_part) {
2853		- // file pointer
2854		- if (is_resource($msg_part)) {
2855		- rewind($msg_part);
2856		- while (!feof($msg_part) && $this->fp) {
2857		- $buffer = fread($msg_part, $chunk_size);
2858		- $this->putLine($buffer, false);
2859		- }
2860		- fclose($msg_part);
2861		- } // string
2862		- else {
2863		- $size = strlen($msg_part);
2864		-
2865		- // Break up the data by sending one chunk (up to 512k) at a time.
2866		- // This approach reduces our peak memory usage
2867		- for ($offset = 0 ; $offset < $size ; $offset += $chunk_size) {
2868		- $chunk = substr($msg_part, $offset, $chunk_size);
2869		- if (!$this->putLine($chunk, false)) {
2870		- return false;
2871		- }
2872		- }
2873		- }
2874		- }
2875		-
2876		- if (!$this->putLine('')) { // \r\n
2877		- return false;
2878		- }
2879		-
2880		- do {
2881		- $line = $this->readLine();
2882		- } while (!$this->startsWith($line, $key, true, true));
2883		-
2884		- // Clear internal status cache
2885		- unset($this->data['STATUS:'.$mailbox]);
2886		-
2887		- if ($this->parseResult($line, 'APPEND: ') != self::ERROR_OK) {
2888		- return false;
2889		- }
2890		-
2891		- if (!empty($this->data['APPENDUID'])) {
2892		- return $this->data['APPENDUID'];
2893		- }
2894		-
2895		- return true;
2896		- }
2897		-
2898		- /**
2899		- * Handler for IMAP APPEND command.
2900		- *
2901		- * @param string $mailbox Mailbox name
2902		- * @param string $path Path to the file with message body
2903		- * @param string $headers Message headers
2904		- * @param array $flags Message flags
2905		- * @param string $date Message internal date
2906		- * @param bool $binary Enable BINARY append (RFC3516)
2907		- *
2908		- * @return string|bool On success APPENDUID response (if available) or True, False on failure
2909		- */
2910		- public function appendFromFile($mailbox, $path, $headers = null, $flags = [], $date = null, $binary = false)
2911		- {
2912		- // open message file
2913		- if (file_exists(realpath($path))) {
2914		- $fp = fopen($path, 'r');
2915		- }
2916		-
2917		- if (!$fp) {
2918		- $this->setError(self::ERROR_UNKNOWN, "Couldn't open $path for reading");
2919		-
2920		- return false;
2921		- }
2922		-
2923		- $message = [];
2924		- if ($headers) {
2925		- $message[] = trim($headers, "\r\n")."\r\n\r\n";
2926		- }
2927		- $message[] = $fp;
2928		-
2929		- return $this->append($mailbox, $message, $flags, $date, $binary);
2930		- }
2931		-
2932		- /**
2933		- * Send the SETACL command (RFC4314)
2934		- *
2935		- * @param string $mailbox Mailbox name
2936		- * @param string $user User name
2937		- * @param mixed $acl ACL string or array
2938		- *
2939		- * @return boolean True on success, False on failure
2940		- *
2941		- * @since 0.5-beta
2942		- */
2943		- public function setACL($mailbox, $user, $acl)
2944		- {
2945		- if (is_array($acl)) {
2946		- $acl = implode('', $acl);
2947		- }
2948		-
2949		- $result = $this->execute(
2950		- 'SETACL',
2951		- [
2952		- $this->escape($mailbox),
2953		- $this->escape($user),
2954		- strtolower($acl),
2955		- ],
2956		- self::COMMAND_NORESPONSE
2957		- );
2958		-
2959		- return ($result == self::ERROR_OK);
2960		- }
2961		-
2962		- /**
2963		- * Send the DELETEACL command (RFC4314)
2964		- *
2965		- * @param string $mailbox Mailbox name
2966		- * @param string $user User name
2967		- *
2968		- * @return boolean True on success, False on failure
2969		- *
2970		- * @since 0.5-beta
2971		- */
2972		- public function deleteACL($mailbox, $user)
2973		- {
2974		- $result = $this->execute(
2975		- 'DELETEACL',
2976		- [
2977		- $this->escape($mailbox),
2978		- $this->escape($user),
2979		- ],
2980		- self::COMMAND_NORESPONSE
2981		- );
2982		-
2983		- return ($result == self::ERROR_OK);
2984		- }
2985		-
2986		- /**
2987		- * Send the GETACL command (RFC4314)
2988		- *
2989		- * @param string $mailbox Mailbox name
2990		- *
2991		- * @return array User-rights array on success, NULL on error
2992		- * @since 0.5-beta
2993		- */
2994		- public function getACL($mailbox)
2995		- {
2996		- [$code, $response] = $this->execute('GETACL', [$this->escape($mailbox)], 0, '/^\* ACL /i');
2997		-
2998		- if ($code == self::ERROR_OK && $response) {
2999		- // Parse server response (remove "* ACL ")
3000		- $response = substr($response, 6);
3001		- $ret = $this->tokenizeResponse($response);
3002		- $mbox = array_shift($ret);
3003		- $size = count($ret);
3004		-
3005		- // Create user-rights hash array
3006		- // @TODO: consider implementing fixACL() method according to RFC4314.2.1.1
3007		- // so we could return only standard rights defined in RFC4314,
3008		- // excluding 'c' and 'd' defined in RFC2086.
3009		- if ($size % 2 == 0) {
3010		- for ($i = 0 ; $i < $size ; $i++) {
3011		- $ret[$ret[$i]] = str_split($ret[++$i]);
3012		- unset($ret[$i - 1]);
3013		- unset($ret[$i]);
3014		- }
3015		-
3016		- return $ret;
3017		- }
3018		-
3019		- $this->setError(self::ERROR_COMMAND, "Incomplete ACL response");
3020		- }
3021		- }
3022		-
3023		- /**
3024		- * Send the LISTRIGHTS command (RFC4314)
3025		- *
3026		- * @param string $mailbox Mailbox name
3027		- * @param string $user User name
3028		- *
3029		- * @return array List of user rights
3030		- * @since 0.5-beta
3031		- */
3032		- public function listRights($mailbox, $user)
3033		- {
3034		- [$code, $response] = $this->execute(
3035		- 'LISTRIGHTS',
3036		- [$this->escape($mailbox), $this->escape($user)],
3037		- 0,
3038		- '/^\* LISTRIGHTS /i'
3039		- );
3040		-
3041		- if ($code == self::ERROR_OK && $response) {
3042		- // Parse server response (remove "* LISTRIGHTS ")
3043		- $response = substr($response, 13);
3044		-
3045		- $ret_mbox = $this->tokenizeResponse($response, 1);
3046		- $ret_user = $this->tokenizeResponse($response, 1);
3047		- $granted = $this->tokenizeResponse($response, 1);
3048		- $optional = trim($response);
3049		-
3050		- return [
3051		- 'granted' => str_split($granted),
3052		- 'optional' => explode(' ', $optional),
3053		- ];
3054		- }
3055		- }
3056		-
3057		- /**
3058		- * Send the MYRIGHTS command (RFC4314)
3059		- *
3060		- * @param string $mailbox Mailbox name
3061		- *
3062		- * @return array MYRIGHTS response on success, NULL on error
3063		- * @since 0.5-beta
3064		- */
3065		- public function myRights($mailbox)
3066		- {
3067		- [$code, $response] = $this->execute('MYRIGHTS', [$this->escape($mailbox)], 0, '/^\* MYRIGHTS /i');
3068		-
3069		- if ($code == self::ERROR_OK && $response) {
3070		- // Parse server response (remove "* MYRIGHTS ")
3071		- $response = substr($response, 11);
3072		-
3073		- $ret_mbox = $this->tokenizeResponse($response, 1);
3074		- $rights = $this->tokenizeResponse($response, 1);
3075		-
3076		- return str_split($rights);
3077		- }
3078		- }
3079		-
3080		- /**
3081		- * Send the SETMETADATA command (RFC5464)
3082		- *
3083		- * @param string $mailbox Mailbox name
3084		- * @param array $entries Entry-value array (use NULL value as NIL)
3085		- *
3086		- * @return boolean True on success, False on failure
3087		- * @since 0.5-beta
3088		- */
3089		- public function setMetadata($mailbox, $entries)
3090		- {
3091		- if (!is_array($entries) || empty($entries)) {
3092		- $this->setError(self::ERROR_COMMAND, "Wrong argument for SETMETADATA command");
3093		-
3094		- return false;
3095		- }
3096		-
3097		- foreach ($entries as $name => $value) {
3098		- $entries[$name] = $this->escape($name).' '.$this->escape($value, true);
3099		- }
3100		-
3101		- $entries = implode(' ', $entries);
3102		- $result = $this->execute(
3103		- 'SETMETADATA',
3104		- [
3105		- $this->escape($mailbox),
3106		- '('.$entries.')',
3107		- ],
3108		- self::COMMAND_NORESPONSE
3109		- );
3110		-
3111		- return ($result == self::ERROR_OK);
3112		- }
3113		-
3114		- /**
3115		- * Send the SETMETADATA command with NIL values (RFC5464)
3116		- *
3117		- * @param string $mailbox Mailbox name
3118		- * @param array $entries Entry names array
3119		- *
3120		- * @return boolean True on success, False on failure
3121		- *
3122		- * @since 0.5-beta
3123		- */
3124		- public function deleteMetadata($mailbox, $entries)
3125		- {
3126		- if (!is_array($entries) && !empty($entries)) {
3127		- $entries = explode(' ', $entries);
3128		- }
3129		-
3130		- if (empty($entries)) {
3131		- $this->setError(self::ERROR_COMMAND, "Wrong argument for SETMETADATA command");
3132		-
3133		- return false;
3134		- }
3135		-
3136		- foreach ($entries as $entry) {
3137		- $data[$entry] = null;
3138		- }
3139		-
3140		- return $this->setMetadata($mailbox, $data);
3141		- }
3142		-
3143		- /**
3144		- * Send the GETMETADATA command (RFC5464)
3145		- *
3146		- * @param string $mailbox Mailbox name
3147		- * @param array $entries Entries
3148		- * @param array $options Command options (with MAXSIZE and DEPTH keys)
3149		- *
3150		- * @return array GETMETADATA result on success, NULL on error
3151		- *
3152		- * @since 0.5-beta
3153		- */
3154		- public function getMetadata($mailbox, $entries, $options = [])
3155		- {
3156		- if (!is_array($entries)) {
3157		- $entries = [$entries];
3158		- }
3159		-
3160		- // create entries string
3161		- foreach ($entries as $idx => $name) {
3162		- $entries[$idx] = $this->escape($name);
3163		- }
3164		-
3165		- $optlist = '';
3166		- $entlist = '('.implode(' ', $entries).')';
3167		-
3168		- // create options string
3169		- if (is_array($options)) {
3170		- $options = array_change_key_case($options, CASE_UPPER);
3171		- $opts = [];
3172		-
3173		- if (!empty($options['MAXSIZE'])) {
3174		- $opts[] = 'MAXSIZE '.intval($options['MAXSIZE']);
3175		- }
3176		- if (!empty($options['DEPTH'])) {
3177		- $opts[] = 'DEPTH '.intval($options['DEPTH']);
3178		- }
3179		-
3180		- if ($opts) {
3181		- $optlist = '('.implode(' ', $opts).')';
3182		- }
3183		- }
3184		-
3185		- $optlist .= ($optlist ? ' ' : '').$entlist;
3186		-
3187		- [$code, $response] = $this->execute('GETMETADATA', [
3188		- $this->escape($mailbox),
3189		- $optlist,
3190		- ]);
3191		-
3192		- if ($code == self::ERROR_OK) {
3193		- $result = [];
3194		- $data = $this->tokenizeResponse($response);
3195		-
3196		- // The METADATA response can contain multiple entries in a single
3197		- // response or multiple responses for each entry or group of entries
3198		- for ($i = 0, $size = count($data) ; $i < $size ; $i++) {
3199		- if ($data[$i] === '*'
3200		- && $data[++$i] === 'METADATA'
3201		- && is_string($mbox = $data[++$i])
3202		- && is_array($data[++$i])
3203		- ) {
3204		- for ($x = 0, $size2 = count($data[$i]) ; $x < $size2 ; $x += 2) {
3205		- if ($data[$i][$x + 1] !== null) {
3206		- $result[$mbox][$data[$i][$x]] = $data[$i][$x + 1];
3207		- }
3208		- }
3209		- }
3210		- }
3211		-
3212		- return $result;
3213		- }
3214		- }
3215		-
3216		- /**
3217		- * Send the SETANNOTATION command (draft-daboo-imap-annotatemore)
3218		- *
3219		- * @param string $mailbox Mailbox name
3220		- * @param array $data Data array where each item is an array with
3221		- * three elements: entry name, attribute name, value
3222		- *
3223		- * @return boolean True on success, False on failure
3224		- * @since 0.5-beta
3225		- */
3226		- public function setAnnotation($mailbox, $data)
3227		- {
3228		- if (!is_array($data) || empty($data)) {
3229		- $this->setError(self::ERROR_COMMAND, "Wrong argument for SETANNOTATION command");
3230		-
3231		- return false;
3232		- }
3233		-
3234		- foreach ($data as $entry) {
3235		- // ANNOTATEMORE drafts before version 08 require quoted parameters
3236		- $entries[] = sprintf(
3237		- '%s (%s %s)',
3238		- $this->escape($entry[0], true),
3239		- $this->escape($entry[1], true),
3240		- $this->escape($entry[2], true)
3241		- );
3242		- }
3243		-
3244		- $entries = implode(' ', $entries);
3245		- $result = $this->execute('SETANNOTATION', [
3246		- $this->escape($mailbox),
3247		- $entries,
3248		- ], self::COMMAND_NORESPONSE);
3249		-
3250		- return ($result == self::ERROR_OK);
3251		- }
3252		-
3253		- /**
3254		- * Send the SETANNOTATION command with NIL values (draft-daboo-imap-annotatemore)
3255		- *
3256		- * @param string $mailbox Mailbox name
3257		- * @param array $data Data array where each item is an array with
3258		- * two elements: entry name and attribute name
3259		- *
3260		- * @return boolean True on success, False on failure
3261		- *
3262		- * @since 0.5-beta
3263		- */
3264		- public function deleteAnnotation($mailbox, $data)
3265		- {
3266		- if (!is_array($data) || empty($data)) {
3267		- $this->setError(self::ERROR_COMMAND, "Wrong argument for SETANNOTATION command");
3268		-
3269		- return false;
3270		- }
3271		-
3272		- return $this->setAnnotation($mailbox, $data);
3273		- }
3274		-
3275		- /**
3276		- * Send the GETANNOTATION command (draft-daboo-imap-annotatemore)
3277		- *
3278		- * @param string $mailbox Mailbox name
3279		- * @param array $entries Entries names
3280		- * @param array $attribs Attribs names
3281		- *
3282		- * @return array Annotations result on success, NULL on error
3283		- *
3284		- * @since 0.5-beta
3285		- */
3286		- public function getAnnotation($mailbox, $entries, $attribs)
3287		- {
3288		- if (!is_array($entries)) {
3289		- $entries = [$entries];
3290		- }
3291		-
3292		- // create entries string
3293		- // ANNOTATEMORE drafts before version 08 require quoted parameters
3294		- foreach ($entries as $idx => $name) {
3295		- $entries[$idx] = $this->escape($name, true);
3296		- }
3297		- $entries = '('.implode(' ', $entries).')';
3298		-
3299		- if (!is_array($attribs)) {
3300		- $attribs = [$attribs];
3301		- }
3302		-
3303		- // create attributes string
3304		- foreach ($attribs as $idx => $name) {
3305		- $attribs[$idx] = $this->escape($name, true);
3306		- }
3307		- $attribs = '('.implode(' ', $attribs).')';
3308		-
3309		- [$code, $response] = $this->execute('GETANNOTATION', [
3310		- $this->escape($mailbox),
3311		- $entries,
3312		- $attribs,
3313		- ]);
3314		-
3315		- if ($code == self::ERROR_OK) {
3316		- $result = [];
3317		- $data = $this->tokenizeResponse($response);
3318		-
3319		- // Here we returns only data compatible with METADATA result format
3320		- if (!empty($data) && ($size = count($data))) {
3321		- for ($i = 0 ; $i < $size ; $i++) {
3322		- $entry = $data[$i];
3323		- if (isset($mbox) && is_array($entry)) {
3324		- $attribs = $entry;
3325		- $entry = $last_entry;
3326		- } elseif ($entry == '*') {
3327		- if ($data[$i + 1] == 'ANNOTATION') {
3328		- $mbox = $data[$i + 2];
3329		- unset($data[$i]); // "*"
3330		- unset($data[++$i]); // "ANNOTATION"
3331		- unset($data[++$i]); // Mailbox
3332		- } // get rid of other untagged responses
3333		- else {
3334		- unset($mbox);
3335		- unset($data[$i]);
3336		- }
3337		- continue;
3338		- } elseif (isset($mbox)) {
3339		- $attribs = $data[++$i];
3340		- } else {
3341		- unset($data[$i]);
3342		- continue;
3343		- }
3344		-
3345		- if (!empty($attribs)) {
3346		- for ($x = 0, $len = count($attribs) ; $x < $len ;) {
3347		- $attr = $attribs[$x++];
3348		- $value = $attribs[$x++];
3349		- if ($attr == 'value.priv' && $value !== null) {
3350		- $result[$mbox]['/private'.$entry] = $value;
3351		- } elseif ($attr == 'value.shared' && $value !== null) {
3352		- $result[$mbox]['/shared'.$entry] = $value;
3353		- }
3354		- }
3355		- }
3356		- $last_entry = $entry;
3357		- unset($data[$i]);
3358		- }
3359		- }
3360		-
3361		- return $result;
3362		- }
3363		- }
3364		-
3365		- /**
3366		- * Returns BODYSTRUCTURE for the specified message.
3367		- *
3368		- * @param string $mailbox Folder name
3369		- * @param int $id Message sequence number or UID
3370		- * @param bool $is_uid True if $id is an UID
3371		- *
3372		- * @return array/bool Body structure array or False on error.
3373		- * @since 0.6
3374		- */
3375		- public function getStructure($mailbox, $id, $is_uid = false)
3376		- {
3377		- $result = $this->fetch($mailbox, $id, $is_uid, ['BODYSTRUCTURE']);
3378		-
3379		- if (is_array($result)) {
3380		- $result = array_shift($result);
3381		-
3382		- return $result->bodystructure;
3383		- }
3384		-
3385		- return false;
3386		- }
3387		-
3388		- /**
3389		- * Returns data of a message part according to specified structure.
3390		- *
3391		- * @param array $structure Message structure (getStructure() result)
3392		- * @param string $part Message part identifier
3393		- *
3394		- * @return array Part data as hash array (type, encoding, charset, size)
3395		- */
3396		- public static function getStructurePartData($structure, $part)
3397		- {
3398		- $part_a = self::getStructurePartArray($structure, $part);
3399		- $data = [];
3400		-
3401		- if (empty($part_a)) {
3402		- return $data;
3403		- }
3404		-
3405		- // content-type
3406		- if (is_array($part_a[0])) {
3407		- $data['type'] = 'multipart';
3408		- } else {
3409		- $data['type'] = strtolower($part_a[0]);
3410		- $data['subtype'] = strtolower($part_a[1]);
3411		- $data['encoding'] = strtolower($part_a[5]);
3412		-
3413		- // charset
3414		- if (is_array($part_a[2])) {
3415		- foreach ($part_a[2] as $key => $val) {
3416		- if (strcasecmp($val, 'charset') == 0) {
3417		- $data['charset'] = $part_a[2][$key + 1];
3418		- break;
3419		- }
3420		- }
3421		- }
3422		- }
3423		-
3424		- // size
3425		- $data['size'] = intval($part_a[6]);
3426		-
3427		- return $data;
3428		- }
3429		-
3430		- public static function getStructurePartArray($a, $part)
3431		- {
3432		- if (!is_array($a)) {
3433		- return false;
3434		- }
3435		-
3436		- if (empty($part)) {
3437		- return $a;
3438		- }
3439		-
3440		- $ctype = is_string($a[0]) && is_string($a[1]) ? $a[0].'/'.$a[1] : '';
3441		-
3442		- if (strcasecmp($ctype, 'message/rfc822') == 0) {
3443		- $a = $a[8];
3444		- }
3445		-
3446		- if (strpos($part, '.') > 0) {
3447		- $orig_part = $part;
3448		- $pos = strpos($part, '.');
3449		- $rest = substr($orig_part, $pos + 1);
3450		- $part = substr($orig_part, 0, $pos);
3451		-
3452		- return self::getStructurePartArray($a[$part - 1], $rest);
3453		- } elseif ($part > 0) {
3454		- return (is_array($a[$part - 1])) ? $a[$part - 1] : $a;
3455		- }
3456		- }
3457		-
3458		- /**
3459		- * Creates next command identifier (tag)
3460		- *
3461		- * @return string Command identifier
3462		- * @since 0.5-beta
3463		- */
3464		- public function nextTag()
3465		- {
3466		- $this->cmd_num++;
3467		- $this->cmd_tag = sprintf('A%04d', $this->cmd_num);
3468		-
3469		- return $this->cmd_tag;
3470		- }
3471		-
3472		- /**
3473		- * Sends IMAP command and parses result
3474		- *
3475		- * @param string $command IMAP command
3476		- * @param array $arguments Command arguments
3477		- * @param int $options Execution options
3478		- * @param string $filter Line filter (regexp)
3479		- *
3480		- * @return mixed Response code or list of response code and data
3481		- * @since 0.5-beta
3482		- */
3483		- public function execute($command, $arguments = [], $options = 0, $filter = null)
3484		- {
3485		- $tag = $this->nextTag();
3486		- $query = $tag.' '.$command;
3487		- $noresp = ($options & self::COMMAND_NORESPONSE);
3488		- $response = $noresp ? null : '';
3489		-
3490		- if (!empty($arguments)) {
3491		- foreach ($arguments as $arg) {
3492		- $query .= ' '.self::r_implode($arg);
3493		- }
3494		- }
3495		-
3496		- // Send command
3497		- if (!$this->putLineC($query, true, ($options & self::COMMAND_ANONYMIZED))) {
3498		- preg_match('/^[A-Z0-9]+ ((UID )?[A-Z]+)/', $query, $matches);
3499		- $cmd = $matches[1] ? : 'UNKNOWN';
3500		- $this->setError(self::ERROR_COMMAND, "Failed to send $cmd command");
3501		-
3502		- return $noresp ? self::ERROR_COMMAND : [self::ERROR_COMMAND, ''];
3503		- }
3504		-
3505		- // Parse response
3506		- do {
3507		- $line = $this->readFullLine(4096);
3508		-
3509		- if ($response !== null) {
3510		- if (!$filter || preg_match($filter, $line)) {
3511		- $response .= $line;
3512		- }
3513		- }
3514		-
3515		- // parse untagged response for [COPYUID 1204196876 3456:3457 123:124] (RFC6851)
3516		- if ($line && $command == 'UID MOVE') {
3517		- if (preg_match("/^\* OK \[COPYUID [0-9]+ ([0-9,:]+) ([0-9,:]+)\]/i", $line, $m)) {
3518		- $this->data['COPYUID'] = [$m[1], $m[2]];
3519		- }
3520		- }
3521		- } while (!$this->startsWith($line, $tag.' ', true, true));
3522		-
3523		- $code = $this->parseResult($line, $command.': ');
3524		-
3525		- // Remove last line from response
3526		- if ($response) {
3527		- if (!$filter) {
3528		- $line_len = min(strlen($response), strlen($line));
3529		- $response = substr($response, 0, -$line_len);
3530		- }
3531		-
3532		- $response = rtrim($response, "\r\n");
3533		- }
3534		-
3535		- // optional CAPABILITY response
3536		- if (($options & self::COMMAND_CAPABILITY) && $code == self::ERROR_OK
3537		- && preg_match('/\[CAPABILITY ([^]]+)\]/i', $line, $matches)
3538		- ) {
3539		- $this->parseCapability($matches[1], true);
3540		- }
3541		-
3542		- // return last line only (without command tag, result and response code)
3543		- if ($line && ($options & self::COMMAND_LASTLINE)) {
3544		- $response = preg_replace("/^$tag (OK|NO|BAD|BYE|PREAUTH)?\s*(\[[a-z-]+\])?\s*/i", '', trim($line));
3545		- }
3546		-
3547		- // return raw last line only (without command tag, result and response code)
3548		- if ($line && ($options & self::COMMAND_RAW_LASTLINE)) {
3549		- $response = preg_replace("/^$tag (OK|NO|BAD|BYE|PREAUTH)?\s*/i", '', trim($line));
3550		- }
3551		-
3552		- return $noresp ? $code : [$code, $response];
3553		- }
3554		-
3555		- /**
3556		- * Splits IMAP response into string tokens
3557		- *
3558		- * @param string &$str The IMAP's server response
3559		- * @param int $num Number of tokens to return
3560		- *
3561		- * @return mixed Tokens array or string if $num=1
3562		- * @since 0.5-beta
3563		- */
3564		- public static function tokenizeResponse(&$str, $num = 0)
3565		- {
3566		- $result = [];
3567		-
3568		- while (!$num || count($result) < $num) {
3569		- // remove spaces from the beginning of the string
3570		- $str = ltrim($str);
3571		-
3572		- switch ($str[0]) {
3573		-
3574		- // String literal
3575		- case '{':
3576		- if (($epos = strpos($str, "}\r\n", 1)) == false) {
3577		- // error
3578		- }
3579		- if (!is_numeric(($bytes = substr($str, 1, $epos - 1)))) {
3580		- // error
3581		- }
3582		-
3583		- $result[] = $bytes ? substr($str, $epos + 3, $bytes) : '';
3584		- $str = substr($str, $epos + 3 + $bytes);
3585		- break;
3586		-
3587		- // Quoted string
3588		- case '"':
3589		- $len = strlen($str);
3590		-
3591		- for ($pos = 1 ; $pos < $len ; $pos++) {
3592		- if ($str[$pos] == '"') {
3593		- break;
3594		- }
3595		- if ($str[$pos] == "\\") {
3596		- if ($str[$pos + 1] == '"' || $str[$pos + 1] == "\\") {
3597		- $pos++;
3598		- }
3599		- }
3600		- }
3601		-
3602		- // we need to strip slashes for a quoted string
3603		- $result[] = stripslashes(substr($str, 1, $pos - 1));
3604		- $str = substr($str, $pos + 1);
3605		- break;
3606		-
3607		- // Parenthesized list
3608		- case '(':
3609		- $str = substr($str, 1);
3610		- $result[] = self::tokenizeResponse($str);
3611		- break;
3612		-
3613		- case ')':
3614		- $str = substr($str, 1);
3615		-
3616		- return $result;
3617		-
3618		- // String atom, number, astring, NIL, *, %
3619		- default:
3620		- // empty string
3621		- if ($str === '' || $str === null) {
3622		- break 2;
3623		- }
3624		-
3625		- // excluded chars: SP, CTL, ), DEL
3626		- // we do not exclude [ and ] (#1489223)
3627		- if (preg_match('/^([^\x00-\x20\x29\x7F]+)/', $str, $m)) {
3628		- $result[] = $m[1] == 'NIL' ? null : $m[1];
3629		- $str = substr($str, strlen($m[1]));
3630		- }
3631		- break;
3632		- }
3633		- }
3634		-
3635		- return $num == 1 ? $result[0] : $result;
3636		- }
3637		-
3638		- /**
3639		- * Joins IMAP command line elements (recursively)
3640		- */
3641		- protected static function r_implode($element)
3642		- {
3643		- $string = '';
3644		-
3645		- if (is_array($element)) {
3646		- reset($element);
3647		- foreach ($element as $value) {
3648		- $string .= ' '.self::r_implode($value);
3649		- }
3650		- } else {
3651		- return $element;
3652		- }
3653		-
3654		- return '('.trim($string).')';
3655		- }
3656		-
3657		- /**
3658		- * Converts message identifiers array into sequence-set syntax
3659		- *
3660		- * @param array $messages Message identifiers
3661		- * @param bool $force Forces compression of any size
3662		- *
3663		- * @return string Compressed sequence-set
3664		- */
3665		- public static function compressMessageSet($messages, $force = false)
3666		- {
3667		- // given a comma delimited list of independent mid's,
3668		- // compresses by grouping sequences together
3669		- if (!is_array($messages)) {
3670		- // if less than 255 bytes long, let's not bother
3671		- if (!$force && strlen($messages) < 255) {
3672		- return preg_match('/[^0-9:,*]/', $messages) ? 'INVALID' : $messages;
3673		- }
3674		-
3675		- // see if it's already been compressed
3676		- if (strpos($messages, ':') !== false) {
3677		- return preg_match('/[^0-9:,*]/', $messages) ? 'INVALID' : $messages;
3678		- }
3679		-
3680		- // separate, then sort
3681		- $messages = explode(',', $messages);
3682		- }
3683		-
3684		- sort($messages);
3685		-
3686		- $result = [];
3687		- $start = $prev = $messages[0];
3688		-
3689		- foreach ($messages as $id) {
3690		- $incr = $id - $prev;
3691		- if ($incr > 1) { // found a gap
3692		- if ($start == $prev) {
3693		- $result[] = $prev; // push single id
3694		- } else {
3695		- $result[] = $start.':'.$prev; // push sequence as start_id:end_id
3696		- }
3697		- $start = $id; // start of new sequence
3698		- }
3699		- $prev = $id;
3700		- }
3701		-
3702		- // handle the last sequence/id
3703		- if ($start == $prev) {
3704		- $result[] = $prev;
3705		- } else {
3706		- $result[] = $start.':'.$prev;
3707		- }
3708		-
3709		- // return as comma separated string
3710		- $result = implode(',', $result);
3711		-
3712		- return preg_match('/[^0-9:,*]/', $result) ? 'INVALID' : $result;
3713		- }
3714		-
3715		- /**
3716		- * Converts message sequence-set into array
3717		- *
3718		- * @param string $messages Message identifiers
3719		- *
3720		- * @return array List of message identifiers
3721		- */
3722		- public static function uncompressMessageSet($messages)
3723		- {
3724		- if (empty($messages)) {
3725		- return [];
3726		- }
3727		-
3728		- $result = [];
3729		- $messages = explode(',', $messages);
3730		-
3731		- foreach ($messages as $idx => $part) {
3732		- $items = explode(':', $part);
3733		- $max = max($items[0], $items[1] ?? $items[0]);
3734		-
3735		- for ($x = $items[0] ; $x <= $max ; $x++) {
3736		- $result[] = (int)$x;
3737		- }
3738		- unset($messages[$idx]);
3739		- }
3740		-
3741		- return $result;
3742		- }
3743		-
3744		- /**
3745		- * Clear internal status cache
3746		- */
3747		- protected function clear_status_cache($mailbox)
3748		- {
3749		- unset($this->data['STATUS:'.$mailbox]);
3750		-
3751		- $keys = ['EXISTS', 'RECENT', 'UNSEEN', 'UID-MAP'];
3752		-
3753		- foreach ($keys as $key) {
3754		- unset($this->data[$key]);
3755		- }
3756		- }
3757		-
3758		- /**
3759		- * Clear internal cache of the current mailbox
3760		- */
3761		- protected function clear_mailbox_cache()
3762		- {
3763		- $this->clear_status_cache($this->selected);
3764		-
3765		- $keys = [
3766		- 'UIDNEXT',
3767		- 'UIDVALIDITY',
3768		- 'HIGHESTMODSEQ',
3769		- 'NOMODSEQ',
3770		- 'PERMANENTFLAGS',
3771		- 'QRESYNC',
3772		- 'VANISHED',
3773		- 'READ-WRITE',
3774		- ];
3775		-
3776		- foreach ($keys as $key) {
3777		- unset($this->data[$key]);
3778		- }
3779		- }
3780		-
3781		- /**
3782		- * Converts flags array into string for inclusion in IMAP command
3783		- *
3784		- * @param array $flags Flags (see self::flags)
3785		- *
3786		- * @return string Space-separated list of flags
3787		- */
3788		- protected function flagsToStr($flags)
3789		- {
3790		- foreach ((array)$flags as $idx => $flag) {
3791		- if ($flag = $this->flags[strtoupper($flag)]) {
3792		- $flags[$idx] = $flag;
3793		- }
3794		- }
3795		-
3796		- return implode(' ', (array)$flags);
3797		- }
3798		-
3799		- /**
3800		- * CAPABILITY response parser
3801		- */
3802		- protected function parseCapability($str, $trusted = false)
3803		- {
3804		- $str = preg_replace('/^\* CAPABILITY /i', '', $str);
3805		-
3806		- $this->capability = explode(' ', strtoupper($str));
3807		-
3808		- if (!empty($this->prefs['disabled_caps'])) {
3809		- $this->capability = array_diff($this->capability, $this->prefs['disabled_caps']);
3810		- }
3811		-
3812		- if (!isset($this->prefs['literal+']) && in_array('LITERAL+', $this->capability)) {
3813		- $this->prefs['literal+'] = true;
3814		- }
3815		-
3816		- if ($trusted) {
3817		- $this->capability_readed = true;
3818		- }
3819		- }
3820		-
3821		- /**
3822		- * Escapes a string when it contains special characters (RFC3501)
3823		- *
3824		- * @param string $string IMAP string
3825		- * @param boolean $force_quotes Forces string quoting (for atoms)
3826		- *
3827		- * @return string String atom, quoted-string or string literal
3828		- * @todo lists
3829		- */
3830		- public static function escape($string, $force_quotes = false)
3831		- {
3832		- if ($string === null) {
3833		- return 'NIL';
3834		- }
3835		-
3836		- if ($string === '') {
3837		- return '""';
3838		- }
3839		-
3840		- // atom-string (only safe characters)
3841		- if (!$force_quotes && !preg_match('/[\x00-\x20\x22\x25\x28-\x2A\x5B-\x5D\x7B\x7D\x80-\xFF]/', $string)) {
3842		- return $string;
3843		- }
3844		-
3845		- // quoted-string
3846		- if (!preg_match('/[\r\n\x00\x80-\xFF]/', $string)) {
3847		- return '"'.addcslashes($string, '\\"').'"';
3848		- }
3849		-
3850		- // literal-string
3851		- return sprintf("{%d}\r\n%s", strlen($string), $string);
3852		- }
3853		-
3854		- /**
3855		- * Set the value of the debugging flag.
3856		- *
3857		- * @param boolean $debug New value for the debugging flag.
3858		- * @param callback $handler Logging handler function
3859		- *
3860		- * @since 0.5-stable
3861		- */
3862		- public function setDebug($debug, $handler = null)
3863		- {
3864		- $this->debug = $debug;
3865		- $this->debug_handler = $handler;
3866		- }
3867		-
3868		- /**
3869		- * Write the given debug text to the current debug output handler.
3870		- *
3871		- * @param string $message Debug message text.
3872		- *
3873		- * @since 0.5-stable
3874		- */
3875		- protected function debug($message)
3876		- {
3877		- if (($len = strlen($message)) > self::DEBUG_LINE_LENGTH) {
3878		- $diff = $len - self::DEBUG_LINE_LENGTH;
3879		- $message = substr($message, 0, self::DEBUG_LINE_LENGTH)
3880		- ."... [truncated $diff bytes]";
3881		- }
3882		-
3883		- if ($this->resourceid) {
3884		- $message = sprintf('[%s] %s', $this->resourceid, $message);
3885		- }
3886		-
3887		- if ($this->debug_handler) {
3888		- call_user_func_array($this->debug_handler, [&$this, $message]);
3889		- } else {
3890		- echo "DEBUG: $message\n";
3891		- }
3892		- }
3893		-
3894		- public function getRawLastLine()
3895		- {
3896		- return $this->rawLastLine;
3897		- }
3898		-}