diff --git a/src/app/Backends/DAV/Vevent.php b/src/app/Backends/DAV/Vevent.php
index e0774e5b..a5c40091 100644
--- a/src/app/Backends/DAV/Vevent.php
+++ b/src/app/Backends/DAV/Vevent.php
@@ -1,284 +1,289 @@
 <?php
 
 namespace App\Backends\DAV;
 
 use Illuminate\Support\Str;
 use Sabre\VObject;
 
 class Vevent extends CommonObject
 {
     /** @var string Object content type (of the string representation) */
     public $contentType = 'text/calendar; charset=utf-8';
 
     public $attendees = [];
     public $comment;
     public $description;
     public $location;
     public $organizer;
     public $recurrence = [];
     public $sequence;
     public $status;
     public $summary;
     public $transp;
     public $url;
     public $valarms = [];
 
     public $dtstart;
     public $dtend;
     public $due;
     public $created;
     public $lastModified;
     public $dtstamp;
 
+    private $vobject;
+
 
     /**
      * Create event object from a DOMElement element
      *
      * @param \DOMElement $element DOM element with object properties
      *
      * @return CommonObject
      */
     public static function fromDomElement(\DOMElement $element)
     {
         /** @var self $object */
         $object = parent::fromDomElement($element);
 
         if ($data = $element->getElementsByTagName('calendar-data')->item(0)) {
             $object->fromIcal($data->nodeValue);
         }
 
         return $object;
     }
 
     /**
      * Set object properties from an iCalendar
      *
      * @param string $ical iCalendar string
      */
     protected function fromIcal(string $ical): void
     {
         $options = VObject\Reader::OPTION_FORGIVING | VObject\Reader::OPTION_IGNORE_INVALID_LINES;
-        $vobject = VObject\Reader::read($ical, $options);
+        $this->vobject = VObject\Reader::read($ical, $options);
 
-        if ($vobject->name != 'VCALENDAR') {
+        if ($this->vobject->name != 'VCALENDAR') {
             return;
         }
 
         $selfType = strtoupper(class_basename(get_class($this)));
 
-        foreach ($vobject->getComponents() as $component) {
+        foreach ($this->vobject->getComponents() as $component) {
             if ($component->name == $selfType) {
                 $this->fromVObject($component);
                 return;
             }
         }
     }
 
     /**
      * Set object properties from a Sabre/VObject component object
      *
      * @param VObject\Component $vobject Sabre/VObject component
      */
     protected function fromVObject(VObject\Component $vobject): void
     {
         $string_properties = [
             'COMMENT',
             'DESCRIPTION',
             'LOCATION',
             'SEQUENCE',
             'STATUS',
             'SUMMARY',
             'TRANSP',
             'UID',
             'URL',
         ];
 
         // map string properties
         foreach ($string_properties as $prop) {
             if (isset($vobject->{$prop})) {
                 $key = Str::camel(strtolower($prop));
                 $this->{$key} = (string) $vobject->{$prop};
             }
         }
 
         // map other properties
         foreach ($vobject->children() as $prop) {
             if (!($prop instanceof VObject\Property)) {
                 continue;
             }
 
             switch ($prop->name) {
                 case 'DTSTART':
                 case 'DTEND':
                 case 'DUE':
                 case 'CREATED':
                 case 'LAST-MODIFIED':
                 case 'DTSTAMP':
                     $key = Str::camel(strtolower($prop->name));
                     // These are of type Sabre\VObject\Property\ICalendar\DateTime
                     $this->{$key} = $prop;
                     break;
 
                 case 'RRULE':
                     $params = !empty($this->recurrence) ? $this->recurrence : [];
 
                     foreach ($prop->getParts() as $k => $v) {
                         $params[Str::camel(strtolower($k))] = is_array($v) ? implode(',', $v) : $v;
                     }
 
                     if (!empty($params['until'])) {
                         $params['until'] = new \DateTime($params['until']);
                     }
 
                     if (empty($params['interval'])) {
                         $params['interval'] = 1;
                     }
 
                     $this->recurrence = array_filter($params);
                     break;
 
                 case 'EXDATE':
                 case 'RDATE':
                     $key = strtolower($prop->name);
                     $dates = []; // TODO
 
                     if (!empty($this->recurrence[$key])) {
                         $this->recurrence[$key] = array_merge($this->recurrence[$key], $dates);
                     } else {
                         $this->recurrence[$key] = $dates;
                     }
 
                     break;
 
                 case 'ATTENDEE':
                 case 'ORGANIZER':
                     $attendee = [
                         'rsvp' => false,
                         'email' => preg_replace('!^mailto:!i', '', (string) $prop),
                     ];
 
                     $attendeeProps = ['CN', 'PARTSTAT', 'ROLE', 'CUTYPE', 'RSVP', 'DELEGATED-FROM', 'DELEGATED-TO',
                         'SCHEDULE-STATUS', 'SCHEDULE-AGENT', 'SENT-BY'];
 
                     foreach ($prop->parameters() as $name => $value) {
                         $key = Str::camel(strtolower($name));
                         switch ($name) {
                             case 'RSVP':
                                 $params[$key] = strtolower($value) == 'true';
                                 break;
                             case 'CN':
                                 $params[$key] = str_replace('\,', ',', strval($value));
                                 break;
                             default:
                                 if (in_array($name, $attendeeProps)) {
                                     $params[$key] = strval($value);
                                 }
                                 break;
                         }
                     }
 
                     if ($prop->name == 'ORGANIZER') {
                         $attendee['role'] = 'ORGANIZER';
                         $attendee['partstat'] = 'ACCEPTED';
 
                         $this->organizer = $attendee;
                     } elseif (empty($this->organizer) || $attendee['email'] != $this->organizer['email']) {
                         $this->attendees[] = $attendee;
                     }
 
                     break;
 
                 default:
                     if (\str_starts_with($prop->name, 'X-')) {
                         $this->custom[$prop->name] = (string) $prop;
                     }
             }
         }
 
         // Check DURATION property if no end date is set
         /*
         if (empty($this->dtend) && !empty($this->dtstart) && !empty($vobject->DURATION)) {
             try {
                 $duration = new \DateInterval((string) $vobject->DURATION);
                 $end = clone $this->dtstart;
                 $end->add($duration);
                 $this->dtend = $end;
             }
             catch (\Exception $e) {
                 // TODO: Error?
             }
         }
         */
 
         // Find alarms
         foreach ($vobject->select('VALARM') as $valarm) {
             $action  = 'DISPLAY';
             $trigger = null;
             $alarm   = [];
 
             foreach ($valarm->children() as $prop) {
                 $value = strval($prop);
 
                 switch ($prop->name) {
                     case 'TRIGGER':
                         foreach ($prop->parameters as $param) {
                             if ($param->name == 'VALUE' && $param->getValue() == 'DATE-TIME') {
                                 $trigger = '@' . $prop->getDateTime()->format('U');
                                 $alarm['trigger'] = $prop->getDateTime();
                             } elseif ($param->name == 'RELATED') {
                                 $alarm['related'] = $param->getValue();
                             }
                         }
     /*
                         if (!$trigger && ($values = libcalendaring::parse_alarm_value($value))) {
                             $trigger = $values[2];
                         }
     */
                         if (empty($alarm['trigger'])) {
                             $alarm['trigger'] = rtrim(preg_replace('/([A-Z])0[WDHMS]/', '\\1', $value), 'T');
                             // if all 0-values have been stripped, assume 'at time'
                             if ($alarm['trigger'] == 'P') {
                                 $alarm['trigger'] = 'PT0S';
                             }
                         }
                         break;
 
                     case 'ACTION':
                         $action = $alarm['action'] = strtoupper($value);
                         break;
 
                     case 'SUMMARY':
                     case 'DESCRIPTION':
                     case 'DURATION':
                         $alarm[strtolower($prop->name)] = $value;
                         break;
 
                     case 'REPEAT':
                         $alarm['repeat'] = (int) $value;
                         break;
 
                     case 'ATTENDEE':
                         $alarm['attendees'][] = preg_replace('!^mailto:!i', '', $value);
                         break;
                 }
             }
 
             if ($action != 'NONE') {
                 if (!empty($alarm['trigger'])) {
                     $this->valarms[] = $alarm;
                 }
             }
         }
     }
 
     /**
      * Create string representation of the DAV object (iCalendar)
      *
      * @return string
      */
     public function __toString()
     {
-        // TODO: This will be needed when we want to create/update objects
-        return '';
+        if (!$this->vobject) {
+            //TODO we currently can only serialize a message back that we just read
+            throw new \Exception("Writing from properties is not implemented");
+        }
+        return VObject\Writer::write($this->vobject);
     }
 }
diff --git a/src/app/Console/Commands/Data/MigrateCommand.php b/src/app/Console/Commands/Data/MigrateCommand.php
index 906498b6..c64f8ab1 100644
--- a/src/app/Console/Commands/Data/MigrateCommand.php
+++ b/src/app/Console/Commands/Data/MigrateCommand.php
@@ -1,60 +1,64 @@
 <?php
 
 namespace App\Console\Commands\Data;
 
 use App\DataMigrator;
 
 use Illuminate\Console\Command;
 
 /**
  * Migrate user data from an external service to Kolab.
  *
  * Example usage:
  *
  * ```
  * php artisan data:migrate \
  *   "ews://$user:$pass@$server?client_id=$client_id&client_secret=$client_secret&tenant_id=$tenant_id" \
  *   "dav://$dest_user:$dest_pass@$dest_server"
  * ```
+ *
+ * Supported account types: ews, dav (davs), imap (tls, ssl, imaps)
  */
 class MigrateCommand extends Command
 {
     /**
      * The name and signature of the console command.
      *
      * @var string
      */
     protected $signature = 'data:migrate
                                 {src : Source account}
                                 {dst : Destination account}
                                 {--type= : Object type(s)}
+                                {--sync : Execute migration synchronously}
                                 {--force : Force existing queue removal}';
 //                                {--export-only : Only export data}
 //                                {--import-only : Only import previously exported data}';
 
     /**
      * The console command description.
      *
      * @var string
      */
     protected $description = 'Migrate user data from an external service';
 
     /**
      * Execute the console command.
      *
      * @return mixed
      */
     public function handle()
     {
         $src = new DataMigrator\Account($this->argument('src'));
         $dst = new DataMigrator\Account($this->argument('dst'));
         $options = [
             'type' => $this->option('type'),
             'force' => $this->option('force'),
+            'sync' => $this->option('sync'),
             'stdout' => true,
         ];
 
         $migrator = new DataMigrator\Engine();
         $migrator->migrate($src, $dst, $options);
     }
 }
diff --git a/src/app/DataMigrator/Account.php b/src/app/DataMigrator/Account.php
index de1c5e6a..530a5f23 100644
--- a/src/app/DataMigrator/Account.php
+++ b/src/app/DataMigrator/Account.php
@@ -1,100 +1,109 @@
 <?php
 
 namespace App\DataMigrator;
 
 /**
  * Data object representing user account on an external service
  */
 class Account
 {
     /** @var string User name (login) */
     public $username;
 
     /** @var string User password */
     public $password;
 
     /** @var string User email address */
     public $email;
 
     /** @var string Hostname */
     public $host;
 
     /** @var string Connection scheme (service type) */
     public $scheme;
 
     /** @var string Full account location URI (w/o parameters) */
     public $uri;
 
     /** @var string Username for proxy auth */
     public $loginas;
 
     /** @var array Additional parameters from the input */
     public $params;
 
+    /** @var ?int Port number */
+    public $port;
+
     /** @var string Full account definition */
     protected $input;
 
 
     /**
      * Object constructor
      *
      * Input can be a valid URI or "<username>:<password>".
      * For proxy authentication use: "<proxy-user>**<username>" as username.
      *
      * @param string $input Account specification
      */
     public function __construct(string $input)
     {
         $url = parse_url($input);
 
         // Not valid URI, try the other form of input
         if ($url === false || !array_key_exists('scheme', $url)) {
             list($user, $password) = explode(':', $input, 2);
             $url = ['user' => $user, 'pass' => $password];
         }
 
         if (isset($url['user'])) {
             $this->username = urldecode($url['user']);
 
             if (strpos($this->username, '**')) {
                 list($this->username, $this->loginas) = explode('**', $this->username, 2);
             }
         }
 
         if (isset($url['pass'])) {
             $this->password = urldecode($url['pass']);
         }
 
         if (isset($url['scheme'])) {
             $this->scheme = strtolower($url['scheme']);
         }
 
+        if (isset($url['port'])) {
+            $this->port = $url['port'];
+        }
+
         if (isset($url['host'])) {
             $this->host = $url['host'];
-            $this->uri = $this->scheme . '://' . $url['host'] . ($url['path'] ?? '');
+            $this->uri = $this->scheme . '://' . $url['host']
+                . ($this->port ? ":{$this->port}" : null)
+                . ($url['path'] ?? '');
         }
 
         if (!empty($url['query'])) {
             parse_str($url['query'], $this->params);
         }
 
         if (strpos($this->loginas, '@')) {
             $this->email = $this->loginas;
         } elseif (strpos($this->username, '@')) {
             $this->email = $this->username;
         }
 
         $this->input = $input;
     }
 
     /**
      * Returns string representation of the object.
      * You can use the result as an input to the object constructor.
      *
      * @return string Account string representation
      */
     public function __toString(): string
     {
         return $this->input;
     }
 }
diff --git a/src/app/DataMigrator/DAV.php b/src/app/DataMigrator/DAV.php
index 27934428..f4e3bb39 100644
--- a/src/app/DataMigrator/DAV.php
+++ b/src/app/DataMigrator/DAV.php
@@ -1,240 +1,367 @@
 <?php
 
 namespace App\DataMigrator;
 
 use App\Backends\DAV as DAVClient;
 use App\Backends\DAV\Opaque as DAVOpaque;
 use App\Backends\DAV\Folder as DAVFolder;
 use App\Backends\DAV\Search as DAVSearch;
 use App\DataMigrator\Interface\Folder;
+use App\DataMigrator\Interface\ExporterInterface;
+use App\DataMigrator\Interface\ImporterInterface;
 use App\DataMigrator\Interface\Item;
+use App\DataMigrator\Interface\ItemSet;
 use App\Utils;
 
-class DAV implements Interface\ImporterInterface
+class DAV implements ExporterInterface, ImporterInterface
 {
+    /** @const int Max number of items to migrate in one go */
+    protected const CHUNK_SIZE = 25;
+
     /** @var DAVClient DAV Backend */
     protected $client;
 
     /** @var Account Account to operate on */
     protected $account;
 
     /** @var Engine Data migrator engine */
     protected $engine;
 
-    /** @var array Settings */
-    protected $settings;
-
 
     /**
      * Object constructor
      */
     public function __construct(Account $account, Engine $engine)
     {
         $username = $account->username . ($account->loginas ? "**{$account->loginas}" : '');
         $baseUri = rtrim($account->uri, '/');
         $baseUri = preg_replace('|^dav|', 'http', $baseUri);
 
-        $this->settings = [
-            'baseUri'  => $baseUri,
-            'userName' => $username,
-            'password' => $account->password,
-        ];
-
         $this->client = new DAVClient($username, $account->password, $baseUri);
         $this->engine = $engine;
         $this->account = $account;
     }
 
     /**
      * Check user credentials.
      *
      * @throws \Exception
      */
-    public function authenticate()
+    public function authenticate(): void
     {
         try {
-            $result = $this->client->options();
+            $this->client->options();
         } catch (\Exception $e) {
             throw new \Exception("Invalid DAV credentials or server.");
         }
     }
 
     /**
      * Create an item in a folder.
      *
      * @param Item $item Item to import
      *
      * @throws \Exception
      */
     public function createItem(Item $item): void
     {
         // TODO: For now we do DELETE + PUT. It's because the UID might have changed (which
         // is the case with e.g. contacts from EWS) causing a discrepancy between UID and href.
         // This is not necessarily a problem and would not happen to calendar events.
         // So, maybe we could improve that so DELETE is not needed.
         if ($item->existing) {
             try {
                 $this->client->delete($item->existing);
             } catch (\Illuminate\Http\Client\RequestException $e) {
                 // ignore 404 response, item removed in meantime?
                 if ($e->getCode() != 404) {
                     throw $e;
                 }
             }
         }
 
         $href = $this->getFolderPath($item->folder) . '/' . pathinfo($item->filename, PATHINFO_BASENAME);
 
         $object = new DAVOpaque($item->filename);
         $object->href = $href;
 
         switch ($item->folder->type) {
             case Engine::TYPE_EVENT:
             case Engine::TYPE_TASK:
                 $object->contentType = 'text/calendar; charset=utf-8';
                 break;
 
             case Engine::TYPE_CONTACT:
                 $object->contentType = 'text/vcard; charset=utf-8';
                 break;
         }
 
         if ($this->client->create($object) === false) {
             throw new \Exception("Failed to save DAV object at {$href}");
         }
     }
 
     /**
      * Create a folder.
      *
      * @param Folder $folder Folder data
      *
      * @throws \Exception on error
      */
     public function createFolder(Folder $folder): void
     {
         $dav_type = $this->type2DAV($folder->type);
         $folders = $this->client->listFolders($dav_type);
 
         if ($folders === false) {
             throw new \Exception("Failed to list folders on the DAV server");
         }
 
         // Note: iRony flattens the list by modifying the folder name
         // This is not going to work with Cyrus DAV, but anyway folder
         // hierarchies support is not full in Kolab 4.
         foreach ($folders as $dav_folder) {
             if (str_replace(' » ', '/', $dav_folder->name) === $folder->fullname) {
                 // do nothing, folder already exists
                 return;
             }
         }
 
         $home = $this->client->getHome($dav_type);
         $folder_id = Utils::uuidStr();
         $collection_type = $dav_type == DAVClient::TYPE_VCARD ? 'addressbook' : 'calendar';
 
         // We create all folders on the top-level
         $dav_folder = new DAVFolder();
         $dav_folder->name = $folder->fullname;
         $dav_folder->href = rtrim($home, '/') . '/' . $folder_id;
         $dav_folder->components = [$dav_type];
         $dav_folder->types = ['collection', $collection_type];
 
         if ($this->client->folderCreate($dav_folder) === false) {
             throw new \Exception("Failed to create a DAV folder {$dav_folder->href}");
         }
     }
 
+    /**
+     * Fetching an item
+     */
+    public function fetchItem(Item $item): void
+    {
+        // Save the item content to a file
+        $location = $item->folder->location;
+
+        if (!file_exists($location)) {
+            mkdir($location, 0740, true);
+        }
+
+        $location .= '/' . basename($item->id);
+
+        $result = $this->client->getObjects(dirname($item->id), $this->type2DAV($item->folder->type), [$item->id]);
+
+        if ($result === false) {
+            throw new \Exception("Failed to fetch DAV item for {$item->id}");
+        }
+
+        // TODO: Do any content changes, e.g. organizer/attendee email migration
+
+        if (file_put_contents($location, (string) $result[0]) === false) {
+            throw new \Exception("Failed to write to {$location}");
+        }
+
+        $item->filename = $location;
+    }
+
+    /**
+     * Fetch a list of folder items
+     */
+    public function fetchItemList(Folder $folder, $callback, ImporterInterface $importer): void
+    {
+        // Get existing messages' headers from the destination mailbox
+        $existing = $importer->getItems($folder);
+
+        $set = new ItemSet();
+
+        $dav_type = $this->type2DAV($folder->type);
+        $location = $this->getFolderPath($folder);
+        $search = new DAVSearch($dav_type);
+
+        // TODO: We request only properties relevant to incremental migration,
+        // i.e. to find that something exists and its last update time.
+        // Some servers (iRony) do ignore that and return full VCARD/VEVENT/VTODO
+        // content, if there's many objects we'll have a memory limit issue.
+        // Also, this list should be controlled by the exporter.
+        $search->dataProperties = ['UID', 'REV'];
+
+        $result = $this->client->search(
+            $location,
+            $search,
+            function ($item) use (&$set, $folder, $callback) {
+                // TODO: Skip an item that exists and did not change
+                $exists = false;
+
+                $set->items[] = Item::fromArray([
+                    'id' => $item->href,
+                    'folder' => $folder,
+                    'existing' => $exists,
+                ]);
+
+                if (count($set->items) == self::CHUNK_SIZE) {
+                    $callback($set);
+                    $set = new ItemSet();
+                }
+            }
+        );
+
+        if ($result === false) {
+            throw new \Exception("Failed to get items from a DAV folder {$location}");
+        }
+
+        if (count($set->items)) {
+            $callback($set);
+        }
+
+        // TODO: Delete items that do not exist anymore?
+    }
+
     /**
      * Get a list of folder items, limited to their essential propeties
      * used in incremental migration.
      *
      * @param Folder $folder Folder data
      *
      * @throws \Exception on error
      */
     public function getItems(Folder $folder): array
     {
         $dav_type = $this->type2DAV($folder->type);
         $location = $this->getFolderPath($folder);
 
         $search = new DAVSearch($dav_type);
 
         // TODO: We request only properties relevant to incremental migration,
         // i.e. to find that something exists and its last update time.
         // Some servers (iRony) do ignore that and return full VCARD/VEVENT/VTODO
         // content, if there's many objects we'll have a memory limit issue.
         // Also, this list should be controlled by the exporter.
         $search->dataProperties = ['UID', 'X-MS-ID', 'REV'];
 
         $items = $this->client->search(
             $location,
             $search,
+            // @phpstan-ignore-next-line
             function ($item) use ($dav_type) {
                 // Slim down the result to properties we might need
                 $result = [
                     'href' => $item->href,
                     'uid' => $item->uid,
                     'x-ms-id' => $item->custom['X-MS-ID'] ?? null,
                 ];
                 /*
                 switch ($dav_type) {
                     case DAVClient::TYPE_VCARD:
                         $result['rev'] = $item->rev;
                         break;
                 }
                 */
 
                 return $result;
             }
         );
 
         if ($items === false) {
             throw new \Exception("Failed to get items from a DAV folder {$location}");
         }
 
         return $items;
     }
 
+    /**
+     * Get folders hierarchy
+     */
+    public function getFolders($types = []): array
+    {
+        $result = [];
+        foreach (['VEVENT', 'VTODO', 'VCARD'] as $component) {
+            $type = $this->typeFromDAV($component);
+
+            // Skip folder types we do not support (need)
+            if (!empty($types) && !in_array($type, $types)) {
+                continue;
+            }
+
+            // TODO: Skip other users folders
+
+            $folders = $this->client->listFolders($component);
+
+            foreach ($folders as $folder) {
+                $result[$folder->href] = Folder::fromArray([
+                    'fullname' => $folder->name,
+                    'href' => $folder->href,
+                    'type' => $type,
+                ]);
+            }
+        }
+
+        return $result;
+    }
+
     /**
      * Get folder relative URI
      */
     protected function getFolderPath(Folder $folder): string
     {
         $folders = $this->client->listFolders($this->type2DAV($folder->type));
 
         if ($folders === false) {
             throw new \Exception("Failed to list folders on the DAV server");
         }
 
         // Note: iRony flattens the list by modifying the folder name
         // This is not going to work with Cyrus DAV, but anyway folder
         // hierarchies support is not full in Kolab 4.
         foreach ($folders as $dav_folder) {
             if (str_replace(' » ', '/', $dav_folder->name) === $folder->fullname) {
                 return rtrim($dav_folder->href, '/');
             }
         }
 
         throw new \Exception("Folder not found: {$folder->fullname}");
     }
 
     /**
      * Map Kolab type into DAV object type
      */
     protected static function type2DAV(string $type): string
     {
         switch ($type) {
             case Engine::TYPE_EVENT:
                 return DAVClient::TYPE_VEVENT;
             case Engine::TYPE_TASK:
                 return DAVClient::TYPE_VTODO;
             case Engine::TYPE_CONTACT:
             case Engine::TYPE_GROUP:
                 return DAVClient::TYPE_VCARD;
             default:
                 throw new \Exception("Cannot map type '{$type}' to DAV");
         }
     }
+
+    /**
+     * Map DAV object type into Kolab type
+     */
+    protected static function typeFromDAV(string $type): string
+    {
+        switch ($type) {
+            case DAVClient::TYPE_VEVENT:
+                return Engine::TYPE_EVENT;
+            case DAVClient::TYPE_VTODO:
+                return Engine::TYPE_TASK;
+            case DAVClient::TYPE_VCARD:
+                // TODO what about groups
+                return Engine::TYPE_CONTACT;
+            default:
+                throw new \Exception("Cannot map type '{$type}' from DAV");
+        }
+    }
 }
diff --git a/src/app/DataMigrator/EWS.php b/src/app/DataMigrator/EWS.php
index 92d327a3..e71177ba 100644
--- a/src/app/DataMigrator/EWS.php
+++ b/src/app/DataMigrator/EWS.php
@@ -1,462 +1,464 @@
 <?php
 
 namespace App\DataMigrator;
 
 use App\DataMigrator\Interface\Folder;
 use App\DataMigrator\Interface\Item;
 use garethp\ews\API;
 use garethp\ews\API\Type;
 use Illuminate\Support\Facades\Http;
 
 /**
  * Data migration from Exchange (EWS)
  */
 class EWS implements Interface\ExporterInterface
 {
     /** @var API EWS API object */
     public $api;
 
     /** @var array Supported folder types */
     protected $folder_classes = [
         EWS\Appointment::FOLDER_TYPE,
         EWS\Contact::FOLDER_TYPE,
         EWS\Task::FOLDER_TYPE,
         // TODO: mail and sticky notes are exported as eml files.
         //       We could use imapsync to synchronize mail, but for notes
         //       the only option will be to convert them to Kolab format here
         //       and upload to Kolab via IMAP, I guess
         // EWS\Note::FOLDER_TYPE,
         // EWS\StickyNote::FOLDER_TYPE,
     ];
 
     /** @var array Interal folders to skip */
     protected $folder_exceptions = [
         'AllContacts',
         'AllPersonMetadata',
         'AllTodoTasks',
         'Document Centric Conversations',
         'ExternalContacts',
         'Favorites',
         'Flagged Emails',
         'GraphFilesAndWorkingSetSearchFolder',
         'My Contacts',
         'MyContactsExtended',
         'Orion Notes',
         'Outbox',
         'PersonMetadata',
         'People I Know',
         'RelevantContacts',
         'SharedFilesSearchFolder',
         'Sharing',
         'To-Do Search',
         'UserCuratedContacts',
         'XrmActivityStreamSearch',
         'XrmCompanySearch',
         'XrmDealSearch',
         'XrmSearch',
         'Folder Memberships',
         // TODO: These are different depending on a user locale
         'Calendar/United States holidays',
         'Kalendarz/Polska — dni wolne od pracy', // pl
     ];
 
     /** @var array Map of EWS folder types to Kolab types */
     protected $type_map = [
         EWS\Appointment::FOLDER_TYPE => Engine::TYPE_EVENT,
         EWS\Contact::FOLDER_TYPE => Engine::TYPE_CONTACT,
         EWS\Task::FOLDER_TYPE => Engine::TYPE_TASK,
     ];
 
     /** @var Account Account to operate on */
     protected $account;
 
     /** @var Engine Data migrator engine */
     protected $engine;
 
 
     /**
      * Object constructor
      */
     public function __construct(Account $account, Engine $engine)
     {
         $this->account = $account;
         $this->engine = $engine;
     }
 
     /**
      * Server autodiscovery
      */
     public static function autodiscover(string $user, string $password): ?string
     {
         // You should never run the Autodiscover more than once.
         // It can make between 1 and 5 calls before giving up, or before finding your server,
         // depending on how many different attempts it needs to make.
 
         // TODO: Autodiscovery may fail with an exception thrown. Handle this nicely.
         // TODO: Looks like this autodiscovery also does not work w/Basic Auth?
 
         $api = API\ExchangeAutodiscover::getAPI($user, $password);
 
         $server = $api->getClient()->getServer();
         $version = $api->getClient()->getVersion();
 
         return sprintf('ews://%s:%s@%s', urlencode($user), urlencode($password), $server);
     }
 
     /**
      * Authenticate to EWS (initialize the EWS client)
      */
-    public function authenticate()
+    public function authenticate(): void
     {
         if (!empty($this->account->params['client_id'])) {
             $this->api = $this->authenticateWithOAuth2(
                 $this->account->host,
                 $this->account->username,
                 $this->account->params['client_id'],
                 $this->account->params['client_secret'],
                 $this->account->params['tenant_id']
             );
         } else {
             // Note: This initializes the client, but not yet connects to the server
             // TODO: To know that the credentials work we'll have to do some API call.
             $this->api = $this->authenticateWithPassword(
                 $this->account->host,
                 $this->account->username,
                 $this->account->password,
                 $this->account->loginas
             );
         }
     }
 
     /**
      * Autodiscover the server and authenticate the user
      */
     protected function authenticateWithPassword(string $server, string $user, string $password, string $loginas = null)
     {
         // Note: Since 2023-01-01 EWS at Office365 requires OAuth2, no way back to basic auth.
 
         \Log::debug("[EWS] Using basic authentication on $server...");
 
         $options = [];
 
         if ($loginas) {
             $options['impersonation'] = $loginas;
         }
 
         $this->engine->setOption('ews', [
             'options' => $options,
             'server' => $server,
         ]);
 
         return API::withUsernameAndPassword($server, $user, $password, $this->apiOptions($options));
     }
 
     /**
      * Authenticate with a token (Office365)
      */
     protected function authenticateWithToken(string $server, string $user, string $token, $expires_at = null)
     {
         \Log::debug("[EWS] Using token authentication on $server...");
 
         $options = ['impersonation' => $user];
 
         $this->engine->setOption('ews', [
             'options' => $options,
             'server' => $server,
             'token' => $token,
             'expires_at' => $expires_at,
         ]);
 
         return API::withCallbackToken($server, $token, $this->apiOptions($options));
     }
 
     /**
      * Authenticate with OAuth2 (Office365) - get the token
      */
     protected function authenticateWithOAuth2(string $server,
         string $user, string $client_id, string $client_secret, string $tenant_id)
     {
         // See https://github.com/Garethp/php-ews/blob/master/examples/basic/authenticatingWithOAuth.php
         // See https://github.com/Garethp/php-ews/issues/236#issuecomment-1292521527
         // To register OAuth2 app goto https://entra.microsoft.com > Applications > App registrations
 
         \Log::debug("[EWS] Fetching OAuth2 token from $server...");
 
         $scope = 'https://outlook.office365.com/.default';
         $token_uri = "https://login.microsoftonline.com/{$tenant_id}/oauth2/v2.0/token";
         // $authUri = "https://login.microsoftonline.com/{$tenant_id}/oauth2/authorize";
 
         $response = Http::asForm()
             ->timeout(5)
             ->post($token_uri, [
                 'client_id' => $client_id,
                 'client_secret' => $client_secret,
                 'scope' => $scope,
                 'grant_type' => 'client_credentials',
             ])
             ->throwUnlessStatus(200);
 
         $token = $response->json('access_token');
 
         // Note: Office365 default token expiration time is ~1h,
         $expires_in = $response->json('expires_in');
         $expires_at = now()->addSeconds($expires_in)->toDateTimeString();
 
         return $this->authenticateWithToken($server, $user, $token, $expires_at);
     }
 
     /**
      * Get folders hierarchy
      */
     public function getFolders($types = []): array
     {
         // Get full folders hierarchy
         $options = [
             'Traversal' => 'Deep',
         ];
 
         $folders = $this->api->getChildrenFolders('root', $options);
 
         $result = [];
 
         foreach ($folders as $folder) {
             $class = $folder->getFolderClass();
             $type = $this->type_map[$class] ?? null;
 
             // Skip folder types we do not support (need)
             if (empty($type) || (!empty($types) && !in_array($type, $types))) {
                 continue;
             }
 
             // Note: Folder names are localized
             $name = $fullname = $folder->getDisplayName();
             $id = $folder->getFolderId()->getId();
             $parentId = $folder->getParentFolderId()->getId();
 
             // Create folder name with full path
             if ($parentId && !empty($result[$parentId])) {
                 $fullname = $result[$parentId]->fullname . '/' . $name;
             }
 
             // Top-level folder, check if it's a special folder we should ignore
             // FIXME: Is there a better way to distinguish user folders from system ones?
             if (
                 in_array($fullname, $this->folder_exceptions)
                 || strpos($fullname, 'OwaFV15.1All') === 0
             ) {
                 continue;
             }
 
             $result[$id] = Folder::fromArray([
                 'id' => $folder->getFolderId()->toArray(true),
                 'total' => $folder->getTotalCount(),
                 'class' => $class,
                 'type' => $this->type_map[$class] ?? null,
                 'name' => $name,
                 'fullname' => $fullname,
             ]);
         }
 
         return $result;
     }
 
     /**
      * Fetch a list of folder items
      */
     public function fetchItemList(Folder $folder, $callback, Interface\ImporterInterface $importer): void
     {
         // Job processing - initialize environment
         $this->initEnv($this->engine->queue);
 
         // The folder is empty, we can stop here
         if (empty($folder->total)) {
             // TODO: Delete all existing items?
             return;
         }
 
         // Get items already imported
         // TODO: This might be slow and/or memory expensive, we should consider
         // whether storing list of imported items in some cache wouldn't be a better
         // solution. Of course, cache would not get changes in the destination account.
         $existing = $importer->getItems($folder);
 
         // Create X-MS-ID index for easier search in existing items
         // Note: For some objects we could use UID (events), but for some we don't have UID in Exchange.
         // Also because fetching extra properties here is problematic, we use X-MS-ID.
         $existingIndex = [];
         array_walk(
             $existing,
             function (&$item, $idx) use (&$existingIndex) {
                 if (!empty($item['x-ms-id'])) {
                     [$id, $changeKey] = explode('!', $item['x-ms-id']);
                     $item['changeKey'] = $changeKey;
                     $existingIndex[$id] = $idx;
                     unset($item['x-ms-id']);
                 }
             }
         );
 
         $request = [
             // Exchange's maximum is 1000
             'IndexedPageItemView' => ['MaxEntriesReturned' => 100, 'Offset' => 0, 'BasePoint' => 'Beginning'],
             'ParentFolderIds' => $folder->id,
             'Traversal' => 'Shallow',
             'ItemShape' => [
                 'BaseShape' => 'IdOnly',
                 'AdditionalProperties' => [
                     'FieldURI' => ['FieldURI' => 'item:ItemClass'],
                 ],
             ],
         ];
 
         $request = Type::buildFromArray($request);
 
         // Note: It is not possible to get mimeContent with FindItem request
         //       That's why we first get the list of object identifiers and
         //       then call GetItem on each separately.
 
         // TODO: It might be feasible to get all properties for object types
         //       for which we don't use MimeContent, for better performance.
 
         // Request first page
         $response = $this->api->getClient()->FindItem($request);
 
         // @phpstan-ignore-next-line
         foreach ($response as $item) {
             if ($item = $this->toItem($item, $folder, $existing, $existingIndex)) {
                 $callback($item);
             }
         }
 
         // Request other pages until we got all
         while (!$response->isIncludesLastItemInRange()) {
             // @phpstan-ignore-next-line
             $response = $this->api->getNextPage($response);
 
             foreach ($response as $item) {
                 if ($item = $this->toItem($item, $folder, $existing, $existingIndex)) {
                     $callback($item);
                 }
             }
         }
 
         // TODO: Delete items that do not exist anymore?
     }
 
     /**
      * Fetching an item
      */
-    public function fetchItem(Item $item): string
+    public function fetchItem(Item $item): void
     {
         // Job processing - initialize environment
         $this->initEnv($this->engine->queue);
 
         if ($driver = EWS\Item::factory($this, $item)) {
-            return $driver->fetchItem($item);
+            $item->filename = $driver->fetchItem($item);
         }
 
-        throw new \Exception("Failed to fetch an item from EWS");
+        if (empty($item->filename)) {
+            throw new \Exception("Failed to fetch an item from EWS");
+        }
     }
 
     /**
      * Get the source account
      */
     public function getSourceAccount(): Account
     {
         return $this->engine->source;
     }
 
     /**
      * Get the destination account
      */
     public function getDestinationAccount(): Account
     {
         return $this->engine->destination;
     }
 
     /**
      * Synchronize specified object
      */
     protected function toItem(Type $item, Folder $folder, $existing, $existingIndex): ?Item
     {
         $id = $item->getItemId()->toArray();
         $exists = false;
 
         // Detect an existing item, skip if nothing changed
         if (isset($existingIndex[$id['Id']])) {
             $idx = $existingIndex[$id['Id']];
 
             if ($existing[$idx]['changeKey'] == $id['ChangeKey']) {
                 return null;
             }
 
-            $existing = $existing[$idx]['href'];
+            $exists = $existing[$idx]['href'];
         }
 
         $item = Item::fromArray([
             'id' => $id,
             'class' => $item->getItemClass(),
             'folder' => $folder,
-            'existing' => $existing,
+            'existing' => $exists,
         ]);
 
         // TODO: We don't need to instantiate Item at this point, instead
         // implement EWS\Item::validateClass() method
         if ($driver = EWS\Item::factory($this, $item)) {
             return $item;
         }
 
         return null;
     }
 
     /**
      * Set common API options
      */
     protected function apiOptions(array $options): array
     {
         if (empty($options['version'])) {
             $options['version'] = API\ExchangeWebServices::VERSION_2013;
         }
 
         // If you want to inject your own GuzzleClient for the requests
         // $options['httpClient]' = $client;
 
         // In debug mode record all responses
         /*
         if (\config('app.debug')) {
             $options['httpPlayback'] = [
                 'mode' => 'record',
                 'recordLocation' => \storage_path('ews'),
             ];
         }
         */
 
         return $options;
     }
 
     /**
      * Initialize environment for job execution
      *
      * @param Queue $queue Queue
      */
     protected function initEnv(Queue $queue): void
     {
         $ews = $queue->data['options']['ews'];
 
         if (!empty($ews['token'])) {
             // TODO: Refresh the token if needed
             $this->api = API::withCallbackToken(
                 $ews['server'],
                 $ews['token'],
                 $this->apiOptions($ews['options'])
             );
         } else {
             $this->api = API::withUsernameAndPassword(
                 $ews['server'],
                 $this->account->username,
                 $this->account->password,
                 $this->apiOptions($ews['options'])
             );
         }
     }
 }
diff --git a/src/app/DataMigrator/Engine.php b/src/app/DataMigrator/Engine.php
index 56f09d30..651d077c 100644
--- a/src/app/DataMigrator/Engine.php
+++ b/src/app/DataMigrator/Engine.php
@@ -1,275 +1,340 @@
 <?php
 
 namespace App\DataMigrator;
 
 use App\DataMigrator\Interface\ExporterInterface;
 use App\DataMigrator\Interface\Folder;
 use App\DataMigrator\Interface\ImporterInterface;
 use App\DataMigrator\Interface\Item;
+use App\DataMigrator\Interface\ItemSet;
 use Illuminate\Support\Str;
 
 /**
  * Data migration engine
  */
 class Engine
 {
     public const TYPE_CONTACT = 'contact';
     public const TYPE_EVENT = 'event';
     public const TYPE_GROUP = 'group';
     public const TYPE_MAIL = 'mail';
     public const TYPE_NOTE = 'note';
     public const TYPE_TASK = 'task';
 
     /** @var Account Source account */
     public $source;
 
     /** @var Account Destination account */
     public $destination;
 
     /** @var ?Queue Data migration queue (session) */
     public $queue;
 
     /** @var ExporterInterface Data exporter */
     protected $exporter;
 
     /** @var ImporterInterface Data importer */
     protected $importer;
 
     /** @var array Data migration options */
     protected $options = [];
 
 
     /**
      * Execute migration for the specified user
      */
     public function migrate(Account $source, Account $destination, array $options = [])
     {
         $this->source = $source;
         $this->destination = $destination;
         $this->options = $options;
 
         // Create a unique identifier for the migration request
         $queue_id = md5(strval($source) . strval($destination) . $options['type']);
 
+        // TODO: When running in 'sync' mode we shouldn't create a queue at all
+
         // If queue exists, we'll display the progress only
         if ($queue = Queue::find($queue_id)) {
             // If queue contains no jobs, assume invalid
             // TODO: An better API to manage (reset) queues
             if (!$queue->jobs_started || !empty($options['force'])) {
                 $queue->delete();
             } else {
                 while (true) {
                     $this->debug(sprintf("Progress [%d of %d]\n", $queue->jobs_finished, $queue->jobs_started));
 
                     if ($queue->jobs_started == $queue->jobs_finished) {
                         break;
                     }
 
                     sleep(1);
                     $queue->refresh();
                 }
 
                 return;
             }
         }
 
         // Initialize the source
         $this->exporter = $this->initDriver($source, ExporterInterface::class);
         $this->exporter->authenticate();
 
         // Initialize the destination
         $this->importer = $this->initDriver($destination, ImporterInterface::class);
         $this->importer->authenticate();
 
         // $this->debug("Source/destination user credentials verified.");
         $this->debug("Fetching folders hierarchy...");
 
         // Create a queue
         $this->createQueue($queue_id);
 
         // We'll store output in storage/<username> tree
         $location = storage_path('export/') . $source->email;
 
         if (!file_exists($location)) {
             mkdir($location, 0740, true);
         }
 
         $types = preg_split('/\s*,\s*/', strtolower($this->options['type'] ?? ''));
 
         $folders = $this->exporter->getFolders($types);
         $count = 0;
+        $async = empty($options['sync']);
 
         foreach ($folders as $folder) {
             $this->debug("Processing folder {$folder->fullname}...");
 
             $folder->queueId = $queue_id;
             $folder->location = $location;
 
-            // Dispatch the job (for async execution)
-            Jobs\FolderJob::dispatch($folder);
-            $count++;
+            if ($async) {
+                // Dispatch the job (for async execution)
+                Jobs\FolderJob::dispatch($folder);
+                $count++;
+            } else {
+                $this->processFolder($folder);
+            }
         }
 
-        $this->queue->bumpJobsStarted($count);
+        if ($count) {
+            $this->queue->bumpJobsStarted($count);
+        }
 
-        $this->debug(sprintf('Done. %d %s created in queue: %s.', $count, Str::plural('job', $count), $queue_id));
+        if ($async) {
+            $this->debug(sprintf('Done. %d %s created in queue: %s.', $count, Str::plural('job', $count), $queue_id));
+        } else {
+            $this->debug(sprintf('Done (queue: %s).', $queue_id));
+        }
     }
 
     /**
      * Processing of a folder synchronization
      */
     public function processFolder(Folder $folder): void
     {
         // Job processing - initialize environment
-        $this->envFromQueue($folder->queueId);
+        if (!$this->queue) {
+            $this->envFromQueue($folder->queueId);
+        }
 
         // Create the folder on the destination server
         $this->importer->createFolder($folder);
 
         $count = 0;
+        $async = empty($this->options['sync']);
 
         // Fetch items from the source
         $this->exporter->fetchItemList(
             $folder,
-            function (Item $item) use (&$count) {
-                // Dispatch the job (for async execution)
-                Jobs\ItemJob::dispatch($item);
-                $count++;
+            function ($item_or_set) use (&$count, $async) {
+                if ($async) {
+                    // Dispatch the job (for async execution)
+                    if ($item_or_set instanceof ItemSet) {
+                        Jobs\ItemSetJob::dispatch($item_or_set);
+                    } else {
+                        Jobs\ItemJob::dispatch($item_or_set);
+                    }
+                    $count++;
+                } else {
+                    if ($item_or_set instanceof ItemSet) {
+                        $this->processItemSet($item_or_set);
+                    } else {
+                        $this->processItem($item_or_set);
+                    }
+                }
             },
             $this->importer
         );
 
         if ($count) {
             $this->queue->bumpJobsStarted($count);
         }
 
-        $this->queue->bumpJobsFinished();
+        if ($async) {
+            $this->queue->bumpJobsFinished();
+        }
     }
 
     /**
      * Processing of item synchronization
      */
     public function processItem(Item $item): void
     {
         // Job processing - initialize environment
-        $this->envFromQueue($item->folder->queueId);
+        if (!$this->queue) {
+            $this->envFromQueue($item->folder->queueId);
+        }
 
-        if ($filename = $this->exporter->fetchItem($item)) {
-            $item->filename = $filename;
+        $this->exporter->fetchItem($item);
+        $this->importer->createItem($item);
+
+        if (!empty($item->filename)) {
+            unlink($item->filename);
+        }
+
+        if (empty($this->options['sync'])) {
+            $this->queue->bumpJobsFinished();
+        }
+    }
+
+    /**
+     * Processing of item-set synchronization
+     */
+    public function processItemSet(ItemSet $set): void
+    {
+        // Job processing - initialize environment
+        if (!$this->queue) {
+            $this->envFromQueue($set->items[0]->folder->queueId);
+        }
+
+        // TODO: Some exporters, e.g. DAV, might optimize fetching multiple items in one go,
+        // we'll need a new API to do that
+
+        foreach ($set->items as $item) {
+            $this->exporter->fetchItem($item);
             $this->importer->createItem($item);
-            // TODO: remove the file
+
+            if (!empty($item->filename)) {
+                unlink($item->filename);
+            }
         }
 
-        $this->queue->bumpJobsFinished();
+        // TODO: We should probably also track number of items migrated
+        if (empty($this->options['sync'])) {
+            $this->queue->bumpJobsFinished();
+        }
     }
 
     /**
      * Print progress/debug information
      */
     public function debug($line)
     {
         if (!empty($this->options['stdout'])) {
             $output = new \Symfony\Component\Console\Output\ConsoleOutput();
             $output->writeln("$line");
         } else {
             \Log::debug("[DataMigrator] $line");
         }
     }
 
     /**
      * Set migration queue option. Use this if you need to pass
      * some data between queue processes.
      */
     public function setOption(string $name, $value): void
     {
         $this->options[$name] = $value;
 
         if ($this->queue) {
             $this->queue->data = $this->queueData();
             $this->queue->save();
         }
     }
 
     /**
      * Create a queue for the request
      *
      * @param string $queue_id Unique queue identifier
      */
     protected function createQueue(string $queue_id): void
     {
         $this->queue = new Queue();
         $this->queue->id = $queue_id;
         $this->queue->data = $this->queueData();
         $this->queue->save();
     }
 
     /**
      * Prepare queue data
      */
     protected function queueData()
     {
         $options = $this->options;
         unset($options['stdout']); // jobs aren't in stdout anymore
 
         // TODO: data should be encrypted
         return [
             'source' => (string) $this->source,
             'destination' => (string) $this->destination,
             'options' => $options,
         ];
     }
 
     /**
      * Initialize environment for job execution
      *
      * @param string $queueId Queue identifier
      */
     protected function envFromQueue(string $queueId): void
     {
         $this->queue = Queue::findOrFail($queueId);
 
         $this->source = new Account($this->queue->data['source']);
         $this->destination = new Account($this->queue->data['destination']);
         $this->options = $this->queue->data['options'];
 
         $this->importer = $this->initDriver($this->destination, ImporterInterface::class);
         $this->exporter = $this->initDriver($this->source, ExporterInterface::class);
     }
 
     /**
      * Initialize (and select) migration driver
      */
     protected function initDriver(Account $account, string $interface)
     {
         switch ($account->scheme) {
             case 'ews':
                 $driver = new EWS($account, $this);
                 break;
 
             case 'dav':
             case 'davs':
                 $driver = new DAV($account, $this);
                 break;
-            /*
+
             case 'imap':
             case 'imaps':
+            case 'tls':
+            case 'ssl':
                 $driver = new IMAP($account, $this);
                 break;
-            */
 
             default:
                 throw new \Exception("Failed to init driver for '{$account->scheme}'");
         }
 
         // Make sure driver is used in the direction it supports
         if (!is_a($driver, $interface)) {
             throw new \Exception(sprintf(
                 "'%s' driver does not implement %s",
                 class_basename($driver),
                 class_basename($interface)
             ));
         }
 
         return $driver;
     }
 }
diff --git a/src/app/DataMigrator/IMAP.php b/src/app/DataMigrator/IMAP.php
new file mode 100644
index 00000000..0623cb61
--- /dev/null
+++ b/src/app/DataMigrator/IMAP.php
@@ -0,0 +1,377 @@
+<?php
+
+namespace App\DataMigrator;
+
+use App\DataMigrator\Interface\Folder;
+use App\DataMigrator\Interface\ExporterInterface;
+use App\DataMigrator\Interface\ImporterInterface;
+use App\DataMigrator\Interface\Item;
+use App\DataMigrator\Interface\ItemSet;
+
+/**
+ * Data migration from IMAP
+ */
+class IMAP implements ExporterInterface, ImporterInterface
+{
+    /** @const int Max number of items to migrate in one go */
+    protected const CHUNK_SIZE = 100;
+
+    /** @var \rcube_imap_generic Imap backend */
+    protected $imap;
+
+    /** @var Account Account to operate on */
+    protected $account;
+
+    /** @var Engine Data migrator engine */
+    protected $engine;
+
+
+    /**
+     * Object constructor
+     */
+    public function __construct(Account $account, Engine $engine)
+    {
+        $this->account = $account;
+        $this->engine = $engine;
+
+        // TODO: Move this to self::authenticate()?
+        $config = self::getConfig($account->username, $account->password, $account->uri);
+        $this->imap = self::initIMAP($config);
+    }
+
+    /**
+     * Authenticate
+     */
+    public function authenticate(): void
+    {
+    }
+
+    /**
+     * Create a folder.
+     *
+     * @param Folder $folder Folder data
+     *
+     * @throws \Exception on error
+     */
+    public function createFolder(Folder $folder): void
+    {
+        if ($folder->type != 'mail') {
+            throw new \Exception("IMAP does not support folder of type {$folder->type}");
+        }
+
+        if ($folder->fullname == 'INBOX') {
+            // INBOX always exists
+            return;
+        }
+
+        if (!$this->imap->createFolder($folder->fullname)) {
+            \Log::warning("Failed to create the folder: {$this->imap->error}");
+
+            if (str_contains($this->imap->error, "Mailbox already exists")) {
+                // Not an error
+            } else {
+                throw new \Exception("Failed to create an IMAP folder {$folder->fullname}");
+            }
+        }
+    }
+
+    /**
+     * Create an item in a folder.
+     *
+     * @param Item $item Item to import
+     *
+     * @throws \Exception
+     */
+    public function createItem(Item $item): void
+    {
+        $mailbox = $item->folder->fullname;
+
+        // TODO: When updating an email we have to just update flags
+
+        if ($item->filename) {
+            $result = $this->imap->appendFromFile(
+                $mailbox, $item->filename, null, $item->data['flags'], $item->data['internaldate'], true
+            );
+
+            if ($result === false) {
+                throw new \Exception("Failed to append IMAP message into {$mailbox}");
+            }
+        }
+    }
+
+    /**
+     * Fetching an item
+     */
+    public function fetchItem(Item $item): void
+    {
+        [$uid, $messageId] = explode(':', $item->id, 2);
+
+        $mailbox = $item->folder->fullname;
+
+        // Get message flags
+        $header = $this->imap->fetchHeader($mailbox, (int) $uid, true, false, ['FLAGS']);
+
+        if ($header === false) {
+            throw new \Exception("Failed to get IMAP message headers for {$mailbox}/{$uid}");
+        }
+
+        // Remove flags that we can't append (e.g. RECENT)
+        $flags = $this->filterImapFlags(array_keys($header->flags));
+
+        // TODO: If message already exists in the destination account we should update flags
+        // and be done with it. On the other hand for Drafts it's not unusual to get completely
+        // different body for the same Message-ID. Same can happen not only in Drafts, I suppose.
+
+        // Save the message content to a file
+        $location = $item->folder->location;
+
+        if (!file_exists($location)) {
+            mkdir($location, 0740, true);
+        }
+
+        // TODO: What if parent folder not yet exists?
+        $location .= '/' . $uid . '.eml';
+
+        // TODO: We should consider streaming the message, it should be possible
+        // with append() and handlePartBody(), but I don't know if anyone tried that.
+
+        $fp = fopen($location, 'w');
+
+        if (!$fp) {
+            throw new \Exception("Failed to write to {$location}");
+        }
+
+        $result = $this->imap->handlePartBody($mailbox, $uid, true, '', null, null, $fp);
+
+        if ($result === false) {
+            fclose($fp);
+            throw new \Exception("Failed to fetch IMAP message for {$mailbox}/{$uid}");
+        }
+
+        $item->filename = $location;
+        $item->data = [
+            'flags' => $flags,
+            'internaldate' => $header->internaldate,
+        ];
+
+        fclose($fp);
+    }
+
+    /**
+     * Fetch a list of folder items
+     */
+    public function fetchItemList(Folder $folder, $callback, ImporterInterface $importer): void
+    {
+        // Get existing messages' headers from the destination mailbox
+        $existing = $importer->getItems($folder);
+
+        $mailbox = $folder->fullname;
+
+        // TODO: We should probably first use SEARCH/SORT to skip messages marked as \Deleted
+        // TODO: fetchHeaders() fetches too many headers, we should slim-down, here we need
+        // only UID FLAGS INTERNALDATE BODY.PEEK[HEADER.FIELDS (DATE FROM MESSAGE-ID)]
+        $messages = $this->imap->fetchHeaders($mailbox, '1:*', true, false, ['Message-Id']);
+
+        if ($messages === false) {
+            throw new \Exception("Failed to get all IMAP message headers for {$mailbox}");
+        }
+
+        if (empty($messages)) {
+            \Log::debug("Nothing to migrate for {$mailbox}");
+            return;
+        }
+
+        $set = new ItemSet();
+
+        foreach ($messages as $message) {
+            // TODO: If Message-Id header does not exist create it based on internaldate/From/Date
+
+            // Skip message that exists and did not change
+            $exists = false;
+            if (isset($existing[$message->messageID])) {
+                // TODO: Compare flags (compare message size, internaldate?)
+                continue;
+            }
+
+            $set->items[] = Item::fromArray([
+                'id' => $message->uid . ':' . $message->messageID,
+                'folder' => $folder,
+                'existing' => $exists,
+            ]);
+
+            if (count($set->items) == self::CHUNK_SIZE) {
+                $callback($set);
+                $set = new ItemSet();
+            }
+        }
+
+        if (count($set->items)) {
+            $callback($set);
+        }
+
+        // TODO: Delete messages that do not exist anymore?
+    }
+
+    /**
+     * Get folders hierarchy
+     */
+    public function getFolders($types = []): array
+    {
+        $folders = $this->imap->listMailboxes('', '');
+
+        if ($folders === false) {
+            throw new \Exception("Failed to get list of IMAP folders");
+        }
+
+        $result = [];
+
+        foreach ($folders as $folder) {
+            if ($this->shouldSkip($folder)) {
+                \Log::debug("Skipping folder {$folder}.");
+                continue;
+            }
+
+            $result[] = Folder::fromArray([
+                'fullname' => $folder,
+                'type' => 'mail'
+            ]);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Get a list of folder items, limited to their essential propeties
+     * used in incremental migration to skip unchanged items.
+     */
+    public function getItems(Folder $folder): array
+    {
+        $mailbox = $folder->fullname;
+
+        // TODO: We should probably first use SEARCH/SORT to skip messages marked as \Deleted
+        // TODO: fetchHeaders() fetches too many headers, we should slim-down, here we need
+        // only UID FLAGS INTERNALDATE BODY.PEEK[HEADER.FIELDS (DATE FROM MESSAGE-ID)]
+        $messages = $this->imap->fetchHeaders($mailbox, '1:*', true, false, ['Message-Id']);
+
+        if ($messages === false) {
+            throw new \Exception("Failed to get IMAP message headers in {$mailbox}");
+        }
+
+        $result = [];
+
+        foreach ($messages as $message) {
+            // Remove flags that we can't append (e.g. RECENT)
+            $flags = $this->filterImapFlags(array_keys($message->flags));
+
+            // TODO: Generate message ID if the header does not exist
+            $result[$message->messageID] = [
+                'uid' => $message->uid,
+                'flags' => $flags,
+            ];
+        }
+
+        return $result;
+    }
+
+    /**
+     * Initialize IMAP connection and authenticate the user
+     */
+    private static function initIMAP(array $config, string $login_as = null): \rcube_imap_generic
+    {
+        $imap = new \rcube_imap_generic();
+
+        if (\config('app.debug')) {
+            $imap->setDebug(true, 'App\Backends\IMAP::logDebug');
+        }
+
+        if ($login_as) {
+            $config['options']['auth_cid'] = $config['user'];
+            $config['options']['auth_pw'] = $config['password'];
+            $config['options']['auth_type'] = 'PLAIN';
+            $config['user'] = $login_as;
+        }
+
+        $imap->connect($config['host'], $config['user'], $config['password'], $config['options']);
+
+        if (!$imap->connected()) {
+            $message = sprintf("Login failed for %s against %s. %s", $config['user'], $config['host'], $imap->error);
+
+            \Log::error($message);
+
+            throw new \Exception("Connection to IMAP failed");
+        }
+
+        return $imap;
+    }
+
+    /**
+     * Get IMAP configuration
+     */
+    private static function getConfig($user, $password, $uri): array
+    {
+        $uri = \parse_url($uri);
+        $default_port = 143;
+        $ssl_mode = null;
+
+        if (isset($uri['scheme'])) {
+            if (preg_match('/^(ssl|imaps)/', $uri['scheme'])) {
+                $default_port = 993;
+                $ssl_mode = 'ssl';
+            } elseif ($uri['scheme'] === 'tls') {
+                $ssl_mode = 'tls';
+            }
+        }
+
+        $config = [
+            'host' => $uri['host'],
+            'user' => $user,
+            'password' => $password,
+            'options' => [
+                'port' => !empty($uri['port']) ? $uri['port'] : $default_port,
+                'ssl_mode' => $ssl_mode,
+                'socket_options' => [
+                    'ssl' => [
+                        // TODO: These configuration options make sense for "local" Kolab IMAP,
+                        // but when connecting to external one we might want to just disable
+                        // cert validation, or make it optional via Account URI parameters
+                        'verify_peer' => \config('imap.verify_peer'),
+                        'verify_peer_name' => \config('imap.verify_peer'),
+                        'verify_host' => \config('imap.verify_host')
+                    ],
+                ],
+            ],
+        ];
+
+        return $config;
+    }
+
+    /**
+     * Limit IMAP flags to these that can be migrated
+     */
+    private function filterImapFlags($flags)
+    {
+        // TODO: Support custom flags migration
+
+        return array_filter(
+            $flags,
+            function ($flag) {
+                return in_array($flag, $this->imap->flags);
+            }
+        );
+    }
+
+    /**
+     * Check if the folder should not be migrated
+     */
+    private function shouldSkip($folder): bool
+    {
+        // TODO: This should probably use NAMESPACE information
+        // TODO: This should also skip other user folders
+
+        if (preg_match("/Shared Folders\/.*/", $folder)) {
+            return true;
+        }
+
+        return false;
+    }
+}
diff --git a/src/app/DataMigrator/Interface/ExporterInterface.php b/src/app/DataMigrator/Interface/ExporterInterface.php
index 250106ef..b93f8709 100644
--- a/src/app/DataMigrator/Interface/ExporterInterface.php
+++ b/src/app/DataMigrator/Interface/ExporterInterface.php
@@ -1,36 +1,36 @@
 <?php
 
 namespace App\DataMigrator\Interface;
 
 use App\DataMigrator\Account;
 use App\DataMigrator\Engine;
 
 interface ExporterInterface
 {
     /**
      * Object constructor
      */
     public function __construct(Account $account, Engine $engine);
 
     /**
      * Check user credentials.
      *
      * @throws \Exception
      */
     public function authenticate();
 
     /**
      * Get folders hierarchy
      */
     public function getFolders($types = []): array;
 
     /**
      * Fetch a list of folder items
      */
     public function fetchItemList(Folder $folder, $callback, ImporterInterface $importer): void;
 
     /**
      * Fetching an item
      */
-    public function fetchItem(Item $item): string;
+    public function fetchItem(Item $item): void;
 }
diff --git a/src/app/DataMigrator/Interface/Folder.php b/src/app/DataMigrator/Interface/Folder.php
index a7cb62b5..f4a5d4a3 100644
--- a/src/app/DataMigrator/Interface/Folder.php
+++ b/src/app/DataMigrator/Interface/Folder.php
@@ -1,47 +1,47 @@
 <?php
 
 namespace App\DataMigrator\Interface;
 
 use App\DataMigrator\Queue;
 
 /**
  * Data object representing a folder
  */
 class Folder
 {
     /** @var mixed Folder identifier */
     public $id;
 
     /** @var int Number of items in the folder */
     public $total;
 
     /** @var string Folder class */
     public $class;
 
     /** @var string Folder Kolab object type */
     public $type;
 
     /** @var string Folder name */
     public $name;
 
     /** @var string Folder name with path */
     public $fullname;
 
     /** @var string Storage location (for temporary data) */
     public $location;
 
     /** @var string Migration queue identifier */
     public $queueId;
 
 
-    public static function fromArray(array $data = [])
+    public static function fromArray(array $data = []): Folder
     {
         $obj = new self();
 
         foreach ($data as $key => $value) {
             $obj->{$key} = $value;
         }
 
         return $obj;
     }
 }
diff --git a/src/app/DataMigrator/Interface/Item.php b/src/app/DataMigrator/Interface/Item.php
index f00f3be6..d242eb76 100644
--- a/src/app/DataMigrator/Interface/Item.php
+++ b/src/app/DataMigrator/Interface/Item.php
@@ -1,36 +1,39 @@
 <?php
 
 namespace App\DataMigrator\Interface;
 
 /**
  * Data object representing a data item
  */
 class Item
 {
     /** @var mixed Item identifier */
     public $id;
 
     /** @var Folder Folder */
     public $folder;
 
     /** @var string Object class */
     public $class;
 
     /** @var false|string Identifier/Location of the item if exists in the destination folder */
     public $existing = false;
 
     /** @var ?string Exported object location in the local storage */
     public $filename;
 
+    /** @var array Extra data to migrate (like email flags, internaldate, etc.) */
+    public $data = [];
 
-    public static function fromArray(array $data = [])
+
+    public static function fromArray(array $data = []): Item
     {
         $obj = new self();
 
         foreach ($data as $key => $value) {
             $obj->{$key} = $value;
         }
 
         return $obj;
     }
 }
diff --git a/src/app/DataMigrator/Interface/ItemSet.php b/src/app/DataMigrator/Interface/ItemSet.php
new file mode 100644
index 00000000..a3b5c5ac
--- /dev/null
+++ b/src/app/DataMigrator/Interface/ItemSet.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\DataMigrator\Interface;
+
+/**
+ * Data object representing a set of data items
+ */
+class ItemSet
+{
+    /** @var array<Item> Items list */
+    public $items = [];
+
+    // TODO: Every item has a $folder property, this makes the set
+    // needlesly big when serialized. We should probably store $folder
+    // once with the set and remove it from an item on serialize
+    // and back in unserialize.
+
+    /**
+     * Create an ItemSet instance
+     */
+    public static function set(array $items = []): ItemSet
+    {
+        $obj = new self();
+        $obj->items = $items;
+
+        return $obj;
+    }
+}
diff --git a/src/app/DataMigrator/Jobs/ItemSetJob.php b/src/app/DataMigrator/Jobs/ItemSetJob.php
new file mode 100644
index 00000000..2af01658
--- /dev/null
+++ b/src/app/DataMigrator/Jobs/ItemSetJob.php
@@ -0,0 +1,64 @@
+<?php
+
+namespace App\DataMigrator\Jobs;
+
+use App\DataMigrator\Engine;
+use App\DataMigrator\Interface\ItemSet;
+use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+use Illuminate\Queue\InteractsWithQueue;
+
+class ItemSetJob implements ShouldQueue
+{
+    use Dispatchable;
+    use InteractsWithQueue;
+    use Queueable;
+    use SerializesModels;
+
+    /** @var int The number of times the job may be attempted. */
+    public $tries = 3;
+
+    /** @var ItemSet Job data */
+    protected $set;
+
+
+    /**
+     * Create a new job instance.
+     *
+     * @param ItemSet $set Set of Items to process
+     *
+     * @return void
+     */
+    public function __construct(ItemSet $set)
+    {
+        $this->set = $set;
+    }
+
+    /**
+     * Execute the job.
+     *
+     * @return void
+     */
+    public function handle()
+    {
+        $migrator = new Engine();
+        $migrator->processItemSet($this->set);
+    }
+
+    /**
+     * The job failed to process.
+     *
+     * @param \Exception $exception
+     *
+     * @return void
+     */
+    public function failed(\Exception $exception)
+    {
+        // TODO: Count failed jobs in the queue
+        // I'm not sure how to do this after the final failure (after X tries)
+        // In other words how do we know all jobs in a queue finished (successfully or not)
+        // Probably we have to set $tries = 1
+    }
+}
diff --git a/src/bootstrap/app.php b/src/bootstrap/app.php
index 037e17df..def6d60c 100644
--- a/src/bootstrap/app.php
+++ b/src/bootstrap/app.php
@@ -1,55 +1,78 @@
 <?php
 
+// Stuff from Roundcube Framework bootstrap required by rcube_* classes
+define('RCUBE_CHARSET', 'UTF-8');
+
+/**
+ * Get first element from an array
+ *
+ * @param array $array Input array
+ *
+ * @return mixed First element if found, Null otherwise
+ */
+function array_first($array)
+{
+    // @phpstan-ignore-next-line
+    if (is_array($array) && !empty($array)) {
+        reset($array);
+        foreach ($array as $element) {
+            return $element;
+        }
+    }
+
+    return null;
+}
+
 /*
 |--------------------------------------------------------------------------
 | Create The Application
 |--------------------------------------------------------------------------
 |
 | The first thing we will do is create a new Laravel application instance
 | which serves as the "glue" for all the components of Laravel, and is
 | the IoC container for the system binding all of the various parts.
 |
 */
 
 $app = new Illuminate\Foundation\Application(
     $_ENV['APP_BASE_PATH'] ?? dirname(__DIR__)
 );
 
 /*
 |--------------------------------------------------------------------------
 | Bind Important Interfaces
 |--------------------------------------------------------------------------
 |
 | Next, we need to bind some important interfaces into the container so
 | we will be able to resolve them when needed. The kernels serve the
 | incoming requests to this application from both the web and CLI.
 |
 */
 
 $app->singleton(
     Illuminate\Contracts\Http\Kernel::class,
     App\Http\Kernel::class
 );
 
 $app->singleton(
     Illuminate\Contracts\Console\Kernel::class,
     App\Console\Kernel::class
 );
 
 $app->singleton(
     Illuminate\Contracts\Debug\ExceptionHandler::class,
     App\Exceptions\Handler::class
 );
 
 /*
 |--------------------------------------------------------------------------
 | Return The Application
 |--------------------------------------------------------------------------
 |
 | This script returns the application instance. The instance is given to
 | the calling script so we can separate the building of the instances
 | from the actual running of the application and sending responses.
 |
 */
 
 return $app;
diff --git a/src/include/rcube_charset.php b/src/include/rcube_charset.php
new file mode 100644
index 00000000..4d6eaa60
--- /dev/null
+++ b/src/include/rcube_charset.php
@@ -0,0 +1,570 @@
+<?php
+
+/**
+ +-----------------------------------------------------------------------+
+ | This file is part of the Roundcube Webmail client                     |
+ |                                                                       |
+ | Copyright (C) The Roundcube Dev Team                                  |
+ | Copyright (C) Kolab Systems AG                                        |
+ | Copyright (C) 2000 Edmund Grimley Evans <edmundo@rano.org>            |
+ |                                                                       |
+ | Licensed under the GNU General Public License version 3 or            |
+ | any later version with exceptions for skins & plugins.                |
+ | See the README file for a full license statement.                     |
+ |                                                                       |
+ | PURPOSE:                                                              |
+ |   Provide charset conversion functionality                            |
+ +-----------------------------------------------------------------------+
+ | Author: Thomas Bruederli <roundcube@gmail.com>                        |
+ | Author: Aleksander Machniak <alec@alec.pl>                            |
+ | Author: Edmund Grimley Evans <edmundo@rano.org>                       |
+ +-----------------------------------------------------------------------+
+*/
+
+/**
+ * Character sets conversion functionality
+ *
+ * @package    Framework
+ * @subpackage Core
+ */
+class rcube_charset
+{
+    /**
+     * Character set aliases (some of them from HTML5 spec.)
+     *
+     * @var array
+     */
+    static public $aliases = [
+        'USASCII'       => 'WINDOWS-1252',
+        'ANSIX31101983' => 'WINDOWS-1252',
+        'ANSIX341968'   => 'WINDOWS-1252',
+        'UNKNOWN8BIT'   => 'ISO-8859-15',
+        'UNKNOWN'       => 'ISO-8859-15',
+        'USERDEFINED'   => 'ISO-8859-15',
+        'KSC56011987'   => 'EUC-KR',
+        'GB2312'        => 'GBK',
+        'GB231280'      => 'GBK',
+        'UNICODE'       => 'UTF-8',
+        'UTF7IMAP'      => 'UTF7-IMAP',
+        'TIS620'        => 'WINDOWS-874',
+        'ISO88599'      => 'WINDOWS-1254',
+        'ISO885911'     => 'WINDOWS-874',
+        'MACROMAN'      => 'MACINTOSH',
+        '77'            => 'MAC',
+        '128'           => 'SHIFT-JIS',
+        '129'           => 'CP949',
+        '130'           => 'CP1361',
+        '134'           => 'GBK',
+        '136'           => 'BIG5',
+        '161'           => 'WINDOWS-1253',
+        '162'           => 'WINDOWS-1254',
+        '163'           => 'WINDOWS-1258',
+        '177'           => 'WINDOWS-1255',
+        '178'           => 'WINDOWS-1256',
+        '186'           => 'WINDOWS-1257',
+        '204'           => 'WINDOWS-1251',
+        '222'           => 'WINDOWS-874',
+        '238'           => 'WINDOWS-1250',
+        'MS950'         => 'CP950',
+        'WINDOWS949'    => 'UHC',
+        'WINDOWS1257'   => 'ISO-8859-13',
+        'ISO2022JP'     => 'ISO-2022-JP-MS',
+    ];
+
+    /**
+     * Windows codepages
+     *
+     * @var array
+     */
+    static public $windows_codepages = [
+         37 => 'IBM037',    // IBM EBCDIC US-Canada
+        437 => 'IBM437',    // OEM United States
+        500 => 'IBM500',    // IBM EBCDIC International
+        708 => 'ASMO-708',  // Arabic (ASMO 708)
+        720 => 'DOS-720',   // Arabic (Transparent ASMO); Arabic (DOS)
+        737 => 'IBM737',    // OEM Greek (formerly 437G); Greek (DOS)
+        775 => 'IBM775',    // OEM Baltic; Baltic (DOS)
+        850 => 'IBM850',    // OEM Multilingual Latin 1; Western European (DOS)
+        852 => 'IBM852',    // OEM Latin 2; Central European (DOS)
+        855 => 'IBM855',    // OEM Cyrillic (primarily Russian)
+        857 => 'IBM857',    // OEM Turkish; Turkish (DOS)
+        858 => 'IBM00858',  // OEM Multilingual Latin 1 + Euro symbol
+        860 => 'IBM860',    // OEM Portuguese; Portuguese (DOS)
+        861 => 'IBM861',    // OEM Icelandic; Icelandic (DOS)
+        862 => 'DOS-862',   // OEM Hebrew; Hebrew (DOS)
+        863 => 'IBM863',    // OEM French Canadian; French Canadian (DOS)
+        864 => 'IBM864',    // OEM Arabic; Arabic (864)
+        865 => 'IBM865',    // OEM Nordic; Nordic (DOS)
+        866 => 'cp866',     // OEM Russian; Cyrillic (DOS)
+        869 => 'IBM869',    // OEM Modern Greek; Greek, Modern (DOS)
+        870 => 'IBM870',    // IBM EBCDIC Multilingual/ROECE (Latin 2); IBM EBCDIC Multilingual Latin 2
+        874 => 'windows-874',  // ANSI/OEM Thai (ISO 8859-11); Thai (Windows)
+        875 => 'cp875',     // IBM EBCDIC Greek Modern
+        932 => 'shift_jis', // ANSI/OEM Japanese; Japanese (Shift-JIS)
+        936 => 'gb2312',    // ANSI/OEM Simplified Chinese (PRC, Singapore); Chinese Simplified (GB2312)
+        950 => 'big5',      // ANSI/OEM Traditional Chinese (Taiwan; Hong Kong SAR, PRC); Chinese Traditional (Big5)
+        1026 => 'IBM1026',      // IBM EBCDIC Turkish (Latin 5)
+        1047 => 'IBM01047',     // IBM EBCDIC Latin 1/Open System
+        1140 => 'IBM01140',     // IBM EBCDIC US-Canada (037 + Euro symbol); IBM EBCDIC (US-Canada-Euro)
+        1141 => 'IBM01141',     // IBM EBCDIC Germany (20273 + Euro symbol); IBM EBCDIC (Germany-Euro)
+        1142 => 'IBM01142',     // IBM EBCDIC Denmark-Norway (20277 + Euro symbol); IBM EBCDIC (Denmark-Norway-Euro)
+        1143 => 'IBM01143',     // IBM EBCDIC Finland-Sweden (20278 + Euro symbol); IBM EBCDIC (Finland-Sweden-Euro)
+        1144 => 'IBM01144',     // IBM EBCDIC Italy (20280 + Euro symbol); IBM EBCDIC (Italy-Euro)
+        1145 => 'IBM01145',     // IBM EBCDIC Latin America-Spain (20284 + Euro symbol); IBM EBCDIC (Spain-Euro)
+        1146 => 'IBM01146',     // IBM EBCDIC United Kingdom (20285 + Euro symbol); IBM EBCDIC (UK-Euro)
+        1147 => 'IBM01147',     // IBM EBCDIC France (20297 + Euro symbol); IBM EBCDIC (France-Euro)
+        1148 => 'IBM01148',     // IBM EBCDIC International (500 + Euro symbol); IBM EBCDIC (International-Euro)
+        1149 => 'IBM01149',     // IBM EBCDIC Icelandic (20871 + Euro symbol); IBM EBCDIC (Icelandic-Euro)
+        1200 => 'UTF-16',       // Unicode UTF-16, little endian byte order (BMP of ISO 10646); available only to managed applications
+        1201 => 'UTF-16BE',     // Unicode UTF-16, big endian byte order; available only to managed applications
+        1250 => 'windows-1250', // ANSI Central European; Central European (Windows)
+        1251 => 'windows-1251', // ANSI Cyrillic; Cyrillic (Windows)
+        1252 => 'windows-1252', // ANSI Latin 1; Western European (Windows)
+        1253 => 'windows-1253', // ANSI Greek; Greek (Windows)
+        1254 => 'windows-1254', // ANSI Turkish; Turkish (Windows)
+        1255 => 'windows-1255', // ANSI Hebrew; Hebrew (Windows)
+        1256 => 'windows-1256', // ANSI Arabic; Arabic (Windows)
+        1257 => 'windows-1257', // ANSI Baltic; Baltic (Windows)
+        1258 => 'windows-1258', // ANSI/OEM Vietnamese; Vietnamese (Windows)
+        10000 => 'macintosh',   // MAC Roman; Western European (Mac)
+        12000 => 'UTF-32',      // Unicode UTF-32, little endian byte order; available only to managed applications
+        12001 => 'UTF-32BE',    // Unicode UTF-32, big endian byte order; available only to managed applications
+        20127 => 'US-ASCII',    // US-ASCII (7-bit)
+        20273 => 'IBM273',      // IBM EBCDIC Germany
+        20277 => 'IBM277',      // IBM EBCDIC Denmark-Norway
+        20278 => 'IBM278',      // IBM EBCDIC Finland-Sweden
+        20280 => 'IBM280',      // IBM EBCDIC Italy
+        20284 => 'IBM284',      // IBM EBCDIC Latin America-Spain
+        20285 => 'IBM285',      // IBM EBCDIC United Kingdom
+        20290 => 'IBM290',      // IBM EBCDIC Japanese Katakana Extended
+        20297 => 'IBM297',      // IBM EBCDIC France
+        20420 => 'IBM420',      // IBM EBCDIC Arabic
+        20423 => 'IBM423',      // IBM EBCDIC Greek
+        20424 => 'IBM424',      // IBM EBCDIC Hebrew
+        20838 => 'IBM-Thai',    // IBM EBCDIC Thai
+        20866 => 'koi8-r',      // Russian (KOI8-R); Cyrillic (KOI8-R)
+        20871 => 'IBM871',      // IBM EBCDIC Icelandic
+        20880 => 'IBM880',      // IBM EBCDIC Cyrillic Russian
+        20905 => 'IBM905',      // IBM EBCDIC Turkish
+        20924 => 'IBM00924',    // IBM EBCDIC Latin 1/Open System (1047 + Euro symbol)
+        20932 => 'EUC-JP',      // Japanese (JIS 0208-1990 and 0212-1990)
+        20936 => 'cp20936',     // Simplified Chinese (GB2312); Chinese Simplified (GB2312-80)
+        20949 => 'cp20949',     // Korean Wansung
+        21025 => 'cp1025',      // IBM EBCDIC Cyrillic Serbian-Bulgarian
+        21866 => 'koi8-u',      // Ukrainian (KOI8-U); Cyrillic (KOI8-U)
+        28591 => 'iso-8859-1',  // ISO 8859-1 Latin 1; Western European (ISO)
+        28592 => 'iso-8859-2',  // ISO 8859-2 Central European; Central European (ISO)
+        28593 => 'iso-8859-3',  // ISO 8859-3 Latin 3
+        28594 => 'iso-8859-4',  // ISO 8859-4 Baltic
+        28595 => 'iso-8859-5',  // ISO 8859-5 Cyrillic
+        28596 => 'iso-8859-6',  // ISO 8859-6 Arabic
+        28597 => 'iso-8859-7',  // ISO 8859-7 Greek
+        28598 => 'iso-8859-8',  // ISO 8859-8 Hebrew; Hebrew (ISO-Visual)
+        28599 => 'iso-8859-9',  // ISO 8859-9 Turkish
+        28603 => 'iso-8859-13', // ISO 8859-13 Estonian
+        28605 => 'iso-8859-15', // ISO 8859-15 Latin 9
+        38598 => 'iso-8859-8-i', // ISO 8859-8 Hebrew; Hebrew (ISO-Logical)
+        50220 => 'iso-2022-jp', // ISO 2022 Japanese with no halfwidth Katakana; Japanese (JIS)
+        50221 => 'csISO2022JP', // ISO 2022 Japanese with halfwidth Katakana; Japanese (JIS-Allow 1 byte Kana)
+        50222 => 'iso-2022-jp', // ISO 2022 Japanese JIS X 0201-1989; Japanese (JIS-Allow 1 byte Kana - SO/SI)
+        50225 => 'iso-2022-kr', // ISO 2022 Korean
+        51932 => 'EUC-JP',      // EUC Japanese
+        51936 => 'EUC-CN',      // EUC Simplified Chinese; Chinese Simplified (EUC)
+        51949 => 'EUC-KR',      // EUC Korean
+        52936 => 'hz-gb-2312',  // HZ-GB2312 Simplified Chinese; Chinese Simplified (HZ)
+        54936 => 'GB18030',     // Windows XP and later: GB18030 Simplified Chinese (4 byte); Chinese Simplified (GB18030)
+        65000 => 'UTF-7',
+        65001 => 'UTF-8',
+    ];
+
+    /**
+     * Validate character set identifier.
+     *
+     * @param string $input Character set identifier
+     *
+     * @return bool True if valid, False if not valid
+     */
+    public static function is_valid($input)
+    {
+        return is_string($input) && preg_match('|^[a-zA-Z0-9_./:#-]{2,32}$|', $input) > 0;
+    }
+
+    /**
+     * Parse and validate charset name string.
+     * Sometimes charset string is malformed, there are also charset aliases,
+     * but we need strict names for charset conversion (specially utf8 class)
+     *
+     * @param string $input Input charset name
+     *
+     * @return string The validated charset name
+     */
+    public static function parse_charset($input)
+    {
+        static $charsets = [];
+
+        $charset = strtoupper($input);
+
+        if (isset($charsets[$input])) {
+            return $charsets[$input];
+        }
+
+        $charset = preg_replace([
+            '/^[^0-9A-Z]+/',    // e.g. _ISO-8859-JP$SIO
+            '/\$.*$/',          // e.g. _ISO-8859-JP$SIO
+            '/UNICODE-1-1-*/',  // RFC1641/1642
+            '/^X-/',            // X- prefix (e.g. X-ROMAN8 => ROMAN8)
+            '/\*.*$/'           // lang code according to RFC 2231.5
+        ], '', $charset);
+
+        if ($charset == 'BINARY') {
+            return $charsets[$input] = null;
+        }
+
+        // allow A-Z and 0-9 only
+        $str = preg_replace('/[^A-Z0-9]/', '', $charset);
+
+        $result = $charset;
+
+        if (isset(self::$aliases[$str])) {
+            $result = self::$aliases[$str];
+        }
+        // UTF
+        else if (preg_match('/U[A-Z][A-Z](7|8|16|32)(BE|LE)*/', $str, $m)) {
+            $result = 'UTF-' . $m[1] . (!empty($m[2]) ? $m[2] : '');
+        }
+        // ISO-8859
+        else if (preg_match('/ISO8859([0-9]{0,2})/', $str, $m)) {
+            $iso = 'ISO-8859-' . ($m[1] ?: 1);
+            // some clients sends windows-1252 text as latin1,
+            // it is safe to use windows-1252 for all latin1
+            $result = $iso == 'ISO-8859-1' ? 'WINDOWS-1252' : $iso;
+        }
+        // handle broken charset names e.g. WINDOWS-1250HTTP-EQUIVCONTENT-TYPE
+        else if (preg_match('/(WIN|WINDOWS)([0-9]+)/', $str, $m)) {
+            $result = 'WINDOWS-' . $m[2];
+        }
+        // LATIN
+        else if (preg_match('/LATIN(.*)/', $str, $m)) {
+            $aliases = ['2' => 2, '3' => 3, '4' => 4, '5' => 9, '6' => 10,
+                '7' => 13, '8' => 14, '9' => 15, '10' => 16,
+                'ARABIC' => 6, 'CYRILLIC' => 5, 'GREEK' => 7, 'GREEK1' => 7, 'HEBREW' => 8
+            ];
+
+            // some clients sends windows-1252 text as latin1,
+            // it is safe to use windows-1252 for all latin1
+            if ($m[1] == 1) {
+                $result = 'WINDOWS-1252';
+            }
+            // we need ISO labels
+            else if (!empty($aliases[$m[1]])) {
+                $result = 'ISO-8859-'.$aliases[$m[1]];
+            }
+        }
+
+        $charsets[$input] = $result;
+
+        return $result;
+    }
+
+    /**
+     * Convert a string from one charset to another.
+     *
+     * @param string $str  Input string
+     * @param string $from Suspected charset of the input string
+     * @param string $to   Target charset to convert to; defaults to RCUBE_CHARSET
+     *
+     * @return string Converted string
+     */
+    public static function convert($str, $from, $to = null)
+    {
+        static $iconv_options;
+
+        $to   = empty($to) ? RCUBE_CHARSET : self::parse_charset($to);
+        $from = self::parse_charset($from);
+
+        // It is a common case when UTF-16 charset is used with US-ASCII content (#1488654)
+        // In that case we can just skip the conversion (use UTF-8)
+        if ($from == 'UTF-16' && !preg_match('/[^\x00-\x7F]/', $str)) {
+            $from = 'UTF-8';
+        }
+
+        if ($from == $to || empty($str) || empty($from)) {
+            return $str;
+        }
+
+        $out = false;
+        $error_handler = function() { throw new \Exception(); };
+
+        // Ignore invalid characters
+        $mbstring_sc = mb_substitute_character();
+        mb_substitute_character('none');
+
+        // If mbstring reports an illegal character in input via E_WARNING.
+        // FIXME: Is this really true with substitute character 'none'?
+        // A warning is thrown in PHP<8 also on unsupported encoding, in PHP>=8 ValueError
+        // is thrown instead (therefore we catch Throwable below)
+        set_error_handler($error_handler, E_WARNING);
+
+        try {
+            $out = mb_convert_encoding($str, $to, $from);
+        }
+        catch (Throwable $e) {
+            $out = false;
+        }
+        catch (Exception $e) {
+            $out = false;
+        }
+
+        restore_error_handler();
+        mb_substitute_character($mbstring_sc);
+
+        if ($out !== false) {
+            return $out;
+        }
+
+        if ($iconv_options === null) {
+            if (function_exists('iconv')) {
+                // ignore characters not available in output charset
+                $iconv_options = '//IGNORE';
+                if (iconv('', $iconv_options, '') === false) {
+                    // iconv implementation does not support options
+                    $iconv_options = '';
+                }
+            }
+            else {
+                $iconv_options = false;
+            }
+        }
+
+        // Fallback to iconv module, it is slower, but supports much more charsets than mbstring
+        if ($iconv_options !== false && $from != 'UTF7-IMAP' && $to != 'UTF7-IMAP'
+            && $from !== 'ISO-2022-JP'
+        ) {
+            // If iconv reports an illegal character in input it means that input string
+            // has been truncated. It's reported as E_NOTICE.
+            // PHP8 will also throw E_WARNING on unsupported encoding.
+            set_error_handler($error_handler, E_NOTICE | E_WARNING);
+
+            try {
+                $out = iconv($from, $to . $iconv_options, $str);
+            }
+            catch (Throwable $e) {
+                $out = false;
+            }
+            catch (Exception $e) {
+                $out = false;
+            }
+
+            restore_error_handler();
+
+            if ($out !== false) {
+                return $out;
+            }
+        }
+
+        // return the original string
+        return $str;
+    }
+
+    /**
+     * Converts string from standard UTF-7 (RFC 2152) to UTF-8.
+     *
+     * @param string $str Input string (UTF-7)
+     *
+     * @return string Converted string (UTF-8)
+     * @deprecated use self::convert()
+     */
+    public static function utf7_to_utf8($str)
+    {
+        return self::convert($str, 'UTF-7', 'UTF-8');
+    }
+
+    /**
+     * Converts string from UTF-16 to UTF-8 (helper for utf-7 to utf-8 conversion)
+     *
+     * @param string $str Input string
+     *
+     * @return string The converted string
+     * @deprecated use self::convert()
+     */
+    public static function utf16_to_utf8($str)
+    {
+        return self::convert($str, 'UTF-16BE', 'UTF-8');
+    }
+
+    /**
+     * Convert the data ($str) from RFC 2060's UTF-7 to UTF-8.
+     * If input data is invalid, return the original input string.
+     * RFC 2060 obviously intends the encoding to be unique (see
+     * point 5 in section 5.1.3), so we reject any non-canonical
+     * form, such as &ACY- (instead of &-) or &AMA-&AMA- (instead
+     * of &AMAAwA-).
+     *
+     * @param string $str Input string (UTF7-IMAP)
+     *
+     * @return string Output string (UTF-8)
+     * @deprecated use self::convert()
+     */
+    public static function utf7imap_to_utf8($str)
+    {
+        return self::convert($str, 'UTF7-IMAP', 'UTF-8');
+    }
+
+    /**
+     * Convert the data ($str) from UTF-8 to RFC 2060's UTF-7.
+     * Unicode characters above U+FFFF are replaced by U+FFFE.
+     * If input data is invalid, return an empty string.
+     *
+     * @param string $str Input string (UTF-8)
+     *
+     * @return string Output string (UTF7-IMAP)
+     * @deprecated use self::convert()
+     */
+    public static function utf8_to_utf7imap($str)
+    {
+        return self::convert($str, 'UTF-8', 'UTF7-IMAP');
+    }
+
+    /**
+     * A method to guess character set of a string.
+     *
+     * @param string $string   String
+     * @param string $failover Default result for failover
+     * @param string $language User language
+     *
+     * @return string Charset name
+     */
+    public static function detect($string, $failover = null, $language = null)
+    {
+        if (substr($string, 0, 4) == "\0\0\xFE\xFF") return 'UTF-32BE';  // Big Endian
+        if (substr($string, 0, 4) == "\xFF\xFE\0\0") return 'UTF-32LE';  // Little Endian
+        if (substr($string, 0, 2) == "\xFE\xFF")     return 'UTF-16BE';  // Big Endian
+        if (substr($string, 0, 2) == "\xFF\xFE")     return 'UTF-16LE';  // Little Endian
+        if (substr($string, 0, 3) == "\xEF\xBB\xBF") return 'UTF-8';
+
+        // heuristics
+        if (strlen($string) >= 4) {
+            if ($string[0] == "\0" && $string[1] == "\0" && $string[2] == "\0" && $string[3] != "\0") return 'UTF-32BE';
+            if ($string[0] != "\0" && $string[1] == "\0" && $string[2] == "\0" && $string[3] == "\0") return 'UTF-32LE';
+            if ($string[0] == "\0" && $string[1] != "\0" && $string[2] == "\0" && $string[3] != "\0") return 'UTF-16BE';
+            if ($string[0] != "\0" && $string[1] == "\0" && $string[2] != "\0" && $string[3] == "\0") return 'UTF-16LE';
+        }
+
+        if (empty($language)) {
+            $rcube    = rcube::get_instance();
+            $language = $rcube->get_user_language();
+        }
+
+        // Prioritize charsets according to current language (#1485669)
+        $prio = null;
+        switch ($language) {
+        case 'ja_JP':
+            $prio = ['ISO-2022-JP', 'JIS', 'UTF-8', 'EUC-JP', 'eucJP-win', 'SJIS', 'SJIS-win'];
+            break;
+
+        case 'zh_CN':
+        case 'zh_TW':
+            $prio = ['UTF-8', 'BIG-5', 'GB2312', 'EUC-TW'];
+            break;
+
+        case 'ko_KR':
+            $prio = ['UTF-8', 'EUC-KR', 'ISO-2022-KR'];
+            break;
+
+        case 'ru_RU':
+            $prio = ['UTF-8', 'WINDOWS-1251', 'KOI8-R'];
+            break;
+
+        case 'tr_TR':
+            $prio = ['UTF-8', 'ISO-8859-9', 'WINDOWS-1254'];
+            break;
+        }
+
+        // mb_detect_encoding() is not reliable for some charsets (#1490135)
+        // use mb_check_encoding() to make charset priority lists really working
+        if (!empty($prio) && function_exists('mb_check_encoding')) {
+            foreach ($prio as $encoding) {
+                if (mb_check_encoding($string, $encoding)) {
+                    return $encoding;
+                }
+            }
+        }
+
+        if (function_exists('mb_detect_encoding')) {
+            if (empty($prio)) {
+                $prio = ['UTF-8', 'SJIS', 'GB2312',
+                    'ISO-8859-1', 'ISO-8859-2', 'ISO-8859-3', 'ISO-8859-4',
+                    'ISO-8859-5', 'ISO-8859-6', 'ISO-8859-7', 'ISO-8859-8', 'ISO-8859-9',
+                    'ISO-8859-10', 'ISO-8859-13', 'ISO-8859-14', 'ISO-8859-15', 'ISO-8859-16',
+                    'WINDOWS-1252', 'WINDOWS-1251', 'EUC-JP', 'EUC-TW', 'KOI8-R', 'BIG-5',
+                    'ISO-2022-KR', 'ISO-2022-JP',
+                ];
+            }
+
+            $encodings = array_unique(array_merge($prio, mb_list_encodings()));
+
+            if ($encoding = mb_detect_encoding($string, $encodings)) {
+                return $encoding;
+            }
+        }
+
+        // No match, check for UTF-8
+        // from http://w3.org/International/questions/qa-forms-utf-8.html
+        if (preg_match('/\A(
+            [\x09\x0A\x0D\x20-\x7E]
+            | [\xC2-\xDF][\x80-\xBF]
+            | \xE0[\xA0-\xBF][\x80-\xBF]
+            | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}
+            | \xED[\x80-\x9F][\x80-\xBF]
+            | \xF0[\x90-\xBF][\x80-\xBF]{2}
+            | [\xF1-\xF3][\x80-\xBF]{3}
+            | \xF4[\x80-\x8F][\x80-\xBF]{2}
+            )*\z/xs', substr($string, 0, 2048))
+        ) {
+            return 'UTF-8';
+        }
+
+        return $failover;
+    }
+
+    /**
+     * Removes non-unicode characters from input.
+     * If the input is an array, both values and keys will be cleaned up.
+     *
+     * @param mixed $input String or array.
+     *
+     * @return mixed String or array
+     */
+    public static function clean($input)
+    {
+        // handle input of type array
+        if (is_array($input)) {
+            foreach (array_keys($input) as $key) {
+                $k = is_string($key) ? self::clean($key) : $key;
+                $v = self::clean($input[$key]);
+
+                if ($k !== $key) {
+                    unset($input[$key]);
+                    if (!array_key_exists($k, $input)) {
+                        $input[$k] = $v;
+                    }
+                }
+                else {
+                    $input[$k] = $v;
+                }
+            }
+            return $input;
+        }
+
+        if (!is_string($input) || $input == '') {
+            return $input;
+        }
+
+        $msch = mb_substitute_character();
+        mb_substitute_character('none');
+        $res = mb_convert_encoding($input, 'UTF-8', 'UTF-8');
+        mb_substitute_character($msch);
+
+        return $res;
+    }
+}
diff --git a/src/include/rcube_imap_generic.php b/src/include/rcube_imap_generic.php
index 8385ac5e..65f24156 100644
--- a/src/include/rcube_imap_generic.php
+++ b/src/include/rcube_imap_generic.php
@@ -1,4235 +1,4235 @@
 <?php
 
 /*
  +-----------------------------------------------------------------------+
  | This file is part of the Roundcube Webmail client                     |
  |                                                                       |
  | Copyright (C) The Roundcube Dev Team                                  |
  | Copyright (C) Kolab Systems AG                                        |
  |                                                                       |
  | Licensed under the GNU General Public License version 3 or            |
  | any later version with exceptions for skins & plugins.                |
  | See the README file for a full license statement.                     |
  |                                                                       |
  | PURPOSE:                                                              |
  |   Provide alternative IMAP library that doesn't rely on the standard  |
  |   C-Client based version. This allows to function regardless          |
  |   of whether or not the PHP build it's running on has IMAP            |
  |   functionality built-in.                                             |
  |                                                                       |
  |   Based on Iloha IMAP Library. See http://ilohamail.org/ for details  |
  +-----------------------------------------------------------------------+
  | Author: Aleksander Machniak <alec@alec.pl>                            |
  | Author: Ryo Chijiiwa <Ryo@IlohaMail.org>                              |
  +-----------------------------------------------------------------------+
 */
 
 /**
  * PHP based wrapper class to connect to an IMAP server
  */
 class rcube_imap_generic
 {
     public $error;
     public $errornum;
     public $result;
     public $resultcode;
     public $selected;
     public $data  = [];
     public $flags = [
         'SEEN'      => '\\Seen',
         'DELETED'   => '\\Deleted',
         'ANSWERED'  => '\\Answered',
         'DRAFT'     => '\\Draft',
         'FLAGGED'   => '\\Flagged',
         'FORWARDED' => '$Forwarded',
         'MDNSENT'   => '$MDNSent',
         '*'         => '\\*',
     ];
 
     protected $fp;
     protected $host;
     protected $user;
     protected $cmd_tag;
     protected $cmd_num = 0;
     protected $resourceid;
     protected $extensions_enabled;
     protected $prefs             = [];
     protected $logged            = false;
     protected $capability        = [];
     protected $capability_read   = false;
     protected $debug             = false;
     protected $debug_handler     = false;
 
     public const ERROR_OK       = 0;
     public const ERROR_NO       = -1;
     public const ERROR_BAD      = -2;
     public const ERROR_BYE      = -3;
     public const ERROR_UNKNOWN  = -4;
     public const ERROR_COMMAND  = -5;
     public const ERROR_READONLY = -6;
 
     public const COMMAND_NORESPONSE = 1;
     public const COMMAND_CAPABILITY = 2;
     public const COMMAND_LASTLINE   = 4;
     public const COMMAND_ANONYMIZED = 8;
 
     public const DEBUG_LINE_LENGTH = 4098; // 4KB + 2B for \r\n
 
 
     /**
      * Send simple (one line) command to the connection stream
      *
      * @param string $string     Command string
      * @param bool   $endln      True if CRLF need to be added at the end of command
      * @param bool   $anonymized Don't write the given data to log but a placeholder
      *
      * @return int Number of bytes sent, False on error
      */
     protected function putLine($string, $endln = true, $anonymized = false)
     {
         if (!$this->fp) {
             return false;
         }
 
         if ($this->debug) {
             // anonymize the sent command for logging
             $cut = $endln ? 2 : 0;
             if ($anonymized && preg_match('/^(A\d+ (?:[A-Z]+ )+)(.+)/', $string, $m)) {
                 $log = $m[1] . sprintf('****** [%d]', strlen($m[2]) - $cut);
             } elseif ($anonymized) {
                 $log = sprintf('****** [%d]', strlen($string) - $cut);
             } else {
                 $log = rtrim($string);
             }
 
             $this->debug('C: ' . $log);
         }
 
         if ($endln) {
             $string .= "\r\n";
         }
 
         $res = fwrite($this->fp, $string);
 
         if ($res === false) {
             $this->closeSocket();
         }
 
         return $res;
     }
 
     /**
      * Send command to the connection stream with Command Continuation
      * Requests (RFC3501 7.5) and LITERAL+ (RFC2088) and LITERAL- (RFC7888) support.
      *
      * @param string $string     Command string
      * @param bool   $endln      True if CRLF need to be added at the end of command
      * @param bool   $anonymized Don't write the given data to log but a placeholder
      *
      * @return int|bool Number of bytes sent, False on error
      */
     protected function putLineC($string, $endln = true, $anonymized = false)
     {
         if (!$this->fp) {
             return false;
         }
 
         if ($endln) {
             $string .= "\r\n";
         }
 
         $res = 0;
         if ($parts = preg_split('/(\{[0-9]+\}\r\n)/m', $string, -1, \PREG_SPLIT_DELIM_CAPTURE)) {
             for ($i = 0, $cnt = count($parts); $i < $cnt; $i++) {
                 if ($i + 1 < $cnt && preg_match('/^\{([0-9]+)\}\r\n$/', $parts[$i + 1], $matches)) {
                     // LITERAL+/LITERAL- support
                     $literal_plus = false;
                     if (
                         !empty($this->prefs['literal+'])
                         || (!empty($this->prefs['literal-']) && $matches[1] <= 4096)
                     ) {
                         $parts[$i + 1] = sprintf("{%d+}\r\n", $matches[1]);
                         $literal_plus = true;
                     }
 
                     $bytes = $this->putLine($parts[$i] . $parts[$i + 1], false, $anonymized);
                     if ($bytes === false) {
                         return false;
                     }
 
                     $res += $bytes;
 
                     // don't wait if server supports LITERAL+ capability
                     if (!$literal_plus) {
                         $line = $this->readLine(1000);
                         // handle error in command
                         if (!isset($line[0]) || $line[0] != '+') {
                             return false;
                         }
                     }
 
                     $i++;
                 } else {
                     $bytes = $this->putLine($parts[$i], false, $anonymized);
                     if ($bytes === false) {
                         return false;
                     }
 
                     $res += $bytes;
                 }
             }
         }
 
         return $res;
     }
 
     /**
      * Reads line from the connection stream
      *
      * @param int $size Buffer size
      *
      * @return string Line of text response
      */
     protected function readLine($size = 1024)
     {
         $line = '';
 
         if (!$size) {
             $size = 1024;
         }
 
         do {
             if ($this->eof()) {
                 return $line;
             }
 
             $buffer = fgets($this->fp, $size);
 
             if ($buffer === false) {
                 $this->closeSocket();
                 break;
             }
 
             if ($this->debug) {
                 $this->debug('S: ' . rtrim($buffer));
             }
 
             $line .= $buffer;
         } while (substr($buffer, -1) != "\n");
 
         return $line;
     }
 
     /**
      * Reads a line of data from the connection stream including all
      * string continuation literals.
      *
      * @param int $size Buffer size
      *
      * @return string Line of text response
      */
     protected function readFullLine($size = 1024)
     {
         $line = $this->readLine($size);
 
         // include all string literals untile the real end of "line"
         while (preg_match('/\{([0-9]+)\}\r\n$/', $line, $m)) {
             $bytes = $m[1];
             $out   = '';
 
             while (strlen($out) < $bytes) {
                 $out = $this->readBytes($bytes);
                 if ($out === '') {
                     break;
                 }
 
                 $line .= $out;
             }
 
             $line .= $this->readLine($size);
         }
 
         return $line;
     }
 
     /**
      * Reads more data from the connection stream when provided
      * data contain string literal
      *
      * @param string $line   Response text
      * @param bool   $escape Enables escaping
      *
      * @return string Line of text response
      */
     protected function multLine($line, $escape = false)
     {
         $line = rtrim($line);
         if (preg_match('/\{([0-9]+)\}$/', $line, $m)) {
             $out   = '';
             $str   = substr($line, 0, -strlen($m[0]));
             $bytes = $m[1];
 
             while (strlen($out) < $bytes) {
                 $line = $this->readBytes($bytes);
                 if ($line === '') {
                     break;
                 }
 
                 $out .= $line;
             }
 
             $line = $str . ($escape ? $this->escape($out) : $out);
         }
 
         return $line;
     }
 
     /**
      * Reads specified number of bytes from the connection stream
      *
      * @param int $bytes Number of bytes to get
      *
      * @return string Response text
      */
     protected function readBytes($bytes)
     {
         $data = '';
         $len  = 0;
 
         while ($len < $bytes && !$this->eof()) {
             $d = fread($this->fp, $bytes - $len);
             if ($this->debug) {
                 $this->debug('S: ' . $d);
             }
             $data .= $d;
             $data_len = strlen($data);
             if ($len == $data_len) {
                 break; // nothing was read -> exit to avoid apache lockups
             }
             $len = $data_len;
         }
 
         return $data;
     }
 
     /**
      * Reads complete response to the IMAP command
      *
      * @param array $untagged Will be filled with untagged response lines
      *
      * @return string Response text
      */
     protected function readReply(&$untagged = null)
     {
         while (true) {
             $line = trim($this->readLine(1024));
             // store untagged response lines
             if (isset($line[0]) && $line[0] == '*') {
                 $untagged[] = $line;
             } else {
                 break;
             }
         }
 
         if ($untagged) {
             $untagged = implode("\n", $untagged);
         }
 
         return $line;
     }
 
     /**
      * Response parser.
      *
      * @param string $string     Response text
      * @param string $err_prefix Error message prefix
      *
      * @return int Response status
      */
     protected function parseResult($string, $err_prefix = '')
     {
         if (preg_match('/^[a-z0-9*]+ (OK|NO|BAD|BYE)(.*)$/i', trim($string), $matches)) {
             $res = strtoupper($matches[1]);
             $str = trim($matches[2]);
 
             if ($res == 'OK') {
                 $this->errornum = self::ERROR_OK;
             } elseif ($res == 'NO') {
                 $this->errornum = self::ERROR_NO;
             } elseif ($res == 'BAD') {
                 $this->errornum = self::ERROR_BAD;
             } elseif ($res == 'BYE') {
                 $this->closeSocket();
                 $this->errornum = self::ERROR_BYE;
             }
 
             if ($str) {
                 $str = trim($str);
                 // get response string and code (RFC5530)
                 if (preg_match('/^\\[([a-z-]+)\\]/i', $str, $m)) {
                     $this->resultcode = strtoupper($m[1]);
                     $str = trim(substr($str, strlen($m[1]) + 2));
                 } else {
                     $this->resultcode = null;
                     // parse response for [APPENDUID 1204196876 3456]
                     if (preg_match('/^\\[APPENDUID [0-9]+ ([0-9]+)\\]/i', $str, $m)) {
                         $this->data['APPENDUID'] = $m[1];
                     }
                     // parse response for [COPYUID 1204196876 3456:3457 123:124]
                     elseif (preg_match('/^\\[COPYUID [0-9]+ ([0-9,:]+) ([0-9,:]+)\\]/i', $str, $m)) {
                         $this->data['COPYUID'] = [$m[1], $m[2]];
                     }
                 }
 
                 $this->result = $str;
 
                 if ($this->errornum != self::ERROR_OK) {
                     $this->error = $err_prefix ? $err_prefix . $str : $str;
                 }
             }
 
             return $this->errornum;
         }
 
         return self::ERROR_UNKNOWN;
     }
 
     /**
      * Checks connection stream state.
      *
      * @return bool True if connection is closed
      */
     protected function eof()
     {
         if (!$this->fp) {
             return true;
         }
 
         // If a connection opened by fsockopen() wasn't closed
         // by the server, feof() will hang.
         $start = microtime(true);
 
         if (feof($this->fp)
             || ($this->prefs['timeout'] && (microtime(true) - $start > $this->prefs['timeout']))
         ) {
             $this->closeSocket();
             return true;
         }
 
         return false;
     }
 
     /**
      * Closes connection stream.
      */
     protected function closeSocket()
     {
         if ($this->fp) {
             fclose($this->fp);
             $this->fp = null;
         }
     }
 
     /**
      * Error code/message setter.
      */
     protected function setError($code, $msg = '')
     {
         $this->errornum = $code;
         $this->error    = $msg;
 
         return $code;
     }
 
     /**
      * Checks response status.
      * Checks if command response line starts with specified prefix (or * BYE/BAD)
      *
      * @param string $string   Response text
      * @param string $match    Prefix to match with (case-sensitive)
      * @param bool   $error    Enables BYE/BAD checking
      * @param bool   $nonempty Enables empty response checking
      *
      * @return bool True any check is true or connection is closed.
      */
     protected function startsWith($string, $match, $error = false, $nonempty = false)
     {
         if (!$this->fp) {
             return true;
         }
 
         if (strncmp($string, $match, strlen($match)) == 0) {
             return true;
         }
 
         if ($error && preg_match('/^\* (BYE|BAD) /i', $string, $m)) {
             if (strtoupper($m[1]) == 'BYE') {
                 $this->closeSocket();
             }
             return true;
         }
 
         if ($nonempty && !strlen($string)) {
             return true;
         }
 
         return false;
     }
 
     /**
      * Capabilities checker
      */
     protected function hasCapability($name)
     {
         if (empty($this->capability) || empty($name)) {
             return false;
         }
 
         if (in_array($name, $this->capability)) {
             return true;
         } elseif (strpos($name, '=')) {
             return false;
         }
 
         $result = [];
         foreach ($this->capability as $cap) {
             $entry = explode('=', $cap);
             if ($entry[0] == $name) {
                 $result[] = $entry[1];
             }
         }
 
         return $result ?: false;
     }
 
     /**
      * Capabilities checker
      *
      * @param string $name Capability name
      *
      * @return mixed Capability values array for key=value pairs, true/false for others
      */
     public function getCapability($name)
     {
         $result = $this->hasCapability($name);
 
         if (!empty($result)) {
             return $result;
         } elseif ($this->capability_read) {
             return false;
         }
 
         // get capabilities (only once) because initial
         // optional CAPABILITY response may differ
         $result = $this->execute('CAPABILITY');
 
         if ($result[0] == self::ERROR_OK) {
             $this->parseCapability($result[1]);
         }
 
         $this->capability_read = true;
 
         return $this->hasCapability($name);
     }
 
     /**
      * Clears detected server capabilities
      */
     public function clearCapability()
     {
         $this->capability        = [];
         $this->capability_read = false;
     }
 
     /**
      * DIGEST-MD5/CRAM-MD5/PLAIN Authentication
      *
      * @param string $user Username
      * @param string $pass Password
      * @param string $type Authentication type (PLAIN/CRAM-MD5/DIGEST-MD5)
      *
      * @return resource|int Connection resource on success, error code on error
      */
     protected function authenticate($user, $pass, $type = 'PLAIN')
     {
         if ($type == 'CRAM-MD5' || $type == 'DIGEST-MD5') {
             if ($type == 'DIGEST-MD5' && !class_exists('Auth_SASL')) {
                 return $this->setError(self::ERROR_BYE,
                     'The Auth_SASL package is required for DIGEST-MD5 authentication');
             }
 
             $this->putLine($this->nextTag() . " AUTHENTICATE $type");
             $line = trim($this->readReply());
 
             if ($line[0] == '+') {
                 $challenge = substr($line, 2);
             } else {
                 return $this->parseResult($line);
             }
 
             if ($type == 'CRAM-MD5') {
                 // RFC2195: CRAM-MD5
                 $ipad = '';
                 $opad = '';
                 $xor  = static function ($str1, $str2) {
                     $result = '';
                     $size   = strlen($str1);
                     for ($i = 0; $i < $size; $i++) {
                         $result .= chr(ord($str1[$i]) ^ ord($str2[$i]));
                     }
                     return $result;
                 };
 
                 // initialize ipad, opad
                 for ($i = 0; $i < 64; $i++) {
                     $ipad .= chr(0x36);
                     $opad .= chr(0x5C);
                 }
 
                 // pad $pass so it's 64 bytes
                 $pass = str_pad($pass, 64, chr(0));
 
                 // generate hash
                 $hash  = md5($xor($pass, $opad) . pack('H*',
                     md5($xor($pass, $ipad) . base64_decode($challenge))));
                 $reply = base64_encode($user . ' ' . $hash);
 
                 // send result
                 $this->putLine($reply, true, true);
             } else {
                 // RFC2831: DIGEST-MD5
                 // proxy authorization
                 if (!empty($this->prefs['auth_cid'])) {
                     $authc = $this->prefs['auth_cid'];
                     $pass  = $this->prefs['auth_pw'];
                 } else {
                     $authc = $user;
                     $user  = '';
                 }
 
                 $auth_sasl = new Auth_SASL();
                 $auth_sasl = $auth_sasl->factory('digestmd5');
                 $reply     = base64_encode($auth_sasl->getResponse($authc, $pass,
                     base64_decode($challenge), $this->host, 'imap', $user));
 
                 // send result
                 $this->putLine($reply, true, true);
                 $line = trim($this->readReply());
 
                 if ($line[0] != '+') {
                     return $this->parseResult($line);
                 }
 
                 // check response
                 $challenge = substr($line, 2);
                 $challenge = base64_decode($challenge);
                 if (strpos($challenge, 'rspauth=') === false) {
                     return $this->setError(self::ERROR_BAD,
                         'Unexpected response from server to DIGEST-MD5 response');
                 }
 
                 $this->putLine('');
             }
 
             $line   = $this->readReply();
             $result = $this->parseResult($line);
         } elseif ($type == 'GSSAPI') {
             if (!extension_loaded('krb5')) {
                 return $this->setError(self::ERROR_BYE,
                     'The krb5 extension is required for GSSAPI authentication');
             }
 
             if (empty($this->prefs['gssapi_cn'])) {
                 return $this->setError(self::ERROR_BYE,
                     'The gssapi_cn parameter is required for GSSAPI authentication');
             }
 
             if (empty($this->prefs['gssapi_context'])) {
                 return $this->setError(self::ERROR_BYE,
                     'The gssapi_context parameter is required for GSSAPI authentication');
             }
 
             putenv('KRB5CCNAME=' . $this->prefs['gssapi_cn']);
 
             try {
                 $ccache = new KRB5CCache();
                 $ccache->open($this->prefs['gssapi_cn']);
                 $gssapicontext = new GSSAPIContext();
                 $gssapicontext->acquireCredentials($ccache);
 
                 $token   = '';
                 $success = $gssapicontext->initSecContext($this->prefs['gssapi_context'], null, null, null, $token);
                 $token   = base64_encode($token);
             } catch (Exception $e) {
                 trigger_error($e->getMessage(), \E_USER_WARNING);
                 return $this->setError(self::ERROR_BYE, 'GSSAPI authentication failed');
             }
 
             $this->putLine($this->nextTag() . ' AUTHENTICATE GSSAPI ' . $token);
             $line = trim($this->readReply());
 
             if ($line[0] != '+') {
                 return $this->parseResult($line);
             }
 
             try {
                 $itoken = base64_decode(substr($line, 2));
 
                 if (!$gssapicontext->unwrap($itoken, $itoken)) {
                     throw new Exception('GSSAPI SASL input token unwrap failed');
                 }
 
                 if (strlen($itoken) < 4) {
                     throw new Exception('GSSAPI SASL input token invalid');
                 }
 
                 // Integrity/encryption layers are not supported. The first bit
                 // indicates that the server supports "no security layers".
                 // 0x00 should not occur, but support broken implementations.
                 $server_layers = ord($itoken[0]);
                 if ($server_layers && ($server_layers & 0x1) != 0x1) {
                     throw new Exception('Server requires GSSAPI SASL integrity/encryption');
                 }
 
                 // Construct output token. 0x01 in the first octet = SASL layer "none",
                 // zero in the following three octets = no data follows.
                 // See https://github.com/cyrusimap/cyrus-sasl/blob/e41cfb986c1b1935770de554872247453fdbb079/plugins/gssapi.c#L1284
                 if (!$gssapicontext->wrap(pack('CCCC', 0x1, 0, 0, 0), $otoken, true)) {
                     throw new Exception('GSSAPI SASL output token wrap failed');
                 }
             } catch (Exception $e) {
                 trigger_error($e->getMessage(), \E_USER_WARNING);
                 return $this->setError(self::ERROR_BYE, 'GSSAPI authentication failed');
             }
 
             $this->putLine(base64_encode($otoken));
 
             $line   = $this->readReply();
             $result = $this->parseResult($line);
         } elseif ($type == 'PLAIN') {
             // proxy authorization
             if (!empty($this->prefs['auth_cid'])) {
                 $authc = $this->prefs['auth_cid'];
                 $pass  = $this->prefs['auth_pw'];
             } else {
                 $authc = $user;
                 $user  = '';
             }
 
             $reply = base64_encode($user . chr(0) . $authc . chr(0) . $pass);
 
             // RFC 4959 (SASL-IR): save one round trip
             if ($this->getCapability('SASL-IR')) {
                 [$result, $line] = $this->execute('AUTHENTICATE PLAIN', [$reply],
                     self::COMMAND_LASTLINE | self::COMMAND_CAPABILITY | self::COMMAND_ANONYMIZED);
             } else {
                 $this->putLine($this->nextTag() . ' AUTHENTICATE PLAIN');
                 $line = trim($this->readReply());
 
                 if ($line[0] != '+') {
                     return $this->parseResult($line);
                 }
 
                 // send result, get reply and process it
                 $this->putLine($reply, true, true);
                 $line   = $this->readReply();
                 $result = $this->parseResult($line);
             }
         } elseif ($type == 'LOGIN') {
             $this->putLine($this->nextTag() . ' AUTHENTICATE LOGIN');
 
             $line = trim($this->readReply());
             if ($line[0] != '+') {
                 return $this->parseResult($line);
             }
 
             $this->putLine(base64_encode($user), true, true);
 
             $line = trim($this->readReply());
             if ($line[0] != '+') {
                 return $this->parseResult($line);
             }
 
             // send result, get reply and process it
             $this->putLine(base64_encode($pass), true, true);
 
             $line   = $this->readReply();
             $result = $this->parseResult($line);
         } elseif (($type == 'XOAUTH2') || ($type == 'OAUTHBEARER')) {
             $auth = ($type == 'XOAUTH2')
                 ? base64_encode("user=$user\1auth=$pass\1\1")  // XOAUTH: original extension, still widely used
                 : base64_encode("n,a=$user,\1auth=$pass\1\1"); // OAUTHBEARER: official RFC 7628
             $this->putLine($this->nextTag() . " AUTHENTICATE $type $auth", true, true);
 
             $line = trim($this->readReply());
 
             if ($line[0] == '+') {
                 // send empty line
                 $this->putLine('', true, true);
                 $line = $this->readReply();
             }
 
             $result = $this->parseResult($line);
         } else {
             $line  = 'not supported';
             $result = self::ERROR_UNKNOWN;
         }
 
         if ($result === self::ERROR_OK) {
             // optional CAPABILITY response
             if ($line && preg_match('/\[CAPABILITY ([^]]+)\]/i', $line, $matches)) {
                 $this->parseCapability($matches[1], true);
             }
 
             return $this->fp;
         }
 
         return $this->setError($result, "AUTHENTICATE $type: $line");
     }
 
     /**
      * LOGIN Authentication
      *
      * @param string $user     Username
      * @param string $password Password
      *
      * @return resource|int Connection resource on success, error code on error
      */
     protected function login($user, $password)
     {
         // Prevent from sending credentials in plain text when connection is not secure
         if ($this->getCapability('LOGINDISABLED')) {
             return $this->setError(self::ERROR_BAD, 'Login disabled by IMAP server');
         }
 
         [$code, $response] = $this->execute('LOGIN', [$this->escape($user, true), $this->escape($password, true)],
             self::COMMAND_CAPABILITY | self::COMMAND_ANONYMIZED);
 
         // re-set capabilities list if untagged CAPABILITY response provided
         if (preg_match('/\* CAPABILITY (.+)/i', $response, $matches)) {
             $this->parseCapability($matches[1], true);
         }
 
         if ($code == self::ERROR_OK) {
             return $this->fp;
         }
 
         return $code;
     }
 
     /**
      * Detects hierarchy delimiter
      *
      * @return string The delimiter
      */
     public function getHierarchyDelimiter()
     {
         if (!empty($this->prefs['delimiter'])) {
             return $this->prefs['delimiter'];
         }
 
         // try (LIST "" ""), should return delimiter (RFC2060 Sec 6.3.8)
         [$code, $response] = $this->execute('LIST', [$this->escape(''), $this->escape('')]);
 
         if ($code == self::ERROR_OK) {
             $args = $this->tokenizeResponse($response, 4);
             $delimiter = $args[3];
 
             if (strlen($delimiter) > 0) {
                 return $this->prefs['delimiter'] = $delimiter;
             }
         }
     }
 
     /**
      * NAMESPACE handler (RFC 2342)
      *
      * @return array Namespace data hash (personal, other, shared)
      */
     public function getNamespace()
     {
         if (array_key_exists('namespace', $this->prefs)) {
             return $this->prefs['namespace'];
         }
 
         if (!$this->getCapability('NAMESPACE')) {
             return self::ERROR_BAD;
         }
 
         [$code, $response] = $this->execute('NAMESPACE');
 
         if ($code == self::ERROR_OK && preg_match('/^\* NAMESPACE /', $response)) {
             $response = substr($response, 11);
             $data     = $this->tokenizeResponse($response);
         }
 
         if (!isset($data) || !is_array($data)) {
             return $code;
         }
 
         $this->prefs['namespace'] = [
             'personal' => $data[0],
             'other'    => $data[1],
             'shared'   => $data[2],
         ];
 
         return $this->prefs['namespace'];
     }
 
     /**
      * Connects to IMAP server and authenticates.
      *
      * @param string $host     Server hostname or IP
      * @param string $user     User name
      * @param string $password Password
      * @param array  $options  Connection and class options
      *
      * @return bool True on success, False on failure
      */
     public function connect($host, $user, $password, $options = [])
     {
         // configure
         $this->set_prefs($options);
 
         $this->host     = $host;
         $this->user     = $user;
         $this->logged   = false;
         $this->selected = null;
 
         // check input
         if (empty($host)) {
             $this->setError(self::ERROR_BAD, 'Empty host');
             return false;
         }
 
         if (empty($user)) {
             $this->setError(self::ERROR_NO, 'Empty user');
             return false;
         }
 
         if (empty($password) && empty($options['gssapi_cn'])) {
             $this->setError(self::ERROR_NO, 'Empty password');
             return false;
         }
 
         // Connect
         if (!$this->_connect($host)) {
             return false;
         }
 
         // Send pre authentication ID info (#7860)
         if (!empty($this->prefs['preauth_ident']) && $this->getCapability('ID')) {
             $this->data['ID'] = $this->id($this->prefs['preauth_ident']);
         }
 
         $auth_method  = $this->prefs['auth_type'];
         $auth_methods = [];
         $result       = null;
 
         // check for supported auth methods
         if (!$auth_method || $auth_method == 'CHECK') {
             if ($auth_caps = $this->getCapability('AUTH')) {
                 $auth_methods = $auth_caps;
             }
 
             // Use best (for security) supported authentication method
             $all_methods = ['DIGEST-MD5', 'CRAM-MD5', 'CRAM_MD5', 'PLAIN', 'LOGIN'];
 
             if (!empty($this->prefs['gssapi_cn'])) {
                 array_unshift($all_methods, 'GSSAPI');
             }
 
             foreach ($all_methods as $auth_method) {
                 if (in_array($auth_method, $auth_methods)) {
                     break;
                 }
             }
 
             // Prefer LOGIN over AUTHENTICATE LOGIN for performance reasons
             if ($auth_method == 'LOGIN' && !$this->getCapability('LOGINDISABLED')) {
                 $auth_method = 'IMAP';
             }
         }
 
         // pre-login capabilities can be not complete
         $this->capability_read = false;
 
         // Authenticate
         switch ($auth_method) {
             case 'CRAM_MD5':
                 $auth_method = 'CRAM-MD5';
             case 'CRAM-MD5':
             case 'DIGEST-MD5':
             case 'GSSAPI':
             case 'PLAIN':
             case 'LOGIN':
             case 'XOAUTH2':
             case 'OAUTHBEARER':
                 $result = $this->authenticate($user, $password, $auth_method);
                 break;
 
             case 'IMAP':
                 $result = $this->login($user, $password);
                 break;
 
             default:
                 $this->setError(self::ERROR_BAD, "Configuration error. Unknown auth method: $auth_method");
         }
 
         // Connected and authenticated
         if (is_resource($result)) {
             if (!empty($this->prefs['force_caps'])) {
                 $this->clearCapability();
             }
 
             $this->logged = true;
 
             // Send ID info after authentication to ensure reliable result (#7517)
             if (!empty($this->prefs['ident']) && $this->getCapability('ID')) {
                 $this->data['ID'] = $this->id($this->prefs['ident']);
             }
 
             return true;
         }
 
         $this->closeConnection();
 
         return false;
     }
 
     /**
      * Connects to IMAP server.
      *
      * @param string $host Server hostname or IP
      *
      * @return bool True on success, False on failure
      */
     protected function _connect($host)
     {
         // initialize connection
         $this->error    = '';
         $this->errornum = self::ERROR_OK;
 
         $port     = empty($this->prefs['port']) ? 143 : $this->prefs['port'];
         $ssl_mode = $this->prefs['ssl_mode'] ?? null;
 
         // check for SSL
         if (!empty($ssl_mode) && $ssl_mode != 'tls') {
             $host = $ssl_mode . '://' . $host;
         }
 
         if (empty($this->prefs['timeout']) || $this->prefs['timeout'] < 0) {
             $this->prefs['timeout'] = max(0, intval(ini_get('default_socket_timeout')));
         }
 
         if ($this->debug) {
             // set connection identifier for debug output
             $this->resourceid = strtoupper(substr(md5(microtime() . $host . $this->user), 0, 4));
 
             $_host = ($ssl_mode == 'tls' ? 'tls://' : '') . $host . ':' . $port;
             $this->debug("Connecting to $_host...");
         }
 
         if (!empty($this->prefs['socket_options'])) {
             $options  = array_intersect_key($this->prefs['socket_options'], ['ssl' => 1]);
             $context  = stream_context_create($options);
             $this->fp = stream_socket_client($host . ':' . $port, $errno, $errstr,
                 $this->prefs['timeout'], \STREAM_CLIENT_CONNECT, $context);
         } else {
             $this->fp = @fsockopen($host, $port, $errno, $errstr, $this->prefs['timeout']);
         }
 
         if (!$this->fp) {
             $this->setError(self::ERROR_BAD, sprintf('Could not connect to %s:%d: %s',
                 $host, $port, $errstr ?: 'Unknown reason'));
 
             return false;
         }
 
         if ($this->prefs['timeout'] > 0) {
             stream_set_timeout($this->fp, $this->prefs['timeout']);
         }
 
         $line = trim(fgets($this->fp, 8192));
 
         if ($this->debug && $line) {
             $this->debug('S: ' . $line);
         }
 
         // Connected to wrong port or connection error?
         if (!preg_match('/^\* (OK|PREAUTH)/i', $line)) {
             if ($line) {
                 $error = sprintf('Wrong startup greeting (%s:%d): %s', $host, $port, $line);
             } else {
                 $error = sprintf('Empty startup greeting (%s:%d)', $host, $port);
             }
 
             $this->setError(self::ERROR_BAD, $error);
             $this->closeConnection();
             return false;
         }
 
         $this->data['GREETING'] = trim(preg_replace('/\[[^\]]+\]\s*/', '', $line));
 
         // RFC3501 [7.1] optional CAPABILITY response
         if (preg_match('/\[CAPABILITY ([^]]+)\]/i', $line, $matches)) {
             $this->parseCapability($matches[1], true);
         }
 
         // TLS connection
         if ($ssl_mode == 'tls' && $this->getCapability('STARTTLS')) {
             $res = $this->execute('STARTTLS');
 
             if (empty($res) || $res[0] != self::ERROR_OK) {
                 $this->closeConnection();
                 return false;
             }
 
             if (isset($this->prefs['socket_options']['ssl']['crypto_method'])) {
                 $crypto_method = $this->prefs['socket_options']['ssl']['crypto_method'];
             } else {
                 // There is no flag to enable all TLS methods. Net_SMTP
                 // handles enabling TLS similarly.
                 $crypto_method = \STREAM_CRYPTO_METHOD_TLS_CLIENT
                     | @\STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT
                     | @\STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT;
             }
 
             if (!stream_socket_enable_crypto($this->fp, true, $crypto_method)) {
                 $this->setError(self::ERROR_BAD, 'Unable to negotiate TLS');
                 $this->closeConnection();
                 return false;
             }
 
             // Now we're secure, capabilities need to be reread
             $this->clearCapability();
         }
 
         return true;
     }
 
     /**
      * Initializes environment
      */
     protected function set_prefs($prefs)
     {
         // set preferences
         if (is_array($prefs)) {
             $this->prefs = $prefs;
         }
 
         // set auth method
         if (!empty($this->prefs['auth_type'])) {
             $this->prefs['auth_type'] = strtoupper($this->prefs['auth_type']);
         } else {
             $this->prefs['auth_type'] = 'CHECK';
         }
 
         // disabled capabilities
         if (!empty($this->prefs['disabled_caps'])) {
             $this->prefs['disabled_caps'] = array_map('strtoupper', (array) $this->prefs['disabled_caps']);
         }
 
         // additional message flags
         if (!empty($this->prefs['message_flags'])) {
             $this->flags = array_merge($this->flags, $this->prefs['message_flags']);
             unset($this->prefs['message_flags']);
         }
     }
 
     /**
      * Checks connection status
      *
      * @return bool True if connection is active and user is logged in, False otherwise.
      */
     public function connected()
     {
         return $this->fp && $this->logged;
     }
 
     /**
      * Closes connection with logout.
      */
     public function closeConnection()
     {
         if ($this->logged && $this->putLine($this->nextTag() . ' LOGOUT')) {
             $this->readReply();
         }
 
         $this->closeSocket();
         $this->clearCapability();
     }
 
     /**
      * Executes SELECT command (if mailbox is already not in selected state)
      *
      * @param string $mailbox      Mailbox name
      * @param array  $qresync_data QRESYNC data (RFC5162)
      *
      * @return bool True on success, false on error
      */
     public function select($mailbox, $qresync_data = null)
     {
         if (!strlen($mailbox)) {
             return false;
         }
 
         if ($this->selected === $mailbox) {
             return true;
         }
 
         $params = [$this->escape($mailbox)];
 
         // QRESYNC data items
         //    0. the last known UIDVALIDITY,
         //    1. the last known modification sequence,
         //    2. the optional set of known UIDs, and
         //    3. an optional parenthesized list of known sequence ranges and their
         //       corresponding UIDs.
         if (!empty($qresync_data)) {
             if (!empty($qresync_data[2])) {
                 $qresync_data[2] = self::compressMessageSet($qresync_data[2]);
             }
 
             $params[] = ['QRESYNC', $qresync_data];
         }
 
         [$code, $response] = $this->execute('SELECT', $params);
 
         if ($code == self::ERROR_OK) {
             $this->clear_mailbox_cache();
 
             $response = explode("\r\n", $response);
             foreach ($response as $line) {
                 if (preg_match('/^\* OK \[/i', $line)) {
                     $pos   = strcspn($line, ' ]', 6);
                     $token = strtoupper(substr($line, 6, $pos));
                     $pos   += 7;
 
                     switch ($token) {
                         case 'UIDNEXT':
                         case 'UIDVALIDITY':
                         case 'UNSEEN':
                             if ($len = strspn($line, '0123456789', $pos)) {
                                 $this->data[$token] = (int) substr($line, $pos, $len);
                             }
                             break;
 
                         case 'HIGHESTMODSEQ':
                             if ($len = strspn($line, '0123456789', $pos)) {
                                 $this->data[$token] = (string) substr($line, $pos, $len);
                             }
                             break;
 
                         case 'NOMODSEQ':
                             $this->data[$token] = true;
                             break;
 
                         case 'PERMANENTFLAGS':
                             $start = strpos($line, '(', $pos);
                             $end   = strrpos($line, ')');
                             if ($start && $end) {
                                 $flags = substr($line, $start + 1, $end - $start - 1);
                                 $this->data[$token] = explode(' ', $flags);
                             }
                             break;
                     }
                 } elseif (preg_match('/^\* ([0-9]+) (EXISTS|RECENT|FETCH)/i', $line, $match)) {
                     $token = strtoupper($match[2]);
                     switch ($token) {
                         case 'EXISTS':
                         case 'RECENT':
                             $this->data[$token] = (int) $match[1];
                             break;
 
                         case 'FETCH':
                             // QRESYNC FETCH response (RFC5162)
                             $line       = substr($line, strlen($match[0]));
                             $fetch_data = $this->tokenizeResponse($line, 1);
                             $data       = ['id' => $match[1]];
 
                             for ($i = 0, $size = count($fetch_data); $i < $size; $i += 2) {
                                 $data[strtolower($fetch_data[$i])] = $fetch_data[$i + 1];
                             }
 
                             $this->data['QRESYNC'][$data['uid']] = $data;
                             break;
                     }
                 }
                 // QRESYNC VANISHED response (RFC5162)
                 elseif (preg_match('/^\* VANISHED [()EARLIER]*/i', $line, $match)) {
                     $line   = substr($line, strlen($match[0]));
                     $v_data = $this->tokenizeResponse($line, 1);
 
                     $this->data['VANISHED'] = $v_data;
                 }
             }
 
             $this->data['READ-WRITE'] = $this->resultcode != 'READ-ONLY';
             $this->selected = $mailbox;
 
             return true;
         }
 
         return false;
     }
 
     /**
      * Executes STATUS command
      *
      * @param string $mailbox Mailbox name
      * @param array  $items   Additional requested item names. By default
      *                        MESSAGES and UNSEEN are requested. Other defined
      *                        in RFC3501: UIDNEXT, UIDVALIDITY, RECENT
      *
      * @return array Status item-value hash
      *
      * @since 0.5-beta
      */
     public function status($mailbox, $items = [])
     {
         if (!strlen($mailbox)) {
             return false;
         }
 
         if (!in_array('MESSAGES', $items)) {
             $items[] = 'MESSAGES';
         }
         if (!in_array('UNSEEN', $items)) {
             $items[] = 'UNSEEN';
         }
 
         [$code, $response] = $this->execute('STATUS',
             [$this->escape($mailbox), '(' . implode(' ', $items) . ')'], 0, '/^\* STATUS /i');
 
         if ($code == self::ERROR_OK && $response) {
             $result   = [];
             $response = substr($response, 9); // remove prefix "* STATUS "
 
             [$mbox, $items] = $this->tokenizeResponse($response, 2);
 
             // Fix for #1487859. Some buggy server returns not quoted
             // folder name with spaces. Let's try to handle this situation
             if (!is_array($items) && ($pos = strpos($response, '(')) !== false) {
                 $response = substr($response, $pos);
                 $items    = $this->tokenizeResponse($response, 1);
             }
 
             if (!is_array($items)) {
                 return $result;
             }
 
             for ($i = 0, $len = count($items); $i < $len; $i += 2) {
                 $result[$items[$i]] = $items[$i + 1];
             }
 
             $this->data['STATUS:' . $mailbox] = $result;
 
             return $result;
         }
 
         return false;
     }
 
     /**
      * Executes EXPUNGE command
      *
      * @param string       $mailbox  Mailbox name
      * @param string|array $messages Message UIDs to expunge
      *
      * @return bool True on success, False on error
      */
     public function expunge($mailbox, $messages = null)
     {
         if (!$this->select($mailbox)) {
             return false;
         }
 
         if (empty($this->data['READ-WRITE'])) {
             $this->setError(self::ERROR_READONLY, 'Mailbox is read-only');
             return false;
         }
 
         // Clear internal status cache
         $this->clear_status_cache($mailbox);
 
         if (!empty($messages) && $messages != '*' && $this->hasCapability('UIDPLUS')) {
             $messages = self::compressMessageSet($messages);
             $result   = $this->execute('UID EXPUNGE', [$messages], self::COMMAND_NORESPONSE);
         } else {
             $result = $this->execute('EXPUNGE', null, self::COMMAND_NORESPONSE);
         }
 
         if ($result == self::ERROR_OK) {
             $this->selected = null; // state has changed, need to reselect
             return true;
         }
 
         return false;
     }
 
     /**
      * Executes CLOSE command
      *
      * @return bool True on success, False on error
      *
      * @since 0.5
      */
     public function close()
     {
         $result = $this->execute('CLOSE', null, self::COMMAND_NORESPONSE);
 
         if ($result == self::ERROR_OK) {
             $this->selected = null;
             return true;
         }
 
         return false;
     }
 
     /**
      * Folder subscription (SUBSCRIBE)
      *
      * @param string $mailbox Mailbox name
      *
      * @return bool True on success, False on error
      */
     public function subscribe($mailbox)
     {
         $result = $this->execute('SUBSCRIBE', [$this->escape($mailbox)], self::COMMAND_NORESPONSE);
 
         return $result == self::ERROR_OK;
     }
 
     /**
      * Folder unsubscription (UNSUBSCRIBE)
      *
      * @param string $mailbox Mailbox name
      *
      * @return bool True on success, False on error
      */
     public function unsubscribe($mailbox)
     {
         $result = $this->execute('UNSUBSCRIBE', [$this->escape($mailbox)], self::COMMAND_NORESPONSE);
 
         return $result == self::ERROR_OK;
     }
 
     /**
      * Folder creation (CREATE)
      *
      * @param string $mailbox Mailbox name
      * @param array  $types   Optional folder types (RFC 6154)
      *
      * @return bool True on success, False on error
      */
     public function createFolder($mailbox, $types = null)
     {
         $args = [$this->escape($mailbox)];
 
         // RFC 6154: CREATE-SPECIAL-USE
         if (!empty($types) && $this->getCapability('CREATE-SPECIAL-USE')) {
             $args[] = '(USE (' . implode(' ', $types) . '))';
         }
 
         $result = $this->execute('CREATE', $args, self::COMMAND_NORESPONSE);
 
         return $result == self::ERROR_OK;
     }
 
     /**
      * Folder renaming (RENAME)
      *
      * @param string $from Mailbox name
      * @param string $to   Mailbox name
      *
      * @return bool True on success, False on error
      */
     public function renameFolder($from, $to)
     {
         $result = $this->execute('RENAME', [$this->escape($from), $this->escape($to)], self::COMMAND_NORESPONSE);
 
         return $result == self::ERROR_OK;
     }
 
     /**
      * Executes DELETE command
      *
      * @param string $mailbox Mailbox name
      *
      * @return bool True on success, False on error
      */
     public function deleteFolder($mailbox)
     {
         // Unselect the folder to prevent "BYE Fatal error: Mailbox has been (re)moved" on Cyrus IMAP
         if ($this->selected === $mailbox && $this->hasCapability('UNSELECT')) {
             $this->execute('UNSELECT', [], self::COMMAND_NORESPONSE);
         }
 
         $result = $this->execute('DELETE', [$this->escape($mailbox)], self::COMMAND_NORESPONSE);
 
         return $result == self::ERROR_OK;
     }
 
     /**
      * Removes all messages in a folder
      *
      * @param string $mailbox Mailbox name
      *
      * @return bool True on success, False on error
      */
     public function clearFolder($mailbox)
     {
         if ($this->countMessages($mailbox) > 0) {
             $res = $this->flag($mailbox, '1:*', 'DELETED');
         } else {
             return true;
         }
 
         if (!empty($res)) {
             if ($this->selected === $mailbox) {
                 $res = $this->close();
             } else {
                 $res = $this->expunge($mailbox);
             }
 
             return $res;
         }
 
         return false;
     }
 
     /**
      * Returns list of mailboxes
      *
      * @param string $ref         Reference name
      * @param string $mailbox     Mailbox name
      * @param array  $return_opts (see self::_listMailboxes)
      * @param array  $select_opts (see self::_listMailboxes)
      *
      * @return array|bool List of mailboxes or hash of options if STATUS/MYRIGHTS response
      *                    is requested, False on error.
      */
     public function listMailboxes($ref, $mailbox, $return_opts = [], $select_opts = [])
     {
         return $this->_listMailboxes($ref, $mailbox, false, $return_opts, $select_opts);
     }
 
     /**
      * Returns list of subscribed mailboxes
      *
      * @param string $ref         Reference name
      * @param string $mailbox     Mailbox name
      * @param array  $return_opts (see self::_listMailboxes)
      *
      * @return array|bool List of mailboxes or hash of options if STATUS/MYRIGHTS response
      *                    is requested, False on error.
      */
     public function listSubscribed($ref, $mailbox, $return_opts = [])
     {
         return $this->_listMailboxes($ref, $mailbox, true, $return_opts, null);
     }
 
     /**
      * IMAP LIST/LSUB command
      *
      * @param string $ref         Reference name
      * @param string $mailbox     Mailbox name
      * @param bool   $subscribed  Enables returning subscribed mailboxes only
      * @param array  $return_opts List of RETURN options (RFC5819: LIST-STATUS, RFC5258: LIST-EXTENDED)
      *                            Possible: MESSAGES, RECENT, UIDNEXT, UIDVALIDITY, UNSEEN,
      *                            MYRIGHTS, SUBSCRIBED, CHILDREN
      * @param array  $select_opts List of selection options (RFC5258: LIST-EXTENDED)
      *                            Possible: SUBSCRIBED, RECURSIVEMATCH, REMOTE,
      *                            SPECIAL-USE (RFC6154)
      *
      * @return array|bool List of mailboxes or hash of options if STATUS/MYRIGHTS response
      *                    is requested, False on error.
      */
     protected function _listMailboxes($ref, $mailbox, $subscribed = false, $return_opts = [], $select_opts = [])
     {
         if (!strlen($mailbox)) {
             $mailbox = '*';
         }
 
         $lstatus = false;
         $args    = [];
         $rets    = [];
 
         if (!empty($select_opts) && $this->getCapability('LIST-EXTENDED')) {
             $select_opts = (array) $select_opts;
 
             $args[] = '(' . implode(' ', $select_opts) . ')';
         }
 
         $args[] = $this->escape($ref);
         $args[] = $this->escape($mailbox);
 
         if (!empty($return_opts) && $this->getCapability('LIST-EXTENDED')) {
             $ext_opts    = ['SUBSCRIBED', 'CHILDREN'];
             $rets        = array_intersect($return_opts, $ext_opts);
             $return_opts = array_diff($return_opts, $rets);
         }
 
         if (!empty($return_opts) && $this->getCapability('LIST-STATUS')) {
             $lstatus     = true;
             $status_opts = ['MESSAGES', 'RECENT', 'UIDNEXT', 'UIDVALIDITY', 'UNSEEN', 'SIZE'];
             $opts        = array_diff($return_opts, $status_opts);
             $status_opts = array_diff($return_opts, $opts);
 
             if (!empty($status_opts)) {
                 $rets[] = 'STATUS (' . implode(' ', $status_opts) . ')';
             }
 
             if (!empty($opts)) {
                 $rets = array_merge($rets, $opts);
             }
         }
 
         if (!empty($rets)) {
             $args[] = 'RETURN (' . implode(' ', $rets) . ')';
         }
 
         [$code, $response] = $this->execute($subscribed ? 'LSUB' : 'LIST', $args);
 
         if ($code == self::ERROR_OK) {
             $folders  = [];
             $last     = 0;
             $pos      = 0;
             $response .= "\r\n";
 
             while ($pos = strpos($response, "\r\n", $pos + 1)) {
                 // literal string, not real end-of-command-line
                 if ($response[$pos - 1] == '}') {
                     continue;
                 }
 
                 $line = substr($response, $last, $pos - $last);
                 $last = $pos + 2;
 
                 if (!preg_match('/^\* (LIST|LSUB|STATUS|MYRIGHTS) /i', $line, $m)) {
                     continue;
                 }
 
                 $cmd  = strtoupper($m[1]);
                 $line = substr($line, strlen($m[0]));
 
                 // * LIST (<options>) <delimiter> <mailbox>
                 if ($cmd == 'LIST' || $cmd == 'LSUB') {
                     [$opts, $delim, $mailbox] = $this->tokenizeResponse($line, 3);
 
                     // Remove redundant separator at the end of folder name, UW-IMAP bug? (#1488879)
                     if ($delim) {
                         $mailbox = rtrim($mailbox, $delim);
                     }
 
                     // Make it easier for the client to deal with INBOX folder
                     // by always returning the word with all capital letters
                     if (strlen($mailbox) == 5
                         && ($mailbox[0] == 'i' || $mailbox[0] == 'I')
                         && ($mailbox[1] == 'n' || $mailbox[1] == 'N')
                         && ($mailbox[2] == 'b' || $mailbox[2] == 'B')
                         && ($mailbox[3] == 'o' || $mailbox[3] == 'O')
                         && ($mailbox[4] == 'x' || $mailbox[4] == 'X')
                     ) {
                         $mailbox = 'INBOX';
                     }
 
                     // Add to result array
                     if (!$lstatus) {
                         $folders[] = $mailbox;
                     } else {
                         $folders[$mailbox] = [];
                     }
 
                     // store folder options
                     if ($cmd == 'LIST') {
                         // Add to options array
                         if (empty($this->data['LIST'][$mailbox])) {
                             $this->data['LIST'][$mailbox] = $opts;
                         } elseif (!empty($opts)) {
                             $this->data['LIST'][$mailbox] = array_unique(array_merge(
                                 $this->data['LIST'][$mailbox], $opts));
                         }
                     }
                 } elseif ($lstatus) {
                     // * STATUS <mailbox> (<result>)
                     if ($cmd == 'STATUS') {
                         [$mailbox, $status] = $this->tokenizeResponse($line, 2);
 
                         for ($i = 0, $len = count($status); $i < $len; $i += 2) {
                             [$name, $value] = $this->tokenizeResponse($status, 2);
                             $folders[$mailbox][$name] = $value;
                         }
                     }
                     // * MYRIGHTS <mailbox> <acl>
                     elseif ($cmd == 'MYRIGHTS') {
                         [$mailbox, $acl]  = $this->tokenizeResponse($line, 2);
                         $folders[$mailbox]['MYRIGHTS'] = $acl;
                     }
                 }
             }
 
             return $folders;
         }
 
         return false;
     }
 
     /**
      * Returns count of all messages in a folder
      *
      * @param string $mailbox Mailbox name
      *
      * @return int Number of messages, False on error
      */
     public function countMessages($mailbox)
     {
         if ($this->selected === $mailbox && isset($this->data['EXISTS'])) {
             return $this->data['EXISTS'];
         }
 
         // Check internal cache
         if (!empty($this->data['STATUS:' . $mailbox])) {
             $cache = $this->data['STATUS:' . $mailbox];
             if (isset($cache['MESSAGES'])) {
                 return (int) $cache['MESSAGES'];
             }
         }
 
         // Try STATUS (should be faster than SELECT)
         $counts = $this->status($mailbox);
         if (is_array($counts)) {
             return (int) $counts['MESSAGES'];
         }
 
         return false;
     }
 
     /**
      * Returns count of messages with \Recent flag in a folder
      *
      * @param string $mailbox Mailbox name
      *
      * @return int Number of messages, False on error
      */
     public function countRecent($mailbox)
     {
         if ($this->selected === $mailbox && isset($this->data['RECENT'])) {
             return $this->data['RECENT'];
         }
 
         // Check internal cache
         $cache = $this->data['STATUS:' . $mailbox];
         if (!empty($cache) && isset($cache['RECENT'])) {
             return (int) $cache['RECENT'];
         }
 
         // Try STATUS (should be faster than SELECT)
         $counts = $this->status($mailbox, ['RECENT']);
         if (is_array($counts)) {
             return (int) $counts['RECENT'];
         }
 
         return false;
     }
 
     /**
      * Returns count of messages without \Seen flag in a specified folder
      *
      * @param string $mailbox Mailbox name
      *
      * @return int Number of messages, False on error
      */
     public function countUnseen($mailbox)
     {
         // Check internal cache
         if (!empty($this->data['STATUS:' . $mailbox])) {
             $cache = $this->data['STATUS:' . $mailbox];
             if (isset($cache['UNSEEN'])) {
                 return (int) $cache['UNSEEN'];
             }
         }
 
         // Try STATUS (should be faster than SELECT+SEARCH)
         $counts = $this->status($mailbox);
         if (is_array($counts)) {
             return (int) $counts['UNSEEN'];
         }
 
         // Invoke SEARCH as a fallback
         $index = $this->search($mailbox, 'ALL UNSEEN', false, ['COUNT']);
         if (!$index->is_error()) {
             return $index->count();
         }
 
         return false;
     }
 
     /**
      * Executes ID command (RFC2971)
      *
      * @param array $items Client identification information key/value hash
      *
      * @return array|false Server identification information key/value hash, False on error
      *
      * @since 0.6
      */
     public function id($items = [])
     {
         if (is_array($items) && !empty($items)) {
             foreach ($items as $key => $value) {
                 $args[] = $this->escape($key, true);
                 $args[] = $this->escape($value, true);
             }
         }
 
         [$code, $response] = $this->execute('ID',
             [!empty($args) ? '(' . implode(' ', (array) $args) . ')' : $this->escape(null)],
             0, '/^\* ID /i'
         );
 
         if ($code == self::ERROR_OK && $response) {
             $response = substr($response, 5); // remove prefix "* ID "
             $items    = $this->tokenizeResponse($response, 1);
             $result   = [];
 
             if (is_array($items)) {
                 for ($i = 0, $len = count($items); $i < $len; $i += 2) {
                     $result[$items[$i]] = $items[$i + 1];
                 }
             }
 
             return $result;
         }
 
         return false;
     }
 
     /**
      * Executes ENABLE command (RFC5161)
      *
      * @param mixed $extension Extension name to enable (or array of names)
      *
      * @return array|bool List of enabled extensions, False on error
      *
      * @since 0.6
      */
     public function enable($extension)
     {
         if (empty($extension)) {
             return false;
         }
 
         if (!$this->hasCapability('ENABLE')) {
             return false;
         }
 
         if (!is_array($extension)) {
             $extension = [$extension];
         }
 
         if (!empty($this->extensions_enabled)) {
             // check if all extensions are already enabled
             $diff = array_diff($extension, $this->extensions_enabled);
 
             if (empty($diff)) {
                 return $extension;
             }
 
             // Make sure the mailbox isn't selected, before enabling extension(s)
             if ($this->selected !== null) {
                 $this->close();
             }
         }
 
         [$code, $response] = $this->execute('ENABLE', $extension, 0, '/^\* ENABLED /i');
 
         if ($code == self::ERROR_OK && $response) {
             $response = substr($response, 10); // remove prefix "* ENABLED "
             $result   = (array) $this->tokenizeResponse($response);
 
             $this->extensions_enabled = array_unique(array_merge((array) $this->extensions_enabled, $result));
 
             return $this->extensions_enabled;
         }
 
         return false;
     }
 
     /**
      * Executes SORT command
      *
      * @param string $mailbox    Mailbox name
      * @param string $field      Field to sort by (ARRIVAL, CC, DATE, FROM, SIZE, SUBJECT, TO)
      * @param string $criteria   Searching criteria
      * @param bool   $return_uid Enables UID SORT usage
      * @param string $encoding   Character set
      *
      * @return rcube_result_index Response data
      */
     public function sort($mailbox, $field = 'ARRIVAL', $criteria = '', $return_uid = false, $encoding = 'US-ASCII')
     {
         $old_sel   = $this->selected;
         $supported = ['ARRIVAL', 'CC', 'DATE', 'FROM', 'SIZE', 'SUBJECT', 'TO'];
         $field     = strtoupper($field);
 
         if ($field == 'INTERNALDATE') {
             $field = 'ARRIVAL';
         }
 
         if (!in_array($field, $supported)) {
             return new rcube_result_index($mailbox);
         }
 
         if (!$this->select($mailbox)) {
             return new rcube_result_index($mailbox);
         }
 
         // return empty result when folder is empty and we're just after SELECT
         if ($old_sel != $mailbox && empty($this->data['EXISTS'])) {
             return new rcube_result_index($mailbox, '* SORT');
         }
 
         // RFC 5957: SORT=DISPLAY
         if (($field == 'FROM' || $field == 'TO') && $this->getCapability('SORT=DISPLAY')) {
             $field = 'DISPLAY' . $field;
         }
 
         $encoding = $encoding ? trim($encoding) : 'US-ASCII';
         $criteria = $criteria ? 'ALL ' . trim($criteria) : 'ALL';
 
         [$code, $response] = $this->execute($return_uid ? 'UID SORT' : 'SORT',
             ["($field)", $encoding, $criteria]);
 
         if ($code != self::ERROR_OK) {
             $response = null;
         }
 
         return new rcube_result_index($mailbox, $response);
     }
 
     /**
      * Executes THREAD command
      *
      * @param string $mailbox    Mailbox name
      * @param string $algorithm  Threading algorithm (ORDEREDSUBJECT, REFERENCES, REFS)
      * @param string $criteria   Searching criteria
      * @param bool   $return_uid Enables UIDs in result instead of sequence numbers
      * @param string $encoding   Character set
      *
      * @return rcube_result_thread Thread data
      */
     public function thread($mailbox, $algorithm = 'REFERENCES', $criteria = '', $return_uid = false, $encoding = 'US-ASCII')
     {
         $old_sel = $this->selected;
 
         if (!$this->select($mailbox)) {
             return new rcube_result_thread($mailbox);
         }
 
         // return empty result when folder is empty and we're just after SELECT
         if ($old_sel != $mailbox && !$this->data['EXISTS']) {
             return new rcube_result_thread($mailbox, '* THREAD');
         }
 
         $encoding  = $encoding ? trim($encoding) : 'US-ASCII';
         $algorithm = $algorithm ? trim($algorithm) : 'REFERENCES';
         $criteria  = $criteria ? 'ALL ' . trim($criteria) : 'ALL';
 
         [$code, $response] = $this->execute($return_uid ? 'UID THREAD' : 'THREAD',
             [$algorithm, $encoding, $criteria]);
 
         if ($code != self::ERROR_OK) {
             $response = null;
         }
 
         return new rcube_result_thread($mailbox, $response);
     }
 
     /**
      * Executes SEARCH command
      *
      * @param string $mailbox    Mailbox name
      * @param string $criteria   Searching criteria
      * @param bool   $return_uid Enable UID in result instead of sequence ID
      * @param array  $items      Return items (MIN, MAX, COUNT, ALL)
      *
      * @return rcube_result_index Result data
      */
     public function search($mailbox, $criteria, $return_uid = false, $items = [])
     {
         $old_sel = $this->selected;
 
         if (!$this->select($mailbox)) {
             return new rcube_result_index($mailbox);
         }
 
         // return empty result when folder is empty and we're just after SELECT
         if ($old_sel != $mailbox && !$this->data['EXISTS']) {
             return new rcube_result_index($mailbox, '* SEARCH');
         }
 
         // If ESEARCH is supported always use ALL
         // but not when items are specified or using simple id2uid search
         if (empty($items) && preg_match('/[^0-9]/', $criteria)) {
             $items = ['ALL'];
         }
 
         $esearch  = empty($items) ? false : $this->getCapability('ESEARCH');
         $criteria = trim($criteria);
         $params   = '';
 
         // RFC4731: ESEARCH
         if (!empty($items) && $esearch) {
             $params .= 'RETURN (' . implode(' ', $items) . ')';
         }
 
         if (!empty($criteria)) {
             $params .= ($params ? ' ' : '') . $criteria;
         } else {
             $params .= 'ALL';
         }
 
         [$code, $response] = $this->execute($return_uid ? 'UID SEARCH' : 'SEARCH', [$params]);
 
         if ($code != self::ERROR_OK) {
             $response = null;
         }
 
         return new rcube_result_index($mailbox, $response);
     }
 
     /**
      * Simulates SORT command by using FETCH and sorting.
      *
      * @param string       $mailbox      Mailbox name
      * @param string|array $message_set  Searching criteria (list of messages to return)
      * @param string       $index_field  Field to sort by (ARRIVAL, CC, DATE, FROM, SIZE, SUBJECT, TO)
      * @param bool         $skip_deleted Makes that DELETED messages will be skipped
      * @param bool         $uidfetch     Enables UID FETCH usage
      * @param bool         $return_uid   Enables returning UIDs instead of IDs
      *
      * @return rcube_result_index Response data
      */
     public function index($mailbox, $message_set, $index_field = '', $skip_deleted = true,
         $uidfetch = false, $return_uid = false)
     {
         $msg_index = $this->fetchHeaderIndex($mailbox, $message_set,
             $index_field, $skip_deleted, $uidfetch, $return_uid);
 
         if (!empty($msg_index)) {
             asort($msg_index); // ASC
             $msg_index = array_keys($msg_index);
             $msg_index = '* SEARCH ' . implode(' ', $msg_index);
         } else {
             $msg_index = is_array($msg_index) ? '* SEARCH' : null;
         }
 
         return new rcube_result_index($mailbox, $msg_index);
     }
 
     /**
      * Fetches specified header/data value for a set of messages.
      *
      * @param string       $mailbox      Mailbox name
      * @param string|array $message_set  Searching criteria (list of messages to return)
      * @param string       $index_field  Field to sort by (ARRIVAL, CC, DATE, FROM, SIZE, SUBJECT, TO)
      * @param bool         $skip_deleted Makes that DELETED messages will be skipped
      * @param bool         $uidfetch     Enables UID FETCH usage
      * @param bool         $return_uid   Enables returning UIDs instead of IDs
      *
      * @return array|bool List of header values or False on failure
      */
     public function fetchHeaderIndex($mailbox, $message_set, $index_field = '', $skip_deleted = true,
         $uidfetch = false, $return_uid = false)
     {
         // Validate input
         if (is_array($message_set)) {
             if (!($message_set = $this->compressMessageSet($message_set))) {
                 return false;
             }
         } elseif (empty($message_set)) {
             return false;
         } elseif (strpos($message_set, ':')) {
             [$from_idx, $to_idx] = explode(':', $message_set);
             if ($to_idx != '*' && (int) $from_idx > (int) $to_idx) {
                 return false;
             }
         }
 
         $index_field = empty($index_field) ? 'DATE' : strtoupper($index_field);
 
         $supported = [
             'DATE'         => 1,
             'INTERNALDATE' => 4,
             'ARRIVAL'      => 4,
             'FROM'         => 1,
             'REPLY-TO'     => 1,
             'SENDER'       => 1,
             'TO'           => 1,
             'CC'           => 1,
             'SUBJECT'      => 1,
             'UID'          => 2,
             'SIZE'         => 2,
             'SEEN'         => 3,
             'RECENT'       => 3,
             'DELETED'      => 3,
         ];
 
         if (empty($supported[$index_field])) {
             return false;
         }
 
         $mode = $supported[$index_field];
 
         //  Select the mailbox
         if (!$this->select($mailbox)) {
             return false;
         }
 
         // build FETCH command string
         $key    = $this->nextTag();
         $cmd    = $uidfetch ? 'UID FETCH' : 'FETCH';
         $fields = [];
 
         if ($return_uid) {
             $fields[] = 'UID';
         }
         if ($skip_deleted) {
             $fields[] = 'FLAGS';
         }
 
         if ($mode == 1) {
             if ($index_field == 'DATE') {
                 $fields[] = 'INTERNALDATE';
             }
             $fields[] = "BODY.PEEK[HEADER.FIELDS ($index_field)]";
         } elseif ($mode == 2) {
             if ($index_field == 'SIZE') {
                 $fields[] = 'RFC822.SIZE';
             } elseif (!$return_uid || $index_field != 'UID') {
                 $fields[] = $index_field;
             }
         } elseif ($mode == 3 && !$skip_deleted) {
             $fields[] = 'FLAGS';
         } elseif ($mode == 4) {
             $fields[] = 'INTERNALDATE';
         }
 
         $request = "$key $cmd $message_set (" . implode(' ', $fields) . ')';
 
         if (!$this->putLine($request)) {
             $this->setError(self::ERROR_COMMAND, "Failed to send $cmd command");
             return false;
         }
 
         $result = [];
 
         do {
             $line = rtrim($this->readLine(200));
             $line = $this->multLine($line);
 
             if (preg_match('/^\* ([0-9]+) FETCH/', $line, $m)) {
                 $id     = $m[1];
                 $flags  = null;
 
                 if ($return_uid) {
                     if (preg_match('/UID ([0-9]+)/', $line, $matches)) {
                         $id = (int) $matches[1];
                     } else {
                         continue;
                     }
                 }
 
                 if ($skip_deleted && preg_match('/FLAGS \(([^)]+)\)/', $line, $matches)) {
                     $flags = explode(' ', strtoupper($matches[1]));
                     if (in_array('\\DELETED', $flags)) {
                         continue;
                     }
                 }
 
                 if ($mode == 1 && $index_field == 'DATE') {
                     if (preg_match('/BODY\[HEADER\.FIELDS \("*DATE"*\)\] (.*)/', $line, $matches)) {
                         $value = preg_replace(['/^"*[a-z]+:/i'], '', $matches[1]);
                         $value = trim($value);
                         $result[$id] = rcube_utils::strtotime($value);
                     }
                     // non-existent/empty Date: header, use INTERNALDATE
                     if (empty($result[$id])) {
                         if (preg_match('/INTERNALDATE "([^"]+)"/', $line, $matches)) {
                             $result[$id] = rcube_utils::strtotime($matches[1]);
                         } else {
                             $result[$id] = 0;
                         }
                     }
                 } elseif ($mode == 1) {
                     if (preg_match('/BODY\[HEADER\.FIELDS \("?(FROM|REPLY-TO|SENDER|TO|SUBJECT)"?\)\] (.*)/', $line, $matches)) {
                         $value = preg_replace(['/^"*[a-z]+:/i', '/\s+$/sm'], ['', ''], $matches[2]);
                         $result[$id] = trim($value);
                     } else {
                         $result[$id] = '';
                     }
                 } elseif ($mode == 2) {
                     if (preg_match('/' . $index_field . ' ([0-9]+)/', $line, $matches)) {
                         $result[$id] = trim($matches[1]);
                     } else {
                         $result[$id] = 0;
                     }
                 } elseif ($mode == 3) {
                     if (!$flags && preg_match('/FLAGS \(([^)]+)\)/', $line, $matches)) {
                         $flags = explode(' ', $matches[1]);
                     }
                     $result[$id] = in_array('\\' . $index_field, (array) $flags) ? 1 : 0;
                 } elseif ($mode == 4) {
                     if (preg_match('/INTERNALDATE "([^"]+)"/', $line, $matches)) {
                         $result[$id] = rcube_utils::strtotime($matches[1]);
                     } else {
                         $result[$id] = 0;
                     }
                 }
             }
         } while (!$this->startsWith($line, $key, true, true));
 
         return $result;
     }
 
     /**
      * Returns message sequence identifier
      *
      * @param string $mailbox Mailbox name
      * @param int    $uid     Message unique identifier (UID)
      *
      * @return int Message sequence identifier
      */
     public function UID2ID($mailbox, $uid)
     {
         if ($uid > 0) {
             $index = $this->search($mailbox, "UID $uid");
 
             if ($index->count() == 1) {
                 $arr = $index->get();
                 return (int) $arr[0];
             }
         }
     }
 
     /**
      * Returns message unique identifier (UID)
      *
      * @param string $mailbox Mailbox name
      * @param int    $id      Message sequence identifier
      *
      * @return int Message unique identifier
      */
     public function ID2UID($mailbox, $id)
     {
         if (empty($id) || $id < 0) {
             return null;
         }
 
         if (!$this->select($mailbox)) {
             return null;
         }
 
         if (!empty($this->data['UID-MAP'][$id])) {
             return $this->data['UID-MAP'][$id];
         }
 
         if (isset($this->data['EXISTS']) && $id > $this->data['EXISTS']) {
             return null;
         }
 
         $index = $this->search($mailbox, $id, true);
 
         if ($index->count() == 1) {
             $arr = $index->get();
             return $this->data['UID-MAP'][$id] = (int) $arr[0];
         }
     }
 
     /**
      * Sets flag of the message(s)
      *
      * @param string       $mailbox  Mailbox name
      * @param string|array $messages Message UID(s)
      * @param string       $flag     Flag name
      *
      * @return bool True on success, False on failure
      */
     public function flag($mailbox, $messages, $flag)
     {
         return $this->modFlag($mailbox, $messages, $flag, '+');
     }
 
     /**
      * Unsets flag of the message(s)
      *
      * @param string       $mailbox  Mailbox name
      * @param string|array $messages Message UID(s)
      * @param string       $flag     Flag name
      *
      * @return bool True on success, False on failure
      */
     public function unflag($mailbox, $messages, $flag)
     {
         return $this->modFlag($mailbox, $messages, $flag, '-');
     }
 
     /**
      * Changes flag of the message(s)
      *
      * @param string       $mailbox  Mailbox name
      * @param string|array $messages Message UID(s)
      * @param string       $flag     Flag name
      * @param string       $mod      Modifier [+|-]. Default: "+".
      *
      * @return bool True on success, False on failure
      */
     protected function modFlag($mailbox, $messages, $flag, $mod = '+')
     {
         if (!$flag) {
             return false;
         }
 
         if (!$this->select($mailbox)) {
             return false;
         }
 
         if (empty($this->data['READ-WRITE'])) {
             $this->setError(self::ERROR_READONLY, 'Mailbox is read-only');
             return false;
         }
 
         if (!empty($this->flags[strtoupper($flag)])) {
             $flag = $this->flags[strtoupper($flag)];
         }
 
         // if PERMANENTFLAGS is not specified all flags are allowed
         if (!empty($this->data['PERMANENTFLAGS'])
             && !in_array($flag, (array) $this->data['PERMANENTFLAGS'])
             && !in_array('\\*', (array) $this->data['PERMANENTFLAGS'])
         ) {
             return false;
         }
 
         // Clear internal status cache
         if ($flag == 'SEEN') {
             unset($this->data['STATUS:' . $mailbox]['UNSEEN']);
         }
 
         if ($mod != '+' && $mod != '-') {
             $mod = '+';
         }
 
         $result = $this->execute('UID STORE',
             [$this->compressMessageSet($messages), $mod . 'FLAGS.SILENT', "($flag)"],
             self::COMMAND_NORESPONSE
         );
 
         return $result == self::ERROR_OK;
     }
 
     /**
      * Copies message(s) from one folder to another
      *
      * @param string|array $messages Message UID(s)
      * @param string       $from     Mailbox name
      * @param string       $to       Destination mailbox name
      *
      * @return bool True on success, False on failure
      */
     public function copy($messages, $from, $to)
     {
         // Clear last COPYUID data
         unset($this->data['COPYUID']);
 
         if (!$this->select($from)) {
             return false;
         }
 
         // Clear internal status cache
         unset($this->data['STATUS:' . $to]);
 
         $result = $this->execute('UID COPY',
             [$this->compressMessageSet($messages), $this->escape($to)],
             self::COMMAND_NORESPONSE
         );
 
         return $result == self::ERROR_OK;
     }
 
     /**
      * Moves message(s) from one folder to another.
      *
      * @param string|array $messages Message UID(s)
      * @param string       $from     Mailbox name
      * @param string       $to       Destination mailbox name
      *
      * @return bool True on success, False on failure
      */
     public function move($messages, $from, $to)
     {
         if (!$this->select($from)) {
             return false;
         }
 
         if (empty($this->data['READ-WRITE'])) {
             $this->setError(self::ERROR_READONLY, 'Mailbox is read-only');
             return false;
         }
 
         // use MOVE command (RFC 6851)
         if ($this->hasCapability('MOVE')) {
             // Clear last COPYUID data
             unset($this->data['COPYUID']);
 
             // Clear internal status cache
             unset($this->data['STATUS:' . $to]);
             $this->clear_status_cache($from);
 
             $result = $this->execute('UID MOVE',
                 [$this->compressMessageSet($messages), $this->escape($to)],
                 self::COMMAND_NORESPONSE
             );
 
             return $result == self::ERROR_OK;
         }
 
         // use COPY + STORE +FLAGS.SILENT \Deleted + EXPUNGE
         $result = $this->copy($messages, $from, $to);
 
         if ($result) {
             // Clear internal status cache
             unset($this->data['STATUS:' . $from]);
 
             $result = $this->flag($from, $messages, 'DELETED');
 
             if ($messages == '*') {
                 // CLOSE+SELECT should be faster than EXPUNGE
                 $this->close();
             } else {
                 $this->expunge($from, $messages);
             }
         }
 
         return $result;
     }
 
     /**
      * FETCH command (RFC3501)
      *
      * @param string $mailbox     Mailbox name
      * @param mixed  $message_set Message(s) sequence identifier(s) or UID(s)
      * @param bool   $is_uid      True if $message_set contains UIDs
      * @param array  $query_items FETCH command data items
      * @param string $mod_seq     Modification sequence for CHANGEDSINCE (RFC4551) query
      * @param bool   $vanished    Enables VANISHED parameter (RFC5162) for CHANGEDSINCE query
      *
      * @return array List of rcube_message_header elements, False on error
      *
      * @since 0.6
      */
     public function fetch($mailbox, $message_set, $is_uid = false, $query_items = [],
         $mod_seq = null, $vanished = false)
     {
         if (!$this->select($mailbox)) {
             return false;
         }
 
         $message_set = $this->compressMessageSet($message_set);
         $result      = [];
 
         $key      = $this->nextTag();
         $cmd      = ($is_uid ? 'UID ' : '') . 'FETCH';
         $request  = "$key $cmd $message_set (" . implode(' ', $query_items) . ')';
 
         if ($mod_seq !== null && $this->hasCapability('CONDSTORE')) {
             $request .= " (CHANGEDSINCE $mod_seq" . ($vanished ? ' VANISHED' : '') . ')';
         }
 
         if (!$this->putLine($request)) {
             $this->setError(self::ERROR_COMMAND, "Failed to send $cmd command");
             return false;
         }
 
         do {
             $line = $this->readFullLine(4096);
 
             if (!$line) {
                 break;
             }
 
             // Sample reply line:
             // * 321 FETCH (UID 2417 RFC822.SIZE 2730 FLAGS (\Seen)
             // INTERNALDATE "16-Nov-2008 21:08:46 +0100" BODYSTRUCTURE (...)
             // BODY[HEADER.FIELDS ...
 
             if (preg_match('/^\* ([0-9]+) FETCH/', $line, $m)) {
                 $id = intval($m[1]);
 
                 $result[$id]            = new rcube_message_header();
                 $result[$id]->id        = $id;
                 $result[$id]->subject   = '';
                 $result[$id]->messageID = 'mid:' . $id;
 
                 $headers = null;
                 $line    = substr($line, strlen($m[0]) + 2);
 
                 // Tokenize response and assign to object properties
                 while (($tokens = $this->tokenizeResponse($line, 2)) && count($tokens) == 2) {
                     [$name, $value] = $tokens;
                     if ($name == 'UID') {
                         $result[$id]->uid = intval($value);
                     } elseif ($name == 'RFC822.SIZE') {
                         $result[$id]->size = intval($value);
                     } elseif ($name == 'RFC822.TEXT') {
                         $result[$id]->body = $value;
                     } elseif ($name == 'INTERNALDATE') {
                         $result[$id]->internaldate = $value;
                         $result[$id]->date         = $value;
                         $result[$id]->timestamp    = rcube_utils::strtotime($value);
                     } elseif ($name == 'FLAGS') {
                         if (!empty($value)) {
                             foreach ((array) $value as $flag) {
                                 $flag = str_replace(['$', '\\'], '', $flag);
                                 $flag = strtoupper($flag);
 
                                 $result[$id]->flags[$flag] = true;
                             }
                         }
                     } elseif ($name == 'MODSEQ') {
                         $result[$id]->modseq = $value[0];
                     } elseif ($name == 'ENVELOPE') {
                         $result[$id]->envelope = $value;
                     } elseif ($name == 'BODYSTRUCTURE' || ($name == 'BODY' && count($value) > 2)) {
                         if (!is_array($value[0]) && (strtolower($value[0]) == 'message' && strtolower($value[1]) == 'rfc822')) {
                             $value = [$value];
                         }
                         $result[$id]->bodystructure = $value;
                     } elseif ($name == 'RFC822') {
                         $result[$id]->body = $value;
                     } elseif (stripos($name, 'BODY[') === 0) {
                         $name = str_replace(']', '', substr($name, 5));
 
                         if ($name == 'HEADER.FIELDS') {
                             // skip ']' after headers list
                             $this->tokenizeResponse($line, 1);
                             $headers = $this->tokenizeResponse($line, 1);
                         } elseif (strlen($name)) {
                             $result[$id]->bodypart[$name] = $value;
                         } else {
                             $result[$id]->body = $value;
                         }
                     }
                 }
 
                 // create array with header field:data
                 if (!empty($headers)) {
                     $headers = explode("\n", trim($headers));
                     $lines   = [];
                     $ln      = 0;
 
                     foreach ($headers as $resln) {
                         if (!isset($resln[0]) || ord($resln[0]) <= 32) {
                             $lines[$ln] = ($lines[$ln] ?? '') . (empty($lines[$ln]) ? '' : "\n") . trim($resln);
                         } else {
                             $lines[++$ln] = trim($resln);
                         }
                     }
 
                     foreach ($lines as $str) {
                         if (strpos($str, ':') === false) {
                             continue;
                         }
 
                         [$field, $string] = explode(':', $str, 2);
 
                         $field  = strtolower($field);
                         $string = preg_replace('/\n[\t\s]*/', ' ', trim($string));
 
                         switch ($field) {
                             case 'date':
                                 $string                 = substr($string, 0, 128);
                                 $result[$id]->date      = $string;
                                 $result[$id]->timestamp = rcube_utils::strtotime($string);
                                 break;
                             case 'to':
                                 $result[$id]->to = preg_replace('/undisclosed-recipients:[;,]*/', '', $string);
                                 break;
                             case 'from':
                             case 'subject':
                                 $string = substr($string, 0, 2048);
                             case 'cc':
                             case 'bcc':
                             case 'references':
                                 $result[$id]->{$field} = $string;
                                 break;
                             case 'reply-to':
                                 $result[$id]->replyto = $string;
                                 break;
                             case 'content-transfer-encoding':
                                 $result[$id]->encoding = substr($string, 0, 32);
                                 break;
                             case 'content-type':
                                 $ctype_parts = preg_split('/[; ]+/', $string);
                                 $result[$id]->ctype = strtolower(array_first($ctype_parts));
                                 if (preg_match('/charset\s*=\s*"?([a-z0-9\-\.\_]+)"?/i', $string, $regs)) {
                                     $result[$id]->charset = $regs[1];
                                 }
                                 break;
                             case 'in-reply-to':
                                 $result[$id]->in_reply_to = str_replace(["\n", '<', '>'], '', $string);
                                 break;
                             case 'disposition-notification-to':
                             case 'x-confirm-reading-to':
                                 $result[$id]->mdn_to = substr($string, 0, 2048);
                                 break;
                             case 'message-id':
                                 $result[$id]->messageID = substr($string, 0, 2048);
                                 break;
                             case 'x-priority':
                                 if (preg_match('/^(\d+)/', $string, $matches)) {
                                     $result[$id]->priority = intval($matches[1]);
                                 }
                                 break;
                             default:
                                 if (strlen($field) < 3) {
                                     break;
                                 }
                                 if (!empty($result[$id]->others[$field])) {
                                     $string = array_merge((array) $result[$id]->others[$field], (array) $string);
                                 }
                                 $result[$id]->others[$field] = $string;
                         }
                     }
                 }
             }
             // VANISHED response (QRESYNC RFC5162)
             // Sample: * VANISHED (EARLIER) 300:310,405,411
             elseif (preg_match('/^\* VANISHED [()EARLIER]*/i', $line, $match)) {
                 $line   = substr($line, strlen($match[0]));
                 $v_data = $this->tokenizeResponse($line, 1);
 
                 $this->data['VANISHED'] = $v_data;
             }
         } while (!$this->startsWith($line, $key, true));
 
         if ($this->parseResult($line, 'FETCH: ') != self::ERROR_OK) {
             return false;
         }
 
         return $result;
     }
 
     /**
      * Returns message(s) data (flags, headers, etc.)
      *
      * @param string $mailbox     Mailbox name
      * @param mixed  $message_set Message(s) sequence identifier(s) or UID(s)
      * @param bool   $is_uid      True if $message_set contains UIDs
      * @param bool   $bodystr     Enable to add BODYSTRUCTURE data to the result
      * @param array  $add_headers List of additional headers
      *
      * @return bool|array List of rcube_message_header elements, False on error
      */
     public function fetchHeaders($mailbox, $message_set, $is_uid = false, $bodystr = false, $add_headers = [])
     {
         $query_items = ['UID', 'RFC822.SIZE', 'FLAGS', 'INTERNALDATE'];
         $headers     = ['DATE', 'FROM', 'TO', 'SUBJECT', 'CONTENT-TYPE', 'CC', 'REPLY-TO',
             'LIST-POST', 'DISPOSITION-NOTIFICATION-TO', 'X-PRIORITY'];
 
         if (!empty($add_headers)) {
             $add_headers = array_map('strtoupper', $add_headers);
             $headers     = array_unique(array_merge($headers, $add_headers));
         }
 
         if ($bodystr) {
             $query_items[] = 'BODYSTRUCTURE';
         }
 
         $query_items[] = 'BODY.PEEK[HEADER.FIELDS (' . implode(' ', $headers) . ')]';
 
         return $this->fetch($mailbox, $message_set, $is_uid, $query_items);
     }
 
     /**
      * Returns message data (flags, headers, etc.)
      *
      * @param string $mailbox     Mailbox name
      * @param int    $id          Message sequence identifier or UID
      * @param bool   $is_uid      True if $id is an UID
      * @param bool   $bodystr     Enable to add BODYSTRUCTURE data to the result
      * @param array  $add_headers List of additional headers
      *
      * @return bool|rcube_message_header Message data, False on error
      */
     public function fetchHeader($mailbox, $id, $is_uid = false, $bodystr = false, $add_headers = [])
     {
         $a = $this->fetchHeaders($mailbox, $id, $is_uid, $bodystr, $add_headers);
 
         if (is_array($a)) {
             return array_first($a);
         }
 
         return false;
     }
 
     /**
      * Sort messages by specified header field
      *
      * @param array  $messages Array of rcube_message_header objects
      * @param string $field    Name of the property to sort by
      * @param string $order    Sorting order (ASC|DESC)
      *
      * @return array Sorted input array
      */
     public static function sortHeaders($messages, $field, $order = 'ASC')
     {
         $field = empty($field) ? 'uid' : strtolower($field);
         $order = empty($order) ? 'ASC' : strtoupper($order);
         $index = [];
 
         reset($messages);
 
         // Create an index
         foreach ($messages as $key => $headers) {
             switch ($field) {
                 case 'arrival':
                     $field = 'internaldate';
                     // no-break
                 case 'date':
                 case 'internaldate':
                 case 'timestamp':
                     $value = rcube_utils::strtotime($headers->{$field});
                     if (!$value && $field != 'timestamp') {
                         $value = $headers->timestamp;
                     }
 
                     break;
 
                 default:
                     // @TODO: decode header value, convert to UTF-8
                     $value = $headers->{$field};
                     if (is_string($value)) {
                         $value = str_replace('"', '', $value);
 
                         if ($field == 'subject') {
                             $value = rcube_utils::remove_subject_prefix($value);
                         }
                     }
             }
 
             $index[$key] = $value;
         }
 
         $sort_order = $order == 'ASC' ? \SORT_ASC : \SORT_DESC;
         $sort_flags = \SORT_STRING | \SORT_FLAG_CASE;
 
         if (in_array($field, ['arrival', 'date', 'internaldate', 'timestamp', 'size', 'uid', 'id'])) {
             $sort_flags = \SORT_NUMERIC;
         }
 
         array_multisort($index, $sort_order, $sort_flags, $messages);
 
         return $messages;
     }
 
     /**
      * Fetch MIME headers of specified message parts
      *
      * @param string $mailbox Mailbox name
      * @param int    $uid     Message UID
      * @param array  $parts   Message part identifiers
      * @param bool   $mime    Use MIME instead of HEADER
      *
      * @return array|bool Array containing headers string for each specified body
      *                    False on failure.
      */
     public function fetchMIMEHeaders($mailbox, $uid, $parts, $mime = true)
     {
         if (!$this->select($mailbox)) {
             return false;
         }
 
         $parts  = (array) $parts;
         $key    = $this->nextTag();
         $peeks  = [];
         $type   = $mime ? 'MIME' : 'HEADER';
 
         // format request
         foreach ($parts as $part) {
             $peeks[] = "BODY.PEEK[$part.$type]";
         }
 
         $request = "$key UID FETCH $uid (" . implode(' ', $peeks) . ')';
 
         // send request
         if (!$this->putLine($request)) {
             $this->setError(self::ERROR_COMMAND, 'Failed to send UID FETCH command');
             return false;
         }
 
         $result = [];
 
         do {
             $line = $this->readLine(1024);
             if (preg_match('/^\* [0-9]+ FETCH [0-9UID( ]+/', $line, $m)) {
                 $line = ltrim(substr($line, strlen($m[0])));
                 while (preg_match('/^\s*BODY\[([0-9\.]+)\.' . $type . '\]/', $line, $matches)) {
                     $line = substr($line, strlen($matches[0]));
                     $result[$matches[1]] = trim($this->multLine($line));
                     $line = $this->readLine(1024);
                 }
             }
         } while (!$this->startsWith($line, $key, true));
 
         return $result;
     }
 
     /**
      * Fetches message part header
      */
     public function fetchPartHeader($mailbox, $id, $is_uid = false, $part = null)
     {
         $part = empty($part) ? 'HEADER' : $part . '.MIME';
 
         return $this->handlePartBody($mailbox, $id, $is_uid, $part);
     }
 
     /**
      * Fetches body of the specified message part
      */
     public function handlePartBody($mailbox, $id, $is_uid = false, $part = '', $encoding = null, $print = null,
         $file = null, $formatted = false, $max_bytes = 0)
     {
         if (!$this->select($mailbox)) {
             return false;
         }
 
         $binary    = true;
         $initiated = false;
 
         do {
             if (!$initiated) {
                 switch ($encoding) {
                     case 'base64':
                         $mode = 1;
                         break;
                     case 'quoted-printable':
                         $mode = 2;
                         break;
                     case 'x-uuencode':
                     case 'x-uue':
                     case 'uue':
                     case 'uuencode':
                         $mode = 3;
                         break;
                     default:
                         $mode = $formatted ? 4 : 0;
                 }
 
                 // Use BINARY extension when possible (and safe)
                 $binary     = $binary && $mode && preg_match('/^[0-9.]+$/', (string) $part) && $this->hasCapability('BINARY');
                 $fetch_mode = $binary ? 'BINARY' : 'BODY';
                 $partial    = $max_bytes ? sprintf('<0.%d>', $max_bytes) : '';
 
                 // format request
                 $key       = $this->nextTag();
                 $cmd       = ($is_uid ? 'UID ' : '') . 'FETCH';
                 $request   = "$key $cmd $id ($fetch_mode.PEEK[$part]$partial)";
                 $result    = false;
                 $found     = false;
                 $initiated = true;
 
                 // send request
                 if (!$this->putLine($request)) {
                     $this->setError(self::ERROR_COMMAND, "Failed to send $cmd command");
                     return false;
                 }
 
                 if ($binary) {
                     // WARNING: Use $formatted argument with care, this may break binary data stream
                     $mode = -1;
                 }
             }
 
             $line = trim($this->readLine(1024));
 
             if (!$line) {
                 break;
             }
 
             // handle UNKNOWN-CTE response - RFC 3516, try again with standard BODY request
             if ($binary && !$found && preg_match('/^' . $key . ' NO \[(UNKNOWN-CTE|PARSE)\]/i', $line)) {
                 $binary = $initiated = false;
                 continue;
             }
 
             // skip irrelevant untagged responses (we have a result already)
             if ($found || !preg_match('/^\* ([0-9]+) FETCH (.*)$/', $line, $m)) {
                 continue;
             }
 
             $line = $m[2];
 
             // handle one line response
             if ($line[0] == '(' && substr($line, -1) == ')') {
                 // tokenize content inside brackets
                 // the content can be e.g.: (UID 9844 BODY[2.4] NIL)
                 $line = preg_replace('/(^\(|\)$)/', '', $line);
                 $tokens = $this->tokenizeResponse($line);
 
                 for ($i = 0; $i < count($tokens); $i += 2) {
                     if (preg_match('/^(BODY|BINARY)/i', $tokens[$i])) {
                         $result = $tokens[$i + 1];
                         $found  = true;
                         break;
                     }
                 }
 
                 // Cyrus IMAP does not return a NO-response on error, but we can detect it
                 // and fallback to a non-binary fetch (#9097)
                 if ($binary && !$found) {
                     $binary = $initiated = false;
                     $line = trim($this->readLine(1024)); // the OK response line
                     continue;
                 }
 
                 if ($result !== false) {
                     $result = $this->decodeContent($result, $mode, true);
                 }
             }
             // response with string literal
             elseif (preg_match('/\{([0-9]+)\}$/', $line, $m)) {
                 $bytes = (int) $m[1];
                 $prev  = '';
                 $found = true;
                 $chunkSize = 1024 * 1024;
 
                 // empty body
                 if (!$bytes) {
                     $result = '';
                 }
                 // An optimal path for a case when we need the body as-is in a string
                 elseif (!$mode && !$file && !$print) {
                     $result = $this->readBytes($bytes);
                 } else {
                     while ($bytes > 0) {
                         $chunk = $this->readBytes($bytes > $chunkSize ? $chunkSize : $bytes);
 
                         if ($chunk === '') {
                             break;
                         }
 
                         $len = strlen($chunk);
 
                         if ($len > $bytes) {
                             $chunk = substr($chunk, 0, $bytes);
                             $len = strlen($chunk);
                         }
                         $bytes -= $len;
 
                         $chunk = $this->decodeContent($chunk, $mode, $bytes <= 0, $prev);
 
                         if ($file) {
-                            if (fwrite($file, $chunk) === false) {
+                            if (($result = fwrite($file, $chunk)) === false) {
                                 break;
                             }
                         } elseif ($print) {
                             echo $chunk;
                         } else {
                             $result .= $chunk;
                         }
                     }
                 }
             }
         } while (!$this->startsWith($line, $key, true) || !$initiated);
 
         if ($result !== false) {
             if ($file) {
-                return fwrite($file, $result);
+                return is_string($result) ? fwrite($file, $result) !== false : true;
             } elseif ($print) {
                 echo $result;
                 return true;
             }
 
             return $result;
         }
 
         return false;
     }
 
     /**
      * Decodes a chunk of a message part content from a FETCH response.
      *
      * @param string $chunk   Content
      * @param int    $mode    Encoding mode
      * @param bool   $is_last Whether it is a last chunk of data
      * @param string $prev    Extra content from the previous chunk
      *
      * @return string Encoded string
      */
     protected static function decodeContent($chunk, $mode, $is_last = false, &$prev = '')
     {
         // BASE64
         if ($mode == 1) {
             $chunk = $prev . preg_replace('|[^a-zA-Z0-9+=/]|', '', $chunk);
 
             // create chunks with proper length for base64 decoding
             $length = strlen($chunk);
 
             if ($length % 4) {
                 $length = floor($length / 4) * 4;
                 $prev = substr($chunk, $length);
                 $chunk = substr($chunk, 0, $length);
             } else {
                 $prev = '';
             }
 
             return base64_decode($chunk);
         }
 
         // QUOTED-PRINTABLE
         if ($mode == 2) {
             if (!self::decodeContentChunk($chunk, $prev, $is_last)) {
                 return '';
             }
 
             $chunk = preg_replace('/[\t\r\0\x0B]+\n/', "\n", $chunk);
 
             return quoted_printable_decode($chunk);
         }
 
         // X-UUENCODE
         if ($mode == 3) {
             if (!self::decodeContentChunk($chunk, $prev, $is_last)) {
                 return '';
             }
 
             $chunk = preg_replace(
                 ['/\r?\n/', '/(^|\n)end$/', '/^begin\s+[0-7]{3,4}\s+[^\n]+\n/'],
                 ["\n", '', ''],
                 $chunk
             );
 
             if (!strlen($chunk)) {
                 return '';
             }
 
             return convert_uudecode($chunk);
         }
 
         // Plain text formatted
         // TODO: Formatting should be handled outside of this class
         if ($mode == 4) {
             if (!self::decodeContentChunk($chunk, $prev, $is_last)) {
                 return '';
             }
 
             if ($is_last) {
                 $chunk = rtrim($chunk, "\t\r\n\0\x0B");
             }
 
             return preg_replace('/[\t\r\0\x0B]+\n/', "\n", $chunk);
         }
 
         return $chunk;
     }
 
     /**
      * A helper for a new-line aware parsing. See self::decodeContent().
      */
     private static function decodeContentChunk(&$chunk, &$prev, $is_last)
     {
         $chunk = $prev . $chunk;
         $prev = '';
 
         if (!$is_last) {
             if (($pos = strrpos($chunk, "\n")) !== false) {
                 $prev = substr($chunk, $pos + 1);
                 $chunk = substr($chunk, 0, $pos + 1);
             } else {
                 $prev = $chunk;
                 return false;
             }
         }
 
         return true;
     }
 
     /**
      * Handler for IMAP APPEND command
      *
      * @param string       $mailbox Mailbox name
      * @param string|array $message The message source string or array (of strings and file pointers)
      * @param array        $flags   Message flags
      * @param string       $date    Message internal date
      * @param bool         $binary  Enable BINARY append (RFC3516)
      *
      * @return string|bool On success APPENDUID response (if available) or True, False on failure
      */
     public function append($mailbox, &$message, $flags = [], $date = null, $binary = false)
     {
         unset($this->data['APPENDUID']);
 
         if ($mailbox === null || $mailbox === '') {
             return false;
         }
 
         $binary       = $binary && $this->getCapability('BINARY');
         $literal_plus = !$binary && !empty($this->prefs['literal+']);
         $len          = 0;
         $msg          = is_array($message) ? $message : [&$message];
         $chunk_size   = 512000;
 
         for ($i = 0, $cnt = count($msg); $i < $cnt; $i++) {
             if (is_resource($msg[$i])) {
                 $stat = fstat($msg[$i]);
                 if ($stat === false) {
                     return false;
                 }
                 $len += $stat['size'];
             } else {
                 if (!$binary) {
                     $msg[$i] = str_replace("\r", '', $msg[$i]);
                     $msg[$i] = str_replace("\n", "\r\n", $msg[$i]);
                 }
 
                 $len += strlen($msg[$i]);
             }
         }
 
         if (!$len) {
             return false;
         }
 
         // build APPEND command
         $key = $this->nextTag();
         $request = "$key APPEND " . $this->escape($mailbox) . ' (' . $this->flagsToStr($flags) . ')';
         if (!empty($date)) {
             $request .= ' ' . $this->escape($date);
         }
         $request .= ' ' . ($binary ? '~' : '') . '{' . $len . ($literal_plus ? '+' : '') . '}';
 
         // send APPEND command
         if (!$this->putLine($request)) {
             $this->setError(self::ERROR_COMMAND, 'Failed to send APPEND command');
             return false;
         }
 
         // Do not wait when LITERAL+ is supported
         if (!$literal_plus) {
             $line = $this->readReply();
 
             if ($line[0] != '+') {
                 $this->parseResult($line, 'APPEND: ');
                 return false;
             }
         }
 
         foreach ($msg as $msg_part) {
             // file pointer
             if (is_resource($msg_part)) {
                 rewind($msg_part);
                 while (!feof($msg_part) && $this->fp) {
                     $buffer = fread($msg_part, $chunk_size);
                     $this->putLine($buffer, false);
                 }
                 fclose($msg_part);
             }
             // string
             else {
                 $size = strlen($msg_part);
 
                 // Break up the data by sending one chunk (up to 512k) at a time.
                 // This approach reduces our peak memory usage
                 for ($offset = 0; $offset < $size; $offset += $chunk_size) {
                     $chunk = substr($msg_part, $offset, $chunk_size);
                     if (!$this->putLine($chunk, false)) {
                         return false;
                     }
                 }
             }
         }
 
         if (!$this->putLine('')) { // \r\n
             return false;
         }
 
         do {
             $line = $this->readLine();
         } while (!$this->startsWith($line, $key, true, true));
 
         // Clear internal status cache
         unset($this->data['STATUS:' . $mailbox]);
 
         if ($this->parseResult($line, 'APPEND: ') != self::ERROR_OK) {
             return false;
         }
 
         if (!empty($this->data['APPENDUID'])) {
             return $this->data['APPENDUID'];
         }
 
         return true;
     }
 
     /**
      * Handler for IMAP APPEND command.
      *
      * @param string $mailbox Mailbox name
      * @param string $path    Path to the file with message body
      * @param string $headers Message headers
      * @param array  $flags   Message flags
      * @param string $date    Message internal date
      * @param bool   $binary  Enable BINARY append (RFC3516)
      *
      * @return string|bool On success APPENDUID response (if available) or True, False on failure
      */
     public function appendFromFile($mailbox, $path, $headers = null, $flags = [], $date = null, $binary = false)
     {
         // open message file
         if (file_exists(realpath($path))) {
             $fp = fopen($path, 'r');
         }
 
         if (empty($fp)) {
             $this->setError(self::ERROR_UNKNOWN, "Couldn't open $path for reading");
             return false;
         }
 
         $message = [];
         if ($headers) {
             $message[] = trim($headers, "\r\n") . "\r\n\r\n";
         }
         $message[] = $fp;
 
         return $this->append($mailbox, $message, $flags, $date, $binary);
     }
 
     /**
      * Returns QUOTA information
      *
      * @param string $mailbox Mailbox name
      *
      * @return array|false Quota information, False on error
      */
     public function getQuota($mailbox = null)
     {
         if ($mailbox === null || $mailbox === '') {
             $mailbox = 'INBOX';
         }
 
         // a0001 GETQUOTAROOT INBOX
         // * QUOTAROOT INBOX user/sample
         // * QUOTA user/sample (STORAGE 654 9765)
         // a0001 OK Completed
 
         [$code, $response] = $this->execute('GETQUOTAROOT', [$this->escape($mailbox)], 0, '/^\* QUOTA /i');
 
         if ($code != self::ERROR_OK) {
             return false;
         }
 
         $min_free = \PHP_INT_MAX;
         $result   = [];
         $all      = [];
 
         foreach (explode("\n", $response) as $line) {
             $tokens     = $this->tokenizeResponse($line, 3);
             $quota_root = $tokens[2] ?? null;
             $quotas     = $this->tokenizeResponse($line, 1);
 
             if (empty($quotas)) {
                 continue;
             }
 
             foreach (array_chunk($quotas, 3) as $quota) {
                 [$type, $used, $total] = $quota;
                 $type = strtolower($type);
 
                 if ($type && $total) {
                     $all[$quota_root][$type]['used']  = intval($used);
                     $all[$quota_root][$type]['total'] = intval($total);
                 }
             }
 
             if (empty($all[$quota_root]['storage'])) {
                 continue;
             }
 
             $used  = $all[$quota_root]['storage']['used'];
             $total = $all[$quota_root]['storage']['total'];
             $free  = $total - $used;
 
             // calculate lowest available space from all storage quotas
             if ($free < $min_free) {
                 $min_free          = $free;
                 $result['used']    = $used;
                 $result['total']   = $total;
                 $result['percent'] = min(100, round(($used / max(1, $total)) * 100));
                 $result['free']    = 100 - $result['percent'];
             }
         }
 
         if (!empty($result)) {
             $result['all'] = $all;
         }
 
         return $result;
     }
 
     /**
      * Send the SETQUOTA command (RFC9208)
      *
      * @param string $root  Quota root
      * @param array  $quota Quota limits e.g. ['storage' => 1024000']
      *
      * @return bool True on success, False on failure
      */
     public function setQuota($root, $quota)
     {
         $fn = static function ($key, $value) {
             return strtoupper($key) . ' ' . $value;
         };
 
         $quota = implode(' ', array_map($fn, array_keys($quota), $quota));
 
         $result = $this->execute('SETQUOTA', [$this->escape($root), "({$quota})"],
             self::COMMAND_NORESPONSE);
 
         return $result == self::ERROR_OK;
     }
 
     /**
      * Send the SETACL command (RFC4314)
      *
      * @param string $mailbox Mailbox name
      * @param string $user    User name
      * @param mixed  $acl     ACL string or array
      *
      * @return bool True on success, False on failure
      *
      * @since 0.5-beta
      */
     public function setACL($mailbox, $user, $acl)
     {
         if (is_array($acl)) {
             $acl = implode('', $acl);
         }
 
         $result = $this->execute('SETACL',
             [$this->escape($mailbox), $this->escape($user), strtolower($acl)],
             self::COMMAND_NORESPONSE
         );
 
         return $result == self::ERROR_OK;
     }
 
     /**
      * Send the DELETEACL command (RFC4314)
      *
      * @param string $mailbox Mailbox name
      * @param string $user    User name
      *
      * @return bool True on success, False on failure
      *
      * @since 0.5-beta
      */
     public function deleteACL($mailbox, $user)
     {
         $result = $this->execute('DELETEACL',
             [$this->escape($mailbox), $this->escape($user)],
             self::COMMAND_NORESPONSE
         );
 
         return $result == self::ERROR_OK;
     }
 
     /**
      * Send the GETACL command (RFC4314)
      *
      * @param string $mailbox Mailbox name
      *
      * @return array User-rights array on success, NULL on error
      *
      * @since 0.5-beta
      */
     public function getACL($mailbox)
     {
         [$code, $response] = $this->execute('GETACL', [$this->escape($mailbox)], 0, '/^\* ACL /i');
 
         if ($code == self::ERROR_OK && $response) {
             // Parse server response (remove "* ACL ")
             $response = substr($response, 6);
             $ret  = $this->tokenizeResponse($response);
             $mbox = array_shift($ret);
             $size = count($ret);
 
             // Create user-rights hash array
             // @TODO: consider implementing fixACL() method according to RFC4314.2.1.1
             // so we could return only standard rights defined in RFC4314,
             // excluding 'c' and 'd' defined in RFC2086.
             if ($size % 2 == 0) {
                 for ($i = 0; $i < $size; $i++) {
                     $ret[$ret[$i]] = str_split($ret[++$i]);
                     unset($ret[$i - 1]);
                     unset($ret[$i]);
                 }
                 return $ret;
             }
 
             $this->setError(self::ERROR_COMMAND, 'Incomplete ACL response');
         }
     }
 
     /**
      * Send the LISTRIGHTS command (RFC4314)
      *
      * @param string $mailbox Mailbox name
      * @param string $user    User name
      *
      * @return array List of user rights
      *
      * @since 0.5-beta
      */
     public function listRights($mailbox, $user)
     {
         [$code, $response] = $this->execute('LISTRIGHTS',
             [$this->escape($mailbox), $this->escape($user)], 0, '/^\* LISTRIGHTS /i');
 
         if ($code == self::ERROR_OK && $response) {
             // Parse server response (remove "* LISTRIGHTS ")
             $response = substr($response, 13);
 
             $ret_mbox = $this->tokenizeResponse($response, 1);
             $ret_user = $this->tokenizeResponse($response, 1);
             $granted  = $this->tokenizeResponse($response, 1);
             $optional = trim($response);
 
             return [
                 'granted'  => str_split($granted),
                 'optional' => explode(' ', $optional),
             ];
         }
     }
 
     /**
      * Send the MYRIGHTS command (RFC4314)
      *
      * @param string $mailbox Mailbox name
      *
      * @return array MYRIGHTS response on success, NULL on error
      *
      * @since 0.5-beta
      */
     public function myRights($mailbox)
     {
         [$code, $response] = $this->execute('MYRIGHTS', [$this->escape($mailbox)], 0, '/^\* MYRIGHTS /i');
 
         if ($code == self::ERROR_OK && $response) {
             // Parse server response (remove "* MYRIGHTS ")
             $response = substr($response, 11);
 
             $ret_mbox = $this->tokenizeResponse($response, 1);
             $rights   = $this->tokenizeResponse($response, 1);
 
             return str_split($rights);
         }
     }
 
     /**
      * Send the SETMETADATA command (RFC5464)
      *
      * @param string $mailbox Mailbox name
      * @param array  $entries Entry-value array (use NULL value as NIL)
      *
      * @return bool True on success, False on failure
      *
      * @since 0.5-beta
      */
     public function setMetadata($mailbox, $entries)
     {
         if (!is_array($entries) || empty($entries)) {
             $this->setError(self::ERROR_COMMAND, 'Wrong argument for SETMETADATA command');
             return false;
         }
 
         foreach ($entries as $name => $value) {
             $entries[$name] = $this->escape($name) . ' ' . $this->escape($value, true);
         }
 
         $entries = implode(' ', $entries);
         $result = $this->execute('SETMETADATA',
             [$this->escape($mailbox), '(' . $entries . ')'],
             self::COMMAND_NORESPONSE
         );
 
         return $result == self::ERROR_OK;
     }
 
     /**
      * Send the SETMETADATA command with NIL values (RFC5464)
      *
      * @param string $mailbox Mailbox name
      * @param array  $entries Entry names array
      *
      * @return bool True on success, False on failure
      *
      * @since 0.5-beta
      */
     public function deleteMetadata($mailbox, $entries)
     {
         if (!is_array($entries) && !empty($entries)) {
             $entries = explode(' ', $entries);
         }
 
         if (empty($entries)) {
             $this->setError(self::ERROR_COMMAND, 'Wrong argument for SETMETADATA command');
             return false;
         }
 
         $data = [];
         foreach ($entries as $entry) {
             $data[$entry] = null;
         }
 
         return $this->setMetadata($mailbox, $data);
     }
 
     /**
      * Send the GETMETADATA command (RFC5464)
      *
      * @param string $mailbox Mailbox name
      * @param array  $entries Entries
      * @param array  $options Command options (with MAXSIZE and DEPTH keys)
      *
      * @return array GETMETADATA result on success, NULL on error
      *
      * @since 0.5-beta
      */
     public function getMetadata($mailbox, $entries, $options = [])
     {
         if (!is_array($entries)) {
             $entries = [$entries];
         }
 
         $args = [];
 
         // create options string
         if (is_array($options)) {
             $options = array_change_key_case($options, \CASE_UPPER);
             $opts    = [];
 
             if (!empty($options['MAXSIZE'])) {
                 $opts[] = 'MAXSIZE ' . intval($options['MAXSIZE']);
             }
 
             if (isset($options['DEPTH'])) {
                 $opts[] = 'DEPTH ' . $this->escape($options['DEPTH']);
             }
 
             if (!empty($opts)) {
                 $args[] = $opts;
             }
         }
 
         $args[] = $this->escape($mailbox);
         $args[] = array_map([$this, 'escape'], $entries);
 
         [$code, $response] = $this->execute('GETMETADATA', $args);
 
         if ($code == self::ERROR_OK) {
             $result = [];
             $data   = $this->tokenizeResponse($response);
 
             // The METADATA response can contain multiple entries in a single
             // response or multiple responses for each entry or group of entries
             for ($i = 0, $size = count($data); $i < $size; $i++) {
                 if ($data[$i] === '*'
                     && $data[++$i] === 'METADATA'
                     && is_string($mbox = $data[++$i])
                     && is_array($data[++$i])
                 ) {
                     for ($x = 0, $size2 = count($data[$i]); $x < $size2; $x += 2) {
                         if ($data[$i][$x + 1] !== null) {
                             $result[$mbox][$data[$i][$x]] = $data[$i][$x + 1];
                         }
                     }
                 }
             }
 
             return $result;
         }
     }
 
     /**
      * Send the SETANNOTATION command (draft-daboo-imap-annotatemore)
      *
      * @param string $mailbox Mailbox name
      * @param array  $data    Data array where each item is an array with
      *                        three elements: entry name, attribute name, value
      *
      * @return bool True on success, False on failure
      *
      * @since 0.5-beta
      */
     public function setAnnotation($mailbox, $data)
     {
         if (!is_array($data) || empty($data)) {
             $this->setError(self::ERROR_COMMAND, 'Wrong argument for SETANNOTATION command');
             return false;
         }
 
         foreach ($data as $entry) {
             // ANNOTATEMORE drafts before version 08 require quoted parameters
             $entries[] = sprintf('%s (%s %s)', $this->escape($entry[0], true),
                 $this->escape($entry[1], true), $this->escape($entry[2], true));
         }
 
         $entries = implode(' ', $entries);
         $result  = $this->execute('SETANNOTATION', [$this->escape($mailbox), $entries], self::COMMAND_NORESPONSE);
 
         return $result == self::ERROR_OK;
     }
 
     /**
      * Send the SETANNOTATION command with NIL values (draft-daboo-imap-annotatemore)
      *
      * @param string $mailbox Mailbox name
      * @param array  $data    Data array where each item is an array with
      *                        two elements: entry name and attribute name
      *
      * @return bool True on success, False on failure
      *
      * @since 0.5-beta
      */
     public function deleteAnnotation($mailbox, $data)
     {
         if (!is_array($data) || empty($data)) {
             $this->setError(self::ERROR_COMMAND, 'Wrong argument for SETANNOTATION command');
             return false;
         }
 
         return $this->setAnnotation($mailbox, $data);
     }
 
     /**
      * Send the GETANNOTATION command (draft-daboo-imap-annotatemore)
      *
      * @param string $mailbox Mailbox name
      * @param array  $entries Entries names
      * @param array  $attribs Attribs names
      *
      * @return array Annotations result on success, NULL on error
      *
      * @since 0.5-beta
      */
     public function getAnnotation($mailbox, $entries, $attribs)
     {
         if (!is_array($entries)) {
             $entries = [$entries];
         }
 
         // create entries string
         // ANNOTATEMORE drafts before version 08 require quoted parameters
         foreach ($entries as $idx => $name) {
             $entries[$idx] = $this->escape($name, true);
         }
         $entries = '(' . implode(' ', $entries) . ')';
 
         if (!is_array($attribs)) {
             $attribs = [$attribs];
         }
 
         // create attributes string
         foreach ($attribs as $idx => $name) {
             $attribs[$idx] = $this->escape($name, true);
         }
         $attribs = '(' . implode(' ', $attribs) . ')';
 
         [$code, $response] = $this->execute('GETANNOTATION', [$this->escape($mailbox), $entries, $attribs]);
 
         if ($code == self::ERROR_OK) {
             $result     = [];
             $data       = $this->tokenizeResponse($response);
             $last_entry = null;
 
             // Here we returns only data compatible with METADATA result format
             if (!empty($data) && ($size = count($data))) {
                 for ($i = 0; $i < $size; $i++) {
                     $entry = $data[$i];
                     if (isset($mbox) && is_array($entry)) {
                         $attribs = $entry;
                         $entry   = $last_entry;
                     } elseif ($entry == '*') {
                         if ($data[$i + 1] == 'ANNOTATION') {
                             $mbox = $data[$i + 2];
                             unset($data[$i]);   // "*"
                             unset($data[++$i]); // "ANNOTATION"
                             unset($data[++$i]); // Mailbox
                         }
                         // get rid of other untagged responses
                         else {
                             unset($mbox);
                             unset($data[$i]);
                         }
                         continue;
                     } elseif (isset($mbox)) {
                         $attribs = $data[++$i];
                     } else {
                         unset($data[$i]);
                         continue;
                     }
 
                     if (!empty($attribs)) {
                         for ($x = 0, $len = count($attribs); $x < $len;) {
                             $attr  = $attribs[$x++];
                             $value = $attribs[$x++];
                             if ($attr == 'value.priv' && $value !== null) {
                                 $result[$mbox]['/private' . $entry] = $value;
                             } elseif ($attr == 'value.shared' && $value !== null) {
                                 $result[$mbox]['/shared' . $entry] = $value;
                             }
                         }
                     }
 
                     $last_entry = $entry;
                     unset($data[$i]);
                 }
             }
 
             return $result;
         }
     }
 
     /**
      * Returns BODYSTRUCTURE for the specified message.
      *
      * @param string $mailbox Folder name
      * @param int    $id      Message sequence number or UID
      * @param bool   $is_uid  True if $id is an UID
      *
      * @return array|bool Body structure array or False on error.
      *
      * @since 0.6
      */
     public function getStructure($mailbox, $id, $is_uid = false)
     {
         $result = $this->fetch($mailbox, $id, $is_uid, ['BODYSTRUCTURE']);
 
         if (is_array($result) && !empty($result)) {
             $result = array_first($result);
             return $result->bodystructure;
         }
 
         return false;
     }
 
     /**
      * Returns data of a message part according to specified structure.
      *
      * @param array  $structure Message structure (getStructure() result)
      * @param string $part      Message part identifier
      *
      * @return array Part data as hash array (type, encoding, charset, size)
      */
     public static function getStructurePartData($structure, $part)
     {
         $part_a = self::getStructurePartArray($structure, $part);
         $data   = [];
 
         if (empty($part_a)) {
             return $data;
         }
 
         // content-type
         if (is_array($part_a[0])) {
             $data['type'] = 'multipart';
         } else {
             $data['type']     = strtolower($part_a[0]);
             $data['subtype']  = strtolower($part_a[1]);
             $data['encoding'] = strtolower($part_a[5]);
 
             // charset
             if (is_array($part_a[2])) {
                 foreach ($part_a[2] as $key => $val) {
                     if (strcasecmp($val, 'charset') == 0) {
                         $data['charset'] = $part_a[2][$key + 1];
                         break;
                     }
                 }
             }
         }
 
         // size
         $data['size'] = intval($part_a[6]);
 
         return $data;
     }
 
     public static function getStructurePartArray($a, $part)
     {
         if (!is_array($a)) {
             return false;
         }
 
         if (empty($part)) {
             return $a;
         }
 
         $ctype = is_string($a[0]) && is_string($a[1]) ? $a[0] . '/' . $a[1] : '';
 
         if (strcasecmp($ctype, 'message/rfc822') == 0) {
             $a = $a[8];
         }
 
         if (strpos($part, '.') > 0) {
             $orig_part = $part;
             $pos       = strpos($part, '.');
             $rest      = substr($orig_part, $pos + 1);
             $part      = substr($orig_part, 0, $pos);
 
             return self::getStructurePartArray($a[$part - 1], $rest);
         } elseif ($part > 0) {
             return is_array($a[$part - 1]) ? $a[$part - 1] : $a;
         }
     }
 
     /**
      * Creates next command identifier (tag)
      *
      * @return string Command identifier
      *
      * @since 0.5-beta
      */
     public function nextTag()
     {
         $this->cmd_num++;
         $this->cmd_tag = sprintf('A%04d', $this->cmd_num);
 
         return $this->cmd_tag;
     }
 
     /**
      * Sends IMAP command and parses result
      *
      * @param string $command   IMAP command
      * @param array  $arguments Command arguments
      * @param int    $options   Execution options
      * @param string $filter    Line filter (regexp)
      *
      * @return mixed Response code or list of response code and data
      *
      * @since 0.5-beta
      */
     public function execute($command, $arguments = [], $options = 0, $filter = null)
     {
         $tag      = $this->nextTag();
         $query    = $tag . ' ' . $command;
         $noresp   = ($options & self::COMMAND_NORESPONSE);
         $response = $noresp ? null : '';
 
         if (!empty($arguments)) {
             foreach ($arguments as $arg) {
                 $query .= ' ' . self::r_implode($arg);
             }
         }
 
         // Send command
         if (!$this->putLineC($query, true, $options & self::COMMAND_ANONYMIZED)) {
             preg_match('/^[A-Z0-9]+ ((UID )?[A-Z]+)/', $query, $matches);
             $cmd = $matches[1] ?: 'UNKNOWN';
             $this->setError(self::ERROR_COMMAND, "Failed to send $cmd command");
 
             return $noresp ? self::ERROR_COMMAND : [self::ERROR_COMMAND, ''];
         }
 
         // Parse response
         do {
             $line = $this->readFullLine(4096);
 
             if ($response !== null) {
                 if (!$filter || preg_match($filter, $line)) {
                     $response .= $line;
                 }
             }
 
             // parse untagged response for [COPYUID 1204196876 3456:3457 123:124] (RFC6851)
             if ($line && $command == 'UID MOVE') {
                 if (preg_match('/^\\* OK \\[COPYUID [0-9]+ ([0-9,:]+) ([0-9,:]+)\\]/i', $line, $m)) {
                     $this->data['COPYUID'] = [$m[1], $m[2]];
                 }
             }
         } while (!$this->startsWith($line, $tag . ' ', true, true));
 
         $code = $this->parseResult($line, $command . ': ');
 
         // Remove last line from response
         if ($response) {
             if (!$filter) {
                 $line_len = min(strlen($response), strlen($line));
                 $response = substr($response, 0, -$line_len);
             }
 
             $response = rtrim($response, "\r\n");
         }
 
         // optional CAPABILITY response
         if (($options & self::COMMAND_CAPABILITY) && $code == self::ERROR_OK
             && preg_match('/\[CAPABILITY ([^]]+)\]/i', $line, $matches)
         ) {
             $this->parseCapability($matches[1], true);
         }
 
         // return last line only (without command tag, result and response code)
         if ($line && ($options & self::COMMAND_LASTLINE)) {
             $response = preg_replace("/^$tag (OK|NO|BAD|BYE|PREAUTH)?\\s*(\\[[a-z-]+\\])?\\s*/i", '', trim($line));
         }
 
         return $noresp ? $code : [$code, $response];
     }
 
     /**
      * Splits IMAP response into string tokens
      *
      * @param string &$str The IMAP's server response
      * @param int    $num  Number of tokens to return
      *
      * @return mixed Tokens array or string if $num=1
      *
      * @since 0.5-beta
      */
     public static function tokenizeResponse(&$str, $num = 0)
     {
         $result = [];
 
         while (!$num || count($result) < $num) {
             // remove spaces from the beginning of the string
             $str = ltrim($str);
 
             // empty string
             if ($str === '' || $str === null) {
                 break;
             }
 
             switch ($str[0]) {
 
                 // String literal
                 case '{':
                     if (($epos = strpos($str, "}\r\n", 1)) == false) {
                         // error
                     }
                     if (!is_numeric($bytes = substr($str, 1, $epos - 1))) {
                         // error
                     }
 
                     $result[] = $bytes ? substr($str, $epos + 3, $bytes) : '';
                     $str      = substr($str, $epos + 3 + $bytes);
                     break;
 
                     // Quoted string (<< reindent once https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/issues/7179 is fixed)
                 case '"':
                     $len = strlen($str);
 
                     for ($pos = 1; $pos < $len; $pos++) {
                         if ($str[$pos] == '"') {
                             break;
                         }
                         if ($str[$pos] == '\\') {
                             if ($str[$pos + 1] == '"' || $str[$pos + 1] == '\\') {
                                 $pos++;
                             }
                         }
                     }
 
                     // we need to strip slashes for a quoted string
                     $result[] = stripslashes(substr($str, 1, $pos - 1));
                     $str      = substr($str, $pos + 1);
                     break;
 
                     // Parenthesized list (<< reindent once https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/issues/7179 is fixed)
                 case '(':
                     $str      = substr($str, 1);
                     $result[] = self::tokenizeResponse($str);
                     break;
 
                 case ')':
                     $str = substr($str, 1);
                     return $result;
 
                     // String atom, number, astring, NIL, *, % (<< reindent once https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/issues/7179 is fixed)
                 default:
                     // excluded chars: SP, CTL, ), DEL
                     // we do not exclude [ and ] (#1489223)
                     if (preg_match('/^([^\x00-\x20\x29\x7F]+)/', $str, $m)) {
                         $result[] = $m[1] == 'NIL' ? null : $m[1];
                         $str      = substr($str, strlen($m[1]));
                     }
 
                     break;
             }
         }
 
         return $num == 1 ? ($result[0] ?? '') : $result;
     }
 
     /**
      * Joins IMAP command line elements (recursively)
      */
     protected static function r_implode($element)
     {
         if (!is_array($element)) {
             return $element;
         }
 
         reset($element);
 
         $string = '';
 
         foreach ($element as $value) {
             $string .= ' ' . self::r_implode($value);
         }
 
         return '(' . trim($string) . ')';
     }
 
     /**
      * Converts message identifiers array into sequence-set syntax
      *
      * @param array $messages Message identifiers
      * @param bool  $force    Forces compression of any size
      *
      * @return string Compressed sequence-set
      */
     public static function compressMessageSet($messages, $force = false)
     {
         // given a comma delimited list of independent mid's,
         // compresses by grouping sequences together
         if (!is_array($messages)) {
             // if less than 255 bytes long, let's not bother
             if (!$force && strlen($messages) < 255) {
                 return preg_match('/[^0-9:,*]/', $messages) ? 'INVALID' : $messages;
             }
 
             // see if it's already been compressed
             if (strpos($messages, ':') !== false) {
                 return preg_match('/[^0-9:,*]/', $messages) ? 'INVALID' : $messages;
             }
 
             // separate, then sort
             $messages = explode(',', $messages);
         }
 
         sort($messages);
 
         $result = [];
         $start  = $prev = $messages[0];
 
         foreach ($messages as $id) {
             $incr = $id - $prev;
             if ($incr > 1) { // found a gap
                 if ($start == $prev) {
                     $result[] = $prev; // push single id
                 } else {
                     $result[] = $start . ':' . $prev; // push sequence as start_id:end_id
                 }
                 $start = $id; // start of new sequence
             }
             $prev = $id;
         }
 
         // handle the last sequence/id
         if ($start == $prev) {
             $result[] = $prev;
         } else {
             $result[] = $start . ':' . $prev;
         }
 
         // return as comma separated string
         $result = implode(',', $result);
 
         return preg_match('/[^0-9:,*]/', $result) ? 'INVALID' : $result;
     }
 
     /**
      * Converts message sequence-set into array
      *
      * @param string $messages Message identifiers
      *
      * @return array List of message identifiers
      */
     public static function uncompressMessageSet($messages)
     {
         if (empty($messages)) {
             return [];
         }
 
         $result   = [];
         $messages = explode(',', $messages);
 
         foreach ($messages as $idx => $part) {
             $items = explode(':', $part);
 
             if (!empty($items[1]) && $items[1] > $items[0]) {
                 $max = $items[1];
             } else {
                 $max = $items[0];
             }
 
             for ($x = $items[0]; $x <= $max; $x++) {
                 $result[] = (int) $x;
             }
 
             unset($messages[$idx]);
         }
 
         return $result;
     }
 
     /**
      * Clear internal status cache
      */
     protected function clear_status_cache($mailbox)
     {
         unset($this->data['STATUS:' . $mailbox]);
 
         $keys = ['EXISTS', 'RECENT', 'UNSEEN', 'UID-MAP'];
 
         foreach ($keys as $key) {
             unset($this->data[$key]);
         }
     }
 
     /**
      * Clear internal cache of the current mailbox
      */
     protected function clear_mailbox_cache()
     {
         $this->clear_status_cache($this->selected);
 
         $keys = ['UIDNEXT', 'UIDVALIDITY', 'HIGHESTMODSEQ', 'NOMODSEQ',
             'PERMANENTFLAGS', 'QRESYNC', 'VANISHED', 'READ-WRITE'];
 
         foreach ($keys as $key) {
             unset($this->data[$key]);
         }
     }
 
     /**
      * Converts flags array into string for inclusion in IMAP command
      *
      * @param array $flags Flags (see self::flags)
      *
      * @return string Space-separated list of flags
      */
     protected function flagsToStr($flags)
     {
         foreach ((array) $flags as $idx => $flag) {
             if ($flag = $this->flags[strtoupper($flag)]) {
                 $flags[$idx] = $flag;
             }
         }
 
         return implode(' ', (array) $flags);
     }
 
     /**
      * CAPABILITY response parser
      */
     protected function parseCapability($str, $trusted = false)
     {
         $str = preg_replace('/^\* CAPABILITY /i', '', $str);
 
         $this->capability = explode(' ', strtoupper($str));
 
         if (!empty($this->prefs['disabled_caps'])) {
             $this->capability = array_diff($this->capability, $this->prefs['disabled_caps']);
         }
 
         if (!isset($this->prefs['literal+']) && in_array('LITERAL+', $this->capability)) {
             $this->prefs['literal+'] = true;
         } elseif (!isset($this->prefs['literal-']) && in_array('LITERAL-', $this->capability)) {
             $this->prefs['literal-'] = true;
         }
 
         if ($trusted) {
             $this->capability_read = true;
         }
     }
 
     /**
      * Escapes a string when it contains special characters (RFC3501)
      *
      * @param string $string       IMAP string
      * @param bool   $force_quotes Forces string quoting (for atoms)
      *
      * @return string String atom, quoted-string or string literal
      *
      * @todo lists
      */
     public static function escape($string, $force_quotes = false)
     {
         if ($string === null) {
             return 'NIL';
         }
 
         if ($string === '') {
             return '""';
         }
 
         // atom-string (only safe characters)
         if (!$force_quotes && !preg_match('/[\x00-\x20\x22\x25\x28-\x2A\x5B-\x5D\x7B\x7D\x80-\xFF]/', $string)) {
             return $string;
         }
 
         // quoted-string
         if (!preg_match('/[\r\n\x00\x80-\xFF]/', $string)) {
             return '"' . addcslashes($string, '\\"') . '"';
         }
 
         // literal-string
         return sprintf("{%d}\r\n%s", strlen($string), $string);
     }
 
     /**
      * Set the value of the debugging flag.
      *
      * @param bool     $debug   New value for the debugging flag.
      * @param callable $handler Logging handler function
      *
      * @since 0.5-stable
      */
     public function setDebug($debug, $handler = null)
     {
         $this->debug         = $debug;
         $this->debug_handler = $handler;
     }
 
     /**
      * Write the given debug text to the current debug output handler.
      *
      * @param string $message Debug message text.
      *
      * @since 0.5-stable
      */
     protected function debug($message)
     {
         if (($len = strlen($message)) > self::DEBUG_LINE_LENGTH) {
             $diff    = $len - self::DEBUG_LINE_LENGTH;
             $message = substr($message, 0, self::DEBUG_LINE_LENGTH)
                 . "... [truncated $diff bytes]";
         }
 
         if ($this->resourceid) {
             $message = sprintf('[%s] %s', $this->resourceid, $message);
         }
 
         if ($this->debug_handler) {
             call_user_func_array($this->debug_handler, [$this, $message]);
         } else {
             echo "DEBUG: $message\n";
         }
     }
 }
diff --git a/src/include/rcube_message_header.php b/src/include/rcube_message_header.php
new file mode 100644
index 00000000..c1fa7171
--- /dev/null
+++ b/src/include/rcube_message_header.php
@@ -0,0 +1,338 @@
+<?php
+
+/**
+ +-----------------------------------------------------------------------+
+ | This file is part of the Roundcube Webmail client                     |
+ |                                                                       |
+ | Copyright (C) The Roundcube Dev Team                                  |
+ | Copyright (C) Kolab Systems AG                                        |
+ |                                                                       |
+ | Licensed under the GNU General Public License version 3 or            |
+ | any later version with exceptions for skins & plugins.                |
+ | See the README file for a full license statement.                     |
+ |                                                                       |
+ | PURPOSE:                                                              |
+ |   E-mail message headers representation                               |
+ +-----------------------------------------------------------------------+
+ | Author: Aleksander Machniak <alec@alec.pl>                            |
+ +-----------------------------------------------------------------------+
+*/
+
+/**
+ * Struct representing an e-mail message header
+ *
+ * @package    Framework
+ * @subpackage Storage
+ */
+class rcube_message_header
+{
+    /**
+     * Message sequence number
+     *
+     * @var int
+     */
+    public $id;
+
+    /**
+     * Message unique identifier
+     *
+     * @var int
+     */
+    public $uid;
+
+    /**
+     * Message subject
+     *
+     * @var string
+     */
+    public $subject;
+
+    /**
+     * Message sender (From)
+     *
+     * @var string
+     */
+    public $from;
+
+    /**
+     * Message recipient (To)
+     *
+     * @var string
+     */
+    public $to;
+
+    /**
+     * Message additional recipients (Cc)
+     *
+     * @var string
+     */
+    public $cc;
+
+    /**
+     * Message Reply-To header
+     *
+     * @var string
+     */
+    public $replyto;
+
+    /**
+     * Message In-Reply-To header
+     *
+     * @var string
+     */
+    public $in_reply_to;
+
+    /**
+     * Message date (Date)
+     *
+     * @var string
+     */
+    public $date;
+
+    /**
+     * Message identifier (Message-ID)
+     *
+     * @var string
+     */
+    public $messageID;
+
+    /**
+     * Message size
+     *
+     * @var int
+     */
+    public $size;
+
+    /**
+     * Message encoding
+     *
+     * @var string
+     */
+    public $encoding;
+
+    /**
+     * Message charset
+     *
+     * @var string
+     */
+    public $charset;
+
+    /**
+     * Message Content-type
+     *
+     * @var string
+     */
+    public $ctype;
+
+    /**
+     * Message timestamp (based on message date)
+     *
+     * @var int
+     */
+    public $timestamp;
+
+    /**
+     * IMAP bodystructure string
+     *
+     * @var string
+     */
+    public $bodystructure;
+
+    /**
+     * IMAP internal date
+     *
+     * @var string
+     */
+    public $internaldate;
+
+    /**
+     * Message References header
+     *
+     * @var string
+     */
+    public $references;
+
+    /**
+     * Message priority (X-Priority)
+     *
+     * @var int
+     */
+    public $priority;
+
+    /**
+     * Message receipt recipient
+     *
+     * @var string
+     */
+    public $mdn_to;
+
+    /**
+     * IMAP folder this message is stored in
+     *
+     * @var string
+     */
+    public $folder;
+
+    /**
+     * Other message headers
+     *
+     * @var array
+     */
+    public $others = [];
+
+    /**
+     * Message flags
+     *
+     * @var array
+     */
+    public $flags = [];
+
+    /**
+     * Header name to rcube_message_header object property map
+     *
+     * @var array
+     */
+    private $obj_headers = [
+        'date'      => 'date',
+        'from'      => 'from',
+        'to'        => 'to',
+        'subject'   => 'subject',
+        'reply-to'  => 'replyto',
+        'cc'        => 'cc',
+        'bcc'       => 'bcc',
+        'mbox'      => 'folder',
+        'folder'    => 'folder',
+        'content-transfer-encoding' => 'encoding',
+        'in-reply-to'               => 'in_reply_to',
+        'content-type'              => 'ctype',
+        'charset'                   => 'charset',
+        'references'                => 'references',
+        'disposition-notification-to' => 'mdn_to',
+        'x-confirm-reading-to'      => 'mdn_to',
+        'message-id'                => 'messageID',
+        'x-priority'                => 'priority',
+    ];
+
+    /**
+     * Returns header value
+     *
+     * @param string $name   Header name
+     * @param bool   $decode Decode the header content
+     *
+     * @param string|null Header content
+     */
+    public function get($name, $decode = true)
+    {
+        $name  = strtolower($name);
+        $value = null;
+
+        if (isset($this->obj_headers[$name]) && isset($this->{$this->obj_headers[$name]})) {
+            $value = $this->{$this->obj_headers[$name]};
+        }
+        else if (isset($this->others[$name])) {
+            $value = $this->others[$name];
+        }
+
+        if ($decode && $value !== null) {
+            if (is_array($value)) {
+                foreach ($value as $key => $val) {
+                    $val         = rcube_mime::decode_header($val, $this->charset);
+                    $value[$key] = rcube_charset::clean($val);
+                }
+            }
+            else {
+                $value = rcube_mime::decode_header($value, $this->charset);
+                $value = rcube_charset::clean($value);
+            }
+        }
+
+        return $value;
+    }
+
+    /**
+     * Sets header value
+     *
+     * @param string $name  Header name
+     * @param string $value Header content
+     */
+    public function set($name, $value)
+    {
+        $name = strtolower($name);
+
+        if (isset($this->obj_headers[$name])) {
+            $this->{$this->obj_headers[$name]} = $value;
+        }
+        else {
+            $this->others[$name] = $value;
+        }
+    }
+
+    /**
+     * Factory method to instantiate headers from a data array
+     *
+     * @param array $arr Hash array with header values
+     *
+     * @return rcube_message_header instance filled with headers values
+     */
+    public static function from_array($arr)
+    {
+        $obj = new rcube_message_header;
+        foreach ($arr as $k => $v) {
+            $obj->set($k, $v);
+        }
+
+        return $obj;
+    }
+}
+
+
+/**
+ * Class for sorting an array of rcube_message_header objects in a predetermined order.
+ *
+ * @package    Framework
+ * @subpackage Storage
+ */
+class rcube_message_header_sorter
+{
+    /** @var array Message UIDs */
+    private $uids = [];
+
+
+    /**
+     * Set the predetermined sort order.
+     *
+     * @param array $index  Numerically indexed array of IMAP UIDs
+     */
+    function set_index($index)
+    {
+        $index = array_flip($index);
+
+        $this->uids = $index;
+    }
+
+    /**
+     * Sort the array of header objects
+     *
+     * @param array $headers Array of rcube_message_header objects indexed by UID
+     */
+    function sort_headers(&$headers)
+    {
+        uksort($headers, [$this, "compare_uids"]);
+    }
+
+    /**
+     * Sort method called by uksort()
+     *
+     * @param int $a Array key (UID)
+     * @param int $b Array key (UID)
+     */
+    function compare_uids($a, $b)
+    {
+        // then find each sequence number in my ordered list
+        $posa = isset($this->uids[$a]) ? intval($this->uids[$a]) : -1;
+        $posb = isset($this->uids[$b]) ? intval($this->uids[$b]) : -1;
+
+        // return the relative position as the comparison value
+        return $posa - $posb;
+    }
+}
diff --git a/src/include/rcube_mime.php b/src/include/rcube_mime.php
new file mode 100644
index 00000000..cb81be72
--- /dev/null
+++ b/src/include/rcube_mime.php
@@ -0,0 +1,992 @@
+<?php
+
+/**
+ +-----------------------------------------------------------------------+
+ | This file is part of the Roundcube Webmail client                     |
+ |                                                                       |
+ | Copyright (C) The Roundcube Dev Team                                  |
+ | Copyright (C) Kolab Systems AG                                        |
+ |                                                                       |
+ | Licensed under the GNU General Public License version 3 or            |
+ | any later version with exceptions for skins & plugins.                |
+ | See the README file for a full license statement.                     |
+ |                                                                       |
+ | PURPOSE:                                                              |
+ |   MIME message parsing utilities                                      |
+ +-----------------------------------------------------------------------+
+ | Author: Thomas Bruederli <roundcube@gmail.com>                        |
+ | Author: Aleksander Machniak <alec@alec.pl>                            |
+ +-----------------------------------------------------------------------+
+*/
+
+/**
+ * Class for parsing MIME messages
+ *
+ * @package    Framework
+ * @subpackage Storage
+ */
+class rcube_mime
+{
+    private static $default_charset;
+
+
+    /**
+     * Object constructor.
+     */
+    function __construct($default_charset = null)
+    {
+        self::$default_charset = $default_charset;
+    }
+
+    /**
+     * Returns message/object character set name
+     *
+     * @return string Character set name
+     */
+    public static function get_charset()
+    {
+        if (self::$default_charset) {
+            return self::$default_charset;
+        }
+
+        if ($charset = rcube::get_instance()->config->get('default_charset')) {
+            return $charset;
+        }
+
+        return RCUBE_CHARSET;
+    }
+
+    /**
+     * Parse the given raw message source and return a structure
+     * of rcube_message_part objects.
+     *
+     * It makes use of the rcube_mime_decode library
+     *
+     * @param string $raw_body The message source
+     *
+     * @return object rcube_message_part The message structure
+     */
+    public static function parse_message($raw_body)
+    {
+        $conf = [
+            'include_bodies'  => true,
+            'decode_bodies'   => true,
+            'decode_headers'  => false,
+            'default_charset' => self::get_charset(),
+        ];
+
+        $mime = new rcube_mime_decode($conf);
+
+        return $mime->decode($raw_body);
+    }
+
+    /**
+     * Split an address list into a structured array list
+     *
+     * @param string|array $input    Input string (or list of strings)
+     * @param int          $max      List only this number of addresses
+     * @param bool         $decode   Decode address strings
+     * @param string       $fallback Fallback charset if none specified
+     * @param bool         $addronly Return flat array with e-mail addresses only
+     *
+     * @return array Indexed list of addresses
+     */
+    static function decode_address_list($input, $max = null, $decode = true, $fallback = null, $addronly = false)
+    {
+        // A common case when the same header is used many times in a mail message
+        if (is_array($input)) {
+            $input = implode(', ', $input);
+        }
+
+        $a   = self::parse_address_list($input, $decode, $fallback);
+        $out = [];
+        $j   = 0;
+
+        // Special chars as defined by RFC 822 need to in quoted string (or escaped).
+        $special_chars = '[\(\)\<\>\\\.\[\]@,;:"]';
+
+        if (!is_array($a)) {
+            return $out;
+        }
+
+        foreach ($a as $val) {
+            $j++;
+            $address = trim($val['address']);
+
+            if ($addronly) {
+                $out[$j] = $address;
+            }
+            else {
+                $name   = trim($val['name']);
+                $string = '';
+
+                if ($name && $address && $name != $address) {
+                    $string = sprintf('%s <%s>', preg_match("/$special_chars/", $name) ? '"'.addcslashes($name, '"').'"' : $name, $address);
+                }
+                else if ($address) {
+                    $string = $address;
+                }
+                else if ($name) {
+                    $string = $name;
+                }
+
+                $out[$j] = ['name' => $name, 'mailto' => $address, 'string' => $string];
+            }
+
+            if ($max && $j == $max) {
+                break;
+            }
+        }
+
+        return $out;
+    }
+
+    /**
+     * Decode a message header value
+     *
+     * @param string  $input    Header value
+     * @param string  $fallback Fallback charset if none specified
+     *
+     * @return string Decoded string
+     */
+    public static function decode_header($input, $fallback = null)
+    {
+        $str = self::decode_mime_string((string)$input, $fallback);
+
+        return $str;
+    }
+
+    /**
+     * Decode a mime-encoded string to internal charset
+     *
+     * @param string $input    Header value
+     * @param string $fallback Fallback charset if none specified
+     *
+     * @return string Decoded string
+     */
+    public static function decode_mime_string($input, $fallback = null)
+    {
+        $default_charset = $fallback ?: self::get_charset();
+
+        // rfc: all line breaks or other characters not found
+        // in the Base64 Alphabet must be ignored by decoding software
+        // delete all blanks between MIME-lines, differently we can
+        // receive unnecessary blanks and broken utf-8 symbols
+        $input = preg_replace("/\?=\s+=\?/", '?==?', $input);
+
+        // encoded-word regexp
+        $re = '/=\?([^?]+)\?([BbQq])\?([^\n]*?)\?=/';
+
+        // Find all RFC2047's encoded words
+        if (preg_match_all($re, $input, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER)) {
+            // Initialize variables
+            $tmp   = [];
+            $out   = '';
+            $start = 0;
+
+            foreach ($matches as $idx => $m) {
+                $pos      = $m[0][1];
+                $charset  = $m[1][0];
+                $encoding = $m[2][0];
+                $text     = $m[3][0];
+                $length   = strlen($m[0][0]);
+
+                // Append everything that is before the text to be decoded
+                if ($start != $pos) {
+                    $substr = substr($input, $start, $pos-$start);
+                    $out   .= rcube_charset::convert($substr, $default_charset);
+                    $start  = $pos;
+                }
+                $start += $length;
+
+                // Per RFC2047, each string part "MUST represent an integral number
+                // of characters . A multi-octet character may not be split across
+                // adjacent encoded-words." However, some mailers break this, so we
+                // try to handle characters spanned across parts anyway by iterating
+                // through and aggregating sequential encoded parts with the same
+                // character set and encoding, then perform the decoding on the
+                // aggregation as a whole.
+
+                $tmp[] = $text;
+                if (!empty($matches[$idx+1]) && ($next_match = $matches[$idx+1])) {
+                    if ($next_match[0][1] == $start
+                        && $next_match[1][0] == $charset
+                        && $next_match[2][0] == $encoding
+                    ) {
+                        continue;
+                    }
+                }
+
+                $count = count($tmp);
+                $text  = '';
+
+                // Decode and join encoded-word's chunks
+                if ($encoding == 'B' || $encoding == 'b') {
+                    $rest  = '';
+                    // base64 must be decoded a segment at a time.
+                    // However, there are broken implementations that continue
+                    // in the following word, we'll handle that (#6048)
+                    for ($i=0; $i<$count; $i++) {
+                        $chunk  = $rest . $tmp[$i];
+                        $length = strlen($chunk);
+                        if ($length % 4) {
+                            $length = floor($length / 4) * 4;
+                            $rest   = substr($chunk, $length);
+                            $chunk  = substr($chunk, 0, $length);
+                        }
+
+                        $text .= base64_decode($chunk);
+                    }
+                }
+                else { // if ($encoding == 'Q' || $encoding == 'q') {
+                    // quoted printable can be combined and processed at once
+                    for ($i=0; $i<$count; $i++) {
+                        $text .= $tmp[$i];
+                    }
+
+                    $text = str_replace('_', ' ', $text);
+                    $text = quoted_printable_decode($text);
+                }
+
+                $out .= rcube_charset::convert($text, $charset);
+                $tmp = [];
+            }
+
+            // add the last part of the input string
+            if ($start != strlen($input)) {
+                $out .= rcube_charset::convert(substr($input, $start), $default_charset);
+            }
+
+            // return the results
+            return $out;
+        }
+
+        // no encoding information, use fallback
+        return rcube_charset::convert($input, $default_charset);
+    }
+
+    /**
+     * Decode a mime part
+     *
+     * @param string $input    Input string
+     * @param string $encoding Part encoding
+     *
+     * @return string Decoded string
+     */
+    public static function decode($input, $encoding = '7bit')
+    {
+        switch (strtolower($encoding)) {
+        case 'quoted-printable':
+            return quoted_printable_decode($input);
+        case 'base64':
+            return base64_decode($input);
+        case 'x-uuencode':
+        case 'x-uue':
+        case 'uue':
+        case 'uuencode':
+            return convert_uudecode($input);
+        case '7bit':
+        default:
+            return $input;
+        }
+    }
+
+    /**
+     * Split RFC822 header string into an associative array
+     */
+    public static function parse_headers($headers)
+    {
+        $result  = [];
+        $headers = preg_replace('/\r?\n(\t| )+/', ' ', $headers);
+        $lines   = explode("\n", $headers);
+        $count   = count($lines);
+
+        for ($i=0; $i<$count; $i++) {
+            if ($p = strpos($lines[$i], ': ')) {
+                $field = strtolower(substr($lines[$i], 0, $p));
+                $value = trim(substr($lines[$i], $p+1));
+                if (!empty($value)) {
+                    $result[$field] = $value;
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * E-mail address list parser
+     */
+    private static function parse_address_list($str, $decode = true, $fallback = null)
+    {
+        // remove any newlines and carriage returns before
+        $str = $str === null ? null : preg_replace('/\r?\n(\s|\t)?/', ' ', $str);
+
+        // extract list items, remove comments
+        $str = self::explode_header_string(',;', $str, true);
+
+        // simplified regexp, supporting quoted local part
+        $email_rx = '([^\s:]+|("\s*(?:[^"\f\n\r\t\v\b\s]+\s*)+"))@\S+';
+
+        $result = [];
+
+        foreach ($str as $key => $val) {
+            $name    = '';
+            $address = '';
+            $val     = trim($val);
+
+            // First token might be a group name, ignore it
+            $tokens = self::explode_header_string(' ', $val);
+            if (isset($tokens[0]) && $tokens[0][strlen($tokens[0])-1] == ':') {
+                $val = substr($val, strlen($tokens[0]));
+            }
+
+            if (preg_match('/(.*)<('.$email_rx.')$/', $val, $m)) {
+                // Note: There are cases like "Test<test@domain.tld" with no closing bracket,
+                // therefor we do not include it in the regexp above, but we have to
+                // remove it later, because $email_rx will catch it (#8164)
+                $address = rtrim($m[2], '>');
+                $name    = trim($m[1]);
+            }
+            else if (preg_match('/^('.$email_rx.')$/', $val, $m)) {
+                $address = $m[1];
+                $name    = '';
+            }
+            // special case (#1489092)
+            else if (preg_match('/(\s*<MAILER-DAEMON>)$/', $val, $m)) {
+                $address = 'MAILER-DAEMON';
+                $name    = substr($val, 0, -strlen($m[1]));
+            }
+            else if (preg_match('/('.$email_rx.')/', $val, $m)) {
+                $name = $m[1];
+            }
+            else {
+                $name = $val;
+            }
+
+            // unquote and/or decode name
+            if ($name) {
+                // An unquoted name ending with colon is a address group name, ignore it
+                if ($name[strlen($name)-1] == ':') {
+                    $name = '';
+                }
+
+                if (strlen($name) > 1 && $name[0] == '"' && $name[strlen($name)-1] == '"') {
+                    $name = substr($name, 1, -1);
+                    $name = stripslashes($name);
+                }
+
+                if ($decode) {
+                    $name = self::decode_header($name, $fallback);
+                    // some clients encode addressee name with quotes around it
+                    if (strlen($name) > 1 && $name[0] == '"' && $name[strlen($name)-1] == '"') {
+                        $name = substr($name, 1, -1);
+                    }
+                }
+            }
+
+            if (!$address && $name) {
+                $address = $name;
+                $name    = '';
+            }
+
+            if ($address) {
+                $address      = self::fix_email($address);
+                $result[$key] = ['name' => $name, 'address' => $address];
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Explodes header (e.g. address-list) string into array of strings
+     * using specified separator characters with proper handling
+     * of quoted-strings and comments (RFC2822)
+     *
+     * @param string $separator       String containing separator characters
+     * @param string $str             Header string
+     * @param bool   $remove_comments Enable to remove comments
+     *
+     * @return array Header items
+     */
+    public static function explode_header_string($separator, $str, $remove_comments = false)
+    {
+        $length  = strlen($str);
+        $result  = [];
+        $quoted  = false;
+        $comment = 0;
+        $out     = '';
+
+        for ($i=0; $i<$length; $i++) {
+            // we're inside a quoted string
+            if ($quoted) {
+                if ($str[$i] == '"') {
+                    $quoted = false;
+                }
+                else if ($str[$i] == "\\") {
+                    if ($comment <= 0) {
+                        $out .= "\\";
+                    }
+                    $i++;
+                }
+            }
+            // we are inside a comment string
+            else if ($comment > 0) {
+                if ($str[$i] == ')') {
+                    $comment--;
+                }
+                else if ($str[$i] == '(') {
+                    $comment++;
+                }
+                else if ($str[$i] == "\\") {
+                    $i++;
+                }
+                continue;
+            }
+            // separator, add to result array
+            else if (strpos($separator, $str[$i]) !== false) {
+                if ($out) {
+                    $result[] = $out;
+                }
+                $out = '';
+                continue;
+            }
+            // start of quoted string
+            else if ($str[$i] == '"') {
+                $quoted = true;
+            }
+            // start of comment
+            else if ($remove_comments && $str[$i] == '(') {
+                $comment++;
+            }
+
+            if ($comment <= 0) {
+                $out .= $str[$i];
+            }
+        }
+
+        if ($out && $comment <= 0) {
+            $result[] = $out;
+        }
+
+        return $result;
+    }
+
+    /**
+     * Interpret a format=flowed message body according to RFC 2646
+     *
+     * @param string $text  Raw body formatted as flowed text
+     * @param string $mark  Mark each flowed line with specified character
+     * @param bool   $delsp Remove the trailing space of each flowed line
+     *
+     * @return string Interpreted text with unwrapped lines and stuffed space removed
+     */
+    public static function unfold_flowed($text, $mark = null, $delsp = false)
+    {
+        $text    = preg_split('/\r?\n/', $text);
+        $last    = -1;
+        $q_level = 0;
+        $marks   = [];
+
+        foreach ($text as $idx => $line) {
+            if ($q = strspn($line, '>')) {
+                // remove quote chars
+                $line = substr($line, $q);
+                // remove (optional) space-staffing
+                if (isset($line[0]) && $line[0] === ' ') {
+                    $line = substr($line, 1);
+                }
+
+                // The same paragraph (We join current line with the previous one) when:
+                // - the same level of quoting
+                // - previous line was flowed
+                // - previous line contains more than only one single space (and quote char(s))
+                if ($q == $q_level
+                    && isset($text[$last]) && $text[$last][strlen($text[$last])-1] == ' '
+                    && !preg_match('/^>+ {0,1}$/', $text[$last])
+                ) {
+                    if ($delsp) {
+                        $text[$last] = substr($text[$last], 0, -1);
+                    }
+                    $text[$last] .= $line;
+                    unset($text[$idx]);
+
+                    if ($mark) {
+                        $marks[$last] = true;
+                    }
+                }
+                else {
+                    $last = $idx;
+                }
+            }
+            else {
+                if ($line == '-- ') {
+                    $last = $idx;
+                }
+                else {
+                    // remove space-stuffing
+                    if (isset($line[0]) && $line[0] === ' ') {
+                        $line = substr($line, 1);
+                    }
+
+                    $last_len = isset($text[$last]) ? strlen($text[$last]) : 0;
+
+                    if (
+                        $last_len && $line && !$q_level && $text[$last] != '-- '
+                        && isset($text[$last][$last_len-1]) && $text[$last][$last_len-1] == ' '
+                    ) {
+                        if ($delsp) {
+                            $text[$last] = substr($text[$last], 0, -1);
+                        }
+                        $text[$last] .= $line;
+                        unset($text[$idx]);
+
+                        if ($mark) {
+                            $marks[$last] = true;
+                        }
+                    }
+                    else {
+                        $text[$idx] = $line;
+                        $last = $idx;
+                    }
+                }
+            }
+            $q_level = $q;
+        }
+
+        if (!empty($marks)) {
+            foreach (array_keys($marks) as $mk) {
+                $text[$mk] = $mark . $text[$mk];
+            }
+        }
+
+        return implode("\r\n", $text);
+    }
+
+    /**
+     * Wrap the given text to comply with RFC 2646
+     *
+     * @param string $text    Text to wrap
+     * @param int    $length  Length
+     * @param string $charset Character encoding of $text
+     *
+     * @return string Wrapped text
+     */
+    public static function format_flowed($text, $length = 72, $charset = null)
+    {
+        $text = preg_split('/\r?\n/', $text);
+
+        foreach ($text as $idx => $line) {
+            if ($line != '-- ') {
+                if ($level = strspn($line, '>')) {
+                    // remove quote chars
+                    $line = substr($line, $level);
+                    // remove (optional) space-staffing and spaces before the line end
+                    $line = rtrim($line, ' ');
+                    if (isset($line[0]) && $line[0] === ' ') {
+                        $line = substr($line, 1);
+                    }
+
+                    $prefix = str_repeat('>', $level) . ' ';
+                    $line   = $prefix . self::wordwrap($line, $length - $level - 2, " \r\n$prefix", false, $charset);
+                }
+                else if ($line) {
+                    $line = self::wordwrap(rtrim($line), $length - 2, " \r\n", false, $charset);
+                    // space-stuffing
+                    $line = preg_replace('/(^|\r\n)(From| |>)/', '\\1 \\2', $line);
+                }
+
+                $text[$idx] = $line;
+            }
+        }
+
+        return implode("\r\n", $text);
+    }
+
+    /**
+     * Improved wordwrap function with multibyte support.
+     * The code is based on Zend_Text_MultiByte::wordWrap().
+     *
+     * @param string $string      Text to wrap
+     * @param int    $width       Line width
+     * @param string $break       Line separator
+     * @param bool   $cut         Enable to cut word
+     * @param string $charset     Charset of $string
+     * @param bool   $wrap_quoted When enabled quoted lines will not be wrapped
+     *
+     * @return string Text
+     */
+    public static function wordwrap($string, $width = 75, $break = "\n", $cut = false, $charset = null, $wrap_quoted = true)
+    {
+        // Note: Never try to use iconv instead of mbstring functions here
+        //       Iconv's substr/strlen are 100x slower (#1489113)
+
+        if ($charset && $charset != RCUBE_CHARSET) {
+            $charset = rcube_charset::parse_charset($charset);
+            mb_internal_encoding($charset);
+        }
+
+        // Convert \r\n to \n, this is our line-separator
+        $string       = str_replace("\r\n", "\n", $string);
+        $separator    = "\n"; // must be 1 character length
+        $result       = [];
+
+        while (($stringLength = mb_strlen($string)) > 0) {
+            $breakPos = mb_strpos($string, $separator, 0);
+
+            // quoted line (do not wrap)
+            if ($wrap_quoted && $string[0] == '>') {
+                if ($breakPos === $stringLength - 1 || $breakPos === false) {
+                    $subString = $string;
+                    $cutLength = null;
+                }
+                else {
+                    $subString = mb_substr($string, 0, $breakPos);
+                    $cutLength = $breakPos + 1;
+                }
+            }
+            // next line found and current line is shorter than the limit
+            else if ($breakPos !== false && $breakPos < $width) {
+                if ($breakPos === $stringLength - 1) {
+                    $subString = $string;
+                    $cutLength = null;
+                }
+                else {
+                    $subString = mb_substr($string, 0, $breakPos);
+                    $cutLength = $breakPos + 1;
+                }
+            }
+            else {
+                $subString = mb_substr($string, 0, $width);
+
+                // last line
+                if ($breakPos === false && $subString === $string) {
+                    $cutLength = null;
+                }
+                else {
+                    $nextChar = mb_substr($string, $width, 1);
+
+                    if ($nextChar === ' ' || $nextChar === $separator) {
+                        $afterNextChar = mb_substr($string, $width + 1, 1);
+
+                        // Note: mb_substr() does never return False
+                        if ($afterNextChar === false || $afterNextChar === '') {
+                            $subString .= $nextChar;
+                        }
+
+                        $cutLength = mb_strlen($subString) + 1;
+                    }
+                    else {
+                        $spacePos = mb_strrpos($subString, ' ', 0);
+
+                        if ($spacePos !== false) {
+                            $subString = mb_substr($subString, 0, $spacePos);
+                            $cutLength = $spacePos + 1;
+                        }
+                        else if ($cut === false) {
+                            $spacePos = mb_strpos($string, ' ', 0);
+
+                            if ($spacePos !== false && ($breakPos === false || $spacePos < $breakPos)) {
+                                $subString = mb_substr($string, 0, $spacePos);
+                                $cutLength = $spacePos + 1;
+                            }
+                            else if ($breakPos === false) {
+                                $subString = $string;
+                                $cutLength = null;
+                            }
+                            else {
+                                $subString = mb_substr($string, 0, $breakPos);
+                                $cutLength = $breakPos + 1;
+                            }
+                        }
+                        else {
+                            $cutLength = $width;
+                        }
+                    }
+                }
+            }
+
+            $result[] = $subString;
+
+            if ($cutLength !== null) {
+                $string = mb_substr($string, $cutLength, ($stringLength - $cutLength));
+            }
+            else {
+                break;
+            }
+        }
+
+        if ($charset && $charset != RCUBE_CHARSET) {
+            mb_internal_encoding(RCUBE_CHARSET);
+        }
+
+        return implode($break, $result);
+    }
+
+    /**
+     * A method to guess the mime_type of an attachment.
+     *
+     * @param string  $path        Path to the file or file contents
+     * @param string  $name        File name (with suffix)
+     * @param string  $failover    Mime type supplied for failover
+     * @param bool    $is_stream   Set to True if $path contains file contents
+     * @param bool    $skip_suffix Set to True if the config/mimetypes.php map should be ignored
+     *
+     * @return string
+     * @author Till Klampaeckel <till@php.net>
+     * @see    http://de2.php.net/manual/en/ref.fileinfo.php
+     * @see    http://de2.php.net/mime_content_type
+     */
+    public static function file_content_type($path, $name, $failover = 'application/octet-stream', $is_stream = false, $skip_suffix = false)
+    {
+        $mime_type = null;
+        $config    = rcube::get_instance()->config;
+
+        // Detect mimetype using filename extension
+        if (!$skip_suffix) {
+            $mime_type = self::file_ext_type($name);
+        }
+
+        // try fileinfo extension if available
+        if (!$mime_type && function_exists('finfo_open')) {
+            $mime_magic = $config->get('mime_magic');
+            // null as a 2nd argument should be the same as no argument
+            // this however is not true on all systems/versions
+            if ($mime_magic) {
+                $finfo = finfo_open(FILEINFO_MIME, $mime_magic);
+            }
+            else {
+                $finfo = finfo_open(FILEINFO_MIME);
+            }
+
+            if ($finfo) {
+                $func      = $is_stream ? 'finfo_buffer' : 'finfo_file';
+                $mime_type = $func($finfo, $path, FILEINFO_MIME_TYPE);
+                finfo_close($finfo);
+            }
+        }
+
+        // try PHP's mime_content_type
+        if (!$mime_type && !$is_stream && function_exists('mime_content_type')) {
+            $mime_type = @mime_content_type($path);
+        }
+
+        // fall back to user-submitted string
+        if (!$mime_type) {
+            $mime_type = $failover;
+        }
+
+        return $mime_type;
+    }
+
+    /**
+     * File type detection based on file name only.
+     *
+     * @param string $filename Path to the file or file contents
+     *
+     * @return string|null Mimetype label
+     */
+    public static function file_ext_type($filename)
+    {
+        static $mime_ext = [];
+
+        if (empty($mime_ext)) {
+            foreach (rcube::get_instance()->config->resolve_paths('mimetypes.php') as $fpath) {
+                $mime_ext = array_merge($mime_ext, (array) @include($fpath));
+            }
+        }
+
+        // use file name suffix with hard-coded mime-type map
+        if (!empty($mime_ext) && $filename) {
+            $ext = strtolower(pathinfo($filename, PATHINFO_EXTENSION));
+            if ($ext && !empty($mime_ext[$ext])) {
+                return $mime_ext[$ext];
+            }
+        }
+    }
+
+    /**
+     * Get mimetype => file extension mapping
+     *
+     * @param string Mime-Type to get extensions for
+     *
+     * @return array List of extensions matching the given mimetype or a hash array
+     *               with ext -> mimetype mappings if $mimetype is not given
+     */
+    public static function get_mime_extensions($mimetype = null)
+    {
+        static $mime_types, $mime_extensions;
+
+        // return cached data
+        if (is_array($mime_types)) {
+            return $mimetype ? (isset($mime_types[$mimetype]) ? $mime_types[$mimetype] : []) : $mime_extensions;
+        }
+
+        // load mapping file
+        $file_paths = [];
+
+        if ($mime_types = rcube::get_instance()->config->get('mime_types')) {
+            $file_paths[] = $mime_types;
+        }
+
+        // try common locations
+        if (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN') {
+            $file_paths[] = 'C:/xampp/apache/conf/mime.types.';
+        }
+        else {
+            $file_paths[] = '/etc/mime.types';
+            $file_paths[] = '/etc/httpd/mime.types';
+            $file_paths[] = '/etc/httpd2/mime.types';
+            $file_paths[] = '/etc/apache/mime.types';
+            $file_paths[] = '/etc/apache2/mime.types';
+            $file_paths[] = '/etc/nginx/mime.types';
+            $file_paths[] = '/usr/local/etc/httpd/conf/mime.types';
+            $file_paths[] = '/usr/local/etc/apache/conf/mime.types';
+            $file_paths[] = '/usr/local/etc/apache24/mime.types';
+        }
+
+        $mime_types      = [];
+        $mime_extensions = [];
+        $lines = [];
+        $regex = "/([\w\+\-\.\/]+)\s+([\w\s]+)/i";
+
+        foreach ($file_paths as $fp) {
+            if (@is_readable($fp)) {
+                $lines = file($fp, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
+                break;
+            }
+        }
+
+        foreach ($lines as $line) {
+             // skip comments or mime types w/o any extensions
+            if ($line[0] == '#' || !preg_match($regex, $line, $matches)) {
+                continue;
+            }
+
+            $mime = $matches[1];
+
+            foreach (explode(' ', $matches[2]) as $ext) {
+                $ext = trim($ext);
+                $mime_types[$mime][]   = $ext;
+                $mime_extensions[$ext] = $mime;
+            }
+        }
+
+        // fallback to some well-known types most important for daily emails
+        if (empty($mime_types)) {
+            foreach (rcube::get_instance()->config->resolve_paths('mimetypes.php') as $fpath) {
+                $mime_extensions = array_merge($mime_extensions, (array) @include($fpath));
+            }
+
+            foreach ($mime_extensions as $ext => $mime) {
+                $mime_types[$mime][] = $ext;
+            }
+        }
+
+        // Add some known aliases that aren't included by some mime.types (#1488891)
+        // the order is important here so standard extensions have higher prio
+        $aliases = [
+            'image/gif'      => ['gif'],
+            'image/png'      => ['png'],
+            'image/x-png'    => ['png'],
+            'image/jpeg'     => ['jpg', 'jpeg', 'jpe'],
+            'image/jpg'      => ['jpg', 'jpeg', 'jpe'],
+            'image/pjpeg'    => ['jpg', 'jpeg', 'jpe'],
+            'image/tiff'     => ['tif'],
+            'image/bmp'      => ['bmp'],
+            'image/x-ms-bmp' => ['bmp'],
+            'message/rfc822' => ['eml'],
+            'text/x-mail'    => ['eml'],
+        ];
+
+        foreach ($aliases as $mime => $exts) {
+            if (isset($mime_types[$mime])) {
+                $mime_types[$mime] = array_unique(array_merge((array) $mime_types[$mime], $exts));
+            }
+            else {
+                $mime_types[$mime] = $exts;
+            }
+
+            foreach ($exts as $ext) {
+                if (!isset($mime_extensions[$ext])) {
+                    $mime_extensions[$ext] = $mime;
+                }
+            }
+        }
+
+        if ($mimetype) {
+            return !empty($mime_types[$mimetype]) ? $mime_types[$mimetype] : [];
+        }
+
+        return $mime_extensions;
+    }
+
+    /**
+     * Detect image type of the given binary data by checking magic numbers.
+     *
+     * @param string $data  Binary file content
+     *
+     * @return string Detected mime-type or jpeg as fallback
+     */
+    public static function image_content_type($data)
+    {
+        $type = 'jpeg';
+        if      (preg_match('/^\x89\x50\x4E\x47/', $data)) $type = 'png';
+        else if (preg_match('/^\x47\x49\x46\x38/', $data)) $type = 'gif';
+        else if (preg_match('/^\x00\x00\x01\x00/', $data)) $type = 'ico';
+    //  else if (preg_match('/^\xFF\xD8\xFF\xE0/', $data)) $type = 'jpeg';
+
+        return 'image/' . $type;
+    }
+
+    /**
+     * Try to fix invalid email addresses
+     */
+    public static function fix_email($email)
+    {
+        $parts = rcube_utils::explode_quoted_string('@', $email);
+
+        foreach ($parts as $idx => $part) {
+            // remove redundant quoting (#1490040)
+            if ($part[0] == '"' && preg_match('/^"([a-zA-Z0-9._+=-]+)"$/', $part, $m)) {
+                $parts[$idx] = $m[1];
+            }
+        }
+
+        return implode('@', $parts);
+    }
+
+    /**
+     * Fix mimetype name.
+     *
+     * @param string $type Mimetype
+     *
+     * @return string Mimetype
+     */
+    public static function fix_mimetype($type)
+    {
+        $type    = strtolower(trim($type));
+        $aliases = [
+            'image/x-ms-bmp' => 'image/bmp',        // #4771
+            'pdf'            => 'application/pdf',  // #6816
+        ];
+
+        if (!empty($aliases[$type])) {
+            return $aliases[$type];
+        }
+
+        // Some versions of Outlook create garbage Content-Type:
+        // application/pdf.A520491B_3BF7_494D_8855_7FAC2C6C0608
+        if (preg_match('/^application\/pdf.+/', $type)) {
+            return 'application/pdf';
+        }
+
+        // treat image/pjpeg (image/pjpg, image/jpg) as image/jpeg (#4196)
+        if (preg_match('/^image\/p?jpe?g$/', $type)) {
+            return 'image/jpeg';
+        }
+
+        return $type;
+    }
+}
diff --git a/src/include/rcube_result_index.php b/src/include/rcube_result_index.php
new file mode 100644
index 00000000..c67bd5b9
--- /dev/null
+++ b/src/include/rcube_result_index.php
@@ -0,0 +1,463 @@
+<?php
+
+/**
+ +-----------------------------------------------------------------------+
+ | This file is part of the Roundcube Webmail client                     |
+ |                                                                       |
+ | Copyright (C) The Roundcube Dev Team                                  |
+ | Copyright (C) Kolab Systems AG                                        |
+ |                                                                       |
+ | Licensed under the GNU General Public License version 3 or            |
+ | any later version with exceptions for skins & plugins.                |
+ | See the README file for a full license statement.                     |
+ |                                                                       |
+ | PURPOSE:                                                              |
+ |   SORT/SEARCH/ESEARCH response handler                                |
+ +-----------------------------------------------------------------------+
+ | Author: Thomas Bruederli <roundcube@gmail.com>                        |
+ | Author: Aleksander Machniak <alec@alec.pl>                            |
+ +-----------------------------------------------------------------------+
+*/
+
+/**
+ * Get first element from an array
+ *
+ * @param array $array Input array
+ *
+ * @return mixed First element if found, Null otherwise
+ */
+function array_first($array)
+{
+    if (is_array($array)) {
+        reset($array);
+        foreach ($array as $element) {
+            return $element;
+        }
+    }
+}
+
+/**
+ * Class for accessing IMAP's SORT/SEARCH/ESEARCH result
+ *
+ * @package    Framework
+ * @subpackage Storage
+ */
+class rcube_result_index
+{
+    public $incomplete = false;
+
+    protected $raw_data;
+    protected $mailbox;
+    protected $meta   = [];
+    protected $params = [];
+    protected $order  = 'ASC';
+
+    const SEPARATOR_ELEMENT = ' ';
+
+
+    /**
+     * Object constructor.
+     */
+    public function __construct($mailbox = null, $data = null, $order = null)
+    {
+        $this->mailbox = $mailbox;
+        $this->order   = $order == 'DESC' ? 'DESC' : 'ASC';
+        $this->init($data);
+    }
+
+    /**
+     * Initializes object with SORT command response
+     *
+     * @param string $data IMAP response string
+     */
+    public function init($data = null)
+    {
+        $this->meta = [];
+
+        $data = explode('*', (string)$data);
+
+        // ...skip unilateral untagged server responses
+        for ($i=0, $len=count($data); $i<$len; $i++) {
+            $data_item = &$data[$i];
+            if (preg_match('/^ SORT/i', $data_item)) {
+                // valid response, initialize raw_data for is_error()
+                $this->raw_data = '';
+                $data_item = substr($data_item, 5);
+                break;
+            }
+            else if (preg_match('/^ (E?SEARCH)/i', $data_item, $m)) {
+                // valid response, initialize raw_data for is_error()
+                $this->raw_data = '';
+                $data_item = substr($data_item, strlen($m[0]));
+
+                if (strtoupper($m[1]) == 'ESEARCH') {
+                    $data_item = trim($data_item);
+                    // remove MODSEQ response
+                    if (preg_match('/\(MODSEQ ([0-9]+)\)$/i', $data_item, $m)) {
+                        $data_item = substr($data_item, 0, -strlen($m[0]));
+                        $this->params['MODSEQ'] = $m[1];
+                    }
+                    // remove TAG response part
+                    if (preg_match('/^\(TAG ["a-z0-9]+\)\s*/i', $data_item, $m)) {
+                        $data_item = substr($data_item, strlen($m[0]));
+                    }
+                    // remove UID
+                    $data_item = preg_replace('/^UID\s*/i', '', $data_item);
+
+                    // ESEARCH parameters
+                    while (preg_match('/^([a-z]+) ([0-9:,]+)\s*/i', $data_item, $m)) {
+                        $param = strtoupper($m[1]);
+                        $value = $m[2];
+
+                        $this->params[$param] = $value;
+                        $data_item = substr($data_item, strlen($m[0]));
+
+                        if (in_array($param, ['COUNT', 'MIN', 'MAX'])) {
+                            $this->meta[strtolower($param)] = (int) $value;
+                        }
+                    }
+
+// @TODO: Implement compression using compressMessageSet() in __sleep() and __wakeup() ?
+// @TODO: work with compressed result?!
+                    if (isset($this->params['ALL'])) {
+                        $data_item = implode(self::SEPARATOR_ELEMENT,
+                            rcube_imap_generic::uncompressMessageSet($this->params['ALL']));
+                    }
+                }
+
+                break;
+            }
+
+            unset($data[$i]);
+        }
+
+        $data = array_filter($data);
+
+        if (empty($data)) {
+            return;
+        }
+
+        $data = array_first($data);
+        $data = trim($data);
+        $data = preg_replace('/[\r\n]/', '', $data);
+        $data = preg_replace('/\s+/', ' ', $data);
+
+        $this->raw_data = $data;
+    }
+
+    /**
+     * Checks the result from IMAP command
+     *
+     * @return bool True if the result is an error, False otherwise
+     */
+    public function is_error()
+    {
+        return $this->raw_data === null;
+    }
+
+    /**
+     * Checks if the result is empty
+     *
+     * @return bool True if the result is empty, False otherwise
+     */
+    public function is_empty()
+    {
+        return empty($this->raw_data)
+            && empty($this->meta['max']) && empty($this->meta['min']) && empty($this->meta['count']);
+    }
+
+    /**
+     * Returns number of elements in the result
+     *
+     * @return int Number of elements
+     */
+    public function count()
+    {
+        if (isset($this->meta['count'])) {
+            return $this->meta['count'];
+        }
+
+        if (empty($this->raw_data)) {
+            $this->meta['count']  = 0;
+            $this->meta['length'] = 0;
+        }
+        else {
+            $this->meta['count'] = 1 + substr_count($this->raw_data, self::SEPARATOR_ELEMENT);
+        }
+
+        return $this->meta['count'];
+    }
+
+    /**
+     * Returns number of elements in the result.
+     * Alias for count() for compatibility with rcube_result_thread
+     *
+     * @return int Number of elements
+     */
+    public function count_messages()
+    {
+        return $this->count();
+    }
+
+    /**
+     * Returns maximal message identifier in the result
+     *
+     * @return int|null Maximal message identifier
+     */
+    public function max()
+    {
+        if ($this->is_empty()) {
+            return null;
+        }
+
+        if (!isset($this->meta['max'])) {
+            $this->meta['max'] = null;
+            $all = $this->get();
+            if (!empty($all)) {
+                $this->meta['max'] = (int) max($all);
+            }
+        }
+
+        return $this->meta['max'];
+    }
+
+    /**
+     * Returns minimal message identifier in the result
+     *
+     * @return int|null Minimal message identifier
+     */
+    public function min()
+    {
+        if ($this->is_empty()) {
+            return null;
+        }
+
+        if (!isset($this->meta['min'])) {
+            $this->meta['min'] = null;
+            $all = $this->get();
+            if (!empty($all)) {
+                $this->meta['min'] = (int) min($all);
+            }
+        }
+
+        return $this->meta['min'];
+    }
+
+    /**
+     * Slices data set.
+     *
+     * @param int $offset Offset (as for PHP's array_slice())
+     * @param int $length Number of elements (as for PHP's array_slice())
+     */
+    public function slice($offset, $length)
+    {
+        $data = $this->get();
+        $data = array_slice($data, $offset, $length);
+
+        $this->meta          = [];
+        $this->meta['count'] = count($data);
+        $this->raw_data      = implode(self::SEPARATOR_ELEMENT, $data);
+    }
+
+    /**
+     * Filters data set. Removes elements not listed in $ids list.
+     *
+     * @param array $ids List of IDs to remove.
+     */
+    public function filter($ids = [])
+    {
+        $data = $this->get();
+        $data = array_intersect($data, $ids);
+
+        $this->meta          = [];
+        $this->meta['count'] = count($data);
+        $this->raw_data      = implode(self::SEPARATOR_ELEMENT, $data);
+    }
+
+    /**
+     * Reverts order of elements in the result
+     */
+    public function revert()
+    {
+        $this->order = $this->order == 'ASC' ? 'DESC' : 'ASC';
+
+        if (empty($this->raw_data)) {
+            return;
+        }
+
+        $data = $this->get();
+        $data = array_reverse($data);
+        $this->raw_data = implode(self::SEPARATOR_ELEMENT, $data);
+
+        $this->meta['pos'] = [];
+    }
+
+    /**
+     * Check if the given message ID exists in the object
+     *
+     * @param int  $msgid     Message ID
+     * @param bool $get_index When enabled element's index will be returned.
+     *                        Elements are indexed starting with 0
+     *
+     * @return mixed False if message ID doesn't exist, True if exists or
+     *               index of the element if $get_index=true
+     */
+    public function exists($msgid, $get_index = false)
+    {
+        if (empty($this->raw_data)) {
+            return false;
+        }
+
+        $msgid = (int) $msgid;
+        $begin = implode('|', ['^', preg_quote(self::SEPARATOR_ELEMENT, '/')]);
+        $end   = implode('|', ['$', preg_quote(self::SEPARATOR_ELEMENT, '/')]);
+
+        if (preg_match("/($begin)$msgid($end)/", $this->raw_data, $m,
+            $get_index ? PREG_OFFSET_CAPTURE : null)
+        ) {
+            if ($get_index) {
+                $idx = 0;
+                if (!empty($m[0][1])) {
+                    $idx = 1 + substr_count($this->raw_data, self::SEPARATOR_ELEMENT, 0, $m[0][1]);
+                }
+                // cache position of this element, so we can use it in get_element()
+                $this->meta['pos'][$idx] = (int)$m[0][1];
+
+                return $idx;
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Return all messages in the result.
+     *
+     * @return array List of message IDs
+     */
+    public function get()
+    {
+        if (empty($this->raw_data)) {
+            return [];
+        }
+
+        return explode(self::SEPARATOR_ELEMENT, $this->raw_data);
+    }
+
+    /**
+     * Return all messages in the result.
+     *
+     * @return array List of message IDs
+     */
+    public function get_compressed()
+    {
+        if (empty($this->raw_data)) {
+            return '';
+        }
+
+        return rcube_imap_generic::compressMessageSet($this->get());
+    }
+
+    /**
+     * Return result element at specified index
+     *
+     * @param int|string  $index  Element's index or "FIRST" or "LAST"
+     *
+     * @return int|null Element value
+     */
+    public function get_element($index)
+    {
+        if (empty($this->raw_data)) {
+            return null;
+        }
+
+        $count = $this->count();
+
+        // first element
+        if ($index === 0 || $index === '0' || $index === 'FIRST') {
+            $pos = strpos($this->raw_data, self::SEPARATOR_ELEMENT);
+            if ($pos === false) {
+                $result = (int) $this->raw_data;
+            }
+            else {
+                $result = (int) substr($this->raw_data, 0, $pos);
+            }
+
+            return $result;
+        }
+
+        // last element
+        if ($index === 'LAST' || $index == $count-1) {
+            $pos = strrpos($this->raw_data, self::SEPARATOR_ELEMENT);
+            if ($pos === false) {
+                $result = (int) $this->raw_data;
+            }
+            else {
+                $result = (int) substr($this->raw_data, $pos);
+            }
+
+            return $result;
+        }
+
+        // do we know the position of the element or the neighbour of it?
+        if (!empty($this->meta['pos'])) {
+            if (isset($this->meta['pos'][$index])) {
+                $pos = $this->meta['pos'][$index];
+            }
+            else if (isset($this->meta['pos'][$index-1])) {
+                $pos = strpos($this->raw_data, self::SEPARATOR_ELEMENT,
+                    $this->meta['pos'][$index-1] + 1);
+            }
+            else if (isset($this->meta['pos'][$index+1])) {
+                $pos = strrpos($this->raw_data, self::SEPARATOR_ELEMENT,
+                    $this->meta['pos'][$index+1] - $this->length() - 1);
+            }
+
+            if (isset($pos) && preg_match('/([0-9]+)/', $this->raw_data, $m, null, $pos)) {
+                return (int) $m[1];
+            }
+        }
+
+        // Finally use less effective method
+        $data = explode(self::SEPARATOR_ELEMENT, $this->raw_data);
+
+        return (int) $data[$index];
+    }
+
+    /**
+     * Returns response parameters, e.g. ESEARCH's MIN/MAX/COUNT/ALL/MODSEQ
+     * or internal data e.g. MAILBOX, ORDER
+     *
+     * @param string $param Parameter name
+     *
+     * @return array|string Response parameters or parameter value
+     */
+    public function get_parameters($param=null)
+    {
+        $params = $this->params;
+        $params['MAILBOX'] = $this->mailbox;
+        $params['ORDER']   = $this->order;
+
+        if ($param !== null) {
+            return $params[$param];
+        }
+
+        return $params;
+    }
+
+    /**
+     * Returns length of internal data representation
+     *
+     * @return int Data length
+     */
+    protected function length()
+    {
+        if (!isset($this->meta['length'])) {
+            $this->meta['length'] = strlen($this->raw_data);
+        }
+
+        return $this->meta['length'];
+    }
+}
diff --git a/src/include/rcube_utils.php b/src/include/rcube_utils.php
new file mode 100644
index 00000000..a4439afb
--- /dev/null
+++ b/src/include/rcube_utils.php
@@ -0,0 +1,1715 @@
+<?php
+
+/**
+ +-----------------------------------------------------------------------+
+ | This file is part of the Roundcube Webmail client                     |
+ |                                                                       |
+ | Copyright (C) The Roundcube Dev Team                                  |
+ | Copyright (C) Kolab Systems AG                                        |
+ |                                                                       |
+ | Licensed under the GNU General Public License version 3 or            |
+ | any later version with exceptions for skins & plugins.                |
+ | See the README file for a full license statement.                     |
+ |                                                                       |
+ | PURPOSE:                                                              |
+ |   Utility class providing common functions                            |
+ +-----------------------------------------------------------------------+
+ | Author: Thomas Bruederli <roundcube@gmail.com>                        |
+ | Author: Aleksander Machniak <alec@alec.pl>                            |
+ +-----------------------------------------------------------------------+
+*/
+
+/**
+ * Utility class providing common functions
+ *
+ * @package    Framework
+ * @subpackage Utils
+ */
+class rcube_utils
+{
+    // define constants for input reading
+    const INPUT_GET    = 1;
+    const INPUT_POST   = 2;
+    const INPUT_COOKIE = 4;
+    const INPUT_GP     = 3; // GET + POST
+    const INPUT_GPC    = 7; // GET + POST + COOKIE
+
+
+    /**
+     * A wrapper for PHP's explode() that does not throw a warning
+     * when the separator does not exist in the string
+     *
+     * @param string $separator Separator string
+     * @param string $string    The string to explode
+     *
+     * @return array Exploded string. Still an array if there's no separator in the string
+     */
+    public static function explode($separator, $string)
+    {
+        if (strpos($string, $separator) !== false) {
+            return explode($separator, $string);
+        }
+
+        return [$string, null];
+    }
+
+    /**
+     * Helper method to set a cookie with the current path and host settings
+     *
+     * @param string $name      Cookie name
+     * @param string $value     Cookie value
+     * @param int    $exp       Expiration time
+     * @param bool   $http_only HTTP Only
+     */
+    public static function setcookie($name, $value, $exp = 0, $http_only = true)
+    {
+        if (headers_sent()) {
+            return;
+        }
+
+        $attrib             = session_get_cookie_params();
+        $attrib['expires']  = $exp;
+        $attrib['secure']   = $attrib['secure'] || self::https_check();
+        $attrib['httponly'] = $http_only;
+
+        // session_get_cookie_params() return includes 'lifetime' but setcookie() does not use it, instead it uses 'expires'
+        unset($attrib['lifetime']);
+
+        if (version_compare(PHP_VERSION, '7.3.0', '>=')) {
+            // An alternative signature for setcookie supporting an options array added in PHP 7.3.0
+            setcookie($name, $value, $attrib);
+        }
+        else {
+            setcookie($name, $value, $attrib['expires'], $attrib['path'], $attrib['domain'], $attrib['secure'], $attrib['httponly']);
+        }
+    }
+
+    /**
+     * E-mail address validation.
+     *
+     * @param string $email     Email address
+     * @param bool   $dns_check True to check dns
+     *
+     * @return bool True on success, False if address is invalid
+     */
+    public static function check_email($email, $dns_check = true)
+    {
+        // Check for invalid (control) characters
+        if (preg_match('/\p{Cc}/u', $email)) {
+            return false;
+        }
+
+        // Check for length limit specified by RFC 5321 (#1486453)
+        if (strlen($email) > 254) {
+            return false;
+        }
+
+        $pos = strrpos($email, '@');
+        if (!$pos) {
+            return false;
+        }
+
+        $domain_part = substr($email, $pos + 1);
+        $local_part  = substr($email, 0, $pos);
+
+        // quoted-string, make sure all backslashes and quotes are
+        // escaped
+        if (substr($local_part, 0, 1) == '"') {
+            $local_quoted = preg_replace('/\\\\(\\\\|\")/','', substr($local_part, 1, -1));
+            if (preg_match('/\\\\|"/', $local_quoted)) {
+                return false;
+            }
+        }
+        // dot-atom portion, make sure there's no prohibited characters
+        else if (preg_match('/(^\.|\.\.|\.$)/', $local_part)
+            || preg_match('/[\\ ",:;<>@]/', $local_part)
+        ) {
+            return false;
+        }
+
+        // Validate domain part
+        if (preg_match('/^\[((IPv6:[0-9a-f:.]+)|([0-9.]+))\]$/i', $domain_part, $matches)) {
+            return self::check_ip(preg_replace('/^IPv6:/i', '', $matches[1])); // valid IPv4 or IPv6 address
+        }
+        else {
+            // If not an IP address
+            $domain_array = explode('.', $domain_part);
+            // Not enough parts to be a valid domain
+            if (count($domain_array) < 2) {
+                return false;
+            }
+
+            foreach ($domain_array as $part) {
+                if (!preg_match('/^((xn--)?([A-Za-z0-9][A-Za-z0-9-]{0,61}[A-Za-z0-9])|([A-Za-z0-9]))$/', $part)) {
+                    return false;
+                }
+            }
+
+            // last domain part (allow extended TLD)
+            $last_part = array_pop($domain_array);
+            if (strpos($last_part, 'xn--') !== 0
+                && (preg_match('/[^a-zA-Z0-9]/', $last_part) || preg_match('/^[0-9]+$/', $last_part))
+            ) {
+                return false;
+            }
+
+            $rcube = rcube::get_instance();
+
+            if (!$dns_check || !function_exists('checkdnsrr') || !$rcube->config->get('email_dns_check')) {
+                return true;
+            }
+
+            // Check DNS record(s)
+            // Note: We can't use ANY (#6581)
+            foreach (['A', 'MX', 'CNAME', 'AAAA'] as $type) {
+                if (checkdnsrr($domain_part, $type)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Validates IPv4 or IPv6 address
+     *
+     * @param string $ip IP address in v4 or v6 format
+     *
+     * @return bool True if the address is valid
+     */
+    public static function check_ip($ip)
+    {
+        return filter_var($ip, FILTER_VALIDATE_IP) !== false;
+    }
+
+    /**
+     * Replacing specials characters to a specific encoding type
+     *
+     * @param string $str      Input string
+     * @param string $enctype  Encoding type: text|html|xml|js|url
+     * @param string $mode     Replace mode for tags: show|remove|strict
+     * @param bool   $newlines Convert newlines
+     *
+     * @return string The quoted string
+     */
+    public static function rep_specialchars_output($str, $enctype = '', $mode = '', $newlines = true)
+    {
+        static $html_encode_arr = false;
+        static $js_rep_table    = false;
+        static $xml_rep_table   = false;
+
+        if (!is_string($str)) {
+            $str = strval($str);
+        }
+
+        // encode for HTML output
+        if ($enctype == 'html') {
+            if (!$html_encode_arr) {
+                $html_encode_arr = get_html_translation_table(HTML_SPECIALCHARS);
+                unset($html_encode_arr['?']);
+            }
+
+            $encode_arr = $html_encode_arr;
+
+            if ($mode == 'remove') {
+                $str = strip_tags($str);
+            }
+            else if ($mode != 'strict') {
+                // don't replace quotes and html tags
+                $ltpos = strpos($str, '<');
+                if ($ltpos !== false && strpos($str, '>', $ltpos) !== false) {
+                    unset($encode_arr['"']);
+                    unset($encode_arr['<']);
+                    unset($encode_arr['>']);
+                    unset($encode_arr['&']);
+                }
+            }
+
+            $out = strtr($str, $encode_arr);
+
+            return $newlines ? nl2br($out) : $out;
+        }
+
+        // if the replace tables for XML and JS are not yet defined
+        if ($js_rep_table === false) {
+            $js_rep_table = $xml_rep_table = [];
+            $xml_rep_table['&'] = '&amp;';
+
+            // can be increased to support more charsets
+            for ($c=160; $c<256; $c++) {
+                $xml_rep_table[chr($c)] = "&#$c;";
+            }
+
+            $xml_rep_table['"'] = '&quot;';
+            $js_rep_table['"']  = '\\"';
+            $js_rep_table["'"]  = "\\'";
+            $js_rep_table["\\"] = "\\\\";
+            // Unicode line and paragraph separators (#1486310)
+            $js_rep_table[chr(hexdec('E2')).chr(hexdec('80')).chr(hexdec('A8'))] = '&#8232;';
+            $js_rep_table[chr(hexdec('E2')).chr(hexdec('80')).chr(hexdec('A9'))] = '&#8233;';
+        }
+
+        // encode for javascript use
+        if ($enctype == 'js') {
+            return preg_replace(["/\r?\n/", "/\r/", '/<\\//'], ['\n', '\n', '<\\/'], strtr($str, $js_rep_table));
+        }
+
+        // encode for plaintext
+        if ($enctype == 'text') {
+            return str_replace("\r\n", "\n", $mode == 'remove' ? strip_tags($str) : $str);
+        }
+
+        if ($enctype == 'url') {
+            return rawurlencode($str);
+        }
+
+        // encode for XML
+        if ($enctype == 'xml') {
+            return strtr($str, $xml_rep_table);
+        }
+
+        // no encoding given -> return original string
+        return $str;
+    }
+
+    /**
+     * Read input value and make sure it is a string.
+     *
+     * @param string $fname      Field name to read
+     * @param int    $source     Source to get value from (see self::INPUT_*)
+     * @param bool   $allow_html Allow HTML tags in field value
+     * @param string $charset    Charset to convert into
+     *
+     * @return string Request parameter value
+     * @see self::get_input_value()
+     */
+    public static function get_input_string($fname, $source, $allow_html = false, $charset = null)
+    {
+        $value = self::get_input_value($fname, $source, $allow_html, $charset);
+
+        return is_string($value) ? $value : '';
+    }
+
+    /**
+     * Read request parameter value and convert it for internal use
+     * Performs stripslashes() and charset conversion if necessary
+     *
+     * @param string $fname      Field name to read
+     * @param int    $source     Source to get value from (see self::INPUT_*)
+     * @param bool   $allow_html Allow HTML tags in field value
+     * @param string $charset    Charset to convert into
+     *
+     * @return string|array|null Request parameter value or NULL if not set
+     */
+    public static function get_input_value($fname, $source, $allow_html = false, $charset = null)
+    {
+        $value = null;
+
+        if (($source & self::INPUT_GET) && isset($_GET[$fname])) {
+            $value = $_GET[$fname];
+        }
+
+        if (($source & self::INPUT_POST) && isset($_POST[$fname])) {
+            $value = $_POST[$fname];
+        }
+
+        if (($source & self::INPUT_COOKIE) && isset($_COOKIE[$fname])) {
+            $value = $_COOKIE[$fname];
+        }
+
+        return self::parse_input_value($value, $allow_html, $charset);
+    }
+
+    /**
+     * Parse/validate input value. See self::get_input_value()
+     * Performs stripslashes() and charset conversion if necessary
+     *
+     * @param string $value      Input value
+     * @param bool   $allow_html Allow HTML tags in field value
+     * @param string $charset    Charset to convert into
+     *
+     * @return string Parsed value
+     */
+    public static function parse_input_value($value, $allow_html = false, $charset = null)
+    {
+        if (empty($value)) {
+            return $value;
+        }
+
+        if (is_array($value)) {
+            foreach ($value as $idx => $val) {
+                $value[$idx] = self::parse_input_value($val, $allow_html, $charset);
+            }
+
+            return $value;
+        }
+
+        // remove HTML tags if not allowed
+        if (!$allow_html) {
+            $value = strip_tags($value);
+        }
+
+        $rcube          = rcube::get_instance();
+        $output_charset = is_object($rcube->output) ? $rcube->output->get_charset() : null;
+
+        // remove invalid characters (#1488124)
+        if ($output_charset == 'UTF-8') {
+            $value = rcube_charset::clean($value);
+        }
+
+        // convert to internal charset
+        if ($charset && $output_charset) {
+            $value = rcube_charset::convert($value, $output_charset, $charset);
+        }
+
+        return $value;
+    }
+
+    /**
+     * Convert array of request parameters (prefixed with _)
+     * to a regular array with non-prefixed keys.
+     *
+     * @param int    $mode       Source to get value from (GPC)
+     * @param string $ignore     PCRE expression to skip parameters by name
+     * @param bool   $allow_html Allow HTML tags in field value
+     *
+     * @return array Hash array with all request parameters
+     */
+    public static function request2param($mode = null, $ignore = 'task|action', $allow_html = false)
+    {
+        $out = [];
+        $src = $mode == self::INPUT_GET ? $_GET : ($mode == self::INPUT_POST ? $_POST : $_REQUEST);
+
+        foreach (array_keys($src) as $key) {
+            $fname = $key[0] == '_' ? substr($key, 1) : $key;
+            if ($ignore && !preg_match('/^(' . $ignore . ')$/', $fname)) {
+                $out[$fname] = self::get_input_value($key, $mode, $allow_html);
+            }
+        }
+
+        return $out;
+    }
+
+    /**
+     * Convert the given string into a valid HTML identifier
+     * Same functionality as done in app.js with rcube_webmail.html_identifier()
+     *
+     * @param string $str    String input
+     * @param bool   $encode Use base64 encoding
+     *
+     * @param string Valid HTML identifier
+     */
+    public static function html_identifier($str, $encode = false)
+    {
+        if ($encode) {
+            return rtrim(strtr(base64_encode($str), '+/', '-_'), '=');
+        }
+
+        return asciiwords($str, true, '_');
+    }
+
+    /**
+     * Replace all css definitions with #container [def]
+     * and remove css-inlined scripting, make position style safe
+     *
+     * @param string $source       CSS source code
+     * @param string $container_id Container ID to use as prefix
+     * @param bool   $allow_remote Allow remote content
+     * @param string $prefix       Prefix to be added to id/class identifier
+     *
+     * @return string Modified CSS source
+     */
+    public static function mod_css_styles($source, $container_id, $allow_remote = false, $prefix = '')
+    {
+        $last_pos     = 0;
+        $replacements = new rcube_string_replacer;
+
+        // ignore the whole block if evil styles are detected
+        $source   = self::xss_entity_decode($source);
+        $stripped = preg_replace('/[^a-z\(:;]/i', '', $source);
+        $evilexpr = 'expression|behavior|javascript:|import[^a]' . (!$allow_remote ? '|url\((?!data:image)' : '');
+
+        if (preg_match("/$evilexpr/i", $stripped)) {
+            return '/* evil! */';
+        }
+
+        $strict_url_regexp = '!url\s*\(\s*["\']?(https?:)//[a-z0-9/._+-]+["\']?\s*\)!Uims';
+
+        // remove html comments
+        $source = preg_replace('/(^\s*<\!--)|(-->\s*$)/m', '', $source);
+
+        // cut out all contents between { and }
+        while (($pos = strpos($source, '{', $last_pos)) && ($pos2 = strpos($source, '}', $pos))) {
+            $nested = strpos($source, '{', $pos+1);
+            if ($nested && $nested < $pos2) { // when dealing with nested blocks (e.g. @media), take the inner one
+                $pos = $nested;
+            }
+            $length = $pos2 - $pos - 1;
+            $styles = substr($source, $pos+1, $length);
+            $output = '';
+
+            // check every css rule in the style block...
+            foreach (self::parse_css_block($styles) as $rule) {
+                // Remove 'page' attributes (#7604)
+                if ($rule[0] == 'page') {
+                    continue;
+                }
+
+                // Convert position:fixed to position:absolute (#5264)
+                if ($rule[0] == 'position' && strcasecmp($rule[1], 'fixed') === 0) {
+                    $rule[1] = 'absolute';
+                }
+                else if ($allow_remote) {
+                    $stripped = preg_replace('/[^a-z\(:;]/i', '', $rule[1]);
+
+                    // allow data:image and strict url() values only
+                    if (
+                        stripos($stripped, 'url(') !== false
+                        && stripos($stripped, 'url(data:image') === false
+                        && !preg_match($strict_url_regexp, $rule[1])
+                    ) {
+                        $rule[1] = '/* evil! */';
+                    }
+                }
+
+                $output .= sprintf(" %s: %s;", $rule[0] , $rule[1]);
+            }
+
+            $key      = $replacements->add($output . ' ');
+            $repl     = $replacements->get_replacement($key);
+            $source   = substr_replace($source, $repl, $pos+1, $length);
+            $last_pos = $pos2 - ($length - strlen($repl));
+        }
+
+        // add #container to each tag selector and prefix to id/class identifiers
+        if ($container_id || $prefix) {
+            // Exclude rcube_string_replacer pattern matches, this is needed
+            // for cases like @media { body { position: fixed; } } (#5811)
+            $excl     = '(?!' . substr($replacements->pattern, 1, -1) . ')';
+            $regexp   = '/(^\s*|,\s*|\}\s*|\{\s*)(' . $excl . ':?[a-z0-9\._#\*\[][a-z0-9\._:\(\)#=~ \[\]"\|\>\+\$\^-]*)/im';
+            $callback = function($matches) use ($container_id, $prefix) {
+                $replace = $matches[2];
+
+                if (stripos($replace, ':root') === 0) {
+                    $replace = substr($replace, 5);
+                }
+
+                if ($prefix) {
+                    $replace = str_replace(['.', '#'], [".$prefix", "#$prefix"], $replace);
+                }
+
+                if ($container_id) {
+                    $replace = "#$container_id " . $replace;
+                }
+
+                // Remove redundant spaces (for simpler testing)
+                $replace = preg_replace('/\s+/', ' ', $replace);
+
+                return str_replace($matches[2], $replace, $matches[0]);
+            };
+
+            $source = preg_replace_callback($regexp, $callback, $source);
+        }
+
+        // replace body definition because we also stripped off the <body> tag
+        if ($container_id) {
+            $regexp = '/#' . preg_quote($container_id, '/') . '\s+body/i';
+            $source = preg_replace($regexp, "#$container_id", $source);
+        }
+
+        // put block contents back in
+        $source = $replacements->resolve($source);
+
+        return $source;
+    }
+
+    /**
+     * Explode css style. Property names will be lower-cased and trimmed.
+     * Values will be trimmed. Invalid entries will be skipped.
+     *
+     * @param string $style CSS style
+     *
+     * @return array List of CSS rule pairs, e.g. [['color', 'red'], ['top', '0']]
+     */
+    public static function parse_css_block($style)
+    {
+        $pos = 0;
+
+        // first remove comments
+        while (($pos = strpos($style, '/*', $pos)) !== false) {
+            $end = strpos($style, '*/', $pos+2);
+
+            if ($end === false) {
+                $style = substr($style, 0, $pos);
+            }
+            else {
+                $style = substr_replace($style, '', $pos, $end - $pos + 2);
+            }
+        }
+
+        // Replace new lines with spaces
+        $style = preg_replace('/[\r\n]+/', ' ', $style);
+
+        $style  = trim($style);
+        $length = strlen($style);
+        $result = [];
+        $pos    = 0;
+
+        while ($pos < $length && ($colon_pos = strpos($style, ':', $pos))) {
+            // Property name
+            $name = strtolower(trim(substr($style, $pos, $colon_pos - $pos)));
+
+            // get the property value
+            $q = $s = false;
+            for ($i = $colon_pos + 1; $i < $length; $i++) {
+                if (($style[$i] == "\"" || $style[$i] == "'") && ($i == 0 || $style[$i-1] != "\\")) {
+                    if ($q == $style[$i]) {
+                        $q = false;
+                    }
+                    else if ($q === false) {
+                        $q = $style[$i];
+                    }
+                }
+                else if ($style[$i] == "(" && !$q && ($i == 0 || $style[$i-1] != "\\")) {
+                    $q = "(";
+                }
+                else if ($style[$i] == ")" && $q == "(" && $style[$i-1] != "\\") {
+                    $q = false;
+                }
+
+                if ($q === false && (($s = $style[$i] == ';') || $i == $length - 1)) {
+                    break;
+                }
+            }
+
+            $value_length = $i - $colon_pos - ($s ? 1 : 0);
+            $value        = trim(substr($style, $colon_pos + 1, $value_length));
+
+            if (strlen($name) && !preg_match('/[^a-z-]/', $name) && strlen($value) && $value !== ';') {
+                $result[] = [$name, $value];
+            }
+
+            $pos = $i + 1;
+        }
+
+        return $result;
+    }
+
+    /**
+     * Generate CSS classes from mimetype and filename extension
+     *
+     * @param string $mimetype Mimetype
+     * @param string $filename Filename
+     *
+     * @return string CSS classes separated by space
+     */
+    public static function file2class($mimetype, $filename)
+    {
+        $mimetype = strtolower($mimetype);
+        $filename = strtolower($filename);
+
+        list($primary, $secondary) = rcube_utils::explode('/', $mimetype);
+
+        $classes = [$primary ?: 'unknown'];
+
+        if (!empty($secondary)) {
+            $classes[] = $secondary;
+        }
+
+        if (preg_match('/\.([a-z0-9]+)$/', $filename, $m)) {
+            if (!in_array($m[1], $classes)) {
+                $classes[] = $m[1];
+            }
+        }
+
+        return implode(' ', $classes);
+    }
+
+    /**
+     * Decode escaped entities used by known XSS exploits.
+     * See http://downloads.securityfocus.com/vulnerabilities/exploits/26800.eml for examples
+     *
+     * @param string $content CSS content to decode
+     *
+     * @return string Decoded string
+     */
+    public static function xss_entity_decode($content)
+    {
+        $callback = function($matches) { return chr(hexdec($matches[1])); };
+
+        $out = html_entity_decode(html_entity_decode($content));
+        $out = trim(preg_replace('/(^<!--|-->$)/', '', trim($out)));
+        $out = preg_replace_callback('/\\\([0-9a-f]{2,6})\s*/i', $callback, $out);
+        $out = preg_replace('/\\\([^0-9a-f])/i', '\\1', $out);
+        $out = preg_replace('#/\*.*\*/#Ums', '', $out);
+        $out = strip_tags($out);
+
+        return $out;
+    }
+
+    /**
+     * Check if we can process not exceeding memory_limit
+     *
+     * @param int $need Required amount of memory
+     *
+     * @return bool True if memory won't be exceeded, False otherwise
+     */
+    public static function mem_check($need)
+    {
+        $mem_limit = parse_bytes(ini_get('memory_limit'));
+        $memory    = function_exists('memory_get_usage') ? memory_get_usage() : 16*1024*1024; // safe value: 16MB
+
+        return $mem_limit > 0 && $memory + $need > $mem_limit ? false : true;
+    }
+
+    /**
+     * Check if working in SSL mode
+     *
+     * @param int  $port      HTTPS port number
+     * @param bool $use_https Enables 'use_https' option checking
+     *
+     * @return bool True in SSL mode, False otherwise
+     */
+    public static function https_check($port = null, $use_https = true)
+    {
+        if (!empty($_SERVER['HTTPS']) && strtolower($_SERVER['HTTPS']) != 'off') {
+            return true;
+        }
+
+        if (!empty($_SERVER['HTTP_X_FORWARDED_PROTO'])
+            && strtolower($_SERVER['HTTP_X_FORWARDED_PROTO']) == 'https'
+            && in_array($_SERVER['REMOTE_ADDR'], (array) rcube::get_instance()->config->get('proxy_whitelist', []))
+        ) {
+            return true;
+        }
+
+        if ($port && isset($_SERVER['SERVER_PORT']) && $_SERVER['SERVER_PORT'] == $port) {
+            return true;
+        }
+
+        if ($use_https && rcube::get_instance()->config->get('use_https')) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Replaces hostname variables.
+     *
+     * @param string $name Hostname
+     * @param string $host Optional IMAP hostname
+     *
+     * @return string Hostname
+     */
+    public static function parse_host($name, $host = '')
+    {
+        if (!is_string($name)) {
+            return $name;
+        }
+
+        // %n - host
+        $n = self::server_name();
+        // %t - host name without first part, e.g. %n=mail.domain.tld, %t=domain.tld
+        // If %n=domain.tld then %t=domain.tld as well (remains valid)
+        $t = preg_replace('/^[^.]+\.(?![^.]+$)/', '', $n);
+        // %d - domain name without first part (up to domain.tld)
+        $d = preg_replace('/^[^.]+\.(?![^.]+$)/', '', self::server_name('HTTP_HOST'));
+        // %h - IMAP host
+        $h = !empty($_SESSION['storage_host']) ? $_SESSION['storage_host'] : $host;
+        // %z - IMAP domain without first part, e.g. %h=imap.domain.tld, %z=domain.tld
+        // If %h=domain.tld then %z=domain.tld as well (remains valid)
+        $z = preg_replace('/^[^.]+\.(?![^.]+$)/', '', $h);
+        // %s - domain name after the '@' from e-mail address provided at login screen.
+        //      Returns FALSE if an invalid email is provided
+        $s = '';
+        if (strpos($name, '%s') !== false) {
+            $user_email = self::idn_to_ascii(self::get_input_value('_user', self::INPUT_POST));
+            $matches    = preg_match('/(.*)@([a-z0-9\.\-\[\]\:]+)/i', $user_email, $s);
+            if ($matches < 1 || filter_var($s[1]."@".$s[2], FILTER_VALIDATE_EMAIL) === false) {
+                return false;
+            }
+            $s = $s[2];
+        }
+
+        return str_replace(['%n', '%t', '%d', '%h', '%z', '%s'], [$n, $t, $d, $h, $z, $s], $name);
+    }
+
+    /**
+     * Returns the server name after checking it against trusted hostname patterns.
+     *
+     * Returns 'localhost' and logs a warning when the hostname is not trusted.
+     *
+     * @param string $type       The $_SERVER key, e.g. 'HTTP_HOST', Default: 'SERVER_NAME'.
+     * @param bool   $strip_port Strip port from the host name
+     *
+     * @return string Server name
+     */
+    public static function server_name($type = null, $strip_port = true)
+    {
+        if (!$type) {
+            $type = 'SERVER_NAME';
+        }
+
+        $name     = isset($_SERVER[$type]) ? $_SERVER[$type] : null;
+        $rcube    = rcube::get_instance();
+        $patterns = (array) $rcube->config->get('trusted_host_patterns');
+
+        if (!empty($name)) {
+            if ($strip_port) {
+                $name = preg_replace('/:\d+$/', '', $name);
+            }
+
+            if (empty($patterns)) {
+                return $name;
+            }
+
+            foreach ($patterns as $pattern) {
+                // the pattern might be a regular expression or just a host/domain name
+                if (preg_match('/[^a-zA-Z0-9.:-]/', $pattern)) {
+                    if (preg_match("/$pattern/", $name)) {
+                        return $name;
+                    }
+                }
+                else if (strtolower($name) === strtolower($pattern)) {
+                    return $name;
+                }
+            }
+
+            $rcube->raise_error([
+                    'file' => __FILE__, 'line' => __LINE__,
+                    'message' => "Specified host is not trusted. Using 'localhost'."
+                ]
+                , true, false
+            );
+        }
+
+        return 'localhost';
+    }
+
+    /**
+     * Returns remote IP address and forwarded addresses if found
+     *
+     * @return string Remote IP address(es)
+     */
+    public static function remote_ip()
+    {
+        $address = isset($_SERVER['REMOTE_ADDR']) ? $_SERVER['REMOTE_ADDR'] : '';
+
+        // append the NGINX X-Real-IP header, if set
+        if (!empty($_SERVER['HTTP_X_REAL_IP']) && $_SERVER['HTTP_X_REAL_IP'] != $address) {
+            $remote_ip[] = 'X-Real-IP: ' . $_SERVER['HTTP_X_REAL_IP'];
+        }
+
+        // append the X-Forwarded-For header, if set
+        if (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
+            $remote_ip[] = 'X-Forwarded-For: ' . $_SERVER['HTTP_X_FORWARDED_FOR'];
+        }
+
+        if (!empty($remote_ip)) {
+            $address .= ' (' . implode(',', $remote_ip) . ')';
+        }
+
+        return $address;
+    }
+
+    /**
+     * Returns the real remote IP address
+     *
+     * @return string Remote IP address
+     */
+    public static function remote_addr()
+    {
+        // Check if any of the headers are set first to improve performance
+        if (!empty($_SERVER['HTTP_X_FORWARDED_FOR']) || !empty($_SERVER['HTTP_X_REAL_IP'])) {
+            $proxy_whitelist = (array) rcube::get_instance()->config->get('proxy_whitelist', []);
+            if (in_array($_SERVER['REMOTE_ADDR'], $proxy_whitelist)) {
+                if (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
+                    foreach (array_reverse(explode(',', $_SERVER['HTTP_X_FORWARDED_FOR'])) as $forwarded_ip) {
+                        $forwarded_ip = trim($forwarded_ip);
+                        if (!in_array($forwarded_ip, $proxy_whitelist)) {
+                            return $forwarded_ip;
+                        }
+                    }
+                }
+
+                if (!empty($_SERVER['HTTP_X_REAL_IP'])) {
+                    return $_SERVER['HTTP_X_REAL_IP'];
+                }
+            }
+        }
+
+        if (!empty($_SERVER['REMOTE_ADDR'])) {
+            return $_SERVER['REMOTE_ADDR'];
+        }
+
+        return '';
+    }
+
+    /**
+     * Read a specific HTTP request header.
+     *
+     * @param string $name Header name
+     *
+     * @return string|null Header value or null if not available
+     */
+    public static function request_header($name)
+    {
+        if (function_exists('apache_request_headers')) {
+            $headers = apache_request_headers();
+            $key     = strtoupper($name);
+        }
+        else {
+            $headers = $_SERVER;
+            $key     = 'HTTP_' . strtoupper(strtr($name, '-', '_'));
+        }
+
+        if (!empty($headers)) {
+            $headers = array_change_key_case($headers, CASE_UPPER);
+
+            return isset($headers[$key]) ? $headers[$key] : null;
+        }
+    }
+
+    /**
+     * Explode quoted string
+     *
+     * @param string $delimiter Delimiter expression string for preg_match()
+     * @param string $string    Input string
+     *
+     * @return array String items
+     */
+    public static function explode_quoted_string($delimiter, $string)
+    {
+        $result = [];
+        $strlen = strlen($string);
+
+        for ($q=$p=$i=0; $i < $strlen; $i++) {
+            if ($string[$i] == "\"" && (!isset($string[$i-1]) || $string[$i-1] != "\\")) {
+                $q = $q ? false : true;
+            }
+            else if (!$q && preg_match("/$delimiter/", $string[$i])) {
+                $result[] = substr($string, $p, $i - $p);
+                $p = $i + 1;
+            }
+        }
+
+        $result[] = (string) substr($string, $p);
+
+        return $result;
+    }
+
+    /**
+     * Improved equivalent to strtotime()
+     *
+     * @param string       $date     Date string
+     * @param DateTimeZone $timezone Timezone to use for DateTime object
+     *
+     * @return int Unix timestamp
+     */
+    public static function strtotime($date, $timezone = null)
+    {
+        $date   = self::clean_datestr($date);
+        $tzname = $timezone ? ' ' . $timezone->getName() : '';
+
+        // unix timestamp
+        if (is_numeric($date)) {
+            return (int) $date;
+        }
+
+        // It can be very slow when provided string is not a date and very long
+        if (strlen($date) > 128) {
+            $date = substr($date, 0, 128);
+        }
+
+        // if date parsing fails, we have a date in non-rfc format.
+        // remove token from the end and try again
+        while (($ts = @strtotime($date . $tzname)) === false || $ts < 0) {
+            if (($pos = strrpos($date, ' ')) === false) {
+                break;
+            }
+
+            $date = rtrim(substr($date, 0, $pos));
+        }
+
+        return (int) $ts;
+    }
+
+    /**
+     * Date parsing function that turns the given value into a DateTime object
+     *
+     * @param string       $date     Date string
+     * @param DateTimeZone $timezone Timezone to use for DateTime object
+     *
+     * @return DateTime|false DateTime object or False on failure
+     */
+    public static function anytodatetime($date, $timezone = null)
+    {
+        if ($date instanceof DateTime) {
+            return $date;
+        }
+
+        $dt   = false;
+        $date = self::clean_datestr($date);
+
+        // try to parse string with DateTime first
+        if (!empty($date)) {
+            try {
+                $_date = preg_match('/^[0-9]+$/', $date) ? "@$date" : $date;
+                $dt    = $timezone ? new DateTime($_date, $timezone) : new DateTime($_date);
+            }
+            catch (Exception $e) {
+                // ignore
+            }
+        }
+
+        // try our advanced strtotime() method
+        if (!$dt && ($timestamp = self::strtotime($date, $timezone))) {
+            try {
+                $dt = new DateTime("@".$timestamp);
+                if ($timezone) {
+                    $dt->setTimezone($timezone);
+                }
+            }
+            catch (Exception $e) {
+                // ignore
+            }
+        }
+
+        return $dt;
+    }
+
+    /**
+     * Clean up date string for strtotime() input
+     *
+     * @param string $date Date string
+     *
+     * @return string Date string
+     */
+    public static function clean_datestr($date)
+    {
+        $date = trim($date);
+
+        // check for MS Outlook vCard date format YYYYMMDD
+        if (preg_match('/^([12][90]\d\d)([01]\d)([0123]\d)$/', $date, $m)) {
+            return sprintf('%04d-%02d-%02d 00:00:00', intval($m[1]), intval($m[2]), intval($m[3]));
+        }
+
+        // Clean malformed data
+        $date = preg_replace(
+            [
+                '/\(.*\)/',                                 // remove RFC comments
+                '/GMT\s*([+-][0-9]+)/',                     // support non-standard "GMTXXXX" literal
+                '/[^a-z0-9\x20\x09:\/\.+-]/i',              // remove any invalid characters
+                '/\s*(Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s*/i',   // remove weekday names
+            ],
+            [
+                '',
+                '\\1',
+                '',
+                '',
+            ],
+            $date
+        );
+
+        $date = trim($date);
+
+        // try to fix dd/mm vs. mm/dd discrepancy, we can't do more here
+        if (preg_match('/^(\d{1,2})[.\/-](\d{1,2})[.\/-](\d{4})(\s.*)?$/', $date, $m)) {
+            $mdy   = $m[2] > 12 && $m[1] <= 12;
+            $day   = $mdy ? $m[2] : $m[1];
+            $month = $mdy ? $m[1] : $m[2];
+            $date  = sprintf('%04d-%02d-%02d%s', $m[3], $month, $day, isset($m[4]) ? $m[4]: ' 00:00:00');
+        }
+        // I've found that YYYY.MM.DD is recognized wrong, so here's a fix
+        else if (preg_match('/^(\d{4})\.(\d{1,2})\.(\d{1,2})(\s.*)?$/', $date, $m)) {
+            $date  = sprintf('%04d-%02d-%02d%s', $m[1], $m[2], $m[3], isset($m[4]) ? $m[4]: ' 00:00:00');
+        }
+
+        return $date;
+    }
+
+    /**
+     * Turns the given date-only string in defined format into YYYY-MM-DD format.
+     *
+     * Supported formats: 'Y/m/d', 'Y.m.d', 'd-m-Y', 'd/m/Y', 'd.m.Y', 'j.n.Y'
+     *
+     * @param string $date   Date string
+     * @param string $format Input date format
+     *
+     * @return string Date string in YYYY-MM-DD format, or the original string
+     *                if format is not supported
+     */
+    public static function format_datestr($date, $format)
+    {
+        $format_items = preg_split('/[.-\/\\\\]/', $format);
+        $date_items   = preg_split('/[.-\/\\\\]/', $date);
+        $iso_format   = '%04d-%02d-%02d';
+
+        if (count($format_items) == 3 && count($date_items) == 3) {
+            if ($format_items[0] == 'Y') {
+                $date = sprintf($iso_format, $date_items[0], $date_items[1], $date_items[2]);
+            }
+            else if (strpos('dj', $format_items[0]) !== false) {
+                $date = sprintf($iso_format, $date_items[2], $date_items[1], $date_items[0]);
+            }
+            else if (strpos('mn', $format_items[0]) !== false) {
+                $date = sprintf($iso_format, $date_items[2], $date_items[0], $date_items[1]);
+            }
+        }
+
+        return $date;
+    }
+
+    /**
+     * Wrapper for idn_to_ascii with support for e-mail address.
+     *
+     * Warning: Domain names may be lowercase'd.
+     * Warning: An empty string may be returned on invalid domain.
+     *
+     * @param string $str Decoded e-mail address
+     *
+     * @return string Encoded e-mail address
+     */
+    public static function idn_to_ascii($str)
+    {
+        return self::idn_convert($str, true);
+    }
+
+    /**
+     * Wrapper for idn_to_utf8 with support for e-mail address
+     *
+     * @param string $str Decoded e-mail address
+     *
+     * @return string Encoded e-mail address
+     */
+    public static function idn_to_utf8($str)
+    {
+        return self::idn_convert($str, false);
+    }
+
+    /**
+     * Convert a string to ascii or utf8 (using IDNA standard)
+     *
+     * @param string  $input  Decoded e-mail address
+     * @param boolean $is_utf Convert by idn_to_ascii if true and idn_to_utf8 if false
+     *
+     * @return string Encoded e-mail address
+     */
+    public static function idn_convert($input, $is_utf = false)
+    {
+        if ($at = strpos($input, '@')) {
+            $user   = substr($input, 0, $at);
+            $domain = substr($input, $at + 1);
+        }
+        else {
+            $user   = '';
+            $domain = $input;
+        }
+
+        // Note that in PHP 7.2/7.3 calling idn_to_* functions with default arguments
+        // throws a warning, so we have to set the variant explicitly (#6075)
+        $variant = defined('INTL_IDNA_VARIANT_UTS46') ? INTL_IDNA_VARIANT_UTS46 : null;
+        $options = 0;
+
+        // Because php-intl extension lowercases domains and return false
+        // on invalid input (#6224), we skip conversion when not needed
+
+        if ($is_utf) {
+            if (preg_match('/[^\x20-\x7E]/', $domain)) {
+                $options = defined('IDNA_NONTRANSITIONAL_TO_ASCII') ? IDNA_NONTRANSITIONAL_TO_ASCII : 0;
+                $domain  = idn_to_ascii($domain, $options, $variant);
+            }
+        }
+        else if (preg_match('/(^|\.)xn--/i', $domain)) {
+            $options = defined('IDNA_NONTRANSITIONAL_TO_UNICODE') ? IDNA_NONTRANSITIONAL_TO_UNICODE : 0;
+            $domain  = idn_to_utf8($domain, $options, $variant);
+        }
+
+        if ($domain === false) {
+            return '';
+        }
+
+        return $at ? $user . '@' . $domain : $domain;
+    }
+
+    /**
+     * Split the given string into word tokens
+     *
+     * @param string $str     Input to tokenize
+     * @param int    $minlen  Minimum length of a single token
+     *
+     * @return array List of tokens
+     */
+    public static function tokenize_string($str, $minlen = 2)
+    {
+        $expr = ['/[\s;,"\'\/+-]+/ui', '/(\d)[-.\s]+(\d)/u'];
+        $repl = [' ', '\\1\\2'];
+
+        if ($minlen > 1) {
+            $minlen--;
+            $expr[] = "/(^|\s+)\w{1,$minlen}(\s+|$)/u";
+            $repl[] = ' ';
+        }
+
+        return array_filter(explode(" ", preg_replace($expr, $repl, $str)));
+    }
+
+    /**
+     * Normalize the given string for fulltext search.
+     * Currently only optimized for ISO-8859-1 and ISO-8859-2 characters; to be extended
+     *
+     * @param string $str      Input string (UTF-8)
+     * @param bool   $as_array True to return list of words as array
+     * @param int    $minlen   Minimum length of tokens
+     *
+     * @return string|array Normalized string or a list of normalized tokens
+     */
+    public static function normalize_string($str, $as_array = false, $minlen = 2)
+    {
+        // replace 4-byte unicode characters with '?' character,
+        // these are not supported in default utf-8 charset on mysql,
+        // the chance we'd need them in searching is very low
+        $str = preg_replace('/('
+            . '\xF0[\x90-\xBF][\x80-\xBF]{2}'
+            . '|[\xF1-\xF3][\x80-\xBF]{3}'
+            . '|\xF4[\x80-\x8F][\x80-\xBF]{2}'
+            . ')/', '?', $str);
+
+        // split by words
+        $arr = self::tokenize_string($str, $minlen);
+
+        // detect character set
+        if (rcube_charset::convert(rcube_charset::convert($str, 'UTF-8', 'ISO-8859-1'), 'ISO-8859-1', 'UTF-8') == $str)  {
+            // ISO-8859-1 (or ASCII)
+            preg_match_all('/./u', 'äâàåáãæçéêëèïîìíñöôòøõóüûùúýÿ', $keys);
+            preg_match_all('/./',  'aaaaaaaceeeeiiiinoooooouuuuyy', $values);
+
+            $mapping = array_combine($keys[0], $values[0]);
+            $mapping = array_merge($mapping, ['ß' => 'ss', 'ae' => 'a', 'oe' => 'o', 'ue' => 'u']);
+        }
+        else if (rcube_charset::convert(rcube_charset::convert($str, 'UTF-8', 'ISO-8859-2'), 'ISO-8859-2', 'UTF-8') == $str) {
+            // ISO-8859-2
+            preg_match_all('/./u', 'ąáâäćçčéęëěíîłľĺńňóôöŕřśšşťţůúűüźžżý', $keys);
+            preg_match_all('/./',  'aaaaccceeeeiilllnnooorrsssttuuuuzzzy', $values);
+
+            $mapping = array_combine($keys[0], $values[0]);
+            $mapping = array_merge($mapping, ['ß' => 'ss', 'ae' => 'a', 'oe' => 'o', 'ue' => 'u']);
+        }
+
+        foreach ($arr as $i => $part) {
+            $part = mb_strtolower($part);
+
+            if (!empty($mapping)) {
+                $part = strtr($part, $mapping);
+            }
+
+            $arr[$i] = $part;
+        }
+
+        return $as_array ? $arr : implode(' ', $arr);
+    }
+
+    /**
+     * Compare two strings for matching words (order not relevant)
+     *
+     * @param string $haystack Haystack
+     * @param string $needle   Needle
+     *
+     * @return bool True if match, False otherwise
+     */
+    public static function words_match($haystack, $needle)
+    {
+        $a_needle  = self::tokenize_string($needle, 1);
+        $_haystack = implode(' ', self::tokenize_string($haystack, 1));
+        $valid     = strlen($_haystack) > 0;
+        $hits      = 0;
+
+        foreach ($a_needle as $w) {
+            if ($valid) {
+                if (stripos($_haystack, $w) !== false) {
+                    $hits++;
+                }
+            }
+            else if (stripos($haystack, $w) !== false) {
+                $hits++;
+            }
+        }
+
+        return $hits >= count($a_needle);
+    }
+
+    /**
+     * Parse commandline arguments into a hash array
+     *
+     * @param array $aliases Argument alias names
+     *
+     * @return array Argument values hash
+     */
+    public static function get_opt($aliases = [])
+    {
+        $args = [];
+        $bool = [];
+
+        // find boolean (no value) options
+        foreach ($aliases as $key => $alias) {
+            if ($pos = strpos($alias, ':')) {
+                $aliases[$key] = substr($alias, 0, $pos);
+                $bool[] = $key;
+                $bool[] = $aliases[$key];
+            }
+        }
+
+        for ($i=1; $i < count($_SERVER['argv']); $i++) {
+            $arg   = $_SERVER['argv'][$i];
+            $value = true;
+            $key   = null;
+
+            if ($arg[0] == '-') {
+                $key = preg_replace('/^-+/', '', $arg);
+                $sp  = strpos($arg, '=');
+
+                if ($sp > 0) {
+                    $key   = substr($key, 0, $sp - 2);
+                    $value = substr($arg, $sp+1);
+                }
+                else if (in_array($key, $bool)) {
+                    $value = true;
+                }
+                else if (
+                    isset($_SERVER['argv'][$i + 1])
+                    && strlen($_SERVER['argv'][$i + 1])
+                    && $_SERVER['argv'][$i + 1][0] != '-'
+                ) {
+                    $value = $_SERVER['argv'][++$i];
+                }
+
+                $args[$key] = is_string($value) ? preg_replace(['/^["\']/', '/["\']$/'], '', $value) : $value;
+            }
+            else {
+                $args[] = $arg;
+            }
+
+            if (!empty($aliases[$key])) {
+                $alias = $aliases[$key];
+                $args[$alias] = $args[$key];
+            }
+        }
+
+        return $args;
+    }
+
+    /**
+     * Safe password prompt for command line
+     * from http://blogs.sitepoint.com/2009/05/01/interactive-cli-password-prompt-in-php/
+     *
+     * @param string $prompt Prompt text
+     *
+     * @return string Password
+     */
+    public static function prompt_silent($prompt = "Password:")
+    {
+        if (preg_match('/^win/i', PHP_OS)) {
+            $vbscript  = sys_get_temp_dir() . 'prompt_password.vbs';
+            $vbcontent = 'wscript.echo(InputBox("' . addslashes($prompt) . '", "", "password here"))';
+            file_put_contents($vbscript, $vbcontent);
+
+            $command  = "cscript //nologo " . escapeshellarg($vbscript);
+            $password = rtrim(shell_exec($command));
+            unlink($vbscript);
+
+            return $password;
+        }
+
+        $command = "/usr/bin/env bash -c 'echo OK'";
+
+        if (rtrim(shell_exec($command)) !== 'OK') {
+            echo $prompt;
+            $pass = trim(fgets(STDIN));
+            echo chr(8)."\r" . $prompt . str_repeat("*", strlen($pass))."\n";
+
+            return $pass;
+        }
+
+        $command  = "/usr/bin/env bash -c 'read -s -p \"" . addslashes($prompt) . "\" mypassword && echo \$mypassword'";
+        $password = rtrim(shell_exec($command));
+        echo "\n";
+
+        return $password;
+    }
+
+    /**
+     * Find out if the string content means true or false
+     *
+     * @param string $str Input value
+     *
+     * @return bool Boolean value
+     */
+    public static function get_boolean($str)
+    {
+        $str = strtolower($str);
+
+        return !in_array($str, ['false', '0', 'no', 'off', 'nein', ''], true);
+    }
+
+    /**
+     * OS-dependent absolute path detection
+     *
+     * @param string $path File path
+     *
+     * @return bool True if the path is absolute, False otherwise
+     */
+    public static function is_absolute_path($path)
+    {
+        if (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN') {
+            return (bool) preg_match('!^[a-z]:[\\\\/]!i', $path);
+        }
+
+        return isset($path[0]) && $path[0] == '/';
+    }
+
+    /**
+     * Resolve relative URL
+     *
+     * @param string $url Relative URL
+     *
+     * @return string Absolute URL
+     */
+    public static function resolve_url($url)
+    {
+        // prepend protocol://hostname:port
+        if (!preg_match('|^https?://|', $url)) {
+            $schema       = 'http';
+            $default_port = 80;
+
+            if (self::https_check()) {
+                $schema       = 'https';
+                $default_port = 443;
+            }
+
+            $host = isset($_SERVER['HTTP_HOST']) ? $_SERVER['HTTP_HOST'] : null;
+            $port = isset($_SERVER['SERVER_PORT']) ? $_SERVER['SERVER_PORT'] : null;
+
+            $prefix = $schema . '://' . preg_replace('/:\d+$/', '', $host);
+            if ($port != $default_port && $port != 80) {
+                $prefix .= ':' . $port;
+            }
+
+            $url = $prefix . ($url[0] == '/' ? '' : '/') . $url;
+        }
+
+        return $url;
+    }
+
+    /**
+     * Generate a random string
+     *
+     * @param int  $length String length
+     * @param bool $raw    Return RAW data instead of ascii
+     *
+     * @return string The generated random string
+     */
+    public static function random_bytes($length, $raw = false)
+    {
+        $hextab  = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        $tabsize = strlen($hextab);
+
+        // Use PHP7 true random generator
+        if ($raw && function_exists('random_bytes')) {
+            return random_bytes($length);
+        }
+
+        if (!$raw && function_exists('random_int')) {
+            $result = '';
+            while ($length-- > 0) {
+                $result .= $hextab[random_int(0, $tabsize - 1)];
+            }
+
+            return $result;
+        }
+
+        $random = openssl_random_pseudo_bytes($length);
+
+        if ($random === false && $length > 0) {
+            throw new Exception("Failed to get random bytes");
+        }
+
+        if (!$raw) {
+            for ($x = 0; $x < $length; $x++) {
+                $random[$x] = $hextab[ord($random[$x]) % $tabsize];
+            }
+        }
+
+        return $random;
+    }
+
+    /**
+     * Convert binary data into readable form (containing a-zA-Z0-9 characters)
+     *
+     * @param string $input Binary input
+     *
+     * @return string Readable output (Base62)
+     * @deprecated since 1.3.1
+     */
+    public static function bin2ascii($input)
+    {
+        $hextab = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        $result = '';
+
+        for ($x = 0; $x < strlen($input); $x++) {
+            $result .= $hextab[ord($input[$x]) % 62];
+        }
+
+        return $result;
+    }
+
+    /**
+     * Format current date according to specified format.
+     * This method supports microseconds (u).
+     *
+     * @param string $format Date format (default: 'd-M-Y H:i:s O')
+     *
+     * @return string Formatted date
+     */
+    public static function date_format($format = null)
+    {
+        if (empty($format)) {
+            $format = 'd-M-Y H:i:s O';
+        }
+
+        if (strpos($format, 'u') !== false) {
+            $dt = number_format(microtime(true), 6, '.', '');
+
+            try {
+                $date = date_create_from_format('U.u', $dt);
+                $date->setTimeZone(new DateTimeZone(date_default_timezone_get()));
+
+                return $date->format($format);
+            }
+            catch (Exception $e) {
+                // ignore, fallback to date()
+            }
+        }
+
+        return date($format);
+    }
+
+    /**
+     * Parses socket options and returns options for specified hostname.
+     *
+     * @param array  &$options Configured socket options
+     * @param string $host     Hostname
+     */
+    public static function parse_socket_options(&$options, $host = null)
+    {
+        if (empty($host) || empty($options)) {
+            return;
+        }
+
+        // get rid of schema and port from the hostname
+        $host_url = parse_url($host);
+        if (isset($host_url['host'])) {
+            $host = $host_url['host'];
+        }
+
+        // find per-host options
+        if ($host && array_key_exists($host, $options)) {
+            $options = $options[$host];
+        }
+    }
+
+    /**
+     * Get maximum upload size
+     *
+     * @return int Maximum size in bytes
+     */
+    public static function max_upload_size()
+    {
+        // find max filesize value
+        $max_filesize = parse_bytes(ini_get('upload_max_filesize'));
+        $max_postsize = parse_bytes(ini_get('post_max_size'));
+
+        if ($max_postsize && $max_postsize < $max_filesize) {
+            $max_filesize = $max_postsize;
+        }
+
+        return $max_filesize;
+    }
+
+    /**
+     * Detect and log last PREG operation error
+     *
+     * @param array $error     Error data (line, file, code, message)
+     * @param bool  $terminate Stop script execution
+     *
+     * @return bool True on error, False otherwise
+     */
+    public static function preg_error($error = [], $terminate = false)
+    {
+        if (($preg_error = preg_last_error()) != PREG_NO_ERROR) {
+            $errstr = "PCRE Error: $preg_error.";
+
+            if ($preg_error == PREG_BACKTRACK_LIMIT_ERROR) {
+                $errstr .= " Consider raising pcre.backtrack_limit!";
+            }
+            if ($preg_error == PREG_RECURSION_LIMIT_ERROR) {
+                $errstr .= " Consider raising pcre.recursion_limit!";
+            }
+
+            $error = array_merge(['code' => 620, 'line' => __LINE__, 'file' => __FILE__], $error);
+
+            if (!empty($error['message'])) {
+                $error['message'] .= ' ' . $errstr;
+            }
+            else {
+                $error['message'] = $errstr;
+            }
+
+            rcube::raise_error($error, true, $terminate);
+
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Generate a temporary file path in the Roundcube temp directory
+     *
+     * @param string $file_name String identifier for the type of temp file
+     * @param bool   $unique    Generate unique file names based on $file_name
+     * @param bool   $create    Create the temp file or not
+     *
+     * @return string temporary file path
+     */
+    public static function temp_filename($file_name, $unique = true, $create = true)
+    {
+        $temp_dir = rcube::get_instance()->config->get('temp_dir');
+
+        // Fall back to system temp dir if configured dir is not writable
+        if (!is_writable($temp_dir)) {
+            $temp_dir = sys_get_temp_dir();
+        }
+
+        // On Windows tempnam() uses only the first three characters of prefix so use uniqid() and manually add the prefix
+        // Full prefix is required for garbage collection to recognise the file
+        $temp_file = $unique ? str_replace('.', '', uniqid($file_name, true)) : $file_name;
+        $temp_path = unslashify($temp_dir) . '/' . RCUBE_TEMP_FILE_PREFIX . $temp_file;
+
+        // Sanity check for unique file name
+        if ($unique && file_exists($temp_path)) {
+            return self::temp_filename($file_name, $unique, $create);
+        }
+
+        // Create the file to prevent possible race condition like tempnam() does
+        if ($create) {
+            touch($temp_path);
+        }
+
+        return $temp_path;
+    }
+
+    /**
+     * Clean the subject from reply and forward prefix
+     *
+     * @param string $subject Subject to clean
+     * @param string $mode Mode of cleaning : reply, forward or both
+     *
+     * @return string Cleaned subject
+     */
+    public static function remove_subject_prefix($subject, $mode = 'both')
+    {
+        $config = rcmail::get_instance()->config;
+
+        // Clean subject prefix for reply, forward or both
+        if ($mode == 'both') {
+            $reply_prefixes = $config->get('subject_reply_prefixes', ['Re:']);
+            $forward_prefixes = $config->get('subject_forward_prefixes', ['Fwd:', 'Fw:']);
+            $prefixes = array_merge($reply_prefixes, $forward_prefixes);
+        }
+        else if ($mode == 'reply') {
+            $prefixes = $config->get('subject_reply_prefixes', ['Re:']);
+            // replace (was: ...) (#1489375)
+            $subject = preg_replace('/\s*\([wW]as:[^\)]+\)\s*$/', '', $subject);
+        }
+        else if ($mode == 'forward') {
+            $prefixes = $config->get('subject_forward_prefixes', ['Fwd:', 'Fw:']);
+        }
+
+        // replace Re:, Re[x]:, Re-x (#1490497)
+        $pieces = array_map(function($prefix) {
+            $prefix = strtolower(str_replace(':', '', $prefix));
+            return "$prefix:|$prefix\[\d\]:|$prefix-\d:";
+        }, $prefixes);
+        $pattern = '/^('.implode('|', $pieces).')\s*/i';
+        do {
+            $subject = preg_replace($pattern, '', $subject, -1, $count);
+        }
+        while ($count);
+
+        return trim($subject);
+    }
+
+    /**
+     * Generates the HAproxy style PROXY protocol header for injection
+     * into the TCP stream, if configured.
+     *
+     * http://www.haproxy.org/download/1.6/doc/proxy-protocol.txt
+     *
+     * PROXY protocol headers must be sent before any other data is sent on the TCP socket.
+     *
+     * @param array $options Preferences array which may contain proxy_protocol (generally {driver}_conn_options)
+     *
+     * @return string Proxy protocol header data, if enabled, otherwise empty string
+     */
+    public static function proxy_protocol_header($options = null)
+    {
+        if (empty($options) || !is_array($options) || !array_key_exists('proxy_protocol', $options)) {
+            return '';
+        }
+
+        if (is_array($options['proxy_protocol'])) {
+            $version = $options['proxy_protocol']['version'];
+            $options = $options['proxy_protocol'];
+        }
+        else {
+            $version = (int) $options['proxy_protocol'];
+            $options = [];
+        }
+
+        $remote_addr = array_key_exists('remote_addr', $options) ? $options['remote_addr'] : self::remote_addr();
+        $remote_port = array_key_exists('remote_port', $options) ? $options['remote_port'] : $_SERVER['REMOTE_PORT'];
+        $local_addr  = array_key_exists('local_addr', $options) ? $options['local_addr'] : $_SERVER['SERVER_ADDR'];
+        $local_port  = array_key_exists('local_port', $options) ? $options['local_port'] : $_SERVER['SERVER_PORT'];
+        $ip_version  = strpos($remote_addr, ':') === false ? 4 : 6;
+
+        // Text based PROXY protocol
+        if ($version == 1) {
+            // PROXY protocol does not support dual IPv6+IPv4 type addresses, e.g. ::127.0.0.1
+            if ($ip_version === 6 && strpos($remote_addr, '.') !== false) {
+                $remote_addr = inet_ntop(inet_pton($remote_addr));
+            }
+            if ($ip_version === 6 && strpos($local_addr, '.') !== false) {
+                $local_addr = inet_ntop(inet_pton($local_addr));
+            }
+
+            return "PROXY TCP{$ip_version} {$remote_addr} {$local_addr} {$remote_port} {$local_port}\r\n";
+        }
+
+        // Binary PROXY protocol
+        if ($version == 2) {
+            $addr = inet_pton($remote_addr) . inet_pton($local_addr) . pack('n', $remote_port) . pack('n', $local_port);
+            $head = implode([
+                    '0D0A0D0A000D0A515549540A',     // protocol header
+                    '21',                           // protocol version and command
+                    $ip_version === 6 ? '2' : '1',  // IP version type
+                    '1'                             // TCP
+            ]);
+
+            return pack('H*', $head) . pack('n', strlen($addr)) . $addr;
+        }
+
+        return '';
+    }
+}