imap.php

<?php
 
namespace Bitrix\Mail;
 
use Bitrix\Main;
use Bitrix\Main\Text\BinaryString;
use Bitrix\Main\Text\Encoding;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\Text\Emoji;
 
Loc::loadMessages(__FILE__);
 
class Imap
{
    const LOG_LEVEL_WRITE = 1;
    const LOG_LEVEL_READ = 2;
 
    const ERR_CONNECT          = 101;
    const ERR_REJECTED         = 102;
    const ERR_COMMUNICATE      = 103;
    const ERR_EMPTY_RESPONSE   = 104;
    const ERR_BAD_SERVER       = 105;
 
    const ERR_STARTTLS         = 201;
    const ERR_COMMAND_REJECTED = 202;
    const ERR_CAPABILITY       = 203;
    const ERR_AUTH             = 204;
    const ERR_AUTH_MECH        = 205;
    const ERR_AUTH_OAUTH       = 206;
    const ERR_LIST             = 207;
    const ERR_SELECT           = 208;
    const ERR_SEARCH           = 209;
    const ERR_FETCH            = 210;
    const ERR_APPEND           = 211;
    const ERR_STORE            = 212;
 
    protected $stream, $errors;
    protected $sessState, $sessCapability, $sessCounter, $sessUntagged, $sessMailbox;
    protected $logLevel = 0, $logPath;
 
    protected $options = array();
 
    protected static $atomRegex    = '[^\x00-\x20\x22\x25\x28-\x2a\x5c\x5d\x7b\x7f-\xff]+';
    protected static $qcharRegex   = '[^\x00\x0a\x0d\x22\x5c\x80-\xff]|\x5c[\x5c\x22]';
    protected static $qcharExtRegex = '[^\x00\x0a\x0d\x22\x5c]|\x5c[\x5c\x22]'; // #119098
    protected static $astringRegex = '[^\x00-\x20\x22\x25\x28-\x2a\x5c\x7b\x7f-\xff]+';
 
    public function __construct($host, $port, $tls, $strict, $login, $password, $encoding = null)
    {
        $this->reset();
 
        $strict = (bool) $strict;
 
        $this->options = array(
            'host'    => $host,
            'port'    => $port,
            'tls'     => $tls,
            'socket'  => sprintf('%s://%s:%s', ($tls ? 'ssl' : 'tcp'), $host, $port),
            'timeout' => \COption::getOptionInt('mail', 'connect_timeout', B_MAIL_TIMEOUT),
            'context' => stream_context_create(array(
                'ssl' => array(
                    'verify_peer' => $strict,
                    'verify_peer_name' => $strict,
                    'crypto_method' => STREAM_CRYPTO_METHOD_ANY_CLIENT,
                )
            )),
            'login'    => $login,
            'password' => $password,
            'encoding' => $encoding ?: LANG_CHARSET,
        );
 
        $logParams = Main\Config\Configuration::getValue('imap');
        if(isset($logParams["log_level"]) && $logParams["log_level"] > 0)
        {
            $this->logLevel = $logParams["log_level"];
            if(isset($logParams["log_path"]) && $logParams["log_path"] <> '')
            {
                $this->logPath = $logParams["log_path"];
            }
        }
    }
 
    public function __destruct()
    {
        $this->disconnect();
    }
 
    protected function disconnect()
    {
        if (!is_null($this->stream))
        {
            @fclose($this->stream);
            unset($this->stream);
        }
    }
 
    protected function reset()
    {
        $this->disconnect();
 
        unset($this->sessState);
        unset($this->sessCapability);
        $this->sessCounter = 0;
        $this->sessUntagged = array();
        $this->sessMailbox = array(
            'name'        => null,
            'exists'      => null,
            'uidvalidity' => null,
            'permanentflags' => null,
        );
        $this->errors = new Main\ErrorCollection();
    }
 
    public function getState()
    {
        return $this->sessState;
    }
 
    public function connect(&$error)
    {
        $error = null;
 
        if (!empty($this->sessState))
            return true;
 
        $resource = @stream_socket_client(
            $this->options['socket'], $errno, $errstr, $this->options['timeout'],
            STREAM_CLIENT_CONNECT, $this->options['context']
        );
 
        if ($resource === false)
        {
            $error = $this->errorMessage(Imap::ERR_CONNECT, $errno ?: null);
            return false;
        }
 
        $this->stream = $resource;
 
        if ($this->options['timeout'] > 0)
            stream_set_timeout($this->stream, $this->options['timeout']);
 
        $prompt = $this->readLine();
 
        if ($prompt !== false && preg_match('/^\* (OK|PREAUTH)/i', $prompt, $matches))
        {
            if ($matches[1] == 'OK')
                $this->sessState = 'no_auth';
            elseif ($matches[1] == 'PREAUTH')
                $this->sessState = 'auth';
        }
        else
        {
            if ($prompt === false)
                $error = Imap::ERR_EMPTY_RESPONSE;
            elseif (preg_match('/^\* BYE/i', $prompt))
                $error = Imap::ERR_REJECTED;
            else
                $error = Imap::ERR_BAD_SERVER;
 
            $error = $this->errorMessage(array(Imap::ERR_CONNECT, $error));
 
            return false;
        }
 
        if (!$this->capability($error))
            return false;
 
        if (!$this->options['tls'] && preg_match('/ \x20 STARTTLS ( \x20 | \r\n ) /ix', $this->sessCapability))
        {
            if (!$this->starttls($error))
                return false;
        }
 
        return true;
    }
 
    protected function starttls(&$error)
    {
        $error = null;
 
        if (!$this->sessState)
        {
            $error = $this->errorMessage(Imap::ERR_STARTTLS);
            return false;
        }
 
        $response = $this->executeCommand('STARTTLS', $error);
 
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage(array(Imap::ERR_STARTTLS, $error), $response);
 
            return false;
        }
 
        if (stream_socket_enable_crypto($this->stream, true, STREAM_CRYPTO_METHOD_ANY_CLIENT))
        {
            if (!$this->capability($error))
            {
                return false;
            }
        }
        else
        {
            $this->reset();
 
            $error = $this->errorMessage(Imap::ERR_STARTTLS);
            return false;
        }
 
