diff --git a/lib/Kolab/CalDAV/CalendarBackend.php b/lib/Kolab/CalDAV/CalendarBackend.php
index ba31729..5d937f6 100644
--- a/lib/Kolab/CalDAV/CalendarBackend.php
+++ b/lib/Kolab/CalDAV/CalendarBackend.php
@@ -1,805 +1,969 @@
 <?php
 
 /**
  * SabreDAV Calendaring backend for Kolab.
  *
  * @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/>.
  */
 
 namespace Kolab\CalDAV;
 
 use \PEAR;
 use \rcube;
 use \rcube_charset;
 use \kolab_storage;
 use \kolab_storage_config;
 use \libcalendaring;
 use Kolab\Utils\DAVBackend;
 use Kolab\Utils\VObjectUtils;
 use Kolab\DAV\Auth\HTTPBasic;
 use Sabre\DAV;
 use Sabre\CalDAV;
 use Sabre\VObject;
 
 /**
  * Kolab Calendaring backend.
  *
  * Checkout the Sabre\CalDAV\Backend\BackendInterface for all the methods that must be implemented.
  *
  */
-class CalendarBackend extends CalDAV\Backend\AbstractBackend
+class CalendarBackend extends CalDAV\Backend\AbstractBackend implements CalDAV\Backend\SchedulingSupport
 {
     private $calendars;
     private $folders;
     private $aliases;
     private $useragent;
     private $subscribed = null;
 
     /**
      * Read available calendar folders from server
      */
     private function _read_calendars()
     {
         // already read sources
         if (isset($this->calendars))
             return $this->calendars;
 
         // get all folders that have "event" type
         $folders = array_merge(kolab_storage::get_folders('event', $this->subscribed), kolab_storage::get_folders('task', $this->subscribed));
         $this->calendars = $this->folders = $this->aliases = array();
 
         $order = 1;
         foreach (kolab_storage::sort_folders($folders) as $folder) {
             $id = $folder->get_uid();
             $this->folders[$id] = $folder;
             $fdata = $folder->get_imap_data();  // fetch IMAP folder data for CTag generation
             $this->calendars[$id] = array(
                 'id' => $id,
                 'uri' => $id,
                 '{DAV:}displayname' => html_entity_decode($folder->get_name(), ENT_COMPAT, RCUBE_CHARSET),
                 '{http://apple.com/ns/ical/}calendar-color' => '#' . $folder->get_color('FF0000') . 'FF',
                 '{http://calendarserver.org/ns/}getctag' => sprintf('%d-%d-%d', $fdata['UIDVALIDITY'], $fdata['HIGHESTMODSEQ'], $fdata['UIDNEXT']),
                 '{urn:ietf:params:xml:ns:caldav}supported-calendar-component-set' => new CalDAV\Property\SupportedCalendarComponentSet(array(DAVBackend::$caldav_type_component_map[$folder->type])),
                 '{urn:ietf:params:xml:ns:caldav}schedule-calendar-transp' => new CalDAV\Property\ScheduleCalendarTransp('opaque'),
                 '{http://apple.com/ns/ical/}calendar-order' => $order++,
             );
             $this->aliases[$folder->name] = $id;
 
             // these properties are used for sharing supprt (not yet active)
             if (false && $folder->get_namespace() != 'personal') {
                 $rights = $folder->get_myrights();
                 $this->calendars[$id]['{http://calendarserver.org/ns/}shared-url'] = '/calendars/' . $folder->get_owner() . '/' . $id;
                 $this->calendars[$id]['{http://calendarserver.org/ns/}owner-principal'] = $folder->get_owner();
                 $this->calendars[$id]['{http://sabredav.org/ns}read-only'] = strpos($rights, 'i') === false;
             }
         }
 
         return $this->calendars;
     }
 
     /**
      * Getter for a kolab_storage_folder representing the calendar for the given ID
      *
      * @param string Calendar ID
      * @return object kolab_storage_folder instance
      */
     public function get_storage_folder($id)
     {
         // resolve alias name
         if ($this->aliases[$id]) {
             $id = $this->aliases[$id];
         }
 
         if ($this->folders[$id]) {
             return $this->folders[$id];
         }
         else {
             return DAVBackend::get_storage_folder($id, '');
         }
     }
 
     /**
      * Returns a list of calendars for a principal.
      *
      * Every calendars is an array with the following keys:
      *  * id, a unique id that will be used by other functions to modify the
      *    calendar. This can be the same as the uri or a database key.
      *  * uri, which the basename of the uri with which the calendar is
      *    accessed.
      *  * principaluri. The owner of the calendar. Almost always the same as
      *    principalUri passed to this method.
      *
      * Furthermore it can contain webdav properties in clark notation. A very
      * common one is '{DAV:}displayname'.
      *
      * @param string $principalUri
      * @return array
      */
     public function getCalendarsForUser($principalUri)
     {
         console(__METHOD__, $principalUri);
 
         $this->_read_calendars();
 
         $calendars = array();
         foreach ($this->calendars as $id => $cal) {
             $this->calendars[$id]['principaluri'] = $principalUri;
             $calendars[] = $this->calendars[$id];
         }
 
         return $calendars;
     }
 
     /**
      * Returns calendar properties for a specific node identified by name/uri
      *
      * @param string Node name/uri
      * @return array Hash array with calendar properties or null if not found
      */
     public function getCalendarByName($calendarUri)
     {
         console(__METHOD__, $calendarUri);
 
         $this->_read_calendars();
         $id = $calendarUri;
 
         // resolve aliases (calendar by folder name)
         if ($this->aliases[$calendarUri]) {
             $id = $this->aliases[$calendarUri];
         }
 
         if ($this->calendars[$id] && empty($this->calendars[$id]['principaluri'])) {
             $this->calendars[$id]['principaluri'] = 'principals/' . HTTPBasic::$current_user;
         }
 
         // retry with subscribed = false (#2701)
         if (empty($this->calendars[$id]) && $id != 'outbox' && $this->subscribed === null && rcube::get_instance()->config->get('kolab_use_subscriptions')) {
             $this->subscribed = false;
             unset($this->calendars);
             return $this->getCalendarByName($calendarUri);
         }
 
         return $this->calendars[$id];
     }
 
     /**
      * Creates a new calendar for a principal.
      *
      * If the creation was a success, an id must be returned that can be used to reference
      * this calendar in other methods, such as updateCalendar.
      *
      * @param string $principalUri
      * @param string $calendarUri
      * @param array $properties
      * @return void
      */
     public function createCalendar($principalUri, $calendarUri, array $properties)
     {
         console(__METHOD__, $calendarUri, $properties);
 
         return DAVBackend::folder_create('event', $properties, $calendarUri);
     }
 
     /**
      * Updates properties for a calendar.
      *
      * The list of mutations is stored in a Sabre\DAV\PropPatch object.
      * To do the actual updates, you must tell this object which properties
      * you're going to process with the handle() method.
      *
      * Calling the handle method is like telling the PropPatch object "I
      * promise I can handle updating this property".
      *
      * Read the PropPatch documenation for more info and examples.
      *
      * @param string $path
      * @param \Sabre\DAV\PropPatch $propPatch
      * @return void
      */
     public function updateCalendar($calendarId, \Sabre\DAV\PropPatch $propPatch)
     {
         console(__METHOD__, $calendarId, $propPatch);
 
         if ($folder = $this->get_storage_folder($calendarId)) {
             DAVBackend::handle_propatch($folder, $propPatch);
         }
     }
 
     /**
      * Delete a calendar and all it's objects
      *
      * @param mixed $calendarId
      * @return void
      */
     public function deleteCalendar($calendarId)
     {
         console(__METHOD__, $calendarId);
 
         $folder = $this->get_storage_folder($calendarId);
         if ($folder && !kolab_storage::folder_delete($folder->name)) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error deleting calendar folder $folder->name"),
                 true, false);
         }
     }
 
 
     /**
      * Returns all calendar objects within a calendar.
      *
      * Every item contains an array with the following keys:
      *   * id - unique identifier which will be used for subsequent updates
      *   * calendardata - The iCalendar-compatible calendar data (optional)
      *   * uri - a unique key which will be used to construct the uri. This can be any arbitrary string.
      *   * lastmodified - a timestamp of the last modification time
      *   * etag - An arbitrary string, surrounded by double-quotes. (e.g.: "abcdef"')
      *   * calendarid - The calendarid as it was passed to this function.
      *   * size - The size of the calendar objects, in bytes.
      *
      * Note that the etag is optional, but it's highly encouraged to return for
      * speed reasons.
      *
      * If neither etag or size are specified, the calendardata will be
      * used/fetched to determine these numbers. If both are specified the
      * amount of times this is needed is reduced by a great degree.
      *
      * @param mixed $calendarId
      * @return array
      */
     public function getCalendarObjects($calendarId)
     {
         console(__METHOD__, $calendarId);
 
         $events = array();
         $query = $this->_event_filter_query();
         $storage = $this->get_storage_folder($calendarId);
         if ($storage) {
             foreach ($storage->select($query) as $event) {
                 // post-filter events to suppress declined invitations
                 if (!$this->_event_filter_compare($event)) {
                     continue;
                 }
 
                 // get tags/categories from relations
                 $this->load_tags($event);
 
                 $events[] = array(
                     'id' => $event['uid'],
                     'uri' => VObjectUtils::uid2uri($event['uid'], '.ics'),
                     'lastmodified' => $event['changed'] ? $event['changed']->format('U') : null,
                     'calendarid' => $calendarId,
                     'etag' => self::_get_etag($event),
                     'size' => $event['_size'],
                 );
             }
         }
 
         return $events;
     }
 
     /**
      * Returns information from a single calendar object, based on it's object
      * uri.
      *
      * The returned array must have the same keys as getCalendarObjects. The
      * 'calendardata' object is required here though, while it's not required
      * for getCalendarObjects.
      *
      * @param mixed $calendarId
      * @param string $objectUri
      * @return array
      */
     public function getCalendarObject($calendarId, $objectUri)
     {
         console(__METHOD__, $calendarId, $objectUri);
 
         $uid = VObjectUtils::uri2uid($objectUri, '.ics');
         $storage = $this->get_storage_folder($calendarId);
 
         // attachment content is requested
         if (preg_match('!^(.+).ics:attachment:(\d+):.+$!', $objectUri, $m)) {
             $uid = VObjectUtils::uri2uid($m[1]);
             $part = $m[2];
         }
 
         if ($storage && ($event = $storage->get_object($uid))) {
             // deliver attachment content directly
             if ($part && !empty($event['_attachments'])) {
                 foreach ($event['_attachments'] as $attachment) {
                     if ($attachment['id'] == $part) {
                         header('Content-Type: ' . $attachment['mimetype']);
                         header('Content-Disposition: inline; filename="' . $attachment['name'] . '"');
                         $storage->get_attachment($uid, $part, null, true);
                         exit;
                     }
                 }
             }
 
             // map attributes
             $event['attachments'] = $event['_attachments'];
 
             // compose an absolute URI for referencing object attachments
             $base_uri = DAVBackend::abs_url(array(
                 CalDAV\Plugin::CALENDAR_ROOT,
                 preg_replace('!principals/!', '', $this->calendars[$calendarId]['principaluri']),
                 $calendarId,
                 VObjectUtils::uid2uri($event['uid'], '.ics'),
             ));
 
             // get tags/categories from relations
             $this->load_tags($event);
 
             // default response
             return array(
                 'id' => $event['uid'],
                 'uri' => VObjectUtils::uid2uri($event['uid'], '.ics'),
                 'lastmodified' => $event['changed'] ? $event['changed']->format('U') : null,
                 'calendarid' => $calendarId,
                 'calendardata' => $this->_to_ical($event, $base_uri, $storage),
                 'etag' => self::_get_etag($event),
             );
         }
 
         return array();
     }
 
 
     /**
      * Creates a new calendar object.
      *
      * It is possible return an etag from this function, which will be used in
      * the response to this PUT request. Note that the ETag must be surrounded
      * by double-quotes.
      *
      * However, you should only really return this ETag if you don't mangle the
      * calendar-data. If the result of a subsequent GET to this object is not
      * the exact same as this request body, you should omit the ETag.
      *
      * @param mixed $calendarId
      * @param string $objectUri
      * @param string $calendarData
      * @return string|null
      */
     public function createCalendarObject($calendarId, $objectUri, $calendarData)
     {
         console(__METHOD__, $calendarId, $objectUri, $calendarData);
 
         $uid = VObjectUtils::uri2uid($objectUri, '.ics');
         $storage = $this->get_storage_folder($calendarId);
         $object = $this->parse_calendar_data($calendarData, $uid);
 
         if (empty($object) || empty($object['uid'])) {
             throw new DAV\Exception('Parse error: not a valid iCalendar 2.0 object');
         }
 
         // if URI doesn't match the content's UID, the object might already exist!
         if ($object['uid'] != $uid && $storage->get_object($object['uid'])) {
             $objectUri = VObjectUtils::uid2uri($object['uid'], '.ics');
             Plugin::$redirect_basename = $objectUri;
             return $this->updateCalendarObject($calendarId, $objectUri, $calendarData);
         }
 
         // map attachments attribute
         $object['_attachments'] = $object['attachments'];
         unset($object['attachments']);
 
         // remove categories from object data (only for tasks yet)
         if ($object['_type'] == 'task') {
             $tags = (array)$object['categories'];
             unset($object['categories']);
         }
 
         $success = $storage->save($object, $object['_type']);
         if (!$success) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error saving $object[_type] object to Kolab server"),
                 true, false);
 
             throw new DAV\Exception('Error saving calendar object to backend');
         }
 
         // save tag relations on success (only available for tasks yet)
         if ($object['_type'] == 'task') {
             $this->save_tags($uid, $tags);
             $object['categories'] = $tags;  // add again for etag computation
         }
 
         // send Location: header if URI doesn't match object's UID (Bug #2109)
         if ($object['uid'] != $uid) {
             Plugin::$redirect_basename = VObjectUtils::uid2uri($object['uid'], '.ics');
         }
 
         // return new Etag
         return $success ? self::_get_etag($object) : null;
     }
 
     /**
      * Updates an existing calendarobject, based on it's uri.
      *
      * It is possible return an etag from this function, which will be used in
      * the response to this PUT request. Note that the ETag must be surrounded
      * by double-quotes.
      *
      * However, you should only really return this ETag if you don't mangle the
      * calendar-data. If the result of a subsequent GET to this object is not
      * the exact same as this request body, you should omit the ETag.
      *
      * @param mixed $calendarId
      * @param string $objectUri
      * @param string $calendarData
      * @return string|null
      */
     public function updateCalendarObject($calendarId, $objectUri, $calendarData)
     {
         console(__METHOD__, $calendarId, $objectUri, $calendarData);
 
         $uid = VObjectUtils::uri2uid($objectUri, '.ics');
         $storage = $this->get_storage_folder($calendarId);
         $object = $this->parse_calendar_data($calendarData, $uid);
 
         if (empty($object)) {
             throw new DAV\Exception('Parse error: not a valid iCalendar 2.0 object');
         }
 
         // sanity check
         if ($object['uid'] != $uid) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error creating calendar object: UID doesn't match object URI"),
                 true, false);
 
             throw new DAV\Exception\NotFound("UID doesn't match object URI");
         }
 
         // copy meta data (starting with _) from old object
         $old = $storage->get_object($uid);
         foreach ((array)$old as $key => $val) {
             if (!isset($object[$key]) && $key[0] == '_')
                 $object[$key] = $val;
         }
 
         // process attachments
         if (/* user agent known to handle attachments inline */ !empty($object['attachments'])) {
             $object['_attachments'] = $object['attachments'];
             unset($object['attachments']);
 
             // mark all existing attachments as deleted (update is always absolute)
             foreach ($old['_attachments'] as $key => $attach) {
                 $object['_attachments'][$key] = false;
             }
         }
 
         // remove categories from object data (only for tasks yet)
         if ($object['_type'] == 'task') {
             $tags = (array)$object['categories'];
             unset($object['categories']);
         }
 
         // save object
         $saved = $storage->save($object, $object['_type'], $uid);
         if (!$saved) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error saving event object to Kolab server"),
                 true, false);
 
             Plugin::$redirect_basename = null;
             throw new DAV\Exception('Error saving event object to backend');
         }
 
         // save tag relations on success (only available for tasks yet)
         if ($object['_type'] == 'task') {
             $this->save_tags($uid, $tags);
             $object['categories'] = $tags;  // add again for etag computation
         }
 
         // return new Etag
         return self::_get_etag($object);
     }
 
     /**
      * Deletes an existing calendar object.
      *
      * @param mixed $calendarId
      * @param string $objectUri
      * @return void
      */
     public function deleteCalendarObject($calendarId, $objectUri)
     {
         console(__METHOD__, $calendarId, $objectUri);
 
         $uid = VObjectUtils::uri2uid($objectUri, '.ics');
         if ($storage = $this->get_storage_folder($calendarId)) {
             if ($storage->delete($uid)) {
                 $this->save_tags($uid, null);
             }
         }
     }
 
     /**
      * Performs a calendar-query on the contents of this calendar.
      *
      * The calendar-query is defined in RFC4791 : CalDAV. Using the
      * calendar-query it is possible for a client to request a specific set of
      * object, based on contents of iCalendar properties, date-ranges and
      * iCalendar component types (VTODO, VEVENT).
      *
      * This method should just return a list of (relative) urls that match this
      * query.
      *
      * The list of filters are specified as an array. The exact array is
      * documented by Sabre\CalDAV\CalendarQueryParser.
      *
      * Note that it is extremely likely that getCalendarObject for every path
      * returned from this method will be called almost immediately after. You
      * may want to anticipate this to speed up these requests.
      *
      * Requests that are extremely common are:
      *   * requests for just VEVENTS
      *   * requests for just VTODO
      *   * requests with a time-range-filter on either VEVENT or VTODO.
      *
      * ..and combinations of these requests. It may not be worth it to try to
      * handle every possible situation and just rely on the (relatively
      * easy to use) CalendarQueryValidator to handle the rest.
      *
      * Note that especially time-range-filters may be difficult to parse. A
      * time-range filter specified on a VEVENT must for instance also handle
      * recurrence rules correctly.
      * A good example of how to interprete all these filters can also simply
      * be found in Sabre\CalDAV\CalendarQueryFilter. This class is as correct
      * as possible, so it gives you a good idea on what type of stuff you need
      * to think of.
      *
      * @param mixed $calendarId
      * @param array $filters
      * @return array
      */
     public function calendarQuery($calendarId, array $filters)
     {
       console(__METHOD__, $calendarId, $filters);
 
       // build kolab storage query from $filters
       $query = $this->_event_filter_query();
       foreach ((array)$filters['comp-filters'] as $filter) {
           if ($filter['name'] != 'VEVENT')
               continue;
           if (is_array($filter['time-range'])) {
               if (!empty($filter['time-range']['end'])) {
                   $query[] = array('dtstart', '<=', $filter['time-range']['end']);
               }
               if (!empty($filter['time-range']['start'])) {
                   $query[] = array('dtend',   '>=', $filter['time-range']['start']);
               }
           }
       }
 
       $results = array();
       if ($storage = $this->get_storage_folder($calendarId)) {
           foreach ($storage->select($query) as $event) {
               // post-filter events to suppress declined invitations
               if ($this->_event_filter_compare($event)) {
                   $results[] = $event['uid'] . '.ics';
               }
           }
       }
 
       return $results;
     }
 
     /**
      * Set User-Agent string of the connected client
      */
     public function setUserAgent($uastring)
     {
         $ua_classes = array(
             'ical'      => 'iCal/\d',
             'outlook'   => 'iCal4OL/\d',
             'lightning' => 'Lightning/\d',
         );
 
         foreach ($ua_classes as $class => $regex) {
             if (preg_match("!$regex!", $uastring)) {
                 $this->useragent = $class;
                 break;
             }
         }
     }
 
 
+    /**********  SchedulingBackend methods  ***********/
+
+    /**
+     * Returns a single scheduling object for the inbox collection.
+     *
+     * The returned array should contain the following elements:
+     *   * uri - A unique basename for the object. This will be used to
+     *           construct a full uri.
+     *   * calendardata - The iCalendar object
+     *   * lastmodified - The last modification date. Can be an int for a unix
+     *                    timestamp, or a PHP DateTime object.
+     *   * etag - A unique token that must change if the object changed.
+     *   * size - The size of the object, in bytes.
+     *
+     * @param string $principalUri
+     * @param string $objectUri
+     * @return array
+     */
+    public function getSchedulingObject($principalUri, $objectUri)
+    {
+        console(__METHOD__, $principalUri, $objectUri);
+
+        if (!$this->is_current_pricipal($principalUri)) {
+            return array();
+        }
+
+        list($calendarId, $objectUid) = explode(':', $objectUri, 2);
+        $uid = VObjectUtils::uri2uid($objectUid, '.ics');
+
+        $event = $this->getCalendarObject($calendarId, $objectUid);
+        if ($event['uri']) {
+            $event['uri'] = $calendarId . ':' . $event['uri'];
+        }
+
+        return $event;
+    }
+
+    /**
+     * Returns all scheduling objects for the inbox collection.
+     *
+     * These objects should be returned as an array. Every item in the array
+     * should follow the same structure as returned from getSchedulingObject.
+     *
+     * The main difference is that 'calendardata' is optional.
+     *
+     * @param string $principalUri
+     * @return array
+     */
+    public function getSchedulingObjects($principalUri)
+    {
+        console(__METHOD__, $principalUri);
+
+        $results = array();
+
+        // we can only access the current user's calendars
+        if (!$this->is_current_pricipal($principalUri)) {
+            return $results;
+        }
+
+        // TODO: list all pending invitation objects with a certain scheduling status ?
+
+/*
+        $query = $this->_event_filter_query(true);
+        foreach (kolab_storage::get_folders('event') as $storage) {
+            // only consider events from personal namespace folders
+            if ($storage->get_namespace() !== 'personal') {
+                continue;
+            }
+
+            $folder_id = $storage->get_uid();
+            foreach ($storage->select($query) as $event) {
+                // post-filter events to only get pending invitations
+                if (!$this->_event_filter_compare($event, true)) {
+                    continue;
+                }
+
+                // get tags/categories from relations
+                $this->load_tags($event);
+
+                $event_uri = $folder_id . ':' . VObjectUtils::uid2uri($event['uid'], '.ics');
+                $results[] = array(
+                    'uri' => $event_uri,
+                    'lastmodified' => $event['changed'] ? $event['changed']->format('U') : null,
+                    'etag' => self::_get_etag($event),
+                    'size' => $event['_size'],
+                );
+            }
+
+            // keep storage folder reference
+            if (!$this->folders[$folder_id]) {
+                $this->folders[$folder_id] = $storage;
+            }
+        }
+*/
+
+        // TODO: find iTip messages in users email INBOX and move to them default calendar
+        // whenever a CalDAV client fetches the inbox data. This will also remove the message
+        // from the email inbox as the message is considered 'processed'.
+
+        return $results;
+    }
+
+    /**
+     * Deletes a scheduling object from the inbox collection.
+     *
+     * @param string $principalUri
+     * @param string $objectUri
+     * @return void
+     */
+    public function deleteSchedulingObject($principalUri, $objectUri)
+    {
+        console(__METHOD__, $principalUri, $objectUri, $objectData);
+    }
+
+    /**
+     * Creates a new scheduling object. This should land in a users' inbox.
+     *
+     * @param string $principalUri
+     * @param string $objectUri
+     * @param string $objectData
+     * @return void
+     */
+    public function createSchedulingObject($principalUri, $objectUri, $objectData)
+    {
+        console(__METHOD__, $principalUri, $objectUri, $objectData);
+
+        // accept only for current user principal (we don't have permissions for other users)
+        if ($this->is_current_pricipal($principalUri)) {
+
+        }
+        else {
+            // send as iTip?
+        }
+    }
+
+
     /**********  Data conversion utilities  ***********/
 
     /**
      * Get object tags
      */
     private function load_tags(&$event)
     {
         // tag relations are only available for tasks yet
         if ($event['_type'] != 'task') {
             return;
         }
 
         $config = kolab_storage_config::get_instance();
         $tags   = $config->get_tags($event['uid']);
 
         if (!empty($tags)) {
             $event['categories'] = array();
         }
 
         foreach ($tags as $tag) {
             $event['categories'][] = $tag['name'];
 
             // modify changed time if relation is newer
             if ($tag['changed'] && !$event['changed'] || $tag['changed'] > $event['changed']) {
                 $event['changed'] = $tag['changed'];
             }
         }
     }
 
     /**
      * Update object tags
      */
     private function save_tags($uid, $tags)
     {
         $config = kolab_storage_config::get_instance();
         $config->save_tags($uid, $tags);
     }
 
     /**
      * Parse the given iCal string into a hash array kolab_format_event can handle
      *
      * @param string iCal data block
      * @return array Hash array with event properties or null on failure
      */
     private function parse_calendar_data($calendarData, $uid)
     {
         try {
             $ical = libcalendaring::get_ical();
 
             // use already parsed object
             if (Plugin::$parsed_vevent && Plugin::$parsed_vevent->UID == $uid) {
                 $objects = $ical->import_from_vobject(Plugin::$parsed_vcalendar);
             }
             else {
                 $objects = $ical->import($calendarData);
             }
 
             // return the first object
             if (count($objects)) {
                 return $objects[0];
             }
         }
         catch (VObject\ParseException $e) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "iCal data parse error: " . $e->getMessage()),
                 true, false);
         }
 
         return null;
     }
 
     /**
      * Build a valid iCal format block from the given event
      *
      * @param array Hash array with event/task properties from libkolab
      * @param string Absolute URI referenceing this event object
      * @param object RECURRENCE-ID property when serializing a recurrence exception
      * @return mixed VCALENDAR string containing the VEVENT data
      *    or VObject\VEvent object with a recurrence exception instance
      * @see: \libvcalendar::export()
      */
     private function _to_ical($event, $base_uri, $storage, $recurrence_id = null)
     {
         $ical = libcalendaring::get_ical();
         $ical->set_prodid('-//Kolab//iRony DAV Server ' . KOLAB_DAV_VERSION . '//Sabre//Sabre VObject ' . VObject\Version::VERSION . '//EN');
         $ical->set_agent($this->useragent == 'ical' ? 'Apple' : '');
 
         // list attachments as absolute URIs for Thunderbird
         if ($this->useragent == 'lightning') {
             $ical->set_attach_uri($base_uri . ':attachment:{{id}}:{{name}}');
             $get_attachment = null;
         }
         else {   // embed attachments for others
             $get_attachment = function($id, $event) use ($storage) {
                 return $storage->get_attachment($event['uid'], $id);
             };
         }
 
         return $ical->export(array($event), null, false, $get_attachment, false);
     }
 
     /**
      * Wrapper for libcalendaring::get_user_emails()
      */
     private function get_user_emails()
     {
         $emails = libcalendaring::get_instance()->get_user_emails();
 
         if (empty($emails)) {
             $emails = array(HTTPBasic::$current_user);
         }
 
         return $emails;
     }
 
     /**
      * Provide basic query for kolab_storage_folder::select()
+     *
+     * @param boolean Filter for inbox events (i.e. status=NEEDS-ACTION)
+     * @return array  List of query parameters for kolab_storage_folder::select()
      */
-    private function _event_filter_query()
+    private function _event_filter_query($inbox = false)
     {
         // get email addresses of the current user
         $user_emails = $this->get_user_emails();
-        $query = array();
+        $query = $subquery = array();
 
         // add query to exclude declined invitations
         foreach ($user_emails as $email) {
-            $query[] = array('tags', '!=', 'x-partstat:' . $email . ':declined');
-            // $query[] = array('tags', '!=', 'x-partstat:' . $email . ':needs-action');
+            if ($inbox) {
+                $subquery[] = array('tags', '=', 'x-partstat:' . $email . ':needs-action');
+                $subquery[] = array('tags', '=', 'x-partstat:' . $email . ':needs-action');
+            }
+            else {
+                $query[] = array('tags', '!=', 'x-partstat:' . $email . ':declined');
+            }
+        }
+
+        if (!empty($subquery)) {
+            $query[] = array($subquery, 'OR');
         }
 
         return $query;
     }
 
     /**
      * Check the given event if it matches the filter
      *
+     * @param array    Hash array with event properties
+     * @param boolean  Filter for inbox events (i.e. status=NEEDS-ACTION)
      * @return boolean True if matches, false if not
      */
-    private function _event_filter_compare($event)
+    private function _event_filter_compare($event, $inbox = false)
     {
         static $user_emails;
 
         if (!is_array($user_emails)) {
             $user_emails = $this->get_user_emails();
         }
 
         if (is_array($event['attendees'])) {
             foreach ($event['attendees'] as $attendee) {
-                if (in_array($attendee['email'], $user_emails) && $attendee['status'] == 'DECLINED') {
-                    return false;
+                if (in_array($attendee['email'], $user_emails)) {
+                    if ($attendee['status'] == 'DECLINED') {
+                        return false;
+                    }
+                    else if ($inbox && $attendee['status'] == 'NEEDS-ACTION') {
+                        return true;
+                    }
                 }
             }
         }
 
-        return true;
+        return !$inbox;
     }
 
     /**
      * Generate an Etag string from the given event data
      *
      * @param array Hash array with event properties from libkolab
      * @return string Etag string
      */
     private static function _get_etag($event)
     {
         return sprintf('"%s-%d-%s"',
             substr(md5($event['uid']), 0, 16),
             $event['_msguid'],
             !empty($event['categories']) ? substr(md5(join(',', (array)$event['categories'])), 0, 16) : '0'
         );
     }
 
+    /**
+     * Helpter method to determine whether the given principal URI
+     * matches the authenticated user principal.
+     */
+    private function is_current_pricipal($principalUri)
+    {
+        return $principalUri === 'principals/' . HTTPBasic::$current_user;
+    }
+
 }
diff --git a/lib/Kolab/CalDAV/CalendarRootNode.php b/lib/Kolab/CalDAV/CalendarRootNode.php
index 62174a7..6af6e78 100644
--- a/lib/Kolab/CalDAV/CalendarRootNode.php
+++ b/lib/Kolab/CalDAV/CalendarRootNode.php
@@ -1,94 +1,53 @@
 <?php
 
 /**
  * SabreDAV CalendarRootNode derived class for the Kolab.
  *
  * @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/>.
  */
 
 namespace Kolab\CalDAV;
 
 use \Sabre\CalDAV;
-use \Sabre\DAVACL\PrincipalBackend;
-use \Sabre\DAVACL\AbstractPrincipalCollection;
 
 /**
  * Calendars collection
  *
  * This object is responsible for generating a list of calendar-homes for each
  * user.
  *
  */
-class CalendarRootNode extends AbstractPrincipalCollection
+class CalendarRootNode extends CalDAV\CalendarRoot
 {
-    /**
-     * CalDAV backend
-     *
-     * @var Sabre\CalDAV\Backend\BackendInterface
-     */
-    protected $caldavBackend;
-
-    /**
-     * Constructor
-     *
-     * This constructor needs both an authentication and a caldav backend.
-     *
-     * By default this class will show a list of calendar collections for
-     * principals in the 'principals' collection. If your main principals are
-     * actually located in a different path, use the $principalPrefix argument
-     * to override this.
-     *
-     * @param PrincipalBackend\BackendInterface $principalBackend
-     * @param Backend\BackendInterface $caldavBackend
-     * @param string $principalPrefix
-     */
-    public function __construct(PrincipalBackend\BackendInterface $principalBackend, CalDAV\Backend\BackendInterface $caldavBackend, $principalPrefix = 'principals')
-    {
-        parent::__construct($principalBackend, $principalPrefix);
-        $this->caldavBackend = $caldavBackend;
-    }
-
-    /**
-     * Returns the nodename
-     *
-     * We're overriding this, because the default will be the 'principalPrefix',
-     * and we want it to be Sabre\CalDAV\Plugin::CALENDAR_ROOT
-     *
-     * @return string
-     */
-    public function getName()
-    {
-        return CalDAV\Plugin::CALENDAR_ROOT;
-    }
 
     /**
      * This method returns a node for a principal.
      *
      * The passed array contains principal information, and is guaranteed to
      * at least contain a uri item. Other properties may or may not be
      * supplied by the authentication backend.
      *
      * @param array $principal
      * @return \Sabre\DAV\INode
      */
     public function getChildForPrincipal(array $principal)
     {
         return new UserCalendars($this->caldavBackend, $principal);
     }
 
 }
diff --git a/lib/Kolab/CalDAV/IMip.php b/lib/Kolab/CalDAV/IMip.php
deleted file mode 100644
index c08f37a..0000000
--- a/lib/Kolab/CalDAV/IMip.php
+++ /dev/null
@@ -1,141 +0,0 @@
-<?php
-
-/**
- * Extended CalDAV IMip handler for the Kolab DAV server
- *
- * @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/>.
- */
-
-namespace Kolab\CalDAV;
-
-use \rcube;
-use \rcube_utils;
-use \Mail_mime;
-
-use Sabre\VObject;
-use Sabre\CalDAV;
-use Sabre\DAV;
-
-/**
- * iMIP handler.
- *
- * This class is responsible for sending out iMIP messages. iMIP is the
- * email-based transport for iTIP. iTIP deals with scheduling operations for
- * iCalendar objects.
- *
- * If you want to customize the email that gets sent out, you can do so by
- * extending this class and overriding the sendMessage method.
- *
- * @copyright Copyright (C) 2007-2013 Rooftop Solutions. All rights reserved.
- * @author Evert Pot (http://www.rooftopsolutions.nl/)
- * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
- */
-class IMip extends CalDAV\Schedule\IMip
-{
-    public function __construct()
-    {
-        
-    }
-    
-    /**
-     * Sends one or more iTip messages through email.
-     *
-     * @param string $originator Originator Email
-     * @param array $recipients Array of email addresses
-     * @param VObject\Component $vObject
-     * @param string $principal Principal Url of the originator
-     * @return void
-     */
-    public function sendMessage($originator, array $recipients, VObject\Component $vObject, $principal)
-    {
-        $ics = $vObject->serialize();
-        console(__METHOD__, $originator, $recipients, $principal, $ics);
-
-        $rcube = rcube::get_instance();
-        $sender = $rcube->user->get_identity();
-        $sender_email = $sender['email'] ?: $rcube->get_user_email();
-        $sender_name  = $sender['name']  ?: $rcube->get_user_name();
-
-        foreach($recipients as $recipient) {
-            $subject = 'KolabDAV iTIP message';
-            switch (strtoupper($vObject->METHOD)) {
-                case 'REPLY' :
-                    $subject = 'Response for: ' . $vObject->VEVENT->SUMMARY;
-                    break;
-                case 'REQUEST' :
-                    $subject = 'Invitation for: ' .$vObject->VEVENT->SUMMARY;
-                    break;
-                case 'CANCEL' :
-                    $subject = 'Cancelled event: ' . $vObject->VEVENT->SUMMARY;
-                    break;
-            }
-
-            $sender = rcube_utils::idn_to_ascii($sender_email);
-            $from = format_email_recipient($sender, $sender_name);
-            $mailto = rcube_utils::idn_to_ascii($recipient);
-
-            // compose multipart message using PEAR:Mail_Mime
-            $message = new Mail_mime("\r\n");
-            $message->setParam('text_encoding', 'quoted-printable');
-            $message->setParam('head_encoding', 'quoted-printable');
-            $message->setParam('head_charset', RCUBE_CHARSET);
-            $message->setParam('text_charset', RCUBE_CHARSET . ";\r\n format=flowed");
-
-            // compose common headers array
-            $headers = array(
-                'To' => $mailto,
-                'From' => $from,
-                'Date' => date('r'),
-                'Reply-To' => $originator,
-                'Message-ID' => $rcube->gen_message_id(),
-                'X-Sender' => $sender,
-                'Subject' => $subject,
-            );
-            if ($agent = $rcube->config->get('useragent'))
-                $headers['User-Agent'] = $agent;
-
-            $message->headers($headers);
-            $message->setContentType('text/calendar', array('method' => strval($vObject->method), 'charset' => RCUBE_CHARSET));
-            $message->setTXTBody($ics);
-
-            // send message through Roundcube's SMTP feature
-            if (!$rcube->deliver_message($message, $sender, $mailto, $smtp_error)) {
-                rcube::raise_error(array(
-                    'code' => 600, 'type' => 'php',
-                    'file' => __FILE__, 'line' => __LINE__,
-                    'message' => "Failed to send iTIP message to " . $mailto),
-                    true, false);
-            }
-        }
-    }
-
-    /**
-     * This function is reponsible for sending the actual email.
-     *
-     * @param string $to Recipient email address
-     * @param string $subject Subject of the email
-     * @param string $body iCalendar body
-     * @param array $headers List of headers
-     * @return void
-     */
-    protected function mail($to, $subject, $body, array $headers)
-    {
-        //mail($to, $subject, $body, implode("\r\n", $headers));
-    }
-
-}
diff --git a/lib/Kolab/CalDAV/IMipPlugin.php b/lib/Kolab/CalDAV/IMipPlugin.php
new file mode 100644
index 0000000..5fae8f0
--- /dev/null
+++ b/lib/Kolab/CalDAV/IMipPlugin.php
@@ -0,0 +1,135 @@
+<?php
+
+/**
+ * Extended CalDAV IMip plugin for the Kolab DAV server
+ *
+ * @author Thomas Bruederli <bruederli@kolabsys.com>
+ *
+ * Copyright (C) 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/>.
+ */
+
+namespace Kolab\CalDAV;
+
+use \rcube;
+use \rcube_utils;
+use \Mail_mime;
+
+use Sabre\VObject;
+use Sabre\CalDAV;
+use Sabre\DAV;
+
+/**
+ * iMIP plugin.
+ *
+ * This class is responsible for sending out iMIP messages. iMIP is the
+ * email-based transport for iTIP. iTIP deals with scheduling operations for
+ * iCalendar objects.
+ */
+class IMipPlugin extends CalDAV\Schedule\IMipPlugin
+{
+
+    /**
+     * Event handler for the 'schedule' event.
+     *
+     * @param ITip\Message $iTipMessage
+     * @return void
+     */
+    function schedule(VObject\ITip\Message $iTipMessage)
+    {
+        console(__METHOD__, $iTipMessage->method, $iTipMessage->recipient, $iTipMessage->significantChange, $iTipMessage->scheduleStatus);
+
+        // Not sending any emails if the system considers the update insignificant.
+        if (!$iTipMessage->significantChange) {
+            if (!$iTipMessage->scheduleStatus) {
+                $iTipMessage->scheduleStatus = '1.0;We got the message, but it\'s not significant enough to warrant an email';
+            }
+            return;
+        }
+
+        $recipient = preg_replace('!^mailto:!i', '', $iTipMessage->recipient);
+        $summary = strval($iTipMessage->message->VEVENT->SUMMARY);
+
+        $rcube = rcube::get_instance();
+        $sender = $rcube->user->get_identity();
+        $sender_email = $sender['email'] ?: $rcube->get_user_email();
+        $sender_name  = $sender['name']  ?: $rcube->get_user_name();
+
+        $subject = 'KolabDAV iTIP message';
+        switch (strtoupper($iTipMessage->method)) {
+            case 'REPLY' :
+                $subject = 'Re: ' . $summary;
+                break;
+            case 'REQUEST' :
+                $subject = 'Invitation: ' .$summary;
+                break;
+            case 'CANCEL' :
+                $subject = 'Cancelled: ' . $summary;
+                break;
+        }
+
+        $sender = rcube_utils::idn_to_ascii($sender_email);
+        $from = format_email_recipient($sender, $sender_name);
+        $mailto = rcube_utils::idn_to_ascii($recipient);
+        $to = format_email_recipient($mailto, $iTipMessage->recipientName);
+
+        // copy some missing properties from master event to make it validate in our clients
+        if (Plugin::$parsed_vevent && strval(Plugin::$parsed_vevent->UID) == strval($iTipMessage->uid)) {
+            if (isset(Plugin::$parsed_vevent->DTEND)) {
+                $iTipMessage->message->VEVENT->DTEND = clone Plugin::$parsed_vevent->DTEND;
+            }
+            if (isset(Plugin::$parsed_vevent->STATUS)) {
+                $iTipMessage->message->VEVENT->STATUS = strval(Plugin::$parsed_vevent->STATUS);
+            }
+        }
+
+        // compose multipart message using PEAR:Mail_Mime
+        $message = new Mail_mime("\r\n");
+        $message->setParam('text_encoding', 'quoted-printable');
+        $message->setParam('head_encoding', 'quoted-printable');
+        $message->setParam('head_charset', RCUBE_CHARSET);
+        $message->setParam('text_charset', RCUBE_CHARSET . ";\r\n format=flowed");
+
+        // compose common headers array
+        $headers = array(
+            'To' => $to,
+            'From' => $from,
+            'Date' => date('r'),
+            'Reply-To' => $originator,
+            'Message-ID' => $rcube->gen_message_id(),
+            'X-Sender' => $sender,
+            'Subject' => $subject,
+        );
+        if ($agent = $rcube->config->get('useragent'))
+            $headers['User-Agent'] = $agent;
+
+        $message->headers($headers);
+        $message->setContentType('text/calendar', array('method' => strval($iTipMessage->method), 'charset' => RCUBE_CHARSET));
+        $message->setTXTBody($iTipMessage->message->serialize());
+
+        // send message through Roundcube's SMTP feature
+        if ($rcube->deliver_message($message, $sender, $mailto, $smtp_error)) {
+            $iTipMessage->scheduleStatus = '1.1;Scheduling message sent via iMip';
+        }
+        else {
+            rcube::raise_error(array(
+                'code' => 600, 'type' => 'php',
+                'file' => __FILE__, 'line' => __LINE__,
+                'message' => "Failed to send iTIP message to " . $mailto),
+                true, false);
+        }
+    }
+
+}
diff --git a/lib/Kolab/CalDAV/Plugin.php b/lib/Kolab/CalDAV/Plugin.php
index 3f71070..fce1607 100644
--- a/lib/Kolab/CalDAV/Plugin.php
+++ b/lib/Kolab/CalDAV/Plugin.php
@@ -1,171 +1,229 @@
 <?php
 
 /**
  * Extended CalDAV plugin for the Kolab DAV server
  *
  * @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/>.
  */
 
 namespace Kolab\CalDAV;
 
 use Sabre\DAV;
 use Sabre\CalDAV;
 use Sabre\VObject;
+use Sabre\HTTP;
+use Sabre\HTTP\URLUtil;
 use Kolab\DAV\Auth\HTTPBasic;
 
 
 /**
  * Extended CalDAV plugin to tweak data validation
  */
 class Plugin extends CalDAV\Plugin
 {
     // make already parsed text/calednar blocks available for later use
     public static $parsed_vcalendar;
     public static $parsed_vevent;
 
     // allow the backend to force a redirect Location
     public static $redirect_basename;
 
     /**
      * Initializes the plugin
      *
      * @param DAV\Server $server
      * @return void
      */
     public function initialize(DAV\Server $server)
     {
         parent::initialize($server);
 
         $server->on('afterCreateFile', array($this, 'afterWriteContent'));
         $server->on('afterWriteContent', array($this, 'afterWriteContent'));
     }
 
     /**
      * Inject some additional HTTP response headers
      */
     public function afterWriteContent($uri, $node)
     {
         // send Location: header to corrected URI
         if (self::$redirect_basename) {
             $path = explode('/', $uri);
             array_pop($path);
             array_push($path, self::$redirect_basename);
             $this->server->httpResponse->setHeader('Location', $this->server->getBaseUri() . join('/', array_map('urlencode', $path)));
             self::$redirect_basename = null;
         }
     }
 
     /**
      * Checks if the submitted iCalendar data is in fact, valid.
      *
      * An exception is thrown if it's not.
      *
      * @param resource|string $data
      * @param string $path
+     * @param bool $modified Should be set to true, if this event handler
+     *                       changed &$data.
+     * @param RequestInterface $request The http request.
+     * @param ResponseInterface $response The http response.
+     * @param bool $isNew Is the item a new one, or an update.
      * @return void
      */
-    protected function validateICalendar(&$data, $path)
+    protected function validateICalendar(&$data, $path, &$modified, HTTP\RequestInterface $request, HTTP\ResponseInterface $response, $isNew)
     {
         // If it's a stream, we convert it to a string first.
         if (is_resource($data)) {
             $data = stream_get_contents($data);
         }
 
+        $before = md5($data);
         // Converting the data to unicode, if needed.
         $data = DAV\StringUtil::ensureUTF8($data);
 
+        if ($before !== md5($data))
+            $modified = true;
+
         try {
-            // modification: Set options to be more tolerant when parsing extended or invalid properties
-            $vobj = VObject\Reader::read($data, VObject\Reader::OPTION_FORGIVING | VObject\Reader::OPTION_IGNORE_INVALID_LINES);
-
-            // keep the parsed object in memory for later processing
-            if ($vobj->name == 'VCALENDAR') {
-                self::$parsed_vcalendar = $vobj;
-                foreach ($vobj->getBaseComponents() as $vevent) {
-                    if ($vevent->name == 'VEVENT' || $vevent->name == 'VTODO') {
-                        self::$parsed_vevent = $vevent;
-                        break;
+            // If the data starts with a [, we can reasonably assume we're dealing
+            // with a jCal object.
+            if (substr($data,0,1) === '[') {
+                $vobj = VObject\Reader::readJson($data);
+
+                // Converting $data back to iCalendar, as that's what we
+                // technically support everywhere.
+                $data = $vobj->serialize();
+                $modified = true;
+            } else {
+                // modification: Set options to be more tolerant when parsing extended or invalid properties
+                $vobj = VObject\Reader::read($data, VObject\Reader::OPTION_FORGIVING | VObject\Reader::OPTION_IGNORE_INVALID_LINES);
+
+                // keep the parsed object in memory for later processing
+                if ($vobj->name == 'VCALENDAR') {
+                    self::$parsed_vcalendar = $vobj;
+                    foreach ($vobj->getBaseComponents() as $vevent) {
+                        if ($vevent->name == 'VEVENT' || $vevent->name == 'VTODO') {
+                            self::$parsed_vevent = $vevent;
+                            break;
+                        }
                     }
                 }
             }
         }
         catch (VObject\ParseException $e) {
-            throw new DAV\Exception\UnsupportedMediaType('This resource requires valid iCalendar 2.0 data. Parse error: ' . $e->getMessage());
+            throw new DAV\Exception\UnsupportedMediaType('This resource only supports valid iCalendar 2.0 data. Parse error: ' . $e->getMessage());
         }
 
         if ($vobj->name !== 'VCALENDAR') {
             throw new DAV\Exception\UnsupportedMediaType('This collection can only support iCalendar objects.');
         }
 
+        $sCCS = '{urn:ietf:params:xml:ns:caldav}supported-calendar-component-set';
+
         // Get the Supported Components for the target calendar
-        list($parentPath,$object) = DAV\URLUtil::splitPath($path);
-        $calendarProperties = $this->server->getProperties($parentPath,array('{urn:ietf:params:xml:ns:caldav}supported-calendar-component-set'));
-        $supportedComponents = $calendarProperties['{urn:ietf:params:xml:ns:caldav}supported-calendar-component-set']->getValue();
+        list($parentPath) = URLUtil::splitPath($path);
+        $calendarProperties = $this->server->getProperties($parentPath, [$sCCS]);
+
+        if (isset($calendarProperties[$sCCS])) {
+            $supportedComponents = $calendarProperties[$sCCS]->getValue();
+        }
+        else {
+            $supportedComponents = ['VTODO', 'VEVENT'];
+        }
 
         $foundType = null;
         $foundUID = null;
         foreach($vobj->getComponents() as $component) {
             switch($component->name) {
                 case 'VTIMEZONE':
                     continue 2;
 
                 case 'VEVENT':
                 case 'VTODO':
                 case 'VJOURNAL':
                     if (is_null($foundType)) {
                         $foundType = $component->name;
                         if (!in_array($foundType, $supportedComponents)) {
-                            throw new CalDAV\Exception\InvalidComponentType('This calendar only supports ' . implode(', ', $supportedComponents) . '. We found a ' . $foundType);
+                            throw new CalDAV\Exception\InvalidComponentType('This resource only supports ' . implode(', ', $supportedComponents) . '. We found a ' . $foundType);
                         }
                         if (!isset($component->UID)) {
                             throw new DAV\Exception\BadRequest('Every ' . $component->name . ' component must have an UID');
                         }
                         $foundUID = (string)$component->UID;
                     } else {
                         if ($foundType !== $component->name) {
                             throw new DAV\Exception\BadRequest('A calendar object must only contain 1 component. We found a ' . $component->name . ' as well as a ' . $foundType);
                         }
                         if ($foundUID !== (string)$component->UID) {
                             throw new DAV\Exception\BadRequest('Every ' . $component->name . ' in this object must have identical UIDs');
                         }
                     }
                     break;
 
                 default:
                     throw new DAV\Exception\BadRequest('You are not allowed to create components of type: ' . $component->name . ' here');
 
             }
         }
         if (!$foundType)
             throw new DAV\Exception\BadRequest('iCalendar object must contain at least 1 of VEVENT, VTODO or VJOURNAL');
+
+        // We use an extra variable to allow event handles to tell us wether
+        // the object was modified or not.
+        //
+        // This helps us determine if we need to re-serialize the object.
+        $subModified = false;
+
+        $this->server->emit(
+            'calendarObjectChange',
+            [
+                $request,
+                $response,
+                $vobj,
+                $parentPath,
+                &$subModified,
+                $isNew
+            ]
+        );
+
+        if ($subModified) {
+            // An event handler told us that it modified the object.
+            $data = $vobj->serialize();
+
+            // Using md5 to figure out if there was an *actual* change.
+            if (!$modified && $before !== md5($data)) {
+                $modified = true;
+            }
+        }
     }
 
     /**
      * Returns a list of features for the DAV: HTTP header.
      * Including 'calendar-schedule' to enable scheduling support in Thunderbird Lightning.
      *
      * @return array
      */
     public function getFeatures()
     {
         $features = parent::getFeatures();
         $features[] = 'calendar-schedule';
         return $features;
     }
 
 }
\ No newline at end of file
diff --git a/lib/Kolab/CalDAV/SchedulePlugin.php b/lib/Kolab/CalDAV/SchedulePlugin.php
index 6ae5151..dbf4f0b 100644
--- a/lib/Kolab/CalDAV/SchedulePlugin.php
+++ b/lib/Kolab/CalDAV/SchedulePlugin.php
@@ -1,100 +1,100 @@
 <?php
 
 /**
  * Extended CalDAV Schedule plugin for the Kolab DAV server
  *
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 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/>.
  */
 
 namespace Kolab\CalDAV;
 
 use Sabre\DAV;
 use Sabre\CalDAV;
 use Sabre\VObject;
 use Sabre\HTTP;
 
 /**
  * Extended CalDAV Schedule plugin
  */
 class SchedulePlugin extends CalDAV\Schedule\Plugin
 {
     /**
      * Returns free-busy information for a specific address. The returned
      * data is an array containing the following properties:
      *
      * calendar-data : A VFREEBUSY VObject
      * request-status : an iTip status code.
      * href: The principal's email address, as requested
      *
      * @param string $email address
      * @param \DateTime $start
      * @param \DateTime $end
      * @param VObject\Component $request
      * @return array
      */
     protected function getFreeBusyForEmail($email, \DateTime $start, \DateTime $end, VObject\Component $request)
     {
         console(__METHOD__, $email, $start, $end);
 
-        $email = preg_replace('!^mailto:!', '', $email);
+        $email = preg_replace('!^mailto:!i', '', $email);
 
         // pass-through the pre-generatd free/busy feed from Kolab's free/busy service
         if ($fburl = \kolab_storage::get_freebusy_url($email)) {
             try {
                 $rcube = \rcube::get_instance();
                 $client = new HTTP\Client();
                 $client->addCurlSetting(CURLOPT_SSL_VERIFYPEER, $rcube->config->get('kolab_ssl_verify_peer', true));
 
                 // authentication required
                 $client->on('error:401', function($request, $response, &$retry, $retryCount) {
                     if ($retryCount <= 1) {
                         // We're only going to retry exactly once.
                         $request->setHeader('Authorization', 'Basic ' . base64_encode(HTTPBasic::$current_user . ':' . HTTPBasic::$current_pass));
                         $retry = true;
                     }
                 });
 
                 $response = $client->send(new HTTP\Request('GET', $fburl));
 
                 // success!
                 if ($response->getStatus() == 200) {
                     $vcalendar = VObject\Reader::read($response->getBodyAsString(), VObject\Reader::OPTION_FORGIVING | VObject\Reader::OPTION_IGNORE_INVALID_LINES);
                     return array(
                         'calendar-data' => $vcalendar,
                         'request-status' => '2.0;Success',
                         'href' => 'mailto:' . $email,
                     );
                 }
             }
             catch (\Exception $e) {
                 // log failures
                 \rcube::raise_error($e, true, false);
             }
         }
         else {
             // generate free/busy data from this user's calendars
             return parent::getFreeBusyForEmail($email, $start, $end, $request);
         }
 
         // return "not found"
         return array(
             'request-status' => '3.7;Could not find principal',
             'href' => 'mailto:' . $email,
         );
     }
 }
\ No newline at end of file
diff --git a/lib/Kolab/CalDAV/UserCalendars.php b/lib/Kolab/CalDAV/UserCalendars.php
index 3573baa..6c7c88f 100644
--- a/lib/Kolab/CalDAV/UserCalendars.php
+++ b/lib/Kolab/CalDAV/UserCalendars.php
@@ -1,167 +1,118 @@
 <?php
 
 /**
  * SabreDAV UserCalendars derived class for the Kolab.
  *
  * @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/>.
  */
 
 namespace Kolab\CalDAV;
 
 use Sabre\DAV;
 use Sabre\DAVACL;
 use Sabre\CalDAV\Backend;
 use Sabre\CalDAV\Schedule;
 use Kolab\CalDAV\Calendar;
 
 /**
  * The UserCalenders class contains all calendars associated to one user
  *
  */
-class UserCalendars extends \Sabre\CalDAV\UserCalendars implements DAV\IExtendedCollection, DAVACL\IACL
+class UserCalendars extends \Sabre\CalDAV\CalendarHome implements DAV\IExtendedCollection, DAVACL\IACL
 {
-    private $outbox;
-
-    /**
-     * Returns a list of calendars
-     *
-     * @return array
-     */
-    public function getChildren()
-    {
-        $calendars = $this->caldavBackend->getCalendarsForUser($this->principalInfo['uri']);
-        $objs = array();
-        foreach ($calendars as $calendar) {
-            // TODO: (later) add sharing support by implenting this all
-            if ($this->caldavBackend instanceof Backend\SharingSupport) {
-                if (isset($calendar['{http://calendarserver.org/ns/}shared-url'])) {
-                    $objs[] = new SharedCalendar($this->caldavBackend, $calendar);
-                }
-                else {
-                    $objs[] = new ShareableCalendar($this->caldavBackend, $calendar);
-                }
-            }
-            else {
-                $objs[] = new Calendar($this->caldavBackend, $calendar);
-            }
-        }
-
-        // add support for scheduling AKA free/busy
-        // TODO: remove when CalendarBackend implements SchedulingSupport
-        $objs[] = new Schedule\Outbox($this->principalInfo['uri']);
-
-        // TODO: add notification support (check with clients first, if anybody supports it)
-        if ($this->caldavBackend instanceof Backend\NotificationSupport) {
-            $objs[] = new Notifications\Collection($this->caldavBackend, $this->principalInfo['uri']);
-        }
-
-        return $objs;
-    }
-
-    /**
-     * Returns a single calendar, by name
-     *
-     * @param string $name
-     * @return Calendar
-     */
-    public function getChild($name)
-    {
-        if ($name == 'outbox') {
-            return new Schedule\Outbox($this->principalInfo['uri']);
-        }
-        if ($calendar = $this->caldavBackend->getCalendarByName($name)) {
-            $calendar['principaluri'] = $this->principalInfo['uri'];
-            return new Calendar($this->caldavBackend, $calendar);
-        }
-
-        throw new DAV\Exception\NotFound('Calendar with name \'' . $name . '\' could not be found');
-    }
-
     /**
      * Checks if a calendar exists.
      *
      * @param string $name
      * @return bool
      */
     public function childExists($name)
     {
+        // Special nodes
+        if ($name === 'inbox' || $name === 'outbox') {
+            return true;
+        }
+        if ($name === 'notifications') {
+            return false;
+        }
+
         if ($this->caldavBackend->getCalendarByName($name)) {
             return true;
         }
         return false;
     }
 
     /**
      * Returns a list of ACE's for this node.
      *
      * Each ACE has the following properties:
      *   - 'privilege', a string such as {DAV:}read or {DAV:}write. These are currently the only supported privileges
      *   - 'principal', a url to the principal who owns the node
      *   - 'protected' (optional), indicating that this ACE is not allowed to be updated.
      *
      * @return array
      */
     public function getACL()
     {
         // define rights for the user's calendar root (which is in fact INBOX)
         return array(
             array(
                 'privilege' => '{DAV:}read',
                 'principal' => $this->principalInfo['uri'],
                 'protected' => true,
             ),
             array(
                 'privilege' => '{DAV:}write',
                 'principal' => $this->principalInfo['uri'],
                 'protected' => true,
             ),
 /* TODO: implement sharing support
             array(
                 'privilege' => '{DAV:}read',
                 'principal' => $this->principalInfo['uri'] . '/calendar-proxy-write',
                 'protected' => true,
             ),
             array(
                 'privilege' => '{DAV:}write',
                 'principal' => $this->principalInfo['uri'] . '/calendar-proxy-write',
                 'protected' => true,
             ),
             array(
                 'privilege' => '{DAV:}read',
                 'principal' => $this->principalInfo['uri'] . '/calendar-proxy-read',
                 'protected' => true,
             ),
 */
         );
     }
 
     /**
      * Updates the ACL
      *
      * This method will receive a list of new ACE's.
      *
      * @param array $acl
      * @return void
      */
     public function setACL(array $acl)
     {
         // TODO: implement this
         throw new DAV\Exception\MethodNotAllowed('Changing ACL is not yet supported');
     }
 
 }
diff --git a/lib/Kolab/DAVACL/PrincipalBackend.php b/lib/Kolab/DAVACL/PrincipalBackend.php
index d22cd8e..eb21111 100644
--- a/lib/Kolab/DAVACL/PrincipalBackend.php
+++ b/lib/Kolab/DAVACL/PrincipalBackend.php
@@ -1,256 +1,260 @@
 <?php
 
 /**
  * SabreDAV Principals Backend implementation for Kolab.
  *
  * @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/>.
  */
 
 namespace Kolab\DAVACL;
 
 use \rcube;
+use \libcalendaring;
 use Sabre\DAV\Exception;
 use Sabre\DAV\URLUtil;
 use Kolab\DAV\Auth\HTTPBasic;
 
 /**
  * Kolab Principal Backend
  */
 class PrincipalBackend extends \Sabre\DAVACL\PrincipalBackend\AbstractBackend implements \Sabre\DAVACL\PrincipalBackend\BackendInterface
 {
     /**
      * Sets up the backend.
      */
     public function __construct()
     {
 
     }
 
     /**
      * Returns a pricipal record for the currently authenticated user
      */
     public function getCurrentUser()
     {
         // console(__METHOD__, HTTPBasic::$current_user);
 
         if (HTTPBasic::$current_user) {
             $user_email = rcube::get_instance()->get_user_email();
+            $emails = libcalendaring::get_instance()->get_user_emails();
+
             return array(
                 'uri' => 'principals/' . HTTPBasic::$current_user,
                 '{DAV:}displayname' => HTTPBasic::$current_user,
                 '{http://sabredav.org/ns}email-address' => $user_email,
-                '{http://calendarserver.org/ns/}email-address-set' => $user_email,
+                '{DAV:}alternate-URI-set' => array_map(function($email) {
+                        return 'mailto:' . $email;
+                    }, $emails),
             );
         }
 
         return false;
     }
 
 
     /**
      * Returns a list of principals based on a prefix.
      *
      * This prefix will often contain something like 'principals'. You are only
      * expected to return principals that are in this base path.
      *
      * You are expected to return at least a 'uri' for every user, you can
      * return any additional properties if you wish so. Common properties are:
      *   {DAV:}displayname
      *   {http://sabredav.org/ns}email-address - This is a custom SabreDAV
      *     field that's actualy injected in a number of other properties. If
      *     you have an email address, use this property.
      *
      * @param string $prefixPath
      * @return array
      */
     public function getPrincipalsByPrefix($prefixPath)
     {
         console(__METHOD__, $prefixPath);
 
         $principals = array();
 
         if ($prefixPath == 'principals') {
             // TODO: list users from LDAP
 
             // we currently only advertise the authenticated user
             if ($user = $this->getCurrentUser()) {
                 $principals[] = $user;
             }
         }
 
         return $principals;
     }
 
     /**
      * Returns a specific principal, specified by it's path.
      * The returned structure should be the exact same as from
      * getPrincipalsByPrefix.
      *
      * @param string $path
      * @return array
      */
     public function getPrincipalByPath($path)
     {
         // console(__METHOD__, $path);
 
         list($prefix,$name) = explode('/', $path);
 
         if ($prefix == 'principals' && $name == HTTPBasic::$current_user) {
             return $this->getCurrentUser();
         }
         else if ($prefix == 'principals' && \rcube_utils::check_email($name, false)) {
             // TODO: do a user lookup in LDAP
             list($localname,$domain) = explode('@', $name);
             return array(
                 'uri' => $path,
                 '{DAV:}displayname' => $localname,
                 '{http://sabredav.org/ns}email-address' => $name,
-                '{http://calendarserver.org/ns/}email-address-set' => $name,
             );
         }
 
         return null;
     }
 
     /**
      * Returns the list of members for a group-principal
      *
      * @param string $principal
      * @return array
      */
     public function getGroupMemberSet($principal)
     {
         // TODO: for now the group principal has only one member, the user itself
         list($prefix, $name) = URLUtil::splitPath($principal);
 
         $principal = $this->getPrincipalByPath($principal);
         if (!$principal) throw new Exception('Principal not found');
 
         return array(
             $prefix
         );
     }
 
     /**
      * Returns the list of groups a principal is a member of
      *
      * @param string $principal
      * @return array
      */
     public function getGroupMembership($principal)
     {
         list($prefix,$name) = URLUtil::splitPath($principal);
 
         $group_membership = array();
         if ($prefix == 'principals') {
             $principal = $this->getPrincipalByPath($principal);
             if (!$principal) throw new Exception('Principal not found');
 
             // TODO: implement full calendar delegation (with information from LDAP kolabDelegate)
             return array(
                 // Calendar delegation is not supported by our backend
                 //'principals/'.$name.'/calendar-proxy-read',
                 //'principals/'.$name.'/calendar-proxy-write',
 
                 // The addressbook groups are not supported in Sabre,
                 // see http://groups.google.com/group/sabredav-discuss/browse_thread/thread/ef2fa9759d55f8c#msg_5720afc11602e753
                 //'principals/'.$name.'/addressbook-proxy-read',
                 //'principals/'.$name.'/addressbook-proxy-write',
             );
         }
         return $group_membership;
     }
 
     /**
      * Updates the list of group members for a group principal.
      *
      * The principals should be passed as a list of uri's.
      *
      * @param string $principal
      * @param array $members
      * @return void
      */
     public function setGroupMemberSet($principal, array $members)
     {
         throw new Exception('Setting members of the group is not supported yet');
     }
 
     function updatePrincipal($path, \Sabre\DAV\PropPatch $propPatch)
     {
         return 0;
     }
 
     /**
      * This method is used to search for principals matching a set of
      * properties.
      *
      * This search is specifically used by RFC3744's principal-property-search
      * REPORT. You should at least allow searching on
      * http://sabredav.org/ns}email-address.
      *
      * The actual search should be a unicode-non-case-sensitive search. The
      * keys in searchProperties are the WebDAV property names, while the values
      * are the property values to search on.
      *
      * If multiple properties are being searched on, the search should be
      * AND'ed.
      *
      * This method should simply return an array with full principal uri's.
      *
      * If somebody attempted to search on a property the backend does not
      * support, you should simply return 0 results.
      *
      * @param string $prefixPath
      * @param array $searchProperties
      * @param string $test
      * @return array
      */
     function searchPrincipals($prefixPath, array $searchProperties, $test = 'allof')
     {
         console(__METHOD__, $prefixPath, $searchProperties);
 
         $email = null;
         $results = array();
         $current_user = $this->getCurrentUser();
         foreach($searchProperties as $property => $value) {
             // check search property against the current user
             if ($current_user[$property] == $value) {
                 $results[] = $current_user['uri'];
                 continue;
             }
             switch($property) {
                 case '{http://sabredav.org/ns}email-address':
                     $email = $value;
                     break;
 
                 case '{DAV:}displayname':
                 default :
                     // Unsupported property
                     return array();
             }
         }
 
         // we only support search by email
         if (!empty($email)) {
             // TODO: search via LDAP
         }
 
         return array_unique($results);
     }
 
 }
diff --git a/lib/Kolab/Utils/DAVBackend.php b/lib/Kolab/Utils/DAVBackend.php
index 7bef0f6..2113143 100644
--- a/lib/Kolab/Utils/DAVBackend.php
+++ b/lib/Kolab/Utils/DAVBackend.php
@@ -1,256 +1,259 @@
 <?php
 
 /**
  * Utility class providing a simple API to PHP's APC cache
  *
  * @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/>.
  */
 
 namespace Kolab\Utils;
 
 use \rcube;
 use \kolab_storage;
 use \rcube_utils;
 use \rcube_charset;
 
 /**
  *
  */
 class DAVBackend
 {
     const IMAP_UID_KEY = '/shared/vendor/kolab/uniqueid';
     const IMAP_UID_KEY_PRIVATE = '/private/vendor/kolab/uniqueid';
     const IMAP_UID_KEY_CYRUS = '/shared/vendor/cmu/cyrus-imapd/uniqueid';
 
     public static $caldav_type_component_map = array('event' => 'VEVENT', 'task' => 'VTODO');
 
     /**
      * Getter for a kolab_storage_folder with the given UID
      *
      * @param string  Folder UID (saved in annotation)
      * @param string  Kolab folder type (for selecting candidates)
      * @return object \kolab_storage_folder instance
      */
     public static function get_storage_folder($uid, $type)
     {
         foreach (kolab_storage::get_folders($type, false) as $folder) {
             if ($folder->get_uid() == $uid)
                 return $folder;
         }
 
         return null;
     }
 
     /**
      * Build an absolute URL with the given parameters
      */
     public static function abs_url($parts = array())
     {
         $schema = 'http';
         $default_port = 80;
         if (rcube_utils::https_check()) {
             $schema = 'https';
             $default_port = 443;
         }
         $url = $schema . '://' . $_SERVER['HTTP_HOST'];
 
         if ($_SERVER['SERVER_PORT'] != $default_port)
             $url .= ':' . $_SERVER['SERVER_PORT'];
 
         if (dirname($_SERVER['SCRIPT_NAME']) != '/')
             $url .= dirname($_SERVER['SCRIPT_NAME']);
 
         $url .= '/' . join('/', array_map('urlencode', $parts));
 
         return $url;
     }
 
     /**
      * Set callback handler for property changes on the given folder
      *
      * @param object $folder kolab_storage_folder instance to operate on
      * @param oject $propPatch PropPatch instance with the property updates
      */
     public static function handle_propatch($folder, \Sabre\DAV\PropPatch $propPatch)
     {
         $propPatch->handle(
             array('{DAV:}displayname','{http://apple.com/ns/ical/}calendar-color'),
             function($mutations) use ($folder) {
                 $result = DAVBackend::folder_update($folder, $mutations);
                 if (is_array($result)) {
                     $ret = array();
                     foreach ($result as $code => $props) {
                         foreach (array_keys($props) as $prop) {
                             $ret[$prop] = $code;
                         }
                     }
                 }
                 else {
                     $ret = $result;
                 }
                 return $ret;
             });
+
+        // silently accept the other/non-supported properties
+        $propPatch->setRemainingResultCode(204);
     }
 
     /**
      * Updates properties for a recourse (kolab folder)
      *
      * The mutations array uses the propertyName in clark-notation as key,
      * and the array value for the property value. In the case a property
      * should be deleted, the property value will be null.
      *
      * This method must be atomic. If one property cannot be changed, the
      * entire operation must fail.
      *
      * If the operation was successful, true is returned.
      * If the operation failed, detailed information about any
      * failures is returned.
      *
      * @param object $folder kolab_storage_folder instance to operate on
      * @param object $mutations Hash array with propeties to change
      * @return void
      */
     public static function folder_update($folder, array $mutations)
     {
         $errors = array();
         $updates = array();
 
         foreach ($mutations as $prop => $val) {
             switch ($prop) {
                 case '{DAV:}displayname':
                     // abort if name didn't change
                     if ($val == html_entity_decode($folder->get_name(), ENT_COMPAT, RCUBE_CHARSET)) {
                         break;
                     }
                     // restrict renaming to personal folders only
                     if ($folder->get_namespace() == 'personal') {
                         $parts = preg_split('!(\s*/\s*|\s+[»:]\s+)!', $val);
                         $updates['oldname'] = $folder->name;
                         $updates['name'] = array_pop($parts);
                         $updates['parent'] = join('/', $parts);
                     }
                     else {
                         $updates['displayname'] = $val;
                     }
                     break;
 
                 case '{http://apple.com/ns/ical/}calendar-color':
                     $newcolor = substr(trim($val, '#'), 0, 6);
                     if (strcasecmp($newcolor, $folder->get_color())) {
                         $updates['color'] = $newcolor;
                     }
                     break;
 
                 case '{urn:ietf:params:xml:ns:caldav}calendar-description':
                 default:
                     // unsupported property
                     $errors[403][$prop] = null;
             }
         }
 
         // execute folder update
         if (!empty($updates)) {
             // 'name' and 'parent' properties are always required
             if (empty($updates['name'])) {
                 $parts = explode('/', $folder->name);
                 $updates['name'] = rcube_charset::convert(array_pop($parts), 'UTF7-IMAP');
                 $updates['parent'] = join('/', $parts);
                 $updates['oldname'] = $folder->name;
             }
 
             if (!kolab_storage::folder_update($updates)) {
                 rcube::raise_error(array(
                     'code' => 600, 'type' => 'php',
                     'file' => __FILE__, 'line' => __LINE__,
                     'message' => "Error updating properties for folder $folder->name:" . kolab_storage::$last_error),
                     true, false);
                 return false;
             }
         }
 
         return empty($errors) ? true : $errors;
     }
 
     /**
      * Creates a new resource (i.e. IMAP folder) of a given type
      *
      * If the creation was a success, an id must be returned that can be used to reference
      * this resource in other methods.
      *
      * @param array $properties
      * @param string $type
      * @param string $uid
      * @return false|string
      */
     public function folder_create($type, array $properties, $uid)
     {
         $props = array(
             'type' => $type,
             'name' => '',
             'subscribed' => true,
         );
 
         foreach ($properties as $prop => $val) {
             switch ($prop) {
                 case '{DAV:}displayname':
                     $parts = explode('/', $val);
                     $props['name'] = array_pop($parts);
                     $props['parent'] = join('/', $parts);
                     break;
 
                 case '{http://apple.com/ns/ical/}calendar-color':
                     $props['color'] = substr(trim($val, '#'), 0, 6);
                     break;
 
                 case '{urn:ietf:params:xml:ns:caldav}supported-calendar-component-set':
                     $type_map = array_flip(self::$caldav_type_component_map);
                     $comp_types = $val->getValue();
                     $comp_type = $comp_types[0];
                     if (!empty($type_map[$comp_type]))
                         $type = $type_map[$comp_type];
                     break;
 
                 case '{urn:ietf:params:xml:ns:caldav}calendar-description':
                 default:
                     // unsupported property
             }
         }
 
         // use UID as name if it doesn't seem to be a real UID
         // TODO: append number to default "Untitled" folder name if one already exists
         if (empty($props['name'])) {
             $props['name'] = strlen($uid) < 16 ? $uid : 'Untitled';
         }
 
         if (!($fname = kolab_storage::folder_update($props))) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error creating a new $type folder '$props[name]':" . kolab_storage::$last_error),
                 true, false);
             return false;
         }
 
         // save UID in folder annotations
         if ($folder = kolab_storage::get_folder($fname)) {
             $folder->set_uid($uid);
         }
 
         return $uid;
     }
 }
diff --git a/public_html/index.php b/public_html/index.php
index 348c52c..2919763 100644
--- a/public_html/index.php
+++ b/public_html/index.php
@@ -1,199 +1,197 @@
 <?php
 
 /**
  * iRony, the Kolab WebDAV/CalDAV/CardDAV Server
  *
  * This is the public API to provide *DAV-based access to the Kolab Groupware backend
  *
  * @version 0.4-dev
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2013-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/>.
  */
 
 // define some environment variables used throughout the app and libraries
 define('KOLAB_DAV_ROOT', realpath('../'));
 define('KOLAB_DAV_VERSION', '0.4-dev');
 define('KOLAB_DAV_START', microtime(true));
 
 define('RCUBE_INSTALL_PATH', KOLAB_DAV_ROOT . '/');
 define('RCUBE_CONFIG_DIR',   KOLAB_DAV_ROOT . '/config/');
 define('RCUBE_PLUGINS_DIR',  KOLAB_DAV_ROOT . '/lib/plugins/');
 
 // suppress error notices
 ini_set('error_reporting', E_ALL &~ E_NOTICE &~ E_STRICT);
 
 
 /**
  * Mapping PHP errors to exceptions.
  *
  * While this is not strictly needed, it makes a lot of sense to do so. If an
  * E_NOTICE or anything appears in your code, this allows SabreDAV to intercept
  * the issue and send a proper response back to the client (HTTP/1.1 500).
  */
 function exception_error_handler($errno, $errstr, $errfile, $errline ) {
     throw new ErrorException($errstr, 0, $errno, $errfile, $errline);
 }
 //set_error_handler("exception_error_handler");
 
 // use composer's autoloader for dependencies
 $loader = require_once(KOLAB_DAV_ROOT . '/vendor/autoload.php');
 $loader->set('Kolab', array(KOLAB_DAV_ROOT . '/lib'));  // register iRony namespace(s)
 $loader->setUseIncludePath(true);  // enable include_path to load PEAR classes from their default location
 
 // load the Roundcube framework with its autoloader
 require_once KOLAB_DAV_ROOT . '/lib/Roundcube/bootstrap.php';
 
 // Roundcube framework initialization
 $rcube = rcube::get_instance(rcube::INIT_WITH_DB | rcube::INIT_WITH_PLUGINS);
 $rcube->config->load_from_file(RCUBE_CONFIG_DIR . 'dav.inc.php');
 
 // Load plugins
 $plugins  = (array)$rcube->config->get('kolabdav_plugins', array('kolab_auth'));
 $required = array('libkolab', 'libcalendaring');
 
 $rcube->plugins->init($rcube);
 $rcube->plugins->load_plugins($plugins, $required);
 
 // enable logger
 if ($rcube->config->get('kolabdav_console') || $rcube->config->get('kolabdav_user_debug')) {
     $logger = new \Kolab\Utils\DAVLogger((\Kolab\Utils\DAVLogger::CONSOLE | $rcube->config->get('kolabdav_http_log', 0)));
 }
 
 // convenience function, you know it well :-)
 function console()
 {
     global $logger;
 
     if ($logger) {
         call_user_func_array(array($logger, 'console'), func_get_args());
     }
 }
 
 
 // Make sure this setting is turned on and reflects the root url of the *DAV server.
 $base_uri = $rcube->config->get('base_uri', slashify(substr(dirname($_SERVER['SCRIPT_FILENAME']), strlen($_SERVER['DOCUMENT_ROOT']))));
 
 // add filename to base URI when called without mod_rewrite (e.g. /dav/index.php/calendar)
 if (strpos($_SERVER['REQUEST_URI'], 'index.php'))
     $base_uri .= 'index.php/';
 
 // create the various backend instances
 $auth_backend      = new \Kolab\DAV\Auth\HTTPBasic();
 $principal_backend = new \Kolab\DAVACL\PrincipalBackend();
 
 $services = array();
 foreach (array('CALDAV','CARDDAV','WEBDAV') as $skey) {
     if (getenv($skey))
         $services[$skey] = 1;
 }
 
 // no config means *all* services
 if (empty($services))
     $services = array('CALDAV' => 1, 'CARDDAV' => 1, 'WEBDAV' => 1);
 
 // add chwala directories to include path for autoloading
 if ($services['WEBDAV']) {
     $include_path  = ini_get('include_path') . PATH_SEPARATOR;
     $include_path .= KOLAB_DAV_ROOT . '/lib/FileAPI' . PATH_SEPARATOR;
     $include_path .= KOLAB_DAV_ROOT . '/lib/FileAPI/kolab' . PATH_SEPARATOR;
     $include_path .= KOLAB_DAV_ROOT . '/lib/FileAPI/ext';
     set_include_path($include_path);
 }
 
 // Build the directory tree
 // This is an array which contains the 'top-level' directories in the WebDAV server.
 if ($services['CALDAV'] || $services['CARDDAV']) {
     $nodes = array(
         new \Kolab\CalDAV\Principal\Collection($principal_backend),
     );
 
     if ($services['CALDAV']) {
         $caldav_backend = new \Kolab\CalDAV\CalendarBackend();
         $caldav_backend->setUserAgent($_SERVER['HTTP_USER_AGENT']);
         $nodes[] = new \Kolab\CalDAV\CalendarRootNode($principal_backend, $caldav_backend);
     }
     if ($services['CARDDAV']) {
         $carddav_backend = new \Kolab\CardDAV\ContactsBackend();
         $carddav_backend->setUserAgent($_SERVER['HTTP_USER_AGENT']);
         $nodes[] = new \Kolab\CardDAV\AddressBookRoot($principal_backend, $carddav_backend);
     }
     if ($services['WEBDAV']) {
         $nodes[] = new \Kolab\DAV\Collection(\Kolab\DAV\Collection::ROOT_DIRECTORY);
     }
 }
 // register WebDAV service as root
 else if ($services['WEBDAV']) {
     $nodes = new \Kolab\DAV\Collection('');
 }
 
 // the object tree needs in turn to be passed to the server class
 $server = new \Sabre\DAV\Server($nodes);
 $server->setBaseUri($base_uri);
 
 // connect logger
 if (is_object($logger)) {
     $server->addPlugin($logger);
 }
 
 // register some plugins
 $server->addPlugin(new \Sabre\DAV\Auth\Plugin($auth_backend, 'KolabDAV'));
 $server->addPlugin(new \Sabre\DAVACL\Plugin());
 
 if ($services['CALDAV']) {
-    $caldav_plugin = new \Kolab\CalDAV\Plugin();
-    $server->addPlugin($caldav_plugin);
-
+    $server->addPlugin(new \Kolab\CalDAV\Plugin());
     $server->addPlugin(new \Kolab\CalDAV\SchedulePlugin());
-    #$server->addPlugin(new \Kolab\CalDAV\IMipPlugin());
+    $server->addPlugin(new \Kolab\CalDAV\IMipPlugin(''));
 }
 
 if ($services['CARDDAV']) {
     $server->addPlugin(new \Kolab\CardDAV\Plugin());
 }
 
 if ($services['WEBDAV']) {
     // the lock manager is responsible for making sure users don't overwrite each others changes.
     $locks_backend = new \Kolab\DAV\Locks\Chwala(\Kolab\DAV\Collection::ROOT_DIRECTORY);
     $server->addPlugin(new \Sabre\DAV\Locks\Plugin($locks_backend));
 
     // intercept some of the garbage files operation systems tend to generate when mounting a WebDAV share
     $server->addPlugin(new \Kolab\DAV\TempFilesPlugin(KOLAB_DAV_ROOT . '/temp'));
 }
 
 // HTML UI for browser-based access (recommended only for development)
 if (getenv('DAVBROWSER')) {
     $server->addPlugin(new \Sabre\DAV\Browser\Plugin());
 }
 
 // log exceptions in iRony error log
 $server->on('exception', function($e){
     if (!($e instanceof \Sabre\DAV\Exception) || $e->getHTTPCode() == 500) {
         rcube::raise_error(array(
             'code' => 500,
             'type' => 'php',
             'file' => $e->getFile(),
             'line' => $e->getLine(),
             'message' => $e->getMessage() . " (error 500)\n" . $e->getTraceAsString(),
         ), true, false);
     }
 });
 
 // finally, process the request
 $server->exec();
 
 // trigger log
 $server->emit('exit', array());