No OneTemporary
Actions

Size

99 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/config/config.inc.php.dist b/config/config.inc.php.dist
	index 6864820..2433475 100644
	--- a/config/config.inc.php.dist
	+++ b/config/config.inc.php.dist
	@@ -1,94 +1,118 @@
	<?php

	// This file lists all ActiveSync-related configuration options

	// Enables ActiveSync protocol debuging
	$config['activesync_debug'] = true;

	// Enables logging to a separate directory for every user/device
	$config['activesync_user_log'] = false;

	// Enable per-user debugging only if /var/log/kolab-syncroton/<username>/ folder exists
	$config['activesync_user_debug'] = false;

	// If specified all ActiveSync-related logs will be saved to this file
	// Note: This doesn't change Roundcube Framework log locations
	$config['activesync_log_file'] = null;

	// Type of ActiveSync cache. Supported values: 'db', 'apc' and 'memcache'.
	// Note: This is only for some additional data like timezones mapping.
	$config['activesync_cache'] = 'db';

	// lifetime of ActiveSync cache
	// possible units: s, m, h, d, w
	$config['activesync_cache_ttl'] = '1d';

	// Type of ActiveSync Auth cache. Supported values: 'db', 'apc' and 'memcache'.
	// Note: This is only for username canonification map.
	$config['activesync_auth_cache'] = 'db';

	// lifetime of ActiveSync Auth cache
	// possible units: s, m, h, d, w
	$config['activesync_auth_cache_ttl'] = '1d';

	// List of global addressbooks (GAL)
	// Note: If empty 'autocomplete_addressbooks' setting will be used
	$config['activesync_addressbooks'] = array();

	// ActiveSync => Roundcube contact fields map for GAL search
	/* Default: array(
	'alias' => 'nickname',
	'company' => 'organization',
	'displayName' => 'name',
	'emailAddress' => 'email',
	'firstName' => 'firstname',
	'lastName' => 'surname',
	'mobilePhone' => 'phone.mobile',
	'office' => 'office',
	'picture' => 'photo',
	'phone' => 'phone',
	'title' => 'jobtitle',
	);
	*/
	$config['activesync_gal_fieldmap'] = null;

	+// List of device types that will sync the LDAP addressbook(s) as a normal folder.
	+// For devices that do not support GAL searching, e.g. Outlook.
	+// Examples:
	+// array('windowsoutlook') # enable for Oultook only
	+// true # enable for all
	+$config['activesync_gal_sync'] = false;
	+
	+// GAL cache. As reading all contacts from LDAP may be slow, caching is recommended.
	+$config['activesync_gal_cache'] = 'db';
	+
	+// TTL of GAL cache entries. Technically this causes that synchronized
	+// contacts will not be updated (queried) often than the specified interval.
	+$config['activesync_gal_cache_ttl'] = '1d';
	+
	// List of Roundcube plugins
	// WARNING: Not all plugins used in Roundcube can be listed here
	$config['activesync_plugins'] = array();

	// Defines for how many seconds we'll sleep between every
	// action for detecting changes in folders. Default: 60
	$config['activesync_ping_timeout'] = 60;

	// Defines maximum Ping interval in seconds. Default: 900 (15 minutes)
	$config['activesync_ping_interval'] = 900;

	// We start detecting changes n seconds since the last sync of a folder
	// Default: 180
	$config['activesync_quiet_time'] = 180;

	// When a device is reqistered, by default a set of folders are
	// subscribed for syncronization, i.e. INBOX and personal folders with
	// defined folder type:
	// mail.drafts, mail.wastebasket, mail.sentitems, mail.outbox,
	// event, event.default,
	// contact, contact.default,
	// task, task.default
	// This default set can be extended by adding following values:
	// 1 - all subscribed folders in personal namespace
	// 2 - all folders in personal namespace
	// 4 - all subscribed folders in other users namespace
	// 8 - all folders in other users namespace
	// 16 - all subscribed folders in shared namespace
	// 32 - all folders in shared namespace
	$config['activesync_init_subscriptions'] = 0;

	// Defines blacklist of devices (device type strings) that do not support folder hierarchies.
	// When set to an array folder hierarchies are used on all devices not listed here.
	// When set to null an old whitelist approach will be used where we do opposite
	// action and enable folder hierarchies only on device types known to support it.
	$config['activesync_multifolder_blacklist'] = null;

	+// Blacklist overwrites for specified object type. If set to an array
	+// it will have a precedence over 'activesync_multifolder_blacklist' list only for that type.
	+// Note: Outlook does not support multiple folders for contacts,
	+// in that case use $config['activesync_multifolder_blacklist_contact'] = array('windowsoutlook');
	+$config['activesync_multifolder_blacklist_mail'] = null;
	+$config['activesync_multifolder_blacklist_event'] = null;
	+$config['activesync_multifolder_blacklist_contact'] = null;
	+$config['activesync_multifolder_blacklist_note'] = null;
	+$config['activesync_multifolder_blacklist_task'] = null;
	+
	// Enables adding sender name in the From: header of send email
	// when a device uses email address only (e.g. iOS devices)
	$config['activesync_fix_from'] = false;
	diff --git a/lib/kolab_sync_data.php b/lib/kolab_sync_data.php
	index a32e738..b03d04b 100644
	--- a/lib/kolab_sync_data.php
	+++ b/lib/kolab_sync_data.php
	@@ -1,1822 +1,1832 @@
	<?php

	/**
	+--------------------------------------------------------------------------+
	\| Kolab Sync (ActiveSync for Kolab) \|
	\| \|
	\| Copyright (C) 2011-2012, Kolab Systems AG <contact@kolabsys.com> \|
	\| \|
	\| This program is free software: you can redistribute it and/or modify \|
	\| it under the terms of the GNU Affero General Public License as published \|
	\| by the Free Software Foundation, either version 3 of the License, or \|
	\| (at your option) any later version. \|
	\| \|
	\| This program is distributed in the hope that it will be useful, \|
	\| but WITHOUT ANY WARRANTY; without even the implied warranty of \|
	\| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the \|
	\| GNU Affero General Public License for more details. \|
	\| \|
	\| You should have received a copy of the GNU Affero General Public License \|
	\| along with this program. If not, see <http://www.gnu.org/licenses/> \|
	+--------------------------------------------------------------------------+
	\| Author: Aleksander Machniak <machniak@kolabsys.com> \|
	+--------------------------------------------------------------------------+
	*/

	/**
	* Base class for Syncroton data backends
	*/
	abstract class kolab_sync_data implements Syncroton_Data_IData
	{
	/**
	* ActiveSync protocol version
	*
	* @var int
	*/
	protected $asversion = 0;

	/**
	* information about the current device
	*
	* @var Syncroton_Model_IDevice
	*/
	protected $device;

	/**
	* timestamp to use for all sync requests
	*
	* @var DateTime
	*/
	protected $syncTimeStamp;

	/**
	* name of model to use
	*
	* @var string
	*/
	protected $modelName;

	/**
	* type of the default folder
	*
	* @var int
	*/
	protected $defaultFolderType;

	/**
	* default container for new entries
	*
	* @var string
	*/
	protected $defaultFolder;

	/**
	* type of user created folders
	*
	* @var int
	*/
	protected $folderType;

	/**
	* Internal cache for kolab_storage folder objects
	*
	* @var array
	*/
	protected $folders = array();

	/**
	* Internal cache for IMAP folders list
	*
	* @var array
	*/
	protected $imap_folders = array();

	/**
	* Timezone
	*
	* @var string
	*/
	protected $timezone;

	/**
	* List of device types with multiple folders support
	*
	* @var array
	*/
	protected $ext_devices = array(
	'iphone',
	'ipad',
	'thundertine',
	'windowsphone',
	'wp',
	'wp8',
	'playbook',
	);

	const RESULT_OBJECT = 0;
	const RESULT_UID = 1;
	const RESULT_COUNT = 2;


	/**
	* Recurrence types
	*/
	const RECUR_TYPE_DAILY = 0; // Recurs daily.
	const RECUR_TYPE_WEEKLY = 1; // Recurs weekly
	const RECUR_TYPE_MONTHLY = 2; // Recurs monthly
	const RECUR_TYPE_MONTHLY_DAYN = 3; // Recurs monthly on the nth day
	const RECUR_TYPE_YEARLY = 5; // Recurs yearly
	const RECUR_TYPE_YEARLY_DAYN = 6; // Recurs yearly on the nth day

	/**
	* Day of week constants
	*/
	const RECUR_DOW_SUNDAY = 1;
	const RECUR_DOW_MONDAY = 2;
	const RECUR_DOW_TUESDAY = 4;
	const RECUR_DOW_WEDNESDAY = 8;
	const RECUR_DOW_THURSDAY = 16;
	const RECUR_DOW_FRIDAY = 32;
	const RECUR_DOW_SATURDAY = 64;
	const RECUR_DOW_LAST = 127; // The last day of the month. Used as a special value in monthly or yearly recurrences.

	/**
	* Mapping of recurrence types
	*
	* @var array
	*/
	protected $recurTypeMap = array(
	self::RECUR_TYPE_DAILY => 'DAILY',
	self::RECUR_TYPE_WEEKLY => 'WEEKLY',
	self::RECUR_TYPE_MONTHLY => 'MONTHLY',
	self::RECUR_TYPE_MONTHLY_DAYN => 'MONTHLY',
	self::RECUR_TYPE_YEARLY => 'YEARLY',
	self::RECUR_TYPE_YEARLY_DAYN => 'YEARLY',
	);

	/**
	* Mapping of weekdays
	* NOTE: ActiveSync uses a bitmask
	*
	* @var array
	*/
	protected $recurDayMap = array(
	'SU' => self::RECUR_DOW_SUNDAY,
	'MO' => self::RECUR_DOW_MONDAY,
	'TU' => self::RECUR_DOW_TUESDAY,
	'WE' => self::RECUR_DOW_WEDNESDAY,
	'TH' => self::RECUR_DOW_THURSDAY,
	'FR' => self::RECUR_DOW_FRIDAY,
	'SA' => self::RECUR_DOW_SATURDAY,
	);


	/**
	* the constructor
	*
	* @param Syncroton_Model_IDevice $device
	* @param DateTime $syncTimeStamp
	*/
	public function __construct(Syncroton_Model_IDevice $device, DateTime $syncTimeStamp)
	{
	$this->backend = kolab_sync_backend::get_instance();
	$this->device = $device;
	$this->asversion = floatval($device->acsversion);
	$this->syncTimeStamp = $syncTimeStamp;

	$this->defaultRootFolder = $this->defaultFolder . '::Syncroton';

	// set internal timezone of kolab_format to user timezone
	try {
	$this->timezone = rcube::get_instance()->config->get('timezone', 'GMT');
	kolab_format::$timezone = new DateTimeZone($this->timezone);
	}
	catch (Exception $e) {
	//rcube::raise_error($e, true);
	$this->timezone = 'GMT';
	kolab_format::$timezone = new DateTimeZone('GMT');
	}
	}

	/**
	* return list of supported folders for this backend
	*
	* @return array
	*/
	public function getAllFolders()
	{
	$list = array();

	// device supports multiple folders ?
	if ($this->isMultiFolder()) {
	// get the folders the user has access to
	$list = $this->listFolders();
	}
	else if ($default = $this->getDefaultFolder()) {
	$list = array($default['serverId'] => $default);
	}

	// getAllFolders() is called only in FolderSync
	// throw Syncroton_Exception_Status_FolderSync exception
	if (!is_array($list)) {
	throw new Syncroton_Exception_Status_FolderSync(Syncroton_Exception_Status_FolderSync::FOLDER_SERVER_ERROR);
	}

	foreach ($list as $idx => $folder) {
	$list[$idx] = new Syncroton_Model_Folder($folder);
	}

	return $list;
	}

	/**
	* Retrieve folders which were modified since last sync
	*
	* @param DateTime $startTimeStamp
	* @param DateTime $endTimeStamp
	*
	* @return array List of folders
	*/
	public function getChangedFolders(DateTime $startTimeStamp, DateTime $endTimeStamp)
	{
	return array();
	}

	/**
	* Returns true if the device supports multiple folders or it was configured so
	*/
	protected function isMultiFolder()
	{
	- $blacklist = rcube::get_instance()->config->get('activesync_multifolder_blacklist');
	+ $config = rcube::get_instance()->config;
	+ $blacklist = $config->get('activesync_multifolder_blacklist_' . $this->modelName);

	- if (is_array($blacklist)) {
	- $is_multifolder = !in_array_nocase($this->device->devicetype, $blacklist);
	+ if (!is_array($blacklist)) {
	+ $blacklist = $config->get('activesync_multifolder_blacklist');
	}
	- else {
	- $is_multifolder = in_array_nocase($this->device->devicetype, $this->ext_devices);
	+
	+ if (is_array($blacklist)) {
	+ return !$this->deviceTypeFilter($blacklist);
	}

	- return $is_multifolder;
	+ return in_array_nocase($this->device->devicetype, $this->ext_devices);
	}

	/**
	* Returns default folder for current class type.
	*/
	protected function getDefaultFolder()
	{
	// Check if there's any folder configured for sync
	$folders = $this->listFolders();

	if (empty($folders)) {
	return $folders;
	}

	foreach ($folders as $folder) {
	if ($folder['type'] == $this->defaultFolderType) {
	$default = $folder;
	break;
	}
	}

	// Return first on the list if there's no default
	if (empty($default)) {
	$key = array_shift(array_keys($folders));
	$default = $folders[$key];
	// make sure the type is default here
	$default['type'] = $this->defaultFolderType;
	}

	// Remember real folder ID and set ID/name to root folder
	$default['realid'] = $default['serverId'];
	$default['serverId'] = $this->defaultRootFolder;
	$default['displayName'] = $this->defaultFolder;

	return $default;
	}

	/**
	* Creates a folder
	*/
	public function createFolder(Syncroton_Model_IFolder $folder)
	{
	$parentid = $folder->parentId;
	$type = $folder->type;
	$display_name = $folder->displayName;

	if ($parentid) {
	$parent = $this->backend->folder_id2name($parentid, $this->device->deviceid);

	if ($parent === null) {
	throw new Syncroton_Exception_Status_FolderCreate(Syncroton_Exception_Status_FolderCreate::PARENT_NOT_FOUND);
	}
	}

	$name = rcube_charset::convert($display_name, kolab_sync::CHARSET, 'UTF7-IMAP');

	if ($parent !== null) {
	$rcube = rcube::get_instance();
	$storage = $rcube->get_storage();
	$delim = $storage->get_hierarchy_delimiter();
	$name = $parent . $delim . $name;
	}

	// Create IMAP folder
	$result = $this->backend->folder_create($name, $type, $this->device->deviceid);

	if ($result) {
	$folder->serverId = $this->backend->folder_id($name);
	return $folder;
	}

	$errno = Syncroton_Exception_Status_FolderCreate::UNKNOWN_ERROR;

	// Special case when client tries to create a subfolder of INBOX
	// which is not possible on Cyrus-IMAP (T2223)
	if ($parent == 'INBOX' && stripos($this->backend->last_error(), 'invalid') !== false) {
	$errno = Syncroton_Exception_Status_FolderCreate::SPECIAL_FOLDER;
	}

	// Note: Looks like Outlook 2013 ignores any errors on FolderCreate command

	throw new Syncroton_Exception_Status_FolderCreate($errno);
	}

	/**
	* Updates a folder
	*/
	public function updateFolder(Syncroton_Model_IFolder $folder)
	{
	$parentid = $folder->parentId;
	$type = $folder->type;
	$display_name = $folder->displayName;
	$old_name = $this->backend->folder_id2name($folder->serverId, $this->device->deviceid);

	if ($parentid) {
	$parent = $this->backend->folder_id2name($parentid, $this->device->deviceid);
	}

	$name = rcube_charset::convert($display_name, kolab_sync::CHARSET, 'UTF7-IMAP');

	if ($parent !== null) {
	$rcube = rcube::get_instance();
	$storage = $rcube->get_storage();
	$delim = $storage->get_hierarchy_delimiter();
	$name = $parent . $delim . $name;
	}

	// Rename/move IMAP folder
	if ($name == $old_name) {
	$result = true;
	// @TODO: folder type change?
	}
	else {
	$result = $this->backend->folder_rename($old_name, $name, $type);
	}

	if ($result) {
	return $folder;
	}

	// @TODO: throw exception
	}

	/**
	* Deletes a folder
	*/
	public function deleteFolder($folder)
	{
	if ($folder instanceof Syncroton_Model_IFolder) {
	$folder = $folder->serverId;
	}

	$name = $this->backend->folder_id2name($folder, $this->device->deviceid);

	// @TODO: throw exception
	return $this->backend->folder_delete($name, $this->device->deviceid);
	}

	/**
	* Empty folder (remove all entries and optionally subfolders)
	*
	* @param string $folderId Folder identifier
	* @param array $options Options
	*/
	public function emptyFolderContents($folderid, $options)
	{
	$folders = $this->extractFolders($folderid);

	foreach ($folders as $folderid) {
	$foldername = $this->backend->folder_id2name($folderid, $this->device->deviceid);
	$folder = $this->getFolderObject($foldername);

	if (!$folder \|\| !$folder->valid) {
	throw new Syncroton_Exception_Status_ItemOperations(Syncroton_Exception_Status_ItemOperations::ITEM_SERVER_ERROR);
	}

	// Remove all entries
	$folder->delete_all();

	// Remove subfolders
	if (!empty($options['deleteSubFolders'])) {
	$list = $this->listFolders($folderid);
	foreach ($list as $folderid => $folder) {
	$foldername = $this->backend->folder_id2name($folderid, $this->device->deviceid);
	$folder = $this->getFolderObject($foldername);

	if (!$folder \|\| !$folder->valid) {
	throw new Syncroton_Exception_Status_ItemOperations(Syncroton_Exception_Status_ItemOperations::ITEM_SERVER_ERROR);
	}

	// Remove all entries
	$folder->delete_all();
	}
	}
	}
	}

	/**
	* Moves object into another location (folder)
	*
	* @param string $srcFolderId Source folder identifier
	* @param string $serverId Object identifier
	* @param string $dstFolderId Destination folder identifier
	*
	* @throws Syncroton_Exception_Status
	* @return string New object identifier
	*/
	public function moveItem($srcFolderId, $serverId, $dstFolderId)
	{
	$item = $this->getObject($srcFolderId, $serverId, $folder);

	if (!$item \|\| !$folder) {
	throw new Syncroton_Exception_Status_MoveItems(Syncroton_Exception_Status_MoveItems::INVALID_SOURCE);
	}

	$dstname = $this->backend->folder_id2name($dstFolderId, $this->device->deviceid);

	if ($dstname === null) {
	throw new Syncroton_Exception_Status_MoveItems(Syncroton_Exception_Status_MoveItems::INVALID_DESTINATION);
	}

	if (!$folder->move($serverId, $dstname)) {
	throw new Syncroton_Exception_Status_MoveItems(Syncroton_Exception_Status_MoveItems::INVALID_SOURCE);
	}

	return $item['uid'];
	}

	/**
	* Add entry
	*
	* @param string $folderId Folder identifier
	* @param Syncroton_Model_IEntry $entry Entry object
	*
	* @return string ID of the created entry
	*/
	public function createEntry($folderId, Syncroton_Model_IEntry $entry)
	{
	$entry = $this->toKolab($entry, $folderId);
	$entry = $this->createObject($folderId, $entry);

	if (empty($entry)) {
	throw new Syncroton_Exception_Status_Sync(Syncroton_Exception_Status_Sync::SYNC_SERVER_ERROR);
	}

	return $entry['uid'];
	}

	/**
	* update existing entry
	*
	* @param string $folderId
	* @param string $serverId
	* @param SimpleXMLElement $entry
	*
	* @return string ID of the updated entry
	*/
	public function updateEntry($folderId, $serverId, Syncroton_Model_IEntry $entry)
	{
	$oldEntry = $this->getObject($folderId, $serverId);

	if (empty($oldEntry)) {
	throw new Syncroton_Exception_NotFound('id not found');
	}

	$entry = $this->toKolab($entry, $folderId, $oldEntry);
	$entry = $this->updateObject($folderId, $serverId, $entry);

	if (empty($entry)) {
	throw new Syncroton_Exception_Status_Sync(Syncroton_Exception_Status_Sync::SYNC_SERVER_ERROR);
	}

	return $entry['uid'];
	}

	/**
	* delete entry
	*
	* @param string $folderId
	* @param string $serverId
	* @param array $collectionData
	*/
	public function deleteEntry($folderId, $serverId, $collectionData)
	{
	$deleted = $this->deleteObject($folderId, $serverId);

	if (!$deleted) {
	throw new Syncroton_Exception_Status_Sync(Syncroton_Exception_Status_Sync::SYNC_SERVER_ERROR);
	}
	}


	public function getFileReference($fileReference)
	{
	// to be implemented by Email data class
	// @TODO: throw "unimplemented" exception here?
	}


	/**
	* Search for existing entries
	*
	* @param string $folderid Folder identifier
	* @param array $filter Search filter
	* @param int $result_type Type of the result (see RESULT_* constants)
	*
	* @return array\|int Search result as count or array of uids/objects
	*/
	protected function searchEntries($folderid, $filter = array(), $result_type = self::RESULT_UID)
	{
	if ($folderid == $this->defaultRootFolder) {
	$folders = $this->listFolders();

	if (!is_array($folders)) {
	throw new Syncroton_Exception_Status(Syncroton_Exception_Status::SERVER_ERROR);
	}

	$folders = array_keys($folders);
	}
	else {
	$folders = array($folderid);
	}

	// there's a PHP Warning from kolab_storage if $filter isn't an array
	if (empty($filter)) {
	$filter = array();
	}
	else {
	$changed_objects = $this->getChangesByRelations($folderid, $filter);
	}

	$result = $result_type == self::RESULT_COUNT ? 0 : array();
	$found = 0;

	foreach ($folders as $folder_id) {
	$foldername = $this->backend->folder_id2name($folder_id, $this->device->deviceid);
	$folder = $this->getFolderObject($foldername);

	if (!$folder \|\| !$folder->valid) {
	throw new Syncroton_Exception_Status(Syncroton_Exception_Status::SERVER_ERROR);
	}

	$found++;
	$error = false;

	switch ($result_type) {
	case self::RESULT_COUNT:
	$count = $folder->count($filter);

	if ($count === null \|\| $count === false) {
	$error = true;
	}
	else {
	$result += (int) $count;
	}
	break;

	case self::RESULT_UID:
	$uids = $folder->get_uids($filter);

	if (!is_array($uids)) {
	$error = true;
	}
	else {
	$result = array_merge($result, $uids);
	}
	break;
	}

	if ($error) {
	throw new Syncroton_Exception_Status(Syncroton_Exception_Status::SERVER_ERROR);
	}

	// handle tag modifications
	if (!empty($changed_objects)) {
	// build new filter
	// search objects mathing current filter,
	// relations may contain members of many types, we need to
	// search them by UID in all requested folders to get
	// only these with requested type (and that really exist
	// in specified folders)
	$tag_filter = array(array('uid', '=', $changed_objects));
	foreach ($filter as $f) {
	if ($f[0] != 'changed') {
	$tag_filter[] = $f;
	}
	}

	switch ($result_type) {
	case self::RESULT_COUNT:
	// Note: this way we're potentally counting the same objects twice
	// I'm not sure if this is a problem, we most likely do not
	// need a precise result here
	$count = $folder->count($tag_filter);
	if ($count !== null && $count !== false) {
	$result += (int) $count;
	}

	break;

	case self::RESULT_UID:
	$uids = $folder->get_uids($tag_filter);
	if (is_array($uids)) {
	$result = array_unique(array_merge($result, $uids));
	}

	break;
	}
	}
	}

	if (!$found) {
	throw new Syncroton_Exception_Status(Syncroton_Exception_Status::SERVER_ERROR);
	}

	return $result;
	}

	/**
	* Detect changes of relation (tag) objects data and assigned objects
	* Returns relation member identifiers
	*/
	protected function getChangesByRelations($folderid, $filter)
	{
	if (!$this->tag_categories) {
	return;
	}

	// get period filter, create new objects filter
	foreach ($filter as $f) {
	if ($f[0] == 'changed' && $f[1] == '>') {
	$since = $f[2];
	}
	}

	// this is not search for changes, do nothing
	if (empty($since)) {
	return;
	}

	// get relations state from the last sync
	$last_state = (array) $this->backend->relations_state_get($this->device->id, $folderid, $since);

	// get current relations state
	$config = kolab_storage_config::get_instance();
	$default = true;
	$filter = array(
	array('type', '=', 'relation'),
	array('category', '=', 'tag')
	);

	$relations = $config->get_objects($filter, $default, 100);

	$result = array();
	$changed = false;

	// compare states, get members of changed relations
	foreach ($relations as $relation) {
	$rel_id = $relation['uid'];

	if ($relation['changed']) {
	$relation['changed']->setTimezone(new DateTimeZone('UTC'));
	}

	// last state unknown...
	if (empty($last_state[$rel_id])) {
	// ...get all members
	if (!empty($relation['members'])) {
	$changed = true;
	$result = array_merge($result, $relation['members']);
	}
	}
	// last state known, changed tag name...
	else if ($last_state[$rel_id]['name'] != $relation['name']) {
	// ...get all (old and new) members
	$members_old = explode("\n", $last_state[$rel_id]['members']);
	$changed = true;
	$members = array_unique(array_merge($relation['members'], $members_old));
	$result = array_merge($result, $members);
	}
	// last state known, any other change change...
	else if ($last_state[$rel_id]['changed'] < $relation['changed']->format('U')) {
	// ...find new and removed members
	$members_old = explode("\n", $last_state[$rel_id]['members']);
	$new = array_diff($relation['members'], $members_old);
	$removed = array_diff($members_old, $relation['members']);

	if (!empty($new) \|\| !empty($removed)) {
	$changed = true;
	$result = array_merge($result, $new, $removed);
	}
	}

	unset($last_state[$rel_id]);
	}

	// get members of deleted relations
	if (!empty($last_state)) {
	$changed = true;
	foreach ($last_state as $relation) {
	$members = explode("\n", $relation['members']);
	$result = array_merge($result, $members);
	}
	}

	// save current state
	if ($changed) {
	$data = array();
	foreach ($relations as $relation) {
	$data[$relation['uid']] = array(
	'name' => $relation['name'],
	'changed' => $relation['changed']->format('U'),
	'members' => implode("\n", $relation['members']),
	);
	}

	$now = new DateTime('now', new DateTimeZone('UTC'));

	$this->backend->relations_state_set($this->device->id, $folderid, $now, $data);
	}

	// in mail mode return only message URIs
	if ($this->modelName == 'mail') {
	// lambda function to skip email members
	$filter_func = function($value) {
	return strpos($value, 'imap://') === 0;
	};

	$result = array_filter(array_unique($result), $filter_func);
	}
	// otherwise return only object UIDs
	else {
	// lambda function to skip email members
	$filter_func = function($value) {
	return strpos($value, 'urn:uuid:') === 0;
	};

	// lambda function to parse member URI
	$member_func = function($value) {
	if (strpos($value, 'urn:uuid:') === 0) {
	$value = substr($value, 9);
	}
	return $value;
	};

	$result = array_map($member_func, array_filter(array_unique($result), $filter_func));
	}

	return $result;
	}

	/**
	* Returns filter query array according to specified ActiveSync FilterType
	*
	* @param int $filter_type Filter type
	*
	* @param array Filter query
	*/
	protected function filter($filter_type = 0)
	{
	// overwrite by child class according to specified type
	return array();
	}

	/**
	* get all entries changed between two dates
	*
	* @param string $folderId
	* @param DateTime $start
	* @param DateTime $end
	* @param int $filterType
	*
	* @return array
	*/
	public function getChangedEntries($folderId, DateTime $start, DateTime $end = null, $filter_type = null)
	{
	$filter = $this->filter($filter_type);
	$filter[] = array('changed', '>', $start);

	if ($end) {
	$filter[] = array('changed', '<=', $end);
	}

	return $this->searchEntries($folderId, $filter, self::RESULT_UID);
	}

	/**
	* Get count of entries changed between two dates
	*
	* @param string $folderId
	* @param DateTime $start
	* @param DateTime $end
	* @param int $filterType
	*
	* @return int
	*/
	public function getChangedEntriesCount($folderId, DateTime $start, DateTime $end = null, $filter_type = null)
	{
	$filter = $this->filter($filter_type);
	$filter[] = array('changed', '>', $start);

	if ($end) {
	$filter[] = array('changed', '<=', $end);
	}

	return $this->searchEntries($folderId, $filter, self::RESULT_COUNT);
	}

	/**
	* get id's of all entries available on the server
	*
	* @param string $folderId
	* @param int $filterType
	*
	* @return array
	*/
	public function getServerEntries($folder_id, $filter_type)
	{
	$filter = $this->filter($filter_type);
	$result = $this->searchEntries($folder_id, $filter, self::RESULT_UID);

	return $result;
	}

	/**
	* get count of all entries available on the server
	*
	* @param string $folderId
	* @param int $filterType
	*
	* @return int
	*/
	public function getServerEntriesCount($folder_id, $filter_type)
	{
	$filter = $this->filter($filter_type);
	$result = $this->searchEntries($folder_id, $filter, self::RESULT_COUNT);

	return $result;
	}

	/**
	* Returns number of changed objects in the backend folder
	*
	* @param Syncroton_Backend_IContent $contentBackend
	* @param Syncroton_Model_IFolder $folder
	* @param Syncroton_Model_ISyncState $syncState
	*
	* @return int
	*/
	public function getCountOfChanges(Syncroton_Backend_IContent $contentBackend, Syncroton_Model_IFolder $folder, Syncroton_Model_ISyncState $syncState)
	{
	$allClientEntries = $contentBackend->getFolderState($this->device, $folder);
	$allServerEntries = $this->getServerEntries($folder->serverId, $folder->lastfiltertype);
	$changedEntries = $this->getChangedEntriesCount($folder->serverId, $syncState->lastsync, null, $folder->lastfiltertype);
	$addedEntries = array_diff($allServerEntries, $allClientEntries);
	$deletedEntries = array_diff($allClientEntries, $allServerEntries);

	return count($addedEntries) + count($deletedEntries) + $changedEntries;
	}

	/**
	* Returns true if any data got modified in the backend folder
	*
	* @param Syncroton_Backend_IContent $contentBackend
	* @param Syncroton_Model_IFolder $folder
	* @param Syncroton_Model_ISyncState $syncState
	*
	* @return bool
	*/
	public function hasChanges(Syncroton_Backend_IContent $contentBackend, Syncroton_Model_IFolder $folder, Syncroton_Model_ISyncState $syncState)
	{
	- // Try to detect change in multi-folder mode and throw exception
	- // so device will re-sync folders hierarchy
	- // @TODO: this is a temp solution until we have real hierarchy
	- // changes detection fort Ping/Hartbeat
	- $is_multifolder = $this->isMultiFolder();
	- if (($is_multifolder && $folder->serverId == $this->defaultRootFolder)
	- \|\| (!$is_multifolder && $folder->type >= 12)
	- ) {
	- throw new Syncroton_Exception_NotFound('Folder not found');
	- }
	-
	try {
	if ($this->getChangedEntriesCount($folder->serverId, $syncState->lastsync, null, $folder->lastfiltertype)) {
	return true;
	}

	$allClientEntries = $contentBackend->getFolderState($this->device, $folder);

	// @TODO: Consider looping over all folders here, not in getServerEntries() and
	// getChangedEntriesCount(). This way we could break the loop and not check all folders
	// or at least skip redundant cache sync of the same folder
	$allServerEntries = $this->getServerEntries($folder->serverId, $folder->lastfiltertype);

	$addedEntries = array_diff($allServerEntries, $allClientEntries);
	$deletedEntries = array_diff($allClientEntries, $allServerEntries);

	return count($addedEntries) > 0 \|\| count($deletedEntries) > 0;
	}
	catch (Exception $e) {
	// return "no changes" if something failed
	return false;
	}
	}

	/**
	* Fetches the entry from the backend
	*/
	protected function getObject($folderid, $entryid, &$folder = null)
	{
	$folders = $this->extractFolders($folderid);

	foreach ($folders as $folderid) {
	$foldername = $this->backend->folder_id2name($folderid, $this->device->deviceid);
	$folder = $this->getFolderObject($foldername);

	if ($folder && $folder->valid && ($object = $folder->get_object($entryid))) {
	$object['_folderid'] = $folderid;

	return $object;
	}
	}
	}

	/**
	* Saves the entry on the backend
	*/
	protected function createObject($folderid, $data)
	{
	if ($folderid == $this->defaultRootFolder) {
	$default = $this->getDefaultFolder();

	if (!is_array($default)) {
	return null;
	}

	$folderid = isset($default['realid']) ? $default['realid'] : $default['serverId'];
	}

	// convert categories into tags, save them after creating an object
	if ($this->tag_categories) {
	$tags = $data['categories'];
	unset($data['categories']);
	}

	$foldername = $this->backend->folder_id2name($folderid, $this->device->deviceid);
	$folder = $this->getFolderObject($foldername);

	if ($folder && $folder->valid && $folder->save($data)) {
	if (!empty($tags)) {
	$this->setKolabTags($data['uid'], $tags);
	}

	return $data;
	}
	}

	/**
	* Updates the entry on the backend
	*/
	protected function updateObject($folderid, $entryid, $data)
	{
	$object = $this->getObject($folderid, $entryid);

	if ($object) {
	$folder = $this->getFolderObject($object['_mailbox']);

	// convert categories into tags, save them after updating an object
	if ($this->tag_categories && array_key_exists('categories', $data)) {
	$tags = (array) $data['categories'];
	unset($data['categories']);
	}

	if ($folder && $folder->valid && $folder->save($data)) {
	if (isset($tags)) {
	$this->setKolabTags($data['uid'], $tags);
	}

	return $data;
	}
	}
	}

	/**
	* Removes the entry from the backend
	*/
	protected function deleteObject($folderid, $entryid)
	{
	$object = $this->getObject($folderid, $entryid);

	if ($object) {
	$folder = $this->getFolderObject($object['_mailbox']);

	if ($folder && $folder->valid && $folder->delete($entryid)) {
	if ($this->tag_categories) {
	$this->setKolabTags($object['uid'], null);
	}

	return true;
	}

	return false;
	}

	// object doesn't exist, confirm deletion
	return true;
	}

	/**
	* Returns internal folder IDs
	*
	* @param string $folderid Folder identifier
	*
	* @return array List of folder identifiers
	*/
	protected function extractFolders($folderid)
	{
	if ($folderid instanceof Syncroton_Model_IFolder) {
	$folderid = $folderid->serverId;
	}

	if ($folderid == $this->defaultRootFolder) {
	$folders = $this->listFolders();

	if (!is_array($folders)) {
	return null;
	}

	$folders = array_keys($folders);
	}
	else {
	$folders = array($folderid);
	}

	return $folders;
	}

	/**
	* List of all IMAP folders (or subtree)
	*
	* @param string $parentid Parent folder identifier
	*
	* @return array List of folder identifiers
	*/
	protected function listFolders($parentid = null)
	{
	if (empty($this->imap_folders)) {
	$this->imap_folders = $this->backend->folders_list(
	$this->device->deviceid, $this->modelName, $this->isMultiFolder());
	}

	if ($parentid === null) {
	return $this->imap_folders;
	}

	$folders = array();
	$parents = array($parentid);

	foreach ($this->imap_folders as $folder_id => $folder) {
	if ($folder['parentId'] && in_array($folder['parentId'], $parents)) {
	$folders[$folder_id] = $folder;
	$parents[] = $folder_id;
	}
	}

	return $folders;
	}

	/**
	* Returns Folder object (uses internal cache)
	*
	* @param string $name Folder name (UTF7-IMAP)
	*
	* @return kolab_storage_folder Folder object
	*/
	protected function getFolderObject($name)
	{
	if ($name === null \|\| $name === '') {
	return null;
	}

	if (!isset($this->folders[$name])) {
	$this->folders[$name] = kolab_storage::get_folder($name, $this->modelName);
	}

	return $this->folders[$name];
	}

	/**
	* Returns ActiveSync settings of specified folder
	*
	* @param string $name Folder name (UTF7-IMAP)
	*
	* @return array Folder settings
	*/
	protected function getFolderConfig($name)
	{
	$metadata = $this->backend->folder_meta();

	if (!is_array($metadata)) {
	return array();
	}

	$deviceid = $this->device->deviceid;
	$config = $metadata[$name]['FOLDER'][$deviceid];

	return array(
	'ALARMS' => $config['S'] == 2,
	);
	}

	/**
	* Returns real folder name for specified folder ID
	*/
	protected function getFolderName($folderid)
	{
	if ($folderid == $this->defaultRootFolder) {
	$default = $this->getDefaultFolder();

	if (!is_array($default)) {
	return null;
	}

	$folderid = isset($default['realid']) ? $default['realid'] : $default['serverId'];
	}

	return $this->backend->folder_id2name($folderid, $this->device->deviceid);
	}

	/**
	* Convert contact from xml to kolab format
	*
	* @param Syncroton_Model_IEntry $data Contact data
	* @param string $folderId Folder identifier
	* @param array $entry Old Contact data for merge
	*
	* @return array
	*/
	abstract function toKolab(Syncroton_Model_IEntry $data, $folderId, $entry = null);

	/**
	* Extracts data from kolab data array
	*/
	protected function getKolabDataItem($data, $name)
	{
	$name_items = explode('.', $name);
	$count = count($name_items);

	// multi-level array (e.g. address, phone)
	if ($count == 3) {
	$name = $name_items[0];
	$type = $name_items[1];
	$key_name = $name_items[2];

	if (!empty($data[$name]) && is_array($data[$name])) {
	foreach ($data[$name] as $element) {
	if ($element['type'] == $type) {
	return $element[$key_name];
	}
	}
	}

	return null;
	}
	/*
	// hash array e.g. organizer
	else if ($count == 2) {
	$name = $name_items[0];
	$type = $name_items[1];
	$key_name = $name_items[2];

	if (!empty($data[$name]) && is_array($data[$name])) {
	foreach ($data[$name] as $element) {
	if ($element['type'] == $type) {
	return $element[$key_name];
	}
	}
	}

	return null;
	}
	*/
	$name_items = explode(':', $name);
	$name = $name_items[0];

	if (empty($data[$name])) {
	return null;
	}

	// simple array (e.g. email)
	if (count($name_items) == 2) {
	return $data[$name][$name_items[1]];
	}

	return $data[$name];
	}

	/**
	* Saves data in kolab data array
	*/
	protected function setKolabDataItem(&$data, $name, $value)
	{
	if (empty($value)) {
	return $this->unsetKolabDataItem($data, $name);
	}

	$name_items = explode('.', $name);

	// multi-level array (e.g. address, phone)
	if (count($name_items) == 3) {
	$name = $name_items[0];
	$type = $name_items[1];
	$key_name = $name_items[2];

	if (!isset($data[$name])) {
	$data[$name] = array();
	}

	foreach ($data[$name] as $idx => $element) {
	if ($element['type'] == $type) {
	$found = $idx;
	break;
	}
	}

	if (!isset($found)) {
	$data[$name] = array_values($data[$name]);
	$found = count($data[$name]);
	$data[$name][$found] = array('type' => $type);
	}

	$data[$name][$found][$key_name] = $value;

	return;
	}

	$name_items = explode(':', $name);
	$name = $name_items[0];

	// simple array (e.g. email)
	if (count($name_items) == 2) {
	$data[$name][$name_items[1]] = $value;
	return;
	}

	$data[$name] = $value;
	}

	/**
	* Unsets data item in kolab data array
	*/
	protected function unsetKolabDataItem(&$data, $name)
	{
	$name_items = explode('.', $name);

	// multi-level array (e.g. address, phone)
	if (count($name_items) == 3) {
	$name = $name_items[0];
	$type = $name_items[1];
	$key_name = $name_items[2];

	if (!isset($data[$name])) {
	return;
	}

	foreach ($data[$name] as $idx => $element) {
	if ($element['type'] == $type) {
	$found = $idx;
	break;
	}
	}

	if (!isset($found)) {
	return;
	}

	unset($data[$name][$found][$key_name]);

	// if there's only one element and it's 'type', remove it
	if (count($data[$name][$found]) == 1 && isset($data[$name][$found]['type'])) {
	unset($data[$name][$found]['type']);
	}
	if (empty($data[$name][$found])) {
	unset($data[$name][$found]);
	}
	if (empty($data[$name])) {
	unset($data[$name]);
	}

	return;
	}

	$name_items = explode(':', $name);
	$name = $name_items[0];

	// simple array (e.g. email)
	if (count($name_items) == 2) {
	unset($data[$name][$name_items[1]]);
	if (empty($data[$name])) {
	unset($data[$name]);
	}
	return;
	}

	unset($data[$name]);
	}

	/**
	* Setter for Body attribute according to client version
	*
	* @param string $value Body
	* @param array $param Body parameters
	*
	* @reurn Syncroton_Model_EmailBody Body element
	*/
	protected function setBody($value, $params = array())
	{
	if (empty($value) && empty($params)) {
	return;
	}

	// Old protocol version doesn't support AirSyncBase:Body, it's eg. WindowsCE
	if ($this->asversion < 12) {
	return;
	}

	if (!empty($value)) {
	// cast to string to workaround issue described in Bug #1635
	$params['data'] = (string) $value;
	}

	if (!isset($params['type'])) {
	$params['type'] = Syncroton_Model_EmailBody::TYPE_PLAINTEXT;
	}

	return new Syncroton_Model_EmailBody($params);
	}

	/**
	* Getter for Body attribute value according to client version
	*
	* @param mixed $body Body element
	* @param int $type Result data type (to which the body will be converted, if specified).
	* One or array of Syncroton_Model_EmailBody constants.
	*
	* @return string Body value
	*/
	protected function getBody($body, $type = null)
	{
	if ($body && $body->data) {
	$data = $body->data;
	}

	if (!$data \|\| empty($type)) {
	return;
	}

	$type = (array) $type;

	// Convert to specified type
	if (!in_array($body->type, $type)) {
	$converter = new kolab_sync_body_converter($data, $body->type);
	$data = $converter->convert($type[0]);
	}

	return $data;
	}

	/**
	* Converts text (plain or html) into ActiveSync Body element.
	* Takes bodyPreferences into account and detects if the text is plain or html.
	*/
	protected function body_from_kolab($body, $collection)
	{
	if (empty($body)) {
	return;
	}

	$opts = $collection->options;
	$prefs = $opts['bodyPreferences'];
	$html_type = Syncroton_Command_Sync::BODY_TYPE_HTML;
	$type = Syncroton_Command_Sync::BODY_TYPE_PLAIN_TEXT;
	$params = array();

	// HTML? check for opening and closing <html> or <body> tags
	$is_html = preg_match('/<(html\|body)(\s+[a-z]\|>)/', $body, $m) && strpos($body, '</'.$m[1].'>') > 0;

	// here we assume that all devices support plain text
	if ($is_html) {
	// device supports HTML...
	if (!empty($prefs[$html_type])) {
	$type = $html_type;
	}
	// ...else convert to plain text
	else {
	$txt = new rcube_html2text($body, false, true);
	$body = $txt->get_text();
	}
	}

	// strip out any non utf-8 characters
	$body = rcube_charset::clean($body);
	$real_length = $body_length = strlen($body);

	// truncate the body if needed
	if (($truncateAt = $prefs[$type]['truncationSize']) && $body_length > $truncateAt) {
	$body = mb_strcut($body, 0, $truncateAt);
	$body_length = strlen($body);

	$params['truncated'] = 1;
	$params['estimatedDataSize'] = $real_length;
	}

	$params['type'] = $type;

	return $this->setBody($body, $params);
	}


	/**
	* Converts PHP DateTime, date (YYYY-MM-DD) or unixtimestamp into PHP DateTime in UTC
	*
	* @param DateTime\|int\|string $date Unix timestamp, date (YYYY-MM-DD) or PHP DateTime object
	*
	* @return DateTime Datetime object
	*/
	protected static function date_from_kolab($date)
	{
	if (!empty($date)) {
	if (is_numeric($date)) {
	$date = new DateTime('@' . $date);
	}
	else if (is_string($date)) {
	$date = new DateTime($date, new DateTimeZone('UTC'));
	}
	else if ($date instanceof DateTime) {
	$date = clone $date;
	$tz = $date->getTimezone();
	$tz_name = $tz->getName();

	// convert to UTC if needed
	if ($tz_name != 'UTC') {
	$utc = new DateTimeZone('UTC');
	// safe dateonly object conversion to UTC
	// note: _dateonly flag is set by libkolab e.g. for birthdays
	if ($date->_dateonly) {
	// avoid time change
	$date = new DateTime($date->format('Y-m-d'), $utc);
	// set time to noon to avoid timezone troubles
	$date->setTime(12, 0, 0);
	}
	else {
	$date->setTimezone($utc);
	}
	}
	}
	else {
	return null; // invalid input
	}

	return $date;
	}
	}

	/**
	* Convert Kolab event/task recurrence into ActiveSync
	*/
	protected function recurrence_from_kolab($collection, $data, &$result, $type = 'Event')
	{
	if (empty($data['recurrence'])) {
	return;
	}

	$recurrence = array();
	$r = $data['recurrence'];

	// required fields
	switch($r['FREQ']) {
	case 'DAILY':
	$recurrence['type'] = self::RECUR_TYPE_DAILY;
	break;

	case 'WEEKLY':
	$recurrence['type'] = self::RECUR_TYPE_WEEKLY;
	$recurrence['dayOfWeek'] = $this->day2bitmask($r['BYDAY']);
	break;

	case 'MONTHLY':
	if (!empty($r['BYMONTHDAY'])) {
	// @TODO: ActiveSync doesn't support multi-valued month days,
	// should we replicate the recurrence element for each day of month?
	$month_day = array_shift(explode(',', $r['BYMONTHDAY']));
	$recurrence['type'] = self::RECUR_TYPE_MONTHLY;
	$recurrence['dayOfMonth'] = $month_day;
	}
	else {
	$week = (int) substr($r['BYDAY'], 0, -2);
	$week = ($week == -1) ? 5 : $week;
	$day = substr($r['BYDAY'], -2);
	$recurrence['type'] = self::RECUR_TYPE_MONTHLY_DAYN;
	$recurrence['weekOfMonth'] = $week;
	$recurrence['dayOfWeek'] = $this->day2bitmask($day);
	}
	break;

	case 'YEARLY':
	// @TODO: ActiveSync doesn't support multi-valued months,
	// should we replicate the recurrence element for each month?
	$month = array_shift(explode(',', $r['BYMONTH']));

	if (!empty($r['BYDAY'])) {
	$week = (int) substr($r['BYDAY'], 0, -2);
	$week = ($week == -1) ? 5 : $week;
	$day = substr($r['BYDAY'], -2);
	$recurrence['type'] = self::RECUR_TYPE_YEARLY_DAYN;
	$recurrence['weekOfMonth'] = $week;
	$recurrence['dayOfWeek'] = $this->day2bitmask($day);
	$recurrence['monthOfYear'] = $month;
	}
	else if (!empty($r['BYMONTHDAY'])) {
	// @TODO: ActiveSync doesn't support multi-valued month days,
	// should we replicate the recurrence element for each day of month?
	$month_day = array_shift(explode(',', $r['BYMONTHDAY']));
	$recurrence['type'] = self::RECUR_TYPE_YEARLY;
	$recurrence['dayOfMonth'] = $month_day;
	$recurrence['monthOfYear'] = $month;
	}
	else {
	$recurrence['type'] = self::RECUR_TYPE_YEARLY;
	$recurrence['monthOfYear'] = $month;
	}
	break;
	}

	// required field
	$recurrence['interval'] = $r['INTERVAL'] ? $r['INTERVAL'] : 1;

	if (!empty($r['UNTIL'])) {
	$recurrence['until'] = self::date_from_kolab($r['UNTIL']);
	}
	else if (!empty($r['COUNT'])) {
	$recurrence['occurrences'] = $r['COUNT'];
	}

	$class = 'Syncroton_Model_' . $type . 'Recurrence';

	$result['recurrence'] = new $class($recurrence);

	// Tasks do not support exceptions
	if ($type == 'Event') {
	$result['exceptions'] = $this->exceptions_from_kolab($collection, $data);
	}
	}

	/**
	* Convert ActiveSync event/task recurrence into Kolab
	*/
	protected function recurrence_to_kolab($data, $folderid, $timezone = null)
	{
	if (!($data->recurrence instanceof Syncroton_Model_EventRecurrence) \|\| !isset($data->recurrence->type)) {
	return null;
	}

	$recurrence = $data->recurrence;
	$type = $recurrence->type;

	switch ($type) {
	case self::RECUR_TYPE_DAILY:
	break;

	case self::RECUR_TYPE_WEEKLY:
	$rrule['BYDAY'] = $this->bitmask2day($recurrence->dayOfWeek);
	break;

	case self::RECUR_TYPE_MONTHLY:
	$rrule['BYMONTHDAY'] = $recurrence->dayOfMonth;
	break;

	case self::RECUR_TYPE_MONTHLY_DAYN:
	$week = $recurrence->weekOfMonth;
	$day = $recurrence->dayOfWeek;
	$byDay = $week == 5 ? -1 : $week;
	$byDay .= $this->bitmask2day($day);

	$rrule['BYDAY'] = $byDay;
	break;

	case self::RECUR_TYPE_YEARLY:
	$rrule['BYMONTH'] = $recurrence->monthOfYear;
	$rrule['BYMONTHDAY'] = $recurrence->dayOfMonth;
	break;

	case self::RECUR_TYPE_YEARLY_DAYN:
	$rrule['BYMONTH'] = $recurrence->monthOfYear;

	$week = $recurrence->weekOfMonth;
	$day = $recurrence->dayOfWeek;
	$byDay = $week == 5 ? -1 : $week;
	$byDay .= $this->bitmask2day($day);

	$rrule['BYDAY'] = $byDay;
	break;
	}

	$rrule['FREQ'] = $this->recurTypeMap[$type];
	$rrule['INTERVAL'] = isset($recurrence->interval) ? $recurrence->interval : 1;

	if (isset($recurrence->until)) {
	if ($timezone) {
	$recurrence->until->setTimezone($timezone);
	}
	$rrule['UNTIL'] = $recurrence->until;
	}
	else if (!empty($recurrence->occurrences)) {
	$rrule['COUNT'] = $recurrence->occurrences;
	}

	// recurrence exceptions (not supported by Tasks)
	if ($data instanceof Syncroton_Model_Event) {
	$this->exceptions_to_kolab($data, $rrule, $folderid, $timezone);
	}

	return $rrule;
	}

	/**
	* Convert Kolab event recurrence exceptions into ActiveSync
	*/
	protected function exceptions_from_kolab($collection, $data)
	{
	if (empty($data['recurrence']['EXCEPTIONS']) && empty($data['recurrence']['EXDATE'])) {
	return null;
	}

	$ex_list = array();

	// exceptions (modified occurences)
	foreach ((array)$data['recurrence']['EXCEPTIONS'] as $exception) {
	$exception['_mailbox'] = $data['_mailbox'];
	$ex = $this->getEntry($collection, $exception, true);

	$ex['exceptionStartTime'] = clone $ex['startTime'];

	// remove fields not supported by Syncroton_Model_EventException
	unset($ex['uID']);

	// @TODO: 'thisandfuture=true' is not supported in Activesync
	// we'd need to slit the event into two separate events

	$ex_list[] = new Syncroton_Model_EventException($ex);
	}

	// exdate (deleted occurences)
	foreach ((array)$data['recurrence']['EXDATE'] as $exception) {
	if (!($exception instanceof DateTime)) {
	continue;
	}

	// set event start time to exception date
	// that can't be any time, tested with Android
	$hour = $data['_start']->format('H');
	$minute = $data['_start']->format('i');
	$second = $data['_start']->format('s');
	$exception->setTime($hour, $minute, $second);
	$exception->_dateonly = false;

	$ex = array(
	'deleted' => 1,
	'exceptionStartTime' => self::date_from_kolab($exception),
	);

	$ex_list[] = new Syncroton_Model_EventException($ex);
	}

	return $ex_list;
	}

	/**
	* Convert ActiveSync event recurrence exceptions into Kolab
	*/
	protected function exceptions_to_kolab($data, &$rrule, $folderid, $timezone = null)
	{
	$rrule['EXDATE'] = array();
	$rrule['EXCEPTIONS'] = array();

	// handle exceptions from recurrence
	if (!empty($data->exceptions)) {
	foreach ($data->exceptions as $exception) {
	if ($exception->deleted) {
	$date = clone $exception->exceptionStartTime;
	if ($timezone) {
	$date->setTimezone($timezone);
	}
	$date->setTime(0, 0, 0);
	$rrule['EXDATE'][] = $date;
	}
	else if (!$exception->deleted) {
	$ex = $this->toKolab($exception, $folderid, null, $timezone);

	if ($data->allDayEvent) {
	$ex['allday'] = 1;
	}

	$rrule['EXCEPTIONS'][] = $ex;
	}
	}
	}

	if (empty($rrule['EXDATE'])) {
	unset($rrule['EXDATE']);
	}
	if (empty($rrule['EXCEPTIONS'])) {
	unset($rrule['EXCEPTIONS']);
	}
	}

	/**
	* Returns list of tag names assigned to kolab object
	*/
	protected function getKolabTags($uid, $categories = null)
	{
	$config = kolab_storage_config::get_instance();
	$tags = $config->get_tags($uid);
	$tags = array_filter(array_map(function($v) { return $v['name']; }, $tags));

	// merge result with old categories
	if (!empty($categories)) {
	$tags = array_unique(array_merge($tags, (array) $categories));
	}

	return $tags;
	}

	/**
	* Set tags to kolab object
	*/
	protected function setKolabTags($uid, $tags)
	{
	$config = kolab_storage_config::get_instance();
	$config->save_tags($uid, $tags);
	}

	/**
	* Converts string of days (TU,TH) to bitmask used by ActiveSync
	*
	* @param string $days
	*
	* @return int
	*/
	protected function day2bitmask($days)
	{
	$days = explode(',', $days);
	$result = 0;

	foreach ($days as $day) {
	$result = $result + $this->recurDayMap[$day];
	}

	return $result;
	}

	/**
	* Convert bitmask used by ActiveSync to string of days (TU,TH)
	*
	* @param int $days
	*
	* @return string
	*/
	protected function bitmask2day($days)
	{
	$days_arr = array();

	for ($bitmask = 1; $bitmask <= self::RECUR_DOW_SATURDAY; $bitmask = $bitmask << 1) {
	$dayMatch = $days & $bitmask;
	if ($dayMatch === $bitmask) {
	$days_arr[] = array_search($bitmask, $this->recurDayMap);
	}
	}
	$result = implode(',', $days_arr);

	return $result;
	}
	+
	+ /**
	+ * Check if current device type string matches any of options
	+ */
	+ protected function deviceTypeFilter($options)
	+ {
	+ foreach ($options as $option) {
	+ if ($option[0] == '/') {
	+ if (preg_match($option, $this->device->devicetype)) {
	+ return true;
	+ }
	+ }
	+ else if (stripos($this->device->devicetype, $option) !== false) {
	+ return true;
	+ }
	+ }
	+
	+ return false;
	+ }
	}
	diff --git a/lib/kolab_sync_data_contacts.php b/lib/kolab_sync_data_contacts.php
	index e348474..0562377 100644
	--- a/lib/kolab_sync_data_contacts.php
	+++ b/lib/kolab_sync_data_contacts.php
	@@ -1,283 +1,637 @@
	<?php

	/**
	+--------------------------------------------------------------------------+
	\| Kolab Sync (ActiveSync for Kolab) \|
	\| \|
	- \| Copyright (C) 2011-2012, Kolab Systems AG <contact@kolabsys.com> \|
	+ \| Copyright (C) 2011-2017, 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/> \|
	+--------------------------------------------------------------------------+
	\| Author: Aleksander Machniak <machniak@kolabsys.com> \|
	+--------------------------------------------------------------------------+
	*/

	/**
	* COntacts data class for Syncroton
	*/
	class kolab_sync_data_contacts extends kolab_sync_data
	{
	/**
	* Mapping from ActiveSync Contacts namespace fields
	*/
	protected $mapping = array(
	'anniversary' => 'anniversary',
	'assistantName' => 'assistant:0',
	//'assistantPhoneNumber' => 'assistantphonenumber',
	'birthday' => 'birthday',
	'body' => 'notes',
	'businessAddressCity' => 'address.work.locality',
	'businessAddressCountry' => 'address.work.country',
	'businessAddressPostalCode' => 'address.work.code',
	'businessAddressState' => 'address.work.region',
	'businessAddressStreet' => 'address.work.street',
	'businessFaxNumber' => 'phone.workfax.number',
	'businessPhoneNumber' => 'phone.work.number',
	'carPhoneNumber' => 'phone.car.number',
	//'categories' => 'categories',
	'children' => 'children',
	'companyName' => 'organization',
	'department' => 'department',
	//'email1Address' => 'email:0',
	//'email2Address' => 'email:1',
	//'email3Address' => 'email:2',
	//'fileAs' => 'fileas', //@TODO: ?
	'firstName' => 'firstname',
	//'home2PhoneNumber' => 'home2phonenumber',
	'homeAddressCity' => 'address.home.locality',
	'homeAddressCountry' => 'address.home.country',
	'homeAddressPostalCode' => 'address.home.code',
	'homeAddressState' => 'address.home.region',
	'homeAddressStreet' => 'address.home.street',
	'homeFaxNumber' => 'phone.homefax.number',
	'homePhoneNumber' => 'phone.home.number',
	'jobTitle' => 'jobtitle',
	'lastName' => 'surname',
	'middleName' => 'middlename',
	'mobilePhoneNumber' => 'phone.mobile.number',
	//'officeLocation' => 'officelocation',
	'otherAddressCity' => 'address.office.locality',
	'otherAddressCountry' => 'address.office.country',
	'otherAddressPostalCode' => 'address.office.code',
	'otherAddressState' => 'address.office.region',
	'otherAddressStreet' => 'address.office.street',
	'pagerNumber' => 'phone.pager.number',
	'picture' => 'photo',
	//'radioPhoneNumber' => 'radiophonenumber',
	//'rtf' => 'rtf',
	'spouse' => 'spouse',
	'suffix' => 'suffix',
	'title' => 'prefix',
	'webPage' => 'website.homepage.url',
	//'yomiCompanyName' => 'yomicompanyname',
	//'yomiFirstName' => 'yomifirstname',
	//'yomiLastName' => 'yomilastname',
	// Mapping from ActiveSync Contacts2 namespace fields
	//'accountName' => 'accountname',
	//'companyMainPhone' => 'companymainphone',
	//'customerId' => 'customerid',
	//'governmentId' => 'governmentid',
	'iMAddress' => 'im:0',
	'iMAddress2' => 'im:1',
	'iMAddress3' => 'im:2',
	'managerName' => 'manager:0',
	//'mMS' => 'mms',
	'nickName' => 'nickname',
	);

	/**
	* Kolab object type
	*
	* @var string
	*/
	protected $modelName = 'contact';

	/**
	* Type of the default folder
	*
	* @var int
	*/
	protected $defaultFolderType = Syncroton_Command_FolderSync::FOLDERTYPE_CONTACT;

	/**
	* Default container for new entries
	*
	* @var string
	*/
	protected $defaultFolder = 'Contacts';

	/**
	* Type of user created folders
	*
	* @var int
	*/
	protected $folderType = Syncroton_Command_FolderSync::FOLDERTYPE_CONTACT_USER_CREATED;

	+ /**
	+ * Identifier of special Global Address List folder
	+ *
	+ * @var string
	+ */
	+ protected $galFolder = 'GAL';
	+
	+ /**
	+ * Name of special Global Address List folder
	+ *
	+ * @var string
	+ */
	+ protected $galFolderName = 'Global Address Book';
	+
	+ protected $galPrefix = 'GAL:';
	+ protected $galSources;
	+ protected $galResult;
	+ protected $galCache;
	+

	/**
	* Creates model object
	*
	* @param Syncroton_Model_SyncCollection $collection Collection data
	* @param string $serverId Local entry identifier
	*/
	public function getEntry(Syncroton_Model_SyncCollection $collection, $serverId)
	{
	$data = is_array($serverId) ? $serverId : $this->getObject($collection->collectionId, $serverId);
	$result = array();

	+ if (empty($data)) {
	+ throw new Syncroton_Exception_NotFound("Contact $serverId not found");
	+ }
	+
	// Contacts namespace fields
	foreach ($this->mapping as $key => $name) {
	$value = $this->getKolabDataItem($data, $name);

	switch ($name) {
	case 'photo':
	if ($value) {
	// ActiveSync limits photo size to 48KB (of base64 encoded string)
	if (strlen($value) * 1.33 > 48 * 1024) {
	continue;
	}
	}
	break;

	case 'birthday':
	case 'anniversary':
	$value = self::date_from_kolab($value);
	break;

	case 'notes':
	$value = $this->body_from_kolab($value, $collection);
	break;
	}

	if (empty($value) \|\| is_array($value)) {
	continue;
	}

	$result[$key] = $value;
	}

	// email address(es): email1Address, email2Address, email3Address
	for ($x=0; $x<3; $x++) {
	- if (!empty($data['email'][$x]) && !empty($data['email'][$x]['address'])) {
	- $result['email' . ($x+1) . 'Address'] = $data['email'][$x]['address'];
	+ if ($email = $data['email'][$x]) {
	+ if (is_array($email)) {
	+ $email = $email['address'];
	+ }
	+ if ($email) {
	+ $result['email' . ($x+1) . 'Address'] = $email;
	+ }
	}
	}

	return new Syncroton_Model_Contact($result);
	}

	/**
	* convert contact from xml to libkolab array
	*
	* @param Syncroton_Model_IEntry $data Contact to convert
	* @param string $folderId Folder identifier
	* @param array $entry Existing entry
	*
	* @return array Kolab object array
	*/
	public function toKolab(Syncroton_Model_IEntry $data, $folderId, $entry = null)
	{
	$contact = !empty($entry) ? $entry : array();

	// Contacts namespace fields
	foreach ($this->mapping as $key => $name) {
	$value = $data->$key;

	switch ($name) {
	case 'address.work.street':
	if (strtolower($this->device->devicetype) == 'palm') {
	// palm pre sends the whole address in the <Contacts:BusinessStreet> tag
	$value = null;
	}
	break;

	case 'website.homepage.url':
	// remove facebook urls
	if (preg_match('/^fb:\/\//', $value)) {
	$value = null;
	}
	break;

	case 'notes':
	$value = $this->getBody($value, Syncroton_Model_EmailBody::TYPE_PLAINTEXT);
	// If note isn't specified keep old note
	if ($value === null) {
	continue 2;
	}
	break;

	case 'photo':
	// If photo isn't specified keep old photo
	if ($value === null) {
	continue 2;
	}
	break;

	case 'birthday':
	case 'anniversary':
	if ($value) {
	// convert date to string format, so libkolab will store
	// it with no time and timezone what could be incorrectly re-calculated (#2555)
	$value = $value->format('Y-m-d');
	}
	break;
	}

	$this->setKolabDataItem($contact, $name, $value);
	}

	// email address(es): email1Address, email2Address, email3Address
	$emails = array();
	for ($x=0; $x<3; $x++) {
	$key = 'email' . ($x+1) . 'Address';
	if ($value = $data->$key) {
	// Android sends email address as: Lars Kneschke <l.kneschke@metaways.de>
	if (preg_match('/(.*)<(.+@[^@]+)>/', $value, $matches)) {
	$value = trim($matches[2]);
	}

	// sanitize email address, it can contain broken (non-unicode) characters (#3287)
	$value = rcube_charset::clean($value);

	// try to find address type, at least we can do this if
	// address wasn't changed
	$type = '';
	foreach ((array)$contact['email'] as $email) {
	if ($email['address'] == $value) {
	$type = $email['type'];
	}
	}
	$emails[] = array('address' => $value, 'type' => $type);
	}
	}
	$contact['email'] = $emails;

	return $contact;
	}

	+ /**
	+ * Return list of supported folders for this backend
	+ *
	+ * @return array
	+ */
	+ public function getAllFolders()
	+ {
	+ $list = parent::getAllFolders();
	+
	+ if ($this->isMultiFolder() && $this->hasGAL()) {
	+ $list[$this->galFolder] = new Syncroton_Model_Folder(array(
	+ 'displayName' => $this->galFolderName, // @TODO: localization?
	+ 'serverId' => $this->galFolder,
	+ 'parentId' => 0,
	+ 'type' => 14,
	+ ));
	+ }
	+
	+ return $list;
	+ }
	+
	+ /**
	+ * Updates a folder
	+ */
	+ public function updateFolder(Syncroton_Model_IFolder $folder)
	+ {
	+ if ($folder->serverId === $this->galFolder && $this->hasGAL()) {
	+ throw new Syncroton_Exception_AccessDenied("Updating GAL folder is not possible");
	+ }
	+
	+ return parent::updateFolder($folder);
	+ }
	+
	+ /**
	+ * Deletes a folder
	+ */
	+ public function deleteFolder($folder)
	+ {
	+ if ($folder instanceof Syncroton_Model_IFolder) {
	+ $folder = $folder->serverId;
	+ }
	+
	+ if ($folder === $this->galFolder && $this->hasGAL()) {
	+ throw new Syncroton_Exception_AccessDenied("Deleting GAL folder is not possible");
	+ }
	+
	+ return parent::deleteFolder($folder);
	+ }
	+
	+ /**
	+ * Empty folder (remove all entries and optionally subfolders)
	+ *
	+ * @param string $folderId Folder identifier
	+ * @param array $options Options
	+ */
	+ public function emptyFolderContents($folderid, $options)
	+ {
	+ if ($folderid === $this->galFolder && $this->hasGAL()) {
	+ throw new Syncroton_Exception_AccessDenied("Emptying GAL folder is not possible");
	+ }
	+
	+ return parent::emptyFolderContents($folderid, $options);
	+ }
	+
	+ /**
	+ * Moves object into another location (folder)
	+ *
	+ * @param string $srcFolderId Source folder identifier
	+ * @param string $serverId Object identifier
	+ * @param string $dstFolderId Destination folder identifier
	+ *
	+ * @throws Syncroton_Exception_Status
	+ * @return string New object identifier
	+ */
	+ public function moveItem($srcFolderId, $serverId, $dstFolderId)
	+ {
	+ if (strpos($serverId, $this->galPrefix) === 0 && $this->hasGAL()) {
	+ throw new Syncroton_Exception_AccessDenied("Moving GAL entries is not possible");
	+ }
	+
	+ if ($srcFolderId === $this->galFolder && $this->hasGAL()) {
	+ throw new Syncroton_Exception_AccessDenied("Moving/Deleting GAL entries is not possible");
	+ }
	+
	+ if ($dstFolderId === $this->galFolder && $this->hasGAL()) {
	+ throw new Syncroton_Exception_AccessDenied("Creating GAL entries is not possible");
	+ }
	+
	+ return parent::moveItem($srcFolderId, $serverId, $dstFolderId);
	+ }
	+
	+ /**
	+ * Add entry
	+ *
	+ * @param string $folderId Folder identifier
	+ * @param Syncroton_Model_IEntry $entry Entry object
	+ *
	+ * @return string ID of the created entry
	+ */
	+ public function createEntry($folderId, Syncroton_Model_IEntry $entry)
	+ {
	+ if ($folderId === $this->galFolder && $this->hasGAL()) {
	+ throw new Syncroton_Exception_AccessDenied("Creating GAL entries is not possible");
	+ }
	+
	+ return parent::createEntry($folderId, $entry);
	+ }
	+
	+ /**
	+ * update existing entry
	+ *
	+ * @param string $folderId
	+ * @param string $serverId
	+ * @param SimpleXMLElement $entry
	+ *
	+ * @return string ID of the updated entry
	+ */
	+ public function updateEntry($folderId, $serverId, Syncroton_Model_IEntry $entry)
	+ {
	+ if (strpos($serverId, $this->galPrefix) === 0 && $this->hasGAL()) {
	+ throw new Syncroton_Exception_AccessDenied("Updating GAL entries is not possible");
	+ }
	+
	+ return parent::updateEntry($folderId, $serverId, $entry);
	+ }
	+
	+ /**
	+ * delete entry
	+ *
	+ * @param string $folderId
	+ * @param string $serverId
	+ * @param array $collectionData
	+ */
	+ public function deleteEntry($folderId, $serverId, $collectionData)
	+ {
	+ if (strpos($serverId, $this->galPrefix) === 0 && $this->hasGAL()) {
	+ throw new Syncroton_Exception_AccessDenied("Deleting GAL entries is not possible");
	+ }
	+
	+ return parent::deleteEntry($folderId, $serverId, $collectionData);
	+ }
	+
	/**
	* Returns filter query array according to specified ActiveSync FilterType
	*
	* @param int $filter_type Filter type
	*
	* @param array Filter query
	*/
	protected function filter($filter_type = 0)
	{
	// specify object type, contact folders in Kolab might
	// contain also ditribution-list objects, we'll skip them
	return array(array('type', '=', $this->modelName));
	}

	+ /**
	+ * Check if GAL synchronization is enabled for current device
	+ */
	+ protected function hasGAL()
	+ {
	+ return count($this->getGALSources());
	+ }
	+
	+ /**
	+ * Search for existing entries
	+ *
	+ * @param string $folderid Folder identifier
	+ * @param array $filter Search filter
	+ * @param int $result_type Type of the result (see RESULT_* constants)
	+ *
	+ * @return array\|int Search result as count or array of uids/objects
	+ */
	+ protected function searchEntries($folderid, $filter = array(), $result_type = self::RESULT_UID)
	+ {
	+ // GAL Folder exists, return result from LDAP only
	+ if ($folderid === $this->galFolder && $this->hasGAL()) {
	+ return $this->searchGALEntries($filter, $result_type);
	+ }
	+
	+ $result = parent::searchEntries($folderid, $filter, $result_type);
	+
	+ // Merge results from LDAP
	+ if ($this->hasGAL() && !$this->isMultiFolder()) {
	+ $gal_result = $this->searchGALEntries($filter, $result_type);
	+
	+ if ($result_type == self::RESULT_COUNT) {
	+ $result += $gal_result;
	+ }
	+ else {
	+ $result = array_merge($result, $gal_result);
	+ }
	+ }
	+
	+ return $result;
	+ }
	+
	+ /**
	+ * Fetches the entry from the backend
	+ */
	+ protected function getObject($folderid, $entryid, &$folder = null)
	+ {
	+ if (strpos($entryid, $this->galPrefix) === 0 && $this->hasGAL()) {
	+ return $this->getGALEntry($entryid);
	+ }
	+
	+ return parent::getObject($folderid, $entryid, $folder);
	+ }
	+
	+ /**
	+ * Search for existing LDAP entries
	+ *
	+ * @param array $filter Search filter
	+ * @param int $result_type Type of the result (see RESULT_* constants)
	+ *
	+ * @return array\|int Search result as count or array of uids/objects
	+ */
	+ protected function searchGALEntries($filter, $result_type)
	+ {
	+ // For GAL we don't check for changes.
	+ // When something changed a new UID will be generated so the update
	+ // will be done as delete + create
	+ foreach ($filter as $f) {
	+ if ($f[0] == 'changed') {
	+ return $result_type == self::RESULT_COUNT ? 0 : array();
	+ }
	+ }
	+
	+ if ($this->galCache && ($result = $this->galCache->get('index')) !== null) {
	+ $result = explode("\n", $result);
	+ return $result_type == self::RESULT_COUNT ? count($result) : $result;
	+ }
	+
	+ $result = array();
	+
	+ foreach ($this->getGALSources() as $source) {
	+ if ($book = kolab_sync_data_gal::get_address_book($source['id'])) {
	+ $book->reset();
	+ $book->set_page(1);
	+ $book->set_pagesize(10000);
	+
	+ $set = $book->list_records();
	+ while ($contact = $set->next()) {
	+ $result[] = $this->createGALEntryUID($contact, $source['id']);
	+ }
	+ }
	+ }
	+
	+ if ($this->galCache) {
	+ $this->galCache->set('index', implode("\n", $result));
	+ }
	+
	+ return $result_type == self::RESULT_COUNT ? count($result) : $result;
	+ }
	+
	+ /**
	+ * Return specified LDAP entry
	+ *
	+ * @param string $serverId Entry identifier
	+ *
	+ * @return array Contact data
	+ */
	+ protected function getGALEntry($serverId)
	+ {
	+ list($source, $timestamp, $uid) = $this->resolveGALEntryUID($serverId);
	+
	+ if ($source && $uid && ($book = kolab_sync_data_gal::get_address_book($source))) {
	+ $book->reset();
	+
	+ $set = $book->search('uid', array($uid), rcube_addressbook::SEARCH_STRICT, true, true);
	+ $result = $set->first();
	+
	+ if ($result['uid'] == $uid && $result['changed'] == $timestamp) {
	+ // As in kolab_sync_data_gal we use only one email address
	+ if (empty($result['email'])) {
	+ $emails = $book->get_col_values('email', $result, true);
	+ $result['email'] = array($emails[0]);
	+ }
	+
	+ return $result;
	+ }
	+ }
	+ }
	+
	+ /**
	+ * Return LDAP address books list
	+ *
	+ * @return array Address books array
	+ */
	+ protected function getGALSources()
	+ {
	+ if ($this->galSources === null) {
	+ $rcube = rcube::get_instance();
	+ $gal_sync = $rcube->config->get('activesync_gal_sync');
	+ $enabled = false;
	+
	+ if ($gal_sync === true) {
	+ $enabled = true;
	+ }
	+ else if (is_array($gal_sync)) {
	+ $enabled = $this->deviceTypeFilter($gal_sync);
	+ }
	+
	+ $this->galSources = $enabled ? kolab_sync_data_gal::get_address_sources() : array();
	+
	+ if ($cache_type = $rcube->config->get('activesync_gal_cache', 'db')) {
	+ $cache_ttl = $rcube->config->get('activesync_gal_cache_ttl', '1d');
	+ $this->galCache = $rcube->get_cache('activesync_gal', $cache_type, $cache_ttl, false);
	+
	+ // expunge cache every now and then
	+ if (rand(0, 10) === 0) {
	+ $this->galCache->expunge();
	+ }
	+ }
	+ }
	+
	+ return $this->galSources;
	+ }
	+
	+ /**
	+ * Builds contact identifier from contact data and source id
	+ */
	+ protected function createGALEntryUID($contact, $source_id)
	+ {
	+ return $this->galPrefix . sprintf('%s:%s:%s', rcube_ldap::dn_encode($source_id), $contact['changed'], $contact['uid']);
	+ }
	+
	+ /**
	+ * Extracts contact identification data from contact identifier
	+ */
	+ protected function resolveGALEntryUID($uid)
	+ {
	+ if (strpos($uid, $this->galPrefix) === 0) {
	+ $items = explode(':', substr($uid, strlen($this->galPrefix)));
	+ $items[0] = rcube_ldap::dn_decode($items[0]);
	+ return $items; // source, timestamp, uid
	+ }
	+
	+ return array();
	+ }
	}
	diff --git a/lib/kolab_sync_data_gal.php b/lib/kolab_sync_data_gal.php
	index 297a4a9..95894e7 100644
	--- a/lib/kolab_sync_data_gal.php
	+++ b/lib/kolab_sync_data_gal.php
	@@ -1,399 +1,390 @@
	<?php

	/**
	+--------------------------------------------------------------------------+
	\| Kolab Sync (ActiveSync for Kolab) \|
	\| \|
	\| Copyright (C) 2011-2012, Kolab Systems AG <contact@kolabsys.com> \|
	\| \|
	\| This program is free software: you can redistribute it and/or modify \|
	\| it under the terms of the GNU Affero General Public License as published \|
	\| by the Free Software Foundation, either version 3 of the License, or \|
	\| (at your option) any later version. \|
	\| \|
	\| This program is distributed in the hope that it will be useful, \|
	\| but WITHOUT ANY WARRANTY; without even the implied warranty of \|
	\| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the \|
	\| GNU Affero General Public License for more details. \|
	\| \|
	\| You should have received a copy of the GNU Affero General Public License \|
	\| along with this program. If not, see <http://www.gnu.org/licenses/> \|
	+--------------------------------------------------------------------------+
	\| Author: Aleksander Machniak <machniak@kolabsys.com> \|
	+--------------------------------------------------------------------------+
	*/

	/**
	* GAL (Global Address List) data backend for Syncroton
	*/
	class kolab_sync_data_gal extends kolab_sync_data implements Syncroton_Data_IDataSearch
	{
	const MAX_SEARCH_RESULT = 100;

	/**
	* LDAP search result
	*
	* @var array
	*/
	protected $result = array();

	/**
	* LDAP address books list
	*
	* @var array
	*/
	- protected $address_books = array();
	+ protected static $address_books = array();

	/**
	* Mapping from ActiveSync Contacts namespace fields
	*/
	protected $mapping = array(
	'alias' => 'nickname',
	'company' => 'organization',
	'displayName' => 'name',
	'emailAddress' => 'email',
	'firstName' => 'firstname',
	'lastName' => 'surname',
	'mobilePhone' => 'phone.mobile',
	'office' => 'office',
	'picture' => 'photo',
	'phone' => 'phone',
	'title' => 'jobtitle',
	);

	/**
	* Kolab object type
	*
	* @var string
	*/
	protected $modelName = 'contact';

	/**
	* Type of the default folder
	*
	* @var int
	*/
	protected $defaultFolderType = Syncroton_Command_FolderSync::FOLDERTYPE_CONTACT;

	/**
	* Default container for new entries
	*
	* @var string
	*/
	protected $defaultFolder = 'Contacts';

	/**
	* Type of user created folders
	*
	* @var int
	*/
	protected $folderType = Syncroton_Command_FolderSync::FOLDERTYPE_CONTACT_USER_CREATED;


	/**
	* the constructor
	*
	* @param Syncroton_Model_IDevice $device
	* @param DateTime $syncTimeStamp
	*/
	public function __construct(Syncroton_Model_IDevice $device, DateTime $syncTimeStamp)
	{
	parent::__construct($device, $syncTimeStamp);

	// Use configured fields mapping
	$rcube = rcube::get_instance();
	$fieldmap = (array) $rcube->config->get('activesync_gal_fieldmap');
	if (!empty($fieldmap)) {
	$fieldmap = array_intersec_key($fieldmap, array_keys($this->mapping));
	$this->mapping = array_merge($this->mapping, $fieldmap);
	}
	}

	/**
	* Not used but required by parent class
	*/
	public function toKolab(Syncroton_Model_IEntry $data, $folderId, $entry = null)
	{
	}

	/**
	* Not used but required by parent class
	*/
	public function getEntry(Syncroton_Model_SyncCollection $collection, $serverId)
	{
	}

	/**
	* Returns properties of a contact for Search response
	*
	* @param array $data Contact data
	* @param array $options Search options
	*
	* @return Syncroton_Model_GAL Contact (GAL) object
	*/
	public function getSearchEntry($data, $options)
	{
	$result = array();

	// Contacts namespace fields
	foreach ($this->mapping as $key => $name) {
	$value = $this->getLDAPDataItem($data, $name);

	if (empty($value) \|\| is_array($value)) {
	continue;
	}

	switch ($name) {
	case 'photo':
	// @TODO: MaxPictures option
	// ActiveSync limits photo size of GAL contact to 100KB
	$maxsize = 102400;
	if (!empty($options['picture']['maxSize'])) {
	$maxsize = min($maxsize, $options['picture']['maxSize']);
	}

	if (strlen($value) > $maxsize) {
	continue;
	}

	$value = new Syncroton_Model_GALPicture(array(
	'data' => $value, // binary
	'status' => Syncroton_Model_GALPicture::STATUS_SUCCESS,
	));

	break;
	}

	$result[$key] = $value;
	}

	return new Syncroton_Model_GAL($result);
	}


	/**
	* ActiveSync Search handler
	*
	* @param Syncroton_Model_StoreRequest $store Search query parameters
	*
	* @return Syncroton_Model_StoreResponse Complete Search response
	* @throws Exception
	*/
	public function search(Syncroton_Model_StoreRequest $store)
	{
	$options = $store->options;
	$query = $store->query;

	if (empty($query) \|\| !is_string($query)) {
	throw new Exception('Empty/invalid search request');
	}

	$records = array();
	$rcube = rcube::get_instance();

	// @TODO: caching with Options->RebuildResults support

	- $books = $this->get_address_sources();
	+ $books = self::get_address_sources();
	$mode = 2; // use prefix mode
	$fields = $rcube->config->get('contactlist_fields');

	if (empty($fields)) {
	$fields = '*';
	}

	foreach ($books as $idx => $book) {
	- $book = $this->get_address_book($idx);
	+ $book = self::get_address_book($idx);

	if (!$book) {
	continue;
	}

	$book->set_page(1);
	$book->set_pagesize(self::MAX_SEARCH_RESULT);

	$result = $book->search($fields, $query, $mode, true, true, 'email');

	if (!$result->count) {
	continue;
	}

	// get records
	$result = $book->list_records();

	while ($row = $result->next()) {
	$row['sourceid'] = $idx;

	// make sure 'email' item is there, convert all email:* into one
	$row['email'] = $book->get_col_values('email', $row, true);

	$key = $this->contact_key($row);
	unset($row['_raw_attrib']); // save some memory, @TODO: do this in rcube_ldap
	$records[$key] = $row;
	}

	// We don't want to search all sources if we've got already a lot of contacts
	if (count($records) >= self::MAX_SEARCH_RESULT) {
	break;
	}
	}

	// sort the records
	ksort($records, SORT_LOCALE_STRING);

	$records = array_values($records);
	$response = new Syncroton_Model_StoreResponse();

	// Calculate requested range
	$start = (int) $options['range'][0];
	$limit = (int) $options['range'][1] + 1;
	$total = count($records);
	$response->total = $total;

	// Get requested chunk of data set
	if ($total) {
	if ($start > $total) {
	$start = $total;
	}
	if ($limit > $total) {
	$limit = max($start+1, $total);
	}

	if ($start > 0 \|\| $limit < $total) {
	$records = array_slice($records, $start, $limit-$start);
	}

	$response->range = array($start, $start + count($records) - 1);
	}

	// Build result array, convert to ActiveSync format
	foreach ($records as $idx => $rec) {
	$response->result[] = new Syncroton_Model_StoreResponseResult(array(
	'longId' => $rec['ID'],
	'properties' => $this->getSearchEntry($rec, $options),
	));
	unset($records[$idx]);
	}

	return $response;
	}

	/**
	* Return instance of the internal address book class
	*
	* @param string $id Address book identifier
	*
	* @return rcube_contacts Address book object
	*/
	- protected function get_address_book($id)
	+ public static function get_address_book($id)
	{
	$config = rcube::get_instance()->config;
	$ldap_config = (array) $config->get('ldap_public');

	// use existing instance
	- if (isset($this->address_books[$id]) && ($this->address_books[$id] instanceof rcube_addressbook)) {
	- $book = $this->address_books[$id];
	+ if (isset(self::$address_books[$id]) && (self::$address_books[$id] instanceof rcube_addressbook)) {
	+ $book = self::$address_books[$id];
	}
	else if ($id && $ldap_config[$id]) {
	$book = new rcube_ldap($ldap_config[$id], $config->get('ldap_debug'),
	$config->mail_domain($_SESSION['storage_host']));
	}

	if (!$book) {
	rcube::raise_error(array(
	'code' => 700, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Addressbook source ($id) not found!"),
	true, false);

	return null;
	}
	/*
	// set configured sort order
	if ($sort_col = $this->config->get('addressbook_sort_col'))
	$book->set_sort_order($sort_col);
	*/
	// add to the 'books' array for shutdown function
	- $this->address_books[$id] = $book;
	+ self::$address_books[$id] = $book;

	return $book;
	}


	/**
	* Return LDAP address books list
	*
	* @return array Address books array
	*/
	- protected function get_address_sources()
	+ public static function get_address_sources()
	{
	$config = rcube::get_instance()->config;
	$ldap_config = (array) $config->get('ldap_public');
	$async_books = $config->get('activesync_addressbooks');

	if ($async_books === null) {
	$async_books = (array) $config->get('autocomplete_addressbooks');
	}

	$list = array();

	foreach ((array)$async_books as $id) {
	$prop = $ldap_config[$id];
	- // handle misconfiguration
	- if (empty($prop) \|\| !is_array($prop)) {
	- continue;
	+ if (!empty($prop) && is_array($prop)) {
	+ $list[$id] = array(
	+ 'id' => $id,
	+ 'name' => $prop['name'],
	+ );
	}
	-
	- $list[$id] = array(
	- 'id' => $id,
	- 'name' => $prop['name'],
	- );
	-/*
	- // register source for shutdown function
	- if (!is_object($this->address_books[$id]))
	- $this->address_books[$id] = $list[$id];
	- }
	-*/
	}

	return $list;
	}

	/**
	* Creates contact key for sorting by
	*/
	protected function contact_key($row)
	{
	$key = $row['name'] . ':' . $row['sourceid'];

	// add email to a key to not skip contacts with the same name
	if (!empty($row['email'])) {
	if (is_array($row['email'])) {
	$key .= ':' . implode(':', $row['email']);
	}
	else {
	$key .= ':' . $row['email'];
	}
	}

	return $key;
	}

	/**
	* Extracts data from Roundcube LDAP data array
	*/
	protected function getLDAPDataItem($data, $name)
	{
	list($name, $index) = explode(':', $name);
	$name = str_replace('.', ':', $name);

	if (isset($data[$name])) {
	if ($index) {
	return is_array($data[$name]) ? $data[$name][$index] : null;
	}

	return is_array($data[$name]) ? array_shift($data[$name]) : $data[$name];
	}

	return null;
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Aug 25, 7:50 PM (20 h, 45 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 257687
Default Alt Text: (99 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions