diff --git a/lib/Kolab/CalDAV/CalendarBackend.php b/lib/Kolab/CalDAV/CalendarBackend.php
index 122ee01..fdef6ca 100644
--- a/lib/Kolab/CalDAV/CalendarBackend.php
+++ b/lib/Kolab/CalDAV/CalendarBackend.php
@@ -1,688 +1,689 @@
 <?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 \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
 {
     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(),
                 '{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 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 can be returned.
      * If the operation failed, false can be returned.
      *
      * Deletion of a non-existent property is always successful.
      *
      * Lastly, it is optional to return detailed information about any
      * failures. In this case an array should be returned with the following
      * structure:
      *
      * array(
      *   403 => array(
      *      '{DAV:}displayname' => null,
      *   ),
      *   424 => array(
      *      '{DAV:}owner' => null,
      *   )
      * )
      *
      * In this example it was forbidden to update {DAV:}displayname.
      * (403 Forbidden), which in turn also caused {DAV:}owner to fail
      * (424 Failed Dependency) because the request needs to be atomic.
      *
      * @param mixed $calendarId
      * @param array $mutations
      * @return bool|array
      */
     public function updateCalendar($calendarId, array $mutations)
     {
         console(__METHOD__, $calendarId, $mutations);
 
         $folder = $this->get_storage_folder($calendarId);
         return DAVBackend::folder_update($folder, $mutations);
     }
 
     /**
      * 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);
 
         $query = array();
         $events = array();
         $storage = $this->get_storage_folder($calendarId);
         if ($storage) {
             foreach ($storage->select($query) as $event) {
                 $events[] = array(
                     'id' => $event['uid'],
-                    'uri' => $event['uid'] . '.ics',
+                    '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 = basename($objectUri, '.ics');
+        $uid = VObjectUtils::uri2uid($objectUri, '.ics');
         $storage = $this->get_storage_folder($calendarId);
 
         // attachment content is requested
         if (preg_match('!^(.+).ics:attachment:(\d+):.+$!', $objectUri, $m)) {
-            $uid = $m[1]; $part = $m[2];
+            $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 absilute URI for referencing object 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,
-                $event['uid'] . '.ics',
+                VObjectUtils::uid2uri($event['uid'], '.ics'),
             ));
 
             // default response
             return array(
                 'id' => $event['uid'],
-                'uri' => $event['uid'] . '.ics',
+                '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 = basename($objectUri, '.ics');
+        $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 = $object['uid'] . '.ics';
+            $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']);
 
         $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');
         }
 
         // send Location: header if URI doesn't match object's UID (Bug #2109)
         if ($object['uid'] != $uid) {
-            Plugin::$redirect_basename = $object['uid'].'.ics';
+            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 = basename($objectUri, '.ics');
+        $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;
             }
         }
 
         // 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');
         }
 
         // 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 = basename($objectUri, '.ics');
+        $uid = VObjectUtils::uri2uid($objectUri, '.ics');
         if ($storage = $this->get_storage_folder($calendarId)) {
             $storage->delete($uid);
         }
     }
 
     /**
      * 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 = array();
       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) {
               // TODO: cache the already fetched events in memory (really?)
               $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;
             }
         }
     }
 
 
     /**********  Data conversion utilities  ***********/
 
     /**
      * 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);
     }
 
     /**
      * 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"', substr(md5($event['uid']), 0, 16), $event['_msguid']);
     }
 
 }
diff --git a/lib/Kolab/CardDAV/ContactsBackend.php b/lib/Kolab/CardDAV/ContactsBackend.php
index 4b9fff0..70c5b53 100644
--- a/lib/Kolab/CardDAV/ContactsBackend.php
+++ b/lib/Kolab/CardDAV/ContactsBackend.php
@@ -1,1072 +1,1072 @@
 <?php
 
 /**
  * SabreDAV Contacts 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\CardDAV;
 
 use \rcube;
 use \rcube_charset;
 use \kolab_storage;
 use Sabre\DAV;
 use Sabre\CardDAV;
 use Sabre\VObject;
 use Kolab\Utils\DAVBackend;
 use Kolab\Utils\VObjectUtils;
 
 /**
  * Kolab Contacts backend.
  *
  * Checkout the Sabre\CardDAV\Backend\BackendInterface for all the methods that must be implemented.
  */
 class ContactsBackend extends CardDAV\Backend\AbstractBackend
 {
     public $ldap_directory;
 
     private $sources;
     private $folders;
     private $aliases;
     private $useragent;
     private $subscribed = null;
 
     // mapping of labelled X-AB properties to known vcard fields
     private $xab_labelled_map = array(
         'X-ABDATE' => array(
             'anniversary' => 'X-ANNIVERSARY',
         ),
         'X-ABRELATEDNAMES' => array(
             'child'     => 'X-CHILDREN',
             'spouse'    => 'X-SPOUSE',
             'manager'   => 'X-MANAGER',
             'assistant' => 'X-ASSISTANT',
         ),
     );
     // known labels need to be quoted specially with _$!< >!$_
     private $xab_known_labels = array('anniversary','child','parent','mother','father','brother','sister','friend','spouse','manager','assistant','partner','other');
 
     /**
      * Read available contact folders from server
      */
     private function _read_sources()
     {
         // already read sources
         if (isset($this->sources))
             return $this->sources;
 
         // get all folders that have "contact" type
         $folders = kolab_storage::get_folders('contact', $this->subscribed);
         $this->sources = $this->folders = $this->aliases = array();
 
         foreach (kolab_storage::sort_folders($folders) as $folder) {
             $id = $folder->get_uid();
             $fdata = $folder->get_imap_data();  // fetch IMAP folder data for CTag generation
             $this->folders[$id] = $folder;
             $this->sources[$id] = array(
                 'id' => $id,
                 'uri' => $id,
                 '{DAV:}displayname' => html_entity_decode($folder->get_name(), ENT_COMPAT, RCUBE_CHARSET),
                 '{http://calendarserver.org/ns/}getctag' => sprintf('%d-%d-%d', $fdata['UIDVALIDITY'], $fdata['HIGHESTMODSEQ'], $fdata['UIDNEXT']),
                 '{urn:ietf:params:xml:ns:caldav}supported-address-data' => new CardDAV\Property\SupportedAddressData(),
             );
             $this->aliases[$folder->name] = $id;
 
             // map default folder to the magic 'all' resource
             if ($folder->default)
                 $this->aliases['__all__'] = $id;
         }
 
         return $this->sources;
     }
 
 
     /**
      * Getter for a kolab_storage_folder representing the address book for the given ID
      *
      * @param string Folder 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, 'contact');
         }
     }
 
 
     /**
      * Returns the list of addressbooks for a specific user.
      *
      * @param string $principalUri
      * @return array
      */
     public function getAddressBooksForUser($principalUri)
     {
         console(__METHOD__, $principalUri, $this->useragent);
 
         $this->_read_sources();
 
         // special case for the apple address book which only supports one (!) address book
         if ($this->useragent == 'macosx' && count($this->sources) > 1) {
             $source = $this->getAddressBookByName('__all__');
             $source['principaluri'] = $principalUri;
             return array($source);
         }
 
         $addressBooks = array();
         foreach ($this->sources as $id => $source) {
             $source['principaluri'] = $principalUri;
             $addressBooks[] = $source;
         }
 
         return $addressBooks;
     }
 
     /**
      * Returns properties for a specific node identified by name/uri
      *
      * @param string Node name/uri
      * @return array Hash array with addressbook properties or null if not found
      */
     public function getAddressBookByName($addressBookUri)
     {
         console(__METHOD__, $addressBookUri);
 
         $this->_read_sources();
         $id = $addressBookUri;
 
         // return the magic *single* address book for Apple's Address Book App
         if ($id == '__all__') {
             $ctags = array();
             foreach ($this->sources as $source) {
                 $ctags[] = $source['{http://calendarserver.org/ns/}getctag'];
             }
 
             return array(
                 'id' => '__all__',
                 'uri' => '__all__',
                 '{DAV:}displayname' => 'All',
                 '{http://calendarserver.org/ns/}getctag' => join(':', $ctags),
                 '{urn:ietf:params:xml:ns:caldav}supported-address-data' => new CardDAV\Property\SupportedAddressData(),
             );
         }
 
         // resolve aliases (addressbook by folder name)
         if ($this->aliases[$addressBookUri]) {
             $id = $this->aliases[$addressBookUri];
         }
 
         // retry with subscribed = false (#2701)
         if (empty($this->sources[$id]) && $this->subscribed === null && rcube::get_instance()->config->get('kolab_use_subscriptions')) {
             $this->subscribed = false;
             unset($this->sources);
             return $this->getAddressBookByName($addressBookUri);
         }
 
         return $this->sources[$id];
     }
 
     /**
      * Updates an addressbook's properties
      *
      * See Sabre\DAV\IProperties for a description of the mutations array, as
      * well as the return value.
      *
      * @param mixed $addressBookId
      * @param array $mutations
      * @see Sabre\DAV\IProperties::updateProperties
      * @return bool|array
      */
     public function updateAddressBook($addressBookId, array $mutations)
     {
         console(__METHOD__, $addressBookId, $mutations);
 
         if ($addressBookId == '__all__')
             return false;
 
         $folder = $this->get_storage_folder($addressBookId);
         return $folder ? DAVBackend::folder_update($folder, $mutations) : false;
     }
 
     /**
      * Creates a new address book
      *
      * @param string $principalUri
      * @param string $url Just the 'basename' of the url.
      * @param array $properties
      * @return void
      */
     public function createAddressBook($principalUri, $url, array $properties)
     {
         console(__METHOD__, $principalUri, $url, $properties);
 
         return DAVBackend::folder_create('contact', $properties, $url);
     }
 
     /**
      * Deletes an entire addressbook and all its contents
      *
      * @param int $addressBookId
      * @return void
      */
     public function deleteAddressBook($addressBookId)
     {
         console(__METHOD__, $addressBookId);
 
         if ($addressBookId == '__all__')
             return;
 
         $folder = $this->get_storage_folder($addressBookId);
         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 cards for a specific addressbook id.
      *
      * This method should return the following properties for each card:
      *   * carddata - raw vcard data
      *   * uri - Some unique url
      *   * lastmodified - A unix timestamp
      *   * etag - A unique etag. This must change every time the card changes.
      *   * size - The size of the card in bytes.
      *
      * If these last two properties are provided, less time will be spent
      * calculating them. If they are specified, you can also ommit carddata.
      * This may speed up certain requests, especially with large cards.
      *
      * @param mixed $addressBookId
      * @return array
      */
     public function getCards($addressBookId)
     {
         console(__METHOD__, $addressBookId);
 
         // recursively fetch contacts from all folders
         if ($addressBookId == '__all__') {
             $cards = array();
             foreach ($this->sources as $id => $source) {
                 $cards = array_merge($cards, $this->getCards($id));
             }
             return $cards;
         }
 
         $groups_support = $this->useragent != 'thunderbird';
         $query = array(array('type', '=', $groups_support ? array('contact','distribution-list') : 'contact'));
         $cards = array();
         if ($storage = $this->get_storage_folder($addressBookId)) {
             foreach ($storage->select($query) as $contact) {
                 $cards[] = array(
                     'id' => $contact['uid'],
-                    'uri' => $contact['uid'] . '.vcf',
+                    'uri' => VObjectUtils::uid2uri($contact['uid'], '.vcf'),
                     'lastmodified' => is_a($contact['changed'], 'DateTime') ? $contact['changed']->format('U') : null,
                     'etag' => self::_get_etag($contact),
                     'size' => $contact['_size'],
                 );
             }
         }
 
         return $cards;
     }
 
     /**
      * Returns a specfic card.
      *
      * The same set of properties must be returned as with getCards. The only
      * exception is that 'carddata' is absolutely required.
      *
      * @param mixed $addressBookId
      * @param string $cardUri
      * @return array
      */
     public function getCard($addressBookId, $cardUri)
     {
         console(__METHOD__, $addressBookId, $cardUri);
 
-        $uid = basename($cardUri, '.vcf');
+        $uid = VObjectUtils::uri2uid($cardUri, '.vcf');
 
         // search all folders for the given card
         if ($addressBookId == '__all__') {
             $contact = $this->get_card_by_uid($uid, $storage);
         }
         // read card data from LDAP directory
         else if ($addressBookId == LDAPDirectory::DIRECTORY_NAME) {
             if (is_object($this->ldap_directory)) {
                 $contact = $this->ldap_directory->getContactObject($uid);
             }
         }
         else {
             $storage = $this->get_storage_folder($addressBookId);
             $contact = $storage->get_object($uid, '*');
         }
 
         if ($contact) {
             return array(
                 'id' => $contact['uid'],
-                'uri' => $contact['uid'] . '.vcf',
+                'uri' => VObjectUtils::uid2uri($contact['uid'], '.vcf'),
                 'lastmodified' => is_a($contact['changed'], 'DateTime') ? $contact['changed']->format('U') : null,
                 'carddata' => $this->to_vcard($contact),
                 'etag' => self::_get_etag($contact),
             );
         }
 
         return array();
     }
 
     /**
      * Creates a new card.
      *
      * The addressbook id will be passed as the first argument. This is the
      * same id as it is returned from the getAddressbooksForUser method.
      *
      * The cardUri is a base uri, and doesn't include the full path. The
      * cardData argument is the vcard body, and is passed as a string.
      *
      * It is possible to return an ETag from this method. This ETag is for the
      * newly created resource, and must be enclosed with double quotes (that
      * is, the string itself must contain the double quotes).
      *
      * You should only return the ETag if you store the carddata as-is. If a
      * subsequent GET request on the same card does not have the same body,
      * byte-by-byte and you did return an ETag here, clients tend to get
      * confused.
      *
      * @param mixed $addressBookId
      * @param string $cardUri
      * @param string $cardData
      * @return string|null
      */
     public function createCard($addressBookId, $cardUri, $cardData)
     {
         console(__METHOD__, $addressBookId, $cardUri, $cardData);
 
-        $uid = basename($cardUri, '.vcf');
+        $uid = VObjectUtils::uri2uid($cardUri, '.vcf');
         $storage = $this->get_storage_folder($addressBookId);
         $object = $this->parse_vcard($cardData, $uid);
 
         if (empty($object) || empty($object['uid'])) {
             throw new DAV\Exception('Parse error: not a valid VCard object');
         }
 
         // if URI doesn't match the content's UID, the object might already exist!
-        $cardUri = $object['uid'] . '.vcf';
+        $cardUri = VObjectUtils::uid2uri($object['uid'], '.vcf');
         if ($object['uid'] != $uid && $this->getCard($addressBookId, $cardUri)) {
             Plugin::$redirect_basename = $cardUri;
             return $this->updateCard($addressBookId, $cardUri, $cardData);
         }
 
         $success = $storage->save($object, $object['_type']);
         if (!$success) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error saving contact object to Kolab server"),
                 true, false);
 
             throw new DAV\Exception('Error saving contact card to backend');
         }
 
         // send Location: header if URI doesn't match object's UID (Bug #2109)
         if ($object['uid'] != $uid) {
             Plugin::$redirect_basename = $cardUri;
         }
 
         // return new Etag
         return $success ? self::_get_etag($object) : null;
     }
 
     /**
      * Updates a card.
      *
      * The addressbook id will be passed as the first argument. This is the
      * same id as it is returned from the getAddressbooksForUser method.
      *
      * The cardUri is a base uri, and doesn't include the full path. The
      * cardData argument is the vcard body, and is passed as a string.
      *
      * It is possible to return an ETag from this method. This ETag should
      * match that of the updated resource, and must be enclosed with double
      * quotes (that is: the string itself must contain the actual quotes).
      *
      * If you don't return an ETag, you can just return null.
      *
      * @param mixed $addressBookId
      * @param string $cardUri
      * @param string $cardData
      * @return string|null
      */
     public function updateCard($addressBookId, $cardUri, $cardData)
     {
         console(__METHOD__, $addressBookId, $cardUri, $cardData);
 
-        $uid = basename($cardUri, '.vcf');
+        $uid = VObjectUtils::uri2uid($cardUri, '.vcf');
         $object = $this->parse_vcard($cardData, $uid);
 
         // sanity check
         if ($object['uid'] != $uid) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error creating contact object: UID doesn't match object URI"),
                 true, false);
 
             throw new DAV\Exception\NotFound("UID doesn't match object URI");
         }
 
         if ($addressBookId == '__all__') {
             $old = $this->get_card_by_uid($uid, $storage);
         }
         else {
             if ($storage = $this->get_storage_folder($addressBookId))
                 $old = $storage->get_object($uid);
         }
 
         if (!$storage) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Unable to find storage folder for contact $addressBookId/$cardUri"),
                 true, false);
 
             throw new DAV\Exception\NotFound("Invalid address book URI");
         }
 
         if (!$this->is_writeable($storage)) {
             throw new DAV\Exception\Forbidden('Insufficient privileges to update this card');
         }
 
         // copy meta data (starting with _) from old object
         foreach ((array)$old as $key => $val) {
             if (!isset($object[$key]) && $key[0] == '_')
                 $object[$key] = $val;
         }
 
         // 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 contact object to Kolab server"),
                 true, false);
 
             Plugin::$redirect_basename = null;
             throw new DAV\Exception('Error saving contact card to backend');
         }
 
         // return new Etag
         return self::_get_etag($object);
     }
 
     /**
      * Deletes a card
      *
      * @param mixed $addressBookId
      * @param string $cardUri
      * @return bool
      */
     public function deleteCard($addressBookId, $cardUri)
     {
         console(__METHOD__, $addressBookId, $cardUri);
 
-        $uid = basename($cardUri, '.vcf');
+        $uid = VObjectUtils::uri2uid($cardUri, '.vcf');
 
         if ($addressBookId == '__all__') {
             $this->get_card_by_uid($uid, $storage);
         }
         else {
             $storage = $this->get_storage_folder($addressBookId);
         }
 
         if (!$storage || !$this->is_writeable($storage)) {
             throw new DAV\Exception\MethodNotAllowed('Insufficient privileges to delete this card');
         }
 
         if ($storage) {
             return $storage->delete($uid);
         }
 
         return false;
     }
 
 
     /**
      * Set User-Agent string of the connected client
      */
     public function setUserAgent($uastring)
     {
         $ua_classes = array(
             'thunderbird' => 'Thunderbird/\d',
             'macosx'      => '(Mac OS X/.+)?AddressBook/\d(.+\sCardDAVPlugin)?',
             'ios'         => '(iOS/\d|[Dd]ata[Aa]ccessd/\d)',
         );
 
         foreach ($ua_classes as $class => $regex) {
             if (preg_match("!$regex!", $uastring)) {
                 $this->useragent = $class;
                 break;
             }
         }
     }
 
 
     /**
      * Find an object and the containing folder by UID
      *
      * @param string Object UID
      * @param object Return parameter for the kolab_storage_folder instance
      * @return array|false
      */
     private function get_card_by_uid($uid, &$storage)
     {
         $obj = kolab_storage::get_object($uid, 'contact');
         if ($obj) {
             $storage = kolab_storage::get_folder($obj['_mailbox']);
             return $obj;
         }
 
         return false;
     }
 
     /**
      * Internal helper method to determine whether the given kolab_storage_folder is writeable
      *
      */
     private function is_writeable($storage)
     {
         $rights = $storage->get_myrights();
         return (strpos($rights, 'i') !== false || $storage->get_namespace() == 'personal');
     }
 
     /**
      * Helper method to determine whether the connected client is an Apple device
      */
     private function is_apple()
     {
         return $this->useragent == 'macosx' || $this->useragent == 'ios';
     }
 
 
     /**********  Data conversion utilities  ***********/
 
     private $phonetypes = array(
         'main'    => 'voice',
         'homefax' => 'fax',
         'workfax' => 'fax',
         'mobile'  => 'cell',
         'other'   => 'textphone',
     );
     
     private $improtocols = array(
         'jabber' => 'xmpp',
     );
 
 
     /**
      * Parse the given VCard string into a hash array kolab_format_contact can handle
      *
      * @param string VCard data block
      * @return array Hash array with contact properties or null on failure
      */
     private function parse_vcard($cardData, $uid)
     {
         try {
             // use already parsed object
             if (Plugin::$parsed_vcard && Plugin::$parsed_vcard->UID == $uid) {
                 $vobject = Plugin::$parsed_vcard;
             }
             else {
                 VObject\Property::$classMap['REV'] = 'Sabre\\VObject\\Property\\DateTime';
                 $vobject = VObject\Reader::read($cardData, VObject\Reader::OPTION_FORGIVING | VObject\Reader::OPTION_IGNORE_INVALID_LINES);
             }
 
             if ($vobject && $vobject->name == 'VCARD') {
                 $contact = $this->_to_array($vobject);
                 if (!empty($contact['uid'])) {
                     return $contact;
                 }
             }
         }
         catch (VObject\ParseException $e) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "VCard data parse error: " . $e->getMessage()),
                 true, false);
         }
 
         return null;
     }
 
 
     /**
      * Build a valid VCard format block from the given contact record
      *
      * @param array Hash array with contact properties from libkolab
      * @return string VCARD string containing the contact data
      */
     public function to_vcard($contact)
     {
         $vc = VObject\Component::create('VCARD');
         $vc->version = '3.0';
         $vc->prodid = '-//Kolab//iRony DAV Server ' . KOLAB_DAV_VERSION . '//Sabre//Sabre VObject ' . VObject\Version::VERSION . '//EN';
 
         $vc->add('UID', $contact['uid']);
         $vc->add('FN', $contact['name']);
 
         // distlists are KIND:group
         if ($contact['_type'] == 'distribution-list') {
             // group cards are actually vcard version 4
             if (!$this->is_apple()) {
                 $vc->version = '4.0';
                 $prop_prefix = '';
             }
             else {
                 // prefix group properties for Apple
                 $prop_prefix = 'X-ADDRESSBOOKSERVER-';
             }
 
             $vc->add($prop_prefix . 'KIND', 'group');
 
             foreach ((array)$contact['member'] as $member) {
                 if ($member['uid'])
                     $value = 'urn:uuid:' . $member['uid'];
                 else if ($member['email'] && $member['name'])
                     $value = 'mailto:' . urlencode(sprintf('"%s" <%s>', addcslashes($member['name'], '"'), $member['email']));
                 else if ($member['email'])
                     $value = 'mailto:' . $member['email'];
                 $vc->add($prop_prefix . 'MEMBER', $value);
             }
         }
         else if ($contact['surname'] . $contact['firstname'] . $contact['middlename'] . $contact['prefix'] . $contact['suffix'] != '') {
             $n = VObject\Property::create('N');
             $n->setParts(array($contact['surname'], $contact['firstname'], $contact['middlename'], $contact['prefix'], $contact['suffix']));
             $vc->add($n);
         }
 
         if (!empty($contact['nickname']))
             $vc->add('NICKNAME', $contact['nickname']);
         if (!empty($contact['jobtitle']))
             $vc->add('TITLE', $contact['jobtitle']);
         if (!empty($contact['profession']))
             $vc->add('ROLE', $contact['profession']);
 
         if (!empty($contact['organization']) || !empty($contact['department'])) {
             $org = VObject\Property::create('ORG');
             $org->setParts(array($contact['organization'], $contact['department']));
             $vc->add($org);
         }
 
         // TODO: save as RELATED
         if (!empty($contact['assistant']))
             $vc->add('X-ASSISTANT', join(',', (array)$contact['assistant']));
         if (!empty($contact['manager']))
             $vc->add('X-MANAGER', join(',', (array)$contact['manager']));
         if (!empty($contact['spouse']))
             $vc->add('X-SPOUSE', join(',', (array)$contact['spouse']));
         if (!empty($contact['children']))
             $vc->add('X-CHILDREN', join(',', (array)$contact['children']));
 
         foreach ((array)$contact['email'] as $email) {
             $vemail = VObject\Property::create('EMAIL', $email['address'], array('type' => 'INTERNET'));
             if (!empty($email['type']))
                 $vemail->offsetSet(null, new VObject\Parameter('type', strtoupper($email['type'])));
             $vc->add($vemail);
         }
 
         foreach ((array)$contact['phone'] as $phone) {
             $type = $this->phonetypes[$phone['type']] ?: $phone['type'];
             $vc->add('TEL', $phone['number'], array('type' => strtoupper($type)));
         }
 
         foreach ((array)$contact['website'] as $website) {
             $vc->add('URL', $website['url'], array('type' => strtoupper($website['type'])));
         }
 
         $improtocolmap = array_flip($this->improtocols);
         foreach ((array)$contact['im'] as $im) {
             list($prot, $val) = explode(':', $im, 2);
             if ($val) $vc->add('x-' . ($improtocolmap[$prot] ?: $prot), $val);
             else      $vc->add('IMPP', $im);
         }
 
         foreach ((array)$contact['address'] as $adr) {
             $vadr = VObject\Property::create('ADR', null, array('type' => strtoupper($adr['type'])));
             $vadr->setParts(array('','', $adr['street'], $adr['locality'], $adr['region'], $adr['code'], $adr['country']));
             $vc->add($vadr);
         }
 
         if (!empty($contact['notes']))
             $vc->add('NOTE', $contact['notes']);
 
         if (!empty($contact['gender']))
             $vc->add($this->is_apple() ? 'SEX' : 'X-GENDER', $contact['gender']);
 
         // convert date cols to DateTime objects
         foreach (array('birthday','anniversary') as $key) {
             if (!empty($contact[$key]) && !$contact[$key] instanceof \DateTime) {
                 try {
                     $contact[$key] = new \DateTime(\rcube_utils::clean_datestr($contact[$key]));
                 }
                 catch (\Exception $e) {
                     $contact[$key] = null;
                 }
             }
         }
 
         if (!empty($contact['birthday']) && $contact['birthday'] instanceof \DateTime) {
             // FIXME: Date values are ignored by Thunderbird
             $contact['birthday']->_dateonly = true;
             $vc->add(VObjectUtils::datetime_prop('BDAY', $contact['birthday'], false));
         }
         if (!empty($contact['anniversary']) && $contact['anniversary'] instanceof \DateTime) {
             $contact['anniversary']->_dateonly = true;
             $vc->add(VObjectUtils::datetime_prop('X-ANNIVERSARY', $contact['anniversary'], false));
         }
 
         if (!empty($contact['categories'])) {
             $cat = VObject\Property::create('CATEGORIES');
             $cat->setParts((array)$contact['categories']);
             $vc->add($cat);
         }
 
         if (!empty($contact['freebusyurl']))
             $vc->add('FBURL', $contact['freebusyurl']);
 
         if (!empty($contact['photo'])) {
             $vc->PHOTO = base64_encode($contact['photo']);
             $vc->PHOTO->add('BASE64', null);
         }
 
         // add custom properties
         foreach ((array)$contact['x-custom'] as $prop) {
             $vc->add($prop[0], $prop[1]);
         }
 
         // send some known fields as itemN.X-AB* for Apple clients
         if ($this->is_apple()) {
             $this->_to_apple($contact, $vc);
         }
 
         if (!empty($contact['changed']))
             $vc->add(VObjectUtils::datetime_prop('REV', $contact['changed'], true));
 
         return $vc->serialize();
     }
 
     /**
      * Convert the given Sabre\VObject\Component\Vcard object to a libkolab compatible contact format
      *
      * @param object Vcard object to convert
      * @return array Hash array with contact properties
      */
     private function _to_array($vc)
     {
         $contact = array(
             '_type' => 'contact',
             'uid'  => strval($vc->UID),
             'name' => strval($vc->FN),
             'x-custom' => array(),
         );
 
         if ($vc->REV) {
             try { $contact['changed'] = $vc->REV->getDateTime(); }
             catch (\Exception $e) {
                 try { $contact['changed'] = new \DateTime(strval($vc->REV)); }
                 catch (\Exception $e) { }
             }
         }
 
         // normalize apple-style properties
         $this->_from_apple($vc);
 
         $phonetypemap = array_flip($this->phonetypes);
 
         // map attributes to internal fields
         foreach ($vc->children as $prop) {
             if (!($prop instanceof VObject\Property))
                 continue;
 
             switch ($prop->name) {
                 case 'N':
                     list($contact['surname'], $contact['firstname'], $contact['middlename'], $contact['prefix'], $contact['suffix']) = $prop->getParts();
                     break;
 
                 case 'NOTE':
                     $contact['notes'] = $prop->value;
                     break;
 
                 case 'TITLE':
                     $contact['jobtitle'] = $prop->value;
                     break;
 
                 case 'NICKNAME':
                     $contact[strtolower($prop->name)] = $prop->value;
                     break;
 
                 case 'ORG':
                     list($contact['organization'], $contact['department']) = $prop->getParts();
                     break;
 
                 case 'CATEGORY':
                 case 'CATEGORIES':
                     $contact['categories'] = $prop->getParts();
                     break;
 
                 case 'EMAIL':
                     $types = array_values(self::array_filter($prop->offsetGet('type'), 'internet,pref', true));
                     $contact['email'][] = array('address' => $prop->value, 'type' => strtolower($types[0] ?: 'other'));
                     break;
 
                 case 'URL':
                     $types = array_values(self::array_filter($prop->offsetGet('type'), 'internet,pref', true));
                     $contact['website'][] = array('url' => $prop->value, 'type' => strtolower($types[0]));
                     break;
 
                 case 'TEL':
                     $types = array_values(self::array_filter($prop->offsetGet('type'), 'internet,pref', true));
                     $type = strtolower($types[0]);
                     $contact['phone'][] = array('number' => $prop->value, 'type' => $phonetypemap[$type] ?: $type);
                     break;
 
                 case 'ADR':
                     $type = $prop->offsetGet('type') ?: $prop->parameters[0];
                     $adr = array('type' => strtolower($type->value ?: $type->name));
                     list(,, $adr['street'], $adr['locality'], $adr['region'], $adr['code'], $adr['country']) = $prop->getParts();
                     $contact['address'][] = $adr;
                     break;
 
                 case 'BDAY':
                     $contact['birthday'] = new \DateTime($prop->value);
                     $contact['birthday']->_dateonly = true;
                     break;
 
                 case 'ANNIVERSARY':
                 case 'X-ANNIVERSARY':
                     $contact['anniversary'] = new \DateTime($prop->value);
                     $contact['anniversary']->_dateonly = true;
                     break;
 
                 case 'SEX':
                 case 'GENDER':
                 case 'X-GENDER':
                     $contact['gender'] = $prop->value;
                     break;
 
                 case 'ROLE':
                 case 'X-PROFESSION':
                     $contact['profession'] = $prop->value;
                     break;
 
                 case 'X-MANAGER':
                 case 'X-ASSISTANT':
                 case 'X-CHILDREN':
                 case 'X-SPOUSE':
                     $contact[strtolower(substr($prop->name, 2))] = explode(',', $prop->value);
                     break;
 
                 case 'X-JABBER':
                 case 'X-ICQ':
                 case 'X-MSN':
                 case 'X-AIM':
                 case 'X-YAHOO':
                 case 'X-SKYPE':
                     $protocol = strtolower(substr($prop->name, 2));
                     $contact['im'][] = ($this->improtocols[$protocol] ?: $protocol) . ':' . preg_replace('/^[a-z]+:/i', '', $prop->value);
                     break;
 
                 case 'IMPP':
                     $prot = null;
                     if (preg_match('/^[a-z]+:/i', $prop->value))
                         list($prot, $val) = explode(':', $prop->value, 2);
                     else
                         $val = $prop->value;
                     $type = strtolower((string)$prop->offsetGet('X-SERVICE-TYPE'));
                     $protocol = $type && (!$prot || $prot == 'aim') ? ($this->improtocols[$type] ?: $type) : $prot;
                     $contact['im'][] = ($this->improtocols[$protocol] ?: $protocol) . ':' . urldecode($val);
                     break;
 
                 case 'PHOTO':
                     $param = $prop->offsetGet('encoding') ?: $prop->parameters[0];
                     if ($param->value && (strtolower($param->value) == 'b' || strtolower($param->value) == 'base64') || strtolower($param->name) == 'base64') {
                         $contact['photo'] = base64_decode($prop->value);
                     }
                     break;
 
                 case 'KIND':
                 case 'X-ADDRESSBOOKSERVER-KIND':
                     if (strtolower($prop->value) == 'group') {
                         $contact['_type'] = 'distribution-list';
                     }
                     break;
 
                 case 'MEMBER':
                 case 'X-ADDRESSBOOKSERVER-MEMBER':
                     if (strpos($prop->value, 'urn:uuid:') === 0) {
                         $contact['member'][] = array('uid' => substr($prop->value, 9));
                     }
                     else if (strpos($prop->value, 'mailto:') === 0) {
                         $member = reset(\rcube_mime::decode_address_list(urldecode(substr($prop->value, 7))));
                         if ($member['mailto'])
                             $contact['member'][] = array('email' => $member['mailto'], 'name' => $member['name']);
                     }
                     break;
 
                 case 'CUSTOM1':
                 case 'CUSTOM2':
                 case 'CUSTOM3':
                 case 'CUSTOM4':
                 default:
                     if (substr($prop->name, 0, 2) == 'X-' || substr($prop->name, 0, 6) == 'CUSTOM') {
                         $prefix = $prop->group ? $prop->group . '.' : '';
                         $contact['x-custom'][] = array($prefix . $prop->name, strval($prop->value));
                     }
                     break;
             }
         }
 
         if (is_array($contact['im']))
             $contact['im'] = array_unique($contact['im']);
 
         return $contact;
     }
 
     /**
      * Convert Apple-style item1.X-AB* properties to flat X-AB*-Label values
      */
     private function _from_apple($vc)
     {
         foreach ($this->xab_labelled_map as $propname => $known_map) {
             foreach ($vc->select($propname) as $prop) {
                 $labelkey = $prop->group ? $prop->group . '.X-ABLABEL' : 'X-ABLABEL';
                 $labels = $vc->select($labelkey);
                 $field = !empty($labels) && ($label = reset($labels)) ? strtolower(trim($label->value, '_$!<>')) : null;
                 if ($field) {
                     $prop->group = null;
                     $prop->name = ($known_map[$field] ?: $propname . '-' . strtoupper($field));
                     unset($vc->{$labelkey});
                 }
             }
 
             // must be an apple client :-)
             $this->useragent = 'macosx';
         }
     }
 
     /**
      * Translate custom fields back to Apple-style item1.X-AB* properties
      */
     private function _to_apple($contact, $vc)
     {
         $this->item_count = 1;
 
         foreach ($this->xab_labelled_map as $propname => $known_map) {
             // convert known vcard properties into labelled ones
             foreach (array_flip($known_map) as $name => $label) {
                 if ($vc->{$name}) {
                     $this->_replace_with_labelled_prop($vc, $name, $propname, $label);
                 }
             }
 
             // translate custom properties with a matching prefix to labelled items
             foreach ((array)$contact['x-custom'] as $prop) {
                 $name = $prop[0];
                 if (strpos($name, $propname) === 0) {
                     $label = strtolower(substr($name, strlen($propname)+1));
                     $this->_replace_with_labelled_prop($vc, $name, $propname, $label);
                 }
             }
         }
     }
 
     /**
      * Helper method to replace a named property with a labelled one
      */
     private function _replace_with_labelled_prop($vc, $name, $propname, $label)
     {
         $group = 'item' . ($this->item_count++);
         $prop = clone $vc->{$name};
         $prop->name = $propname;
         $prop->group = $group;
         $vc->add($prop);
 
         $ablabel = new VObject\Property('X-ABLabel');
         $ablabel->name = 'X-ABLabel';
         $ablabel->group = $group;
         $ablabel->value = in_array($label, $this->xab_known_labels) ? '_$!<'.ucfirst($label).'>!$_' : ucfirst($label);
         $vc->add($ablabel);
 
         unset($vc->{$name});
     }
 
     /**
      * Extract array values by a filter
      *
      * @param array Array to filter
      * @param keys Array or comma separated list of values to keep
      * @param boolean Invert key selection: remove the listed values
      *
      * @return array The filtered array
      */
     private static function array_filter($arr, $values, $inverse = false)
     {
         if (!is_array($values)) {
             $values = explode(',', $values);
         }
 
         $result = array();
         $keep   = array_flip((array)$values);
 
         if (!empty($arr)) {
             foreach ($arr as $key => $val) {
                 if ($inverse != isset($keep[strtolower($val)])) {
                     $result[$key] = $val;
                 }
             }
         }
 
         return $result;
     }
 
     /**
      * Generate an Etag string from the given contact data
      *
      * @param array Hash array with contact properties from libkolab
      * @return string Etag string
      */
     private static function _get_etag($contact)
     {
         return sprintf('"%s-%d"', substr(md5($contact['uid']), 0, 16), $contact['_msguid']);
     }
 
 }
diff --git a/lib/Kolab/CardDAV/LDAPDirectory.php b/lib/Kolab/CardDAV/LDAPDirectory.php
index 6b41755..ca175f2 100644
--- a/lib/Kolab/CardDAV/LDAPDirectory.php
+++ b/lib/Kolab/CardDAV/LDAPDirectory.php
@@ -1,575 +1,576 @@
 <?php
 
 /**
  * CardDAV Directory class providing read-only access
  * to an LDAP-based global address book.
  *
  * This implements the CardDAV Directory Gateway Extension suggested by Apple Inc.
  * http://tools.ietf.org/html/draft-daboo-carddav-directory-gateway-02
  *
  * @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\CardDAV;
 
 use \rcube;
 use \rcube_ldap;
 use \rcube_ldap_generic;
 use Sabre\DAV;
 use Sabre\DAVACL;
 use Sabre\CardDAV\Property;
+use Kolab\Utils\VObjectUtils;
 
 /**
  * CardDAV Directory Gateway implementation
  */
 class LDAPDirectory extends DAV\Collection implements \Sabre\CardDAV\IDirectory, DAV\IProperties, DAVACL\IACL
 {
     const DIRECTORY_NAME = 'ldap-directory';
 
     private $config;
     private $ldap;
     private $carddavBackend;
     private $principalUri;
     private $addressBookInfo = array();
     private $cache;
     private $query;
     private $filter;
 
     /**
      * Default constructor
      */
     function __construct($config, $principalUri, $carddavBackend = null)
     {
         $this->config = $config;
         $this->principalUri = $principalUri;
 
         $this->addressBookInfo = array(
             'id' => self::DIRECTORY_NAME,
             'uri' => self::DIRECTORY_NAME,
             '{DAV:}displayname' => $config['name'] ?: "LDAP Directory",
             '{urn:ietf:params:xml:ns:caldav}supported-address-data' => new Property\SupportedAddressData(),
             'principaluri' => $principalUri,
         );
 
         // used for vcard serialization
         $this->carddavBackend = $carddavBackend ?: new ContactsBackend();
         $this->carddavBackend->ldap_directory = $this;
 
         // initialize cache
         $rcube = rcube::get_instance();
         if ($rcube->config->get('kolabdav_ldap_cache')) {
             $this->cache = $rcube->get_cache_shared('kolabdav_ldap');
 
             // expunge cache every now and then
             if (rand(0,10) === 0) {
                 $this->cache->expunge();
             }
         }
     }
 
     private function connect()
     {
       if (!isset($this->ldap)) {
         $this->ldap = new rcube_ldap($this->config, $this->config['debug']);
         $this->ldap->set_pagesize($this->config['sizelimit'] ?: 10000);
       }
 
       return $this->ldap->ready ? $this->ldap : null;
     }
 
     /**
      * Set parsed addressbook-query object for filtering
      */
     function setAddressbookQuery($query)
     {
         $this->query = $query;
         $this->filter = $this->addressbook_query2ldap_filter($query);
     }
 
     /**
      * Returns the name of the node.
      *
      * This is used to generate the url.
      *
      * @return string
      */
     function getName()
     {
         return self::DIRECTORY_NAME;
     }
 
     /**
      * Returns a specific child node, referenced by its name
      *
      * This method must throw Sabre\DAV\Exception\NotFound if the node does not
      * exist.
      *
      * @param string $name
      * @return DAV\INode
      */
     function getChild($cardUri)
     {
         console(__METHOD__, $cardUri);
 
-        $uid = basename($cardUri, '.vcf');
+        $uid = VObjectUtils::uri2uid($cardUri, '.vcf');
         $record = null;
 
         // get from cache
         $cache_key = $uid;
         if ($this->cache && ($cached = $this->cache->get($cache_key))) {
             return new LDAPCard($this->carddavBackend, $this->addressBookInfo, $cached);
         }
 
         if ($contact = $this->getContactObject($uid)) {
             $obj = array(
                 'id' => $contact['uid'],
-                'uri' => $contact['uid'] . '.vcf',
+                'uri' => VObjectUtils::uid2uri($contact['uid'], '.vcf'),
                 'lastmodified' => $contact['_timestamp'],
                 'carddata' => $this->carddavBackend->to_vcard($contact),
                 'etag' => self::_get_etag($contact),
             );
 
             // cache this object
             if ($this->cache) {
                 $this->cache->set($cache_key, $obj);
             }
 
             return new LDAPCard($this->carddavBackend, $this->addressBookInfo, $obj);
         }
 
         throw new DAV\Exception\NotFound('Card not found');
     }
 
     /**
      * Read contact object from LDAP
      */
     function getContactObject($uid)
     {
         $contact = null;
 
         if ($ldap = $this->connect()) {
             // used cached uid mapping
             $cached_index = $this->cache ? $this->cache->get('index') : array();
             if ($cached_index[$uid]) {
                 $contact = $ldap->get_record($cached_index[$uid][0], true);
             }
             else {  // query for uid
                 $result = $ldap->search('uid', $uid, 1, true, true);
                 if ($result->count) {
                     $contact = $result[0];
                 }
             }
 
             if ($contact) {
                 $this->_normalize_contact($contact);
             }
         }
 
         return $contact;
     }
 
     /**
      * Returns an array with all the child nodes
      *
      * @return DAV\INode[]
      */
     function getChildren()
     {
         console(__METHOD__, $this->query, $this->filter);
 
         $children = array();
 
         // return cached index
         if (!$this->query && !$this->config['searchonly'] && $this->cache && ($cached_index = $this->cache->get('index'))) {
             foreach ($cached_index as $uid => $c) {
                 $obj = array(
                     'id'   => $uid,
-                    'uri'  => $uid . '.vcf',
+                    'uri'  => VObjectUtils::uid2uri($uid, '.vcf'),
                     'etag' => $c[1],
                     'lastmodified' => $c[2],
                 );
                 $children[] = new LDAPCard($this->carddavBackend, $this->addressBookInfo, $obj);
             }
 
             return $children;
         }
 
         // query LDAP if we have a search query or listing is allowed
         if (($this->query || !$this->config['searchonly']) && ($ldap = $this->connect())) {
             // set pagesize from query limit attribute
             if ($this->query && $this->query->limit) {
                 $this->ldap->set_pagesize(intval($this->query->limit));
             }
 
             // set the prepared LDAP filter derived from the addressbook-query
             if ($this->query && !empty($this->filter)) {
                 $ldap->set_search_set($this->filter);
             }
             else {
                 $ldap->set_search_set(null);
             }
 
             $results = $ldap->list_records(null);
             $directory_index = array();
 
             // convert results into vcard blocks
             foreach ($results as $contact) {
                 $this->_normalize_contact($contact);
 
                 $obj = array(
                     'id'  => $contact['uid'],
-                    'uri' => $contact['uid'] . '.vcf',
+                    'uri' => VObjectUtils::uid2uri($contact['uid'], '.vcf'),
                     'lastmodified' => $contact['_timestamp'],
                     'carddata' => $this->carddavBackend->to_vcard($contact),
                     'etag' => self::_get_etag($contact),
                 );
 
                 // cache record
                 $cache_key = $contact['uid'];
                 if ($this->cache) {
                     $this->cache->set($cache_key, $obj);
                 }
 
                 $directory_index[$contact['uid']] = array($contact['ID'], $obj['etag'], $contact['_timestamp']);
 
                 // add CardDAV node
                 $children[] = new LDAPCard($this->carddavBackend, $this->addressBookInfo, $obj);
             }
 
             // cache the full listing
             if (empty($this->filter) && $this->cache) {
                 $this->cache->set('index', $directory_index);
             }
         }
 
         return $children;
     }
 
     /**
      * Returns a list of properties for this node.
      *
      * The properties list is a list of propertynames the client requested,
      * encoded in clark-notation {xmlnamespace}tagname
      *
      * If the array is empty, it means 'all properties' were requested.
      *
      * @param array $properties
      * @return array
      */
     public function getProperties($properties)
     {
         console(__METHOD__, $properties);
 
         $response = array();
         foreach ($properties as $propertyName) {
             if (isset($this->addressBookInfo[$propertyName])) {
                 $response[$propertyName] = $this->addressBookInfo[$propertyName];
             }
             else if ($propertyName == '{DAV:}getlastmodified') {
                 $response[$propertyName] = new DAV\Property\GetLastModified($this->getLastModified());
             }
         }
 
         return $response;
 
     }
 
     /**
      * Returns the last modification time, as a unix timestamp
      *
      * @return int
      */
     function getLastModified()
     {
         console(__METHOD__);
         return time();
     }
 
     /**
      * Deletes the entire addressbook.
      *
      * @return void
      */
     public function delete()
     {
         throw new DAV\Exception\MethodNotAllowed('Deleting directories is not allowed');
     }
 
     /**
      * Renames the addressbook
      *
      * @param string $newName
      * @return void
      */
     public function setName($newName)
     {
         throw new DAV\Exception\MethodNotAllowed('Renaming directories not allowed');
     }
 
     /**
      * Returns the owner principal
      *
      * This must be a url to a principal, or null if there's no owner
      *
      * @return string|null
      */
     public function getOwner()
     {
         return $this->principalUri;
     }
 
     /**
      * Returns a group principal
      *
      * This must be a url to a principal, or null if there's no owner
      *
      * @return string|null
      */
     function getGroup()
     {
         return null;
     }
 
     /**
      * 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
      *   * '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()
     {
         $acl = array(
             array(
                 'privilege' => '{DAV:}read',
                 'principal' => $this->principalUri,
                 'protected' => true,
             ),
         );
 
         return $acl;
     }
 
     /**
      * Updates the ACL
      *
      * @param array $acl
      * @return void
      */
     function setACL(array $acl)
     {
         throw new DAV\Exception\MethodNotAllowed('Changing ACL for directories is not allowed');
     }
 
     /**
      * Returns the list of supported privileges for this node.
      *
      * If null is returned from this method, the default privilege set is used,
      * which is fine for most common usecases.
      *
      * @return array|null
      */
     function getSupportedPrivilegeSet()
     {
         return null;
     }
 
     /**
      * Updates properties on this node,
      *
      * @param array $mutations
      * @return bool|array
      */
     function updateProperties($mutations)
     {
         console(__METHOD__, $mutations);
         return false;
     }
 
     /**
      * Post-process the given contact record from rcube_ldap
      */
     private function _normalize_contact(&$contact)
     {
         if (is_numeric($contact['changed'])) {
             $contact['_timestamp'] = intval($contact['changed']);
             $contact['changed'] = new \DateTime('@' . $contact['changed']);
         }
         else if (!empty($contact['changed'])) {
             try {
                 $contact['changed'] = new \DateTime($contact['changed']);
                 $contact['_timestamp'] = intval($contact['changed']->format('U'));
             }
             catch (Exception $e) {
                 $contact['changed'] = null;
             }
         }
 
         // map col:subtype fields to a list that the vcard serialization function understands
         foreach (array('email' => 'address', 'phone' => 'number', 'website' => 'url') as $col => $prop) {
             foreach (rcube_ldap::get_col_values($col, $contact) as $type => $values) {
                 foreach ((array)$values as $value) {
                     $contact[$col][] = array($prop => $value, 'type' => $type);
                 }
             }
             unset($contact[$col.':'.$type]);
         }
 
         $addresses = array();
         foreach (rcube_ldap::get_col_values('address', $contact) as $type => $values) {
             foreach ((array)$values as $adr) {
                 // skip empty address
                 $adr = array_filter($adr);
                 if (empty($adr))
                     continue;
 
                 $addresses[] = array(
                     'type'     => $type,
                     'street'   => $adr['street'],
                     'locality' => $adr['locality'],
                     'code'     => $adr['zipcode'],
                     'region'   => $adr['region'],
                     'country'  => $adr['country'],
                 );
             }
 
             unset($contact['address:'.$type]);
         }
 
         $contact['address'] = $addresses;
     }
 
     /**
      * Translate the given AddressBookQueryParser object into an LDAP filter
      */
     private function addressbook_query2ldap_filter($query)
     {
         $criterias = array();
 
         foreach ($query->filters as $filter) {
             $ldap_attrs = $this->map_property2ldap($filter['name']);
             $ldap_filter = ''; $count = 0;
 
             // unknown attribute, skip
             if (empty($ldap_attrs)) {
                 continue;
             }
 
             foreach ((array)$filter['text-matches'] as $matcher) {
                 // case-insensitive matching
                 if (in_array($matcher['collation'], array('i;unicode-casemap', 'i;ascii-casemap'))) {
                     $matcher['value'] = mb_strtolower($matcher['value']);
                 }
                 $value = rcube_ldap_generic::quote_string($matcher['value']);
                 $ldap_match = '';
 
                 // this assumes fuzzy search capabilities of the LDAP backend
                 switch ($matcher['match-type']) {
                     case 'contains':
                         $wp = $ws = '*';
                         break;
                     case 'starts-with':
                         $ws = '*';
                         break;
                     case 'ends-with':
                         $wp = '*';
                         break;
                     default:
                         $wp = $ws = '';
                 }
 
                 // OR query for all attributes involved
                 if (count($ldap_attrs) > 1) {
                     $ldap_match .= '(|';
                 }
                 foreach ($ldap_attrs as $attr) {
                     $ldap_match .= "($attr=$wp$value$ws)";
                 }
                 if (count($ldap_attrs) > 1) {
                     $ldap_match .= ')';
                 }
 
                 // negate the filter
                 if ($matcher['negate-condition']) {
                     $ldap_match = '(!' . $ldap_match . ')';
                 }
 
                 $ldap_filter .= $ldap_match;
                 $count++;
             }
 
             if ($count > 1) {
                 $criterias[] = '(' . ($filter['test'] == 'allof' ? '&' : '|') . $ldap_filter . ')';
             }
             else if (!empty($ldap_filter)) {
                 $criterias[] = $ldap_filter;
             }
         }
 
         return empty($criterias) ? '' : sprintf('(%s%s)', $query->test == 'allof' ? '&' : '|', join('', $criterias));
     }
 
     /**
      * Map a vcard property to an LDAP attribute
      */
     private function map_property2ldap($propname)
     {
         $attribs = array();
 
         // LDAP backend not available, abort
         if (!($ldap = $this->connect())) {
             return $attribs;
         }
 
         $vcard_fieldmap = array(
             'FN'    => array('name'),
             'N'     => array('surname','firstname','middlename'),
             'ADR'   => array('street','locality','region','code','country'),
             'TITLE' => array('jobtitle'),
             'ORG'   => array('organization','department'),
             'TEL'   => array('phone'),
             'URL'   => array('website'),
             'ROLE'  => array('profession'),
             'BDAY'  => array('birthday'),
             'IMPP'  => array('im'),
         );
 
         $fields = $vcard_fieldmap[$propname] ?: array(strtolower($propname));
         foreach ($fields as $field) {
             if ($ldap->coltypes[$field]) {
                 $attribs = array_merge($attribs, (array)$ldap->coltypes[$field]['attributes']);
             }
         }
 
         return $attribs;
     }
 
     /**
      * Generate an Etag string from the given contact data
      *
      * @param array Hash array with contact properties from libkolab
      * @return string Etag string
      */
     private static function _get_etag($contact)
     {
         return sprintf('"%s-%d"', substr(md5($contact['uid']), 0, 16), $contact['_timestamp']);
     }
 }
diff --git a/lib/Kolab/Utils/VObjectUtils.php b/lib/Kolab/Utils/VObjectUtils.php
index f04884e..82f934b 100644
--- a/lib/Kolab/Utils/VObjectUtils.php
+++ b/lib/Kolab/Utils/VObjectUtils.php
@@ -1,60 +1,84 @@
 <?php
 
 /**
  * Utility class providing functions for VObject data encoding
  *
  * @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 Sabre\VObject\Property;
 
 /**
  * Helper class proviting utility functions for VObject data encoding
  */
 class VObjectUtils
 {
+    /**
+     * Convert an object URI into a valid UID value
+     */
+    public static function uri2uid($uri, $suffix = '')
+    {
+        $base = basename($uri, $suffix);
+        $uid = strtr($base, array('%2F' => '/'));
+
+        // assume full URL encoding
+        if (preg_match('/%[A-F0-9]{2}/', $uid)) {
+            return urldecode($base);
+        }
+
+        return $uid;
+    }
+
+    /**
+     * Encode an object UID into a valid URI
+     */
+    public static function uid2uri($uid, $suffix = '')
+    {
+        $encode = strpos($uid, '/') !== false;
+        return ($encode ? urlencode($uid) : $uid) . $suffix;
+    }
 
     /**
      * Create a Sabre\VObject\Property instance from a PHP DateTime object
      *
      * @param string Property name
      * @param object DateTime
      */
     public static function datetime_prop($name, $dt, $utc = false)
     {
         $vdt = new Property\DateTime($name);
         $vdt->setDateTime($dt, $dt->_dateonly ? Property\DateTime::DATE : ($utc ? Property\DateTime::UTC : Property\DateTime::LOCALTZ));
         return $vdt;
     }
 
     /**
      * Copy values from one hash array to another using a key-map
      */
     public static function map_keys($values, $map)
     {
         $out = array();
         foreach ($map as $from => $to) {
             if (isset($values[$from]))
                 $out[$to] = $values[$from];
         }
         return $out;
     }
 
 }
\ No newline at end of file