No OneTemporary
Actions

Size

99 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/ext/Syncroton/Command/GetAttachment.php b/lib/ext/Syncroton/Command/GetAttachment.php
	index 28c0deb..f098dec 100644
	--- a/lib/ext/Syncroton/Command/GetAttachment.php
	+++ b/lib/ext/Syncroton/Command/GetAttachment.php
	@@ -1,69 +1,69 @@
	<?php
	/**
	* Syncroton
	*
	* @package Syncroton
	* @subpackage Command
	* @license http://www.tine20.org/licenses/lgpl.html LGPL Version 3
	* @copyright Copyright (c) 2010-2012 Metaways Infosystems GmbH (http://www.metaways.de)
	* @author Lars Kneschke <l.kneschke@metaways.de>
	*/

	/**
	* class to handle ActiveSync GetAttachment command
	*
	* @package Syncroton
	* @subpackage Command
	*/
	class Syncroton_Command_GetAttachment extends Syncroton_Command_Wbxml
	{
	/**
	*
	* @var string
	*/
	protected $_attachmentName;

	protected $_skipValidatePolicyKey = true;

	/**
	* process the XML file and add, change, delete or fetches data
	*
	* @return resource
	*/
	public function handle()
	{
	$this->_attachmentName = $this->_requestParameters['attachmentName'];
	}

	/**
	* this function generates the response for the client
	*
	* @return void
	*/
	public function getResponse()
	{
	$dataController = Syncroton_Data_Factory::factory(Syncroton_Data_Factory::CLASS_EMAIL, $this->_device, $this->_syncTimeStamp);

	$attachment = $dataController->getFileReference($this->_attachmentName);

	if (PHP_SAPI !== 'cli') {
	// cache for 3600 seconds
	$maxAge = 3600;
	- $now = new DateTime(null, new DateTimeZone('UTC'));
	+ $now = new DateTime('now', new DateTimeZone('UTC'));
	header('Cache-Control: private, max-age=' . $maxAge);
	header("Expires: " . gmdate('D, d M Y H:i:s', $now->modify("+{$maxAge} sec")->getTimestamp()) . " GMT");

	// overwrite Pragma header from session
	header("Pragma: cache");

	#header('Content-Disposition: attachment; filename="' . $filename . '"');
	header("Content-Type: " . $attachment->contentType);
	}

	if (is_resource($attachment->data)) {
	fpassthru($attachment->data);
	} else {
	echo $attachment->data;
	}
	}
	}
	diff --git a/lib/ext/Syncroton/Command/Sync.php b/lib/ext/Syncroton/Command/Sync.php
	index e179f40..4f3dde7 100644
	--- a/lib/ext/Syncroton/Command/Sync.php
	+++ b/lib/ext/Syncroton/Command/Sync.php
	@@ -1,1178 +1,1178 @@
	<?php
	/**
	* Syncroton
	*
	* @package Syncroton
	* @subpackage Command
	* @license http://www.tine20.org/licenses/lgpl.html LGPL Version 3
	* @copyright Copyright (c) 2009-2012 Metaways Infosystems GmbH (http://www.metaways.de)
	* @author Lars Kneschke <l.kneschke@metaways.de>
	*/

	/**
	* class to handle ActiveSync Sync command
	*
	* @package Syncroton
	* @subpackage Command
	*/
	class Syncroton_Command_Sync extends Syncroton_Command_Wbxml
	{
	const STATUS_SUCCESS = 1;
	const STATUS_PROTOCOL_VERSION_MISMATCH = 2;
	const STATUS_INVALID_SYNC_KEY = 3;
	const STATUS_PROTOCOL_ERROR = 4;
	const STATUS_SERVER_ERROR = 5;
	const STATUS_ERROR_IN_CLIENT_SERVER_CONVERSION = 6;
	const STATUS_CONFLICT_MATCHING_THE_CLIENT_AND_SERVER_OBJECT = 7;
	const STATUS_OBJECT_NOT_FOUND = 8;
	const STATUS_USER_ACCOUNT_MAYBE_OUT_OF_DISK_SPACE = 9;
	const STATUS_ERROR_SETTING_NOTIFICATION_GUID = 10;
	const STATUS_DEVICE_NOT_PROVISIONED_FOR_NOTIFICATIONS = 11;
	const STATUS_FOLDER_HIERARCHY_HAS_CHANGED = 12;
	const STATUS_RESEND_FULL_XML = 13;
	const STATUS_WAIT_INTERVAL_OUT_OF_RANGE = 14;
	const STATUS_TOO_MANY_COLLECTIONS = 15;

	const CONFLICT_OVERWRITE_SERVER = 0;
	const CONFLICT_OVERWRITE_PIM = 1;

	const MIMESUPPORT_DONT_SEND_MIME = 0;
	const MIMESUPPORT_SMIME_ONLY = 1;
	const MIMESUPPORT_SEND_MIME = 2;

	const BODY_TYPE_PLAIN_TEXT = 1;
	const BODY_TYPE_HTML = 2;
	const BODY_TYPE_RTF = 3;
	const BODY_TYPE_MIME = 4;

	/**
	* truncate types
	*/
	const TRUNCATE_ALL = 0;
	const TRUNCATE_4096 = 1;
	const TRUNCATE_5120 = 2;
	const TRUNCATE_7168 = 3;
	const TRUNCATE_10240 = 4;
	const TRUNCATE_20480 = 5;
	const TRUNCATE_51200 = 6;
	const TRUNCATE_102400 = 7;
	const TRUNCATE_NOTHING = 8;

	/**
	* filter types
	*/
	const FILTER_NOTHING = 0;
	const FILTER_1_DAY_BACK = 1;
	const FILTER_3_DAYS_BACK = 2;
	const FILTER_1_WEEK_BACK = 3;
	const FILTER_2_WEEKS_BACK = 4;
	const FILTER_1_MONTH_BACK = 5;
	const FILTER_3_MONTHS_BACK = 6;
	const FILTER_6_MONTHS_BACK = 7;
	const FILTER_INCOMPLETE = 8;


	protected $_defaultNameSpace = 'uri:AirSync';
	protected $_documentElement = 'Sync';

	/**
	* list of collections
	*
	* @var array
	*/
	protected $_collections = array();

	protected $_modifications = array();

	/**
	* the global WindowSize
	*
	* @var integer
	*/
	protected $_globalWindowSize;

	/**
	* there are more entries than WindowSize available
	* the MoreAvailable tag hot added to the xml output
	*
	* @var boolean
	*/
	protected $_moreAvailable = false;

	/**
	* @var Syncroton_Model_SyncState
	*/
	protected $_syncState;

	protected $_maxWindowSize = 100;

	protected $_heartbeatInterval = null;

	/**
	* process the XML file and add, change, delete or fetches data
	*/
	public function handle()
	{
	// input xml
	$requestXML = simplexml_import_dom($this->_mergeSyncRequest($this->_requestBody, $this->_device));

	if (! isset($requestXML->Collections)) {
	$this->_outputDom->documentElement->appendChild(
	$this->_outputDom->createElementNS('uri:AirSync', 'Status', self::STATUS_RESEND_FULL_XML)
	);

	return $this->_outputDom;
	}

	if (isset($requestXML->HeartbeatInterval)) {
	$intervalDiv = 1;
	$this->_heartbeatInterval = (int)$requestXML->HeartbeatInterval;
	} else if (isset($requestXML->Wait)) {
	$intervalDiv = 60;
	$this->_heartbeatInterval = (int)$requestXML->Wait * $intervalDiv;
	}

	$maxInterval = Syncroton_Registry::getPingInterval();
	if ($maxInterval <= 0 \|\| $maxInterval > Syncroton_Server::MAX_HEARTBEAT_INTERVAL) {
	$maxInterval = Syncroton_Server::MAX_HEARTBEAT_INTERVAL;
	}

	if ($this->_heartbeatInterval && $this->_heartbeatInterval > $maxInterval) {
	$sync = $this->_outputDom->documentElement;
	$sync->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', self::STATUS_WAIT_INTERVAL_OUT_OF_RANGE));
	$sync->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Limit', floor($maxInterval/$intervalDiv)));
	$this->_heartbeatInterval = null;
	return;
	}

	$this->_globalWindowSize = isset($requestXML->WindowSize) ? (int)$requestXML->WindowSize : 100;

	if (!$this->_globalWindowSize \|\| $this->_globalWindowSize > 512) {
	$this->_globalWindowSize = 512;
	}

	if ($this->_globalWindowSize > $this->_maxWindowSize) {
	$this->_globalWindowSize = $this->_maxWindowSize;
	}

	// load options from lastsynccollection
	$lastSyncCollection = array('options' => array());
	if (!empty($this->_device->lastsynccollection)) {
	$lastSyncCollection = Zend_Json::decode($this->_device->lastsynccollection);
	if (!array_key_exists('options', $lastSyncCollection) \|\| !is_array($lastSyncCollection['options'])) {
	$lastSyncCollection['options'] = array();
	}
	}

	$maxCollections = Syncroton_Registry::getMaxCollections();
	if ($maxCollections && count($requestXML->Collections->Collection) > $maxCollections) {
	$sync = $this->_outputDom->documentElement;
	$sync->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', self::STATUS_TOO_MANY_COLLECTIONS));
	$sync->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Limit', $maxCollections));
	return;
	}

	$collections = array();

	foreach ($requestXML->Collections->Collection as $xmlCollection) {
	$collectionId = (string)$xmlCollection->CollectionId;

	$collections[$collectionId] = new Syncroton_Model_SyncCollection($xmlCollection);

	// do we have to reuse the options from the previous request?
	if (!isset($xmlCollection->Options) && array_key_exists($collectionId, $lastSyncCollection['options'])) {
	$collections[$collectionId]->options = $lastSyncCollection['options'][$collectionId];
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " restored options to " . print_r($collections[$collectionId]->options, TRUE));
	}

	// store current options for next Sync command request (sticky options)
	$lastSyncCollection['options'][$collectionId] = $collections[$collectionId]->options;
	}

	$this->_device->lastsynccollection = Zend_Json::encode($lastSyncCollection);

	if ($this->_device->isDirty()) {
	Syncroton_Registry::getDeviceBackend()->update($this->_device);
	}

	foreach ($collections as $collectionData) {
	// has the folder been synchronised to the device already
	try {
	$collectionData->folder = $this->_folderBackend->getFolder($this->_device, $collectionData->collectionId);

	} catch (Syncroton_Exception_NotFound $senf) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " folder {$collectionData->collectionId} not found");

	// trigger INVALID_SYNCKEY instead of OBJECT_NOTFOUND when synckey is higher than 0
	// to avoid a syncloop for the iPhone
	if ($collectionData->syncKey > 0) {
	$collectionData->folder = new Syncroton_Model_Folder(array(
	'deviceId' => $this->_device,
	'serverId' => $collectionData->collectionId
	));
	}

	$this->_collections[$collectionData->collectionId] = $collectionData;

	continue;
	}

	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " SyncKey is {$collectionData->syncKey} Class: {$collectionData->folder->class} CollectionId: {$collectionData->collectionId}");

	// initial synckey
	if($collectionData->syncKey === 0) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " initial client synckey 0 provided");

	// reset sync state for this folder
	$this->_syncStateBackend->resetState($this->_device, $collectionData->folder);
	$this->_contentStateBackend->resetState($this->_device, $collectionData->folder);

	$collectionData->syncState = new Syncroton_Model_SyncState(array(
	'device_id' => $this->_device,
	'counter' => 0,
	'type' => $collectionData->folder,
	'lastsync' => $this->_syncTimeStamp
	));

	$this->_collections[$collectionData->collectionId] = $collectionData;

	continue;
	}

	// check for invalid sycnkey
	if(($collectionData->syncState = $this->_syncStateBackend->validate($this->_device, $collectionData->folder, $collectionData->syncKey)) === false) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " invalid synckey {$collectionData->syncKey} provided");

	// reset sync state for this folder
	$this->_syncStateBackend->resetState($this->_device, $collectionData->folder);
	$this->_contentStateBackend->resetState($this->_device, $collectionData->folder);

	$this->_collections[$collectionData->collectionId] = $collectionData;

	continue;
	}

	$dataController = Syncroton_Data_Factory::factory($collectionData->folder->class, $this->_device, $this->_syncTimeStamp);

	switch($collectionData->folder->class) {
	case Syncroton_Data_Factory::CLASS_CALENDAR:
	$dataClass = 'Syncroton_Model_Event';
	break;

	case Syncroton_Data_Factory::CLASS_CONTACTS:
	$dataClass = 'Syncroton_Model_Contact';
	break;

	case Syncroton_Data_Factory::CLASS_EMAIL:
	$dataClass = 'Syncroton_Model_Email';
	break;

	case Syncroton_Data_Factory::CLASS_NOTES:
	$dataClass = 'Syncroton_Model_Note';
	break;

	case Syncroton_Data_Factory::CLASS_TASKS:
	$dataClass = 'Syncroton_Model_Task';
	break;

	default:
	throw new Syncroton_Exception_UnexpectedValue('invalid class provided');
	break;
	}

	$clientModifications = array(
	'added' => array(),
	'changed' => array(),
	'deleted' => array(),
	'forceAdd' => array(),
	'forceChange' => array(),
	'toBeFetched' => array(),
	);

	// handle incoming data
	if($collectionData->hasClientAdds()) {
	$adds = $collectionData->getClientAdds();

	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " found " . count($adds) . " entries to be added to server");

	foreach ($adds as $add) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " add entry with clientId " . (string) $add->ClientId);

	try {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " adding entry as new");

	$serverId = $dataController->createEntry($collectionData->collectionId, new $dataClass($add->ApplicationData));

	$clientModifications['added'][$serverId] = array(
	'clientId' => (string)$add->ClientId,
	'serverId' => $serverId,
	'status' => self::STATUS_SUCCESS,
	'contentState' => $this->_contentStateBackend->create(new Syncroton_Model_Content(array(
	'device_id' => $this->_device,
	'folder_id' => $collectionData->folder,
	'contentid' => $serverId,
	'creation_time' => $this->_syncTimeStamp,
	'creation_synckey' => $collectionData->syncKey + 1
	)))
	);

	} catch (Exception $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " failed to add entry " . $e->getMessage());
	$clientModifications['added'][] = array(
	'clientId' => (string)$add->ClientId,
	'status' => self::STATUS_SERVER_ERROR
	);
	}
	}
	}

	// handle changes, but only if not first sync
	if($collectionData->syncKey > 1 && $collectionData->hasClientChanges()) {
	$changes = $collectionData->getClientChanges();

	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " found " . count($changes) . " entries to be updated on server");

	foreach ($changes as $change) {
	$serverId = (string)$change->ServerId;

	try {
	$dataController->updateEntry($collectionData->collectionId, $serverId, new $dataClass($change->ApplicationData));
	$clientModifications['changed'][$serverId] = self::STATUS_SUCCESS;

	} catch (Syncroton_Exception_AccessDenied $e) {
	$clientModifications['changed'][$serverId] = self::STATUS_CONFLICT_MATCHING_THE_CLIENT_AND_SERVER_OBJECT;
	$clientModifications['forceChange'][$serverId] = $serverId;

	} catch (Syncroton_Exception_NotFound $e) {
	// entry does not exist anymore, will get deleted automaticaly
	$clientModifications['changed'][$serverId] = self::STATUS_OBJECT_NOT_FOUND;

	} catch (Exception $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " failed to update entry " . $e);
	// something went wrong while trying to update the entry
	$clientModifications['changed'][$serverId] = self::STATUS_SERVER_ERROR;
	}
	}
	}

	// handle deletes, but only if not first sync
	if($collectionData->hasClientDeletes()) {
	$deletes = $collectionData->getClientDeletes();
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " found " . count($deletes) . " entries to be deleted on server");

	foreach ($deletes as $delete) {
	$serverId = (string)$delete->ServerId;

	try {
	// check if we have sent this entry to the phone
	$state = $this->_contentStateBackend->getContentState($this->_device, $collectionData->folder, $serverId);

	try {
	$dataController->deleteEntry($collectionData->collectionId, $serverId, $collectionData);

	} catch(Syncroton_Exception_NotFound $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->crit(__METHOD__ . '::' . __LINE__ . ' tried to delete entry ' . $serverId . ' but entry was not found');

	} catch (Syncroton_Exception $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . ' tried to delete entry ' . $serverId . ' but a error occured: ' . $e->getMessage());
	$clientModifications['forceAdd'][$serverId] = $serverId;
	}
	$this->_contentStateBackend->delete($state);

	} catch (Syncroton_Exception_NotFound $senf) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . ' ' . $serverId . ' should have been removed from client already');
	// should we send a special status???
	//$collectionData->deleted[$serverId] = self::STATUS_SUCCESS;
	}

	$clientModifications['deleted'][$serverId] = self::STATUS_SUCCESS;
	}
	}

	// handle fetches, but only if not first sync
	if($collectionData->syncKey > 1 && $collectionData->hasClientFetches()) {
	// the default value for GetChanges is 1. If the phone don't want the changes it must set GetChanges to 0
	// some prevoius versions of iOS did not set GetChanges to 0 for fetches. Let's enforce getChanges to false here.
	$collectionData->getChanges = false;

	$fetches = $collectionData->getClientFetches();
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " found " . count($fetches) . " entries to be fetched from server");

	$toBeFetched = array();

	foreach ($fetches as $fetch) {
	$serverId = (string)$fetch->ServerId;

	$toBeFetched[$serverId] = $serverId;
	}

	$collectionData->toBeFetched = $toBeFetched;
	}

	$this->_collections[$collectionData->collectionId] = $collectionData;
	$this->_modifications[$collectionData->collectionId] = $clientModifications;
	}
	}

	/**
	* (non-PHPdoc)
	* @see Syncroton_Command_Wbxml::getResponse()
	*/
	public function getResponse()
	{
	$sync = $this->_outputDom->documentElement;

	$collections = $this->_outputDom->createElementNS('uri:AirSync', 'Collections');

	$totalChanges = 0;

	// Detect devices that do not support empty Sync reponse
	$emptySyncSupported = !preg_match('/(meego\|nokian800)/i', $this->_device->useragent);

	// continue only if there are changes or no time is left
	if ($this->_heartbeatInterval > 0) {
	$intervalStart = time();
	$sleepCallback = Syncroton_Registry::getSleepCallback();
	$wakeupCallback = Syncroton_Registry::getWakeupCallback();

	do {
	// take a break to save battery lifetime
	$sleepCallback();
	sleep(Syncroton_Registry::getPingTimeout());

	// make sure the connection is still alive, abort otherwise
	if (connection_aborted()) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " Exiting on aborted connection");
	exit;
	}

	$wakeupCallback();

	- $now = new DateTime(null, new DateTimeZone('utc'));
	+ $now = new DateTime('now', new DateTimeZone('UTC'));

	foreach($this->_collections as $collectionData) {
	// continue immediately if folder does not exist
	if (! ($collectionData->folder instanceof Syncroton_Model_IFolder)) {
	break 2;

	// countinue immediately if syncstate is invalid
	} elseif (! ($collectionData->syncState instanceof Syncroton_Model_ISyncState)) {
	break 2;

	} else {
	if ($collectionData->getChanges !== true) {
	continue;
	}

	try {
	// just check if the folder still exists
	$this->_folderBackend->get($collectionData->folder);
	} catch (Syncroton_Exception_NotFound $senf) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " collection does not exist anymore: " . $collectionData->collectionId);

	$collectionData->getChanges = false;

	// make sure this is the last while loop
	// no break 2 here, as we like to check the other folders too
	$intervalStart -= $this->_heartbeatInterval;
	}

	// check that the syncstate still exists and is still valid
	try {
	$syncState = $this->_syncStateBackend->getSyncState($this->_device, $collectionData->folder);

	// another process synchronized data of this folder already. let's skip it
	if ($syncState->id !== $collectionData->syncState->id) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " syncstate changed during heartbeat interval for collection: " . $collectionData->folder->serverId);

	$collectionData->getChanges = false;

	// make sure this is the last while loop
	// no break 2 here, as we like to check the other folders too
	$intervalStart -= $this->_heartbeatInterval;
	}
	} catch (Syncroton_Exception_NotFound $senf) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " no syncstate found anymore for collection: " . $collectionData->folder->serverId);

	$collectionData->syncState = null;

	// make sure this is the last while loop
	// no break 2 here, as we like to check the other folders too
	$intervalStart -= $this->_heartbeatInterval;
	}


	// safe battery time by skipping folders which got synchronied less than Syncroton_Command_Ping::$quietTime seconds ago
	if ( ! $collectionData->syncState instanceof Syncroton_Model_SyncState \|\|
	($now->getTimestamp() - $collectionData->syncState->lastsync->getTimestamp()) < Syncroton_Registry::getQuietTime()) {
	continue;
	}

	$dataController = Syncroton_Data_Factory::factory($collectionData->folder->class , $this->_device, $this->_syncTimeStamp);

	// countinue immediately if there are any changes available
	if($dataController->hasChanges($this->_contentStateBackend, $collectionData->folder, $collectionData->syncState)) {
	break 2;
	}
	}
	}

	// See: http://www.tine20.org/forum/viewtopic.php?f=12&t=12146
	//
	// break if there are less than PingTimeout + 10 seconds left for the next loop
	// otherwise the response will be returned after the client has finished his Ping
	// request already maybe
	} while (Syncroton_Server::validateSession() && time() - $intervalStart < $this->_heartbeatInterval - (Syncroton_Registry::getPingTimeout() + 10));
	}

	// First check for folders hierarchy changes
	foreach ($this->_collections as $collectionData) {
	if (! ($collectionData->folder instanceof Syncroton_Model_IFolder)) {

	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " Detected a folder hierarchy change on {$collectionData->collectionId}.");

	$sync->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', self::STATUS_FOLDER_HIERARCHY_HAS_CHANGED));
	return $this->_outputDom;
	}
	}

	foreach($this->_collections as $collectionData) {
	$collectionChanges = 0;

	/**
	* keep track of entries added on server side
	*/
	$newContentStates = array();

	/**
	* keep track of entries deleted on server side
	*/
	$deletedContentStates = array();

	// invalid synckey provided
	if (! ($collectionData->syncState instanceof Syncroton_Model_ISyncState)) {
	// set synckey to 0
	$collection = $collections->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Collection'));
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'SyncKey', 0));
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'CollectionId', $collectionData->collectionId));
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', self::STATUS_INVALID_SYNC_KEY));

	// initial sync
	} elseif ($collectionData->syncState->counter === 0) {
	$collectionData->syncState->counter++;

	// initial sync
	// send back a new SyncKey only
	$collection = $collections->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Collection'));
	if (!empty($collectionData->folder->class)) {
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Class', $collectionData->folder->class));
	}
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'SyncKey', $collectionData->syncState->counter));
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'CollectionId', $collectionData->collectionId));
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', self::STATUS_SUCCESS));

	} else {

	$dataController = Syncroton_Data_Factory::factory($collectionData->folder->class , $this->_device, $this->_syncTimeStamp);

	$clientModifications = $this->_modifications[$collectionData->collectionId];
	$serverModifications = array(
	'added' => array(),
	'changed' => array(),
	'deleted' => array(),
	);

	$status = self::STATUS_SUCCESS;
	$hasChanges = 0;

	if($collectionData->getChanges === true) {
	// continue sync session?
	if(is_array($collectionData->syncState->pendingdata)) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " restored from sync state ");

	$serverModifications = $collectionData->syncState->pendingdata;
	} else {
	try {
	$hasChanges = $dataController->hasChanges($this->_contentStateBackend, $collectionData->folder, $collectionData->syncState);
	} catch (Syncroton_Exception_NotFound $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " Folder changes checking failed (not found): " . $e->getTraceAsString());

	$status = self::STATUS_FOLDER_HIERARCHY_HAS_CHANGED;
	} catch (Exception $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->crit(__METHOD__ . '::' . __LINE__ . " Folder changes checking failed: " . $e->getMessage());

	// Prevent from removing client entries when getServerEntries() fails
	// @todo: should we break the loop here?
	$status = self::STATUS_SERVER_ERROR;
	}
	}

	if ($hasChanges) {
	// update _syncTimeStamp as $dataController->hasChanges might have spent some time
	- $this->_syncTimeStamp = new DateTime(null, new DateTimeZone('utc'));
	+ $this->_syncTimeStamp = new DateTime('now', new DateTimeZone('UTC'));

	try {
	// fetch entries added since last sync
	$allClientEntries = $this->_contentStateBackend->getFolderState(
	$this->_device,
	$collectionData->folder
	);

	// fetch entries changed since last sync
	$allChangedEntries = $dataController->getChangedEntries(
	$collectionData->collectionId,
	$collectionData->syncState->lastsync,
	$this->_syncTimeStamp,
	$collectionData->options['filterType']
	);

	// fetch all entries
	$allServerEntries = $dataController->getServerEntries(
	$collectionData->collectionId,
	$collectionData->options['filterType']
	);

	// add entries
	$serverDiff = array_diff($allServerEntries, $allClientEntries);
	// add entries which produced problems during delete from client
	$serverModifications['added'] = $clientModifications['forceAdd'];
	// add entries not yet sent to client
	$serverModifications['added'] = array_unique(array_merge($serverModifications['added'], $serverDiff));

	// @todo still needed?
	foreach($serverModifications['added'] as $id => $serverId) {
	// skip entries added by client during this sync session
	if(isset($clientModifications['added'][$serverId]) && !isset($clientModifications['forceAdd'][$serverId])) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " skipped added entry: " . $serverId);
	unset($serverModifications['added'][$id]);
	}
	}

	// entries to be deleted
	$serverModifications['deleted'] = array_diff($allClientEntries, $allServerEntries);

	// entries changed since last sync
	$serverModifications['changed'] = array_merge($allChangedEntries, $clientModifications['forceChange']);

	foreach($serverModifications['changed'] as $id => $serverId) {
	// skip entry, if it got changed by client during current sync
	if(isset($clientModifications['changed'][$serverId]) && !isset($clientModifications['forceChange'][$serverId])) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " skipped changed entry: " . $serverId);
	unset($serverModifications['changed'][$id]);
	}
	// skip entry, make sure we don't sent entries already added by client in this request
	else if (isset($clientModifications['added'][$serverId]) && !isset($clientModifications['forceAdd'][$serverId])) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " skipped change for added entry: " . $serverId);
	unset($serverModifications['changed'][$id]);
	}
	}

	// entries comeing in scope are already in $serverModifications['added'] and do not need to
	// be send with $serverCanges
	$serverModifications['changed'] = array_diff($serverModifications['changed'], $serverModifications['added']);
	} catch (Exception $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->crit(__METHOD__ . '::' . __LINE__ . " Folder state checking failed: " . $e->getMessage());
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " Folder state checking failed: " . $e->getTraceAsString());

	// Prevent from removing client entries when getServerEntries() fails
	// @todo: should we break the loop here?
	$status = self::STATUS_SERVER_ERROR;
	}

	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " found (added/changed/deleted) " . count($serverModifications['added']) . '/' . count($serverModifications['changed']) . '/' . count($serverModifications['deleted']) . ' entries for sync from server to client');
	}
	}

	// collection header
	$collection = $this->_outputDom->createElementNS('uri:AirSync', 'Collection');
	if (!empty($collectionData->folder->class)) {
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Class', $collectionData->folder->class));
	}

	$syncKeyElement = $collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'SyncKey'));

	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'CollectionId', $collectionData->collectionId));
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', $status));

	$responses = $this->_outputDom->createElementNS('uri:AirSync', 'Responses');

	// send reponse for newly added entries
	if(!empty($clientModifications['added'])) {
	foreach($clientModifications['added'] as $entryData) {
	$add = $responses->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Add'));
	$add->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ClientId', $entryData['clientId']));
	// we have no serverId is the add failed
	if(isset($entryData['serverId'])) {
	$add->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ServerId', $entryData['serverId']));
	}
	$add->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', $entryData['status']));
	}
	}

	// send reponse for changed entries
	if(!empty($clientModifications['changed'])) {
	foreach($clientModifications['changed'] as $serverId => $status) {
	if ($status !== Syncroton_Command_Sync::STATUS_SUCCESS) {
	$change = $responses->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Change'));
	$change->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ServerId', $serverId));
	$change->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', $status));
	}
	}
	}

	// send response for to be fetched entries
	if(!empty($collectionData->toBeFetched)) {
	// unset all truncation settings as entries are not allowed to be truncated during fetch
	$fetchCollectionData = clone $collectionData;

	// unset truncationSize
	if (isset($fetchCollectionData->options['bodyPreferences']) && is_array($fetchCollectionData->options['bodyPreferences'])) {
	foreach($fetchCollectionData->options['bodyPreferences'] as $key => $bodyPreference) {
	unset($fetchCollectionData->options['bodyPreferences'][$key]['truncationSize']);
	}
	}
	$fetchCollectionData->options['mimeTruncation'] = Syncroton_Command_Sync::TRUNCATE_NOTHING;

	foreach($collectionData->toBeFetched as $serverId) {
	$fetch = $responses->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Fetch'));
	$fetch->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ServerId', $serverId));

	try {
	$applicationData = $this->_outputDom->createElementNS('uri:AirSync', 'ApplicationData');

	$dataController
	->getEntry($fetchCollectionData, $serverId)
	->appendXML($applicationData, $this->_device);

	$fetch->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', self::STATUS_SUCCESS));

	$fetch->appendChild($applicationData);
	} catch (Exception $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " unable to convert entry to xml: " . $e->getMessage());
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " unable to convert entry to xml: " . $e->getTraceAsString());
	$fetch->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'Status', self::STATUS_OBJECT_NOT_FOUND));
	}
	}
	}

	if ($responses->hasChildNodes() === true) {
	$collection->appendChild($responses);
	}

	$commands = $this->_outputDom->createElementNS('uri:AirSync', 'Commands');

	foreach($serverModifications['added'] as $id => $serverId) {
	if($collectionChanges == $collectionData->windowSize \|\| $totalChanges + $collectionChanges >= $this->_globalWindowSize) {
	break;
	}

	#/**
	# * somewhere is a problem in the logic for handling moreAvailable
	# *
	# * it can happen, that we have a contentstate (which means we sent the entry to the client
	# * and that this entry is yet in $collectionData->syncState->pendingdata['serverAdds']
	# * I have no idea how this can happen, but the next lines of code work around this problem
	# */
	#try {
	# $this->_contentStateBackend->getContentState($this->_device, $collectionData->folder, $serverId);
	#
	# if ($this->_logger instanceof Zend_Log)
	# $this->_logger->info(__METHOD__ . '::' . __LINE__ . " skipped an entry($serverId) which is already on the client");
	#
	# unset($serverModifications['added'][$id]);
	# continue;
	#
	#} catch (Syncroton_Exception_NotFound $senf) {
	# // do nothing => content state should not exist yet
	#}

	try {
	$add = $this->_outputDom->createElementNS('uri:AirSync', 'Add');
	$add->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ServerId', $serverId));

	$applicationData = $add->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ApplicationData'));

	$dataController
	->getEntry($collectionData, $serverId)
	->appendXML($applicationData, $this->_device);

	$commands->appendChild($add);

	$newContentStates[] = new Syncroton_Model_Content(array(
	'device_id' => $this->_device,
	'folder_id' => $collectionData->folder,
	'contentid' => $serverId,
	'creation_time' => $this->_syncTimeStamp,
	'creation_synckey' => $collectionData->syncState->counter + 1
	));

	$collectionChanges++;
	} catch (Syncroton_Exception_MemoryExhausted $seme) {
	// continue to next entry, as there is not enough memory left for the current entry
	// this will lead to MoreAvailable at the end and the entry will be synced during the next Sync command
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " memory exhausted for entry: " . $serverId);

	break;

	} catch (Exception $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " unable to convert entry to xml: " . $e->getMessage());
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " unable to convert entry to xml: " . $e->getTraceAsString());
	// We bump collectionChanges anyways to make sure the windowSize still applies.
	$collectionChanges++;
	}

	// mark as sent to the client, even the conversion to xml might have failed
	unset($serverModifications['added'][$id]);
	}

	/**
	* process entries changed on server side
	*/
	foreach($serverModifications['changed'] as $id => $serverId) {
	if($collectionChanges == $collectionData->windowSize \|\| $totalChanges + $collectionChanges >= $this->_globalWindowSize) {
	break;
	}

	try {
	$change = $this->_outputDom->createElementNS('uri:AirSync', 'Change');
	$change->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ServerId', $serverId));

	$applicationData = $change->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ApplicationData'));

	$dataController
	->getEntry($collectionData, $serverId)
	->appendXML($applicationData, $this->_device);


	$commands->appendChild($change);

	$collectionChanges++;
	} catch (Syncroton_Exception_MemoryExhausted $seme) {
	// continue to next entry, as there is not enough memory left for the current entry
	// this will lead to MoreAvailable at the end and the entry will be synced during the next Sync command
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " memory exhausted for entry: " . $serverId);

	break;

	} catch (Exception $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " unable to convert entry to xml: " . $e->getMessage());
	// We bump collectionChanges anyways to make sure the windowSize still applies.
	$collectionChanges++;
	}

	unset($serverModifications['changed'][$id]);
	}

	foreach($serverModifications['deleted'] as $id => $serverId) {
	if($collectionChanges == $collectionData->windowSize \|\| $totalChanges + $collectionChanges >= $this->_globalWindowSize) {
	break;
	}

	try {
	// check if we have sent this entry to the phone
	$state = $this->_contentStateBackend->getContentState($this->_device, $collectionData->folder, $serverId);

	$delete = $this->_outputDom->createElementNS('uri:AirSync', 'Delete');
	$delete->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'ServerId', $serverId));

	$deletedContentStates[] = $state;

	$commands->appendChild($delete);

	$collectionChanges++;
	} catch (Exception $e) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . " unable to convert entry to xml: " . $e->getMessage());
	// We bump collectionChanges anyways to make sure the windowSize still applies.
	$collectionChanges++;
	}

	unset($serverModifications['deleted'][$id]);
	}

	$countOfPendingChanges = (count($serverModifications['added']) + count($serverModifications['changed']) + count($serverModifications['deleted']));
	if ($countOfPendingChanges > 0) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " there are ". $countOfPendingChanges . " more items available");
	$collection->appendChild($this->_outputDom->createElementNS('uri:AirSync', 'MoreAvailable'));
	} else {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " there are no more items available");
	$serverModifications = null;
	}

	if ($commands->hasChildNodes() === true) {
	$collection->appendChild($commands);
	}

	$totalChanges += $collectionChanges;

	// increase SyncKey if needed
	if ((
	// sent the clients updates... ?
	!empty($clientModifications['added']) \|\|
	!empty($clientModifications['changed']) \|\|
	!empty($clientModifications['deleted'])
	) \|\| (
	// is the server sending updates to the client... ?
	$commands->hasChildNodes() === true
	) \|\| (
	// changed the pending data... ?
	$collectionData->syncState->pendingdata != $serverModifications
	)
	) {
	// ...then increase SyncKey
	$collectionData->syncState->counter++;
	}
	$syncKeyElement->appendChild($this->_outputDom->createTextNode($collectionData->syncState->counter));

	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " current synckey is ". $collectionData->syncState->counter);

	if (!$emptySyncSupported \|\| $collection->childNodes->length > 4 \|\| $collectionData->syncState->counter != $collectionData->syncKey) {
	$collections->appendChild($collection);
	}
	}

	if (isset($collectionData->syncState) &&
	$collectionData->syncState instanceof Syncroton_Model_ISyncState &&
	$collectionData->syncState->counter != $collectionData->syncKey
	) {

	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " update syncState for collection: " . $collectionData->collectionId);

	// store pending data in sync state when needed
	if(isset($countOfPendingChanges) && $countOfPendingChanges > 0) {
	$collectionData->syncState->pendingdata = array(
	'added' => (array)$serverModifications['added'],
	'changed' => (array)$serverModifications['changed'],
	'deleted' => (array)$serverModifications['deleted']
	);
	} else {
	$collectionData->syncState->pendingdata = null;
	}


	if (!empty($clientModifications['added'])) {
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->info(__METHOD__ . '::' . __LINE__ . " remove previous synckey as client added new entries");
	$keepPreviousSyncKey = false;
	} else {
	$keepPreviousSyncKey = true;
	}

	$collectionData->syncState->lastsync = clone $this->_syncTimeStamp;
	// increment sync timestamp by 1 second
	$collectionData->syncState->lastsync->modify('+1 sec');

	try {
	$transactionId = Syncroton_Registry::getTransactionManager()->startTransaction(Syncroton_Registry::getDatabase());

	// store new synckey
	$this->_syncStateBackend->create($collectionData->syncState, $keepPreviousSyncKey);

	// store contentstates for new entries added to client
	foreach($newContentStates as $state) {
	$this->_contentStateBackend->create($state);
	}

	// remove contentstates for entries to be deleted on client
	foreach($deletedContentStates as $state) {
	$this->_contentStateBackend->delete($state);
	}

	Syncroton_Registry::getTransactionManager()->commitTransaction($transactionId);
	} catch (Zend_Db_Statement_Exception $zdse) {
	// something went wrong
	// maybe another parallel request added a new synckey
	// we must remove data added from client
	if (!empty($clientModifications['added'])) {
	foreach ($clientModifications['added'] as $added) {
	$this->_contentStateBackend->delete($added['contentState']);
	$dataController->deleteEntry($collectionData->collectionId, $added['serverId'], array());
	}
	}

	Syncroton_Registry::getTransactionManager()->rollBack();

	throw $zdse;
	}
	}

	// store current filter type
	try {
	$folderState = $this->_folderBackend->get($collectionData->folder);
	$folderState->lastfiltertype = $collectionData->options['filterType'];
	if ($folderState->isDirty()) {
	$this->_folderBackend->update($folderState);
	}
	} catch (Syncroton_Exception_NotFound $senf) {
	// failed to get folderstate => should not happen but is also no problem in this state
	if ($this->_logger instanceof Zend_Log)
	$this->_logger->warn(__METHOD__ . '::' . __LINE__ . ' failed to get folder state for: ' . $collectionData->collectionId);
	}
	}

	if ($collections->hasChildNodes() === true) {
	$sync->appendChild($collections);
	}

	if ($sync->hasChildNodes()) {
	return $this->_outputDom;
	}

	return null;
	}

	/**
	* remove Commands and Supported from collections XML tree
	*
	* @param DOMDocument $document
	* @return DOMDocument
	*/
	protected function _cleanUpXML(DOMDocument $document)
	{
	$cleanedDocument = clone $document;

	$xpath = new DomXPath($cleanedDocument);
	$xpath->registerNamespace('AirSync', 'uri:AirSync');

	$collections = $xpath->query("//AirSync:Sync/AirSync:Collections/AirSync:Collection");

	// remove Commands and Supported elements
	foreach ($collections as $collection) {
	foreach (array('Commands', 'Supported') as $element) {
	$childrenToRemove = $collection->getElementsByTagName($element);

	foreach ($childrenToRemove as $childToRemove) {
	$collection->removeChild($childToRemove);
	}
	}
	}

	return $cleanedDocument;
	}

	/**
	* merge a partial XML document with the XML document from the previous request
	*
	* @param DOMDocument\|null $requestBody
	* @return SimpleXMLElement
	*/
	protected function _mergeSyncRequest($requestBody, Syncroton_Model_Device $device)
	{
	$lastSyncCollection = array();

	if (!empty($device->lastsynccollection)) {
	$lastSyncCollection = Zend_Json::decode($device->lastsynccollection);
	if (!empty($lastSyncCollection['lastXML'])) {
	$lastXML = new DOMDocument();
	$lastXML->loadXML($lastSyncCollection['lastXML']);
	}
	}

	if (! $requestBody instanceof DOMDocument && isset($lastXML) && $lastXML instanceof DOMDocument) {
	$requestBody = $lastXML;
	} elseif (! $requestBody instanceof DOMDocument) {
	throw new Syncroton_Exception_UnexpectedValue('no xml body found');
	}

	if ($requestBody->getElementsByTagName('Partial')->length > 0) {
	$partialBody = clone $requestBody;
	$requestBody = $lastXML;

	$xpath = new DomXPath($requestBody);
	$xpath->registerNamespace('AirSync', 'uri:AirSync');

	foreach ($partialBody->documentElement->childNodes as $child) {
	if (! $child instanceof DOMElement) {
	continue;
	}

	if ($child->tagName == 'Partial') {
	continue;
	}

	if ($child->tagName == 'Collections') {
	foreach ($child->getElementsByTagName('Collection') as $updatedCollection) {
	$collectionId = $updatedCollection->getElementsByTagName('CollectionId')->item(0)->nodeValue;

	$existingCollections = $xpath->query("//AirSync:Sync/AirSync:Collections/AirSync:Collection[AirSync:CollectionId='$collectionId']");

	if ($existingCollections->length > 0) {
	$existingCollection = $existingCollections->item(0);
	foreach ($updatedCollection->childNodes as $updatedCollectionChild) {
	if (! $updatedCollectionChild instanceof DOMElement) {
	continue;
	}

	$duplicateChild = $existingCollection->getElementsByTagName($updatedCollectionChild->tagName);

	if ($duplicateChild->length > 0) {
	$existingCollection->replaceChild($requestBody->importNode($updatedCollectionChild, TRUE), $duplicateChild->item(0));
	} else {
	$existingCollection->appendChild($requestBody->importNode($updatedCollectionChild, TRUE));
	}
	}
	} else {
	$importedCollection = $requestBody->importNode($updatedCollection, TRUE);
	}
	}

	} else {
	$duplicateChild = $xpath->query("//AirSync:Sync/AirSync:{$child->tagName}");

	if ($duplicateChild->length > 0) {
	$requestBody->documentElement->replaceChild($requestBody->importNode($child, TRUE), $duplicateChild->item(0));
	} else {
	$requestBody->documentElement->appendChild($requestBody->importNode($child, TRUE));
	}
	}
	}
	}

	$lastSyncCollection['lastXML'] = $this->_cleanUpXML($requestBody)->saveXML();

	$device->lastsynccollection = Zend_Json::encode($lastSyncCollection);

	return $requestBody;
	}
	}
	diff --git a/lib/ext/Syncroton/Command/Wbxml.php b/lib/ext/Syncroton/Command/Wbxml.php
	index cb36d13..89e2bb2 100644
	--- a/lib/ext/Syncroton/Command/Wbxml.php
	+++ b/lib/ext/Syncroton/Command/Wbxml.php
	@@ -1,222 +1,222 @@
	<?php
	/**
	* Syncroton
	*
	* @package Syncroton
	* @subpackage Command
	* @license http://www.tine20.org/licenses/lgpl.html LGPL Version 3
	* @copyright Copyright (c) 2008-2012 Metaways Infosystems GmbH (http://www.metaways.de)
	* @author Lars Kneschke <l.kneschke@metaways.de>
	*/

	/**
	* abstract class for all commands using wbxml encoded content
	*
	* @package Syncroton
	* @subpackage Command
	*/

	abstract class Syncroton_Command_Wbxml implements Syncroton_Command_ICommand
	{
	/**
	* informations about the currently device
	*
	* @var Syncroton_Model_Device
	*/
	protected $_device;

	/**
	* informations about the currently device
	*
	* @var Syncroton_Backend_IDevice
	*/
	protected $_deviceBackend;

	/**
	* informations about the currently device
	*
	* @var Syncroton_Backend_IFolder
	*/
	protected $_folderBackend;

	/**
	* @var Syncroton_Backend_ISyncState
	*/
	protected $_syncStateBackend;

	/**
	* @var Syncroton_Backend_IContent
	*/
	protected $_contentStateBackend;

	/**
	*
	* @var Syncroton_Backend_IPolicy
	*/
	protected $_policyBackend;

	/**
	* the domDocument containing the xml response from the server
	*
	* @var DOMDocument
	*/
	protected $_outputDom;

	/**
	* the domDocucment containing the xml request from the client
	*
	* @var DOMDocument
	*/
	protected $_requestBody;

	/**
	* the default namespace
	*
	* @var string
	*/
	protected $_defaultNameSpace;

	/**
	* the main xml tag
	*
	* @var string
	*/
	protected $_documentElement;

	/**
	* @var array
	*/
	protected $_requestParameters;

	/**
	* @var Syncroton_Model_SyncState
	*/
	protected $_syncState;

	protected $_skipValidatePolicyKey = false;

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

	/**
	* @var string
	*/
	protected $_transactionId;

	/**
	* @var string
	*/
	protected $_policyKey;

	/**
	* @var Zend_Log
	*/
	protected $_logger;

	/**
	* list of part streams
	*
	* @var array
	*/
	protected $_parts = array();

	/**
	* list of headers
	*
	* @var array
	*/
	protected $_headers = array();

	/**
	* the constructor
	*
	* @param mixed $requestBody
	* @param Syncroton_Model_Device $device
	* @param array $requestParameters
	*/
	public function __construct($requestBody, Syncroton_Model_IDevice $device, $requestParameters)
	{
	$this->_requestBody = $requestBody;
	$this->_device = $device;
	$this->_requestParameters = $requestParameters;
	$this->_policyKey = isset($requestParameters['policyKey']) ? $requestParameters['policyKey'] : null;

	$this->_deviceBackend = Syncroton_Registry::getDeviceBackend();
	$this->_folderBackend = Syncroton_Registry::getFolderBackend();
	$this->_syncStateBackend = Syncroton_Registry::getSyncStateBackend();
	$this->_contentStateBackend = Syncroton_Registry::getContentStateBackend();
	$this->_policyBackend = Syncroton_Registry::getPolicyBackend();
	if (Syncroton_Registry::isRegistered('loggerBackend')) {
	$this->_logger = Syncroton_Registry::get('loggerBackend');
	}

	- $this->_syncTimeStamp = new DateTime(null, new DateTimeZone('UTC'));
	+ $this->_syncTimeStamp = new DateTime('now', new DateTimeZone('UTC'));

	// set default content type
	$this->_headers['Content-Type'] = 'application/vnd.ms-sync.wbxml';

	if ($this->_logger instanceof Zend_Log)
	$this->_logger->debug(__METHOD__ . '::' . __LINE__ . " sync timestamp: " . $this->_syncTimeStamp->format('Y-m-d H:i:s'));

	if (isset($this->_defaultNameSpace) && isset($this->_documentElement)) {
	// Creates an instance of the DOMImplementation class
	$imp = new DOMImplementation();

	// Creates a DOMDocumentType instance
	$dtd = $imp->createDocumentType('AirSync', "-//AIRSYNC//DTD AirSync//EN", "http://www.microsoft.com/");

	// Creates a DOMDocument instance
	$this->_outputDom = $imp->createDocument($this->_defaultNameSpace, $this->_documentElement, $dtd);
	$this->_outputDom->documentElement->setAttributeNS('http://www.w3.org/2000/xmlns/', 'xmlns:Syncroton', 'uri:Syncroton');
	$this->_outputDom->formatOutput = false;
	$this->_outputDom->encoding = 'utf-8';
	}

	if ($this->_skipValidatePolicyKey != true) {
	if (!empty($this->_device->policyId)) {
	$policy = $this->_policyBackend->get($this->_device->policyId);

	if((int)$policy->policyKey != (int)$this->_policyKey) {
	$this->_outputDom->documentElement->appendChild($this->_outputDom->createElementNS($this->_defaultNameSpace, 'Status', 142));

	$sepn = new Syncroton_Exception_ProvisioningNeeded();
	$sepn->domDocument = $this->_outputDom;

	throw $sepn;
	}

	// should we wipe the mobile phone?
	if ($this->_device->remotewipe >= Syncroton_Command_Provision::REMOTEWIPE_REQUESTED) {
	$this->_outputDom->documentElement->appendChild($this->_outputDom->createElementNS($this->_defaultNameSpace, 'Status', 140));

	$sepn = new Syncroton_Exception_ProvisioningNeeded();
	$sepn->domDocument = $this->_outputDom;

	throw $sepn;
	}
	}
	}
	}

	/**
	* (non-PHPdoc)
	* @see Syncroton_Command_ICommand::getHeaders()
	*/
	public function getHeaders()
	{
	return $this->_headers;
	}
	/**
	* return array of part streams
	*
	* @return array
	*/
	public function getParts()
	{
	return $this->_parts;
	}
	}
	diff --git a/lib/ext/Syncroton/Model/AEntry.php b/lib/ext/Syncroton/Model/AEntry.php
	index d2ad8be..13e7610 100644
	--- a/lib/ext/Syncroton/Model/AEntry.php
	+++ b/lib/ext/Syncroton/Model/AEntry.php
	@@ -1,105 +1,107 @@
	<?php
	/**
	* Syncroton
	*
	* @package Syncroton
	* @subpackage Model
	* @license http://www.tine20.org/licenses/lgpl.html LGPL Version 3
	* @copyright Copyright (c) 2012-2012 Metaways Infosystems GmbH (http://www.metaways.de)
	* @author Lars Kneschke <l.kneschke@metaways.de>
	*/

	/**
	* abstract class to handle ActiveSync entry
	*
	* @package Syncroton
	* @subpackage Model
	*/

	abstract class Syncroton_Model_AEntry implements Syncroton_Model_IEntry, IteratorAggregate, Countable
	{
	protected $_elements = array();

	protected $_isDirty;

	/**
	* (non-PHPdoc)
	* @see Syncroton_Model_IEntry::__construct()
	*/
	public function __construct($properties = null)
	{
	if (is_array($properties)) {
	$this->setFromArray($properties);
	}

	$this->_isDirty = false;
	}


	/**
	* (non-PHPdoc)
	* @see Countable::count()
	*/
	+ #[\ReturnTypeWillChange]
	public function count()
	{
	return count($this->_elements);
	}

	/**
	* (non-PHPdoc)
	* @see IteratorAggregate::getIterator()
	*/
	+ #[\ReturnTypeWillChange]
	public function getIterator()
	{
	return new ArrayIterator($this->_elements);
	}

	/**
	* (non-PHPdoc)
	* @see Syncroton_Model_IEntry::isDirty()
	*/
	public function isDirty()
	{
	return $this->_isDirty;
	}

	/**
	* (non-PHPdoc)
	* @see Syncroton_Model_IEntry::setFromArray()
	*/
	public function setFromArray(array $properties)
	{
	foreach($properties as $key => $value) {
	try {
	$this->$key = $value; //echo __LINE__ . PHP_EOL;
	} catch (InvalidArgumentException $iae) {
	//ignore invalid properties
	//echo __LINE__ . PHP_EOL; echo $iae->getMessage(); echo $iae->getTraceAsString();
	}
	}
	}

	public function &__get($name)
	{
	return $this->_elements[$name];
	}

	public function __set($name, $value)
	{
	if (!array_key_exists($name, $this->_elements) \|\| $this->_elements[$name] != $value) {
	$this->_elements[$name] = $value;

	$this->_isDirty = true;
	}
	}

	public function __isset($name)
	{
	return isset($this->_elements[$name]);
	}

	public function __unset($name)
	{
	unset($this->_elements[$name]);
	}
	}
	\ No newline at end of file
	diff --git a/lib/kolab_sync_timezone_converter.php b/lib/kolab_sync_timezone_converter.php
	index 251ab08..4ad19f1 100644
	--- a/lib/kolab_sync_timezone_converter.php
	+++ b/lib/kolab_sync_timezone_converter.php
	@@ -1,674 +1,674 @@
	<?php

	/**
	+--------------------------------------------------------------------------+
	\| Kolab Sync (ActiveSync for Kolab) \|
	\| \|
	\| Copyright (C) 2011-2017, Kolab Systems AG <contact@kolabsys.com> \|
	\| Copyright (C) 2008-2012, Metaways Infosystems GmbH \|
	\| \|
	\| 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> \|
	\| Author: Jonas Fischer <j.fischer@metaways.de> \|
	+--------------------------------------------------------------------------+
	*/

	/**
	* Activesync timezone converter
	*/
	class kolab_sync_timezone_converter
	{
	/**
	* holds the instance of the singleton
	*
	* @var kolab_sync_timezone_onverter
	*/
	private static $_instance = NULL;

	protected $_startDate = array();

	/**
	* If set then the timezone guessing results will be cached.
	* This is strongly recommended for performance reasons.
	*
	* @var rcube_cache
	*/
	protected $cache = null;

	/**
	* array of offsets known by ActiceSync clients, but unknown by php
	* @var array
	*/
	protected $_knownTimezones = array(
	'0AIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==' => array(
	'Pacific/Kwajalein' => 'MHT'
	)
	);

	/**
	* don't use the constructor. Use the singleton.
	*
	* @param $_logger
	*/
	private function __construct()
	{
	}

	/**
	* don't clone. Use the singleton.
	*/
	private function __clone()
	{
	}

	/**
	* the singleton pattern
	*
	* @return kolab_sync_timezone_converter
	*/
	public static function getInstance()
	{
	if (self::$_instance === NULL) {
	self::$_instance = new kolab_sync_timezone_converter();
	}

	return self::$_instance;
	}


	/**
	* Returns a timezone with an offset matching the time difference
	* of $dt from $referenceDt.
	*
	* If set and matching the offset, kolab_format::$timezone is preferred.
	*
	* @param DateTime $dt The date time value for which we
	* calculate the offset.
	* @param DateTime $referenceDt The reference value, for instance in UTC.
	*
	* @return DateTimeZone\|null
	*/
	public function getOffsetTimezone($dt, $referenceDt)
	{
	$interval = $referenceDt->diff($dt);
	$tz = new DateTimeZone($interval->format('%R%H%I')); //e.g. +0200
	$utcOffset = $tz->getOffset($dt);

	//Prefer the configured timezone if it matches the offset.
	if (kolab_format::$timezone) {
	if (kolab_format::$timezone->getOffset($dt) == $utcOffset) {
	return kolab_format::$timezone;
	}
	}

	//Look for any timezone with a matching offset.
	foreach (DateTimeZone::listIdentifiers() as $timezoneIdentifier) {
	$timezone = new DateTimeZone($timezoneIdentifier);
	if ($timezone->getOffset($dt) == $utcOffset) {
	return $timezone;
	}
	}
	return null;
	}


	/**
	* Returns a list of timezones that match to the {@param $_offsets}
	*
	* If {@see $_expectedTimezone} is set then the method will terminate as soon
	* as the expected timezone has matched and the expected timezone will be the
	* first entry to the returned array.
	*
	* @param string\|array $_offsets
	*
	* @return array
	*/
	public function getListOfTimezones($_offsets)
	{
	if (is_string($_offsets) && isset($this->_knownTimezones[$_offsets])) {
	$timezones = $this->_knownTimezones[$_offsets];
	}
	else {
	if (is_string($_offsets)) {
	// unpack timezone info to array
	$_offsets = $this->_unpackTimezoneInfo($_offsets);
	}

	if (!$this->_validateOffsets($_offsets)) {
	return array();
	}
	$this->_setDefaultStartDateIfEmpty($_offsets);

	$cacheId = $this->_getCacheId('timezones', $_offsets);
	$timezones = $this->_loadFromCache($cacheId);

	if (!is_array($timezones)) {
	$timezones = array();
	foreach (DateTimeZone::listIdentifiers() as $timezoneIdentifier) {
	$timezone = new DateTimeZone($timezoneIdentifier);
	if (false !== ($matchingTransition = $this->_checkTimezone($timezone, $_offsets))) {
	$timezones[$timezoneIdentifier] = $matchingTransition['abbr'];
	}
	}
	$this->_saveInCache($timezones, $cacheId);
	}
	}

	return $timezones;
	}

	/**
	* Returns PHP timezone that matches to the {@param $_offsets}
	*
	* If {@see $_expectedTimezone} is set then the method will return this timezone if it matches.
	*
	* @param string\|array $_offsets Activesync timezone definition
	* @param string $_expectedTomezone Expected timezone name
	*
	* @return string Expected timezone name
	*/
	public function getTimezone($_offsets, $_expectedTimezone = null)
	{
	$timezones = $this->getListOfTimezones($_offsets);

	if ($_expectedTimezone && isset($timezones[$_expectedTimezone])) {
	return $_expectedTimezone;
	}
	else {
	return key($timezones);
	}
	}

	/**
	* Return packed string for given {@param $_timezone}
	*
	* @param string $_timezone Timezone identifier
	* @param string\|int $_startDate Start date
	*
	* @return string Packed timezone offsets
	*/
	public function encodeTimezone($_timezone, $_startDate = null)
	{
	foreach ($this->_knownTimezones as $packedString => $knownTimezone) {
	if (array_key_exists($_timezone, $knownTimezone)) {
	return $packedString;
	}
	}

	$offsets = $this->getOffsetsForTimezone($_timezone, $_startDate);

	return $this->_packTimezoneInfo($offsets);
	}

	/**
	* Get offsets for given timezone
	*
	* @param string $_timezone Timezone identifier
	* @param string\|int $_startDate Start date
	*
	* @return array Timezone offsets
	*/
	public function getOffsetsForTimezone($_timezone, $_startDate = null)
	{
	$this->_setStartDate($_startDate);

	$cacheId = $this->_getCacheId('offsets', array($_timezone));

	if (!($offsets = $this->_loadFromCache($cacheId))) {
	$offsets = $this->_getOffsetsTemplate();

	try {
	$timezone = new DateTimeZone($_timezone);
	}
	catch (Exception $e) {
	return null;
	}

	list($standardTransition, $daylightTransition) = $this->_getTransitionsForTimezoneAndYear($timezone, $this->_startDate['year']);

	if ($standardTransition) {
	$offsets['bias'] = $standardTransition['offset']/60*-1;
	if ($daylightTransition) {
	$offsets = $this->_generateOffsetsForTransition($offsets, $standardTransition, 'standard', $timezone);
	$offsets = $this->_generateOffsetsForTransition($offsets, $daylightTransition, 'daylight', $timezone);

	//@todo how do we get the standardBias (is usually 0)?
	//$offsets['standardBias'] = ...

	$offsets['daylightBias'] = ($daylightTransition['offset'] - $standardTransition['offset'])/60*-1;
	$offsets['standardHour'] -= $offsets['daylightBias'] / 60;
	$offsets['daylightHour'] += $offsets['daylightBias'] / 60;
	}
	}

	$this->_saveInCache($offsets, $cacheId);
	}

	return $offsets;
	}

	/**
	* Get offsets for timezone transition
	*
	* @param array $_offsets Timezone offsets
	* @param array $_transition Timezone transition information
	* @param string $_type Transition type: 'standard' or 'daylight'
	* @param DateTimeZone $_timezone Timezone of the transition
	*
	* @return array
	*/
	protected function _generateOffsetsForTransition(array $_offsets, array $_transition, $_type, $_timezone)
	{
	$transitionDate = new DateTime($_transition['time'], $_timezone);

	if ($_transition['offset']) {
	$transitionDate->modify($_transition['offset'] . ' seconds');
	}

	$_offsets[$_type . 'Month'] = (int) $transitionDate->format('n');
	$_offsets[$_type . 'DayOfWeek'] = (int) $transitionDate->format('w');
	$_offsets[$_type . 'Minute'] = (int) $transitionDate->format('i');
	$_offsets[$_type . 'Hour'] = (int) $transitionDate->format('G');

	for ($i=5; $i>0; $i--) {
	if ($this->_isNthOcurrenceOfWeekdayInMonth($transitionDate, $i)) {
	$_offsets[$_type . 'Week'] = $i;
	break;
	};
	}

	return $_offsets;
	}

	/**
	* Test if the weekday of the given {@param $_timestamp} is the {@param $_occurence}th occurence of this weekday within its month.
	*
	* @param DateTime $_datetime
	* @param int $_occurence [1 to 5, where 5 indicates the final occurrence during the month if that day of the week does not occur 5 times]
	*
	* @return bool
	*/
	protected function _isNthOcurrenceOfWeekdayInMonth($_datetime, $_occurence)
	{
	if ($_occurence <= 1) {
	return true;
	}

	$orig = $_datetime->format('n');

	if ($_occurence == 5) {
	$modified = clone($_datetime);
	$modified->modify('1 week');
	$mod = $modified->format('n');

	// modified date is a next month
	return $mod > $orig \|\| ($mod == 1 && $orig == 12);
	}

	$modified = clone($_datetime);
	$modified->modify(sprintf('-%d weeks', $_occurence - 1));
	$mod = $modified->format('n');

	if ($mod != $orig) {
	return false;
	}

	$modified = clone($_datetime);
	$modified->modify(sprintf('-%d weeks', $_occurence));
	$mod = $modified->format('n');

	// modified month is earlier than original
	return $mod < $orig \|\| ($mod == 12 && $orig == 1);
	}

	/**
	* Check if the given {@param $_standardTransition} and {@param $_daylightTransition}
	* match to the object property {@see $_offsets}
	*
	* @param array $standardTransition
	* @param array $daylightTransition
	*
	* @return bool
	*/
	protected function _checkTransition($_standardTransition, $_daylightTransition, $_offsets, $tz)
	{
	if (empty($_standardTransition) \|\| empty($_offsets)) {
	return false;
	}

	$standardOffset = ($_offsets['bias'] + $_offsets['standardBias']) * 60 * -1;

	// check each condition in a single if statement and break the chain when one condition is not met - for performance reasons
	if ($standardOffset == $_standardTransition['offset']) {

	if (empty($_offsets['daylightMonth']) && (empty($_daylightTransition) \|\| empty($_daylightTransition['isdst']))) {
	// No DST
	return true;
	}

	$daylightOffset = ($_offsets['bias'] + $_offsets['daylightBias']) * 60 * -1;

	// the milestone is sending a positive value for daylightBias while it should send a negative value
	$daylightOffsetMilestone = ($_offsets['bias'] + ($_offsets['daylightBias'] * -1) ) * 60 * -1;

	if (
	!empty($_daylightTransition)
	&& ($daylightOffset == $_daylightTransition['offset'] \|\| $daylightOffsetMilestone == $_daylightTransition['offset'])
	) {
	// date-time input here contains UTC timezone specifier (+0000),
	// we have to convert the date to the requested timezone afterwards.
	$standardDate = new DateTime($_standardTransition['time']);
	$daylightDate = new DateTime($_daylightTransition['time']);
	$standardDate->setTimezone($tz);
	$daylightDate->setTimezone($tz);

	if ($standardDate->format('n') == $_offsets['standardMonth'] &&
	$daylightDate->format('n') == $_offsets['daylightMonth'] &&
	$standardDate->format('w') == $_offsets['standardDayOfWeek'] &&
	$daylightDate->format('w') == $_offsets['daylightDayOfWeek']
	) {
	return $this->_isNthOcurrenceOfWeekdayInMonth($daylightDate, $_offsets['daylightWeek']) &&
	$this->_isNthOcurrenceOfWeekdayInMonth($standardDate, $_offsets['standardWeek']);
	}
	}
	}

	return false;
	}

	/**
	* decode timezone info from activesync
	*
	* @param string $_packedTimezoneInfo the packed timezone info
	* @return array
	*/
	protected function _unpackTimezoneInfo($_packedTimezoneInfo)
	{
	$timezoneUnpackString = 'lbias/a64standardName/vstandardYear/vstandardMonth/vstandardDayOfWeek/vstandardWeek/vstandardHour/vstandardMinute/vstandardSecond/vstandardMilliseconds/lstandardBias'
	. '/a64daylightName/vdaylightYear/vdaylightMonth/vdaylightDayOfWeek/vdaylightWeek/vdaylightHour/vdaylightMinute/vdaylightSecond/vdaylightMilliseconds/ldaylightBias';

	$timezoneInfo = unpack($timezoneUnpackString, base64_decode($_packedTimezoneInfo));

	if ($timezoneInfo['standardHour'] == 23 && $timezoneInfo['standardMilliseconds'] == 999
	&& $timezoneInfo['standardMinute'] == 59 && $timezoneInfo['standardSecond'] == 59
	) {
	$timezoneInfo['standardHour'] = 24;
	$timezoneInfo['standardMinute'] = 0;
	$timezoneInfo['standardSecond'] = 0;
	$timezoneInfo['standardMilliseconds'] = 0;
	}

	return $timezoneInfo;
	}

	/**
	* encode timezone info to activesync
	*
	* @param array $_timezoneInfo
	* @return string
	*/
	protected function _packTimezoneInfo($_timezoneInfo)
	{
	if (!is_array($_timezoneInfo)) {
	return null;
	}

	// According to e.g. https://docs.microsoft.com/en-us/windows/win32/api/minwinbase/ns-minwinbase-systemtime,
	// 24 is not allowed in the Hour field, and consequently Outlook can't deal with it.
	// This is the same workaround that Outlook applies.
	if ($_timezoneInfo['standardHour'] == 24) {
	$_timezoneInfo['standardHour'] = 23;
	$_timezoneInfo['standardMinute'] = 59;
	$_timezoneInfo['standardSecond'] = 59;
	$_timezoneInfo['standardMilliseconds'] = 999;
	}

	$packed = pack(
	"la64vvvvvvvvla64vvvvvvvvl",
	$_timezoneInfo['bias'],
	$_timezoneInfo['standardName'],
	$_timezoneInfo['standardYear'],
	$_timezoneInfo['standardMonth'],
	$_timezoneInfo['standardDayOfWeek'],
	$_timezoneInfo['standardWeek'],
	$_timezoneInfo['standardHour'],
	$_timezoneInfo['standardMinute'],
	$_timezoneInfo['standardSecond'],
	$_timezoneInfo['standardMilliseconds'],
	$_timezoneInfo['standardBias'],
	$_timezoneInfo['daylightName'],
	$_timezoneInfo['daylightYear'],
	$_timezoneInfo['daylightMonth'],
	$_timezoneInfo['daylightDayOfWeek'],
	$_timezoneInfo['daylightWeek'],
	$_timezoneInfo['daylightHour'],
	$_timezoneInfo['daylightMinute'],
	$_timezoneInfo['daylightSecond'],
	$_timezoneInfo['daylightMilliseconds'],
	$_timezoneInfo['daylightBias']
	);

	return base64_encode($packed);
	}

	/**
	* Returns complete offsets array with all fields empty
	*
	* Used e.g. when reverse-generating ActiveSync Timezone Offset Information
	* based on a given Timezone, {@see getOffsetsForTimezone}
	*
	* @return unknown_type
	*/
	protected function _getOffsetsTemplate()
	{
	return array(
	'bias' => 0,
	'standardName' => '',
	'standardYear' => 0,
	'standardMonth' => 0,
	'standardDayOfWeek' => 0,
	'standardWeek' => 0,
	'standardHour' => 0,
	'standardMinute' => 0,
	'standardSecond' => 0,
	'standardMilliseconds' => 0,
	'standardBias' => 0,
	'daylightName' => '',
	'daylightYear' => 0,
	'daylightMonth' => 0,
	'daylightDayOfWeek' => 0,
	'daylightWeek' => 0,
	'daylightHour' => 0,
	'daylightMinute' => 0,
	'daylightSecond' => 0,
	'daylightMilliseconds' => 0,
	'daylightBias' => 0
	);
	}

	/**
	* Validate and set offsets
	*
	* @param array $value
	*
	* @return bool Validation result
	*/
	protected function _validateOffsets($value)
	{
	// validate $value
	if ((!empty($value['standardMonth']) \|\| !empty($value['standardWeek']) \|\| !empty($value['daylightMonth']) \|\| !empty($value['daylightWeek'])) &&
	(empty($value['standardMonth']) \|\| empty($value['standardWeek']) \|\| empty($value['daylightMonth']) \|\| empty($value['daylightWeek']))
	) {
	// It is not possible not set standard offsets without setting daylight offsets and vice versa
	return false;
	}

	return true;
	}

	/**
	* Parse and set object property {@see $_startDate}
	*
	* @param string\|int $_startDate
	* @return void
	*/
	protected function _setStartDate($_startDate)
	{
	if (empty($_startDate)) {
	$this->_setDefaultStartDateIfEmpty();
	return;
	}

	$startDateParsed = array();

	if (is_string($_startDate)) {
	$startDateParsed['string'] = $_startDate;
	$startDateParsed['ts'] = strtotime($_startDate);
	}
	else if (is_int($_startDate)) {
	$startDateParsed['ts'] = $_startDate;
	- $startDateParsed['string'] = strftime('%F', $_startDate);
	+ $startDateParsed['string'] = date('Y-m-d', $_startDate);
	}
	else {
	$this->_setDefaultStartDateIfEmpty();
	return;
	}

	$startDateParsed['object'] = new DateTime($startDateParsed['string']);

	$startDateParsed = array_merge($startDateParsed, getdate($startDateParsed['ts']));

	$this->_startDate = $startDateParsed;
	}

	/**
	* Set default value for object property {@see $_startdate} if it is not set yet.
	* Tries to guess the correct startDate depending on object property {@see $_offsets} and
	* falls back to current date.
	*
	* @param array $_offsets [offsets may be avaluated for a given start year]
	* @return void
	*/
	protected function _setDefaultStartDateIfEmpty($_offsets = null)
	{
	if (!empty($this->_startDate)) {
	return;
	}

	if (!empty($_offsets['standardYear'])) {
	$this->_setStartDate($_offsets['standardYear'].'-01-01');
	}
	else {
	$this->_setStartDate(time());
	}
	}

	/**
	* Check if the given {@param $_timezone} matches the {@see $_offsets}
	* and also evaluate the daylight saving time transitions for this timezone if necessary.
	*
	* @param DateTimeZone $timezone
	* @param array $offsets
	*
	* @return array\|bool
	*/
	protected function _checkTimezone(DateTimeZone $timezone, $offsets)
	{
	list($standardTransition, $daylightTransition) = $this->_getTransitionsForTimezoneAndYear($timezone, $this->_startDate['year']);

	if ($this->_checkTransition($standardTransition, $daylightTransition, $offsets, $timezone)) {
	return $standardTransition;
	}

	return false;
	}

	/**
	* Returns the standard and daylight transitions for the given {@param $_timezone}
	* and {@param $_year}.
	*
	* @param DateTimeZone $_timezone
	* @param int $_year
	*
	* @return array
	*/
	protected function _getTransitionsForTimezoneAndYear(DateTimeZone $_timezone, $_year)
	{
	$standardTransition = null;
	$daylightTransition = null;

	$start = mktime(0, 0, 0, 12, 1, $_year - 1);
	$end = mktime(24, 0, 0, 12, 31, $_year);
	$transitions = $_timezone->getTransitions($start, $end);

	if ($transitions === false) {
	return array();
	}

	foreach ($transitions as $index => $transition) {
	- if (strftime('%Y', $transition['ts']) == $_year) {
	- if (isset($transitions[$index+1]) && strftime('%Y', $transitions[$index]['ts']) == strftime('%Y', $transitions[$index+1]['ts'])) {
	+ if (date('Y', $transition['ts']) == $_year) {
	+ if (isset($transitions[$index+1]) && date('Y', $transitions[$index]['ts']) == date('Y', $transitions[$index+1]['ts'])) {
	$daylightTransition = $transition['isdst'] ? $transition : $transitions[$index+1];
	$standardTransition = $transition['isdst'] ? $transitions[$index+1] : $transition;
	}
	else {
	$daylightTransition = $transition['isdst'] ? $transition : null;
	$standardTransition = $transition['isdst'] ? null : $transition;
	}
	break;
	}
	else if ($index == count($transitions) -1) {
	$standardTransition = $transition;
	}
	}

	return array($standardTransition, $daylightTransition);
	}

	protected function _getCacheId($_prefix, $_offsets)
	{
	return $_prefix . md5(serialize($_offsets));
	}

	protected function _loadFromCache($key)
	{
	if ($cache = $this->getCache()) {
	return $cache->get($key);
	}

	return false;
	}

	protected function _saveInCache($value, $key)
	{
	if ($cache = $this->getCache()) {
	$cache->set($key, $value);
	}
	}

	/**
	* Getter for the cache engine object
	*/
	protected function getCache()
	{
	if ($this->cache === null) {
	$rcube = rcube::get_instance();
	$cache = $rcube->get_cache_shared('activesync');
	$this->cache = $cache ? $cache : false;
	}

	return $this->cache;
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Fri, Mar 20, 5:37 AM (1 d, 22 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 458872
Default Alt Text: (99 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions