diff --git a/plugins/kolab_addressbook/lib/rcube_kolab_contacts.php b/plugins/kolab_addressbook/lib/rcube_kolab_contacts.php
index b301ffad..cfc9e693 100644
--- a/plugins/kolab_addressbook/lib/rcube_kolab_contacts.php
+++ b/plugins/kolab_addressbook/lib/rcube_kolab_contacts.php
@@ -1,1337 +1,1340 @@
 <?php
 
 /**
  * Backend class for a custom address book
  *
  * This part of the Roundcube+Kolab integration and connects the
  * rcube_addressbook interface with the kolab_storage wrapper from libkolab
  *
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  * @author Aleksander Machniak <machniak@kolabsys.com>
  *
  * Copyright (C) 2011, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  *
  * @see rcube_addressbook
  */
 class rcube_kolab_contacts extends rcube_addressbook
 {
     public $primary_key = 'ID';
     public $rights   = 'lrs';
     public $readonly = true;
     public $undelete = true;
     public $groups = true;
     public $coltypes = array(
       'name'         => array('limit' => 1),
       'firstname'    => array('limit' => 1),
       'surname'      => array('limit' => 1),
       'middlename'   => array('limit' => 1),
       'prefix'       => array('limit' => 1),
       'suffix'       => array('limit' => 1),
       'nickname'     => array('limit' => 1),
       'jobtitle'     => array('limit' => 1),
       'organization' => array('limit' => 1),
       'department'   => array('limit' => 1),
       'email'        => array('subtypes' => array('home','work','other')),
       'phone'        => array(),
       'address'      => array('subtypes' => array('home','work','office')),
       'website'      => array('subtypes' => array('homepage','blog')),
       'im'           => array('subtypes' => null),
       'gender'       => array('limit' => 1),
       'birthday'     => array('limit' => 1),
       'anniversary'  => array('limit' => 1),
       'profession'   => array('type' => 'text', 'size' => 40, 'maxlength' => 80, 'limit' => 1,
                                 'label' => 'kolab_addressbook.profession', 'category' => 'personal'),
       'manager'      => array('limit' => null),
       'assistant'    => array('limit' => null),
       'spouse'       => array('limit' => 1),
       'children'     => array('type' => 'text', 'size' => 40, 'maxlength' => 80, 'limit' => null,
                                 'label' => 'kolab_addressbook.children', 'category' => 'personal'),
       'freebusyurl'  => array('type' => 'text', 'size' => 40, 'limit' => 1,
                                 'label' => 'kolab_addressbook.freebusyurl'),
       'pgppublickey' => array('type' => 'textarea', 'size' => 70, 'rows' => 10, 'limit' => 1,
                                 'label' => 'kolab_addressbook.pgppublickey'),
       'pkcs7publickey' => array('type' => 'textarea', 'size' => 70, 'rows' => 10, 'limit' => 1,
                                 'label' => 'kolab_addressbook.pkcs7publickey'),
       'notes'        => array('limit' => 1),
       'photo'        => array('limit' => 1),
       // TODO: define more Kolab-specific fields such as: language, latitude, longitude, crypto settings
     );
 
     /**
      * vCard additional fields mapping
      */
     public $vcard_map = array(
       'profession'     => 'X-PROFESSION',
       'officelocation' => 'X-OFFICE-LOCATION',
       'initials'       => 'X-INITIALS',
       'children'       => 'X-CHILDREN',
       'freebusyurl'    => 'X-FREEBUSY-URL',
       'pgppublickey'   => 'KEY',
     );
 
     /**
      * List of date type fields
      */
     public $date_cols = array('birthday', 'anniversary');
 
     private $gid;
     private $storagefolder;
     private $dataset;
     private $sortindex;
     private $contacts;
     private $distlists;
     private $groupmembers;
     private $filter;
     private $result;
     private $namespace;
     private $imap_folder = 'INBOX/Contacts';
     private $action;
 
     // list of fields used for searching in "All fields" mode
     private $search_fields = array(
       'name',
       'firstname',
       'surname',
       'middlename',
       'prefix',
       'suffix',
       'nickname',
       'jobtitle',
       'organization',
       'department',
       'email',
       'phone',
       'address',
       'profession',
       'manager',
       'assistant',
       'spouse',
       'children',
       'notes',
     );
 
 
     public function __construct($imap_folder = null)
     {
         if ($imap_folder) {
             $this->imap_folder = $imap_folder;
         }
 
         // extend coltypes configuration 
         $format = kolab_format::factory('contact');
         $this->coltypes['phone']['subtypes'] = array_keys($format->phonetypes);
         $this->coltypes['address']['subtypes'] = array_keys($format->addresstypes);
 
         $rcube = rcube::get_instance();
 
         // set localized labels for proprietary cols
         foreach ($this->coltypes as $col => $prop) {
             if (is_string($prop['label']))
                 $this->coltypes[$col]['label'] = $rcube->gettext($prop['label']);
         }
 
         // fetch objects from the given IMAP folder
         $this->storagefolder = kolab_storage::get_folder($this->imap_folder);
         $this->ready = $this->storagefolder && !PEAR::isError($this->storagefolder);
 
         // Set readonly and rights flags according to folder permissions
         if ($this->ready) {
             if ($this->storagefolder->get_owner() == $_SESSION['username']) {
                 $this->readonly = false;
                 $this->rights = 'lrswikxtea';
             }
             else {
                 $rights = $this->storagefolder->get_myrights();
                 if ($rights && !PEAR::isError($rights)) {
                     $this->rights = $rights;
                     if (strpos($rights, 'i') !== false && strpos($rights, 't') !== false)
                         $this->readonly = false;
                 }
             }
         }
 
         $this->action = rcube::get_instance()->action;
     }
 
     /**
      * Getter for the address book name to be displayed
      *
      * @return string Name of this address book
      */
     public function get_name()
     {
         return $this->storagefolder->get_name();
     }
 
     /**
      * Wrapper for kolab_storage_folder::get_foldername()
      */
     public function get_foldername()
     {
         return $this->storagefolder->get_foldername();
     }
 
     /**
      * Getter for the IMAP folder name
      *
      * @return string Name of the IMAP folder
      */
     public function get_realname()
     {
         return $this->imap_folder;
     }
 
     /**
      * Getter for the name of the namespace to which the IMAP folder belongs
      *
      * @return string Name of the namespace (personal, other, shared)
      */
     public function get_namespace()
     {
         if ($this->namespace === null && $this->ready) {
             $this->namespace = $this->storagefolder->get_namespace();
         }
 
         return $this->namespace;
     }
 
     /**
      * Getter for parent folder path
      *
      * @return string Full path to parent folder
      */
     public function get_parent()
     {
         return $this->storagefolder->get_parent();
     }
 
     /**
      * Check subscription status of this folder
      *
      * @return boolean True if subscribed, false if not
      */
     public function is_subscribed()
     {
         return kolab_storage::folder_is_subscribed($this->imap_folder);
     }
 
     /**
      * Compose an URL for CardDAV access to this address book (if configured)
      */
     public function get_carddav_url()
     {
       $rcmail = rcmail::get_instance();
       if ($template = $rcmail->config->get('kolab_addressbook_carddav_url', null)) {
         return strtr($template, array(
           '%h' => $_SERVER['HTTP_HOST'],
           '%u' => urlencode($rcmail->get_user_name()),
           '%i' => urlencode($this->storagefolder->get_uid()),
           '%n' => urlencode($this->imap_folder),
         ));
       }
 
       return false;
     }
 
     /**
      * Setter for the current group
      */
     public function set_group($gid)
     {
         $this->gid = $gid;
     }
 
 
     /**
      * Save a search string for future listings
      *
      * @param mixed Search params to use in listing method, obtained by get_search_set()
      */
     public function set_search_set($filter)
     {
         $this->filter = $filter;
     }
 
 
     /**
      * Getter for saved search properties
      *
      * @return mixed Search properties used by this class
      */
     public function get_search_set()
     {
         return $this->filter;
     }
 
 
     /**
      * Reset saved results and search parameters
      */
     public function reset()
     {
         $this->result = null;
         $this->filter = null;
     }
 
 
     /**
      * List all active contact groups of this source
      *
      * @param string Optional search string to match group name
      * @param int    Search mode. Sum of self::SEARCH_*
      *
      * @return array  Indexed list of contact groups, each a hash array
      */
     function list_groups($search = null, $mode = 0)
     {
         $this->_fetch_groups();
         $groups = array();
 
         foreach ((array)$this->distlists as $group) {
             if (!$search || strstr(mb_strtolower($group['name']), mb_strtolower($search))) {
                 $groups[$group['ID']] = array('ID' => $group['ID'], 'name' => $group['name']);
             }
         }
 
         // sort groups by name
         uasort($groups, function($a, $b) { return strcoll($a['name'], $b['name']); });
 
         return array_values($groups);
     }
 
 
     /**
      * List the current set of contact records
      *
      * @param array List of cols to show
      * @param  int  Only return this number of records, use negative values for tail
      * @param  boolean True to skip the count query (select only)
      *
      * @return array  Indexed list of contact records, each a hash array
      */
     public function list_records($cols = null, $subset = 0, $nocount = false)
     {
         $this->result = new rcube_result_set(0, ($this->list_page-1) * $this->page_size);
+
         $fetch_all = false;
+        $fast_mode = !empty($cols) && is_array($cols);
 
         // list member of the selected group
         if ($this->gid) {
             $this->_fetch_groups();
 
             $this->sortindex = array();
             $this->contacts  = array();
             $local_sortindex = array();
             $uids            = array();
 
             // get members with email specified
             foreach ((array)$this->distlists[$this->gid]['member'] as $member) {
                 // skip member that don't match the search filter
                 if (!empty($this->filter['ids']) && array_search($member['ID'], $this->filter['ids']) === false) {
                     continue;
                 }
 
                 if (!empty($member['uid'])) {
                     $uids[] = $member['uid'];
                 }
                 else if (!empty($member['email'])) {
                     $this->contacts[$member['ID']] = $member;
                     $local_sortindex[$member['ID']] = $this->_sort_string($member);
                     $fetch_all = true;
                 }
             }
 
             // get members by UID
             if (!empty($uids)) {
-                $this->_fetch_contacts($query = array(array('uid', '=', $uids)), $fetch_all ? false : count($uids));
+                $this->_fetch_contacts($query = array(array('uid', '=', $uids)), $fetch_all ? false : count($uids), $fast_mode);
                 $this->sortindex = array_merge($this->sortindex, $local_sortindex);
             }
         }
         else if (is_array($this->filter['ids'])) {
             $ids = $this->filter['ids'];
             if (count($ids)) {
                 $uids = array_map(array($this, 'id2uid'), $this->filter['ids']);
-                $this->_fetch_contacts($query = array(array('uid', '=', $uids)), count($ids));
+                $this->_fetch_contacts($query = array(array('uid', '=', $uids)), count($ids), $fast_mode);
             }
         }
         else {
-            $this->_fetch_contacts($query = 'contact', true);
+            $this->_fetch_contacts($query = 'contact', true, $fast_mode);
         }
 
         if ($fetch_all) {
             // sort results (index only)
             asort($this->sortindex, SORT_LOCALE_STRING);
             $ids = array_keys($this->sortindex);
 
             // fill contact data into the current result set
             $this->result->count = count($ids);
             $start_row = $subset < 0 ? $this->result->first + $this->page_size + $subset : $this->result->first;
             $last_row = min($subset != 0 ? $start_row + abs($subset) : $this->result->first + $this->page_size, $this->result->count);
 
             for ($i = $start_row; $i < $last_row; $i++) {
                 if (array_key_exists($i, $ids)) {
                     $idx = $ids[$i];
                     $this->result->add($this->contacts[$idx] ?: $this->_to_rcube_contact($this->dataset[$idx]));
                 }
             }
         }
         else if (!empty($this->dataset)) {
             // get all records count, skip the query if possible
             if (!isset($query) || count($this->dataset) < $this->page_size) {
                 $this->result->count = count($this->dataset) + $this->page_size * ($this->list_page - 1);
             }
             else {
                 $this->result->count = $this->storagefolder->count($query);
             }
 
             $start_row = $subset < 0 ? $this->page_size + $subset : 0;
             $last_row  = min($subset != 0 ? $start_row + abs($subset) : $this->page_size, $this->result->count);
 
             for ($i = $start_row; $i < $last_row; $i++) {
                 $this->result->add($this->_to_rcube_contact($this->dataset[$i]));
             }
         }
 
         return $this->result;
     }
 
 
     /**
      * Search records
      *
      * @param mixed   $fields   The field name of array of field names to search in
      * @param mixed   $value    Search value (or array of values when $fields is array)
      * @param int     $mode     Matching mode:
      *                          0 - partial (*abc*),
      *                          1 - strict (=),
      *                          2 - prefix (abc*)
      *                          4 - include groups (if supported)
      * @param boolean $select   True if results are requested, False if count only
      * @param boolean $nocount  True to skip the count query (select only)
      * @param array   $required List of fields that cannot be empty
      *
      * @return object rcube_result_set List of contact records and 'count' value
      */
     public function search($fields, $value, $mode=0, $select=true, $nocount=false, $required=array())
     {
         // search by ID
         if ($fields == $this->primary_key) {
             $ids    = !is_array($value) ? explode(',', $value) : $value;
             $result = new rcube_result_set();
 
             foreach ($ids as $id) {
                 if ($rec = $this->get_record($id, true)) {
                     $result->add($rec);
                     $result->count++;
                 }
             }
             return $result;
         }
         else if ($fields == '*') {
             $fields = $this->search_fields;
         }
 
         if (!is_array($fields))
             $fields = array($fields);
         if (!is_array($required) && !empty($required))
             $required = array($required);
 
         // advanced search
         if (is_array($value)) {
             $advanced = true;
             $value = array_map('mb_strtolower', $value);
         }
         else
             $value = mb_strtolower($value);
 
         $scount = count($fields);
         // build key name regexp
         $regexp = '/^(' . implode($fields, '|') . ')(?:.*)$/';
 
         // pass query to storage if only indexed cols are involved
         // NOTE: this is only some rough pre-filtering but probably includes false positives
         $squery = $this->_search_query($fields, $value, $mode);
 
         // add magic selector to select contacts with birthday dates only
         if (in_array('birthday', $required)) {
             $squery[] = array('tags', '=', 'x-has-birthday');
         }
 
         $squery[] = array('type', '=', 'contact');
 
         // get all/matching records
         $this->_fetch_contacts($squery);
 
         // save searching conditions
         $this->filter = array('fields' => $fields, 'value' => $value, 'mode' => $mode, 'ids' => array());
 
         // search by iterating over all records in dataset
         foreach ($this->dataset as $record) {
             $contact = $this->_to_rcube_contact($record);
             $id = $contact['ID'];
 
             // check if current contact has required values, otherwise skip it
             if ($required) {
                 foreach ($required as $f) {
                     // required field might be 'email', but contact might contain 'email:home'
                     if (!($v = rcube_addressbook::get_col_values($f, $contact, true)) || empty($v)) {
                         continue 2;
                     }
                 }
             }
 
             $found = array();
             $contents = '';
             foreach (preg_grep($regexp, array_keys($contact)) as $col) {
                 $pos     = strpos($col, ':');
                 $colname = $pos ? substr($col, 0, $pos) : $col;
 
                 foreach ((array)$contact[$col] as $val) {
                     if ($advanced) {
                         $found[$colname] = $this->compare_search_value($colname, $val, $value[array_search($colname, $fields)], $mode);
                     }
                     else {
                         $contents .= ' ' . join(' ', (array)$val);
                     }
                 }
             }
 
             // compare matches
             if (($advanced && count($found) >= $scount) ||
                 (!$advanced && rcube_utils::words_match(mb_strtolower($contents), $value))) {
                 $this->filter['ids'][] = $id;
             }
         }
 
         // dummy result with contacts count
         if (!$select) {
             return new rcube_result_set(count($this->filter['ids']), ($this->list_page-1) * $this->page_size);
         }
 
         // list records (now limited by $this->filter)
         return $this->list_records();
     }
 
 
     /**
      * Refresh saved search results after data has changed
      */
     public function refresh_search()
     {
         if ($this->filter)
             $this->search($this->filter['fields'], $this->filter['value'], $this->filter['mode']);
 
         return $this->get_search_set();
     }
 
 
     /**
      * Count number of available contacts in database
      *
      * @return rcube_result_set Result set with values for 'count' and 'first'
      */
     public function count()
     {
         if ($this->gid) {
             $this->_fetch_groups();
             $count = count($this->distlists[$this->gid]['member']);
         }
         else if (is_array($this->filter['ids'])) {
             $count = count($this->filter['ids']);
         }
         else {
             $count = $this->storagefolder->count('contact');
         }
 
         return new rcube_result_set($count, ($this->list_page-1) * $this->page_size);
     }
 
 
     /**
      * Return the last result set
      *
      * @return rcube_result_set Current result set or NULL if nothing selected yet
      */
     public function get_result()
     {
         return $this->result;
     }
 
 
     /**
      * Get a specific contact record
      *
      * @param mixed record identifier(s)
      * @param boolean True to return record as associative array, otherwise a result set is returned
      * @return mixed Result object with all record fields or False if not found
      */
     public function get_record($id, $assoc=false)
     {
         $rec = null;
         $uid = $this->id2uid($id);
         $rev = rcube_utils::get_input_value('_rev', rcube_utils::INPUT_GPC);
 
         if (strpos($uid, 'mailto:') === 0) {
             $this->_fetch_groups(true);
             $rec = $this->contacts[$id];
             $this->readonly = true;  // set source to read-only
         }
         else if (!empty($rev)) {
             $rcmail = rcube::get_instance();
             $plugin = $rcmail->plugins->get_plugin('kolab_addressbook');
             if ($plugin && ($object = $plugin->get_revision($id, kolab_storage::id_encode($this->imap_folder), $rev))) {
                 $rec = $this->_to_rcube_contact($object);
                 $rec['rev'] = $rev;
             }
             $this->readonly = true;  // set source to read-only
         }
         else if ($object = $this->storagefolder->get_object($uid)) {
             $rec = $this->_to_rcube_contact($object);
         }
 
         if ($rec) {
             $this->result = new rcube_result_set(1);
             $this->result->add($rec);
             return $assoc ? $rec : $this->result;
         }
 
         return false;
     }
 
 
     /**
      * Get group assignments of a specific contact record
      *
      * @param mixed Record identifier
      * @return array List of assigned groups as ID=>Name pairs
      */
     public function get_record_groups($id)
     {
         $out = array();
         $this->_fetch_groups();
 
         foreach ((array)$this->groupmembers[$id] as $gid) {
             if ($group = $this->distlists[$gid])
                 $out[$gid] = $group['name'];
         }
 
         return $out;
     }
 
 
     /**
      * Create a new contact record
      *
      * @param array Assoziative array with save data
      *  Keys:   Field name with optional section in the form FIELD:SECTION
      *  Values: Field value. Can be either a string or an array of strings for multiple values
      * @param boolean True to check for duplicates first
      * @return mixed The created record ID on success, False on error
      */
     public function insert($save_data, $check=false)
     {
         if (!is_array($save_data))
             return false;
 
         $insert_id = $existing = false;
 
         // check for existing records by e-mail comparison
         if ($check) {
             foreach ($this->get_col_values('email', $save_data, true) as $email) {
                 if (($res = $this->search('email', $email, true, false)) && $res->count) {
                     $existing = true;
                     break;
                 }
             }
         }
 
         if (!$existing) {
             // remove existing id attributes (#1101)
             unset($save_data['ID'], $save_data['uid']);
 
             // generate new Kolab contact item
             $object = $this->_from_rcube_contact($save_data);
             $saved  = $this->storagefolder->save($object, 'contact');
 
             if (!$saved) {
                 rcube::raise_error(array(
                   'code' => 600, 'type' => 'php',
                   'file' => __FILE__, 'line' => __LINE__,
                   'message' => "Error saving contact object to Kolab server"),
                 true, false);
             }
             else {
                 $insert_id = $this->uid2id($object['uid']);
             }
         }
 
         return $insert_id;
     }
 
 
     /**
      * Update a specific contact record
      *
      * @param mixed Record identifier
      * @param array Assoziative array with save data
      *  Keys:   Field name with optional section in the form FIELD:SECTION
      *  Values: Field value. Can be either a string or an array of strings for multiple values
      * @return boolean True on success, False on error
      */
     public function update($id, $save_data)
     {
         $updated = false;
         if ($old = $this->storagefolder->get_object($this->id2uid($id))) {
             $object = $this->_from_rcube_contact($save_data, $old);
 
             if (!$this->storagefolder->save($object, 'contact', $old['uid'])) {
                 rcube::raise_error(array(
                   'code' => 600, 'type' => 'php',
                   'file' => __FILE__, 'line' => __LINE__,
                   'message' => "Error saving contact object to Kolab server"),
                 true, false);
             }
             else {
                 $updated = true;
 
                 // TODO: update data in groups this contact is member of
             }
         }
 
         return $updated;
     }
 
 
     /**
      * Mark one or more contact records as deleted
      *
      * @param array   Record identifiers
      * @param boolean Remove record(s) irreversible (mark as deleted otherwise)
      *
      * @return int Number of records deleted
      */
     public function delete($ids, $force=true)
     {
         $this->_fetch_groups();
 
         if (!is_array($ids))
             $ids = explode(',', $ids);
 
         $count = 0;
         foreach ($ids as $id) {
             if ($uid = $this->id2uid($id)) {
                 $is_mailto = strpos($uid, 'mailto:') === 0;
                 $deleted = $is_mailto || $this->storagefolder->delete($uid, $force);
 
                 if (!$deleted) {
                     rcube::raise_error(array(
                       'code' => 600, 'type' => 'php',
                       'file' => __FILE__, 'line' => __LINE__,
                       'message' => "Error deleting a contact object $uid from the Kolab server"),
                     true, false);
                 }
                 else {
                     // remove from distribution lists
                     foreach ((array)$this->groupmembers[$id] as $gid) {
                         if (!$is_mailto || $gid == $this->gid)
                             $this->remove_from_group($gid, $id);
                     }
 
                     // clear internal cache
                     unset($this->groupmembers[$id]);
                     $count++;
                 }
             }
         }
 
         return $count;
     }
 
 
     /**
      * Undelete one or more contact records.
      * Only possible just after delete (see 2nd argument of delete() method).
      *
      * @param array  Record identifiers
      *
      * @return int Number of records restored
      */
     public function undelete($ids)
     {
         if (!is_array($ids))
             $ids = explode(',', $ids);
 
         $count = 0;
         foreach ($ids as $id) {
             $uid = $this->id2uid($id);
             if ($this->storagefolder->undelete($uid)) {
                 $count++;
             }
             else {
                 rcube::raise_error(array(
                   'code' => 600, 'type' => 'php',
                   'file' => __FILE__, 'line' => __LINE__,
                   'message' => "Error undeleting a contact object $uid from the Kolab server"),
                 true, false);
             }
         }
 
         return $count;
     }
 
 
     /**
      * Remove all records from the database
      *
      * @param bool $with_groups Remove also groups
      */
     public function delete_all($with_groups = false)
     {
         if ($this->storagefolder->delete_all()) {
             $this->contacts  = array();
             $this->sortindex = array();
             $this->dataset   = null;
             $this->result    = null;
         }
     }
 
 
     /**
      * Close connection to source
      * Called on script shutdown
      */
     public function close()
     {
     }
 
 
     /**
      * Create a contact group with the given name
      *
      * @param string The group name
      * @return mixed False on error, array with record props in success
      */
     function create_group($name)
     {
         $this->_fetch_groups();
         $result = false;
 
         $list = array(
             'name' => $name,
             'member' => array(),
         );
         $saved = $this->storagefolder->save($list, 'distribution-list');
 
         if (!$saved) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error saving distribution-list object to Kolab server"),
             true, false);
             return false;
         }
         else {
             $id = $this->uid2id($list['uid']);
             $this->distlists[$id] = $list;
             $result = array('id' => $id, 'name' => $name);
         }
 
         return $result;
     }
 
     /**
      * Delete the given group and all linked group members
      *
      * @param string Group identifier
      * @return boolean True on success, false if no data was changed
      */
     function delete_group($gid)
     {
         $this->_fetch_groups();
         $result = false;
 
         if ($list = $this->distlists[$gid]) {
             $deleted = $this->storagefolder->delete($list['uid']);
         }
 
         if (!$deleted) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error deleting distribution-list object from the Kolab server"),
             true, false);
         }
         else {
             $result = true;
         }
 
         return $result;
     }
 
     /**
      * Rename a specific contact group
      *
      * @param string Group identifier
      * @param string New name to set for this group
      * @param string New group identifier (if changed, otherwise don't set)
      *
      * @return boolean New name on success, false if no data was changed
      */
     function rename_group($gid, $newname, &$newid)
     {
         $this->_fetch_groups();
         $list = $this->distlists[$gid];
 
         if ($newname != $list['name']) {
             $list['name'] = $newname;
             $saved = $this->storagefolder->save($list, 'distribution-list', $list['uid']);
         }
 
         if (!$saved) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error saving distribution-list object to Kolab server"),
             true, false);
             return false;
         }
 
         return $newname;
     }
 
     /**
      * Add the given contact records the a certain group
      *
      * @param string  Group identifier
      * @param array   List of contact identifiers to be added
      * @return int    Number of contacts added
      */
     function add_to_group($gid, $ids)
     {
         if (!is_array($ids)) {
             $ids = explode(',', $ids);
         }
 
         $this->_fetch_groups(true);
 
         $list   = $this->distlists[$gid];
         $added  = 0;
         $uids   = array();
         $exists = array();
 
         foreach ((array)$list['member'] as $member) {
             $exists[] = $member['ID'];
         }
 
         // substract existing assignments from list
         $ids = array_unique(array_diff($ids, $exists));
 
         // add mailto: members
         foreach ($ids as $contact_id) {
             $uid = $this->id2uid($contact_id);
             if (strpos($uid, 'mailto:') === 0 && ($contact = $this->contacts[$contact_id])) {
                 $list['member'][] = array(
                     'email' => $contact['email'],
                     'name'  => $contact['name'],
                 );
                 $this->groupmembers[$contact_id][] = $gid;
                 $added++;
             }
             else {
                 $uids[$uid] = $contact_id;
             }
         }
 
         // add members with UID
         if (!empty($uids)) {
             foreach ($uids as $uid => $contact_id) {
                 $list['member'][] = array('uid' => $uid);
                 $this->groupmembers[$contact_id][] = $gid;
                 $added++;
             }
         }
 
         if ($added)
             $saved = $this->storagefolder->save($list, 'distribution-list', $list['uid']);
         else
             $saved = true;
 
         if (!$saved) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error saving distribution-list to Kolab server"),
             true, false);
             $added = false;
             $this->set_error(self::ERROR_SAVING, 'errorsaving');
         }
         else {
             $this->distlists[$gid] = $list;
         }
 
         return $added;
     }
 
     /**
      * Remove the given contact records from a certain group
      *
      * @param string  Group identifier
      * @param array   List of contact identifiers to be removed
      * @return int    Number of deleted group members
      */
     function remove_from_group($gid, $ids)
     {
         if (!is_array($ids))
             $ids = explode(',', $ids);
 
         $this->_fetch_groups();
         if (!($list = $this->distlists[$gid]))
             return false;
 
         $new_member = array();
         foreach ((array)$list['member'] as $member) {
             if (!in_array($member['ID'], $ids))
                 $new_member[] = $member;
         }
 
         // write distribution list back to server
         $list['member'] = $new_member;
         $saved = $this->storagefolder->save($list, 'distribution-list', $list['uid']);
 
         if (!$saved) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error saving distribution-list object to Kolab server"),
             true, false);
         }
         else {
             // remove group assigments in local cache
             foreach ($ids as $id) {
                 $j = array_search($gid, $this->groupmembers[$id]);
                 unset($this->groupmembers[$id][$j]);
             }
             $this->distlists[$gid] = $list;
             return true;
         }
 
         return false;
     }
 
     /**
      * Check the given data before saving.
      * If input not valid, the message to display can be fetched using get_error()
      *
      * @param array Associative array with contact data to save
      * @param bool  Attempt to fix/complete data automatically
      *
      * @return boolean True if input is valid, False if not.
      */
     public function validate(&$save_data, $autofix = false)
     {
         // validate e-mail addresses
         $valid = parent::validate($save_data);
 
         // require at least one e-mail address if there's no name
         // (syntax check is already done)
         if ($valid) {
             if (!strlen($save_data['name'])
                 && !strlen($save_data['organization'])
                 && !array_filter($this->get_col_values('email', $save_data, true))
             ) {
                 $this->set_error('warning', 'kolab_addressbook.noemailnamewarning');
                 $valid = false;
             }
         }
 
         return $valid;
     }
 
     /**
      * Query storage layer and store records in private member var
      */
-    private function _fetch_contacts($query = array(), $limit = false)
+    private function _fetch_contacts($query = array(), $limit = false, $fast_mode = false)
     {
         if (!isset($this->dataset) || !empty($query)) {
             if ($limit) {
                 $size = is_int($limit) && $limit < $this->page_size ? $limit : $this->page_size;
                 $this->storagefolder->set_order_and_limit($this->_sort_columns(), $size, ($this->list_page-1) * $this->page_size);
             }
 
             $this->sortindex = array();
-            $this->dataset   = $this->storagefolder->select($query);
+            $this->dataset   = $this->storagefolder->select($query, $fast_mode);
 
             foreach ($this->dataset as $idx => $record) {
                 $contact = $this->_to_rcube_contact($record);
                 $this->sortindex[$idx] = $this->_sort_string($contact);
             }
         }
     }
 
     /**
      * Extract a string for sorting from the given contact record
      */
     private function _sort_string($rec)
     {
         $str = '';
 
         switch ($this->sort_col) {
         case 'name':
             $str = $rec['name'] . $rec['prefix'];
         case 'firstname':
             $str .= $rec['firstname'] . $rec['middlename'] . $rec['surname'];
             break;
 
         case 'surname':
             $str = $rec['surname'] . $rec['firstname'] . $rec['middlename'];
             break;
 
         default:
             $str = $rec[$this->sort_col];
             break;
         }
 
         $str .= is_array($rec['email']) ? $rec['email'][0] : $rec['email'];
         return mb_strtolower($str);
     }
 
     /**
      * Return the cache table columns to order by
      */
     private function _sort_columns()
     {
         $sortcols = array();
 
         switch ($this->sort_col) {
         case 'name':
             $sortcols[] = 'name';
         case 'firstname':
             $sortcols[] = 'firstname';
             break;
 
         case 'surname':
             $sortcols[] = 'surname';
             break;
         }
 
         $sortcols[] = 'email';
         return $sortcols;
     }
 
     /**
      * Read distribution-lists AKA groups from server
      */
     private function _fetch_groups($with_contacts = false)
     {
         if (!isset($this->distlists)) {
             $this->distlists = $this->groupmembers = array();
-            foreach ($this->storagefolder->select('distribution-list') as $record) {
+            foreach ($this->storagefolder->select('distribution-list', true) as $record) {
                 $record['ID'] = $this->uid2id($record['uid']);
                 foreach ((array)$record['member'] as $i => $member) {
                     $mid = $this->uid2id($member['uid'] ? $member['uid'] : 'mailto:' . $member['email']);
                     $record['member'][$i]['ID'] = $mid;
                     $record['member'][$i]['readonly'] = empty($member['uid']);
                     $this->groupmembers[$mid][] = $record['ID'];
 
-                    if ($with_contacts && empty($member['uid']))
+                    if ($with_contacts && empty($member['uid'])) {
                         $this->contacts[$mid] = $record['member'][$i];
+                    }
                 }
                 $this->distlists[$record['ID']] = $record;
             }
         }
     }
 
     /**
      * Encode object UID into a safe identifier
      */
     public function uid2id($uid)
     {
         return rtrim(strtr(base64_encode($uid), '+/', '-_'), '=');
     }
 
     /**
      * Convert Roundcube object identifier back into the original UID
      */
     public function id2uid($id)
     {
         return base64_decode(str_pad(strtr($id, '-_', '+/'), strlen($id) % 4, '=', STR_PAD_RIGHT));
     }
 
     /**
      * Build SQL query for fulltext matches
      */
     private function _search_query($fields, $value, $mode)
     {
         $query = array();
         $cols  = array();
 
         // $fulltext_cols might contain composite field names e.g. 'email:address' while $fields not
         foreach (kolab_format_contact::$fulltext_cols as $col) {
             if ($pos = strpos($col, ':')) {
                 $col = substr($col, 0, $pos);
             }
             if (in_array($col, $fields)) {
                 $cols[] = $col;
             }
         }
 
         if (count($cols) == count($fields)) {
             if ($mode & rcube_addressbook::SEARCH_STRICT) {
                 $prefix = '^'; $suffix = '$';
             }
             else if ($mode & rcube_addressbook::SEARCH_PREFIX) {
                 $prefix = '^'; $suffix = '';
             }
             else {
                 $prefix = ''; $suffix = '';
             }
 
             $search_string = is_array($value) ? join(' ', $value) : $value;
             foreach (rcube_utils::normalize_string($search_string, true) as $word) {
                 $query[] = array('words', 'LIKE', $prefix . $word . $suffix);
             }
         }
 
         return $query;
     }
 
     /**
      * Map fields from internal Kolab_Format to Roundcube contact format
      */
     private function _to_rcube_contact($record)
     {
         $record['ID'] = $this->uid2id($record['uid']);
 
         // convert email, website, phone values
         foreach (array('email'=>'address', 'website'=>'url', 'phone'=>'number') as $col => $propname) {
             if (is_array($record[$col])) {
                 $values = $record[$col];
                 unset($record[$col]);
                 foreach ((array)$values as $i => $val) {
                     $key = $col . ($val['type'] ? ':' . $val['type'] : '');
                     $record[$key][] = $val[$propname];
                 }
             }
         }
 
         if (is_array($record['address'])) {
             $addresses = $record['address'];
             unset($record['address']);
             foreach ($addresses as $i => $adr) {
                 $key = 'address' . ($adr['type'] ? ':' . $adr['type'] : '');
                 $record[$key][] = array(
                     'street'   => $adr['street'],
                     'locality' => $adr['locality'],
                     'zipcode'  => $adr['code'],
                     'region'   => $adr['region'],
                     'country'  => $adr['country'],
                 );
             }
         }
 
         // photo is stored as separate attachment
         if ($record['photo'] && strlen($record['photo']) < 255 && ($att = $record['_attachments'][$record['photo']])) {
             // only fetch photo content if requested
             if ($this->action == 'photo')
                 $record['photo'] = $att['content'] ? $att['content'] : $this->storagefolder->get_attachment($record['uid'], $att['id']);
         }
 
         // truncate publickey value for display
         if ($record['pgppublickey'] && $this->action == 'show')
             $record['pgppublickey'] = substr($record['pgppublickey'], 0, 140) . '...';
 
         // remove empty fields
         $record = array_filter($record);
 
         // remove kolab_storage internal data
         unset($record['_msguid'], $record['_formatobj'], $record['_mailbox'], $record['_type'], $record['_size']);
 
         return $record;
     }
 
     /**
      * Map fields from Roundcube format to internal kolab_format_contact properties
      */
     private function _from_rcube_contact($contact, $old = array())
     {
         if (!$contact['uid'] && $contact['ID'])
             $contact['uid'] = $this->id2uid($contact['ID']);
         else if (!$contact['uid'] && $old['uid'])
             $contact['uid'] = $old['uid'];
 
         $contact['im'] = array_filter($this->get_col_values('im', $contact, true));
 
         // convert email, website, phone values
         foreach (array('email'=>'address', 'website'=>'url', 'phone'=>'number') as $col => $propname) {
             $col_values = $this->get_col_values($col, $contact);
             $contact[$col] = array();
             foreach ($col_values as $type => $values) {
                 foreach ((array)$values as $val) {
                     if (!empty($val)) {
                         $contact[$col][] = array($propname => $val, 'type' => $type);
                     }
                 }
                 unset($contact[$col.':'.$type]);
             }
         }
 
         $addresses = array();
         foreach ($this->get_col_values('address', $contact) as $type => $values) {
             foreach ((array)$values as $adr) {
                 // skip empty address
                 $adr = array_filter($adr);
                 if (empty($adr))
                     continue;
 
                 $addresses[] = array(
                     'type' => $type,
                     'street' => $adr['street'],
                     'locality' => $adr['locality'],
                     'code' => $adr['zipcode'],
                     'region' => $adr['region'],
                     'country' => $adr['country'],
                 );
             }
 
             unset($contact['address:'.$type]);
         }
 
         $contact['address'] = $addresses;
 
         // categories are not supported in the web client but should be preserved (#2608)
         $contact['categories'] = $old['categories'];
 
         // copy meta data (starting with _) from old object
         foreach ((array)$old as $key => $val) {
             if (!isset($contact[$key]) && $key[0] == '_')
                 $contact[$key] = $val;
         }
 
         // convert one-item-array elements into string element
         // this is needed e.g. to properly import birthday field
         foreach ($this->coltypes as $type => $col_def) {
             if ($col_def['limit'] == 1 && is_array($contact[$type])) {
                 $contact[$type] = array_shift(array_filter($contact[$type]));
             }
         }
 
         // When importing contacts 'vcard' data is added, we don't need it (Bug #1711)
         unset($contact['vcard']);
 
         // add empty values for some fields which can be removed in the UI
         return array_filter($contact) + array('nickname' => '', 'birthday' => '', 'anniversary' => '', 'freebusyurl' => '', 'photo' => $contact['photo']);
     }
 
 }
diff --git a/plugins/kolab_notes/kolab_notes.php b/plugins/kolab_notes/kolab_notes.php
index 34f0d3c5..9d1c240d 100644
--- a/plugins/kolab_notes/kolab_notes.php
+++ b/plugins/kolab_notes/kolab_notes.php
@@ -1,1482 +1,1482 @@
 <?php
 
 /**
  * Kolab notes module
  *
  * Adds simple notes management features to the web client
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2014-2015, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class kolab_notes extends rcube_plugin
 {
     public $task = '?(?!login|logout).*';
     public $allowed_prefs = array('kolab_notes_sort_col');
     public $rc;
 
     private $ui;
     private $lists;
     private $folders;
     private $cache = array();
     private $message_notes = array();
     private $bonnie_api = false;
 
     /**
      * Required startup method of a Roundcube plugin
      */
     public function init()
     {
         $this->require_plugin('libkolab');
 
         $this->rc = rcube::get_instance();
 
         // proceed initialization in startup hook
         $this->add_hook('startup', array($this, 'startup'));
     }
 
     /**
      * Startup hook
      */
     public function startup($args)
     {
         // the notes module can be enabled/disabled by the kolab_auth plugin
         if ($this->rc->config->get('kolab_notes_disabled', false) || !$this->rc->config->get('kolab_notes_enabled', true)) {
             return;
         }
 
         $this->register_task('notes');
 
         // load plugin configuration
         $this->load_config();
 
         // load localizations
         $this->add_texts('localization/', $args['task'] == 'notes' && (!$args['action'] || $args['action'] == 'dialog-ui'));
         $this->rc->load_language($_SESSION['language'], array('notes.notes' => $this->gettext('navtitle')));  // add label for task title
 
         if ($args['task'] == 'notes') {
             $this->add_hook('storage_init', array($this, 'storage_init'));
 
             // register task actions
             $this->register_action('index', array($this, 'notes_view'));
             $this->register_action('fetch', array($this, 'notes_fetch'));
             $this->register_action('get',   array($this, 'note_record'));
             $this->register_action('action', array($this, 'note_action'));
             $this->register_action('list',  array($this, 'list_action'));
             $this->register_action('dialog-ui', array($this, 'dialog_view'));
             $this->register_action('print', array($this, 'print_note'));
 
             if (!$this->rc->output->ajax_call && in_array($args['action'], array('dialog-ui', 'list'))) {
                 $this->load_ui();
             }
         }
         else if ($args['task'] == 'mail') {
             $this->add_hook('storage_init', array($this, 'storage_init'));
             $this->add_hook('message_compose', array($this, 'mail_message_compose'));
 
             if (in_array($args['action'], array('show', 'preview', 'print'))) {
                 $this->add_hook('message_load', array($this, 'mail_message_load'));
                 $this->add_hook('template_object_messagebody', array($this, 'mail_messagebody_html'));
             }
 
             // add 'Append note' item to message menu
             if ($this->api->output->type == 'html' && $_REQUEST['_rel'] != 'note') {
                 $this->api->add_content(html::tag('li', array('role' => 'menuitem'),
                     $this->api->output->button(array(
                       'command'  => 'append-kolab-note',
                       'label'    => 'kolab_notes.appendnote',
                       'type'     => 'link',
                       'classact' => 'icon appendnote active',
                       'class'    => 'icon appendnote disabled',
                       'innerclass' => 'icon note',
                     ))),
                     'messagemenu');
 
                 $this->api->output->add_label('kolab_notes.appendnote', 'kolab_notes.editnote', 'kolab_notes.deletenotesconfirm', 'kolab_notes.entertitle', 'save', 'delete', 'cancel', 'close');
                 $this->include_script('notes_mail.js');
             }
         }
 
         if (!$this->rc->output->ajax_call && !$this->rc->output->env['framed']) {
             $this->load_ui();
         }
 
         // get configuration for the Bonnie API
         $this->bonnie_api = libkolab::get_bonnie_api();
 
         // notes use fully encoded identifiers
         kolab_storage::$encode_ids = true;
     }
 
     /**
      * Hook into IMAP FETCH HEADER.FIELDS command and request MESSAGE-ID
      */
     public function storage_init($p)
     {
         $p['fetch_headers'] = trim($p['fetch_headers'] . ' MESSAGE-ID');
         return $p;
     }
 
     /**
      * Load and initialize UI class
      */
     private function load_ui()
     {
         if (!$this->ui) {
             require_once($this->home . '/kolab_notes_ui.php');
             $this->ui = new kolab_notes_ui($this);
             $this->ui->init();
         }
     }
 
     /**
      * Read available calendars for the current user and store them internally
      */
     private function _read_lists($force = false)
     {
         // already read sources
         if (isset($this->lists) && !$force)
             return $this->lists;
 
         // get all folders that have type "task"
         $folders = kolab_storage::sort_folders(kolab_storage::get_folders('note'));
         $this->lists = $this->folders = array();
 
         // find default folder
         $default_index = 0;
         foreach ($folders as $i => $folder) {
             if ($folder->default)
                 $default_index = $i;
         }
 
         // put default folder on top of the list
         if ($default_index > 0) {
             $default_folder = $folders[$default_index];
             unset($folders[$default_index]);
             array_unshift($folders, $default_folder);
         }
 
         foreach ($folders as $folder) {
             $item = $this->folder_props($folder);
             $this->lists[$item['id']] = $item;
             $this->folders[$item['id']] = $folder;
             $this->folders[$folder->name] = $folder;
         }
     }
 
     /**
      * Get a list of available folders from this source
      */
     public function get_lists(&$tree = null)
     {
         $this->_read_lists();
 
         // attempt to create a default folder for this user
         if (empty($this->lists)) {
             $folder = array('name' => 'Notes', 'type' => 'note', 'default' => true, 'subscribed' => true);
             if (kolab_storage::folder_update($folder)) {
                 $this->_read_lists(true);
             }
         }
 
         $folders = array();
         foreach ($this->lists as $id => $list) {
             if (!empty($this->folders[$id])) {
                 $folders[] = $this->folders[$id];
             }
         }
 
         // include virtual folders for a full folder tree
         if (!is_null($tree)) {
             $folders = kolab_storage::folder_hierarchy($folders, $tree);
         }
 
         $delim = $this->rc->get_storage()->get_hierarchy_delimiter();
 
         $lists = array();
         foreach ($folders as $folder) {
             $list_id = $folder->id;
             $imap_path = explode($delim, $folder->name);
 
             // find parent
             do {
               array_pop($imap_path);
               $parent_id = kolab_storage::folder_id(join($delim, $imap_path));
             }
             while (count($imap_path) > 1 && !$this->folders[$parent_id]);
 
             // restore "real" parent ID
             if ($parent_id && !$this->folders[$parent_id]) {
                 $parent_id = kolab_storage::folder_id($folder->get_parent());
             }
 
             $fullname = $folder->get_name();
             $listname = $folder->get_foldername();
 
             // special handling for virtual folders
             if ($folder instanceof kolab_storage_folder_user) {
                 $lists[$list_id] = array(
                     'id'       => $list_id,
                     'name'     => $fullname,
                     'listname' => $listname,
                     'title'    => $folder->get_title(),
                     'virtual'  => true,
                     'editable' => false,
                     'rights'   => 'l',
                     'group'    => 'other virtual',
                     'class'    => 'user',
                     'parent'   => $parent_id,
                 );
             }
             else if ($folder->virtual) {
                 $lists[$list_id] = array(
                     'id'       => $list_id,
                     'name'     => $fullname,
                     'listname' => $listname,
                     'virtual'  => true,
                     'editable' => false,
                     'rights'   => 'l',
                     'group'    => $folder->get_namespace(),
                     'parent'   => $parent_id,
                 );
             }
             else {
                 if (!$this->lists[$list_id]) {
                     $this->lists[$list_id] = $this->folder_props($folder);
                     $this->folders[$list_id] = $folder;
                 }
                 $this->lists[$list_id]['parent'] = $parent_id;
                 $lists[$list_id] = $this->lists[$list_id];
             }
         }
 
         return $lists;
     }
 
     /**
      * Search for shared or otherwise not listed folders the user has access
      *
      * @param string Search string
      * @param string Section/source to search
      * @return array List of notes folders
      */
     protected function search_lists($query, $source)
     {
         if (!kolab_storage::setup()) {
             return array();
         }
 
         $this->search_more_results = false;
         $this->lists = $this->folders = array();
 
         // find unsubscribed IMAP folders that have "event" type
         if ($source == 'folders') {
             foreach ((array)kolab_storage::search_folders('note', $query, array('other')) as $folder) {
                 $this->folders[$folder->id] = $folder;
                 $this->lists[$folder->id] = $this->folder_props($folder);
             }
         }
         // search other user's namespace via LDAP
         else if ($source == 'users') {
             $limit = $this->rc->config->get('autocomplete_max', 15) * 2;  // we have slightly more space, so display twice the number
             foreach (kolab_storage::search_users($query, 0, array(), $limit * 10) as $user) {
                 $folders = array();
                 // search for note folders shared by this user
                 foreach (kolab_storage::list_user_folders($user, 'note', false) as $foldername) {
                     $folders[] = new kolab_storage_folder($foldername, 'note');
                 }
 
                 if (count($folders)) {
                     $userfolder = new kolab_storage_folder_user($user['kolabtargetfolder'], '', $user);
                     $this->folders[$userfolder->id] = $userfolder;
                     $this->lists[$userfolder->id] = $this->folder_props($userfolder);
 
                     foreach ($folders as $folder) {
                         $this->folders[$folder->id] = $folder;
                         $this->lists[$folder->id] = $this->folder_props($folder);
                         $count++;
                     }
                 }
 
                 if ($count >= $limit) {
                     $this->search_more_results = true;
                     break;
                 }
             }
 
         }
 
         return $this->get_lists();
     }
 
     /**
      * Derive list properties from the given kolab_storage_folder object
      */
     protected function folder_props($folder)
     {
         if ($folder->get_namespace() == 'personal') {
             $norename = false;
             $editable = true;
             $rights = 'lrswikxtea';
             $alarms = true;
         }
         else {
             $alarms = false;
             $rights = 'lr';
             $editable = false;
             if (($myrights = $folder->get_myrights()) && !PEAR::isError($myrights)) {
                 $rights = $myrights;
                 if (strpos($rights, 't') !== false || strpos($rights, 'd') !== false)
                     $editable = strpos($rights, 'i');
             }
             $info = $folder->get_folder_info();
             $norename = $readonly || $info['norename'] || $info['protected'];
         }
 
         $list_id = $folder->id;
         return array(
             'id' => $list_id,
             'name' => $folder->get_name(),
             'listname' => $folder->get_foldername(),
             'editname' => $folder->get_foldername(),
             'editable' => $editable,
             'rights'   => $rights,
             'norename' => $norename,
             'parentfolder' => $folder->get_parent(),
             'subscribed' => (bool)$folder->is_subscribed(),
             'default'  => $folder->default,
             'group'    => $folder->default ? 'default' : $folder->get_namespace(),
             'class'    => trim($folder->get_namespace() . ($folder->default ? ' default' : '')),
         );
     }
 
     /**
      * Get the kolab_calendar instance for the given calendar ID
      *
      * @param string List identifier (encoded imap folder name)
      * @return object kolab_storage_folder Object nor null if list doesn't exist
      */
     public function get_folder($id)
     {
         // create list and folder instance if necesary
         if (!$this->lists[$id]) {
             $folder = kolab_storage::get_folder(kolab_storage::id_decode($id));
             if ($folder->type) {
                 $this->folders[$id] = $folder;
                 $this->lists[$id] = $this->folder_props($folder);
             }
         }
 
         return $this->folders[$id];
     }
 
     /*******  UI functions  ********/
 
     /**
      * Render main view of the tasklist task
      */
     public function notes_view()
     {
         $this->ui->init();
         $this->ui->init_templates();
         $this->rc->output->set_pagetitle($this->gettext('navtitle'));
         $this->rc->output->send('kolab_notes.notes');
     }
 
     /**
      * Deliver a rediced UI for inline (dialog)
      */
     public function dialog_view()
     {
         // resolve message reference
         if ($msgref = rcube_utils::get_input_value('_msg', rcube_utils::INPUT_GPC, true)) {
             $storage = $this->rc->get_storage();
             list($uid, $folder) = explode('-', $msgref, 2);
             if ($message = $storage->get_message_headers($msgref)) {
                 $this->rc->output->set_env('kolab_notes_template', array(
                     '_from_mail' => true,
                     'title' => $message->get('subject'),
                     'links' => array(kolab_storage_config::get_message_reference(
                         kolab_storage_config::get_message_uri($message, $folder),
                         'note'
                     )),
                 ));
             }
         }
 
         $this->ui->init_templates();
         $this->rc->output->send('kolab_notes.dialogview');
     }
 
     /**
      * Handler to retrieve note records for the given list and/or search query
      */
     public function notes_fetch()
     {
         $search = rcube_utils::get_input_value('_q', rcube_utils::INPUT_GPC, true);
         $list   = rcube_utils::get_input_value('_list', rcube_utils::INPUT_GPC);
 
         $data = $this->notes_data($this->list_notes($list, $search), $tags);
 
         $this->rc->output->command('plugin.data_ready', array(
                 'list'   => $list,
                 'search' => $search,
                 'data'   => $data,
                 'tags'   => array_values($tags)
         ));
     }
 
     /**
      * Convert the given note records for delivery to the client
      */
     protected function notes_data($records, &$tags)
     {
         $config = kolab_storage_config::get_instance();
         $tags   = $config->apply_tags($records);
         $config->apply_links($records);
 
         foreach ($records as $i => $rec) {
             unset($records[$i]['description']);
             $this->_client_encode($records[$i]);
         }
 
         return $records;
     }
 
     /**
      * Read note records for the given list from the storage backend
      */
     protected function list_notes($list_id, $search = null)
     {
         $results = array();
 
         // query Kolab storage
         $query = array();
 
         // full text search (only works with cache enabled)
         if (strlen($search)) {
             $words = array_filter(rcube_utils::normalize_string(mb_strtolower($search), true));
             foreach ($words as $word) {
                 if (strlen($word) > 2) {  // only words > 3 chars are stored in DB
                     $query[] = array('words', '~', $word);
                 }
             }
         }
 
         $this->_read_lists();
         if ($folder = $this->get_folder($list_id)) {
-            foreach ($folder->select($query) as $record) {
+            foreach ($folder->select($query, empty($query)) as $record) {
                 // post-filter search results
                 if (strlen($search)) {
                     $matches = 0;
                     $contents = mb_strtolower(
                         $record['title'] .
                         ($this->is_html($record) ? strip_tags($record['description']) : $record['description'])
                     );
                     foreach ($words as $word) {
                         if (mb_strpos($contents, $word) !== false) {
                             $matches++;
                         }
                     }
 
                     // skip records not matching all search words
                     if ($matches < count($words)) {
                         continue;
                     }
                 }
                 $record['list'] = $list_id;
                 $results[] = $record;
             }
         }
 
         return $results;
     }
 
     /**
      * Handler for delivering a full note record to the client
      */
     public function note_record()
     {
         $data = $this->get_note(array(
             'uid'  => rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC),
             'list' => rcube_utils::get_input_value('_list', rcube_utils::INPUT_GPC),
         ));
 
         // encode for client use
         if (is_array($data)) {
             $this->_client_encode($data);
         }
 
         $this->rc->output->command('plugin.render_note', $data);
     }
 
     /**
      * Get the full note record identified by the given UID + Lolder identifier
      */
     public function get_note($note)
     {
         if (is_array($note)) {
             $uid = $note['uid'] ?: $note['id'];
             $list_id = $note['list'];
         }
         else {
             $uid = $note;
         }
 
         // deliver from in-memory cache
         $key = $list_id . ':' . $uid;
         if ($this->cache[$key]) {
             return $this->cache[$key];
         }
 
         $result = false;
 
         $this->_read_lists();
         if ($list_id) {
             if ($folder = $this->get_folder($list_id)) {
                 $result = $folder->get_object($uid);
             }
         }
         // iterate over all calendar folders and search for the event ID
         else {
             foreach ($this->folders as $list_id => $folder) {
                 if ($result = $folder->get_object($uid)) {
                     $result['list'] = $list_id;
                     break;
                 }
             }
         }
 
         if ($result) {
             // get note tags
             $result['tags'] = $this->get_tags($result['uid']);
             // get note links
             $result['links'] = $this->get_links($result['uid']);
         }
 
         return $result;
     }
 
     /**
      * Helper method to encode the given note record for use in the client
      */
     private function _client_encode(&$note)
     {
         foreach ($note as $key => $prop) {
             if ($key[0] == '_' || $key == 'x-custom') {
                 unset($note[$key]);
             }
         }
 
         foreach (array('created','changed') as $key) {
             if (is_object($note[$key]) && $note[$key] instanceof DateTime) {
                 $note[$key.'_'] = $note[$key]->format('U');
                 $note[$key] = $this->rc->format_date($note[$key]);
             }
         }
 
         // clean HTML contents
         if (!empty($note['description']) && $this->is_html($note)) {
             $note['html'] = $this->_wash_html($note['description']);
         }
 
         // convert link URIs references into structs
         if (array_key_exists('links', $note)) {
             foreach ((array)$note['links'] as $i => $link) {
                 if (strpos($link, 'imap://') === 0 && ($msgref = kolab_storage_config::get_message_reference($link, 'note'))) {
                     $note['links'][$i] = $msgref;
                 }
             }
         }
 
         return $note;
     }
 
     /**
      * Handler for client-initiated actions on a single note record
      */
     public function note_action()
     {
         $action = rcube_utils::get_input_value('_do', rcube_utils::INPUT_POST);
         $note   = rcube_utils::get_input_value('_data', rcube_utils::INPUT_POST, true);
 
         $success = $silent = false;
         switch ($action) {
             case 'new':
             case 'edit':
                 if ($success = $this->save_note($note)) {
                     $refresh = $this->get_note($note);
                 }
                 break;
 
             case 'move':
                 $uids = explode(',', $note['uid']);
                 foreach ($uids as $uid) {
                     $note['uid'] = $uid;
                     if (!($success = $this->move_note($note, $note['to']))) {
                         $refresh = $this->get_note($note);
                         break;
                     }
                 }
                 break;
 
             case 'delete':
                 $uids = explode(',', $note['uid']);
                 foreach ($uids as $uid) {
                     $note['uid'] = $uid;
                     if (!($success = $this->delete_note($note))) {
                         $refresh = $this->get_note($note);
                         break;
                     }
                 }
                 break;
 
             case 'changelog':
                 $data = $this->get_changelog($note);
                 if (is_array($data) && !empty($data)) {
                     $rcmail = $this->rc;
                     $dtformat = $rcmail->config->get('date_format') . ' ' . $this->rc->config->get('time_format');
                     array_walk($data, function(&$change) use ($lib, $rcmail, $dtformat) {
                       if ($change['date']) {
                           $dt = rcube_utils::anytodatetime($change['date']);
                           if ($dt instanceof DateTime) {
                               $change['date'] = $rcmail->format_date($dt, $dtformat);
                           }
                       }
                     });
                     $this->rc->output->command('plugin.note_render_changelog', $data);
                 }
                 else {
                     $this->rc->output->command('plugin.note_render_changelog', false);
                 }
                 $silent = true;
                 break;
 
             case 'diff':
                 $silent = true;
                 $data = $this->get_diff($note, $note['rev1'], $note['rev2']);
                 if (is_array($data)) {
                     $this->rc->output->command('plugin.note_show_diff', $data);
                 }
                 else {
                     $this->rc->output->command('display_message', $this->gettext('objectdiffnotavailable'), 'error');
                 }
                 break;
 
             case 'show':
                 if ($rec = $this->get_revison($note, $note['rev'])) {
                     $this->rc->output->command('plugin.note_show_revision', $this->_client_encode($rec));
                 }
                 else {
                     $this->rc->output->command('display_message', $this->gettext('objectnotfound'), 'error');
                 }
                 $silent = true;
                 break;
 
             case 'restore':
                 if ($this->restore_revision($note, $note['rev'])) {
                     $refresh = $this->get_note($note);
                     $this->rc->output->command('display_message', $this->gettext(array('name' => 'objectrestoresuccess', 'vars' => array('rev' => $note['rev']))), 'confirmation');
                     $this->rc->output->command('plugin.close_history_dialog');
                 }
                 else {
                     $this->rc->output->command('display_message', $this->gettext('objectrestoreerror'), 'error');
                 }
                 $silent = true;
                 break;
         }
 
         // show confirmation/error message
         if ($success) {
             $this->rc->output->show_message('successfullysaved', 'confirmation');
         }
         else if (!$silent) {
             $this->rc->output->show_message('errorsaving', 'error');
         }
 
         // unlock client
         $this->rc->output->command('plugin.unlock_saving');
 
         if ($refresh) {
             $this->rc->output->command('plugin.update_note', $this->_client_encode($refresh));
         }
     }
 
     /**
      * Update an note record with the given data
      *
      * @param array Hash array with note properties (id, list)
      * @return boolean True on success, False on error
      */
     private function save_note(&$note)
     {
         $this->_read_lists();
 
         $list_id = $note['list'];
         if (!$list_id || !($folder = $this->get_folder($list_id)))
             return false;
 
         // moved from another folder
         if ($note['_fromlist'] && ($fromfolder = $this->get_folder($note['_fromlist']))) {
             if (!$fromfolder->move($note['uid'], $folder->name))
                 return false;
 
             unset($note['_fromlist']);
         }
 
         // load previous version of this record to merge
         if ($note['uid']) {
             $old = $folder->get_object($note['uid']);
             if (!$old || PEAR::isError($old))
                 return false;
 
             // merge existing properties if the update isn't complete
             if (!isset($note['title']) || !isset($note['description']))
                 $note += $old;
         }
 
         // generate new note object from input
         $object = $this->_write_preprocess($note, $old);
 
         // email links and tags are handled separately
         $links = $object['links'];
         $tags  = $object['tags'];
 
         unset($object['links']);
         unset($object['tags']);
 
         $saved = $folder->save($object, 'note', $note['uid']);
 
         if (!$saved) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error saving note object to Kolab server"),
                 true, false);
             $saved = false;
         }
         else {
             // save links in configuration.relation object
             $this->save_links($object['uid'], $links);
             // save tags in configuration.relation object
             $this->save_tags($object['uid'], $tags);
 
             $note         = $object;
             $note['list'] = $list_id;
             $note['tags'] = (array) $tags;
 
             // cache this in memory for later read
             $key = $list_id . ':' . $note['uid'];
             $this->cache[$key] = $note;
         }
 
         return $saved;
     }
 
     /**
      * Move the given note to another folder
      */
     function move_note($note, $list_id)
     {
         $this->_read_lists();
 
         $tofolder   = $this->get_folder($list_id);
         $fromfolder = $this->get_folder($note['list']);
 
         if ($fromfolder && $tofolder) {
             return $fromfolder->move($note['uid'], $tofolder->name);
         }
 
         return false;
     }
 
     /**
      * Remove a single note record from the backend
      *
      * @param array   Hash array with note properties (id, list)
      * @param boolean Remove record irreversible (mark as deleted otherwise)
      * @return boolean True on success, False on error
      */
     public function delete_note($note, $force = true)
     {
         $this->_read_lists();
 
         $list_id = $note['list'];
         if (!$list_id || !($folder = $this->get_folder($list_id))) {
             return false;
         }
 
         $status = $folder->delete($note['uid'], $force);
 
         if ($status) {
             $this->save_links($note['uid'], null);
             $this->save_tags($note['uid'], null);
         }
 
         return $status;
     }
 
     /**
      * Render the template for printing with placeholders
      */
     public function print_note()
     {
         $uid  = rcube_utils::get_input_value('_uid', rcube_utils::INPUT_GET);
         $list = rcube_utils::get_input_value('_list', rcube_utils::INPUT_GET);
 
         $this->note = $this->get_note(array('uid' => $uid, 'list' => $list));
 
         // encode for client use
         if (is_array($this->note)) {
             $this->_client_encode($this->note);
         }
 
         $this->rc->output->set_pagetitle($this->note['title']);
         $this->rc->output->add_handlers(array(
                 'noteheader' => array($this, 'print_note_header'),
                 'notebody'   => array($this, 'print_note_body'),
         ));
 
         $this->include_script('notes.js');
 
         $this->rc->output->send('kolab_notes.print');
     }
 
     public function print_note_header()
     {
         $tags = array_map(array('rcube', 'Q'), (array) $this->note['tags']);
         $tags = implode(' ', $tags);
 
         return html::tag('h1', array('id' => 'notetitle'), rcube::Q($this->note['title']))
             . html::div(array('id' => 'notetags', 'class' => 'tagline'), $tags)
             . html::div('dates',
                 html::label(null, rcube::Q($this->gettext('created')))
                 . html::span(array('id' => 'notecreated'), rcube::Q($this->note['created']))
                 . html::label(null, rcube::Q($this->gettext('changed')))
                 . html::span(array('id' => 'notechanged'), rcube::Q($this->note['changed']))
             );
     }
 
     public function print_note_body()
     {
         return isset($this->note['html']) ? $this->note['html'] : rcube::Q($this->note['description']);
     }
 
     /**
      * Provide a list of revisions for the given object
      *
      * @param array  $note Hash array with note properties
      * @return array List of changes, each as a hash array
      */
     public function get_changelog($note)
     {
         if (empty($this->bonnie_api)) {
             return false;
         }
 
         list($uid, $mailbox, $msguid) = $this->_resolve_note_identity($note);
 
         $result = $uid && $mailbox ? $this->bonnie_api->changelog('note', $uid, $mailbox, $msguid) : null;
         if (is_array($result) && $result['uid'] == $uid) {
             return $result['changes'];
         }
 
         return false;
     }
 
     /**
      * Return full data of a specific revision of a note record
      *
      * @param mixed  $note UID string or hash array with note properties
      * @param mixed  $rev Revision number
      *
      * @return array Note object as hash array
      */
     public function get_revison($note, $rev)
     {
         if (empty($this->bonnie_api)) {
             return false;
         }
 
         list($uid, $mailbox, $msguid) = $this->_resolve_note_identity($note);
 
         // call Bonnie API
         $result = $this->bonnie_api->get('note', $uid, $rev, $mailbox, $msguid);
         if (is_array($result) && $result['uid'] == $uid && !empty($result['xml'])) {
             $format = kolab_format::factory('note');
             $format->load($result['xml']);
             $rec = $format->to_array();
 
             if ($format->is_valid()) {
                 $rec['rev'] = $result['rev'];
                 return $rec;
             }
         }
 
         return false;
     }
 
     /**
      * Get a list of property changes beteen two revisions of a note object
      *
      * @param array  $$note Hash array with note properties
      * @param mixed  $rev   Revisions: "from:to"
      *
      * @return array List of property changes, each as a hash array
      */
     public function get_diff($note, $rev1, $rev2)
     {
         if (empty($this->bonnie_api)) {
             return false;
         }
 
         list($uid, $mailbox, $msguid) = $this->_resolve_note_identity($note);
 
         // call Bonnie API
         $result = $this->bonnie_api->diff('note', $uid, $rev1, $rev2, $mailbox, $msguid);
         if (is_array($result) && $result['uid'] == $uid) {
             $result['rev1'] = $rev1;
             $result['rev2'] = $rev2;
 
             // convert some properties, similar to self::_client_encode()
             $keymap = array(
                 'summary'  => 'title',
                 'lastmodified-date' => 'changed',
             );
 
             // map kolab object properties to keys and values the client expects
             array_walk($result['changes'], function(&$change, $i) use ($keymap) {
                 if (array_key_exists($change['property'], $keymap)) {
                     $change['property'] = $keymap[$change['property']];
                 }
 
                 if ($change['property'] == 'created' || $change['property'] == 'changed') {
                     if ($old_ = rcube_utils::anytodatetime($change['old'])) {
                         $change['old_'] = $this->rc->format_date($old_);
                     }
                     if ($new_ = rcube_utils::anytodatetime($change['new'])) {
                         $change['new_'] = $this->rc->format_date($new_);
                     }
                 }
 
                 // compute a nice diff of note contents
                 if ($change['property'] == 'description') {
                     $change['diff_'] = libkolab::html_diff($change['old'], $change['new']);
                     if (!empty($change['diff_'])) {
                         unset($change['old'], $change['new']);
                         $change['diff_'] = preg_replace(array('!^.*<body[^>]*>!Uims','!</body>.*$!Uims'), '', $change['diff_']);
                         $change['diff_'] = preg_replace("!</(p|li|span)>\n!", '</\\1>', $change['diff_']);
                     }
                 }
             });
 
             return $result;
         }
 
         return false;
     }
 
     /**
      * Command the backend to restore a certain revision of a note.
      * This shall replace the current object with an older version.
      *
      * @param array  $note Hash array with note properties (id, list)
      * @param mixed  $rev Revision number
      *
      * @return boolean True on success, False on failure
      */
     public function restore_revision($note, $rev)
     {
         if (empty($this->bonnie_api)) {
             return false;
         }
 
         list($uid, $mailbox, $msguid) = $this->_resolve_note_identity($note);
 
         $folder = $this->get_folder($note['list']);
         $success = false;
 
         if ($folder && ($raw_msg = $this->bonnie_api->rawdata('note', $uid, $rev, $mailbox))) {
             $imap = $this->rc->get_storage();
 
             // insert $raw_msg as new message
             if ($imap->save_message($folder->name, $raw_msg, null, false)) {
                 $success = true;
 
                 // delete old revision from imap and cache
                 $imap->delete_message($msguid, $folder->name);
                 $folder->cache->set($msguid, false);
                 $this->cache = array();
             }
         }
 
         return $success;
     }
 
     /**
      * Helper method to resolved the given note identifier into uid and mailbox
      *
      * @return array (uid,mailbox,msguid) tuple
      */
     private function _resolve_note_identity($note)
     {
         $mailbox = $msguid = null;
 
         if (!is_array($note)) {
             $note = $this->get_note($note);
         }
 
         if (is_array($note)) {
             $uid = $note['uid'] ?: $note['id'];
             $list = $note['list'];
         }
         else {
             return array(null, $mailbox, $msguid);
         }
 
         if ($folder = $this->get_folder($list)) {
             $mailbox = $folder->get_mailbox_id();
 
             // get object from storage in order to get the real object uid an msguid
             if ($rec = $folder->get_object($uid)) {
                 $msguid = $rec['_msguid'];
                 $uid = $rec['uid'];
             }
         }
 
         return array($uid, $mailbox, $msguid);
     }
 
 
     /**
      * Handler for client requests to list (aka folder) actions
      */
     public function list_action()
     {
         $action  = rcube_utils::get_input_value('_do', rcube_utils::INPUT_GPC);
         $list    = rcube_utils::get_input_value('_list', rcube_utils::INPUT_GPC, true);
         $success = $update_cmd = false;
 
         if (empty($action)) {
             $action = rcube_utils::get_input_value('action', rcube_utils::INPUT_GPC);
         }
 
         switch ($action) {
             case 'form-new':
             case 'form-edit':
                 $this->_read_lists();
                 $this->ui->list_editform($action, $this->lists[$list['id']], $this->folders[$list['id']]);
                 exit;
 
             case 'new':
                 $list['type'] = 'note';
                 $list['subscribed'] = true;
                 $folder = kolab_storage::folder_update($list);
 
                 if ($folder === false) {
                     $save_error = $this->gettext(kolab_storage::$last_error);
                 }
                 else {
                     $success = true;
                     $update_cmd = 'plugin.update_list';
                     $list['id'] = kolab_storage::folder_id($folder);
                     $list['_reload'] = true;
                 }
                 break;
 
             case 'edit':
                 $this->_read_lists();
                 $oldparent = $this->lists[$list['id']]['parentfolder'];
                 $newfolder = kolab_storage::folder_update($list);
 
                 if ($newfolder === false) {
                     $save_error = $this->gettext(kolab_storage::$last_error);
                 }
                 else {
                     $success = true;
                     $update_cmd = 'plugin.update_list';
                     $list['newid'] = kolab_storage::folder_id($newfolder);
                     $list['_reload'] = $list['parent'] != $oldparent;
 
                     // compose the new display name
                     $delim            = $this->rc->get_storage()->get_hierarchy_delimiter();
                     $path_imap        = explode($delim, $newfolder);
                     $list['name']     = kolab_storage::object_name($newfolder);
                     $list['editname'] = rcube_charset::convert(array_pop($path_imap), 'UTF7-IMAP');
                     $list['listname'] = $list['editname'];
                 }
                 break;
 
             case 'delete':
                 $this->_read_lists();
                 $folder = $this->get_folder($list['id']);
                 if ($folder && kolab_storage::folder_delete($folder->name)) {
                     $success = true;
                     $update_cmd = 'plugin.destroy_list';
                 }
                 else {
                     $save_error = $this->gettext(kolab_storage::$last_error);
                 }
                 break;
 
             case 'search':
                 $this->load_ui();
                 $results = array();
                 foreach ((array)$this->search_lists(rcube_utils::get_input_value('q', rcube_utils::INPUT_GPC), rcube_utils::get_input_value('source', rcube_utils::INPUT_GPC)) as $id => $prop) {
                     $editname = $prop['editname'];
                     unset($prop['editname']);  // force full name to be displayed
 
                     // let the UI generate HTML and CSS representation for this calendar
                     $html = $this->ui->folder_list_item($id, $prop, $jsenv, true);
                     $prop += (array)$jsenv[$id];
                     $prop['editname'] = $editname;
                     $prop['html'] = $html;
 
                     $results[] = $prop;
                 }
                 // report more results available
                 if ($this->driver->search_more_results) {
                     $this->rc->output->show_message('autocompletemore', 'notice');
                 }
 
                 $this->rc->output->command('multi_thread_http_response', $results, rcube_utils::get_input_value('_reqid', rcube_utils::INPUT_GPC));
                 return;
 
             case 'subscribe':
                 $success = false;
                 if ($list['id'] && ($folder = $this->get_folder($list['id']))) {
                     if (isset($list['permanent']))
                         $success |= $folder->subscribe(intval($list['permanent']));
                     if (isset($list['active']))
                         $success |= $folder->activate(intval($list['active']));
 
                     // apply to child folders, too
                     if ($list['recursive']) {
                         foreach ((array)kolab_storage::list_folders($folder->name, '*', 'node') as $subfolder) {
                             if (isset($list['permanent']))
                                 ($list['permanent'] ? kolab_storage::folder_subscribe($subfolder) : kolab_storage::folder_unsubscribe($subfolder));
                             if (isset($list['active']))
                                 ($list['active'] ? kolab_storage::folder_activate($subfolder) : kolab_storage::folder_deactivate($subfolder));
                         }
                     }
                 }
                 break;
         }
 
         $this->rc->output->command('plugin.unlock_saving');
 
         if ($success) {
             $this->rc->output->show_message('successfullysaved', 'confirmation');
 
             if ($update_cmd) {
                 $this->rc->output->command($update_cmd, $list);
             }
         }
         else {
             $error_msg = $this->gettext('errorsaving') . ($save_error ? ': ' . $save_error :'');
             $this->rc->output->show_message($error_msg, 'error');
         }
     }
 
     /**
      * Hook to add note attachments to message compose if the according parameter is present.
      * This completes the 'send note by mail' feature.
      */
     public function mail_message_compose($args)
     {
         if (!empty($args['param']['with_notes'])) {
             $uids = explode(',', $args['param']['with_notes']);
             $list = $args['param']['notes_list'];
 
             foreach ($uids as $uid) {
                 if ($note = $this->get_note(array('uid' => $uid, 'list' => $list))) {
                     $data = $this->note2message($note);
                     $args['attachments'][] = array(
                         'name'     => abbreviate_string($note['title'], 50, ''),
                         'mimetype' => 'message/rfc822',
                         'data'     => $data,
                         'size'     => strlen($data),
                     );
 
                     if (empty($args['param']['subject'])) {
                         $args['param']['subject'] = $note['title'];
                     }
                 }
             }
 
             unset($args['param']['with_notes'], $args['param']['notes_list']);
         }
 
         return $args;
     }
 
     /**
      * Lookup backend storage and find notes associated with the given message
      */
     public function mail_message_load($p)
     {
         if (!$p['object']->headers->others['x-kolab-type']) {
             $this->message_notes = $this->get_message_notes($p['object']->headers, $p['object']->folder);
         }
     }
 
     /**
      * Handler for 'messagebody_html' hook
      */
     public function mail_messagebody_html($args)
     {
         $html = '';
         foreach ($this->message_notes as $note) {
             $html .= html::a(array(
                 'href' => $this->rc->url(array('task' => 'notes', '_list' => $note['list'], '_id' => $note['uid'])),
                 'class' => 'kolabnotesref',
                 'rel' => $note['uid'] . '@' . $note['list'],
                 'target' => '_blank',
             ), rcube::Q($note['title']));
         }
 
         // prepend note links to message body
         if ($html) {
             $this->load_ui();
             $args['content'] = html::div('kolabmessagenotes boxinformation', $html) . $args['content'];
         }
 
         return $args;
     }
 
     /**
      * Determine whether the given note is HTML formatted
      */
     private function is_html($note)
     {
         // check for opening and closing <html> or <body> tags
         return (preg_match('/<(html|body)(\s+[a-z]|>)/', $note['description'], $m) && strpos($note['description'], '</'.$m[1].'>') > 0);
     }
 
     /**
      * Build an RFC 822 message from the given note
      */
     private function note2message($note)
     {
         $message = new Mail_mime("\r\n");
 
         $message->setParam('text_encoding', '8bit');
         $message->setParam('html_encoding', 'quoted-printable');
         $message->setParam('head_encoding', 'quoted-printable');
         $message->setParam('head_charset', RCUBE_CHARSET);
         $message->setParam('html_charset', RCUBE_CHARSET);
         $message->setParam('text_charset', RCUBE_CHARSET);
 
         $message->headers(array(
             'Subject' => $note['title'],
             'Date' => $note['changed']->format('r'),
         ));
 
         if ($this->is_html($note)) {
             $message->setHTMLBody($note['description']);
 
             // add a plain text version of the note content as an alternative part.
             $h2t = new rcube_html2text($note['description'], false, true, 0, RCUBE_CHARSET);
             $plain_part = rcube_mime::wordwrap($h2t->get_text(), $this->rc->config->get('line_length', 72), "\r\n", false, RCUBE_CHARSET);
             $plain_part = trim(wordwrap($plain_part, 998, "\r\n", true));
 
             // make sure all line endings are CRLF
             $plain_part = preg_replace('/\r?\n/', "\r\n", $plain_part);
 
             $message->setTXTBody($plain_part);
         }
         else {
             $message->setTXTBody($note['description']);
         }
 
         return $message->getMessage();
     }
 
     private function save_links($uid, $links)
     {
         $config = kolab_storage_config::get_instance();
         return $config->save_object_links($uid, (array) $links);
     }
 
     /**
      * Find messages assigned to specified note
      */
     private function get_links($uid)
     {
         $config = kolab_storage_config::get_instance();
         return $config->get_object_links($uid);
     }
 
     /**
      * Get note tags
      */
     private function get_tags($uid)
     {
         $config = kolab_storage_config::get_instance();
         $tags   = $config->get_tags($uid);
         $tags   = array_map(function($v) { return $v['name']; }, $tags);
 
         return $tags;
     }
 
     /**
      * Find notes assigned to specified message
      */
     private function get_message_notes($message, $folder)
     {
         $config = kolab_storage_config::get_instance();
         $result = $config->get_message_relations($message, $folder, 'note');
 
         foreach ($result as $idx => $note) {
             $result[$idx]['list'] = kolab_storage::folder_id($note['_mailbox']);
         }
 
         return $result;
     }
 
     /**
      * Update note tags
      */
     private function save_tags($uid, $tags)
     {
         $config = kolab_storage_config::get_instance();
         $config->save_tags($uid, $tags);
     }
 
     /**
      * Process the given note data (submitted by the client) before saving it
      */
     private function _write_preprocess($note, $old = array())
     {
         $object = $note;
 
         // TODO: handle attachments
 
         // convert link references into simple URIs
         if (array_key_exists('links', $note)) {
             $object['links'] = array_map(function($link){ return is_array($link) ? $link['uri'] : strval($link); }, $note['links']);
         }
         else {
             $object['links'] = $old['links'];
         }
 
         // clean up HTML content
         $object['description'] = $this->_wash_html($note['description']);
         $is_html = true;
 
         // try to be smart and convert to plain-text if no real formatting is detected
         if (preg_match('!<body><(?:p|pre)>(.*)</(?:p|pre)></body>!Uims', $object['description'], $m)) {
             if (!preg_match('!<(a|b|i|strong|em|p|span|div|pre|li|img)(\s+[a-z]|>)!im', $m[1], $n)
                 || ($n[1] != 'img' && !strpos($m[1], '</'.$n[1].'>'))
             ) {
                 // $converter = new rcube_html2text($m[1], false, true, 0);
                 // $object['description'] = rtrim($converter->get_text());
                 $object['description'] = html_entity_decode(preg_replace('!<br(\s+/)>!', "\n", $m[1]));
                 $is_html = false;
             }
         }
 
         // Add proper HTML header, otherwise Kontact renders it as plain text
         if ($is_html) {
             $object['description'] = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">'."\n" .
                 str_replace('<head>', '<head><meta name="qrichtext" content="1" />', $object['description']);
         }
 
         // copy meta data (starting with _) from old object
         foreach ((array)$old as $key => $val) {
             if (!isset($object[$key]) && $key[0] == '_')
                 $object[$key] = $val;
         }
 
         // make list of categories unique
         if (is_array($object['tags'])) {
             $object['tags'] = array_unique(array_filter($object['tags']));
         }
 
         unset($object['list'], $object['tempid'], $object['created'], $object['changed'], $object['created_'], $object['changed_']);
         return $object;
     }
 
     /**
      * Sanity checks/cleanups HTML content
      */
     private function _wash_html($html)
     {
         // Add header with charset spec., washtml cannot work without that
         $html = '<html><head>'
             . '<meta http-equiv="Content-Type" content="text/html; charset='.RCUBE_CHARSET.'" />'
             . '</head><body>' . $html . '</body></html>';
 
         // clean HTML with washtml by Frederic Motte
         $wash_opts = array(
             'show_washed'   => false,
             'allow_remote'  => 1,
             'charset'       => RCUBE_CHARSET,
             'html_elements' => array('html', 'head', 'meta', 'body', 'link'),
             'html_attribs'  => array('rel', 'type', 'name', 'http-equiv'),
         );
 
         // initialize HTML washer
         $washer = new rcube_washtml($wash_opts);
 
         $washer->add_callback('form', array($this, '_washtml_callback'));
         $washer->add_callback('a',    array($this, '_washtml_callback'));
 
         // Remove non-UTF8 characters
         $html = rcube_charset::clean($html);
 
         $html = $washer->wash($html);
 
         // remove unwanted comments (produced by washtml)
         $html = preg_replace('/<!--[^>]+-->/', '', $html);
 
         return $html;
     }
 
     /**
      * Callback function for washtml cleaning class
      */
     public function _washtml_callback($tagname, $attrib, $content, $washtml)
     {
         switch ($tagname) {
         case 'form':
             $out = html::div('form', $content);
             break;
 
         case 'a':
             // strip temporary link tags from plain-text markup
             $attrib = html::parse_attrib_string($attrib);
             if (!empty($attrib['class']) && strpos($attrib['class'], 'x-templink') !== false) {
                 // remove link entirely
                 if (strpos($attrib['href'], html_entity_decode($content)) !== false) {
                     $out = $content;
                     break;
                 }
                 $attrib['class'] = trim(str_replace('x-templink', '', $attrib['class']));
             }
             $out = html::a($attrib, $content);
             break;
 
         default:
             $out = '';
         }
 
         return $out;
     }
 
 }
diff --git a/plugins/libkolab/SQL/mysql.initial.sql b/plugins/libkolab/SQL/mysql.initial.sql
index 0213c45b..80da02fa 100644
--- a/plugins/libkolab/SQL/mysql.initial.sql
+++ b/plugins/libkolab/SQL/mysql.initial.sql
@@ -1,191 +1,183 @@
 /**
  * libkolab database schema
  *
  * @version 1.2
  * @author Thomas Bruederli
  * @licence GNU AGPL
  **/
 
 /*!40014  SET FOREIGN_KEY_CHECKS=0 */;
 
 DROP TABLE IF EXISTS `kolab_folders`;
 
 CREATE TABLE `kolab_folders` (
   `folder_id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
   `resource` VARCHAR(255) NOT NULL,
   `type` VARCHAR(32) NOT NULL,
   `synclock` INT(10) NOT NULL DEFAULT '0',
   `ctag` VARCHAR(40) DEFAULT NULL,
   `changed` DATETIME DEFAULT NULL,
   `objectcount` BIGINT DEFAULT NULL,
   PRIMARY KEY(`folder_id`),
   INDEX `resource_type` (`resource`, `type`)
 ) /*!40000 ENGINE=INNODB */ /*!40101 CHARACTER SET utf8 COLLATE utf8_general_ci */;
 
 DROP TABLE IF EXISTS `kolab_cache`;
 
 DROP TABLE IF EXISTS `kolab_cache_contact`;
 
 CREATE TABLE `kolab_cache_contact` (
   `folder_id` BIGINT UNSIGNED NOT NULL,
   `msguid` BIGINT UNSIGNED NOT NULL,
   `uid` VARCHAR(512) NOT NULL,
   `created` DATETIME DEFAULT NULL,
   `changed` DATETIME DEFAULT NULL,
   `data` LONGTEXT NOT NULL,
-  `xml` LONGBLOB NOT NULL,
   `tags` TEXT NOT NULL,
   `words` TEXT NOT NULL,
   `type` VARCHAR(32) CHARACTER SET ascii NOT NULL,
   `name` VARCHAR(255) NOT NULL,
   `firstname` VARCHAR(255) NOT NULL,
   `surname` VARCHAR(255) NOT NULL,
   `email` VARCHAR(255) NOT NULL,
   CONSTRAINT `fk_kolab_cache_contact_folder` FOREIGN KEY (`folder_id`)
     REFERENCES `kolab_folders`(`folder_id`) ON DELETE CASCADE ON UPDATE CASCADE,
   PRIMARY KEY(`folder_id`,`msguid`),
   INDEX `contact_type` (`folder_id`,`type`),
   INDEX `contact_uid2msguid` (`folder_id`,`uid`,`msguid`)
 ) /*!40000 ENGINE=INNODB */ /*!40101 CHARACTER SET utf8 COLLATE utf8_general_ci */;
 
 DROP TABLE IF EXISTS `kolab_cache_event`;
 
 CREATE TABLE `kolab_cache_event` (
   `folder_id` BIGINT UNSIGNED NOT NULL,
   `msguid` BIGINT UNSIGNED NOT NULL,
   `uid` VARCHAR(512) NOT NULL,
   `created` DATETIME DEFAULT NULL,
   `changed` DATETIME DEFAULT NULL,
   `data` LONGTEXT NOT NULL,
-  `xml` LONGBLOB NOT NULL,
   `tags` TEXT NOT NULL,
   `words` TEXT NOT NULL,
   `dtstart` DATETIME,
   `dtend` DATETIME,
   CONSTRAINT `fk_kolab_cache_event_folder` FOREIGN KEY (`folder_id`)
     REFERENCES `kolab_folders`(`folder_id`) ON DELETE CASCADE ON UPDATE CASCADE,
   PRIMARY KEY(`folder_id`,`msguid`),
   INDEX `event_uid2msguid` (`folder_id`,`uid`,`msguid`)
 ) /*!40000 ENGINE=INNODB */ /*!40101 CHARACTER SET utf8 COLLATE utf8_general_ci */;
 
 DROP TABLE IF EXISTS `kolab_cache_task`;
 
 CREATE TABLE `kolab_cache_task` (
   `folder_id` BIGINT UNSIGNED NOT NULL,
   `msguid` BIGINT UNSIGNED NOT NULL,
   `uid` VARCHAR(512) NOT NULL,
   `created` DATETIME DEFAULT NULL,
   `changed` DATETIME DEFAULT NULL,
   `data` LONGTEXT NOT NULL,
-  `xml` LONGBLOB NOT NULL,
   `tags` TEXT NOT NULL,
   `words` TEXT NOT NULL,
   `dtstart` DATETIME,
   `dtend` DATETIME,
   CONSTRAINT `fk_kolab_cache_task_folder` FOREIGN KEY (`folder_id`)
     REFERENCES `kolab_folders`(`folder_id`) ON DELETE CASCADE ON UPDATE CASCADE,
   PRIMARY KEY(`folder_id`,`msguid`),
   INDEX `task_uid2msguid` (`folder_id`,`uid`,`msguid`)
 ) /*!40000 ENGINE=INNODB */ /*!40101 CHARACTER SET utf8 COLLATE utf8_general_ci */;
 
 DROP TABLE IF EXISTS `kolab_cache_journal`;
 
 CREATE TABLE `kolab_cache_journal` (
   `folder_id` BIGINT UNSIGNED NOT NULL,
   `msguid` BIGINT UNSIGNED NOT NULL,
   `uid` VARCHAR(512) NOT NULL,
   `created` DATETIME DEFAULT NULL,
   `changed` DATETIME DEFAULT NULL,
   `data` LONGTEXT NOT NULL,
-  `xml` LONGBLOB NOT NULL,
   `tags` TEXT NOT NULL,
   `words` TEXT NOT NULL,
   `dtstart` DATETIME,
   `dtend` DATETIME,
   CONSTRAINT `fk_kolab_cache_journal_folder` FOREIGN KEY (`folder_id`)
     REFERENCES `kolab_folders`(`folder_id`) ON DELETE CASCADE ON UPDATE CASCADE,
   PRIMARY KEY(`folder_id`,`msguid`),
   INDEX `journal_uid2msguid` (`folder_id`,`uid`,`msguid`)
 ) /*!40000 ENGINE=INNODB */ /*!40101 CHARACTER SET utf8 COLLATE utf8_general_ci */;
 
 DROP TABLE IF EXISTS `kolab_cache_note`;
 
 CREATE TABLE `kolab_cache_note` (
   `folder_id` BIGINT UNSIGNED NOT NULL,
   `msguid` BIGINT UNSIGNED NOT NULL,
   `uid` VARCHAR(512) NOT NULL,
   `created` DATETIME DEFAULT NULL,
   `changed` DATETIME DEFAULT NULL,
   `data` LONGTEXT NOT NULL,
-  `xml` LONGBLOB NOT NULL,
   `tags` TEXT NOT NULL,
   `words` TEXT NOT NULL,
   CONSTRAINT `fk_kolab_cache_note_folder` FOREIGN KEY (`folder_id`)
     REFERENCES `kolab_folders`(`folder_id`) ON DELETE CASCADE ON UPDATE CASCADE,
   PRIMARY KEY(`folder_id`,`msguid`),
   INDEX `note_uid2msguid` (`folder_id`,`uid`,`msguid`)
 ) /*!40000 ENGINE=INNODB */ /*!40101 CHARACTER SET utf8 COLLATE utf8_general_ci */;
 
 DROP TABLE IF EXISTS `kolab_cache_file`;
 
 CREATE TABLE `kolab_cache_file` (
   `folder_id` BIGINT UNSIGNED NOT NULL,
   `msguid` BIGINT UNSIGNED NOT NULL,
   `uid` VARCHAR(512) NOT NULL,
   `created` DATETIME DEFAULT NULL,
   `changed` DATETIME DEFAULT NULL,
   `data` LONGTEXT NOT NULL,
-  `xml` LONGBLOB NOT NULL,
   `tags` TEXT NOT NULL,
   `words` TEXT NOT NULL,
   `filename` varchar(255) DEFAULT NULL,
   CONSTRAINT `fk_kolab_cache_file_folder` FOREIGN KEY (`folder_id`)
     REFERENCES `kolab_folders`(`folder_id`) ON DELETE CASCADE ON UPDATE CASCADE,
   PRIMARY KEY(`folder_id`,`msguid`),
   INDEX `folder_filename` (`folder_id`, `filename`),
   INDEX `file_uid2msguid` (`folder_id`,`uid`,`msguid`)
 ) /*!40000 ENGINE=INNODB */ /*!40101 CHARACTER SET utf8 COLLATE utf8_general_ci */;
 
 DROP TABLE IF EXISTS `kolab_cache_configuration`;
 
 CREATE TABLE `kolab_cache_configuration` (
   `folder_id` BIGINT UNSIGNED NOT NULL,
   `msguid` BIGINT UNSIGNED NOT NULL,
   `uid` VARCHAR(512) NOT NULL,
   `created` DATETIME DEFAULT NULL,
   `changed` DATETIME DEFAULT NULL,
   `data` LONGTEXT NOT NULL,
-  `xml` LONGBLOB NOT NULL,
   `tags` TEXT NOT NULL,
   `words` TEXT NOT NULL,
   `type` VARCHAR(32) CHARACTER SET ascii NOT NULL,
   CONSTRAINT `fk_kolab_cache_configuration_folder` FOREIGN KEY (`folder_id`)
     REFERENCES `kolab_folders`(`folder_id`) ON DELETE CASCADE ON UPDATE CASCADE,
   PRIMARY KEY(`folder_id`,`msguid`),
   INDEX `configuration_type` (`folder_id`,`type`),
   INDEX `configuration_uid2msguid` (`folder_id`,`uid`,`msguid`)
 ) /*!40000 ENGINE=INNODB */ /*!40101 CHARACTER SET utf8 COLLATE utf8_general_ci */;
 
 DROP TABLE IF EXISTS `kolab_cache_freebusy`;
 
 CREATE TABLE `kolab_cache_freebusy` (
   `folder_id` BIGINT UNSIGNED NOT NULL,
   `msguid` BIGINT UNSIGNED NOT NULL,
   `uid` VARCHAR(512) NOT NULL,
   `created` DATETIME DEFAULT NULL,
   `changed` DATETIME DEFAULT NULL,
   `data` LONGTEXT NOT NULL,
-  `xml` LONGBLOB NOT NULL,
   `tags` TEXT NOT NULL,
   `words` TEXT NOT NULL,
   `dtstart` DATETIME,
   `dtend` DATETIME,
   CONSTRAINT `fk_kolab_cache_freebusy_folder` FOREIGN KEY (`folder_id`)
     REFERENCES `kolab_folders`(`folder_id`) ON DELETE CASCADE ON UPDATE CASCADE,
   PRIMARY KEY(`folder_id`,`msguid`),
   INDEX `freebusy_uid2msguid` (`folder_id`,`uid`,`msguid`)
 ) /*!40000 ENGINE=INNODB */ /*!40101 CHARACTER SET utf8 COLLATE utf8_general_ci */;
 
 /*!40014  SET FOREIGN_KEY_CHECKS=1 */;
 
-REPLACE INTO `system` (`name`, `value`) VALUES ('libkolab-version', '2018021300');
+REPLACE INTO `system` (`name`, `value`) VALUES ('libkolab-version', '2018122700');
diff --git a/plugins/libkolab/SQL/mysql/2018122700.sql b/plugins/libkolab/SQL/mysql/2018122700.sql
new file mode 100644
index 00000000..08030dd0
--- /dev/null
+++ b/plugins/libkolab/SQL/mysql/2018122700.sql
@@ -0,0 +1,10 @@
+-- remove xml column, and change data format (clear cache needed)
+DELETE FROM `kolab_folders`;
+ALTER TABLE `kolab_cache_contact` DROP COLUMN `xml`;
+ALTER TABLE `kolab_cache_event` DROP COLUMN `xml`;
+ALTER TABLE `kolab_cache_task` DROP COLUMN `xml`;
+ALTER TABLE `kolab_cache_journal` DROP COLUMN `xml`;
+ALTER TABLE `kolab_cache_note` DROP COLUMN `xml`;
+ALTER TABLE `kolab_cache_file` DROP COLUMN `xml`;
+ALTER TABLE `kolab_cache_configuration` DROP COLUMN `xml`;
+ALTER TABLE `kolab_cache_freebusy` DROP COLUMN `xml`;
diff --git a/plugins/libkolab/SQL/oracle.initial.sql b/plugins/libkolab/SQL/oracle.initial.sql
index 78675783..ebba60dc 100644
--- a/plugins/libkolab/SQL/oracle.initial.sql
+++ b/plugins/libkolab/SQL/oracle.initial.sql
@@ -1,186 +1,178 @@
 /**
  * libkolab database schema
  *
  * @version 1.2
  * @author Aleksander Machniak
  * @licence GNU AGPL
  **/
 
 
 CREATE TABLE "kolab_folders" (
     "folder_id" number NOT NULL PRIMARY KEY,
     "resource" VARCHAR(255) NOT NULL,
     "type" VARCHAR(32) NOT NULL,
     "synclock" integer DEFAULT 0 NOT NULL,
     "ctag" VARCHAR(40) DEFAULT NULL,
     "changed" timestamp DEFAULT NULL,
     "objectcount" number DEFAULT NULL
 );
 
 CREATE INDEX "kolab_folders_resource_idx" ON "kolab_folders" ("resource", "type");
 
 CREATE SEQUENCE "kolab_folders_seq"
     START WITH 1 INCREMENT BY 1 NOMAXVALUE;
 
 CREATE TRIGGER "kolab_folders_seq_trig"
 BEFORE INSERT ON "kolab_folders" FOR EACH ROW
 BEGIN
     :NEW."folder_id" := "kolab_folders_seq".nextval;
 END;
 /
 
 CREATE TABLE "kolab_cache_contact" (
     "folder_id" number NOT NULL
         REFERENCES "kolab_folders" ("folder_id") ON DELETE CASCADE,
     "msguid" number NOT NULL,
     "uid" varchar(512) NOT NULL,
     "created" timestamp DEFAULT NULL,
     "changed" timestamp DEFAULT NULL,
     "data" clob NOT NULL,
-    "xml" clob NOT NULL,
     "tags" clob DEFAULT NULL,
     "words" clob DEFAULT NULL,
     "type" varchar(32) NOT NULL,
     "name" varchar(255) DEFAULT NULL,
     "firstname" varchar(255) DEFAULT NULL,
     "surname" varchar(255) DEFAULT NULL,
     "email" varchar(255) DEFAULT NULL,
     PRIMARY KEY ("folder_id", "msguid")
 );
 
 CREATE INDEX "kolab_cache_contact_type_idx" ON "kolab_cache_contact" ("folder_id", "type");
 CREATE INDEX "kolab_cache_contact_uid2msguid" ON "kolab_cache_contact" ("folder_id", "uid", "msguid");
 
 
 CREATE TABLE "kolab_cache_event" (
     "folder_id" number NOT NULL
         REFERENCES "kolab_folders" ("folder_id") ON DELETE CASCADE,
     "msguid" number NOT NULL,
     "uid" varchar(512) NOT NULL,
     "created" timestamp DEFAULT NULL,
     "changed" timestamp DEFAULT NULL,
     "data" clob NOT NULL,
-    "xml" clob NOT NULL,
     "tags" clob DEFAULT NULL,
     "words" clob DEFAULT NULL,
     "dtstart" timestamp DEFAULT NULL,
     "dtend" timestamp DEFAULT NULL,
     PRIMARY KEY ("folder_id", "msguid")
 );
 
 CREATE INDEX "kolab_cache_event_uid2msguid" ON "kolab_cache_event" ("folder_id", "uid", "msguid");
 
 
 CREATE TABLE "kolab_cache_task" (
     "folder_id" number NOT NULL
         REFERENCES "kolab_folders" ("folder_id") ON DELETE CASCADE,
     "msguid" number NOT NULL,
     "uid" varchar(512) NOT NULL,
     "created" timestamp DEFAULT NULL,
     "changed" timestamp DEFAULT NULL,
     "data" clob NOT NULL,
-    "xml" clob NOT NULL,
     "tags" clob DEFAULT NULL,
     "words" clob DEFAULT NULL,
     "dtstart" timestamp DEFAULT NULL,
     "dtend" timestamp DEFAULT NULL,
     PRIMARY KEY ("folder_id", "msguid")
 );
 
 CREATE INDEX "kolab_cache_task_uid2msguid" ON "kolab_cache_task" ("folder_id", "uid", "msguid");
 
 
 CREATE TABLE "kolab_cache_journal" (
     "folder_id" number NOT NULL
         REFERENCES "kolab_folders" ("folder_id") ON DELETE CASCADE,
     "msguid" number NOT NULL,
     "uid" varchar(512) NOT NULL,
     "created" timestamp DEFAULT NULL,
     "changed" timestamp DEFAULT NULL,
     "data" clob NOT NULL,
-    "xml" clob NOT NULL,
     "tags" clob DEFAULT NULL,
     "words" clob DEFAULT NULL,
     "dtstart" timestamp DEFAULT NULL,
     "dtend" timestamp DEFAULT NULL,
     PRIMARY KEY ("folder_id", "msguid")
 );
 
 CREATE INDEX "kolab_cache_journal_uid2msguid" ON "kolab_cache_journal" ("folder_id", "uid", "msguid");
 
 
 CREATE TABLE "kolab_cache_note" (
     "folder_id" number NOT NULL
         REFERENCES "kolab_folders" ("folder_id") ON DELETE CASCADE,
     "msguid" number NOT NULL,
     "uid" varchar(512) NOT NULL,
     "created" timestamp DEFAULT NULL,
     "changed" timestamp DEFAULT NULL,
     "data" clob NOT NULL,
-    "xml" clob NOT NULL,
     "tags" clob DEFAULT NULL,
     "words" clob DEFAULT NULL,
     PRIMARY KEY ("folder_id", "msguid")
 );
 
 CREATE INDEX "kolab_cache_note_uid2msguid" ON "kolab_cache_note" ("folder_id", "uid", "msguid");
 
 
 CREATE TABLE "kolab_cache_file" (
     "folder_id" number NOT NULL
         REFERENCES "kolab_folders" ("folder_id") ON DELETE CASCADE,
     "msguid" number NOT NULL,
     "uid" varchar(512) NOT NULL,
     "created" timestamp DEFAULT NULL,
     "changed" timestamp DEFAULT NULL,
     "data" clob NOT NULL,
-    "xml" clob NOT NULL,
     "tags" clob DEFAULT NULL,
     "words" clob DEFAULT NULL,
     "filename" varchar(255) DEFAULT NULL,
     PRIMARY KEY ("folder_id", "msguid")
 );
 
 CREATE INDEX "kolab_cache_file_filename" ON "kolab_cache_file" ("folder_id", "filename");
 CREATE INDEX "kolab_cache_file_uid2msguid" ON "kolab_cache_file" ("folder_id", "uid", "msguid");
 
 
 CREATE TABLE "kolab_cache_configuration" (
     "folder_id" number NOT NULL
         REFERENCES "kolab_folders" ("folder_id") ON DELETE CASCADE,
     "msguid" number NOT NULL,
     "uid" varchar(512) NOT NULL,
     "created" timestamp DEFAULT NULL,
     "changed" timestamp DEFAULT NULL,
     "data" clob NOT NULL,
-    "xml" clob NOT NULL,
     "tags" clob DEFAULT NULL,
     "words" clob DEFAULT NULL,
     "type" varchar(32) NOT NULL,
     PRIMARY KEY ("folder_id", "msguid")
 );
 
 CREATE INDEX "kolab_cache_config_type" ON "kolab_cache_configuration" ("folder_id", "type");
 CREATE INDEX "kolab_cache_config_uid2msguid" ON "kolab_cache_configuration" ("folder_id", "uid", "msguid");
 
 
 CREATE TABLE "kolab_cache_freebusy" (
     "folder_id" number NOT NULL
         REFERENCES "kolab_folders" ("folder_id") ON DELETE CASCADE,
     "msguid" number NOT NULL,
     "uid" varchar(512) NOT NULL,
     "created" timestamp DEFAULT NULL,
     "changed" timestamp DEFAULT NULL,
     "data" clob NOT NULL,
-    "xml" clob NOT NULL,
     "tags" clob DEFAULT NULL,
     "words" clob DEFAULT NULL,
     "dtstart" timestamp DEFAULT NULL,
     "dtend" timestamp DEFAULT NULL,
     PRIMARY KEY("folder_id", "msguid")
 );
 
 CREATE INDEX "kolab_cache_fb_uid2msguid" ON "kolab_cache_freebusy" ("folder_id", "uid", "msguid");
 
 
-INSERT INTO "system" ("name", "value") VALUES ('libkolab-version', '2018021300');
+INSERT INTO "system" ("name", "value") VALUES ('libkolab-version', '2018122700');
diff --git a/plugins/libkolab/SQL/oracle/2018122700.sql b/plugins/libkolab/SQL/oracle/2018122700.sql
new file mode 100644
index 00000000..45fccb74
--- /dev/null
+++ b/plugins/libkolab/SQL/oracle/2018122700.sql
@@ -0,0 +1,10 @@
+-- remove xml column, and change data format (clear cache needed)
+DELETE FROM "kolab_folders";
+ALTER TABLE "kolab_cache_contact" DROP COLUMN "xml";
+ALTER TABLE "kolab_cache_event" DROP COLUMN "xml";
+ALTER TABLE "kolab_cache_task" DROP COLUMN "xml";
+ALTER TABLE "kolab_cache_journal" DROP COLUMN "xml";
+ALTER TABLE "kolab_cache_note" DROP COLUMN "xml";
+ALTER TABLE "kolab_cache_file" DROP COLUMN "xml";
+ALTER TABLE "kolab_cache_configuration" DROP COLUMN "xml";
+ALTER TABLE "kolab_cache_freebusy" DROP COLUMN "xml";
diff --git a/plugins/libkolab/SQL/sqlite.initial.sql b/plugins/libkolab/SQL/sqlite.initial.sql
index 909188ca..815316dc 100644
--- a/plugins/libkolab/SQL/sqlite.initial.sql
+++ b/plugins/libkolab/SQL/sqlite.initial.sql
@@ -1,159 +1,151 @@
 /**
  * libkolab database schema
  *
  * @version 1.2
  * @author Thomas Bruederli
  * @licence GNU AGPL
  **/
 
 CREATE TABLE kolab_folders (
   folder_id INTEGER NOT NULL PRIMARY KEY,
   resource VARCHAR(255) NOT NULL,
   type VARCHAR(32) NOT NULL,
   synclock INTEGER NOT NULL DEFAULT '0',
   ctag VARCHAR(40) DEFAULT NULL,
   changed DATETIME DEFAULT NULL,
   objectcount INTEGER DEFAULT NULL
 );
 
 CREATE INDEX ix_resource_type ON kolab_folders(resource, type);
 
 CREATE TABLE kolab_cache_contact (
   folder_id INTEGER NOT NULL,
   msguid INTEGER NOT NULL,
   uid VARCHAR(512) NOT NULL,
   created DATETIME DEFAULT NULL,
   changed DATETIME DEFAULT NULL,
   data TEXT NOT NULL,
-  xml TEXT NOT NULL,
   tags TEXT NOT NULL,
   words TEXT NOT NULL,
   type VARCHAR(32) NOT NULL,
   name VARCHAR(255) NOT NULL,
   firstname VARCHAR(255) NOT NULL,
   surname VARCHAR(255) NOT NULL,
   email VARCHAR(255) NOT NULL,
   PRIMARY KEY(folder_id,msguid)
 );
 
 CREATE INDEX ix_contact_type ON kolab_cache_contact(folder_id,type);
 CREATE INDEX ix_contact_uid2msguid ON kolab_cache_contact(folder_id,uid,msguid);
 
 CREATE TABLE kolab_cache_event (
   folder_id INTEGER NOT NULL,
   msguid INTEGER NOT NULL,
   uid VARCHAR(512) NOT NULL,
   created DATETIME DEFAULT NULL,
   changed DATETIME DEFAULT NULL,
   data TEXT NOT NULL,
-  xml TEXT NOT NULL,
   tags TEXT NOT NULL,
   words TEXT NOT NULL,
   dtstart DATETIME,
   dtend DATETIME,
   PRIMARY KEY(folder_id,msguid)
 );
 
 CREATE INDEX ix_event_uid2msguid ON kolab_cache_event(folder_id,uid,msguid);
 
 CREATE TABLE kolab_cache_task (
   folder_id INTEGER NOT NULL,
   msguid INTEGER NOT NULL,
   uid VARCHAR(512) NOT NULL,
   created DATETIME DEFAULT NULL,
   changed DATETIME DEFAULT NULL,
   data TEXT NOT NULL,
-  xml TEXT NOT NULL,
   tags TEXT NOT NULL,
   words TEXT NOT NULL,
   dtstart DATETIME,
   dtend DATETIME,
   PRIMARY KEY(folder_id,msguid)
 );
 
 CREATE INDEX ix_task_uid2msguid ON kolab_cache_task(folder_id,uid,msguid);
 
 CREATE TABLE kolab_cache_journal (
   folder_id INTEGER NOT NULL,
   msguid INTEGER NOT NULL,
   uid VARCHAR(512) NOT NULL,
   created DATETIME DEFAULT NULL,
   changed DATETIME DEFAULT NULL,
   data TEXT NOT NULL,
-  xml TEXT NOT NULL,
   tags TEXT NOT NULL,
   words TEXT NOT NULL,
   dtstart DATETIME,
   dtend DATETIME,
   PRIMARY KEY(folder_id,msguid)
 );
 
 CREATE INDEX ix_journal_uid2msguid ON kolab_cache_journal(folder_id,uid,msguid);
 
 CREATE TABLE kolab_cache_note (
   folder_id INTEGER NOT NULL,
   msguid INTEGER NOT NULL,
   uid VARCHAR(512) NOT NULL,
   created DATETIME DEFAULT NULL,
   changed DATETIME DEFAULT NULL,
   data TEXT NOT NULL,
-  xml TEXT NOT NULL,
   tags TEXT NOT NULL,
   words TEXT NOT NULL,
   PRIMARY KEY(folder_id,msguid)
 );
 
 CREATE INDEX ix_note_uid2msguid ON kolab_cache_note(folder_id,uid,msguid);
 
 CREATE TABLE kolab_cache_file (
   folder_id INTEGER NOT NULL,
   msguid INTEGER NOT NULL,
   uid VARCHAR(512) NOT NULL,
   created DATETIME DEFAULT NULL,
   changed DATETIME DEFAULT NULL,
   data TEXT NOT NULL,
-  xml TEXT NOT NULL,
   tags TEXT NOT NULL,
   words TEXT NOT NULL,
   filename varchar(255) DEFAULT NULL,
   PRIMARY KEY(folder_id,msguid)
 );
 
 CREATE INDEX ix_folder_filename ON kolab_cache_file(folder_id,filename);
 CREATE INDEX ix_file_uid2msguid ON kolab_cache_file(folder_id,uid,msguid);
 
 CREATE TABLE kolab_cache_configuration (
   folder_id INTEGER NOT NULL,
   msguid INTEGER NOT NULL,
   uid VARCHAR(512) NOT NULL,
   created DATETIME DEFAULT NULL,
   changed DATETIME DEFAULT NULL,
   data TEXT NOT NULL,
-  xml TEXT NOT NULL,
   tags TEXT NOT NULL,
   words TEXT NOT NULL,
   type VARCHAR(32) NOT NULL,
   PRIMARY KEY(folder_id,msguid)
 );
 
 CREATE INDEX ix_configuration_type ON kolab_cache_configuration(folder_id,type);
 CREATE INDEX ix_configuration_uid2msguid ON kolab_cache_configuration(folder_id,uid,msguid);
 
 CREATE TABLE kolab_cache_freebusy (
   folder_id INTEGER NOT NULL,
   msguid INTEGER NOT NULL,
   uid VARCHAR(512) NOT NULL,
   created DATETIME DEFAULT NULL,
   changed DATETIME DEFAULT NULL,
   data TEXT NOT NULL,
-  xml TEXT NOT NULL,
   tags TEXT NOT NULL,
   words TEXT NOT NULL,
   dtstart DATETIME,
   dtend DATETIME,
   PRIMARY KEY(folder_id,msguid)
 );
 
 CREATE INDEX ix_freebusy_uid2msguid ON kolab_cache_freebusy(folder_id,uid,msguid);
 
-INSERT INTO system (name, value) VALUES ('libkolab-version', '2018021300');
+INSERT INTO system (name, value) VALUES ('libkolab-version', '2018122700');
diff --git a/plugins/libkolab/SQL/sqlite.initial.sql b/plugins/libkolab/SQL/sqlite/2018122700.sql
similarity index 83%
copy from plugins/libkolab/SQL/sqlite.initial.sql
copy to plugins/libkolab/SQL/sqlite/2018122700.sql
index 909188ca..ee24c1a6 100644
--- a/plugins/libkolab/SQL/sqlite.initial.sql
+++ b/plugins/libkolab/SQL/sqlite/2018122700.sql
@@ -1,159 +1,137 @@
-/**
- * libkolab database schema
- *
- * @version 1.2
- * @author Thomas Bruederli
- * @licence GNU AGPL
- **/
-
-CREATE TABLE kolab_folders (
-  folder_id INTEGER NOT NULL PRIMARY KEY,
-  resource VARCHAR(255) NOT NULL,
-  type VARCHAR(32) NOT NULL,
-  synclock INTEGER NOT NULL DEFAULT '0',
-  ctag VARCHAR(40) DEFAULT NULL,
-  changed DATETIME DEFAULT NULL,
-  objectcount INTEGER DEFAULT NULL
-);
-
-CREATE INDEX ix_resource_type ON kolab_folders(resource, type);
-
+DROP TABLE kolab_cache_contact;
 CREATE TABLE kolab_cache_contact (
   folder_id INTEGER NOT NULL,
   msguid INTEGER NOT NULL,
   uid VARCHAR(512) NOT NULL,
   created DATETIME DEFAULT NULL,
   changed DATETIME DEFAULT NULL,
   data TEXT NOT NULL,
-  xml TEXT NOT NULL,
   tags TEXT NOT NULL,
   words TEXT NOT NULL,
   type VARCHAR(32) NOT NULL,
   name VARCHAR(255) NOT NULL,
   firstname VARCHAR(255) NOT NULL,
   surname VARCHAR(255) NOT NULL,
   email VARCHAR(255) NOT NULL,
   PRIMARY KEY(folder_id,msguid)
 );
 
 CREATE INDEX ix_contact_type ON kolab_cache_contact(folder_id,type);
 CREATE INDEX ix_contact_uid2msguid ON kolab_cache_contact(folder_id,uid,msguid);
 
+DROP TABLE kolab_cache_event;
 CREATE TABLE kolab_cache_event (
   folder_id INTEGER NOT NULL,
   msguid INTEGER NOT NULL,
   uid VARCHAR(512) NOT NULL,
   created DATETIME DEFAULT NULL,
   changed DATETIME DEFAULT NULL,
   data TEXT NOT NULL,
-  xml TEXT NOT NULL,
   tags TEXT NOT NULL,
   words TEXT NOT NULL,
   dtstart DATETIME,
   dtend DATETIME,
   PRIMARY KEY(folder_id,msguid)
 );
 
 CREATE INDEX ix_event_uid2msguid ON kolab_cache_event(folder_id,uid,msguid);
 
+DROP TABLE kolab_cache_task;
 CREATE TABLE kolab_cache_task (
   folder_id INTEGER NOT NULL,
   msguid INTEGER NOT NULL,
   uid VARCHAR(512) NOT NULL,
   created DATETIME DEFAULT NULL,
   changed DATETIME DEFAULT NULL,
   data TEXT NOT NULL,
-  xml TEXT NOT NULL,
   tags TEXT NOT NULL,
   words TEXT NOT NULL,
   dtstart DATETIME,
   dtend DATETIME,
   PRIMARY KEY(folder_id,msguid)
 );
 
 CREATE INDEX ix_task_uid2msguid ON kolab_cache_task(folder_id,uid,msguid);
 
+DROP TABLE kolab_cache_journal;
 CREATE TABLE kolab_cache_journal (
   folder_id INTEGER NOT NULL,
   msguid INTEGER NOT NULL,
   uid VARCHAR(512) NOT NULL,
   created DATETIME DEFAULT NULL,
   changed DATETIME DEFAULT NULL,
   data TEXT NOT NULL,
-  xml TEXT NOT NULL,
   tags TEXT NOT NULL,
   words TEXT NOT NULL,
   dtstart DATETIME,
   dtend DATETIME,
   PRIMARY KEY(folder_id,msguid)
 );
 
 CREATE INDEX ix_journal_uid2msguid ON kolab_cache_journal(folder_id,uid,msguid);
 
+DROP TABLE kolab_cache_note;
 CREATE TABLE kolab_cache_note (
   folder_id INTEGER NOT NULL,
   msguid INTEGER NOT NULL,
   uid VARCHAR(512) NOT NULL,
   created DATETIME DEFAULT NULL,
   changed DATETIME DEFAULT NULL,
   data TEXT NOT NULL,
-  xml TEXT NOT NULL,
   tags TEXT NOT NULL,
   words TEXT NOT NULL,
   PRIMARY KEY(folder_id,msguid)
 );
 
 CREATE INDEX ix_note_uid2msguid ON kolab_cache_note(folder_id,uid,msguid);
 
+DROP TABLE kolab_cache_file;
 CREATE TABLE kolab_cache_file (
   folder_id INTEGER NOT NULL,
   msguid INTEGER NOT NULL,
   uid VARCHAR(512) NOT NULL,
   created DATETIME DEFAULT NULL,
   changed DATETIME DEFAULT NULL,
   data TEXT NOT NULL,
-  xml TEXT NOT NULL,
   tags TEXT NOT NULL,
   words TEXT NOT NULL,
   filename varchar(255) DEFAULT NULL,
   PRIMARY KEY(folder_id,msguid)
 );
 
 CREATE INDEX ix_folder_filename ON kolab_cache_file(folder_id,filename);
 CREATE INDEX ix_file_uid2msguid ON kolab_cache_file(folder_id,uid,msguid);
 
+DROP TABLE kolab_cache_configuration;
 CREATE TABLE kolab_cache_configuration (
   folder_id INTEGER NOT NULL,
   msguid INTEGER NOT NULL,
   uid VARCHAR(512) NOT NULL,
   created DATETIME DEFAULT NULL,
   changed DATETIME DEFAULT NULL,
   data TEXT NOT NULL,
-  xml TEXT NOT NULL,
   tags TEXT NOT NULL,
   words TEXT NOT NULL,
   type VARCHAR(32) NOT NULL,
   PRIMARY KEY(folder_id,msguid)
 );
 
 CREATE INDEX ix_configuration_type ON kolab_cache_configuration(folder_id,type);
 CREATE INDEX ix_configuration_uid2msguid ON kolab_cache_configuration(folder_id,uid,msguid);
 
+DROP TABLE kolab_cache_freebusy;
 CREATE TABLE kolab_cache_freebusy (
   folder_id INTEGER NOT NULL,
   msguid INTEGER NOT NULL,
   uid VARCHAR(512) NOT NULL,
   created DATETIME DEFAULT NULL,
   changed DATETIME DEFAULT NULL,
   data TEXT NOT NULL,
-  xml TEXT NOT NULL,
   tags TEXT NOT NULL,
   words TEXT NOT NULL,
   dtstart DATETIME,
   dtend DATETIME,
   PRIMARY KEY(folder_id,msguid)
 );
 
 CREATE INDEX ix_freebusy_uid2msguid ON kolab_cache_freebusy(folder_id,uid,msguid);
-
-INSERT INTO system (name, value) VALUES ('libkolab-version', '2018021300');
diff --git a/plugins/libkolab/config.inc.php.dist b/plugins/libkolab/config.inc.php.dist
index a4a7a7a6..eddafbd6 100644
--- a/plugins/libkolab/config.inc.php.dist
+++ b/plugins/libkolab/config.inc.php.dist
@@ -1,87 +1,88 @@
 <?php
 
 /* Configuration for libkolab */
 
 // Enable caching of Kolab objects in local database
 $config['kolab_cache'] = true;
 
 // Cache refresh interval (default is 12 hours)
 // after this period, cache is forced to synchronize with IMAP
 $config['kolab_cache_refresh'] = '12h';
 
 // Specify format version to write Kolab objects (must be a string value!)
 $config['kolab_format_version']  = '3.0';
 
 // Optional override of the URL to read and trigger Free/Busy information of Kolab users
 // Defaults to /freebusy or https://<imap-server->/freebusy
 $config['kolab_freebusy_server'] = null;
 
 // Enables listing of only subscribed folders. This e.g. will limit
 // folders in calendar view or available addressbooks
 $config['kolab_use_subscriptions'] = false;
 
 // List any of 'personal','shared','other' namespaces to be excluded from groupware folder listing
 // example: array('other');
 $config['kolab_skip_namespace'] = null;
 
 // Enables the use of displayname folder annotations as introduced in KEP:?
 // for displaying resource folder names (experimental!)
 $config['kolab_custom_display_names'] = false;
 
 // Configuration of HTTP requests.
 // See http://pear.php.net/manual/en/package.http.http-request2.config.php
 // for list of supported configuration options (array keys)
 $config['kolab_http_request'] = array();
 
 // When kolab_cache is enabled Roundcube's messages cache will be redundant
 // when working on kolab folders. Here we can:
-// 2 - bypass messages/indexes cache completely
+// 3 - bypass only indexes, but use messages cache
+// 2 - bypass both messages and indexes cache
 // 1 - bypass only messages, but use index cache
 $config['kolab_messages_cache_bypass'] = 0;
 
 // These event properties contribute to a significant revision to the calendar component
 // and if changed will increment the sequence number relevant for scheduling according to RFC 5545
 $config['kolab_event_scheduling_properties'] = array('start', 'end', 'allday', 'recurrence', 'location', 'status', 'cancelled');
 
 // These task properties contribute to a significant revision to the calendar component
 // and if changed will increment the sequence number relevant for scheduling according to RFC 5545
 $config['kolab_task_scheduling_properties'] = array('start', 'due', 'summary', 'status');
 
 // LDAP directory to find avilable users for folder sharing.
 // Either contains an array with LDAP addressbook configuration or refers to entry in $config['ldap_public'].
 // If not specified, the configuraton from 'kolab_auth_addressbook' will be used.
 // Should be provided for multi-domain setups with placeholders like %dc, %d, %u, %fu or %dn.
 $config['kolab_users_directory'] = null;
 
 // Filter to be used for resolving user folders in LDAP.
 // Defaults to the 'kolab_auth_filter' configuration option.
 $config['kolab_users_filter'] = '(&(objectclass=kolabInetOrgPerson)(|(uid=%u)(mail=%fu)))';
 
 // Which property of the LDAP user record to use for user folder mapping in IMAP.
 // Defaults to the 'kolab_auth_login' configuration option.
 $config['kolab_users_id_attrib'] = null;
 
 // Use these attributes when searching users in LDAP
 $config['kolab_users_search_attrib'] = array('cn','mail','alias');
 
 // Which property of the LDAP user record to use as a display name.
 // Defaults to the 'kolab_auth_name' configuration option.
 $config['kolab_users_name_field'] = null;
 
 // Type of cache for uid-to-user map. Supported: 'db', 'apc', 'memcache' and 'memcached'.
 // Note: This stores only other user folder identifier to user attributes map.
 $config['kolab_users_cache'] = null;
 
 // lifetime of shared folder mapping cache
 // possible units: s, m, h, d, w
 $config['kolab_users_cache_ttl'] = '10d';
 
 // JSON-RPC endpoint configuration of the Bonnie web service providing historic data for groupware objects
 $config['kolab_bonnie_api'] = array(
     'uri'    => 'https://<kolab-hostname>:8080/api/rpc',
     'user'   => 'webclient',
     'pass'   => 'Welcome2KolabSystems',
     'secret' => '8431f191707fffffff00000000cccc',
     'debug'  => true,   // logs requests/responses to <log-dir>/bonnie
     'timeout' => 30,
 );
diff --git a/plugins/libkolab/lib/kolab_storage_cache.php b/plugins/libkolab/lib/kolab_storage_cache.php
index 362d53c1..8f682e54 100644
--- a/plugins/libkolab/lib/kolab_storage_cache.php
+++ b/plugins/libkolab/lib/kolab_storage_cache.php
@@ -1,1281 +1,1272 @@
 <?php
 
 /**
  * Kolab storage cache class providing a local caching layer for Kolab groupware objects.
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2012-2013, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class kolab_storage_cache
 {
     const DB_DATE_FORMAT = 'Y-m-d H:i:s';
     const MAX_RECORDS    = 500;
 
     public $sync_complete = false;
 
     protected $db;
     protected $imap;
     protected $folder;
     protected $uid2msg;
     protected $objects;
     protected $metadata = array();
     protected $folder_id;
     protected $resource_uri;
     protected $enabled = true;
     protected $synched = false;
     protected $synclock = false;
     protected $ready = false;
     protected $cache_table;
     protected $cache_refresh = 3600;
     protected $folders_table;
     protected $max_sql_packet;
     protected $max_sync_lock_time = 600;
-    protected $binary_items = array();
     protected $extra_cols = array();
+    protected $data_props = array();
     protected $order_by = null;
     protected $limit = null;
     protected $error = 0;
     protected $server_timezone;
 
 
     /**
      * Factory constructor
      */
     public static function factory(kolab_storage_folder $storage_folder)
     {
         $subclass = 'kolab_storage_cache_' . $storage_folder->type;
         if (class_exists($subclass)) {
             return new $subclass($storage_folder);
         }
         else {
             rcube::raise_error(array(
                 'code' => 900,
                 'type' => 'php',
                 'message' => "No kolab_storage_cache class found for folder '$storage_folder->name' of type '$storage_folder->type'"
             ), true);
 
             return new kolab_storage_cache($storage_folder);
         }
     }
 
 
     /**
      * Default constructor
      */
     public function __construct(kolab_storage_folder $storage_folder = null)
     {
         $rcmail = rcube::get_instance();
         $this->db = $rcmail->get_dbh();
         $this->imap = $rcmail->get_storage();
         $this->enabled = $rcmail->config->get('kolab_cache', false);
         $this->folders_table = $this->db->table_name('kolab_folders');
         $this->cache_refresh = get_offset_sec($rcmail->config->get('kolab_cache_refresh', '12h'));
         $this->server_timezone = new DateTimeZone(date_default_timezone_get());
 
         if ($this->enabled) {
             // always read folder cache and lock state from DB master
             $this->db->set_table_dsn('kolab_folders', 'w');
             // remove sync-lock on script termination
             $rcmail->add_shutdown_function(array($this, '_sync_unlock'));
         }
 
         if ($storage_folder)
             $this->set_folder($storage_folder);
     }
 
     /**
      * Direct access to cache by folder_id
      * (only for internal use)
      */
     public function select_by_id($folder_id)
     {
         $sql_arr = $this->db->fetch_assoc($this->db->query("SELECT * FROM `{$this->folders_table}` WHERE `folder_id` = ?", $folder_id));
         if ($sql_arr) {
             $this->metadata = $sql_arr;
             $this->folder_id = $sql_arr['folder_id'];
             $this->folder = new StdClass;
             $this->folder->type = $sql_arr['type'];
             $this->resource_uri = $sql_arr['resource'];
             $this->cache_table = $this->db->table_name('kolab_cache_' . $sql_arr['type']);
             $this->ready = true;
         }
     }
 
     /**
      * Connect cache with a storage folder
      *
      * @param kolab_storage_folder The storage folder instance to connect with
      */
     public function set_folder(kolab_storage_folder $storage_folder)
     {
         $this->folder = $storage_folder;
 
         if (empty($this->folder->name) || !$this->folder->valid) {
             $this->ready = false;
             return;
         }
 
         // compose fully qualified ressource uri for this instance
         $this->resource_uri = $this->folder->get_resource_uri();
         $this->cache_table = $this->db->table_name('kolab_cache_' . $this->folder->type);
         $this->ready = $this->enabled && !empty($this->folder->type);
         $this->folder_id = null;
     }
 
     /**
      * Returns true if this cache supports query by type
      */
     public function has_type_col()
     {
         return in_array('type', $this->extra_cols);
     }
 
     /**
      * Getter for the numeric ID used in cache tables
      */
     public function get_folder_id()
     {
         $this->_read_folder_data();
         return $this->folder_id;
     }
 
     /**
      * Returns code of last error
      *
      * @return int Error code
      */
     public function get_error()
     {
         return $this->error;
     }
 
     /**
      * Synchronize local cache data with remote
      */
     public function synchronize()
     {
         // only sync once per request cycle
         if ($this->synched)
             return;
 
         // increase time limit
         @set_time_limit($this->max_sync_lock_time - 60);
 
         // get effective time limit we have for synchronization (~70% of the execution time)
         $time_limit = ini_get('max_execution_time') * 0.7;
         $sync_start = time();
 
         // assume sync will be completed
         $this->sync_complete = true;
 
         if (!$this->ready) {
             // kolab cache is disabled, synchronize IMAP mailbox cache only
             $this->imap_mode(true);
             $this->imap->folder_sync($this->folder->name);
             $this->imap_mode(false);
         }
         else {
             // read cached folder metadata
             $this->_read_folder_data();
 
             // check cache status ($this->metadata is set in _read_folder_data())
             if (  empty($this->metadata['ctag']) ||
                   empty($this->metadata['changed']) ||
                   $this->metadata['objectcount'] === null ||
                   $this->metadata['changed'] < date(self::DB_DATE_FORMAT, time() - $this->cache_refresh) ||
                   $this->metadata['ctag'] != $this->folder->get_ctag() ||
                   intval($this->metadata['objectcount']) !== $this->count()
-                ) {
+            ) {
                 // lock synchronization for this folder or wait if locked
                 $this->_sync_lock();
 
                 // disable messages cache if configured to do so
                 $this->imap_mode(true);
 
                 // synchronize IMAP mailbox cache
                 $this->imap->folder_sync($this->folder->name);
 
                 // compare IMAP index with object cache index
                 $imap_index = $this->imap->index($this->folder->name, null, null, true, true);
 
                 $this->imap_mode(false);
 
                 // determine objects to fetch or to invalidate
                 if (!$imap_index->is_error()) {
                     $imap_index = $imap_index->get();
                     $old_index  = array();
                     $del_index  = array();
 
                     // read cache index
                     $sql_result = $this->db->query(
                         "SELECT `msguid`, `uid` FROM `{$this->cache_table}` WHERE `folder_id` = ?"
                             . " ORDER BY `msguid` DESC", $this->folder_id
                     );
 
                     while ($sql_arr = $this->db->fetch_assoc($sql_result)) {
                         // Mark all duplicates for removal (note sorting order above)
                         // Duplicates here should not happen, but they do sometimes
                         if (isset($old_index[$sql_arr['uid']])) {
                             $del_index[] = $sql_arr['msguid'];
                         }
                         else {
                             $old_index[$sql_arr['uid']] = $sql_arr['msguid'];
                         }
                     }
 
                     // fetch new objects from imap
                     $i = 0;
                     foreach (array_diff($imap_index, $old_index) as $msguid) {
-                        if ($object = $this->folder->read_object($msguid, '*')) {
+                        // Note: We'll store only objects matching the folder type
+                        // anything else will be silently ignored
+                        if ($object = $this->folder->read_object($msguid)) {
                             // Deduplication: remove older objects with the same UID
                             // Here we do not resolve conflicts, we just make sure
                             // the most recent version of the object will be used
                             if ($old_msguid = $old_index[$object['uid']]) {
                                 if ($old_msguid < $msguid) {
                                     $del_index[] = $old_msguid;
                                 }
                                 else {
                                     $del_index[] = $msguid;
                                     continue;
                                 }
                             }
 
                             $old_index[$object['uid']] = $msguid;
 
                             $this->_extended_insert($msguid, $object);
 
                             // check time limit and abort sync if running too long
                             if (++$i % 50 == 0 && time() - $sync_start > $time_limit) {
                                 $this->sync_complete = false;
                                 break;
                             }
                         }
                     }
                     $this->_extended_insert(0, null);
 
                     $del_index = array_unique($del_index);
 
                     // delete duplicate entries from IMAP
                     $rem_index = array_intersect($del_index, $imap_index);
                     if (!empty($rem_index)) {
                         $this->imap_mode(true);
                         $this->imap->delete_message($rem_index, $this->folder->name);
                         $this->imap_mode(false);
                     }
 
                     // delete old/invalid entries from the cache
                     $del_index += array_diff($old_index, $imap_index);
                     if (!empty($del_index)) {
                         $quoted_ids = join(',', array_map(array($this->db, 'quote'), $del_index));
                         $this->db->query(
                             "DELETE FROM `{$this->cache_table}` WHERE `folder_id` = ? AND `msguid` IN ($quoted_ids)",
                             $this->folder_id
                         );
                     }
 
                     // update ctag value (will be written to database in _sync_unlock())
                     if ($this->sync_complete) {
                         $this->metadata['ctag'] = $this->folder->get_ctag();
                         $this->metadata['changed'] = date(self::DB_DATE_FORMAT, time());
                         // remember the number of cache entries linked to this folder
                         $this->metadata['objectcount'] = $this->count();
                     }
                 }
 
                 // remove lock
                 $this->_sync_unlock();
             }
         }
 
         $this->check_error();
         $this->synched = time();
     }
 
 
     /**
      * Read a single entry from cache or from IMAP directly
      *
      * @param string Related IMAP message UID
      * @param string Object type to read
      * @param string IMAP folder name the entry relates to
      * @param array  Hash array with object properties or null if not found
      */
     public function get($msguid, $type = null, $foldername = null)
     {
         // delegate to another cache instance
         if ($foldername && $foldername != $this->folder->name) {
             $success = false;
             if ($targetfolder = kolab_storage::get_folder($foldername)) {
                 $success = $targetfolder->cache->get($msguid, $type);
                 $this->error = $targetfolder->cache->get_error();
             }
             return $success;
         }
 
         // load object if not in memory
         if (!isset($this->objects[$msguid])) {
             if ($this->ready) {
                 $this->_read_folder_data();
 
                 $sql_result = $this->db->query(
                     "SELECT * FROM `{$this->cache_table}` ".
                     "WHERE `folder_id` = ? AND `msguid` = ?",
                     $this->folder_id,
                     $msguid
                 );
 
                 if ($sql_arr = $this->db->fetch_assoc($sql_result)) {
                     $this->objects = array($msguid => $this->_unserialize($sql_arr));  // store only this object in memory (#2827)
                 }
             }
 
             // fetch from IMAP if not present in cache
             if (empty($this->objects[$msguid])) {
                 if ($object = $this->folder->read_object($msguid, $type ?: '*', $foldername)) {
                     $this->objects = array($msguid => $object);
                     $this->set($msguid, $object);
                 }
             }
         }
 
         $this->check_error();
         return $this->objects[$msguid];
     }
 
     /**
      * Getter for a single Kolab object identified by its UID
      *
      * @param string $uid Object UID
      *
      * @return array The Kolab object represented as hash array
      */
     public function get_by_uid($uid)
     {
         $old_order_by = $this->order_by;
         $old_limit    = $this->limit;
 
         // set order to make sure we get most recent object version
         // set limit to skip count query
         $this->order_by = '`msguid` DESC';
         $this->limit    = array(1, 0);
 
         $list = $this->select(array(array('uid', '=', $uid)));
 
         // set the order/limit back to defined value
         $this->order_by = $old_order_by;
         $this->limit    = $old_limit;
 
         if (!empty($list) && !empty($list[0])) {
             return $list[0];
         }
     }
 
     /**
      * Insert/Update a cache entry
      *
      * @param string Related IMAP message UID
      * @param mixed  Hash array with object properties to save or false to delete the cache entry
      * @param string IMAP folder name the entry relates to
      */
     public function set($msguid, $object, $foldername = null)
     {
         if (!$msguid) {
             return;
         }
 
         // delegate to another cache instance
         if ($foldername && $foldername != $this->folder->name) {
           if ($targetfolder = kolab_storage::get_folder($foldername)) {
               $targetfolder->cache->set($msguid, $object);
               $this->error = $targetfolder->cache->get_error();
           }
           return;
         }
 
         // remove old entry
         if ($this->ready) {
             $this->_read_folder_data();
             $this->db->query("DELETE FROM `{$this->cache_table}` WHERE `folder_id` = ? AND `msguid` = ?",
                 $this->folder_id, $msguid);
         }
 
         if ($object) {
             // insert new object data...
             $this->save($msguid, $object);
         }
         else {
             // ...or set in-memory cache to false
             $this->objects[$msguid] = $object;
         }
 
         $this->check_error();
     }
 
 
     /**
      * Insert (or update) a cache entry
      *
      * @param int    Related IMAP message UID
      * @param mixed  Hash array with object properties to save or false to delete the cache entry
      * @param int    Optional old message UID (for update)
      */
     public function save($msguid, $object, $olduid = null)
     {
         // write to cache
         if ($this->ready) {
             $this->_read_folder_data();
 
             $sql_data = $this->_serialize($object);
             $sql_data['folder_id'] = $this->folder_id;
             $sql_data['msguid']    = $msguid;
             $sql_data['uid']       = $object['uid'];
 
             $args = array();
-            $cols = array('folder_id', 'msguid', 'uid', 'changed', 'data', 'xml', 'tags', 'words');
+            $cols = array('folder_id', 'msguid', 'uid', 'changed', 'data', 'tags', 'words');
             $cols = array_merge($cols, $this->extra_cols);
 
             foreach ($cols as $idx => $col) {
                 $cols[$idx] = $this->db->quote_identifier($col);
                 $args[]     = $sql_data[$col];
             }
 
             if ($olduid) {
                 foreach ($cols as $idx => $col) {
                     $cols[$idx] = "$col = ?";
                 }
 
                 $query = "UPDATE `{$this->cache_table}` SET " . implode(', ', $cols)
                     . " WHERE `folder_id` = ? AND `msguid` = ?";
                 $args[] = $this->folder_id;
                 $args[] = $olduid;
             }
             else {
                 $query = "INSERT INTO `{$this->cache_table}` (`created`, " . implode(', ', $cols)
                     . ") VALUES (" . $this->db->now() . str_repeat(', ?', count($cols)) . ")";
             }
 
             $result = $this->db->query($query, $args);
 
             if (!$this->db->affected_rows($result)) {
                 rcube::raise_error(array(
                     'code' => 900, 'type' => 'php',
                     'message' => "Failed to write to kolab cache"
                 ), true);
             }
         }
 
         // keep a copy in memory for fast access
         $this->objects = array($msguid => $object);
         $this->uid2msg = array($object['uid'] => $msguid);
 
         $this->check_error();
     }
 
 
     /**
      * Move an existing cache entry to a new resource
      *
      * @param string               Entry's IMAP message UID
      * @param string               Entry's Object UID
      * @param kolab_storage_folder Target storage folder instance
      * @param string               Target entry's IMAP message UID
      */
     public function move($msguid, $uid, $target, $new_msguid = null)
     {
         if ($this->ready && $target) {
             // clear cached uid mapping and force new lookup
             unset($target->cache->uid2msg[$uid]);
 
             // resolve new message UID in target folder
             if (!$new_msguid) {
                 $new_msguid = $target->cache->uid2msguid($uid);
             }
 
             if ($new_msguid) {
                 $this->_read_folder_data();
 
                 $this->db->query(
                     "UPDATE `{$this->cache_table}` SET `folder_id` = ?, `msguid` = ? ".
                     "WHERE `folder_id` = ? AND `msguid` = ?",
                     $target->cache->get_folder_id(),
                     $new_msguid,
                     $this->folder_id,
                     $msguid
                 );
 
                 $result = $this->db->affected_rows();
             }
         }
 
         if (empty($result)) {
             // just clear cache entry
             $this->set($msguid, false);
         }
 
         unset($this->uid2msg[$uid]);
         $this->check_error();
     }
 
 
     /**
      * Remove all objects from local cache
      */
     public function purge()
     {
         if (!$this->ready) {
             return true;
         }
 
         $this->_read_folder_data();
 
         $result = $this->db->query(
             "DELETE FROM `{$this->cache_table}` WHERE `folder_id` = ?",
             $this->folder_id
         );
 
         return $this->db->affected_rows($result);
     }
 
     /**
      * Update resource URI for existing cache entries
      *
      * @param string Target IMAP folder to move it to
      */
     public function rename($new_folder)
     {
         if (!$this->ready) {
             return;
         }
 
         if ($target = kolab_storage::get_folder($new_folder)) {
             // resolve new message UID in target folder
             $this->db->query(
                 "UPDATE `{$this->folders_table}` SET `resource` = ? ".
                 "WHERE `resource` = ?",
                 $target->get_resource_uri(),
                 $this->resource_uri
             );
 
             $this->check_error();
         }
         else {
             $this->error = kolab_storage::ERROR_IMAP_CONN;
         }
     }
 
     /**
      * Select Kolab objects filtered by the given query
      *
      * @param array Pseudo-SQL query as list of filter parameter triplets
      *   triplet: array('<colname>', '<comparator>', '<value>')
      * @param boolean Set true to only return UIDs instead of complete objects
+     * @param boolean Use fast mode to fetch only minimal set of information
+     *                (no xml fetching and parsing, etc.)
+     *
      * @return array List of Kolab data objects (each represented as hash array) or UIDs
      */
-    public function select($query = array(), $uids = false)
+    public function select($query = array(), $uids = false, $fast = false)
     {
         $result = $uids ? array() : new kolab_storage_dataset($this);
 
         // read from local cache DB (assume it to be synchronized)
         if ($this->ready) {
             $this->_read_folder_data();
 
             // fetch full object data on one query if a small result set is expected
             $fetchall = !$uids && ($this->limit ? $this->limit[0] : ($count = $this->count($query))) < self::MAX_RECORDS;
 
             // skip SELECT if we know it will return nothing
             if ($count === 0) {
                 return $result;
             }
 
             $sql_query = "SELECT " . ($fetchall ? '*' : "`msguid` AS `_msguid`, `uid`")
                 . " FROM `{$this->cache_table}` WHERE `folder_id` = ?"
                 . $this->_sql_where($query)
                 . (!empty($this->order_by) ? " ORDER BY " . $this->order_by : '');
 
             $sql_result = $this->limit ?
                 $this->db->limitquery($sql_query, $this->limit[1], $this->limit[0], $this->folder_id) :
                 $this->db->query($sql_query, $this->folder_id);
 
             if ($this->db->is_error($sql_result)) {
                 if ($uids) {
                     return null;
                 }
                 $result->set_error(true);
                 return $result;
             }
 
             while ($sql_arr = $this->db->fetch_assoc($sql_result)) {
+                if ($fast) {
+                    $sql_arr['fast-mode'] = true;
+                }
                 if ($uids) {
                     $this->uid2msg[$sql_arr['uid']] = $sql_arr['_msguid'];
                     $result[] = $sql_arr['uid'];
                 }
                 else if ($fetchall && ($object = $this->_unserialize($sql_arr))) {
                     $result[] = $object;
                 }
                 else if (!$fetchall) {
                     // only add msguid to dataset index
                     $result[] = $sql_arr;
                 }
             }
         }
         // use IMAP
         else {
             $filter = $this->_query2assoc($query);
 
             $this->imap_mode(true);
 
             if ($filter['type']) {
                 $search = 'UNDELETED HEADER X-Kolab-Type ' . kolab_format::KTYPE_PREFIX . $filter['type'];
                 $index  = $this->imap->search_once($this->folder->name, $search);
             }
             else {
                 $index = $this->imap->index($this->folder->name, null, null, true, true);
             }
 
             $this->imap_mode(false);
 
             if ($index->is_error()) {
                 $this->check_error();
                 if ($uids) {
                     return null;
                 }
                 $result->set_error(true);
                 return $result;
             }
 
             $index  = $index->get();
             $result = $uids ? $index : $this->_fetch($index, $filter['type']);
 
             // TODO: post-filter result according to query
         }
 
         // We don't want to cache big results in-memory, however
         // if we select only one object here, there's a big chance we will need it later
         if (!$uids && count($result) == 1) {
             if ($msguid = $result[0]['_msguid']) {
                 $this->uid2msg[$result[0]['uid']] = $msguid;
                 $this->objects = array($msguid => $result[0]);
             }
         }
 
         $this->check_error();
 
         return $result;
     }
 
-
     /**
      * Get number of objects mathing the given query
      *
      * @param array  $query Pseudo-SQL query as list of filter parameter triplets
      * @return integer The number of objects of the given type
      */
     public function count($query = array())
     {
         // read from local cache DB (assume it to be synchronized)
         if ($this->ready) {
             $this->_read_folder_data();
 
             $sql_result = $this->db->query(
                 "SELECT COUNT(*) AS `numrows` FROM `{$this->cache_table}` ".
                 "WHERE `folder_id` = ?" . $this->_sql_where($query),
                 $this->folder_id
             );
 
             if ($this->db->is_error($sql_result)) {
                 return null;
             }
 
             $sql_arr = $this->db->fetch_assoc($sql_result);
             $count   = intval($sql_arr['numrows']);
         }
         // use IMAP
         else {
             $filter = $this->_query2assoc($query);
 
             $this->imap_mode(true);
 
             if ($filter['type']) {
                 $search = 'UNDELETED HEADER X-Kolab-Type ' . kolab_format::KTYPE_PREFIX . $filter['type'];
                 $index  = $this->imap->search_once($this->folder->name, $search);
             }
             else {
                 $index = $this->imap->index($this->folder->name, null, null, true, true);
             }
 
             $this->imap_mode(false);
 
             if ($index->is_error()) {
                 $this->check_error();
                 return null;
             }
 
             // TODO: post-filter result according to query
 
             $count = $index->count();
         }
 
         $this->check_error();
         return $count;
     }
 
     /**
      * Define ORDER BY clause for cache queries
      */
     public function set_order_by($sortcols)
     {
         if (!empty($sortcols)) {
             $sortcols = array_map(function($v) {
                 list($column, $order) = explode(' ', $v, 2);
                 return "`$column`" . ($order ? " $order" : '');
             }, (array) $sortcols);
 
             $this->order_by = join(', ', $sortcols);
         }
         else {
             $this->order_by = null;
         }
     }
 
     /**
      * Define LIMIT clause for cache queries
      */
     public function set_limit($length, $offset = 0)
     {
         $this->limit = array($length, $offset);
     }
 
     /**
      * Helper method to compose a valid SQL query from pseudo filter triplets
      */
     protected function _sql_where($query)
     {
         $sql_where = '';
         foreach ((array) $query as $param) {
             if (is_array($param[0])) {
                 $subq = array();
                 foreach ($param[0] as $q) {
                     $subq[] = preg_replace('/^\s*AND\s+/i', '', $this->_sql_where(array($q)));
                 }
                 if (!empty($subq)) {
                     $sql_where .= ' AND (' . implode($param[1] == 'OR' ? ' OR ' : ' AND ', $subq) . ')';
                 }
                 continue;
             }
             else if ($param[1] == '=' && is_array($param[2])) {
                 $qvalue = '(' . join(',', array_map(array($this->db, 'quote'), $param[2])) . ')';
                 $param[1] = 'IN';
             }
             else if ($param[1] == '~' || $param[1] == 'LIKE' || $param[1] == '!~' || $param[1] == '!LIKE') {
                 $not = ($param[1] == '!~' || $param[1] == '!LIKE') ? 'NOT ' : '';
                 $param[1] = $not . 'LIKE';
                 $qvalue = $this->db->quote('%'.preg_replace('/(^\^|\$$)/', ' ', $param[2]).'%');
             }
             else if ($param[1] == '~*' || $param[1] == '!~*') {
                 $not = $param[1][1] == '!' ? 'NOT ' : '';
                 $param[1] = $not . 'LIKE';
                 $qvalue = $this->db->quote(preg_replace('/(^\^|\$$)/', ' ', $param[2]).'%');
             }
             else if ($param[0] == 'tags') {
                 $param[1] = ($param[1] == '!=' ? 'NOT ' : '' ) . 'LIKE';
                 $qvalue = $this->db->quote('% '.$param[2].' %');
             }
             else {
                 $qvalue = $this->db->quote($param[2]);
             }
 
             $sql_where .= sprintf(' AND %s %s %s',
                 $this->db->quote_identifier($param[0]),
                 $param[1],
                 $qvalue
             );
         }
 
         return $sql_where;
     }
 
     /**
      * Helper method to convert the given pseudo-query triplets into
      * an associative filter array with 'equals' values only
      */
     protected function _query2assoc($query)
     {
         // extract object type from query parameter
         $filter = array();
         foreach ($query as $param) {
             if ($param[1] == '=')
                 $filter[$param[0]] = $param[2];
         }
         return $filter;
     }
 
     /**
      * Fetch messages from IMAP
      *
      * @param array  List of message UIDs to fetch
      * @param string Requested object type or * for all
      * @param string IMAP folder to read from
      * @return array List of parsed Kolab objects
      */
     protected function _fetch($index, $type = null, $folder = null)
     {
         $results = new kolab_storage_dataset($this);
         foreach ((array)$index as $msguid) {
             if ($object = $this->folder->read_object($msguid, $type, $folder)) {
                 $results[] = $object;
                 $this->set($msguid, $object);
             }
         }
 
         return $results;
     }
 
     /**
      * Helper method to convert the given Kolab object into a dataset to be written to cache
      */
     protected function _serialize($object)
     {
-        $sql_data = array('changed' => null, 'xml' => '', 'tags' => '', 'words' => '');
+        $data     = array();
+        $sql_data = array('changed' => null, 'tags' => '', 'words' => '');
 
         if ($object['changed']) {
             $sql_data['changed'] = date(self::DB_DATE_FORMAT, is_object($object['changed']) ? $object['changed']->format('U') : $object['changed']);
         }
 
         if ($object['_formatobj']) {
-            $sql_data['xml']   = preg_replace('!(</?[a-z0-9:-]+>)[\n\r\t\s]+!ms', '$1', (string)$object['_formatobj']->write(3.0));
+            $xml = (string) $object['_formatobj']->write(3.0);
+
+            $data['_size']     = strlen($xml);
             $sql_data['tags']  = ' ' . join(' ', $object['_formatobj']->get_tags()) . ' ';  // pad with spaces for strict/prefix search
             $sql_data['words'] = ' ' . join(' ', $object['_formatobj']->get_words()) . ' ';
         }
 
-        // extract object data
-        $data = array();
-        foreach ($object as $key => $val) {
-            // skip empty properties
-            if ($val === "" || $val === null) {
-                continue;
-            }
-            // mark binary data to be extracted from xml on unserialize()
-            if (isset($this->binary_items[$key])) {
-                $data[$key] = true;
-            }
-            else if ($key[0] != '_') {
-                $data[$key] = $val;
-            }
-            else if ($key == '_attachments') {
-                foreach ($val as $k => $att) {
-                    unset($att['content'], $att['path']);
-                    if ($att['id'])
-                        $data[$key][$k] = $att;
+        // Store only minimal set of object properties
+        foreach ($this->data_props as $prop) {
+            if (isset($object[$prop])) {
+                $data[$prop] = $object[$prop];
+                if ($data[$prop] instanceof DateTime) {
+                    $data[$prop] = array(
+                        'cl' => 'DateTime',
+                        'dt' => $data[$prop]->format('Y-m-d H:i:s'),
+                        'tz' => $data[$prop]->getTimezone()->getName(),
+                    );
                 }
             }
         }
 
-        // use base64 encoding (Bug #1912, #2662)
-        $sql_data['data'] = base64_encode(serialize($data));
+        $sql_data['data'] = json_encode(rcube_charset::clean($data));
 
         return $sql_data;
     }
 
     /**
      * Helper method to turn stored cache data into a valid storage object
      */
     protected function _unserialize($sql_arr)
     {
-        // check if data is a base64-encoded string, for backward compat.
-        if (strpos(substr($sql_arr['data'], 0, 64), ':') === false) {
-            $sql_arr['data'] = base64_decode($sql_arr['data']);
-        }
-
-        $object = unserialize($sql_arr['data']);
-
-        // de-serialization failed
-        if ($object === false) {
-            rcube::raise_error(array(
-                'code' => 900, 'type' => 'php',
-                'message' => "Malformed data for {$this->resource_uri}/{$sql_arr['msguid']} object."
-            ), true);
-
-            return null;
-        }
+        if ($sql_arr['fast-mode'] && !empty($sql_arr['data']) && ($object = json_decode($sql_arr['data'], true))) {
+            $object['uid'] = $sql_arr['uid'];
 
-        // decode binary properties
-        foreach ($this->binary_items as $key => $regexp) {
-            if (!empty($object[$key]) && preg_match($regexp, $sql_arr['xml'], $m)) {
-                $object[$key] = base64_decode($m[1]);
+            foreach ($this->data_props as $prop) {
+                if (isset($object[$prop]) && is_array($object[$prop]) && $object[$prop]['cl'] == 'DateTime') {
+                    $object[$prop] = new DateTime($object[$prop]['dt'], new DateTimeZone($object[$prop]['tz']));
+                }
+                else if (!isset($object[$prop]) && isset($sql_arr[$prop])) {
+                    $object[$prop] = $sql_arr[$prop];
+                }
             }
-        }
 
-        $object_type = $sql_arr['type'] ?: $this->folder->type;
-        $format_type = $this->folder->type == 'configuration' ? 'configuration' : $object_type;
+            if ($sql_arr['created'] && empty($object['created'])) {
+                $object['created'] = new DateTime($sql_arr['created']);
+            }
 
-        // add meta data
-        $object['_type']      = $object_type;
-        $object['_msguid']    = $sql_arr['msguid'];
-        $object['_mailbox']   = $this->folder->name;
-        $object['_size']      = strlen($sql_arr['xml']);
-        $object['_formatobj'] = kolab_format::factory($format_type, 3.0, $sql_arr['xml']);
+            if ($sql_arr['changed'] && empty($object['changed'])) {
+                $object['changed'] = new DateTime($sql_arr['changed']);
+            }
 
-        // Fix old broken objects with missing creation date
-        if (empty($object['created']) && method_exists($object['_formatobj'], 'to_array')) {
-            $new_object        = $object['_formatobj']->to_array();
-            $object['created'] = $new_object['created'];
+            $object['_type']     = $sql_arr['type'] ?: $this->folder->type;
+            $object['_msguid']   = $sql_arr['msguid'];
+            $object['_mailbox']  = $this->folder->name;
+        }
+        // Fetch object xml
+        else {
+            // FIXME: Because old cache solution allowed storing objects that
+            // do not match folder type we may end up with invalid objects.
+            // 2nd argument of read_object() here makes sure they are still
+            // usable. However, not allowing them here might be also an intended
+            // solution in future.
+            $object = $this->folder->read_object($sql_arr['msguid'], '*');
         }
 
         return $object;
     }
 
     /**
      * Write records into cache using extended inserts to reduce the number of queries to be executed
      *
      * @param int  Message UID. Set 0 to commit buffered inserts
      * @param array Kolab object to cache
      */
     protected function _extended_insert($msguid, $object)
     {
         static $buffer = '';
 
         $line = '';
+        $cols = array('folder_id', 'msguid', 'uid', 'created', 'changed', 'data', 'tags', 'words');
+        if ($this->extra_cols) {
+            $cols = array_merge($cols, $this->extra_cols);
+        }
+
         if ($object) {
             $sql_data = $this->_serialize($object);
 
-            // Skip multifolder insert for Oracle, we can't put long data inline
-            if ($this->db->db_provider == 'oracle') {
-                $extra_cols = '';
-                if ($this->extra_cols) {
-                    $extra_cols = array_map(function($n) { return "`{$n}`"; }, $this->extra_cols);
-                    $extra_cols = ', ' . join(', ', $extra_cols);
-                    $extra_args = str_repeat(', ?', count($this->extra_cols));
-                }
-
+            // Skip multi-folder insert for all databases but MySQL
+            // In Oracle we can't put long data inline, others we don't support yet
+            if (strpos($this->db->db_provider, 'mysql') !== 0) {
+                $extra_args = array();
                 $params = array($this->folder_id, $msguid, $object['uid'], $sql_data['changed'],
-                    $sql_data['data'], $sql_data['xml'], $sql_data['tags'], $sql_data['words']);
+                    $sql_data['data'], $sql_data['tags'], $sql_data['words']);
 
                 foreach ($this->extra_cols as $col) {
                     $params[] = $sql_data[$col];
+                    $extra_args[] = '?';
                 }
 
+                $cols = implode(', ', array_map(function($n) { return "`{$n}`"; }, $cols));
+                $extra_args = count($extra_args) ? ', ' . implode(', ', $extra_args) : '';
+
                 $result = $this->db->query(
-                    "INSERT INTO `{$this->cache_table}` "
-                    . " (`folder_id`, `msguid`, `uid`, `created`, `changed`, `data`, `xml`, `tags`, `words` $extra_cols)"
-                    . " VALUES (?, ?, ?, " . $this->db->now() . ", ?, ?, ?, ?, ? $extra_args)",
+                    "INSERT INTO `{$this->cache_table}` ($cols)"
+                    . " VALUES (?, ?, ?, " . $this->db->now() . ", ?, ?, ?, ?$extra_args)",
                     $params
                 );
 
                 if (!$this->db->affected_rows($result)) {
                     rcube::raise_error(array(
-                        'code' => 900, 'type' => 'php',
-                        'message' => "Failed to write to kolab cache"
+                        'code' => 900, 'message' => "Failed to write to kolab cache"
                     ), true);
                 }
 
                 return;
             }
 
             $values = array(
                 $this->db->quote($this->folder_id),
                 $this->db->quote($msguid),
                 $this->db->quote($object['uid']),
                 $this->db->now(),
                 $this->db->quote($sql_data['changed']),
                 $this->db->quote($sql_data['data']),
-                $this->db->quote($sql_data['xml']),
                 $this->db->quote($sql_data['tags']),
                 $this->db->quote($sql_data['words']),
             );
             foreach ($this->extra_cols as $col) {
                 $values[] = $this->db->quote($sql_data[$col]);
             }
             $line = '(' . join(',', $values) . ')';
         }
 
         if ($buffer && (!$msguid || (strlen($buffer) + strlen($line) > $this->max_sql_packet()))) {
-            $extra_cols = '';
-            if ($this->extra_cols) {
-                $extra_cols = array_map(function($n) { return "`{$n}`"; }, $this->extra_cols);
-                $extra_cols = ', ' . join(', ', $extra_cols);
-            }
+            $columns = implode(', ', array_map(function($n) { return "`{$n}`"; }, $cols));
+            $update  = implode(', ', array_map(function($i) { return "`{$i}` = VALUES(`{$i}`)"; }, array_slice($cols, 2)));
 
             $result = $this->db->query(
-                "INSERT INTO `{$this->cache_table}` ".
-                " (`folder_id`, `msguid`, `uid`, `created`, `changed`, `data`, `xml`, `tags`, `words` $extra_cols)".
-                " VALUES $buffer"
+                "INSERT INTO `{$this->cache_table}` ($columns) VALUES $buffer"
+                . " ON DUPLICATE KEY UPDATE $update"
             );
 
             if (!$this->db->affected_rows($result)) {
                 rcube::raise_error(array(
-                    'code' => 900, 'type' => 'php',
-                    'message' => "Failed to write to kolab cache"
+                    'code' => 900, 'message' => "Failed to write to kolab cache"
                 ), true);
             }
 
             $buffer = '';
         }
 
         $buffer .= ($buffer ? ',' : '') . $line;
     }
 
     /**
      * Returns max_allowed_packet from mysql config
      */
     protected function max_sql_packet()
     {
         if (!$this->max_sql_packet) {
             // mysql limit or max 4 MB
             $value = $this->db->get_variable('max_allowed_packet', 1048500);
             $this->max_sql_packet = min($value, 4*1024*1024) - 2000;
         }
 
         return $this->max_sql_packet;
     }
 
     /**
      * Read this folder's ID and cache metadata
      */
     protected function _read_folder_data()
     {
         // already done
         if (!empty($this->folder_id) || !$this->ready)
             return;
 
         $sql_arr = $this->db->fetch_assoc($this->db->query(
                 "SELECT `folder_id`, `synclock`, `ctag`, `changed`, `objectcount`"
                 . " FROM `{$this->folders_table}` WHERE `resource` = ?",
                 $this->resource_uri
         ));
 
         if ($sql_arr) {
             $this->metadata = $sql_arr;
             $this->folder_id = $sql_arr['folder_id'];
         }
         else {
             $this->db->query("INSERT INTO `{$this->folders_table}` (`resource`, `type`)"
                 . " VALUES (?, ?)", $this->resource_uri, $this->folder->type);
 
             $this->folder_id = $this->db->insert_id('kolab_folders');
             $this->metadata = array();
         }
     }
 
     /**
      * Check lock record for this folder and wait if locked or set lock
      */
     protected function _sync_lock()
     {
         if (!$this->ready)
             return;
 
         $this->_read_folder_data();
 
         // abort if database is not set-up
         if ($this->db->is_error()) {
             $this->check_error();
             $this->ready = false;
             return;
         }
 
         $read_query  = "SELECT `synclock`, `ctag` FROM `{$this->folders_table}` WHERE `folder_id` = ?";
         $write_query = "UPDATE `{$this->folders_table}` SET `synclock` = ? WHERE `folder_id` = ? AND `synclock` = ?";
 
         // wait if locked (expire locks after 10 minutes) ...
         // ... or if setting lock fails (another process meanwhile set it)
         while (
             (intval($this->metadata['synclock']) + $this->max_sync_lock_time > time()) ||
             (($res = $this->db->query($write_query, time(), $this->folder_id, intval($this->metadata['synclock']))) &&
                 !($affected = $this->db->affected_rows($res)))
         ) {
             usleep(500000);
             $this->metadata = $this->db->fetch_assoc($this->db->query($read_query, $this->folder_id));
         }
 
         $this->synclock = $affected > 0;
     }
 
     /**
      * Remove lock for this folder
      */
     public function _sync_unlock()
     {
         if (!$this->ready || !$this->synclock)
             return;
 
         $this->db->query(
             "UPDATE `{$this->folders_table}` SET `synclock` = 0, `ctag` = ?, `changed` = ?, `objectcount` = ? WHERE `folder_id` = ?",
             $this->metadata['ctag'],
             $this->metadata['changed'],
             $this->metadata['objectcount'],
             $this->folder_id
         );
 
         $this->synclock = false;
     }
 
     /**
      * Check IMAP connection error state
      */
     protected function check_error()
     {
         if (($err_code = $this->imap->get_error_code()) < 0) {
             $this->error = kolab_storage::ERROR_IMAP_CONN;
             if (($res_code = $this->imap->get_response_code()) !== 0 && in_array($res_code, array(rcube_storage::NOPERM, rcube_storage::READONLY))) {
                 $this->error = kolab_storage::ERROR_NO_PERMISSION;
             }
         }
         else if ($this->db->is_error()) {
             $this->error = kolab_storage::ERROR_CACHE_DB;
         }
     }
 
     /**
      * Resolve an object UID into an IMAP message UID
      *
      * @param string  Kolab object UID
      * @param boolean Include deleted objects
      * @return int The resolved IMAP message UID
      */
     public function uid2msguid($uid, $deleted = false)
     {
         // query local database if available
         if (!isset($this->uid2msg[$uid]) && $this->ready) {
             $this->_read_folder_data();
 
             $sql_result = $this->db->query(
                 "SELECT `msguid` FROM `{$this->cache_table}` ".
                 "WHERE `folder_id` = ? AND `uid` = ? ORDER BY `msguid` DESC",
                 $this->folder_id,
                 $uid
             );
 
             if ($sql_arr = $this->db->fetch_assoc($sql_result)) {
                 $this->uid2msg[$uid] = $sql_arr['msguid'];
             }
         }
 
         if (!isset($this->uid2msg[$uid])) {
             // use IMAP SEARCH to get the right message
             $index = $this->imap->search_once($this->folder->name, ($deleted ? '' : 'UNDELETED ') .
                 'HEADER SUBJECT ' . rcube_imap_generic::escape($uid));
             $results = $index->get();
             $this->uid2msg[$uid] = end($results);
         }
 
         return $this->uid2msg[$uid];
     }
 
     /**
      * Getter for protected member variables
      */
     public function __get($name)
     {
         if ($name == 'folder_id') {
             $this->_read_folder_data();
         }
 
         return $this->$name;
     }
 
     /**
-     * Set Roundcube storage options and bypass messages cache.
+     * Set Roundcube storage options and bypass messages/indexes cache.
      *
      * We use skip_deleted and threading settings specific to Kolab,
      * we have to change these global settings only temporarily.
      * Roundcube cache duplicates information already stored in kolab_cache,
      * that's why we can disable it for better performance.
      *
      * @param bool $force True to start Kolab mode, False to stop it.
      */
     public function imap_mode($force = false)
     {
         // remember current IMAP settings
         if ($force) {
             $this->imap_options = array(
                 'skip_deleted' => $this->imap->get_option('skip_deleted'),
                 'threading'    => $this->imap->get_threading(),
             );
         }
 
         // re-set IMAP settings
         $this->imap->set_threading($force ? false : $this->imap_options['threading']);
         $this->imap->set_options(array(
                 'skip_deleted' => $force ? true : $this->imap_options['skip_deleted'],
         ));
 
         // if kolab cache is disabled do nothing
         if (!$this->enabled) {
             return;
         }
 
         static $messages_cache, $cache_bypass;
 
         if ($messages_cache === null) {
             $rcmail = rcube::get_instance();
             $messages_cache = (bool) $rcmail->config->get('messages_cache');
             $cache_bypass   = (int) $rcmail->config->get('kolab_messages_cache_bypass');
         }
 
         if ($messages_cache) {
             // handle recurrent (multilevel) bypass() calls
             if ($force) {
                 $this->cache_bypassed += 1;
                 if ($this->cache_bypassed > 1) {
                     return;
                 }
             }
             else {
                 $this->cache_bypassed -= 1;
                 if ($this->cache_bypassed > 0) {
                     return;
                 }
             }
 
             switch ($cache_bypass) {
                 case 2:
-                    // Disable messages cache completely
+                    // Disable messages and index cache completely
                     $this->imap->set_messages_caching(!$force);
                     break;
 
+                case 3:
                 case 1:
-                    // We'll disable messages cache, but keep index cache.
+                    // We'll disable messages cache, but keep index cache (1) or vice-versa (3)
                     // Default mode is both (MODE_INDEX | MODE_MESSAGE)
-                    $mode = rcube_imap_cache::MODE_INDEX;
+                    $mode = $cache_bypass == 3 ? rcube_imap_cache::MODE_MESSAGE : rcube_imap_cache::MODE_INDEX;
 
                     if (!$force) {
-                        $mode |= rcube_imap_cache::MODE_MESSAGE;
+                        $mode |= $cache_bypass == 3 ? rcube_imap_cache::MODE_INDEX : rcube_imap_cache::MODE_MESSAGE;
                     }
 
                     $this->imap->set_messages_caching(true, $mode);
             }
         }
     }
 
     /**
      * Converts DateTime or unix timestamp into sql date format
      * using server timezone.
      */
     protected function _convert_datetime($datetime)
     {
         if (is_object($datetime)) {
             $dt = clone $datetime;
             $dt->setTimeZone($this->server_timezone);
             return $dt->format(self::DB_DATE_FORMAT);
         }
         else if ($datetime) {
             return date(self::DB_DATE_FORMAT, $datetime);
         }
     }
 }
diff --git a/plugins/libkolab/lib/kolab_storage_cache_configuration.php b/plugins/libkolab/lib/kolab_storage_cache_configuration.php
index c3c7ac4f..a5ac396d 100644
--- a/plugins/libkolab/lib/kolab_storage_cache_configuration.php
+++ b/plugins/libkolab/lib/kolab_storage_cache_configuration.php
@@ -1,88 +1,136 @@
 <?php
 
 /**
  * Kolab storage cache class for configuration objects
  *
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2013, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class kolab_storage_cache_configuration extends kolab_storage_cache
 {
     protected $extra_cols = array('type');
 
     /**
      * Helper method to convert the given Kolab object into a dataset to be written to cache
      *
      * @override
      */
     protected function _serialize($object)
     {
+        $this->set_data_props($object['type']);
+
         $sql_data = parent::_serialize($object);
         $sql_data['type'] = $object['type'];
 
         return $sql_data;
     }
 
+    /**
+     * Helper method to convert database record to the given Kolab object
+     *
+     * @override
+     */
+    protected function _unserialize($sql_arr)
+    {
+        $this->set_data_props($sql_arr['type']);
+
+        return parent::_unserialize($sql_arr);
+    }
+
     /**
      * Select Kolab objects filtered by the given query
      *
-     * @param array Pseudo-SQL query as list of filter parameter triplets
+     * @param array   Pseudo-SQL query as list of filter parameter triplets
      * @param boolean Set true to only return UIDs instead of complete objects
+     * @param boolean Use fast mode to fetch only minimal set of information
+     *                (no xml fetching and parsing, etc.)
+     *
      * @return array List of Kolab data objects (each represented as hash array) or UIDs
      */
-    public function select($query = array(), $uids = false)
+    public function select($query = array(), $uids = false, $fast = false)
     {
         // modify query for IMAP search: query param 'type' is actually a subtype
         if (!$this->ready) {
             foreach ($query as $i => $tuple) {
                 if ($tuple[0] == 'type') {
                     $tuple[2] = 'configuration.' . $tuple[2];
                     $query[$i] = $tuple;
                 }
             }
         }
 
-        return parent::select($query, $uids);
+        return parent::select($query, $uids, $fast);
     }
 
     /**
      * Helper method to compose a valid SQL query from pseudo filter triplets
      */
     protected function _sql_where($query)
     {
         if (is_array($query)) {
             foreach ($query as $idx => $param) {
                 // convert category filter
                 if ($param[0] == 'category') {
                     $param[2] = array_map(function($n) { return 'category:' . $n; }, (array) $param[2]);
 
                     $query[$idx][0] = 'tags';
                     $query[$idx][2] = count($param[2]) > 1 ? $param[2] : $param[2][0];
                 }
                 // convert member filter (we support only = operator with single value)
                 else if ($param[0] == 'member') {
                     $query[$idx][0] = 'words';
                     $query[$idx][1] = '~';
                     $query[$idx][2] = '^' . $param[2] . '$';
                 }
             }
         }
 
         return parent::_sql_where($query);
     }
+
+    /**
+     * Set $data_props property depending on object type
+     */
+    protected function set_data_props($type)
+    {
+        switch ($type) {
+        case 'dictionary':
+            $this->data_props = array('language', 'e');
+            break;
+
+        case 'file_driver':
+            $this->data_props = array('driver', 'title', 'enabled', 'host', 'port', 'username', 'password');
+            break;
+
+        case 'relation':
+            // Note: Because relations are heavily used, for performance reasons
+            // we store all properties for them
+            $this->data_props = array('name', 'category', 'color', 'parent', 'iconName', 'priority', 'members');
+            break;
+
+        case 'snippet':
+            $this->data_props = array('name');
+            break;
+
+        case 'category':
+        default:
+            // TODO: implement this
+            $this->data_props = array();
+        }
+    }
 }
diff --git a/plugins/libkolab/lib/kolab_storage_cache_contact.php b/plugins/libkolab/lib/kolab_storage_cache_contact.php
index 70aa5f62..22d0a330 100644
--- a/plugins/libkolab/lib/kolab_storage_cache_contact.php
+++ b/plugins/libkolab/lib/kolab_storage_cache_contact.php
@@ -1,72 +1,68 @@
 <?php
 
 /**
  * Kolab storage cache class for contact objects
  *
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2013, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class kolab_storage_cache_contact extends kolab_storage_cache
 {
     protected $extra_cols_max = 255;
-    protected $extra_cols     = array('type','name','firstname','surname','email');
-    protected $binary_items   = array(
-        'photo'          => '|<photo><uri>[^;]+;base64,([^<]+)</uri></photo>|i',
-        'pgppublickey'   => '|<key><uri>data:application/pgp-keys;base64,([^<]+)</uri></key>|i',
-        'pkcs7publickey' => '|<key><uri>data:application/pkcs7-mime;base64,([^<]+)</uri></key>|i',
-    );
+    protected $extra_cols     = array('type', 'name', 'firstname', 'surname', 'email');
+    protected $data_props     = array('type', 'name', 'firstname', 'middlename', 'prefix', 'suffix', 'surname', 'email', 'organization', 'member');
 
     /**
      * Helper method to convert the given Kolab object into a dataset to be written to cache
      *
      * @override
      */
     protected function _serialize($object)
     {
         $sql_data = parent::_serialize($object);
         $sql_data['type'] = $object['_type'];
 
         // columns for sorting
         $sql_data['name']      = rcube_charset::clean($object['name'] . $object['prefix']);
         $sql_data['firstname'] = rcube_charset::clean($object['firstname'] . $object['middlename'] . $object['surname']);
         $sql_data['surname']   = rcube_charset::clean($object['surname']   . $object['firstname']  . $object['middlename']);
         $sql_data['email']     = rcube_charset::clean(is_array($object['email']) ? $object['email'][0] : $object['email']);
 
         if (is_array($sql_data['email'])) {
             $sql_data['email'] = $sql_data['email']['address'];
         }
         // avoid value being null
         if (empty($sql_data['email'])) {
             $sql_data['email'] = '';
         }
 
         // use organization if name is empty
         if (empty($sql_data['name']) && !empty($object['organization'])) {
             $sql_data['name'] = rcube_charset::clean($object['organization']);
         }
 
         // make sure some data is not longer that database limit (#5291)
         foreach ($this->extra_cols as $col) {
             if (strlen($sql_data[$col]) > $this->extra_cols_max) {
                 $sql_data[$col] = rcube_charset::clean(substr($sql_data[$col], 0,  $this->extra_cols_max));
             }
         }
 
         return $sql_data;
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/libkolab/lib/kolab_storage_cache_event.php b/plugins/libkolab/lib/kolab_storage_cache_event.php
index b6d8b15f..13b350b3 100644
--- a/plugins/libkolab/lib/kolab_storage_cache_event.php
+++ b/plugins/libkolab/lib/kolab_storage_cache_event.php
@@ -1,67 +1,68 @@
 <?php
 
 /**
  * Kolab storage cache class for calendar event objects
  *
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2013, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class kolab_storage_cache_event extends kolab_storage_cache
 {
     protected $extra_cols = array('dtstart','dtend');
+    protected $data_props = array('categories', 'status', 'attendees'); // start, end
 
     /**
      * Helper method to convert the given Kolab object into a dataset to be written to cache
      *
      * @override
      */
     protected function _serialize($object)
     {
         $sql_data = parent::_serialize($object);
 
         $sql_data['dtstart'] = $this->_convert_datetime($object['start']);
         $sql_data['dtend']   = $this->_convert_datetime($object['end']);
 
         // extend date range for recurring events
         if ($object['recurrence'] && $object['_formatobj']) {
             $recurrence = new kolab_date_recurrence($object['_formatobj']);
             $dtend = $recurrence->end() ?: new DateTime('now +100 years');
             $sql_data['dtend'] = $this->_convert_datetime($dtend);
         }
 
         // extend start/end dates to spawn all exceptions
         if (is_array($object['exceptions'])) {
             foreach ($object['exceptions'] as $exception) {
                 if (is_a($exception['start'], 'DateTime')) {
                     $exstart = $this->_convert_datetime($exception['start']);
                     if ($exstart < $sql_data['dtstart']) {
                         $sql_data['dtstart'] = $exstart;
                     }
                 }
                 if (is_a($exception['end'], 'DateTime')) {
                     $exend = $this->_convert_datetime($exception['end']);
                     if ($exend > $sql_data['dtend']) {
                         $sql_data['dtend'] = $exend;
                     }
                 }
             }
         }
 
         return $sql_data;
     }
 }
diff --git a/plugins/libkolab/lib/kolab_storage_cache_file.php b/plugins/libkolab/lib/kolab_storage_cache_file.php
index ea1823d6..1f3d4d92 100644
--- a/plugins/libkolab/lib/kolab_storage_cache_file.php
+++ b/plugins/libkolab/lib/kolab_storage_cache_file.php
@@ -1,44 +1,77 @@
 <?php
 
 /**
  * Kolab storage cache class for file objects
  *
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2013, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class kolab_storage_cache_file extends kolab_storage_cache
 {
     protected $extra_cols = array('filename');
+    protected $data_props = array('type', 'size', 'filename', 'fileid');
 
     /**
      * Helper method to convert the given Kolab object into a dataset to be written to cache
      *
      * @override
      */
     protected function _serialize($object)
     {
-        $sql_data = parent::_serialize($object);
-
         if (!empty($object['_attachments'])) {
             reset($object['_attachments']);
-            $sql_data['filename'] = $object['_attachments'][key($object['_attachments'])]['name'];
+
+            $file = $object['_attachments'][key($object['_attachments'])];
+
+            $object['type']   = $file['mimetype'];
+            $object['size']   = $file['size'];
+            $object['fileid'] = $file['id'];
+        }
+
+        $sql_data = parent::_serialize($object);
+
+        if (!empty($file)) {
+            $sql_data['filename'] = $file['name'];
         }
 
         return $sql_data;
     }
-}
\ No newline at end of file
+
+    /**
+     * Helper method to turn stored cache data into a valid storage object
+     *
+     * @override
+     */
+    protected function _unserialize($sql_arr)
+    {
+        $object = parent::_unserialize($sql_arr);
+
+        if ($object && $sql_arr['fast-mode']) {
+            if (!empty($object['_attachments'])) {
+                $file = $object['_attachments'][key($object['_attachments'])];
+
+                $object['type']     = $file['mimetype'];
+                $object['size']     = $file['size'];
+                $object['fileid']   = $file['id'];
+                $object['filename'] = $file['name'];
+            }
+        }
+
+        return $object;
+    }
+}
diff --git a/plugins/libkolab/lib/kolab_storage_cache_journal.php b/plugins/libkolab/lib/kolab_storage_cache_journal.php
index 766f1da1..042d4bde 100644
--- a/plugins/libkolab/lib/kolab_storage_cache_journal.php
+++ b/plugins/libkolab/lib/kolab_storage_cache_journal.php
@@ -1,42 +1,43 @@
 <?php
 
 /**
  * Kolab storage cache class for journal objects
  *
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2013, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class kolab_storage_cache_journal extends kolab_storage_cache
 {
     protected $extra_cols = array('dtstart','dtend');
+    protected $data_props = array('categories');
 
     /**
      * Helper method to convert the given Kolab object into a dataset to be written to cache
      *
      * @override
      */
     protected function _serialize($object)
     {
         $sql_data = parent::_serialize($object) + array('dtstart' => null, 'dtend' => null);
 
         $sql_data['dtstart'] = $this->_convert_datetime($object['start']);
         $sql_data['dtend']   = $this->_convert_datetime($object['end']);
 
         return $sql_data;
     }
 }
diff --git a/plugins/libkolab/lib/kolab_storage_cache_mongodb.php b/plugins/libkolab/lib/kolab_storage_cache_mongodb.php
deleted file mode 100644
index 8ae95e4b..00000000
--- a/plugins/libkolab/lib/kolab_storage_cache_mongodb.php
+++ /dev/null
@@ -1,561 +0,0 @@
-<?php
-
-/**
- * Kolab storage cache class providing a local caching layer for Kolab groupware objects.
- *
- * @version @package_version@
- * @author Thomas Bruederli <bruederli@kolabsys.com>
- *
- * Copyright (C) 2012, Kolab Systems AG <contact@kolabsys.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-class kolab_storage_cache_mongodb
-{
-    private $db;
-    private $imap;
-    private $folder;
-    private $uid2msg;
-    private $objects;
-    private $index = array();
-    private $resource_uri;
-    private $enabled = true;
-    private $synched = false;
-    private $synclock = false;
-    private $ready = false;
-    private $max_sql_packet = 1046576;  // 1 MB - 2000 bytes
-    private $binary_cols = array('photo','pgppublickey','pkcs7publickey');
-
-
-    /**
-     * Default constructor
-     */
-    public function __construct(kolab_storage_folder $storage_folder = null)
-    {
-        $rcmail = rcube::get_instance();
-        $mongo = new Mongo();
-        $this->db = $mongo->kolab_cache;
-        $this->imap = $rcmail->get_storage();
-        $this->enabled = $rcmail->config->get('kolab_cache', false);
-
-        if ($this->enabled) {
-            // remove sync-lock on script termination
-            $rcmail->add_shutdown_function(array($this, '_sync_unlock'));
-        }
-
-        if ($storage_folder)
-            $this->set_folder($storage_folder);
-    }
-
-
-    /**
-     * Connect cache with a storage folder
-     *
-     * @param kolab_storage_folder The storage folder instance to connect with
-     */
-    public function set_folder(kolab_storage_folder $storage_folder)
-    {
-        $this->folder = $storage_folder;
-
-        if (empty($this->folder->name)) {
-            $this->ready = false;
-            return;
-        }
-
-        // compose fully qualified ressource uri for this instance
-        $this->resource_uri = $this->folder->get_resource_uri();
-        $this->ready = $this->enabled;
-    }
-
-
-    /**
-     * Synchronize local cache data with remote
-     */
-    public function synchronize()
-    {
-        // only sync once per request cycle
-        if ($this->synched)
-            return;
-
-        // increase time limit
-        @set_time_limit(500);
-
-        // lock synchronization for this folder or wait if locked
-        $this->_sync_lock();
-
-        // synchronize IMAP mailbox cache
-        $this->imap->folder_sync($this->folder->name);
-
-        // compare IMAP index with object cache index
-        $imap_index = $this->imap->index($this->folder->name);
-        $this->index = $imap_index->get();
-
-        // determine objects to fetch or to invalidate
-        if ($this->ready) {
-            // read cache index
-            $old_index = array();
-            $cursor = $this->db->cache->find(array('resource' => $this->resource_uri), array('msguid' => 1, 'uid' => 1));
-            foreach ($cursor as $doc) {
-                $old_index[] = $doc['msguid'];
-                $this->uid2msg[$doc['uid']] = $doc['msguid'];
-            }
-
-            // fetch new objects from imap
-            foreach (array_diff($this->index, $old_index) as $msguid) {
-                if ($object = $this->folder->read_object($msguid, '*')) {
-                    try {
-                        $this->db->cache->insert($this->_serialize($object, $msguid));
-                    }
-                    catch (Exception $e) {
-                        rcmail::raise_error(array(
-                            'code' => 900, 'type' => 'php',
-                            'message' => "Failed to write to mongodb cache: " . $e->getMessage(),
-                        ), true);
-                    }
-                }
-            }
-
-            // delete invalid entries from local DB
-            $del_index = array_diff($old_index, $this->index);
-            if (!empty($del_index)) {
-                $this->db->cache->remove(array('resource' => $this->resource_uri, 'msguid' => array('$in' => $del_index)));
-            }
-        }
-
-        // remove lock
-        $this->_sync_unlock();
-
-        $this->synched = time();
-    }
-
-
-    /**
-     * Read a single entry from cache or from IMAP directly
-     *
-     * @param string Related IMAP message UID
-     * @param string Object type to read
-     * @param string IMAP folder name the entry relates to
-     * @param array  Hash array with object properties or null if not found
-     */
-    public function get($msguid, $type = null, $foldername = null)
-    {
-        // delegate to another cache instance
-        if ($foldername && $foldername != $this->folder->name) {
-            return kolab_storage::get_folder($foldername)->cache->get($msguid, $object);
-        }
-
-        // load object if not in memory
-        if (!isset($this->objects[$msguid])) {
-            if ($this->ready && ($doc = $this->db->cache->findOne(array('resource' => $this->resource_uri, 'msguid' => $msguid))))
-                $this->objects[$msguid] = $this->_unserialize($doc);
-
-            // fetch from IMAP if not present in cache
-            if (empty($this->objects[$msguid])) {
-                $result = $this->_fetch(array($msguid), $type, $foldername);
-                $this->objects[$msguid] = $result[0];
-            }
-        }
-
-        return $this->objects[$msguid];
-    }
-
-
-    /**
-     * Insert/Update a cache entry
-     *
-     * @param string Related IMAP message UID
-     * @param mixed  Hash array with object properties to save or false to delete the cache entry
-     * @param string IMAP folder name the entry relates to
-     */
-    public function set($msguid, $object, $foldername = null)
-    {
-        // delegate to another cache instance
-        if ($foldername && $foldername != $this->folder->name) {
-            kolab_storage::get_folder($foldername)->cache->set($msguid, $object);
-            return;
-        }
-
-        // write to cache
-        if ($this->ready) {
-            // remove old entry
-            $this->db->cache->remove(array('resource' => $this->resource_uri, 'msguid' => $msguid));
-
-            // write new object data if not false (wich means deleted)
-            if ($object) {
-                try {
-                    $this->db->cache->insert($this->_serialize($object, $msguid));
-                }
-                catch (Exception $e) {
-                    rcmail::raise_error(array(
-                        'code' => 900, 'type' => 'php',
-                        'message' => "Failed to write to mongodb cache: " . $e->getMessage(),
-                    ), true);
-                }
-            }
-        }
-
-        // keep a copy in memory for fast access
-        $this->objects[$msguid] = $object;
-
-        if ($object)
-            $this->uid2msg[$object['uid']] = $msguid;
-    }
-
-    /**
-     * Move an existing cache entry to a new resource
-     *
-     * @param string Entry's IMAP message UID
-     * @param string Entry's Object UID
-     * @param string Target IMAP folder to move it to
-     */
-    public function move($msguid, $objuid, $target_folder)
-    {
-        $target = kolab_storage::get_folder($target_folder);
-
-        // resolve new message UID in target folder
-        if ($new_msguid = $target->cache->uid2msguid($objuid)) {
-/*
-            $this->db->query(
-                "UPDATE kolab_cache SET resource=?, msguid=? ".
-                "WHERE resource=? AND msguid=? AND type<>?",
-                $target->get_resource_uri(),
-                $new_msguid,
-                $this->resource_uri,
-                $msguid,
-                'lock'
-            );
-*/
-        }
-        else {
-            // just clear cache entry
-            $this->set($msguid, false);
-        }
-
-        unset($this->uid2msg[$uid]);
-    }
-
-
-    /**
-     * Remove all objects from local cache
-     */
-    public function purge($type = null)
-    {
-        return $this->db->cache->remove(array(), array('safe' => true));
-    }
-
-
-    /**
-     * Select Kolab objects filtered by the given query
-     *
-     * @param array Pseudo-SQL query as list of filter parameter triplets
-     *   triplet: array('<colname>', '<comparator>', '<value>')
-     * @return array List of Kolab data objects (each represented as hash array)
-     */
-    public function select($query = array())
-    {
-        $result = array();
-
-        // read from local cache DB (assume it to be synchronized)
-        if ($this->ready) {
-            $cursor = $this->db->cache->find(array('resource' => $this->resource_uri) + $this->_mongo_filter($query));
-            foreach ($cursor as $doc) {
-                if ($object = $this->_unserialize($doc))
-                    $result[] = $object;
-            }
-        }
-        else {
-            // extract object type from query parameter
-            $filter = $this->_query2assoc($query);
-
-            // use 'list' for folder's default objects
-            if ($filter['type'] == $this->type) {
-                $index = $this->index;
-            }
-            else {  // search by object type
-                $search = 'UNDELETED HEADER X-Kolab-Type ' . kolab_storage_folder::KTYPE_PREFIX . $filter['type'];
-                $index = $this->imap->search_once($this->folder->name, $search)->get();
-            }
-
-            // fetch all messages in $index from IMAP
-            $result = $this->_fetch($index, $filter['type']);
-
-            // TODO: post-filter result according to query
-        }
-
-        return $result;
-    }
-
-
-    /**
-     * Get number of objects mathing the given query
-     *
-     * @param array  $query Pseudo-SQL query as list of filter parameter triplets
-     * @return integer The number of objects of the given type
-     */
-    public function count($query = array())
-    {
-        $count = 0;
-
-        // cache is in sync, we can count records in local DB
-        if ($this->synched) {
-            $cursor = $this->db->cache->find(array('resource' => $this->resource_uri) + $this->_mongo_filter($query));
-            $count = $cursor->valid() ? $cursor->count() : 0;
-        }
-        else {
-            // search IMAP by object type
-            $filter = $this->_query2assoc($query);
-            $ctype  = kolab_storage_folder::KTYPE_PREFIX . $filter['type'];
-            $index = $this->imap->search_once($this->folder->name, 'UNDELETED HEADER X-Kolab-Type ' . $ctype);
-            $count = $index->count();
-        }
-
-        return $count;
-    }
-
-    /**
-     * Helper method to convert the pseudo-SQL query into a valid mongodb filter
-     */
-    private function _mongo_filter($query)
-    {
-        $filters = array();
-        foreach ($query as $param) {
-            $filter = array();
-            if ($param[1] == '=' && is_array($param[2])) {
-                $filter[$param[0]] = array('$in' => $param[2]);
-                $filters[] = $filter;
-            }
-            else if ($param[1] == '=') {
-                $filters[] = array($param[0] => $param[2]);
-            }
-            else if ($param[1] == 'LIKE' || $param[1] == '~') {
-                $filter[$param[0]] = array('$regex' => preg_quote($param[2]), '$options' => 'i');
-                $filters[] = $filter;
-            }
-            else if ($param[1] == '!~' || $param[1] == '!LIKE') {
-                $filter[$param[0]] = array('$not' => '/' . preg_quote($param[2]) . '/i');
-                $filters[] = $filter;
-            }
-            else {
-                $op = '';
-                switch ($param[1]) {
-                    case '>':  $op = '$gt';  break;
-                    case '>=': $op = '$gte'; break;
-                    case '<':  $op = '$lt';  break;
-                    case '<=': $op = '$lte'; break;
-                    case '!=':
-                    case '<>': $op = '$gte'; break;
-                }
-                if ($op) {
-                    $filter[$param[0]] = array($op => $param[2]);
-                    $filters[] = $filter;
-                }
-            }
-        }
-
-        return array('$and' => $filters);
-    }
-
-    /**
-     * Helper method to convert the given pseudo-query triplets into
-     * an associative filter array with 'equals' values only
-     */
-    private function _query2assoc($query)
-    {
-        // extract object type from query parameter
-        $filter = array();
-        foreach ($query as $param) {
-            if ($param[1] == '=')
-                $filter[$param[0]] = $param[2];
-        }
-        return $filter;
-    }
-
-    /**
-     * Fetch messages from IMAP
-     *
-     * @param array List of message UIDs to fetch
-     * @return array List of parsed Kolab objects
-     */
-    private function _fetch($index, $type = null, $folder = null)
-    {
-        $results = array();
-        foreach ((array)$index as $msguid) {
-            if ($object = $this->folder->read_object($msguid, $type, $folder)) {
-                $results[] = $object;
-                $this->set($msguid, $object);
-            }
-        }
-
-        return $results;
-    }
-
-
-    /**
-     * Helper method to convert the given Kolab object into a dataset to be written to cache
-     */
-    private function _serialize($object, $msguid)
-    {
-        $bincols = array_flip($this->binary_cols);
-        $doc = array(
-            'resource' => $this->resource_uri,
-            'type'     => $object['_type'] ? $object['_type'] : $this->folder->type,
-            'msguid'   => $msguid,
-            'uid'      => $object['uid'],
-            'xml'      => '',
-            'tags'     => array(),
-            'words'    => array(),
-            'objcols'  => array(),
-        );
-
-        // set type specific values
-        if ($this->folder->type == 'event') {
-            // database runs in server's timezone so using date() is what we want
-            $doc['dtstart'] = date('Y-m-d H:i:s', is_object($object['start']) ? $object['start']->format('U') : $object['start']);
-            $doc['dtend']   = date('Y-m-d H:i:s', is_object($object['end'])   ? $object['end']->format('U')   : $object['end']);
-
-            // extend date range for recurring events
-            if ($object['recurrence']) {
-                $doc['dtend'] = date('Y-m-d H:i:s', $object['recurrence']['UNTIL'] ?: strtotime('now + 2 years'));
-            }
-        }
-
-        if ($object['_formatobj']) {
-            $doc['xml'] = preg_replace('!(</?[a-z0-9:-]+>)[\n\r\t\s]+!ms', '$1', (string)$object['_formatobj']->write());
-            $doc['tags'] = $object['_formatobj']->get_tags();
-            $doc['words'] = $object['_formatobj']->get_words();
-        }
-
-        // extract object data
-        $data = array();
-        foreach ($object as $key => $val) {
-            if ($val === "" || $val === null) {
-                // skip empty properties
-                continue;
-            }
-            if (isset($bincols[$key])) {
-                $data[$key] = base64_encode($val);
-            }
-            else if (is_object($val)) {
-                if (is_a($val, 'DateTime')) {
-                    $data[$key] = array('_class' => 'DateTime', 'date' => $val->format('Y-m-d H:i:s'), 'timezone' => $val->getTimezone()->getName());
-                    $doc['objcols'][] = $key;
-                }
-            }
-            else if ($key[0] != '_') {
-                $data[$key] = $val;
-            }
-            else if ($key == '_attachments') {
-                foreach ($val as $k => $att) {
-                    unset($att['content'], $att['path']);
-                    if ($att['id'])
-                        $data[$key][$k] = $att;
-                }
-            }
-        }
-
-        $doc['data'] = $data;
-        return $doc;
-    }
-
-    /**
-     * Helper method to turn stored cache data into a valid storage object
-     */
-    private function _unserialize($doc)
-    {
-        $object = $doc['data'];
-
-        // decode binary properties
-        foreach ($this->binary_cols as $key) {
-            if (!empty($object[$key]))
-                $object[$key] = base64_decode($object[$key]);
-        }
-
-        // restore serialized objects
-        foreach ((array)$doc['objcols'] as $key) {
-            switch ($object[$key]['_class']) {
-                case 'DateTime':
-                    $val = new DateTime($object[$key]['date'], new DateTimeZone($object[$key]['timezone']));
-                    $object[$key] = $val;
-                    break;
-            }
-        }
-
-        // add meta data
-        $object['_type'] = $doc['type'];
-        $object['_msguid'] = $doc['msguid'];
-        $object['_mailbox'] = $this->folder->name;
-        $object['_formatobj'] = kolab_format::factory($doc['type'], $doc['xml']);
-
-        return $object;
-    }
-
-    /**
-     * Check lock record for this folder and wait if locked or set lock
-     */
-    private function _sync_lock()
-    {
-        if (!$this->ready)
-            return;
-
-        $this->synclock = true;
-        $lock = $this->db->locks->findOne(array('resource' => $this->resource_uri));
-
-        // create lock record if not exists
-        if (!$lock) {
-            $this->db->locks->insert(array('resource' => $this->resource_uri, 'created' => time()));
-        }
-        // wait if locked (expire locks after 10 minutes)
-        else if ((time() - $lock['created']) < 600) {
-            usleep(500000);
-            return $this->_sync_lock();
-        }
-        // set lock
-        else {
-            $lock['created'] = time();
-            $this->db->locks->update(array('_id' => $lock['_id']), $lock, array('safe' => true));
-        }
-    }
-
-    /**
-     * Remove lock for this folder
-     */
-    public function _sync_unlock()
-    {
-        if (!$this->ready || !$this->synclock)
-            return;
-
-        $this->db->locks->remove(array('resource' => $this->resource_uri));
-    }
-
-    /**
-     * Resolve an object UID into an IMAP message UID
-     *
-     * @param string  Kolab object UID
-     * @param boolean Include deleted objects
-     * @return int The resolved IMAP message UID
-     */
-    public function uid2msguid($uid, $deleted = false)
-    {
-        if (!isset($this->uid2msg[$uid])) {
-            // use IMAP SEARCH to get the right message
-            $index = $this->imap->search_once($this->folder->name, ($deleted ? '' : 'UNDELETED ') . 'HEADER SUBJECT ' . $uid);
-            $results = $index->get();
-            $this->uid2msg[$uid] = $results[0];
-        }
-
-        return $this->uid2msg[$uid];
-    }
-
-}
diff --git a/plugins/libkolab/lib/kolab_storage_cache_note.php b/plugins/libkolab/lib/kolab_storage_cache_note.php
index 85469275..3211da57 100644
--- a/plugins/libkolab/lib/kolab_storage_cache_note.php
+++ b/plugins/libkolab/lib/kolab_storage_cache_note.php
@@ -1,27 +1,27 @@
 <?php
 
 /**
  * Kolab storage cache class for note objects
  *
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2013, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class kolab_storage_cache_note extends kolab_storage_cache
 {
-    
-}
\ No newline at end of file
+    protected $data_props = array('title');
+}
diff --git a/plugins/libkolab/lib/kolab_storage_cache_task.php b/plugins/libkolab/lib/kolab_storage_cache_task.php
index 8b714e63..9c776d75 100644
--- a/plugins/libkolab/lib/kolab_storage_cache_task.php
+++ b/plugins/libkolab/lib/kolab_storage_cache_task.php
@@ -1,42 +1,43 @@
 <?php
 
 /**
  * Kolab storage cache class for task objects
  *
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2013, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class kolab_storage_cache_task extends kolab_storage_cache
 {
-    protected $extra_cols = array('dtstart','dtend');
+    protected $extra_cols = array('dtstart', 'dtend');
+    protected $data_props = array('categories', 'status', 'complete', 'start', 'due');
 
     /**
      * Helper method to convert the given Kolab object into a dataset to be written to cache
      *
      * @override
      */
     protected function _serialize($object)
     {
         $sql_data = parent::_serialize($object);
 
         $sql_data['dtstart'] = $this->_convert_datetime($object['start']);
         $sql_data['dtend']   = $this->_convert_datetime($object['due']);
 
         return $sql_data;
     }
 }
diff --git a/plugins/libkolab/lib/kolab_storage_config.php b/plugins/libkolab/lib/kolab_storage_config.php
index fb442ece..b29e7a90 100644
--- a/plugins/libkolab/lib/kolab_storage_config.php
+++ b/plugins/libkolab/lib/kolab_storage_config.php
@@ -1,1009 +1,1009 @@
 <?php
 
 /**
  * Kolab storage class providing access to configuration objects on a Kolab server.
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  * @author Aleksander Machniak <machniak@kolabsys.com>
  *
  * Copyright (C) 2012-2014, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class kolab_storage_config
 {
     const FOLDER_TYPE   = 'configuration';
     const MAX_RELATIONS = 499; // should be less than kolab_storage_cache::MAX_RECORDS
 
     /**
      * Singleton instace of kolab_storage_config
      *
      * @var kolab_storage_config
      */
     static protected $instance;
 
     private $folders;
     private $default;
     private $enabled;
     private $tags;
 
 
     /**
      * This implements the 'singleton' design pattern
      *
      * @return kolab_storage_config The one and only instance
      */
     static function get_instance()
     {
         if (!self::$instance) {
             self::$instance = new kolab_storage_config();
         }
 
         return self::$instance;
     }
 
     /**
      * Private constructor (finds default configuration folder as a config source)
      */
     private function _init()
     {
         if ($this->enabled !== null) {
             return $this->enabled;
         }
 
         // get all configuration folders
         $this->folders = kolab_storage::get_folders(self::FOLDER_TYPE, false);
 
         foreach ($this->folders as $folder) {
             if ($folder->default) {
                 $this->default = $folder;
                 break;
             }
         }
 
         // if no folder is set as default, choose the first one
         if (!$this->default) {
             $this->default = reset($this->folders);
         }
 
         // attempt to create a default folder if it does not exist
         if (!$this->default) {
             $folder_name = 'Configuration';
             $folder_type = self::FOLDER_TYPE . '.default';
 
             if (kolab_storage::folder_create($folder_name, $folder_type, true)) {
                 $this->default = new kolab_storage_folder($folder_name, $folder_type);
             }
         }
 
         // check if configuration folder exist
         return $this->enabled = $this->default && $this->default->name;
     }
 
     /**
      * Check wether any configuration storage (folder) exists
      *
      * @return bool
      */
     public function is_enabled()
     {
         return $this->_init();
     }
 
     /**
      * Get configuration objects
      *
      * @param array $filter  Search filter
      * @param bool  $default Enable to get objects only from default folder
      * @param int   $limit   Max. number of records (per-folder)
      *
      * @return array List of objects
      */
     public function get_objects($filter = array(), $default = false, $limit = 0)
     {
         $list = array();
 
         if (!$this->is_enabled()) {
             return $list;
         }
 
         foreach ($this->folders as $folder) {
             // we only want to read from default folder
             if ($default && !$folder->default) {
                 continue;
             }
 
             // for better performance it's good to assume max. number of records
             if ($limit) {
                 $folder->set_order_and_limit(null, $limit);
             }
 
-            foreach ($folder->select($filter) as $object) {
+            foreach ($folder->select($filter, true) as $object) {
                 unset($object['_formatobj']);
                 $list[] = $object;
             }
         }
 
         return $list;
     }
 
     /**
      * Get configuration object
      *
      * @param string $uid     Object UID
      * @param bool   $default Enable to get objects only from default folder
      *
      * @return array Object data
      */
     public function get_object($uid, $default = false)
     {
         if (!$this->is_enabled()) {
             return;
         }
 
         foreach ($this->folders as $folder) {
             // we only want to read from default folder
             if ($default && !$folder->default) {
                 continue;
             }
 
             if ($object = $folder->get_object($uid)) {
                 return $object;
             }
         }
     }
 
     /**
      * Create/update configuration object
      *
      * @param array  $object Object data
      * @param string $type   Object type
      *
      * @return bool True on success, False on failure
      */
     public function save(&$object, $type)
     {
         if (!$this->is_enabled()) {
             return false;
         }
 
         $folder = $this->find_folder($object);
 
         if ($type) {
             $object['type'] = $type;
         }
 
         $status = $folder->save($object, self::FOLDER_TYPE . '.' . $object['type'], $object['uid']);
 
         // on success, update cached tags list
         if ($status && $object['category'] == 'tag' && is_array($this->tags)) {
             $found = false;
             unset($object['_formatobj']); // we don't need it anymore
 
             foreach ($this->tags as $idx => $tag) {
                 if ($tag['uid'] == $object['uid']) {
                     $found = true;
                     $this->tags[$idx] = $object;
                 }
             }
 
             if (!$found) {
                 $this->tags[] = $object;
             }
         }
 
         return !empty($status);
     }
 
     /**
      * Remove configuration object
      *
      * @param string|array $object Object array or its UID
      *
      * @return bool True on success, False on failure
      */
     public function delete($object)
     {
         if (!$this->is_enabled()) {
             return false;
         }
 
         // fetch the object to find folder
         if (!is_array($object)) {
             $object = $this->get_object($object);
         }
 
         if (!$object) {
             return false;
         }
 
         $folder = $this->find_folder($object);
         $status = $folder->delete($object);
 
         // on success, update cached tags list
         if ($status && is_array($this->tags)) {
             foreach ($this->tags as $idx => $tag) {
                 if ($tag['uid'] == $uid) {
                     unset($this->tags[$idx]);
                     break;
                 }
             }
         }
 
         return $status;
     }
 
     /**
      * Find folder
      */
     public function find_folder($object = array())
     {
         if (!$this->is_enabled()) {
             return;
         }
 
         // find folder object
         if ($object['_mailbox']) {
             foreach ($this->folders as $folder) {
                 if ($folder->name == $object['_mailbox']) {
                     break;
                 }
             }
         }
         else {
             $folder = $this->default;
         }
 
         return $folder;
     }
 
     /**
      * Builds relation member URI
      *
      * @param string|array Object UUID or Message folder, UID, Search headers (Message-Id, Date)
      *
      * @return string $url Member URI
      */
     public static function build_member_url($params)
     {
         // param is object UUID
         if (is_string($params) && !empty($params)) {
             return 'urn:uuid:' . $params;
         }
 
         if (empty($params) || !strlen($params['folder'])) {
             return null;
         }
 
         $rcube   = rcube::get_instance();
         $storage = $rcube->get_storage();
         list($username, $domain) = explode('@', $rcube->get_user_name());
 
         if (strlen($domain)) {
             $domain = '@' . $domain;
         }
 
         // modify folder spec. according to namespace
         $folder = $params['folder'];
         $ns     = $storage->folder_namespace($folder);
 
         if ($ns == 'shared') {
             // Note: this assumes there's only one shared namespace root
             if ($ns = $storage->get_namespace('shared')) {
                 if ($prefix = $ns[0][0]) {
                     $folder = substr($folder, strlen($prefix));
                 }
             }
         }
         else {
             if ($ns == 'other') {
                 // Note: this assumes there's only one other users namespace root
                 if ($ns = $storage->get_namespace('other')) {
                     if ($prefix = $ns[0][0]) {
                         list($otheruser, $path) = explode('/', substr($folder, strlen($prefix)), 2);
                         $folder = 'user/' . $otheruser . $domain . '/' . $path;
                     }
                 }
             }
             else {
                 $folder = 'user/' . $username . $domain . '/' . $folder;
             }
         }
 
         $folder = implode('/', array_map('rawurlencode', explode('/', $folder)));
 
         // build URI
         $url = 'imap:///' . $folder;
 
         // UID is optional here because sometimes we want
         // to build just a member uri prefix
         if ($params['uid']) {
             $url .= '/' . $params['uid'];
         }
 
         unset($params['folder']);
         unset($params['uid']);
 
         if (!empty($params)) {
             $url .= '?' . http_build_query($params, '', '&');
         }
 
         return $url;
     }
 
     /**
      * Parses relation member string
      *
      * @param string $url Member URI
      *
      * @return array Message folder, UID, Search headers (Message-Id, Date)
      */
     public static function parse_member_url($url)
     {
         // Look for IMAP URI:
         // imap:///(user/username@domain|shared)/<folder>/<UID>?<search_params>
         if (strpos($url, 'imap:///') === 0) {
             $rcube   = rcube::get_instance();
             $storage = $rcube->get_storage();
 
             // parse_url does not work with imap:/// prefix
             $url   = parse_url(substr($url, 8));
             $path  = explode('/', $url['path']);
             parse_str($url['query'], $params);
 
             $uid  = array_pop($path);
             $ns   = array_shift($path);
             $path = array_map('rawurldecode', $path);
 
             // resolve folder name
             if ($ns == 'user') {
                 $username = array_shift($path);
                 $folder   = implode('/', $path);
 
                 if ($username != $rcube->get_user_name()) {
                     list($user, $domain) = explode('@', $username);
 
                     // Note: this assumes there's only one other users namespace root
                     if ($ns = $storage->get_namespace('other')) {
                         if ($prefix = $ns[0][0]) {
                             $folder = $prefix . $user . '/' . $folder;
                         }
                     }
                 }
                 else if (!strlen($folder)) {
                     $folder = 'INBOX';
                 }
             }
             else {
                 $folder = $ns . '/' . implode('/', $path);
                 // Note: this assumes there's only one shared namespace root
                 if ($ns = $storage->get_namespace('shared')) {
                     if ($prefix = $ns[0][0]) {
                         $folder = $prefix . $folder;
                     }
                 }
             }
 
             return array(
                 'folder' => $folder,
                 'uid'    => $uid,
                 'params' => $params,
             );
         }
 
         return false;
     }
 
     /**
      * Build array of member URIs from set of messages
      *
      * @param string $folder   Folder name
      * @param array  $messages Array of rcube_message objects
      *
      * @return array List of members (IMAP URIs)
      */
     public static function build_members($folder, $messages)
     {
         $members = array();
 
         foreach ((array) $messages as $msg) {
             $params = array(
                 'folder' => $folder,
                 'uid'    => $msg->uid,
             );
 
             // add search parameters:
             // we don't want to build "invalid" searches e.g. that
             // will return false positives (more or wrong messages)
             if (($messageid = $msg->get('message-id', false)) && ($date = $msg->get('date', false))) {
                 $params['message-id'] = $messageid;
                 $params['date']       = $date;
 
                 if ($subject = $msg->get('subject', false)) {
                     $params['subject'] = substr($subject, 0, 256);
                 }
             }
 
             $members[] = self::build_member_url($params);
         }
 
         return $members;
     }
 
     /**
      * Resolve/validate/update members (which are IMAP URIs) of relation object.
      *
      * @param array $tag   Tag object
      * @param bool  $force Force members list update
      *
      * @return array Folder/UIDs list
      */
     public static function resolve_members(&$tag, $force = true)
     {
         $result = array();
 
         foreach ((array) $tag['members'] as $member) {
             // IMAP URI members
             if ($url = self::parse_member_url($member)) {
                 $folder = $url['folder'];
 
                 if (!$force) {
                     $result[$folder][] = $url['uid'];
                 }
                 else {
                     $result[$folder]['uid'][]    = $url['uid'];
                     $result[$folder]['params'][] = $url['params'];
                     $result[$folder]['member'][] = $member;
                 }
             }
         }
 
         if (empty($result) || !$force) {
             return $result;
         }
 
         $rcube   = rcube::get_instance();
         $storage = $rcube->get_storage();
         $search  = array();
         $missing = array();
 
         // first we search messages by Folder+UID
         foreach ($result as $folder => $data) {
             // @FIXME: maybe better use index() which is cached?
             // @TODO: consider skip_deleted option
             $index = $storage->search_once($folder, 'UID ' . rcube_imap_generic::compressMessageSet($data['uid']));
             $uids  = $index->get();
 
             // messages that were not found need to be searched by search parameters
             $not_found = array_diff($data['uid'], $uids);
             if (!empty($not_found)) {
                 foreach ($not_found as $uid) {
                     $idx = array_search($uid, $data['uid']);
 
                     if ($p = $data['params'][$idx]) {
                         $search[] = $p;
                     }
 
                     $missing[] = $result[$folder]['member'][$idx];
 
                     unset($result[$folder]['uid'][$idx]);
                     unset($result[$folder]['params'][$idx]);
                     unset($result[$folder]['member'][$idx]);
                 }
             }
 
             $result[$folder] = $uids;
         }
 
         // search in all subscribed mail folders using search parameters
         if (!empty($search)) {
             // remove not found members from the members list
             $tag['members'] = array_diff($tag['members'], $missing);
 
             // get subscribed folders
             $folders = $storage->list_folders_subscribed('', '*', 'mail', null, true);
 
             // @TODO: do this search in chunks (for e.g. 10 messages)?
             $search_str = '';
 
             foreach ($search as $p) {
                 $search_params = array();
                 foreach ($p as $key => $val) {
                     $key = strtoupper($key);
                     // don't search by subject, we don't want false-positives
                     if ($key != 'SUBJECT') {
                         $search_params[] = 'HEADER ' . $key . ' ' . rcube_imap_generic::escape($val);
                     }
                 }
 
                 $search_str .= ' (' . implode(' ', $search_params) . ')';
             }
 
             $search_str = trim(str_repeat(' OR', count($search)-1) . $search_str);
 
             // search
             $search = $storage->search_once($folders, $search_str);
 
             // handle search result
             $folders = (array) $search->get_parameters('MAILBOX');
 
             foreach ($folders as $folder) {
                 $set  = $search->get_set($folder);
                 $uids = $set->get();
 
                 if (!empty($uids)) {
                     $msgs    = $storage->fetch_headers($folder, $uids, false);
                     $members = self::build_members($folder, $msgs);
 
                     // merge new members into the tag members list
                     $tag['members'] = array_merge($tag['members'], $members);
 
                     // add UIDs into the result
                     $result[$folder] = array_unique(array_merge((array)$result[$folder], $uids));
                 }
             }
 
             // update tag object with new members list
             $tag['members'] = array_unique($tag['members']);
             kolab_storage_config::get_instance()->save($tag, 'relation', false);
         }
 
         return $result;
     }
 
     /**
      * Assign tags to kolab objects
      *
      * @param array $records   List of kolab objects
      * @param bool  $no_return Don't return anything
      *
      * @return array List of tags
      */
     public function apply_tags(&$records, $no_return = false)
     {
         if (empty($records) && $no_return) {
             return;
         }
 
         // first convert categories into tags
         foreach ($records as $i => $rec) {
             if (!empty($rec['categories'])) {
                 $folder = new kolab_storage_folder($rec['_mailbox']);
                 if ($object = $folder->get_object($rec['uid'])) {
                     $tags = $rec['categories'];
 
                     unset($object['categories']);
                     unset($records[$i]['categories']);
 
                     $this->save_tags($rec['uid'], $tags);
                     $folder->save($object, $rec['_type'], $rec['uid']);
                 }
             }
         }
 
         $tags = array();
 
         // assign tags to objects
         foreach ($this->get_tags() as $tag) {
             foreach ($records as $idx => $rec) {
                 $uid = self::build_member_url($rec['uid']);
                 if (in_array($uid, (array) $tag['members'])) {
                     $records[$idx]['tags'][] = $tag['name'];
                 }
             }
 
             $tags[] = $tag['name'];
         }
 
         $tags = $no_return ? null : array_unique($tags);
 
         return $tags;
     }
 
     /**
      * Assign links (relations) to kolab objects
      *
      * @param array $records List of kolab objects
      */
     public function apply_links(&$records)
     {
         $links = array();
         $uids  = array();
         $ids   = array();
         $limit = 25;
 
         // get list of object UIDs and UIRs map
         foreach ($records as $i => $rec) {
             $uids[] = $rec['uid'];
             // there can be many objects with the same uid (recurring events)
             $ids[self::build_member_url($rec['uid'])][] = $i;
             $records[$i]['links'] = array();
         }
 
         if (!empty($uids)) {
             $uids = array_unique($uids);
         }
 
         // The whole story here is to not do SELECT for every object.
         // We'll build one SELECT for many (limit above) objects at once
 
         while (!empty($uids)) {
             $chunk = array_splice($uids, 0, $limit);
             $chunk = array_map(function($v) { return array('member', '=', $v); }, $chunk);
 
             $filter = array(
                 array('type', '=', 'relation'),
                 array('category', '=', 'generic'),
                 array($chunk, 'OR'),
             );
 
             $relations = $this->get_objects($filter, true, self::MAX_RELATIONS);
 
             foreach ($relations as $relation) {
                 $links[$relation['uid']] = $relation;
             }
         }
 
         if (empty($links)) {
             return;
         }
 
         // assign links of related messages
         foreach ($links as $relation) {
             // make relation members up-to-date
             kolab_storage_config::resolve_members($relation);
 
             $members = array();
             foreach ((array) $relation['members'] as $member) {
                 if (strpos($member, 'imap://') === 0) {
                     $members[$member] = $member;
                 }
             }
             $members = array_values($members);
 
             // assign links to objects
             foreach ((array) $relation['members'] as $member) {
                 if (($id = $ids[$member]) !== null) {
                     foreach ($id as $i) {
                         $records[$i]['links'] = array_unique(array_merge($records[$i]['links'], $members));
                     }
                 }
             }
         }
     }
 
     /**
      * Update object tags
      *
      * @param string $uid  Kolab object UID
      * @param array  $tags List of tag names
      */
     public function save_tags($uid, $tags)
     {
         $url       = self::build_member_url($uid);
         $relations = $this->get_tags();
 
         foreach ($relations as $idx => $relation) {
             $selected = !empty($tags) && in_array($relation['name'], $tags);
             $found    = !empty($relation['members']) && in_array($url, $relation['members']);
             $update   = false;
 
             // remove member from the relation
             if ($found && !$selected) {
                 $relation['members'] = array_diff($relation['members'], (array) $url);
                 $update = true;
             }
             // add member to the relation
             else if (!$found && $selected) {
                 $relation['members'][] = $url;
                 $update = true;
             }
 
             if ($update) {
                 $this->save($relation, 'relation');
             }
 
             if ($selected) {
                 $tags = array_diff($tags, array($relation['name']));
             }
         }
 
         // create new relations
         if (!empty($tags)) {
             foreach ($tags as $tag) {
                 $relation = array(
                     'name'     => $tag,
                     'members'  => (array) $url,
                     'category' => 'tag',
                 );
 
                 $this->save($relation, 'relation');
             }
         }
     }
 
     /**
      * Get tags (all or referring to specified object)
      *
      * @param string $member Optional object UID or mail message-id
      *
      * @return array List of Relation objects
      */
     public function get_tags($member = '*')
     {
         if (!isset($this->tags)) {
             $default = true;
             $filter  = array(
                 array('type', '=', 'relation'),
                 array('category', '=', 'tag')
             );
 
             // use faster method
             if ($member && $member != '*') {
                 $filter[] = array('member', '=', $member);
                 $tags = $this->get_objects($filter, $default, self::MAX_RELATIONS);
             }
             else {
                 $this->tags = $tags = $this->get_objects($filter, $default, self::MAX_RELATIONS);
             }
         }
         else {
             $tags = $this->tags;
         }
 
         if ($member === '*') {
             return $tags;
         }
 
         $result = array();
 
         if ($member[0] == '<') {
             $search_msg = urlencode($member);
         }
         else {
             $search_uid = self::build_member_url($member);
         }
 
         foreach ($tags as $tag) {
             if ($search_uid && in_array($search_uid, (array) $tag['members'])) {
                 $result[] = $tag;
             }
             else if ($search_msg) {
                 foreach ($tag['members'] as $m) {
                     if (strpos($m, $search_msg) !== false) {
                         $result[] = $tag;
                         break;
                     }
                 }
             }
         }
 
         return $result;
     }
 
     /**
      * Find objects linked with the given groupware object through a relation
      *
      * @param string Object UUID
      *
      * @return array List of related URIs
      */
     public function get_object_links($uid)
     {
         $links = array();
         $object_uri = self::build_member_url($uid);
 
         foreach ($this->get_relations_for_member($uid) as $relation) {
             if (in_array($object_uri, (array) $relation['members'])) {
                 // make relation members up-to-date
                 kolab_storage_config::resolve_members($relation);
 
                 foreach ($relation['members'] as $member) {
                     if ($member != $object_uri) {
                         $links[] = $member;
                     }
                 }
             }
         }
 
         return array_unique($links);
     }
 
     /**
      * Save relations of an object.
      * Note, that we already support only one-to-one relations.
      * So, all relations to the object that are not provided in $links
      * argument will be removed.
      *
      * @param string $uid   Object UUID
      * @param array  $links List of related-object URIs
      *
      * @return bool True on success, False on failure
      */
     public function save_object_links($uid, $links)
     {
         $object_uri = self::build_member_url($uid);
         $relations  = $this->get_relations_for_member($uid);
         $done       = false;
 
         foreach ($relations as $relation) {
             // make relation members up-to-date
             kolab_storage_config::resolve_members($relation);
 
             // remove and add links
             $members = array($object_uri);
             $members = array_unique(array_merge($members, $links));
 
             // remove relation if no other members remain
             if (count($members) <= 1) {
                 $done = $this->delete($relation);
             }
             // update relation object if members changed
             else if (count(array_diff($members, $relation['members'])) || count(array_diff($relation['members'], $members))) {
                 $relation['members'] = $members;
                 $done = $this->save($relation, 'relation');
                 $links = array();
             }
             // no changes, we're happy
             else {
                 $done  = true;
                 $links = array();
             }
         }
 
         // create a new relation
         if (!$done && !empty($links)) {
             $relation = array(
                 'members'  => array_merge($links, array($object_uri)),
                 'category' => 'generic',
             );
 
             $done = $this->save($relation, 'relation');
         }
 
         return $done;
     }
 
     /**
      * Find relation objects referring to specified note
      */
     public function get_relations_for_member($uid, $reltype = 'generic')
     {
         $default = true;
         $filter  = array(
             array('type', '=', 'relation'),
             array('category', '=', $reltype),
             array('member', '=', $uid),
         );
 
         return $this->get_objects($filter, $default, self::MAX_RELATIONS);
     }
 
     /**
      * Find kolab objects assigned to specified e-mail message
      *
      * @param rcube_message $message E-mail message
      * @param string        $folder  Folder name
      * @param string        $type    Result objects type
      *
      * @return array List of kolab objects
      */
     public function get_message_relations($message, $folder, $type)
     {
         static $_cache = array();
 
         $result  = array();
         $uids    = array();
         $default = true;
         $uri     = self::get_message_uri($message, $folder);
         $filter  = array(
             array('type', '=', 'relation'),
             array('category', '=', 'generic'),
         );
 
         // query by message-id
         $member_id = $message->get('message-id', false);
         if (empty($member_id)) {
             // derive message identifier from URI
             $member_id = md5($uri);
         }
         $filter[] = array('member', '=', $member_id);
 
         if (!isset($_cache[$uri])) {
             // get UIDs of related groupware objects
             foreach ($this->get_objects($filter, $default) as $relation) {
                 // we don't need to update members if the URI is found
                 if (!in_array($uri, $relation['members'])) {
                     // update members...
                     $messages = kolab_storage_config::resolve_members($relation);
                     // ...and check again
                     if (empty($messages[$folder]) || !in_array($message->uid, $messages[$folder])) {
                         continue;
                     }
                 }
 
                 // find groupware object UID(s)
                 foreach ($relation['members'] as $member) {
                     if (strpos($member, 'urn:uuid:') === 0) {
                         $uids[] = substr($member, 9);
                     }
                 }
             }
 
             // remember this lookup
             $_cache[$uri] = $uids;
         }
         else {
             $uids = $_cache[$uri];
         }
 
         // get kolab objects of specified type
         if (!empty($uids)) {
             $query  = array(array('uid', '=', array_unique($uids)));
             $result = kolab_storage::select($query, $type, count($uids));
         }
 
         return $result;
     }
 
     /**
      * Build a URI representing the given message reference
      */
     public static function get_message_uri($headers, $folder)
     {
         $params = array(
             'folder' => $headers->folder ?: $folder,
             'uid'    => $headers->uid,
         );
 
         if (($messageid = $headers->get('message-id', false)) && ($date = $headers->get('date', false))) {
             $params['message-id'] = $messageid;
             $params['date']       = $date;
 
             if ($subject = $headers->get('subject')) {
                 $params['subject'] = $subject;
             }
         }
 
         return self::build_member_url($params);
     }
 
     /**
      * Resolve the email message reference from the given URI
      */
     public static function get_message_reference($uri, $rel = null)
     {
         if ($linkref = self::parse_member_url($uri)) {
             $linkref['subject'] = $linkref['params']['subject'];
             $linkref['uri']     = $uri;
 
             $rcmail = rcube::get_instance();
             if (method_exists($rcmail, 'url')) {
                 $linkref['mailurl'] = $rcmail->url(array(
                     'task'   => 'mail',
                     'action' => 'show',
                     'mbox'   => $linkref['folder'],
                     'uid'    => $linkref['uid'],
                     'rel'    => $rel,
                 ));
             }
 
             unset($linkref['params']);
         }
 
         return $linkref;
     }
 }
diff --git a/plugins/libkolab/lib/kolab_storage_folder.php b/plugins/libkolab/lib/kolab_storage_folder.php
index 4018b7df..d0695cb2 100644
--- a/plugins/libkolab/lib/kolab_storage_folder.php
+++ b/plugins/libkolab/lib/kolab_storage_folder.php
@@ -1,1141 +1,1147 @@
 <?php
 
 /**
  * The kolab_storage_folder class represents an IMAP folder on the Kolab server.
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  * @author Aleksander Machniak <machniak@kolabsys.com>
  *
  * Copyright (C) 2012-2013, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 class kolab_storage_folder extends kolab_storage_folder_api
 {
     /**
      * The kolab_storage_cache instance for caching operations
      * @var object
      */
     public $cache;
 
     /**
      * Indicate validity status
      * @var boolean
      */
     public $valid = false;
 
     protected $error = 0;
     protected $resource_uri;
 
 
     /**
      * Default constructor
      *
      * @param string The folder name/path
      * @param string Expected folder type
      */
     function __construct($name, $type = null, $type_annotation = null)
     {
         parent::__construct($name);
         $this->set_folder($name, $type, $type_annotation);
     }
 
     /**
      * Set the IMAP folder this instance connects to
      *
      * @param string The folder name/path
      * @param string Expected folder type
      * @param string Optional folder type if known
      */
     public function set_folder($name, $type = null, $type_annotation = null)
     {
         $this->name = $name;
 
         if (empty($type_annotation)) {
             $type_annotation = $this->get_type();
         }
 
         $oldtype = $this->type;
         list($this->type, $suffix) = explode('.', $type_annotation);
         $this->default      = $suffix == 'default';
         $this->subtype      = $this->default ? '' : $suffix;
         $this->id           = kolab_storage::folder_id($name);
         $this->valid        = !empty($this->type) && $this->type != 'mail' && (!$type || $this->type == $type);
 
         if (!$this->valid) {
             $this->error = $this->imap->get_error_code() < 0 ? kolab_storage::ERROR_IMAP_CONN : kolab_storage::ERROR_INVALID_FOLDER;
         }
 
         // reset cached object properties
         $this->owner = $this->namespace = $this->resource_uri = $this->info = $this->idata = null;
 
         // get a new cache instance if folder type changed
         if (!$this->cache || $this->type != $oldtype)
             $this->cache = kolab_storage_cache::factory($this);
         else
             $this->cache->set_folder($this);
 
         $this->imap->set_folder($this->name);
     }
 
     /**
      * Returns code of last error
      *
      * @return int Error code
      */
     public function get_error()
     {
         return $this->error ?: $this->cache->get_error();
     }
 
     /**
      * Check IMAP connection error state
      */
     public function check_error()
     {
         if (($err_code = $this->imap->get_error_code()) < 0) {
             $this->error = kolab_storage::ERROR_IMAP_CONN;
             if (($res_code = $this->imap->get_response_code()) !== 0 && in_array($res_code, array(rcube_storage::NOPERM, rcube_storage::READONLY))) {
                 $this->error = kolab_storage::ERROR_NO_PERMISSION;
             }
         }
 
         return $this->error;
     }
 
     /**
      * Compose a unique resource URI for this IMAP folder
      */
     public function get_resource_uri()
     {
         if (!empty($this->resource_uri)) {
             return $this->resource_uri;
         }
 
         // strip namespace prefix from folder name
         $ns     = $this->get_namespace();
         $nsdata = $this->imap->get_namespace($ns);
 
         if (is_array($nsdata[0]) && strlen($nsdata[0][0]) && strpos($this->name, $nsdata[0][0]) === 0) {
             $subpath = substr($this->name, strlen($nsdata[0][0]));
             if ($ns == 'other') {
                 list($user, $suffix) = explode($nsdata[0][1], $subpath, 2);
                 $subpath = $suffix;
             }
         }
         else {
             $subpath = $this->name;
         }
 
         // compose fully qualified ressource uri for this instance
         $this->resource_uri = 'imap://' . urlencode($this->get_owner(true)) . '@' . $this->imap->options['host'] . '/' . $subpath;
         return $this->resource_uri;
     }
 
     /**
      * Helper method to extract folder UID metadata
      *
      * @return string Folder's UID
      */
     public function get_uid()
     {
         // UID is defined in folder METADATA
         $metakeys = array(kolab_storage::UID_KEY_SHARED, kolab_storage::UID_KEY_CYRUS);
         $metadata = $this->get_metadata();
 
         if ($metadata !== null) {
             foreach ($metakeys as $key) {
                 if ($uid = $metadata[$key]) {
                     return $uid;
                 }
             }
 
             // generate a folder UID and set it to IMAP
             $uid = rtrim(chunk_split(md5($this->name . $this->get_owner() . uniqid('-', true)), 12, '-'), '-');
             if ($this->set_uid($uid)) {
                 return $uid;
             }
         }
 
         $this->check_error();
 
         // create hash from folder name if we can't write the UID metadata
         return md5($this->name . $this->get_owner());
     }
 
     /**
      * Helper method to set an UID value to the given IMAP folder instance
      *
      * @param string Folder's UID
      * @return boolean True on succes, False on failure
      */
     public function set_uid($uid)
     {
         $success = $this->set_metadata(array(kolab_storage::UID_KEY_SHARED => $uid));
 
         $this->check_error();
         return $success;
     }
 
     /**
      * Compose a folder Etag identifier
      */
     public function get_ctag()
     {
         $fdata = $this->get_imap_data();
         $this->check_error();
         return sprintf('%d-%d-%d', $fdata['UIDVALIDITY'], $fdata['HIGHESTMODSEQ'], $fdata['UIDNEXT']);
     }
 
     /**
      * Check activation status of this folder
      *
      * @return boolean True if enabled, false if not
      */
     public function is_active()
     {
         return kolab_storage::folder_is_active($this->name);
     }
 
     /**
      * Change activation status of this folder
      *
      * @param boolean The desired subscription status: true = active, false = not active
      *
      * @return True on success, false on error
      */
     public function activate($active)
     {
         return $active ? kolab_storage::folder_activate($this->name) : kolab_storage::folder_deactivate($this->name);
     }
 
     /**
      * Check subscription status of this folder
      *
      * @return boolean True if subscribed, false if not
      */
     public function is_subscribed()
     {
         return kolab_storage::folder_is_subscribed($this->name);
     }
 
     /**
      * Change subscription status of this folder
      *
      * @param boolean The desired subscription status: true = subscribed, false = not subscribed
      *
      * @return True on success, false on error
      */
     public function subscribe($subscribed)
     {
         return $subscribed ? kolab_storage::folder_subscribe($this->name) : kolab_storage::folder_unsubscribe($this->name);
     }
 
     /**
      * Get number of objects stored in this folder
      *
      * @param mixed Pseudo-SQL query as list of filter parameter triplets
      *    or string with object type (e.g. contact, event, todo, journal, note, configuration)
      *
      * @return integer The number of objects of the given type
      * @see self::select()
      */
     public function count($query = null)
     {
         if (!$this->valid) {
             return 0;
         }
 
         // synchronize cache first
         $this->cache->synchronize();
 
         return $this->cache->count($this->_prepare_query($query));
     }
 
     /**
      * List Kolab objects matching the given query
      *
      * @param mixed Pseudo-SQL query as list of filter parameter triplets
      *    or string with object type (e.g. contact, event, todo, journal, note, configuration)
      *
      * @return array List of Kolab data objects (each represented as hash array)
      * @deprecated Use select()
      */
     public function get_objects($query = array())
     {
         return $this->select($query);
     }
 
     /**
      * Select Kolab objects matching the given query
      *
-     * @param mixed Pseudo-SQL query as list of filter parameter triplets
-     *    or string with object type (e.g. contact, event, todo, journal, note, configuration)
+     * @param mixed   Pseudo-SQL query as list of filter parameter triplets
+     *                or string with object type (e.g. contact, event, todo, journal, note, configuration)
+     * @param boolean Use fast mode to fetch only minimal set of information
+     *                (no xml fetching and parsing, etc.)
      *
      * @return array List of Kolab data objects (each represented as hash array)
      */
-    public function select($query = array())
+    public function select($query = array(), $fast = false)
     {
         if (!$this->valid) {
             return array();
         }
 
         // synchronize caches
         $this->cache->synchronize();
 
         // fetch objects from cache
-        return $this->cache->select($this->_prepare_query($query));
+        return $this->cache->select($this->_prepare_query($query), false, $fast);
     }
 
     /**
      * Getter for object UIDs only
      *
      * @param array Pseudo-SQL query as list of filter parameter triplets
      * @return array List of Kolab object UIDs
      */
     public function get_uids($query = array())
     {
         if (!$this->valid) {
             return array();
         }
 
         // synchronize caches
         $this->cache->synchronize();
 
         // fetch UIDs from cache
         return $this->cache->select($this->_prepare_query($query), true);
     }
 
     /**
      * Setter for ORDER BY and LIMIT parameters for cache queries
      *
      * @param array   List of columns to order by
      * @param integer Limit result set to this length
      * @param integer Offset row
      */
     public function set_order_and_limit($sortcols, $length = null, $offset = 0)
     {
         $this->cache->set_order_by($sortcols);
 
         if ($length !== null) {
             $this->cache->set_limit($length, $offset);
         }
     }
 
     /**
      * Helper method to sanitize query arguments
      */
     private function _prepare_query($query)
     {
         // string equals type query
         // FIXME: should not be called this way!
         if (is_string($query)) {
             return $this->cache->has_type_col() && !empty($query) ? array(array('type','=',$query)) : array();
         }
 
         foreach ((array)$query as $i => $param) {
             if ($param[0] == 'type' && !$this->cache->has_type_col()) {
                 unset($query[$i]);
             }
             else if (($param[0] == 'dtstart' || $param[0] == 'dtend' || $param[0] == 'changed')) {
                 if (is_object($param[2]) && is_a($param[2], 'DateTime'))
                     $param[2] = $param[2]->format('U');
                 if (is_numeric($param[2]))
                     $query[$i][2] = date('Y-m-d H:i:s', $param[2]);
             }
         }
 
         return $query;
     }
 
     /**
      * Getter for a single Kolab object identified by its UID
      *
      * @param string $uid Object UID
      *
      * @return array The Kolab object represented as hash array
      */
     public function get_object($uid)
     {
         if (!$this->valid || !$uid) {
             return false;
         }
 
         // synchronize caches
         $this->cache->synchronize();
 
         return $this->cache->get_by_uid($uid);
     }
 
     /**
      * Fetch a Kolab object attachment which is stored in a separate part
      * of the mail MIME message that represents the Kolab record.
      *
      * @param string   Object's UID
      * @param string   The attachment's mime number
      * @param string   IMAP folder where message is stored;
      *                 If set, that also implies that the given UID is an IMAP UID
      * @param bool     True to print the part content
      * @param resource File pointer to save the message part
      * @param boolean  Disables charset conversion
      *
      * @return mixed  The attachment content as binary string
      */
     public function get_attachment($uid, $part, $mailbox = null, $print = false, $fp = null, $skip_charset_conv = false)
     {
         if ($this->valid && ($msguid = ($mailbox ? $uid : $this->cache->uid2msguid($uid)))) {
             $this->imap->set_folder($mailbox ? $mailbox : $this->name);
 
             if (substr($part, 0, 2) == 'i:') {
                 // attachment data is stored in XML
                 if ($object = $this->cache->get($msguid)) {
                     // load data from XML (attachment content is not stored in cache)
                     if ($object['_formatobj'] && isset($object['_size'])) {
                         $object['_attachments'] = array();
                         $object['_formatobj']->get_attachments($object);
                     }
 
                     foreach ($object['_attachments'] as $attach) {
                         if ($attach['id'] == $part) {
                             if ($print)   echo $attach['content'];
                             else if ($fp) fwrite($fp, $attach['content']);
                             else          return $attach['content'];
                             return true;
                         }
                     }
                 }
             }
             else {
                 // return message part from IMAP directly
+                // TODO: We could improve performance if we cache part's encoding
+                //       without 3rd argument get_message_part() will request BODYSTRUCTURE from IMAP
                 return $this->imap->get_message_part($msguid, $part, null, $print, $fp, $skip_charset_conv);
             }
         }
 
         return null;
     }
 
     /**
      * Fetch the mime message from the storage server and extract
      * the Kolab groupware object from it
      *
      * @param string The IMAP message UID to fetch
      * @param string The object type expected (use wildcard '*' to accept all types)
      * @param string The folder name where the message is stored
      *
      * @return mixed Hash array representing the Kolab object, a kolab_format instance or false if not found
      */
     public function read_object($msguid, $type = null, $folder = null)
     {
         if (!$this->valid) {
             return false;
         }
 
         if (!$type) $type = $this->type;
         if (!$folder) $folder = $this->name;
 
         $this->imap->set_folder($folder);
 
         $this->cache->imap_mode(true);
         $message = new rcube_message($msguid);
         $this->cache->imap_mode(false);
 
         // Message doesn't exist?
         if (empty($message->headers)) {
             return false;
         }
 
         // extract the X-Kolab-Type header from the XML attachment part if missing
         if (empty($message->headers->others['x-kolab-type'])) {
             foreach ((array)$message->attachments as $part) {
                 if (strpos($part->mimetype, kolab_format::KTYPE_PREFIX) === 0) {
                     $message->headers->others['x-kolab-type'] = $part->mimetype;
                     break;
                 }
             }
         }
         // fix buggy messages stating the X-Kolab-Type header twice
         else if (is_array($message->headers->others['x-kolab-type'])) {
             $message->headers->others['x-kolab-type'] = reset($message->headers->others['x-kolab-type']);
         }
 
         // no object type header found: abort
         if (empty($message->headers->others['x-kolab-type'])) {
             rcube::raise_error(array(
                 'code' => 600,
                 'type' => 'php',
                 'file' => __FILE__,
                 'line' => __LINE__,
                 'message' => "No X-Kolab-Type information found in message $msguid ($this->name).",
             ), true);
             return false;
         }
 
         $object_type  = kolab_format::mime2object_type($message->headers->others['x-kolab-type']);
         $content_type = kolab_format::KTYPE_PREFIX . $object_type;
 
         // check object type header and abort on mismatch
-        if ($type != '*' && $object_type != $type)
+        if ($type != '*' && strpos($object_type, $type) !== 0 && !($object_type == 'distribution-list' && $type == 'contact')) {
             return false;
+        }
 
         $attachments = array();
 
         // get XML part
         foreach ((array)$message->attachments as $part) {
             if (!$xml && ($part->mimetype == $content_type || preg_match('!application/([a-z.]+\+)?xml!i', $part->mimetype))) {
                 $xml = $message->get_part_body($part->mime_id, true);
             }
             else if ($part->filename || $part->content_id) {
                 $key  = $part->content_id ? trim($part->content_id, '<>') : $part->filename;
                 $size = null;
 
                 // Use Content-Disposition 'size' as for the Kolab Format spec.
                 if (isset($part->d_parameters['size'])) {
                     $size = $part->d_parameters['size'];
                 }
                 // we can trust part size only if it's not encoded
                 else if ($part->encoding == 'binary' || $part->encoding == '7bit' || $part->encoding == '8bit') {
                     $size = $part->size;
                 }
 
                 $attachments[$key] = array(
                     'id'       => $part->mime_id,
                     'name'     => $part->filename,
                     'mimetype' => $part->mimetype,
                     'size'     => $size,
                 );
             }
         }
 
         if (!$xml) {
             rcube::raise_error(array(
                 'code' => 600,
                 'type' => 'php',
                 'file' => __FILE__,
                 'line' => __LINE__,
                 'message' => "Could not find Kolab data part in message $msguid ($this->name).",
             ), true);
             return false;
         }
 
         // check kolab format version
         $format_version = $message->headers->others['x-kolab-mime-version'];
         if (empty($format_version)) {
             list($xmltype, $subtype) = explode('.', $object_type);
             $xmlhead = substr($xml, 0, 512);
 
             // detect old Kolab 2.0 format
             if (strpos($xmlhead, '<' . $xmltype) !== false && strpos($xmlhead, 'xmlns=') === false)
                 $format_version = '2.0';
             else
                 $format_version = '3.0'; // assume 3.0
         }
 
         // get Kolab format handler for the given type
         $format = kolab_format::factory($object_type, $format_version);
 
         if (is_a($format, 'PEAR_Error'))
             return false;
 
         // load Kolab object from XML part
         $format->load($xml);
 
         if ($format->is_valid()) {
             $object = $format->to_array(array('_attachments' => $attachments));
             $object['_type']      = $object_type;
             $object['_msguid']    = $msguid;
             $object['_mailbox']   = $this->name;
             $object['_formatobj'] = $format;
+            $object['_size']      = strlen($xml);
 
             return $object;
         }
         else {
             // try to extract object UID from XML block
             if (preg_match('!<uid>(.+)</uid>!Uims', $xml, $m))
                 $msgadd = " UID = " . trim(strip_tags($m[1]));
 
             rcube::raise_error(array(
                 'code' => 600,
                 'type' => 'php',
                 'file' => __FILE__,
                 'line' => __LINE__,
                 'message' => "Could not parse Kolab object data in message $msguid ($this->name)." . $msgadd,
             ), true);
         }
 
         return false;
     }
 
     /**
      * Save an object in this folder.
      *
      * @param array  $object The array that holds the data of the object.
      * @param string $type   The type of the kolab object.
      * @param string $uid    The UID of the old object if it existed before
      *
      * @return mixed False on error or IMAP message UID on success
      */
     public function save(&$object, $type = null, $uid = null)
     {
         if (!$this->valid) {
             return false;
         }
 
         if (!$type)
             $type = $this->type;
 
         // copy attachments from old message
         $copyfrom = $object['_copyfrom'] ?: $object['_msguid'];
         if (!empty($copyfrom) && ($old = $this->cache->get($copyfrom, $type, $object['_mailbox']))) {
             foreach ((array)$old['_attachments'] as $key => $att) {
                 if (!isset($object['_attachments'][$key])) {
                     $object['_attachments'][$key] = $old['_attachments'][$key];
                 }
                 // unset deleted attachment entries
                 if ($object['_attachments'][$key] == false) {
                     unset($object['_attachments'][$key]);
                 }
                 // load photo.attachment from old Kolab2 format to be directly embedded in xcard block
                 else if ($type == 'contact' && ($key == 'photo.attachment' || $key == 'kolab-picture.png') && $att['id']) {
                     if (!isset($object['photo']))
                         $object['photo'] = $this->get_attachment($copyfrom, $att['id'], $object['_mailbox']);
                     unset($object['_attachments'][$key]);
                 }
             }
         }
 
         // save contact photo to attachment for Kolab2 format
         if (kolab_storage::$version == '2.0' && $object['photo']) {
             $attkey = 'kolab-picture.png';  // this file name is hard-coded in libkolab/kolabformatV2/contact.cpp
             $object['_attachments'][$attkey] = array(
                 'mimetype'=> rcube_mime::image_content_type($object['photo']),
                 'content' => preg_match('![^a-z0-9/=+-]!i', $object['photo']) ? $object['photo'] : base64_decode($object['photo']),
             );
         }
 
         // process attachments
         if (is_array($object['_attachments'])) {
             $numatt = count($object['_attachments']);
             foreach ($object['_attachments'] as $key => $attachment) {
                 // FIXME: kolab_storage and Roundcube attachment hooks use different fields!
                 if (empty($attachment['content']) && !empty($attachment['data'])) {
                     $attachment['content'] = $attachment['data'];
                     unset($attachment['data'], $object['_attachments'][$key]['data']);
                 }
 
                 // make sure size is set, so object saved in cache contains this info
                 if (!isset($attachment['size'])) {
                     if (!empty($attachment['content'])) {
                         if (is_resource($attachment['content'])) {
                             // this need to be a seekable resource, otherwise
                             // fstat() failes and we're unable to determine size
                             // here nor in rcube_imap_generic before IMAP APPEND
                             $stat = fstat($attachment['content']);
                             $attachment['size'] = $stat ? $stat['size'] : 0;
                         }
                         else {
                             $attachment['size'] = strlen($attachment['content']);
                         }
                     }
                     else if (!empty($attachment['path'])) {
                         $attachment['size'] = filesize($attachment['path']);
                     }
                     $object['_attachments'][$key] = $attachment;
                 }
 
                 // generate unique keys (used as content-id) for attachments
                 if (is_numeric($key) && $key < $numatt) {
                     // derrive content-id from attachment file name
                     $ext = preg_match('/(\.[a-z0-9]{1,6})$/i', $attachment['name'], $m) ? $m[1] : null;
                     $basename = preg_replace('/[^a-z0-9_.-]/i', '', basename($attachment['name'], $ext));  // to 7bit ascii
                     if (!$basename) $basename = 'noname';
                     $cid = $basename . '.' . microtime(true) . $key . $ext;
 
                     $object['_attachments'][$cid] = $attachment;
                     unset($object['_attachments'][$key]);
                 }
             }
         }
 
         // save recurrence exceptions as individual objects due to lack of support in Kolab v2 format
         if (kolab_storage::$version == '2.0' && $object['recurrence']['EXCEPTIONS']) {
             $this->save_recurrence_exceptions($object, $type);
         }
 
         // check IMAP BINARY extension support for 'file' objects
         // allow configuration to workaround bug in Cyrus < 2.4.17
         $rcmail = rcube::get_instance();
         $binary = $type == 'file' && !$rcmail->config->get('kolab_binary_disable') && $this->imap->get_capability('BINARY');
 
         // generate and save object message
         if ($raw_msg = $this->build_message($object, $type, $binary, $body_file)) {
             // resolve old msguid before saving
             if ($uid && empty($object['_msguid']) && ($msguid = $this->cache->uid2msguid($uid))) {
                 $object['_msguid'] = $msguid;
                 $object['_mailbox'] = $this->name;
             }
 
             $result = $this->imap->save_message($this->name, $raw_msg, null, false, null, null, $binary);
 
             // update cache with new UID
             if ($result) {
                 $old_uid = $object['_msguid'];
 
                 $object['_msguid'] = $result;
                 $object['_mailbox'] = $this->name;
 
                 if ($old_uid) {
                     // delete old message
                     $this->cache->imap_mode(true);
                     $this->imap->delete_message($old_uid, $object['_mailbox']);
                     $this->cache->imap_mode(false);
                 }
 
                 // insert/update message in cache
                 $this->cache->save($result, $object, $old_uid);
             }
 
             // remove temp file
             if ($body_file) {
                 @unlink($body_file);
             }
         }
 
         return $result;
     }
 
     /**
      * Save recurrence exceptions as individual objects.
      * The Kolab v2 format doesn't allow us to save fully embedded exception objects.
      *
      * @param array Hash array with event properties
      * @param string Object type
      */
     private function save_recurrence_exceptions(&$object, $type = null)
     {
         if ($object['recurrence']['EXCEPTIONS']) {
             $exdates = array();
             foreach ((array)$object['recurrence']['EXDATE'] as $exdate) {
                 $key = is_a($exdate, 'DateTime') ? $exdate->format('Y-m-d') : strval($exdate);
                 $exdates[$key] = 1;
             }
 
             // save every exception as individual object
             foreach((array)$object['recurrence']['EXCEPTIONS'] as $exception) {
                 $exception['uid'] = self::recurrence_exception_uid($object['uid'], $exception['start']->format('Ymd'));
                 $exception['sequence'] = $object['sequence'] + 1;
 
                 if ($exception['thisandfuture']) {
                     $exception['recurrence'] = $object['recurrence'];
 
                     // adjust the recurrence duration of the exception
                     if ($object['recurrence']['COUNT']) {
                         $recurrence = new kolab_date_recurrence($object['_formatobj']);
                         if ($end = $recurrence->end()) {
                             unset($exception['recurrence']['COUNT']);
                             $exception['recurrence']['UNTIL'] = $end;
                         }
                     }
 
                     // set UNTIL date if we have a thisandfuture exception
                     $untildate = clone $exception['start'];
                     $untildate->sub(new DateInterval('P1D'));
                     $object['recurrence']['UNTIL'] = $untildate;
                     unset($object['recurrence']['COUNT']);
                 }
                 else {
                     if (!$exdates[$exception['start']->format('Y-m-d')])
                         $object['recurrence']['EXDATE'][] = clone $exception['start'];
                     unset($exception['recurrence']);
                 }
 
                 unset($exception['recurrence']['EXCEPTIONS'], $exception['_formatobj'], $exception['_msguid']);
                 $this->save($exception, $type, $exception['uid']);
             }
 
             unset($object['recurrence']['EXCEPTIONS']);
         }
     }
 
     /**
      * Generate an object UID with the given recurrence-ID in a way that it is
      * unique (the original UID is not a substring) but still recoverable.
      */
     private static function recurrence_exception_uid($uid, $recurrence_id)
     {
         $offset = -2;
         return substr($uid, 0, $offset) . '-' . $recurrence_id . '-' . substr($uid, $offset);
     }
 
     /**
      * Delete the specified object from this folder.
      *
      * @param  mixed   $object  The Kolab object to delete or object UID
      * @param  boolean $expunge Should the folder be expunged?
      *
      * @return boolean True if successful, false on error
      */
     public function delete($object, $expunge = true)
     {
         if (!$this->valid) {
             return false;
         }
 
         $msguid = is_array($object) ? $object['_msguid'] : $this->cache->uid2msguid($object);
         $success = false;
 
         $this->cache->imap_mode(true);
 
         if ($msguid && $expunge) {
             $success = $this->imap->delete_message($msguid, $this->name);
         }
         else if ($msguid) {
             $success = $this->imap->set_flag($msguid, 'DELETED', $this->name);
         }
 
         $this->cache->imap_mode(false);
 
         if ($success) {
             $this->cache->set($msguid, false);
         }
 
         return $success;
     }
 
     /**
      *
      */
     public function delete_all()
     {
         if (!$this->valid) {
             return false;
         }
 
         $this->cache->purge();
         $this->cache->imap_mode(true);
         $result = $this->imap->clear_folder($this->name);
         $this->cache->imap_mode(false);
 
         return $result;
     }
 
     /**
      * Restore a previously deleted object
      *
      * @param string Object UID
      * @return mixed Message UID on success, false on error
      */
     public function undelete($uid)
     {
         if (!$this->valid) {
             return false;
         }
 
         if ($msguid = $this->cache->uid2msguid($uid, true)) {
             $this->cache->imap_mode(true);
             $result = $this->imap->set_flag($msguid, 'UNDELETED', $this->name);
             $this->cache->imap_mode(false);
 
             if ($result) {
                 return $msguid;
             }
         }
 
         return false;
     }
 
     /**
      * Move a Kolab object message to another IMAP folder
      *
      * @param string Object UID
      * @param string IMAP folder to move object to
      * @return boolean True on success, false on failure
      */
     public function move($uid, $target_folder)
     {
         if (!$this->valid) {
             return false;
         }
 
         if (is_string($target_folder))
             $target_folder = kolab_storage::get_folder($target_folder);
 
         if ($msguid = $this->cache->uid2msguid($uid)) {
             $this->cache->imap_mode(true);
             $result = $this->imap->move_message($msguid, $target_folder->name, $this->name);
             $this->cache->imap_mode(false);
 
             if ($result) {
                 $new_uid = ($copyuid = $this->imap->conn->data['COPYUID']) ? $copyuid[1] : null;
                 $this->cache->move($msguid, $uid, $target_folder, $new_uid);
                 return true;
             }
             else {
                 rcube::raise_error(array(
                     'code' => 600, 'type' => 'php',
                     'file' => __FILE__, 'line' => __LINE__,
                     'message' => "Failed to move message $msguid to $target_folder: " . $this->imap->get_error_str(),
                 ), true);
             }
         }
 
         return false;
     }
 
     /**
      * Creates source of the configuration object message
      *
      * @param array  $object    The array that holds the data of the object.
      * @param string $type      The type of the kolab object.
      * @param bool   $binary    Enables use of binary encoding of attachment(s)
      * @param string $body_file Reference to filename of message body
      *
      * @return mixed Message as string or array with two elements
      *               (one for message file path, second for message headers)
      */
     private function build_message(&$object, $type, $binary, &$body_file)
     {
         // load old object to preserve data we don't understand/process
         if (is_object($object['_formatobj']))
             $format = $object['_formatobj'];
         else if ($object['_msguid'] && ($old = $this->cache->get($object['_msguid'], $type, $object['_mailbox'])))
             $format = $old['_formatobj'];
 
         // create new kolab_format instance
         if (!$format)
             $format = kolab_format::factory($type, kolab_storage::$version);
 
         if (PEAR::isError($format))
             return false;
 
         $format->set($object);
         $xml = $format->write(kolab_storage::$version);
         $object['uid'] = $format->uid;  // read UID from format
         $object['_formatobj'] = $format;
 
         if (empty($xml) || !$format->is_valid() || empty($object['uid'])) {
             return false;
         }
 
         $mime     = new Mail_mime("\r\n");
         $rcmail   = rcube::get_instance();
         $headers  = array();
         $files    = array();
         $part_id  = 1;
         $encoding = $binary ? 'binary' : 'base64';
 
         if ($user_email = $rcmail->get_user_email()) {
             $headers['From'] = $user_email;
             $headers['To'] = $user_email;
         }
         $headers['Date'] = date('r');
         $headers['X-Kolab-Type'] = kolab_format::KTYPE_PREFIX . $type;
         $headers['X-Kolab-Mime-Version'] = kolab_storage::$version;
         $headers['Subject'] = $object['uid'];
 //        $headers['Message-ID'] = $rcmail->gen_message_id();
         $headers['User-Agent'] = $rcmail->config->get('useragent');
 
         // Check if we have enough memory to handle the message in it
         // It's faster than using files, so we'll do this if we only can
         if (!empty($object['_attachments']) && ($mem_limit = parse_bytes(ini_get('memory_limit'))) > 0) {
             $memory = function_exists('memory_get_usage') ? memory_get_usage() : 16*1024*1024; // safe value: 16MB
 
             foreach ($object['_attachments'] as $attachment) {
                 $memory += $attachment['size'];
             }
 
             // 1.33 is for base64, we need at least 4x more memory than the message size
             if ($memory * ($binary ? 1 : 1.33) * 4 > $mem_limit) {
                 $marker   = '%%%~~~' . md5(microtime(true) . $memory) . '~~~%%%';
                 $is_file  = true;
                 $temp_dir = unslashify($rcmail->config->get('temp_dir'));
                 $mime->setParam('delay_file_io', true);
             }
         }
 
         $mime->headers($headers);
         $mime->setTXTBody("This is a Kolab Groupware object. "
             . "To view this object you will need an email client that understands the Kolab Groupware format. "
             . "For a list of such email clients please visit http://www.kolab.org/\n\n");
 
         $ctype = kolab_storage::$version == '2.0' ? $format->CTYPEv2 : $format->CTYPE;
         // Convert new lines to \r\n, to wrokaround "NO Message contains bare newlines"
         // when APPENDing from temp file
         $xml = preg_replace('/\r?\n/', "\r\n", $xml);
 
         $mime->addAttachment($xml,  // file
             $ctype,                 // content-type
             'kolab.xml',            // filename
             false,                  // is_file
             '8bit',                 // encoding
             'attachment',           // disposition
             RCUBE_CHARSET           // charset
         );
         $part_id++;
 
         // save object attachments as separate parts
         foreach ((array)$object['_attachments'] as $key => $att) {
             if (empty($att['content']) && !empty($att['id'])) {
                 // @TODO: use IMAP CATENATE to skip attachment fetch+push operation
                 $msguid = $object['_copyfrom'] ?: ($object['_msguid'] ?: $object['uid']);
                 if ($is_file) {
                     $att['path'] = tempnam($temp_dir, 'rcmAttmnt');
                     if (($fp = fopen($att['path'], 'w')) && $this->get_attachment($msguid, $att['id'], $object['_mailbox'], false, $fp, true)) {
                         fclose($fp);
                     }
                     else {
                         return false;
                     }
                 }
                 else {
                     $att['content'] = $this->get_attachment($msguid, $att['id'], $object['_mailbox'], false, null, true);
                 }
             }
 
             $headers = array('Content-ID' => Mail_mimePart::encodeHeader('Content-ID', '<' . $key . '>', RCUBE_CHARSET, 'quoted-printable'));
             $name = !empty($att['name']) ? $att['name'] : $key;
 
             // To store binary files we can use faster method
             // without writting full message content to a temporary file but
             // directly to IMAP, see rcube_imap_generic::append().
             // I.e. use file handles where possible
             if (!empty($att['path'])) {
                 if ($is_file && $binary) {
                     $files[] = fopen($att['path'], 'r');
                     $mime->addAttachment($marker, $att['mimetype'], $name, false, $encoding, 'attachment', '', '', '', null, null, '', RCUBE_CHARSET, $headers);
                 }
                 else {
                     $mime->addAttachment($att['path'], $att['mimetype'], $name, true, $encoding, 'attachment', '', '', '', null, null, '', RCUBE_CHARSET, $headers);
                 }
             }
             else {
                 if (is_resource($att['content']) && $is_file && $binary) {
                     $files[] = $att['content'];
                     $mime->addAttachment($marker, $att['mimetype'], $name, false, $encoding, 'attachment', '', '', '', null, null, '', RCUBE_CHARSET, $headers);
                 }
                 else {
                     if (is_resource($att['content'])) {
                         @rewind($att['content']);
                         $att['content'] = stream_get_contents($att['content']);
                     }
                     $mime->addAttachment($att['content'], $att['mimetype'], $name, false, $encoding, 'attachment', '', '', '', null, null, '', RCUBE_CHARSET, $headers);
                 }
             }
 
             $object['_attachments'][$key]['id'] = ++$part_id;
         }
 
         if (!$is_file || !empty($files)) {
             $message = $mime->getMessage();
         }
 
         // parse message and build message array with
         // attachment file pointers in place of file markers
         if (!empty($files)) {
             $message = explode($marker, $message);
             $tmp     = array();
 
             foreach ($message as $msg_part) {
                 $tmp[] = $msg_part;
                 if ($file = array_shift($files)) {
                     $tmp[] = $file;
                 }
             }
             $message = $tmp;
         }
         // write complete message body into temp file
         else if ($is_file) {
             // use common temp dir
             $body_file = tempnam($temp_dir, 'rcmMsg');
 
             if (PEAR::isError($mime_result = $mime->saveMessageBody($body_file))) {
                 rcube::raise_error(array('code' => 650, 'type' => 'php',
                     'file' => __FILE__, 'line' => __LINE__,
                     'message' => "Could not create message: ".$mime_result->getMessage()),
                     true, false);
                 return false;
             }
 
             $message = array(trim($mime->txtHeaders()) . "\r\n\r\n", fopen($body_file, 'r'));
         }
 
         return $message;
     }
 
     /**
      * Triggers any required updates after changes within the
      * folder. This is currently only required for handling free/busy
      * information with Kolab.
      *
      * @return boolean|PEAR_Error True if successfull.
      */
     public function trigger()
     {
         $owner = $this->get_owner();
         $result = false;
 
         switch($this->type) {
         case 'event':
             if ($this->get_namespace() == 'personal') {
                 $result = $this->trigger_url(
                     sprintf('%s/trigger/%s/%s.pfb',
                         kolab_storage::get_freebusy_server(),
                         urlencode($owner),
                         urlencode($this->imap->mod_folder($this->name))
                     ),
                     $this->imap->options['user'],
                     $this->imap->options['password']
                 );
             }
             break;
 
         default:
             return true;
         }
 
         if ($result && is_object($result) && is_a($result, 'PEAR_Error')) {
             return PEAR::raiseError(sprintf("Failed triggering folder %s. Error was: %s",
                                             $this->name, $result->getMessage()));
         }
 
         return $result;
     }
 
     /**
      * Triggers a URL.
      *
      * @param string $url          The URL to be triggered.
      * @param string $auth_user    Username to authenticate with
      * @param string $auth_passwd  Password for basic auth
      * @return boolean|PEAR_Error  True if successfull.
      */
     private function trigger_url($url, $auth_user = null, $auth_passwd = null)
     {
         try {
             $request = libkolab::http_request($url);
 
             // set authentication credentials
             if ($auth_user && $auth_passwd)
                 $request->setAuth($auth_user, $auth_passwd);
 
             $result = $request->send();
             // rcube::write_log('trigger', $result->getBody());
         }
         catch (Exception $e) {
             return PEAR::raiseError($e->getMessage());
         }
 
         return true;
     }
 }
diff --git a/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php b/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
index 1bfff58b..73142be3 100644
--- a/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
+++ b/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
@@ -1,1724 +1,1724 @@
 <?php
 
 /**
  * Kolab Groupware driver for the Tasklist plugin
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2012-2015, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class tasklist_kolab_driver extends tasklist_driver
 {
     // features supported by the backend
     public $alarms      = false;
     public $attachments = true;
     public $attendees   = true;
     public $undelete    = false; // task undelete action
     public $alarm_types = array('DISPLAY','AUDIO');
     public $search_more_results;
 
     private $rc;
     private $plugin;
     private $lists;
     private $folders = array();
     private $tasks   = array();
     private $tags    = array();
     private $bonnie_api = false;
 
 
     /**
      * Default constructor
      */
     public function __construct($plugin)
     {
         $this->rc     = $plugin->rc;
         $this->plugin = $plugin;
 
         if (kolab_storage::$version == '2.0') {
             $this->alarm_absolute = false;
         }
 
         // tasklist use fully encoded identifiers
         kolab_storage::$encode_ids = true;
 
         // get configuration for the Bonnie API
         $this->bonnie_api = libkolab::get_bonnie_api();
 
         $this->plugin->register_action('folder-acl', array($this, 'folder_acl'));
     }
 
     /**
      * Read available calendars for the current user and store them internally
      */
     private function _read_lists($force = false)
     {
         // already read sources
         if (isset($this->lists) && !$force) {
             return $this->lists;
         }
 
         // get all folders that have type "task"
         $folders = kolab_storage::sort_folders(kolab_storage::get_folders('task'));
         $this->lists = $this->folders = array();
 
         $delim = $this->rc->get_storage()->get_hierarchy_delimiter();
 
         // find default folder
         $default_index = 0;
         foreach ($folders as $i => $folder) {
             if ($folder->default && strpos($folder->name, $delim) === false)
                 $default_index = $i;
         }
 
         // put default folder (aka INBOX) on top of the list
         if ($default_index > 0) {
             $default_folder = $folders[$default_index];
             unset($folders[$default_index]);
             array_unshift($folders, $default_folder);
         }
 
         $prefs = $this->rc->config->get('kolab_tasklists', array());
 
         foreach ($folders as $folder) {
             $tasklist = $this->folder_props($folder, $prefs);
 
             $this->lists[$tasklist['id']] = $tasklist;
             $this->folders[$tasklist['id']] = $folder;
             $this->folders[$folder->name] = $folder;
         }
 
         return $this->lists;
     }
 
     /**
      * Derive list properties from the given kolab_storage_folder object
      */
     protected function folder_props($folder, $prefs)
     {
         if ($folder->get_namespace() == 'personal') {
             $norename = false;
             $editable = true;
             $rights = 'lrswikxtea';
             $alarms = true;
         }
         else {
             $alarms = false;
             $rights = 'lr';
             $editable = false;
             if ($myrights = $folder->get_myrights()) {
                 $rights = $myrights;
                 if (strpos($rights, 't') !== false || strpos($rights, 'd') !== false)
                     $editable = strpos($rights, 'i') !== false;
             }
             $info = $folder->get_folder_info();
             $norename = $readonly || $info['norename'] || $info['protected'];
         }
 
         $list_id = $folder->id; #kolab_storage::folder_id($folder->name);
         $old_id = kolab_storage::folder_id($folder->name, false);
 
         if (!isset($prefs[$list_id]['showalarms']) && isset($prefs[$old_id]['showalarms'])) {
             $prefs[$list_id]['showalarms'] = $prefs[$old_id]['showalarms'];
         }
 
         return array(
             'id' => $list_id,
             'name' => $folder->get_name(),
             'listname' => $folder->get_foldername(),
             'editname' => $folder->get_foldername(),
             'color' => $folder->get_color('0000CC'),
             'showalarms' => isset($prefs[$list_id]['showalarms']) ? $prefs[$list_id]['showalarms'] : $alarms,
             'editable' => $editable,
             'rights'    => $rights,
             'norename' => $norename,
             'active' => $folder->is_active(),
             'owner' => $folder->get_owner(),
             'parentfolder' => $folder->get_parent(),
             'default' => $folder->default,
             'virtual' => $folder->virtual,
             'children' => true,  // TODO: determine if that folder indeed has child folders
             'subscribed' => (bool)$folder->is_subscribed(),
             'removable' => !$folder->default,
             'subtype'  => $folder->subtype,
             'group' => $folder->default ? 'default' : $folder->get_namespace(),
             'class' => trim($folder->get_namespace() . ($folder->default ? ' default' : '')),
             'caldavuid' => $folder->get_uid(),
             'history' => !empty($this->bonnie_api),
         );
     }
 
     /**
      * Get a list of available task lists from this source
      *
      * @param integer Bitmask defining filter criterias.
      *                See FILTER_* constants for possible values.
      */
     public function get_lists($filter = 0, &$tree = null)
     {
         $this->_read_lists();
 
         // attempt to create a default list for this user
         if (empty($this->lists) && !isset($this->search_more_results)) {
             $prop = array('name' => 'Tasks', 'color' => '0000CC', 'default' => true);
             if ($this->create_list($prop))
                 $this->_read_lists(true);
         }
 
         $folders = $this->filter_folders($filter);
 
         // include virtual folders for a full folder tree
         if (!is_null($tree)) {
             $folders = kolab_storage::folder_hierarchy($folders, $tree);
         }
 
         $delim = $this->rc->get_storage()->get_hierarchy_delimiter();
         $prefs = $this->rc->config->get('kolab_tasklists', array());
 
         $lists = array();
         foreach ($folders as $folder) {
             $list_id   = $folder->id; // kolab_storage::folder_id($folder->name);
             $imap_path = explode($delim, $folder->name);
 
             // find parent
             do {
               array_pop($imap_path);
               $parent_id = kolab_storage::folder_id(join($delim, $imap_path));
             }
             while (count($imap_path) > 1 && !$this->folders[$parent_id]);
 
             // restore "real" parent ID
             if ($parent_id && !$this->folders[$parent_id]) {
                 $parent_id = kolab_storage::folder_id($folder->get_parent());
             }
 
             $fullname = $folder->get_name();
             $listname = $folder->get_foldername();
 
             // special handling for virtual folders
             if ($folder instanceof kolab_storage_folder_user) {
                 $lists[$list_id] = array(
                     'id'       => $list_id,
                     'name'     => $fullname,
                     'listname' => $listname,
                     'title'    => $folder->get_title(),
                     'virtual'  => true,
                     'editable' => false,
                     'rights'   => 'l',
                     'group'    => 'other virtual',
                     'class'    => 'user',
                     'parent'   => $parent_id,
                 );
             }
             else if ($folder->virtual) {
                 $lists[$list_id] = array(
                     'id'       => $list_id,
                     'name'     => $fullname,
                     'listname' => $listname,
                     'virtual'  => true,
                     'editable' => false,
                     'rights'   => 'l',
                     'group'    => $folder->get_namespace(),
                     'class'    => 'folder',
                     'parent'   => $parent_id,
                 );
             }
             else {
                 if (!$this->lists[$list_id]) {
                     $this->lists[$list_id] = $this->folder_props($folder, $prefs);
                     $this->folders[$list_id] = $folder;
                 }
                 $this->lists[$list_id]['parent'] = $parent_id;
                 $lists[$list_id] = $this->lists[$list_id];
             }
         }
 
         return $lists;
     }
 
     /**
      * Get list of folders according to specified filters
      *
      * @param integer Bitmask defining restrictions. See FILTER_* constants for possible values.
      *
      * @return array List of task folders
      */
     protected function filter_folders($filter)
     {
         $this->_read_lists();
 
         $folders = array();
         foreach ($this->lists as $id => $list) {
             if (!empty($this->folders[$id])) {
                 $folder = $this->folders[$id];
 
                 if ($folder->get_namespace() == 'personal') {
                     $folder->editable = true;
                 }
                 else if ($rights = $folder->get_myrights()) {
                     if (strpos($rights, 't') !== false || strpos($rights, 'd') !== false) {
                         $folder->editable = strpos($rights, 'i') !== false;
                     }
                 }
 
                 $folders[] = $folder;
             }
         }
 
         $plugin = $this->rc->plugins->exec_hook('tasklist_list_filter', array(
             'list'      => $folders,
             'filter'    => $filter,
             'tasklists' => $folders,
         ));
 
         if ($plugin['abort'] || !$filter) {
             return $plugin['tasklists'];
         }
 
         $personal = $filter & self::FILTER_PERSONAL;
         $shared   = $filter & self::FILTER_SHARED;
 
         $tasklists = array();
         foreach ($folders as $folder) {
             if (($filter & self::FILTER_WRITEABLE) && !$folder->editable) {
                 continue;
             }
 /*
             if (($filter & self::FILTER_INSERTABLE) && !$folder->insert) {
                 continue;
             }
             if (($filter & self::FILTER_ACTIVE) && !$folder->is_active()) {
                 continue;
             }
             if (($filter & self::FILTER_PRIVATE) && $folder->subtype != 'private') {
                 continue;
             }
             if (($filter & self::FILTER_CONFIDENTIAL) && $folder->subtype != 'confidential') {
                 continue;
             }
 */
             if ($personal || $shared) {
                 $ns = $folder->get_namespace();
                 if (!(($personal && $ns == 'personal') || ($shared && $ns == 'shared'))) {
                     continue;
                 }
             }
 
             $tasklists[$folder->id] = $folder;
         }
 
         return $tasklists;
     }
 
     /**
      * Get the kolab_calendar instance for the given calendar ID
      *
      * @param string List identifier (encoded imap folder name)
      * @return object kolab_storage_folder Object nor null if list doesn't exist
      */
     protected function get_folder($id)
     {
         $this->_read_lists();
 
         // create list and folder instance if necesary
         if (!$this->lists[$id]) {
             $folder = kolab_storage::get_folder(kolab_storage::id_decode($id));
             if ($folder->type) {
                 $this->folders[$id] = $folder;
                 $this->lists[$id] = $this->folder_props($folder, $this->rc->config->get('kolab_tasklists', array()));
             }
         }
 
         return $this->folders[$id];
     }
 
 
     /**
      * Create a new list assigned to the current user
      *
      * @param array Hash array with list properties
      *        name: List name
      *       color: The color of the list
      *  showalarms: True if alarms are enabled
      * @return mixed ID of the new list on success, False on error
      */
     public function create_list(&$prop)
     {
         $prop['type'] = 'task' . ($prop['default'] ? '.default' : '');
         $prop['active'] = true; // activate folder by default
         $prop['subscribed'] = true;
         $folder = kolab_storage::folder_update($prop);
 
         if ($folder === false) {
             $this->last_error = kolab_storage::$last_error;
             return false;
         }
 
         // create ID
         $id = kolab_storage::folder_id($folder);
 
         $prefs['kolab_tasklists'] = $this->rc->config->get('kolab_tasklists', array());
 
         if (isset($prop['showalarms']))
             $prefs['kolab_tasklists'][$id]['showalarms'] = $prop['showalarms'] ? true : false;
 
         if ($prefs['kolab_tasklists'][$id])
             $this->rc->user->save_prefs($prefs);
 
         // force page reload to properly render folder hierarchy
         if (!empty($prop['parent'])) {
             $prop['_reload'] = true;
         }
         else {
             $folder = kolab_storage::get_folder($folder);
             $prop += $this->folder_props($folder, array());
         }
 
         return $id;
     }
 
     /**
      * Update properties of an existing tasklist
      *
      * @param array Hash array with list properties
      *          id: List Identifier
      *        name: List name
      *       color: The color of the list
      *  showalarms: True if alarms are enabled (if supported)
      * @return boolean True on success, Fales on failure
      */
     public function edit_list(&$prop)
     {
         if ($prop['id'] && ($folder = $this->get_folder($prop['id']))) {
             $prop['oldname'] = $folder->name;
             $prop['type'] = 'task';
             $newfolder = kolab_storage::folder_update($prop);
 
             if ($newfolder === false) {
                 $this->last_error = kolab_storage::$last_error;
                 return false;
             }
 
             // create ID
             $id = kolab_storage::folder_id($newfolder);
 
             // fallback to local prefs
             $prefs['kolab_tasklists'] = $this->rc->config->get('kolab_tasklists', array());
             unset($prefs['kolab_tasklists'][$prop['id']]);
 
             if (isset($prop['showalarms']))
                 $prefs['kolab_tasklists'][$id]['showalarms'] = $prop['showalarms'] ? true : false;
 
             if ($prefs['kolab_tasklists'][$id])
                 $this->rc->user->save_prefs($prefs);
 
             // force page reload if folder name/hierarchy changed
             if ($newfolder != $prop['oldname'])
                 $prop['_reload'] = true;
 
             return $id;
         }
 
         return false;
     }
 
     /**
      * Set active/subscribed state of a list
      *
      * @param array Hash array with list properties
      *          id: List Identifier
      *      active: True if list is active, false if not
      *   permanent: True if list is to be subscribed permanently
      * @return boolean True on success, Fales on failure
      */
     public function subscribe_list($prop)
     {
         if ($prop['id'] && ($folder = $this->get_folder($prop['id']))) {
             $ret = false;
             if (isset($prop['permanent']))
                 $ret |= $folder->subscribe(intval($prop['permanent']));
             if (isset($prop['active']))
                 $ret |= $folder->activate(intval($prop['active']));
 
             // apply to child folders, too
             if ($prop['recursive']) {
                 foreach ((array)kolab_storage::list_folders($folder->name, '*', 'task') as $subfolder) {
                     if (isset($prop['permanent']))
                         ($prop['permanent'] ? kolab_storage::folder_subscribe($subfolder) : kolab_storage::folder_unsubscribe($subfolder));
                     if (isset($prop['active']))
                         ($prop['active'] ? kolab_storage::folder_activate($subfolder) : kolab_storage::folder_deactivate($subfolder));
                 }
             }
 
             return $ret;
         }
 
         return false;
     }
 
     /**
      * Delete the given list with all its contents
      *
      * @param array Hash array with list properties
      *      id: list Identifier
      * @return boolean True on success, Fales on failure
      */
     public function delete_list($prop)
     {
         if ($prop['id'] && ($folder = $this->get_folder($prop['id']))) {
             if (kolab_storage::folder_delete($folder->name)) {
                 return true;
             }
 
             $this->last_error = kolab_storage::$last_error;
         }
 
         return false;
     }
 
     /**
      * Search for shared or otherwise not listed tasklists the user has access
      *
      * @param string Search string
      * @param string Section/source to search
      * @return array List of tasklists
      */
     public function search_lists($query, $source)
     {
         if (!kolab_storage::setup()) {
             return array();
         }
 
         $this->search_more_results = false;
         $this->lists = $this->folders = array();
 
         // find unsubscribed IMAP folders that have "event" type
         if ($source == 'folders') {
             foreach ((array)kolab_storage::search_folders('task', $query, array('other')) as $folder) {
                 $this->folders[$folder->id] = $folder;
                 $this->lists[$folder->id] = $this->folder_props($folder, array());
             }
         }
         // search other user's namespace via LDAP
         else if ($source == 'users') {
             $limit = $this->rc->config->get('autocomplete_max', 15) * 2;  // we have slightly more space, so display twice the number
             foreach (kolab_storage::search_users($query, 0, array(), $limit * 10) as $user) {
                 $folders = array();
                 // search for tasks folders shared by this user
                 foreach (kolab_storage::list_user_folders($user, 'task', false) as $foldername) {
                     $folders[] = new kolab_storage_folder($foldername, 'task');
                 }
 
                 if (count($folders)) {
                     $userfolder = new kolab_storage_folder_user($user['kolabtargetfolder'], '', $user);
                     $this->folders[$userfolder->id] = $userfolder;
                     $this->lists[$userfolder->id] = $this->folder_props($userfolder, array());
 
                     foreach ($folders as $folder) {
                         $this->folders[$folder->id] = $folder;
                         $this->lists[$folder->id] = $this->folder_props($folder, array());
                         $count++;
                     }
                 }
 
                 if ($count >= $limit) {
                     $this->search_more_results = true;
                     break;
                 }
             }
         }
 
         return $this->get_lists();
     }
 
     /**
      * Get a list of tags to assign tasks to
      *
      * @return array List of tags
      */
     public function get_tags()
     {
         $config = kolab_storage_config::get_instance();
         $tags   = $config->get_tags();
         $backend_tags = array_map(function($v) { return $v['name']; }, $tags);
 
         return array_values(array_unique(array_merge($this->tags, $backend_tags)));
     }
 
     /**
      * Get number of tasks matching the given filter
      *
      * @param array List of lists to count tasks of
      * @return array Hash array with counts grouped by status (all|flagged|completed|today|tomorrow|nodate)
      */
     public function count_tasks($lists = null)
     {
         if (empty($lists)) {
             $lists = $this->_read_lists();
             $lists = array_keys($lists);
         }
         else if (is_string($lists)) {
             $lists = explode(',', $lists);
         }
 
         $today_date    = new DateTime('now', $this->plugin->timezone);
         $today         = $today_date->format('Y-m-d');
         $tomorrow_date = new DateTime('now + 1 day', $this->plugin->timezone);
         $tomorrow      = $tomorrow_date->format('Y-m-d');
 
         $counts = array('all' => 0, 'today' => 0, 'tomorrow' => 0, 'later' => 0, 'overdue'  => 0);
 
         foreach ($lists as $list_id) {
             if (!$folder = $this->get_folder($list_id)) {
                 continue;
             }
 
-            foreach ($folder->select(array(array('tags','!~','x-complete'))) as $record) {
+            foreach ($folder->select(array(array('tags','!~','x-complete')), true) as $record) {
                 $rec = $this->_to_rcube_task($record, $list_id, false);
 
                 if ($this->is_complete($rec))  // don't count complete tasks
                     continue;
 
                 $counts['all']++;
                 if (empty($rec['date']))
                     $counts['later']++;
                 else if ($rec['date'] == $today)
                     $counts['today']++;
                 else if ($rec['date'] == $tomorrow)
                     $counts['tomorrow']++;
                 else if ($rec['date'] < $today)
                     $counts['overdue']++;
                 else if ($rec['date'] > $tomorrow)
                     $counts['later']++;
             }
         }
 
         // avoid session race conditions that will loose temporary subscriptions
         $this->plugin->rc->session->nowrite = true;
 
         return $counts;
     }
 
     /**
      * Get all task records matching the given filter
      *
      * @param array Hash array with filter criterias:
      *  - mask:  Bitmask representing the filter selection (check against tasklist::FILTER_MASK_* constants)
      *  - from:  Date range start as string (Y-m-d)
      *  - to:    Date range end as string (Y-m-d)
      *  - search: Search query string
      *  - uid:   Task UIDs
      * @param array List of lists to get tasks from
      * @return array List of tasks records matchin the criteria
      */
     public function list_tasks($filter, $lists = null)
     {
         if (empty($lists)) {
             $lists = $this->_read_lists();
             $lists = array_keys($lists);
         }
         else if (is_string($lists)) {
             $lists = explode(',', $lists);
         }
 
         $config  = kolab_storage_config::get_instance();
         $results = array();
 
         // query Kolab storage
         $query = array();
         if ($filter['mask'] & tasklist::FILTER_MASK_COMPLETE)
             $query[] = array('tags','~','x-complete');
         else if (empty($filter['since']))
             $query[] = array('tags','!~','x-complete');
 
         // full text search (only works with cache enabled)
         if ($filter['search']) {
             $search = mb_strtolower($filter['search']);
             foreach (rcube_utils::normalize_string($search, true) as $word) {
                 $query[] = array('words', '~', $word);
             }
         }
 
         if ($filter['since']) {
             $query[] = array('changed', '>=', $filter['since']);
         }
 
         if ($filter['uid']) {
             $query[] = array('uid', '=', (array) $filter['uid']);
         }
 
         foreach ($lists as $list_id) {
             if (!$folder = $this->get_folder($list_id)) {
                 continue;
             }
 
             foreach ($folder->select($query) as $record) {
                 // TODO: post-filter tasks returned from storage
                 $record['list_id'] = $list_id;
                 $results[] = $record;
             }
         }
 
         $config->apply_tags($results, true);
         $config->apply_links($results);
 
         foreach (array_keys($results) as $idx) {
             $results[$idx] = $this->_to_rcube_task($results[$idx], $results[$idx]['list_id']);
         }
 
         // avoid session race conditions that will loose temporary subscriptions
         $this->plugin->rc->session->nowrite = true;
 
         return $results;
     }
 
     /**
      * Return data of a specific task
      *
      * @param mixed   Hash array with task properties or task UID
      * @param integer Bitmask defining filter criterias for folders.
      *                See FILTER_* constants for possible values.
      *
      * @return array Hash array with task properties or false if not found
      */
     public function get_task($prop, $filter = 0)
     {
         $this->_parse_id($prop);
 
         $id      = $prop['uid'];
         $list_id = $prop['list'];
         $folders = $list_id ? array($list_id => $this->get_folder($list_id)) : $this->get_lists($filter);
 
         // find task in the available folders
         foreach ($folders as $list_id => $folder) {
             if (is_array($folder))
                 $folder = $this->folders[$list_id];
             if (is_numeric($list_id) || !$folder)
                 continue;
             if (!$this->tasks[$id] && ($object = $folder->get_object($id))) {
                 $this->load_tags($object);
                 $this->tasks[$id] = $this->_to_rcube_task($object, $list_id);
                 break;
             }
         }
 
         return $this->tasks[$id];
     }
 
     /**
      * Get all decendents of the given task record
      *
      * @param mixed  Hash array with task properties or task UID
      * @param boolean True if all childrens children should be fetched
      * @return array List of all child task IDs
      */
     public function get_childs($prop, $recursive = false)
     {
         if (is_string($prop)) {
             $task = $this->get_task($prop);
             $prop = array('uid' => $task['uid'], 'list' => $task['list']);
         }
         else {
             $this->_parse_id($prop);
         }
 
         $childs = array();
         $list_id = $prop['list'];
         $task_ids = array($prop['uid']);
         $folder = $this->get_folder($list_id);
 
         // query for childs (recursively)
         while ($folder && !empty($task_ids)) {
             $query_ids = array();
             foreach ($task_ids as $task_id) {
                 $query = array(array('tags','=','x-parent:' . $task_id));
                 foreach ($folder->select($query) as $record) {
                     // don't rely on kolab_storage_folder filtering
                     if ($record['parent_id'] == $task_id) {
                         $childs[] = $list_id . ':' . $record['uid'];
                         $query_ids[] = $record['uid'];
                     }
                 }
             }
 
             if (!$recursive)
                 break;
 
             $task_ids = $query_ids;
         }
 
         return $childs;
     }
 
     /**
      * Provide a list of revisions for the given task
      *
      * @param array  $task Hash array with task properties
      * @return array List of changes, each as a hash array
      * @see tasklist_driver::get_task_changelog()
      */
     public function get_task_changelog($prop)
     {
         if (empty($this->bonnie_api)) {
             return false;
         }
 
         list($uid, $mailbox, $msguid) = $this->_resolve_task_identity($prop);
 
         $result = $uid && $mailbox ? $this->bonnie_api->changelog('task', $uid, $mailbox, $msguid) : null;
         if (is_array($result) && $result['uid'] == $uid) {
             return $result['changes'];
         }
 
         return false;
     }
 
     /**
      * Return full data of a specific revision of an event
      *
      * @param mixed  $task UID string or hash array with task properties
      * @param mixed  $rev Revision number
      *
      * @return array Task object as hash array
      * @see tasklist_driver::get_task_revision()
      */
     public function get_task_revison($prop, $rev)
     {
         if (empty($this->bonnie_api)) {
             return false;
         }
 
         $this->_parse_id($prop);
         $uid     = $prop['uid'];
         $list_id = $prop['list'];
         list($uid, $mailbox, $msguid) = $this->_resolve_task_identity($prop);
 
         // call Bonnie API
         $result = $this->bonnie_api->get('task', $uid, $rev, $mailbox, $msguid);
         if (is_array($result) && $result['uid'] == $uid && !empty($result['xml'])) {
             $format = kolab_format::factory('task');
             $format->load($result['xml']);
             $rec = $format->to_array();
             $format->get_attachments($rec, true);
 
             if ($format->is_valid()) {
                 $rec = self::_to_rcube_task($rec, $list_id, false);
                 $rec['rev'] = $result['rev'];
                 return $rec;
             }
         }
 
         return false;
     }
 
     /**
      * Command the backend to restore a certain revision of a task.
      * This shall replace the current object with an older version.
      *
      * @param mixed  $task UID string or hash array with task properties
      * @param mixed  $rev Revision number
      *
      * @return boolean True on success, False on failure
      * @see tasklist_driver::restore_task_revision()
      */
     public function restore_task_revision($prop, $rev)
     {
         if (empty($this->bonnie_api)) {
             return false;
         }
 
         $this->_parse_id($prop);
         $uid     = $prop['uid'];
         $list_id = $prop['list'];
         list($uid, $mailbox, $msguid) = $this->_resolve_task_identity($prop);
 
         $folder  = $this->get_folder($list_id);
         $success = false;
 
         if ($folder && ($raw_msg = $this->bonnie_api->rawdata('task', $uid, $rev, $mailbox))) {
             $imap = $this->rc->get_storage();
 
             // insert $raw_msg as new message
             if ($imap->save_message($folder->name, $raw_msg, null, false)) {
                 $success = true;
 
                 // delete old revision from imap and cache
                 $imap->delete_message($msguid, $folder->name);
                 $folder->cache->set($msguid, false);
             }
         }
 
         return $success;
     }
 
     /**
      * Get a list of property changes beteen two revisions of a task object
      *
      * @param array  $task Hash array with task properties
      * @param mixed  $rev   Revisions: "from:to"
      *
      * @return array List of property changes, each as a hash array
      * @see tasklist_driver::get_task_diff()
      */
     public function get_task_diff($prop, $rev1, $rev2)
     {
         $this->_parse_id($prop);
         $uid     = $prop['uid'];
         $list_id = $prop['list'];
         list($uid, $mailbox, $msguid) = $this->_resolve_task_identity($prop);
 
         // call Bonnie API
         $result = $this->bonnie_api->diff('task', $uid, $rev1, $rev2, $mailbox, $msguid, $instance_id);
         if (is_array($result) && $result['uid'] == $uid) {
             $result['rev1'] = $rev1;
             $result['rev2'] = $rev2;
 
             $keymap = array(
                 'start'    => 'start',
                 'due'      => 'date',
                 'dstamp'   => 'changed',
                 'summary'  => 'title',
                 'alarm'    => 'alarms',
                 'attendee' => 'attendees',
                 'attach'   => 'attachments',
                 'rrule'    => 'recurrence',
                 'related-to' => 'parent_id',
                 'percent-complete' => 'complete',
                 'lastmodified-date' => 'changed',
             );
             $prop_keymaps = array(
                 'attachments' => array('fmttype' => 'mimetype', 'label' => 'name'),
                 'attendees'   => array('partstat' => 'status'),
             );
             $special_changes = array();
 
             // map kolab event properties to keys the client expects
             array_walk($result['changes'], function(&$change, $i) use ($keymap, $prop_keymaps, $special_changes) {
                 if (array_key_exists($change['property'], $keymap)) {
                     $change['property'] = $keymap[$change['property']];
                 }
                 if ($change['property'] == 'priority') {
                     $change['property'] = 'flagged';
                     $change['old'] = $change['old'] == 1 ? $this->plugin->gettext('yes') : null;
                     $change['new'] = $change['new'] == 1 ? $this->plugin->gettext('yes') : null;
                 }
                 // map alarms trigger value
                 if ($change['property'] == 'alarms') {
                     if (is_array($change['old']) && is_array($change['old']['trigger']))
                         $change['old']['trigger'] = $change['old']['trigger']['value'];
                     if (is_array($change['new']) && is_array($change['new']['trigger']))
                         $change['new']['trigger'] = $change['new']['trigger']['value'];
                 }
                 // make all property keys uppercase
                 if ($change['property'] == 'recurrence') {
                     $special_changes['recurrence'] = $i;
                     foreach (array('old','new') as $m) {
                         if (is_array($change[$m])) {
                             $props = array();
                             foreach ($change[$m] as $k => $v) {
                                 $props[strtoupper($k)] = $v;
                             }
                             $change[$m] = $props;
                         }
                     }
                 }
                 // map property keys names
                 if (is_array($prop_keymaps[$change['property']])) {
                   foreach ($prop_keymaps[$change['property']] as $k => $dest) {
                     if (is_array($change['old']) && array_key_exists($k, $change['old'])) {
                         $change['old'][$dest] = $change['old'][$k];
                         unset($change['old'][$k]);
                     }
                     if (is_array($change['new']) && array_key_exists($k, $change['new'])) {
                         $change['new'][$dest] = $change['new'][$k];
                         unset($change['new'][$k]);
                     }
                   }
                 }
 
                 if ($change['property'] == 'exdate') {
                     $special_changes['exdate'] = $i;
                 }
                 else if ($change['property'] == 'rdate') {
                     $special_changes['rdate'] = $i;
                 }
             });
 
             // merge some recurrence changes
             foreach (array('exdate','rdate') as $prop) {
                 if (array_key_exists($prop, $special_changes)) {
                     $exdate = $result['changes'][$special_changes[$prop]];
                     if (array_key_exists('recurrence', $special_changes)) {
                         $recurrence = &$result['changes'][$special_changes['recurrence']];
                     }
                     else {
                         $i = count($result['changes']);
                         $result['changes'][$i] = array('property' => 'recurrence', 'old' => array(), 'new' => array());
                         $recurrence = &$result['changes'][$i]['recurrence'];
                     }
                     $key = strtoupper($prop);
                     $recurrence['old'][$key] = $exdate['old'];
                     $recurrence['new'][$key] = $exdate['new'];
                     unset($result['changes'][$special_changes[$prop]]);
                 }
             }
 
             return $result;
         }
 
         return false;
     }
 
     /**
      * Helper method to resolved the given task identifier into uid and folder
      *
      * @return array (uid,folder,msguid) tuple
      */
     private function _resolve_task_identity($prop)
     {
         $mailbox = $msguid = null;
 
         $this->_parse_id($prop);
         $uid     = $prop['uid'];
         $list_id = $prop['list'];
 
         if ($folder = $this->get_folder($list_id)) {
             $mailbox = $folder->get_mailbox_id();
 
             // get task object from storage in order to get the real object uid an msguid
             if ($rec = $folder->get_object($uid)) {
                 $msguid = $rec['_msguid'];
                 $uid = $rec['uid'];
             }
         }
 
         return array($uid, $mailbox, $msguid);
     }
 
     /**
      * Get a list of pending alarms to be displayed to the user
      *
      * @param  integer Current time (unix timestamp)
      * @param  mixed   List of list IDs to show alarms for (either as array or comma-separated string)
      * @return array   A list of alarms, each encoded as hash array with task properties
      * @see tasklist_driver::pending_alarms()
      */
     public function pending_alarms($time, $lists = null)
     {
         $interval = 300;
         $time -= $time % 60;
 
         $slot = $time;
         $slot -= $slot % $interval;
 
         $last = $time - max(60, $this->rc->config->get('refresh_interval', 0));
         $last -= $last % $interval;
 
         // only check for alerts once in 5 minutes
         if ($last == $slot)
             return array();
 
         if ($lists && is_string($lists))
             $lists = explode(',', $lists);
 
         $time = $slot + $interval;
 
         $candidates = array();
         $query      = array(
             array('tags', '=', 'x-has-alarms'),
             array('tags', '!=', 'x-complete')
         );
 
         $this->_read_lists();
 
         foreach ($this->lists as $lid => $list) {
             // skip lists with alarms disabled
             if (!$list['showalarms'] || ($lists && !in_array($lid, $lists)))
                 continue;
 
             $folder = $this->get_folder($lid);
             foreach ($folder->select($query) as $record) {
                 if (!($record['valarms'] || $record['alarms']) || $record['status'] == 'COMPLETED' || $record['complete'] == 100)  // don't trust query :-)
                     continue;
 
                 $task = $this->_to_rcube_task($record, $lid, false);
 
                 // add to list if alarm is set
                 $alarm = libcalendaring::get_next_alarm($task, 'task');
                 if ($alarm && $alarm['time'] && $alarm['time'] <= $time && in_array($alarm['action'], $this->alarm_types)) {
                     $id = $alarm['id'];  // use alarm-id as primary identifier
                     $candidates[$id] = array(
                         'id'       => $id,
                         'title'    => $task['title'],
                         'date'     => $task['date'],
                         'time'     => $task['time'],
                         'notifyat' => $alarm['time'],
                         'action'   => $alarm['action'],
                     );
                 }
             }
         }
 
         // get alarm information stored in local database
         if (!empty($candidates)) {
             $alarm_ids = array_map(array($this->rc->db, 'quote'), array_keys($candidates));
             $result = $this->rc->db->query("SELECT *"
                 . " FROM " . $this->rc->db->table_name('kolab_alarms', true)
                 . " WHERE `alarm_id` IN (" . join(',', $alarm_ids) . ")"
                     . " AND `user_id` = ?",
                 $this->rc->user->ID
             );
 
             while ($result && ($rec = $this->rc->db->fetch_assoc($result))) {
                 $dbdata[$rec['alarm_id']] = $rec;
             }
         }
 
         $alarms = array();
         foreach ($candidates as $id => $task) {
           // skip dismissed
           if ($dbdata[$id]['dismissed'])
               continue;
 
           // snooze function may have shifted alarm time
           $notifyat = $dbdata[$id]['notifyat'] ? strtotime($dbdata[$id]['notifyat']) : $task['notifyat'];
           if ($notifyat <= $time)
               $alarms[] = $task;
         }
 
         return $alarms;
     }
 
     /**
      * (User) feedback after showing an alarm notification
      * This should mark the alarm as 'shown' or snooze it for the given amount of time
      *
      * @param  string  Task identifier
      * @param  integer Suspend the alarm for this number of seconds
      */
     public function dismiss_alarm($id, $snooze = 0)
     {
         // delete old alarm entry
         $this->rc->db->query(
             "DELETE FROM " . $this->rc->db->table_name('kolab_alarms', true) . "
              WHERE `alarm_id` = ? AND `user_id` = ?",
             $id,
             $this->rc->user->ID
         );
 
         // set new notifyat time or unset if not snoozed
         $notifyat = $snooze > 0 ? date('Y-m-d H:i:s', time() + $snooze) : null;
 
         $query = $this->rc->db->query(
             "INSERT INTO " . $this->rc->db->table_name('kolab_alarms', true) . "
              (`alarm_id`, `user_id`, `dismissed`, `notifyat`)
              VALUES (?, ?, ?, ?)",
             $id,
             $this->rc->user->ID,
             $snooze > 0 ? 0 : 1,
             $notifyat
         );
 
         return $this->rc->db->affected_rows($query);
     }
 
     /**
      * Remove alarm dismissal or snooze state
      *
      * @param  string  Task identifier
      */
     public function clear_alarms($id)
     {
         // delete alarm entry
         $this->rc->db->query(
             "DELETE FROM " . $this->rc->db->table_name('kolab_alarms', true) . "
              WHERE `alarm_id` = ? AND `user_id` = ?",
             $id,
             $this->rc->user->ID
         );
 
         return true;
     }
 
     /**
      * Get task tags
      */
     private function load_tags(&$object)
     {
         // this task hasn't been migrated yet
         if (!empty($object['categories'])) {
             // OPTIONAL: call kolab_storage_config::apply_tags() to migrate the object
             $object['tags'] = (array)$object['categories'];
             if (!empty($object['tags'])) {
                 $this->tags = array_merge($this->tags, $object['tags']);
             }
         }
         else {
             $config = kolab_storage_config::get_instance();
             $tags   = $config->get_tags($object['uid']);
             $object['tags'] = array_map(function($v) { return $v['name']; }, $tags);
         }
     }
 
     /**
      * Update task tags
      */
     private function save_tags($uid, $tags)
     {
         $config = kolab_storage_config::get_instance();
         $config->save_tags($uid, $tags);
     }
 
     /**
      * Find messages linked with a task record
      */
     private function get_links($uid)
     {
         $config = kolab_storage_config::get_instance();
         return $config->get_object_links($uid);
     }
 
     /**
      *
      */
     private function save_links($uid, $links)
     {
         $config = kolab_storage_config::get_instance();
         return $config->save_object_links($uid, (array) $links);
     }
 
     /**
      * Extract uid + list identifiers from the given input
      *
      * @param mixed array or string with task identifier(s)
      */
     private function _parse_id(&$prop)
     {
         $id_ = null;
         if (is_array($prop)) {
             // 'uid' + 'list' available, nothing to be done
             if (!empty($prop['uid']) && !empty($prop['list'])) {
                 return;
             }
 
             // 'id' is given
             if (!empty($prop['id'])) {
                 if (!empty($prop['list'])) {
                     $list_id = $prop['_fromlist'] ?: $prop['list'];
                     if (strpos($prop['id'], $list_id.':') === 0) {
                         $prop['uid'] = substr($prop['id'], strlen($list_id)+1);
                     }
                     else {
                         $prop['uid'] = $prop['id'];
                     }
                 }
                 else {
                     $id_ = $prop['id'];
                 }
             }
         }
         else {
             $id_ = strval($prop);
             $prop = array();
         }
 
         // split 'id' into list + uid
         if (!empty($id_)) {
             list($list, $uid) = explode(':', $id_, 2);
             if (!empty($uid)) {
                 $prop['uid'] = $uid;
                 $prop['list'] = $list;
             }
             else {
                 $prop['uid'] = $id_;
             }
         }
     }
 
     /**
      * Convert from Kolab_Format to internal representation
      */
     private function _to_rcube_task($record, $list_id, $all = true)
     {
         $id_prefix = $list_id . ':';
         $task = array(
             'id' => $id_prefix . $record['uid'],
             'uid' => $record['uid'],
             'title' => $record['title'],
 //            'location' => $record['location'],
             'description' => $record['description'],
             'flagged' => $record['priority'] == 1,
             'complete' => floatval($record['complete'] / 100),
             'status' => $record['status'],
             'parent_id' => $record['parent_id'] ? $id_prefix . $record['parent_id'] : null,
             'recurrence' => $record['recurrence'],
             'attendees' => $record['attendees'],
             'organizer' => $record['organizer'],
             'sequence' => $record['sequence'],
             'tags' => $record['tags'],
             'list' => $list_id,
             'links' => $record['links'],
         );
 
         // we can sometimes skip this expensive operation
         if ($all && !array_key_exists('links', $task)) {
             $task['links'] = $this->get_links($task['uid']);
         }
 
         // convert from DateTime to internal date format
         if (is_a($record['due'], 'DateTime')) {
             $due = $this->plugin->lib->adjust_timezone($record['due']);
             $task['date'] = $due->format('Y-m-d');
             if (!$record['due']->_dateonly)
                 $task['time'] = $due->format('H:i');
         }
         // convert from DateTime to internal date format
         if (is_a($record['start'], 'DateTime')) {
             $start = $this->plugin->lib->adjust_timezone($record['start']);
             $task['startdate'] = $start->format('Y-m-d');
             if (!$record['start']->_dateonly)
                 $task['starttime'] = $start->format('H:i');
         }
         if (is_a($record['changed'], 'DateTime')) {
             $task['changed'] = $record['changed'];
         }
         if (is_a($record['created'], 'DateTime')) {
             $task['created'] = $record['created'];
         }
 
         if ($record['valarms']) {
             $task['valarms'] = $record['valarms'];
         }
         else if ($record['alarms']) {
             $task['alarms'] = $record['alarms'];
         }
 
         if (!empty($task['attendees'])) {
             foreach ((array)$task['attendees'] as $i => $attendee) {
                 if (is_array($attendee['delegated-from'])) {
                     $task['attendees'][$i]['delegated-from'] = join(', ', $attendee['delegated-from']);
                 }
                 if (is_array($attendee['delegated-to'])) {
                     $task['attendees'][$i]['delegated-to'] = join(', ', $attendee['delegated-to']);
                 }
             }
         }
 
         if (!empty($record['_attachments'])) {
             foreach ($record['_attachments'] as $key => $attachment) {
                 if ($attachment !== false) {
                     if (!$attachment['name'])
                         $attachment['name'] = $key;
                     $attachments[] = $attachment;
                 }
             }
 
             $task['attachments'] = $attachments;
         }
 
         return $task;
     }
 
     /**
      * Convert the given task record into a data structure that can be passed to kolab_storage backend for saving
      * (opposite of self::_to_rcube_event())
      */
     private function _from_rcube_task($task, $old = array())
     {
         $object    = $task;
         $id_prefix = $task['list'] . ':';
 
         if (!empty($task['date'])) {
             $object['due'] = rcube_utils::anytodatetime($task['date'].' '.$task['time'], $this->plugin->timezone);
             if (empty($task['time']))
                 $object['due']->_dateonly = true;
             unset($object['date']);
         }
 
         if (!empty($task['startdate'])) {
             $object['start'] = rcube_utils::anytodatetime($task['startdate'].' '.$task['starttime'], $this->plugin->timezone);
             if (empty($task['starttime']))
                 $object['start']->_dateonly = true;
             unset($object['startdate']);
         }
 
         // as per RFC (and the Kolab schema validation), start and due dates need to be of the same type (#3614)
         // this should be catched in the client already but just make sure we don't write invalid objects
         if (!empty($object['start']) && !empty($object['due']) && $object['due']->_dateonly != $object['start']->_dateonly) {
             $object['start']->_dateonly = true;
             $object['due']->_dateonly = true;
         }
 
         $object['complete'] = $task['complete'] * 100;
         if ($task['complete'] == 1.0 && empty($task['complete']))
             $object['status'] = 'COMPLETED';
 
         if ($task['flagged'])
             $object['priority'] = 1;
         else
             $object['priority'] = $old['priority'] > 1 ? $old['priority'] : 0;
 
         // remove list: prefix from parent_id
         if (!empty($task['parent_id']) && strpos($task['parent_id'], $id_prefix) === 0) {
             $object['parent_id'] = substr($task['parent_id'], strlen($id_prefix));
         }
 
         // copy meta data (starting with _) from old object
         foreach ((array)$old as $key => $val) {
             if (!isset($object[$key]) && $key[0] == '_')
                 $object[$key] = $val;
         }
 
         // copy recurrence rules if the client didn't submit it (#2713)
         if (!array_key_exists('recurrence', $object) && $old['recurrence']) {
             $object['recurrence'] = $old['recurrence'];
         }
 
         unset($task['attachments']);
         kolab_format::merge_attachments($object, $old);
 
         // allow sequence increments if I'm the organizer
         if ($this->plugin->is_organizer($object) && empty($object['_method'])) {
             unset($object['sequence']);
         }
         else if (isset($old['sequence']) && empty($object['_method'])) {
             $object['sequence'] = $old['sequence'];
         }
 
         unset($object['tempid'], $object['raw'], $object['list'], $object['flagged'], $object['tags'], $object['created']);
         return $object;
     }
 
     /**
      * Add a single task to the database
      *
      * @param array Hash array with task properties (see header of tasklist_driver.php)
      * @return mixed New task ID on success, False on error
      */
     public function create_task($task)
     {
         return $this->edit_task($task);
     }
 
     /**
      * Update an task entry with the given data
      *
      * @param array Hash array with task properties (see header of tasklist_driver.php)
      * @return boolean True on success, False on error
      */
     public function edit_task($task)
     {
         $this->_parse_id($task);
         $list_id = $task['list'];
         if (!$list_id || !($folder = $this->get_folder($list_id))) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Invalid list identifer to save task: " . print_r($list_id, true)),
                 true, false);
             return false;
         }
 
         // email links and tags are stored separately
         $links = $task['links'];
         $tags  = $task['tags'];
         unset($task['tags'], $task['links']);
 
         // moved from another folder
         if ($task['_fromlist'] && ($fromfolder = $this->get_folder($task['_fromlist']))) {
             if (!$fromfolder->move($task['uid'], $folder))
                 return false;
 
             unset($task['_fromlist']);
         }
 
         // load previous version of this task to merge
         if ($task['id']) {
             $old = $folder->get_object($task['uid']);
             if (!$old || PEAR::isError($old))
                 return false;
 
             // merge existing properties if the update isn't complete
             if (!isset($task['title']) || !isset($task['complete']))
                 $task += $this->_to_rcube_task($old, $list_id);
         }
 
         // generate new task object from RC input
         $object = $this->_from_rcube_task($task, $old);
         $saved  = $folder->save($object, 'task', $task['uid']);
 
         if (!$saved) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error saving task object to Kolab server"),
                 true, false);
             $saved = false;
         }
         else {
             // save links in configuration.relation object
             $this->save_links($object['uid'], $links);
             // save tags in configuration.relation object
             $this->save_tags($object['uid'], $tags);
 
             $task = $this->_to_rcube_task($object, $list_id);
             $task['tags'] = (array) $tags;
             $this->tasks[$task['uid']] = $task;
         }
 
         return $saved;
     }
 
     /**
      * Move a single task to another list
      *
      * @param array   Hash array with task properties:
      * @return boolean True on success, False on error
      * @see tasklist_driver::move_task()
      */
     public function move_task($task)
     {
         $this->_parse_id($task);
         $list_id = $task['list'];
         if (!$list_id || !($folder = $this->get_folder($list_id)))
             return false;
 
         // execute move command
         if ($task['_fromlist'] && ($fromfolder = $this->get_folder($task['_fromlist']))) {
             return $fromfolder->move($task['uid'], $folder);
         }
 
         return false;
     }
 
     /**
      * Remove a single task from the database
      *
      * @param array   Hash array with task properties:
      *      id: Task identifier
      * @param boolean Remove record irreversible (mark as deleted otherwise, if supported by the backend)
      * @return boolean True on success, False on error
      */
     public function delete_task($task, $force = true)
     {
         $this->_parse_id($task);
         $list_id = $task['list'];
         if (!$list_id || !($folder = $this->get_folder($list_id)))
             return false;
 
         $status = $folder->delete($task['uid']);
 
         if ($status) {
             // remove tag assignments
             // @TODO: don't do this when undelete feature will be implemented
             $this->save_tags($task['uid'], null);
         }
 
         return $status;
     }
 
     /**
      * Restores a single deleted task (if supported)
      *
      * @param array Hash array with task properties:
      *      id: Task identifier
      * @return boolean True on success, False on error
      */
     public function undelete_task($prop)
     {
         // TODO: implement this
         return false;
     }
 
 
     /**
      * Get attachment properties
      *
      * @param string $id    Attachment identifier
      * @param array  $task  Hash array with event properties:
      *         id: Task identifier
      *       list: List identifier
      *        rev: Revision (optional)
      *
      * @return array Hash array with attachment properties:
      *         id: Attachment identifier
      *       name: Attachment name
      *   mimetype: MIME content type of the attachment
      *       size: Attachment size
      */
     public function get_attachment($id, $task)
     {
         // get old revision of the object
         if ($task['rev']) {
             $task = $this->get_task_revison($task, $task['rev']);
         }
         else {
             $task = $this->get_task($task);
         }
 
         if ($task && !empty($task['attachments'])) {
             foreach ($task['attachments'] as $att) {
                 if ($att['id'] == $id)
                     return $att;
             }
         }
 
         return null;
     }
 
     /**
      * Get attachment body
      *
      * @param string $id    Attachment identifier
      * @param array  $task  Hash array with event properties:
      *         id: Task identifier
      *       list: List identifier
      *        rev: Revision (optional)
      *
      * @return string Attachment body
      */
     public function get_attachment_body($id, $task)
     {
         $this->_parse_id($task);
 
         // get old revision of event
         if ($task['rev']) {
             if (empty($this->bonnie_api)) {
                 return false;
             }
 
             $cid = substr($id, 4);
 
             // call Bonnie API and get the raw mime message
             list($uid, $mailbox, $msguid) = $this->_resolve_task_identity($task);
             if ($msg_raw = $this->bonnie_api->rawdata('task', $uid, $task['rev'], $mailbox, $msguid)) {
                 // parse the message and find the part with the matching content-id
                 $message = rcube_mime::parse_message($msg_raw);
                 foreach ((array)$message->parts as $part) {
                     if ($part->headers['content-id'] && trim($part->headers['content-id'], '<>') == $cid) {
                         return $part->body;
                     }
                 }
             }
 
             return false;
         }
 
 
         if ($storage = $this->get_folder($task['list'])) {
             return $storage->get_attachment($task['uid'], $id);
         }
 
         return false;
     }
 
     /**
      * Build a struct representing the given message reference
      *
      * @see tasklist_driver::get_message_reference()
      */
     public function get_message_reference($uri_or_headers, $folder = null)
     {
         if (is_object($uri_or_headers)) {
             $uri_or_headers = kolab_storage_config::get_message_uri($uri_or_headers, $folder);
         }
 
         if (is_string($uri_or_headers)) {
             return kolab_storage_config::get_message_reference($uri_or_headers, 'task');
         }
 
         return false;
     }
 
     /**
      * Find tasks assigned to a specified message
      *
      * @see tasklist_driver::get_message_related_tasks()
      */
     public function get_message_related_tasks($headers, $folder)
     {
         $config = kolab_storage_config::get_instance();
         $result = $config->get_message_relations($headers, $folder, 'task');
 
         foreach ($result as $idx => $rec) {
             $result[$idx] = $this->_to_rcube_task($rec, kolab_storage::folder_id($rec['_mailbox']));
         }
 
         return $result;
     }
 
     /**
      * 
      */
     public function tasklist_edit_form($action, $list, $fieldprop)
     {
         $this->_read_lists();
 
         if ($list['id'] && ($list = $this->lists[$list['id']])) {
             $folder_name = $this->get_folder($list['id'])->name; // UTF7
         }
         else {
             $folder_name = '';
         }
 
         $storage = $this->rc->get_storage();
         $delim   = $storage->get_hierarchy_delimiter();
         $form    = array();
 
         if (strlen($folder_name)) {
             $path_imap = explode($delim, $folder_name);
             array_pop($path_imap);  // pop off name part
             $path_imap = implode($path_imap, $delim);
 
             $options = $storage->folder_info($folder_name);
         }
         else {
             $path_imap = '';
         }
 
         $hidden_fields[] = array('name' => 'oldname', 'value' => $folder_name);
 
         // folder name (default field)
         $input_name = new html_inputfield(array('name' => 'name', 'id' => 'taskedit-tasklistname', 'size' => 20));
         $fieldprop['name']['value'] = $input_name->show($list['editname'], array('disabled' => ($options['norename'] || $options['protected'])));
 
         // prevent user from moving folder
         if (!empty($options) && ($options['norename'] || $options['protected'])) {
             $hidden_fields[] = array('name' => 'parent', 'value' => $path_imap);
         }
         else {
             $select = kolab_storage::folder_selector('task', array('name' => 'parent', 'id' => 'taskedit-parentfolder'), $folder_name);
             $fieldprop['parent'] = array(
                 'id'    => 'taskedit-parentfolder',
                 'label' => $this->plugin->gettext('parentfolder'),
                 'value' => $select->show($path_imap),
             );
         }
 
         // General tab
         $form['properties'] = array(
             'name' => $this->rc->gettext('properties'),
             'fields' => array(),
         );
 
         foreach (array('name','parent','showalarms') as $f) {
             $form['properties']['fields'][$f] = $fieldprop[$f];
         }
 
         return kolab_utils::folder_form($form, $folder_name, 'tasklist', $hidden_fields);
     }
 }