        return true;
    }
 
    protected function capability(&$error)
    {
        $error = null;
 
        if (!$this->sessState)
        {
            $error = $this->errorMessage(Imap::ERR_CAPABILITY);
            return false;
        }
 
        $response = $this->executeCommand('CAPABILITY', $error);
 
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage(array(Imap::ERR_CAPABILITY, $error), $response);
 
            return false;
        }
 
        $regex = '/^ \* \x20 CAPABILITY /ix';
        foreach ($this->getUntagged($regex, true) as $item)
            $this->sessCapability = $item[0];
 
        return true;
    }
 
    public function authenticate(&$error)
    {
        $error = null;
 
        if (!$this->connect($error))
            return false;
        if (in_array($this->sessState, array('auth', 'select')))
            return true;
 
        $mech = false;
        $token = null;
 
        if (preg_match('/ \x20 AUTH=XOAUTH2 ( \x20 | \r\n ) /ix', $this->sessCapability))
        {
            $token = Helper\OAuth::getTokenByMeta($this->options['password']);
 
            if (!empty($token))
            {
                $mech = 'oauth';
            }
            else if (false === $token)
            {
                $error = $this->errorMessage(array(Imap::ERR_AUTH, Imap::ERR_AUTH_OAUTH));
                return false;
            }
        }
 
        if ($mech == false)
        {
            if (preg_match('/ \x20 AUTH=PLAIN ( \x20 | \r\n ) /ix', $this->sessCapability))
                $mech = 'plain';
            elseif (!preg_match('/ \x20 LOGINDISABLED ( \x20 | \r\n ) /ix', $this->sessCapability))
                $mech = 'login';
        }
 
        if (!$mech)
        {
            $error = $this->errorMessage(array(Imap::ERR_AUTH, Imap::ERR_AUTH_MECH));
            return false;
        }
 
        if ($mech == 'oauth')
        {
            $response = $this->executeCommand('AUTHENTICATE XOAUTH2', $error);
 
            if (mb_strpos($response, '+') !== 0)
            {
                $error = $error == Imap::ERR_COMMAND_REJECTED ? Imap::ERR_AUTH_MECH : $error;
                $error = $this->errorMessage(array(Imap::ERR_AUTH, $error), $response);
 
                return false;
            }
 
            $response = $this->exchange(base64_encode(sprintf(
                "user=%s\x01auth=Bearer %s\x01\x01", $this->options['login'], $token
            )), $error);
 
            if (mb_strpos($response, '+') === 0)
                $response = $this->exchange("\r\n", $error);
        }
        elseif ($mech == 'plain')
        {
            $response = $this->executeCommand('AUTHENTICATE PLAIN', $error);
 
            if (mb_strpos($response, '+') !== 0)
            {
                $error = $error == Imap::ERR_COMMAND_REJECTED ? Imap::ERR_AUTH_MECH : $error;
                $error = $this->errorMessage(array(Imap::ERR_AUTH, $error), $response);
 
                return false;
            }
 
            $response = $this->exchange(base64_encode(sprintf(
                "\x00%s\x00%s",
                Encoding::convertEncoding($this->options['login'], $this->options['encoding'], 'UTF-8'),
                Encoding::convertEncoding($this->options['password'], $this->options['encoding'], 'UTF-8')
            )), $error);
        }
        else // if ($mech == 'login')
        {
            $response = $this->executeCommand(sprintf(
                'LOGIN %s %s',
                static::prepareString($this->options['login']),
                static::prepareString($this->options['password'])
            ), $error);
        }
 
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage(array(Imap::ERR_AUTH, $error), $response);
 
            return false;
        }
 
        $this->sessState = 'auth';
 
        if (!$this->capability($error))
            return false;
 
        return true;
    }
 
    public function select($mailbox, &$error)
    {
        $error = null;
 
        if (!$this->authenticate($error))
            return false;
        if ($this->sessState == 'select' && $mailbox == $this->sessMailbox['name'])
            return $this->sessMailbox;
 
        $response = $this->executeCommand(sprintf(
            'SELECT "%s"', static::escapeQuoted($this->encodeUtf7Imap($mailbox))
        ), $error);
 
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage(array(Imap::ERR_SELECT, $error), $response);
 
            return false;
        }
 
        $this->sessState = 'select';
        $this->sessMailbox = array(
            'name'        => $mailbox,
            'exists'      => null,
            'uidvalidity' => null,
        );
 
        $regex = '/^ \* \x20 ( \d+ ) \x20 EXISTS /ix';
        foreach ($this->getUntagged($regex, true) as $item)
            $this->sessMailbox['exists'] = $item[1][1];
 
        $regex = '/^ \* \x20 OK \x20 \[ UIDVALIDITY \x20 ( \d+ ) \] /ix';
        foreach ($this->getUntagged($regex, true) as $item)
            $this->sessMailbox['uidvalidity'] = $item[1][1];
 
        $regex = sprintf(
            '/^ \* \x20 OK \x20 \[ PERMANENTFLAGS \x20 \‍( ( ( \x5c? %1$s | \x5c \* ) ( \x20 (?2) )* )? \‍) \] /ix',
            self::$atomRegex
        );
        foreach ($this->getUntagged($regex, true) as $item)
        {
            $this->sessMailbox['permanentflags'] = explode("\x20", $item[1][1]);
        }
 
        if (!$this->capability($error))
            return false;
 
        return $this->sessMailbox;
    }
 
    public function examine($mailbox, &$error)
    {
        $error = null;
 
        if (!$this->authenticate($error))
            return false;
 
        $response = $this->executeCommand(sprintf(
            'EXAMINE "%s"', static::escapeQuoted($this->encodeUtf7Imap($mailbox))
        ), $error);
 
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage(array(Imap::ERR_SELECT, $error), $response);
 
            return false;
        }
 
        $result = array();
 
        $regex = '/^ \* \x20 ( \d+ ) \x20 EXISTS /ix';
        foreach ($this->getUntagged($regex, true) as $item)
            $result['exists'] = $item[1][1];
 
        $regex = '/^ \* \x20 OK \x20 \[ UIDVALIDITY \x20 ( \d+ ) \] /ix';
        foreach ($this->getUntagged($regex, true) as $item)
            $result['uidvalidity'] = $item[1][1];
 
        $regex = sprintf(
            '/^ \* \x20 OK \x20 \[ PERMANENTFLAGS \x20 \‍( ( ( \x5c? %1$s | \x5c \* ) ( \x20 (?2) )* )? \‍) \] /ix',
            self::$atomRegex
        );
        foreach ($this->getUntagged($regex, true) as $item)
        {
            $result['permanentflags'] = explode("\x20", $item[1][1]);
        }
 
        return $result;
    }
 
    public function singin(&$error)
    {
        $error = null;
 
        return $this->authenticate($error);
    }
 
    public function fetch($uid, $mailbox, $range, $select, &$error, $outputFormat = 'smart')
    {
        $error = null;
 
        if (!preg_match('/(([1-9]\d*|\*)(:(?2))?)(,(?1))*/', $range))
        {
            return false;
        }
 
        if (empty($select))
        {
            $select = '(FLAGS)';
        }
        else if (is_array($select))
        {
            $select = sprintf('(%s)', join(' ', $select));
        }
 
        if (!$this->select($mailbox, $error))
        {
            return false;
        }
 
        $list = array();
 
        if ($this->sessMailbox['exists'] > 0)
        {
            $fetchUntaggedRegex = '/^ \* \x20 ( \d+ ) \x20 FETCH \x20 \‍( ( .+ ) \‍) \r\n $/isx';
            $this->getUntagged($fetchUntaggedRegex, true);
 
            $response = $this->executeCommand(
                sprintf('%sFETCH %s %s', $uid ? 'UID ' : '', $range, $select),
                $error
            );
 
            if ($error)
            {
                $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
                $error = $this->errorMessage(array(Imap::ERR_FETCH, $error), $response);
 
                return false;
            }
 
            $shiftName = function (&$item)
            {
                $result = false;
 
                // #120949
                $regex = sprintf(
                    '/^
                        (
                            [a-z0-9]+ (?: \. [a-z0-9]+ )*
                            (?: \[ (?: [a-z0-9]+ (?: \. [a-z0-9]* )* (?: \x20 %s )* )? \] )?
                            (?: < \d+ > )?
                        )
                        \x20
                    /ix',
                    self::$astringRegex
                );
 
                if (preg_match($regex, $item, $matches))
                {
                    $result = $matches[1];
 
                    $item = BinaryString::getSubstring($item, BinaryString::getLength($matches[0]));
                }
 
                return $result;
            };
 
            $shiftValue = function (&$item) use (&$shiftValue)
            {
                $result = false;
 
                $tail = ' (?= [\x20)] | $ ) \x20? ';
 
                if (BinaryString::getSubstring($item, 0, 1) === '(')
                {
                    $item = BinaryString::getSubstring($item, 1);
 
                    $result = array();
 
                    while (BinaryString::getLength($item) > 0 && BinaryString::getSubstring($item, 0, 1) !== ')')
                    {
                        $subresult = $shiftValue($item);
 
                        if (false !== $subresult)
                        {
                            $result[] = $subresult;
                        }
                        else
                        {
                            return false;
                        }
                    }
 
                    if (preg_match('/^ \‍) (?= [\x20()] | $ ) \x20? /ix', $item, $matches))
                    {
                        $item = BinaryString::getSubstring($item, BinaryString::getLength($matches[0]));
                    }
                    else
                    {
                        return false;
                    }
                }
                else if (preg_match('/^ { ( \d+ ) } \r\n /ix', $item, $matches))
                {
                    $item = BinaryString::getSubstring($item, BinaryString::getLength($matches[0]));
 
                    if (BinaryString::getLength($item) >= $matches[1])
                    {
                        $result = BinaryString::getSubstring($item, 0, $matches[1]);
 
                        $item = BinaryString::getSubstring($item, $matches[1]);
 
                        if (preg_match(sprintf('/^ %s /ix', $tail), $item, $matches))
                        {
                            $item = BinaryString::getSubstring($item, BinaryString::getLength($matches[0]));
                        }
                        else
                        {
                            return false;
                        }
                    }
                }
                else if (preg_match(sprintf('/^ NIL %s /ix', $tail), $item, $matches))
                {
                    $result = null;
 
                    $item = BinaryString::getSubstring($item, BinaryString::getLength($matches[0]));
                }
                else if (preg_match(sprintf('/^ " ( (?: %s )* ) " %s /ix', self::$qcharExtRegex, $tail), $item, $matches))
                {
                    $result = self::unescapeQuoted($matches[1]);
 
                    $item = BinaryString::getSubstring($item, BinaryString::getLength($matches[0]));
                }
                else if (preg_match(sprintf('/^ ( \x5c? %s ) %s /ix', self::$astringRegex, $tail), $item, $matches))
                {
                    $result = $matches[1];
 
                    $item = BinaryString::getSubstring($item, BinaryString::getLength($matches[0]));
                }
                else if (preg_match(sprintf('/^ %s /ix', $tail), $item, $matches))
                {
                    $result = '';
 
                    $item = BinaryString::getSubstring($item, BinaryString::getLength($matches[0]));
                }
 
                return $result;
            };
 
            $bodystructure = function (&$value) use (&$bodystructure)
            {
                if (!is_array($value) || !is_array($value[0]))
                {
                    return $value;
                }
 
                $value[0] = $bodystructure($value[0]);
                $value[0] = array($value[0]);
 
                while (array_key_exists(1, $value) && is_array($value[1]))
                {
                    $value[0][] = $bodystructure($value[1]);
 
                    array_splice($value, 1, 1);
                }
 
                while (count($value[0]) == 1 && count($value[0][0]) == 1)
                {
                    $value[0] = $value[0][0];
                }
 
                return $value;
            };
 
            foreach ($this->getUntagged($fetchUntaggedRegex, true) as $item)
            {
                $data = array(
                    'id' => $item[1][1],
                );
 
                while (BinaryString::getLength($item[1][2]) > 0)
                {
                    if (($name = $shiftName($item[1][2])) !== false)
                    {
                        if (($value = $shiftValue($item[1][2])) !== false)
                        {
                            if (in_array(mb_strtoupper($name), array('BODY', 'BODYSTRUCTURE')))
                            {
                                $value = $bodystructure($value);
                            }
 
                            $data[$name] = $value;
 
                            continue;
                        }
                    }
 
                    break;
                }
 
                $list[$data['id']] = $data;
            }
        }
 
        ksort($list);
 
        // todo remove the different format of the data output
        if ($outputFormat === 'smart' && !preg_match('/[:,]/', $range))
        {
            $list = reset($list);
        }
 
        return $list;
    }
 
    public function getUIDsForSpecificDay($dirPath, $internalDate)
    {
        $error = [];
 
        if (!$this->select($dirPath, $error))
        {
            return false;
        }
 
        //since some mail services (example mail.ru ) do not support the 'on' search criterion
        $command = 'UID SEARCH SINCE '.date("j-M-Y", strtotime($internalDate)).' BEFORE '.date('j-M-Y', strtotime($internalDate.' +1 day'));
 
        $response = $this->executeCommand($command, $error);
 
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage(array(Imap::ERR_SEARCH, $error), $response);
 
            return false;
        }
 
        $UIDs = [];
        $regex = '/^ \* \x20 SEARCH \x20 ( .+ ) \r\n $ /ix';
        foreach ($this->getUntagged($regex, true) as $item)
        {
            preg_match_all('/\d+/', $item[1][1],$UIDs);
        }
 
        if(count($UIDs) === 0 )
        {
            return [];
        }
 
        return $UIDs[0];
    }
 
    public function getUnseen($dirPath, &$error, $startInternalDate = null)
    {
        $error = null;
 
        if (!$this->select($dirPath, $error))
        {
            return false;
        }
 
        $unseen = 0;
 
        if (!($this->sessMailbox['exists'] > 0))
        {
            return $unseen;
        }
 
        $command = 'SEARCH UNSEEN';
 
        if(!is_null($startInternalDate))
        {
            $command .= (' SINCE '.$startInternalDate->format('j-M-Y'));
        }
        $response = $this->executeCommand($command, $error);
 
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage(array(Imap::ERR_SEARCH, $error), $response);
 
            return false;
        }
 
        $regex = '/^ \* \x20 SEARCH \x20 ( .+ ) \r\n $ /ix';
        foreach ($this->getUntagged($regex, true) as $item)
        {
            $unseen = preg_match_all('/\d+/', $item[1][1]);
        }
 
        return $unseen;
    }
 
    public function getNew($mailbox, $uidMin, $uidMax, &$error)
    {
        $error = null;
 
        if (!($uidMin <= $uidMax))
        {
            return false;
        }
 
        if (!$this->select($mailbox, $error))
        {
            return false;
        }
 
        $new = 0;
 
        if (!($this->sessMailbox['exists'] > 0))
        {
            return $new;
        }
 
        if ($uidMax < 1)
        {
            return $this->sessMailbox['exists'];
        }
 
        $range = $this->getUidRange($mailbox, $error);
 
        if (empty($range))
        {
            return false;
        }
 
        [$min, $max] = $range;
 
        $searches = array();
 
        if ($uidMin > 1 && $uidMin > $min)
        {
            $searches[] = sprintf('%u:%u', $min, $uidMin - 1);
        }
 
        if ($uidMax > 0 && $uidMax < $max)
        {
            $searches[] = sprintf('%u:%u', $uidMax + 1, $max);
        }
 
        if (!empty($searches))
        {
            $response = $this->executeCommand(sprintf('SEARCH UID %s', join(',', $searches)), $error);
 
            if ($error)
            {
                $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
                $error = $this->errorMessage(array(Imap::ERR_SEARCH, $error), $response);
 
                return false;
            }
 
            $regex = '/^ \* \x20 SEARCH \x20 ( .+ ) \r\n $ /ix';
            foreach ($this->getUntagged($regex, true) as $item)
            {
                $new = preg_match_all('/\d+/', $item[1][1]);
            }
        }
 
        return $new;
    }
 
    public function getUidRange($mailbox, &$error)
    {
        $error = null;
 
        if (!$this->select($mailbox, $error))
        {
            return false;
        }
 
        if (!($this->sessMailbox['exists'] > 0))
        {
            return false;
        }
 
        $range = $this->fetch(false, $mailbox, sprintf('1,%u', $this->sessMailbox['exists']), '(UID)', $error);
 
        if (empty($range) || empty($range[1]))
        {
            return false;
        }
 
        return array(
            $range[1]['UID'],
            end($range)['UID'],
        );
    }
 
    public function listex($reference, $pattern, &$error)
    {
        $error = null;
 
        if (!$this->authenticate($error))
        {
            return false;
        }
 
        $response = $this->executeCommand(sprintf(
            'LIST "%s" "%s"',
            static::escapeQuoted($this->encodeUtf7Imap($reference)),
            static::escapeQuoted($this->encodeUtf7Imap($pattern))
        ), $error);
 
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage(array(Imap::ERR_LIST, $error), $response);
 
            return false;
        }
 
        $list = array();
 
        $regex = sprintf(
            '/^ \* \x20 LIST \x20
                \‍( (?<flags> ( \x5c? %1$s ( \x20 \x5c? %1$s )* )? ) \‍) \x20
                (?<delim> NIL | " ( %2$s ) " ) \x20
                (?<name> \{ \d+ \} | " ( %2$s )* " | %3$s ) \r\n
                (?<ext> .* )
            /ix',
            self::$atomRegex, self::$qcharRegex, self::$astringRegex
        );
        foreach ($this->getUntagged($regex, true) as $item)
        {
            [$item, $matches] = $item;
 
            $sflags = $matches['flags'];
            $sdelim = $matches['delim'];
            $sname  = $matches['name'];
 
            if (preg_match('/^ " ( .+ ) " $/ix', $sdelim, $quoted))
            {
                $sdelim = static::unescapeQuoted($quoted[1]);
            }
 
            if (preg_match('/^ \{ ( \d+ ) \} $/ix', $sname, $literal))
            {
                $sname = substr($matches['ext'], 0, $literal[1]);
            }
            else if (preg_match('/^ " ( .* ) " $/ix', $sname, $quoted))
            {
                $sname = static::unescapeQuoted($quoted[1]);
            }
 
            $sname = $this->decodeUtf7Imap($sname);
 
            // #79498
            if (mb_strtoupper($sdelim) != 'NIL')
                $sname = rtrim($sname, $sdelim);
 
            $list[] = array(
                'name'  => $sname,
                'delim' => mb_strtoupper($sdelim) == 'NIL' ? 'NIL' : $sdelim,
                'flags' => preg_split('/\s+/i', $sflags, -1, PREG_SPLIT_NO_EMPTY),
            );
        }
 
        return $list;
    }
 
    public function listMailboxes($pattern, &$error, $flat = false)
    {
        $error = null;
 
        $listGetter = function ($parent = null, $level = 0) use (&$listGetter, &$delimiter, &$error)
        {
            $pattern = $parent ? sprintf('%s%s%%', $parent, $delimiter) : '%';
 
            $list = $this->listex('', $pattern, $error);
 
            if (false === $list)
            {
                return false;
            }
 
            foreach ($list as $i => $item)
            {
                $item['title'] = $item['name'];
                $item['level'] = $level;
 
                if ($parent)
                {
                    $regex = sprintf(
                        '/^%s%s(.)/',
                        preg_quote($parent, '/'),
                        preg_quote($delimiter, '/')
                    );
 
                    if (!preg_match($regex, $item['name']))
                    {
                        unset($list[$i]);
                        continue;
                    }
 
                    $item['title'] = preg_replace($regex, '\1', $item['name']);
                }
 
                if ($item['name'] == $parent)
                {
                    continue;
                }
 
                if ($item['delim'] === null)
                {
                    continue;
                }
 
                $delimiter = $item['delim'];
 
                if (!preg_grep('/^ \x5c ( Noinferiors | HasNoChildren ) $/ix', $item['flags']))
                {
                    $children = $listGetter($item['name'], $level + 1);
 
                    if ($children === false)
                    {
                        return false;
                    }
 
                    if (!empty($children))
                    {
                        $item['children'] = $children;
                    }
                }
 
                $list[$i] = $item;
            }
 
            return array_values($list);
        };
 
        $list = $listGetter();
 
        if (false === $list)
        {
            return false;
        }
 
        $regex = sprintf(
            '/^%s$/i',
            preg_replace(
                array('/ ( \x5c \* )+ /x', '/ ( \% )+ /x'),
                array('.*', $delimiter ? sprintf('[^\x%s]*', bin2hex($delimiter)) : '.*'),
                preg_quote($pattern, '/')
            )
        );
 
        $listFilter = function ($list) use (&$listFilter, $regex)
        {
            foreach ($list as $i => $item)
            {
                if (!preg_match($regex, $item['name']))
                {
                    if (empty($item['children']))
                    {
                        unset($list[$i]);
                        continue;
                    }
                }
 
                if (!empty($item['children']))
                {
                    $item['children'] = $listFilter($item['children']);
 
                    if (empty($item['children']))
                    {
                        unset($item['children']);
                    }
                }
 
                $list[$i] = $item;
            }
 
            $list = array_values($list);
 
            for ($i = 0; $i < count($list); $i++)
            {
                $item = $list[$i];
 
                if (!preg_match($regex, $item['name']))
                {
                    $children = empty($item['children']) ? array() : $item['children'];
 
                    array_splice($list, $i, 1, $children);
                    $i += count($children) - 1;
                }
            }
 
            return $list;
        };
 
        $list = $listFilter($list);
 
        $listHandler = function ($list, $path = array()) use (&$listHandler, $regex, $flat)
        {
            for ($i = 0; $i < count($list); $i++)
            {
                $item = $list[$i];
 
                $item['path'] = array_merge($path, array($item['title']));
 
                if (!empty($item['children']))
                {
                    $item['children'] = $listHandler($item['children'], $item['path']);
                }
 
                $list[$i] = $item;
 
                if ($flat && !empty($item['children']))
                {
                    unset($list[$i]['children']);
 
                    array_splice($list, $i + 1, 0, $item['children']);
                    $i += count($item['children']);
                }
            }
 
            return array_values($list);
        };
 
        $list = $listHandler($list);
 
        return $list;
    }
 
    public function listMessages($mailbox, &$uidtoken, &$error)
    {
        $error = null;
 
        $params = array(
            'offset' => 0,
            'limit'  => -1,
        );
 
        if (is_array($mailbox))
        {
            $params  = array_merge($params, $mailbox);
            $mailbox = $mailbox['mailbox'];
        }
 
        if (!($params['offset'] > 0))
        {
            $params['offset'] = 0;
        }
 
        if (!($params['limit'] > 0))
        {
            $params['limit'] = -1;
        }
 
        if (!$this->select($mailbox, $error))
        {
            return false;
        }
 
        if (!($this->sessMailbox['exists'] > 0) || $params['offset'] + 1 > $this->sessMailbox['exists'])
        {
            return array();
        }
 
        if ($params['limit'] > 0 && $params['offset'] + $params['limit'] > $this->sessMailbox['exists'])
        {
            $params['limit'] = $this->sessMailbox['exists'] - $params['offset'];
        }
 
        $uidtoken = $this->sessMailbox['uidvalidity'];
 
        $list = $this->fetch(
            false,
            $mailbox,
            sprintf(
                '%u:%s',
                $params['offset'] + 1,
                $params['limit'] > 0 ? (int) ($params['offset']+$params['limit']) : '*'
            ),
            array_merge(
                !is_null($uidtoken) ? array('UID') : array(),
                array('INTERNALDATE', 'RFC822.SIZE', 'FLAGS')
            ),
            $error
        );
 
        foreach ($list as $id => $data)
        {
            $list[$id] = array(
                'id'    => $id,
                'uid'   => array_key_exists('UID', $data) ? $data['UID'] : null,
                'date'  => array_key_exists('INTERNALDATE', $data) ? $data['INTERNALDATE'] : null,
                'size'  => array_key_exists('RFC822.SIZE', $data) ? $data['RFC822.SIZE'] : null,
                'flags' => array_key_exists('FLAGS', $data) ? $data['FLAGS'] : array(),
            );
        }
 
        $list = array_filter(
            $list,
            function ($item)
            {
                return isset($item['date'], $item['size'], $item['flags']);
            }
        );
 
        return $list;
    }
 
    public function addMessage($mailbox, $data, &$error)
    {
        $error = null;
 
        return $this->append($mailbox, array('\Seen'), new \DateTime, $data, $error);
    }
 
    public function searchByHeader($uid, $mailbox, array $header, &$error)
    {
        $error = null;
 
        if (!$this->select($mailbox, $error))
        {
            return false;
        }
 
        if (empty($header))
        {
            return false;
        }
 
        $result = array();
 
        $response = $this->executeCommand(
            $ccc = sprintf(
                '%sSEARCH %s', $uid ? 'UID ' : '',
                join(
                    ' ',
                    array_map(
                        function ($name, $value)
                        {
                            return sprintf(
                                'HEADER %s %s',
                                static::prepareString($name),
                                static::prepareString($value)
                            );
                        },
                        array_keys($header),
                        array_values($header)
                    )
                )
            ),
            $error
        );
 
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage(array(Imap::ERR_SEARCH, $error), $response);
 
            return false;
        }
 
        $regex = '/^ \* \x20 SEARCH \x20 ( .+ ) \r\n $ /ix';
        foreach ($this->getUntagged($regex, true) as $item)
        {
            $result = preg_match_all('/\d+/', $item[1][1]);
        }
 
        return $result;
    }
 
    public function append($mailbox, array $flags, \DateTime $internaldate, $data, &$error)
    {
        $error = null;
 
        if (!$this->authenticate($error))
        {
            return false;
        }
 
        foreach ($flags as $k => $item)
        {
            if (!preg_match(sprintf('/ ^ \x5c? %s $ /ix', self::$atomRegex), $item))
            {
                unset($flags[$k]);
            }
        }
 
        $response = $this->executeCommand(sprintf(
            'APPEND "%s" (%s) "%26s" %s',
            static::escapeQuoted($this->encodeUtf7Imap($mailbox)),
            join(' ', $flags),
            $internaldate->format('j-M-Y H:i:s O'),
            static::prepareString($data)
        ), $error);
 
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage(array(Imap::ERR_APPEND, $error), $response);
 
            return false;
        }
 
        $regex = sprintf('/^ OK \x20 \[ APPENDUID \x20 ( \d+ ) \x20 ( \d+ ) \] /ix', $this->getTag());
        if (preg_match($regex, $response, $matches))
        {
            return sprintf('%u:%u', $matches[1], $matches[2]);
        }
 
        return true;
    }
 
    public function moveMails($ids, $folderFrom, $folderTo)
    {
        $folderTo = Emoji::decode($folderTo);
        $error = null;
        $result = new Main\Result();
        if (!$this->authenticate($error))
        {
            return $result->addError(new Main\Error(''));
        }
 
        if (preg_match('/ \x20 MOVE ( \x20 | \r\n ) /ix', $this->sessCapability))
        {
            $result = $this->move($ids, $folderFrom, $folderTo);
        }
        else
        {
            $result = $this->copyMailToFolder($ids, $folderFrom, $folderTo);
            if ($result->isSuccess())
            {
                $result = $this->delete($ids, $folderFrom);
            }
        }
        return $result;
    }
 
    public function move($ids, $folderFrom, $folderTo)
    {
        $error = null;
        $result = new Main\Result();
        if (!$this->authenticate($error))
        {
            return $result->addError(new Main\Error(''));
        }
        if (!$this->select($folderFrom, $error))
        {
            return $result->addError(new Main\Error(''));
        }
        $response = $this->executeCommand(sprintf('UID MOVE %s "%s"', $this->prepareIdsParam($ids), static::escapeQuoted($this->encodeUtf7Imap($folderTo))), $error);
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage([Imap::ERR_STORE, $error], $response);
            return $result->addError(new Main\Error($error));
        }
 
        return $result;
    }
 
    public function copyMailToFolder($ids, $mailboxName, $folder)
    {
        $error = null;
        $result = new Main\Result();
        if (!$this->authenticate($error))
        {
            return $result->addError(new Main\Error(''));
        }
        if (!$this->select($mailboxName, $error))
        {
            return $result->addError(new Main\Error(''));
        }
        $response = $this->executeCommand(sprintf('UID COPY %s "%s"', $this->prepareIdsParam($ids), static::escapeQuoted($this->encodeUtf7Imap($folder))), $error);
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage(array(Imap::ERR_STORE, $error), $response);
            return $result->addError(new Main\Error($error));
        }
 
        return $result;
    }
 
    public function unseen($ids, $folder)
    {
        $error = null;
        $result = new Main\Result();
        if (!$this->authenticate($error))
        {
            return $result->addError(new Main\Error(''));
        }
        if (!$this->select($folder, $error))
        {
            return $result->addError(new Main\Error(''));
        }
 
        $response = $this->store($ids, ['\Seen'], $error, true, true);
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage([Imap::ERR_STORE, $error], $response);
            return $result->addError(new Main\Error($error));
        }
        return $result;
    }
 
    public function seen($ids, $folder)
    {
        $error = null;
        $result = new Main\Result();
        if (!$this->authenticate($error))
        {
            return $result->addError(new Main\Error(''));
        }
        if (!$this->select($folder, $error))
        {
            return $result->addError(new Main\Error(''));
        }
 
        $response = $this->store($ids, ['\Seen'], $error);
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage([Imap::ERR_STORE, $error], $response);
            return $result->addError(new Main\Error($error));
        }
        return $result;
    }
 
    public function delete($id, $mailboxName)
    {
        $error = null;
        $result = new Main\Result();
        if (!$this->authenticate($error))
        {
            return $result->addError(new Main\Error(''));
        }
        if (!$this->select($mailboxName, $error))
        {
            return $result->addError(new Main\Error(''));
        }
        $response = $this->store($id, ['\Deleted'], $error);
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage(array(Imap::ERR_STORE, $error), $response);
            return $result->addError(new Main\Error($error));
        }
 
        $response = $this->expunge($error);
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage(array(Imap::ERR_STORE, $error), $response);
            return $result->addError(new Main\Error($error));
        }
        return $result;
    }
 
    private function expunge(&$error)
    {
        return $this->executeCommand('EXPUNGE', $error);
    }
 
    private function store($ids, $flags, &$error, $isUid = true, $isRemoveFlags = false)
    {
        $command = sprintf('STORE %s ', $this->prepareIdsParam($ids));
        $command .= $isRemoveFlags ? '-' : '+';
        $command = $command . sprintf('FLAGS (%s)', join(' ', $flags));
 
        if ($isUid)
        {
            $command = 'UID ' . $command;
        }
 
        return $this->executeCommand($command, $error);
    }
 
    public function updateMessageFlags($mailbox, $id, $flags, &$error)
    {
        $error = null;
        $response = '';
 
        if (!$this->select($mailbox, $error))
        {
            return false;
        }
 
        $addFlags = array();
        $delFlags = array();
        foreach ($flags as $name => $value)
        {
            if (preg_match(sprintf('/ ^ \x5c? %s $ /ix', self::$atomRegex), $name))
            {
                if ($value)
                {
                    $addFlags[] = $name;
                }
                else
                {
                    $delFlags[] = $name;
                }
            }
        }
 
        if ($addFlags)
        {
            $response = $this->store($id, $addFlags, $error, false);
        }
 
        if (!$error && $delFlags)
        {
            $response = $this->store($id, $delFlags, $error, false, true);
        }
 
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage(array(Imap::ERR_STORE, $error), $response);
 
            return false;
        }
 
        $this->getUntagged(sprintf('/^ \* \x20 %u \x20 FETCH \x20 \‍( .+ \‍) \r\n $/isx', $id), true);
 
        return true;
    }
 
    public function getMessage($mailbox, $id, $section, &$error)
    {
        $error = null;
 
        $section = mb_strtoupper($section);
 
        if (!in_array(mb_strtoupper($section), array('HEADER', 'TEXT')))
        {
            $section = '';
        }
 
        if (!$this->select($mailbox, $error))
        {
            return false;
        }
 
        $response = $this->fetch(false, $mailbox, (int) $id, sprintf('BODY.PEEK[%s]', $section), $error);
 
        return $response[sprintf('BODY[%s]', $section)];
    }
 
    public function isExistsDir($mailbox, &$error)
    {
        $error = null;
 
        $dirs = $this->listex('', $mailbox, $error);
 
        if (is_array($dirs) && empty($dirs))
        {
            return false;
        }
 
        return true;
    }
 
    public function ensureEmpty($mailbox, &$error)
    {
        $error = null;
 
        if (!$this->select($mailbox, $error))
        {
            return false;
        }
 
        if ($this->sessMailbox['exists'] > 0)
        {
            return false;
        }
 
        $searchUntaggedRegex = '/^ \* \x20 SEARCH \x20 ( .+ ) \r\n $ /ix';
        $this->getUntagged($searchUntaggedRegex, true);
 
        $response = $this->executeCommand('UID SEARCH 1', $error);
 
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage(array(Imap::ERR_SEARCH, $error), $response);
 
            return false;
        }
 
        $matches = 0;
        foreach ($this->getUntagged($searchUntaggedRegex, true) as $item)
        {
            $matches = preg_match_all('/\d+/', $item[1][1]);
        }
 
        if ($matches > 0)
        {
            addMessage2Log(
                sprintf(
                    'IMAP: invalid mailbox (search>exists) (%s:%s:%s:%u)',
                    $this->options['host'], $this->options['login'], $mailbox, $this->sessMailbox['uidvalidity']
                ),
                'mail', 0, false
            );
 
            return false;
        }
 
        $fetchUntaggedRegex = '/^ \* \x20 ( \d+ ) \x20 FETCH \x20 \‍( ( .+ ) \‍) \r\n $/isx';
        $this->getUntagged($fetchUntaggedRegex, true);
 
        $response = $this->executeCommand('FETCH 1 (UID)', $error);
 
        if ($error)
        {
            $error = $error == Imap::ERR_COMMAND_REJECTED ? null : $error;
            $error = $this->errorMessage(array(Imap::ERR_FETCH, $error), $response);
 
            return false;
        }
 
        $matches = 0;
        foreach ($this->getUntagged($fetchUntaggedRegex, true) as $item)
        {
            $matches = $item[1][1];
        }
 
        if ($matches > 0)
        {
            addMessage2Log(
                sprintf(
                    'IMAP: invalid mailbox (fetch>exists) (%s:%s:%s:%u)',
                    $this->options['host'], $this->options['login'], $mailbox, $this->sessMailbox['uidvalidity']
                ),
                'mail', 0, false
            );
 
            return false;
        }
 
        return true;
    }
 
    protected function getUntagged($regex, $unset = false)
    {
        $result = array();
 
        $length = count($this->sessUntagged);
        for ($i = 0; $i < $length; $i++)
        {
            if (!preg_match($regex, $this->sessUntagged[$i], $matches))
                continue;
 
            unset($matches[0]);
            $result[] = array($this->sessUntagged[$i], $matches);
 
            if ($unset)
                unset($this->sessUntagged[$i]);
        }
 
        if ($unset && !empty($result))
            $this->sessUntagged = array_values($this->sessUntagged);
 
        return $result;
    }
 
    protected function getTag($next = false)
    {
        if ($next)
            $this->sessCounter++;
 
        return sprintf('A%03u', $this->sessCounter);
    }
 
    protected function executeCommand($command, &$error)
    {
        $error = null;
        $response = false;
 
        $chunks = explode("\x00", sprintf('%s %s', $this->getTag(true), $command));
 
        $k = count($chunks);
        foreach ($chunks as $chunk)
        {
            $k--;
 
            $response = $this->exchange($chunk, $error);
 
            if ($k > 0 && mb_strpos($response, '+') !== 0)
                break;
        }
 
        return $response;
    }
 
    protected function exchange($data, &$error)
    {
        $error = null;
 
        if ($this->sendData(sprintf("%s\r\n", $data)) === false)
        {
            $error = Imap::ERR_COMMUNICATE;
            return false;
        }
 
        $response = $this->readResponse();
 
        if ($response === false)
        {
            $error = Imap::ERR_EMPTY_RESPONSE;
            return false;
        }
 
        $response = trim($response);
 
        if (!preg_match(sprintf('/^ %s \x20 OK /ix', $this->getTag()), $response))
        {
            if (preg_match(sprintf('/^ %s \x20 ( NO | BAD ) /ix', $this->getTag()), $response))
                $error = Imap::ERR_COMMAND_REJECTED;
            else
                $error = Imap::ERR_BAD_SERVER;
        }
 
        return preg_replace(sprintf('/^ %s \x20 /ix', $this->getTag()), '', $response);
    }
 
    protected function sendData($data)
    {
        $logData = null;
        if(($this->logLevel & self::LOG_LEVEL_WRITE))
        {
            $logData = $data;
        }
 
        $fails = 0;
        while (strlen($data) > 0 && !feof($this->stream))
        {
            $bytes = @fputs($this->stream, $data);
 
            if (false == $bytes)
            {
                if (false === $bytes || ++$fails >= 3)
                {
                    break;
                }
 
                continue;
            }
 
            $fails = 0;
 
            $data = substr($data, $bytes);
        }
 
        if (strlen($data) > 0)
        {
            $this->reset();
            return false;
        }
 
        if($logData !== null)
        {
            $this->writeToLog($logData);
        }
 
        return true;
    }
 
    protected function readBytes($bytes)
    {
        $data = '';
 
        while ($bytes > 0 && !feof($this->stream))
        {
            $buffer = @fread($this->stream, $bytes);
            if ($buffer === false)
                break;
 
            $meta = $this->options['timeout'] > 0
                ? stream_get_meta_data($this->stream)
                : array('timed_out' => false);
 
            $data  .= $buffer;
            $bytes -= strlen($buffer);
 
            if ($meta['timed_out'])
                break;
        }
 
        if ($bytes > 0)
        {
            $this->reset();
            return false;
        }
 
        return $data;
    }
 
    protected function readLine()
    {
        $line = '';
 
        while (!feof($this->stream))
        {
            $buffer = @fgets($this->stream, 4096);
            if ($buffer === false)
                break;
 
            $meta = $this->options['timeout'] > 0
                ? stream_get_meta_data($this->stream)
                : array('timed_out' => false);
 
            $line .= $buffer;
 
            $eolRegex = '/ (?<literal> \{ (?<bytes> \d+ ) \} )? \r\n $ /x';
            if (preg_match($eolRegex, $line, $matches))
            {
                if (empty($matches['literal']))
                    break;
 
                if ($meta['timed_out'])
                    return false;
 
                $data = $this->readBytes($matches['bytes']);
                if ($data === false)
                    return false;
 
                $line .= $data;
            }
 
            if ($meta['timed_out'])
                break;
        }
 
        if (!preg_match('/\r\n$/', $line, $matches))
        {
            $this->reset();
            return false;
        }
 
        if(($this->logLevel & self::LOG_LEVEL_READ))
        {
            $this->writeToLog($line);
        }
 
        return $line;
    }
 
    protected function readResponse()
    {
        do
        {
            $line = $this->readLine();
            if ($line === false)
                return false;
 
            if (mb_strpos($line, '*') === 0)
                $this->sessUntagged[] = $line;
        }
        while (mb_strpos($line, '*') === 0);
 
        if ('select' == $this->sessState)
        {
            $regex = '/^ \* \x20 ( \d+ ) \x20 EXISTS /ix';
            foreach ($this->getUntagged($regex) as $item)
            {
                $this->sessMailbox['exists'] = $item[1][1];
            }
        }
 
        return $line;
    }
 
    protected static function prepareString($data)
    {
        if (preg_match('/^[^\x00\x0a\x0d\x80-\xff]*$/', $data))
            return sprintf('"%s"', static::escapeQuoted($data));
        else
            return sprintf("{%u}\x00%s", strlen($data), $data);
    }
 
    protected static function escapeQuoted($data)
    {
        return str_replace(array('\\', '"'), array('\\\\', '\\"'), $data);
    }
 
    protected static function unescapeQuoted($data)
    {
        return str_replace(array('\\\\', '\\"'), array('\\', '"'), $data);
    }
 
    protected function encodeUtf7Imap($data)
    {
        if (!$data)
            return $data;
 
        $result = Encoding::convertEncoding($data, $this->options['encoding'], 'UTF7-IMAP');
 
        if ($result === false)
        {
            $result = $data;
 
            $result = Encoding::convertEncoding($result, $this->options['encoding'], 'UTF-8');
            $result = str_replace('&', '&-', $result);
 
            $result = preg_replace_callback('/[\x00-\x1f\x7f-\xff]+/', function($matches)
            {
                $result = $matches[0];
 
                $result = Encoding::convertEncoding($result, 'UTF-8', 'UTF-16BE');
                $result = base64_encode($result);
                $result = str_replace('/', ',', $result);
                $result = str_replace('=', '', $result);
                $result = '&' . $result . '-';
 
                return $result;
            }, $result);
        }
 
        return $result;
    }
 
    protected function decodeUtf7Imap($data)
    {
        if (!$data)
            return $data;
 
        $result = Encoding::convertEncoding($data, 'UTF7-IMAP', $this->options['encoding']);
 
        if ($result === false)
        {
            $result = $data;
 
            $result = preg_replace_callback('/&([\x2b\x2c\x30-\x39\x41-\x5a\x61-\x7a]+)-/', function($matches)
            {
                $result = $matches[1];
 
                $result = str_replace(',', '/', $result);
                $result = base64_decode($result);
                $result = Encoding::convertEncoding($result, 'UTF-16BE', 'UTF-8');
 
                return $result;
            }, $result);
 
            $result = str_replace('&-', '&', $result);
            $result = Encoding::convertEncoding($result, 'UTF-8', $this->options['encoding']);
        }
 
        return $result;
    }
 
    private function prepareIdsParam($idsData)
    {
        if (is_array($idsData))
        {
            return implode(',', array_map('intval', $idsData));
        }
        else
        {
            return intval($idsData);
        }
    }
 
    protected function errorMessage($errors, $details = null)
    {
        $errors  = array_filter((array) $errors);
        $details = array_filter((array) $details);
 
        foreach ($errors as $i => $error)
        {
            $errors[$i] = static::decodeError($error);
            $this->errors->setError(new Main\Error((string) $errors[$i], $error > 0 ? $error : 0));
        }
 
        $error = join(': ', $errors);
        if ($details)
        {
            $error .= sprintf(' (IMAP: %s)', join(': ', $details));
 
            $this->errors->setError(new Main\Error('IMAP', -1));
            foreach ($details as $item)
            {
                $this->errors->setError(new Main\Error((string) $item, -1));
            }
        }
 
        return $error;
    }
 
    public function getErrors()
    {
        return $this->errors;
    }
 
    public static function decodeError($code)
    {
        switch ($code)
        {
            case self::ERR_CONNECT:
                return Loc::getMessage('MAIL_IMAP_ERR_CONNECT');
            case self::ERR_REJECTED:
                return Loc::getMessage('MAIL_IMAP_ERR_REJECTED');
            case self::ERR_COMMUNICATE:
                return Loc::getMessage('MAIL_IMAP_ERR_COMMUNICATE');
            case self::ERR_EMPTY_RESPONSE:
                return Loc::getMessage('MAIL_IMAP_ERR_EMPTY_RESPONSE');
            case self::ERR_BAD_SERVER:
                return Loc::getMessage('MAIL_IMAP_ERR_BAD_SERVER');
            case self::ERR_STARTTLS:
                return Loc::getMessage('MAIL_IMAP_ERR_STARTTLS');
            case self::ERR_COMMAND_REJECTED:
                return Loc::getMessage('MAIL_IMAP_ERR_COMMAND_REJECTED');
            case self::ERR_CAPABILITY:
                return Loc::getMessage('MAIL_IMAP_ERR_CAPABILITY');
            case self::ERR_AUTH:
            case self::ERR_SELECT:
                return Loc::getMessage('MAIL_IMAP_ERR_AUTH');
            case self::ERR_AUTH_MECH:
                return Loc::getMessage('MAIL_IMAP_ERR_AUTH_MECH');
            case self::ERR_AUTH_OAUTH:
                return Loc::getMessage('MAIL_IMAP_ERR_AUTH_OAUTH');
            case self::ERR_LIST:
                return Loc::getMessage('MAIL_IMAP_ERR_LIST');
            case self::ERR_SEARCH:
                return Loc::getMessage('MAIL_IMAP_ERR_SEARCH');
            case self::ERR_FETCH:
                return Loc::getMessage('MAIL_IMAP_ERR_FETCH');
            case self::ERR_APPEND:
                return Loc::getMessage('MAIL_IMAP_ERR_APPEND');
            case self::ERR_STORE:
                return Loc::getMessage('MAIL_IMAP_ERR_STORE');
 
            default:
                return Loc::getMessage('MAIL_IMAP_ERR_DEFAULT');
        }
    }
 
    protected function writeToLog($data)
    {
        if($this->logPath <> '')
        {
            $fileName = $this->options["host"].".".$this->options["login"].".log";
            file_put_contents($this->logPath."/".$fileName, $data, FILE_APPEND);
        }
    }
}