diff --git a/lib/ext/Syncroton/Command/Sync.php b/lib/ext/Syncroton/Command/Sync.php index 6c00f3b..f41e79f 100644 --- a/lib/ext/Syncroton/Command/Sync.php +++ b/lib/ext/Syncroton/Command/Sync.php @@ -1,1301 +1,1301 @@ */ /** * class to handle ActiveSync Sync command * * @package Syncroton * @subpackage Command */ class Syncroton_Command_Sync extends Syncroton_Command_Wbxml { public const STATUS_SUCCESS = 1; public const STATUS_PROTOCOL_VERSION_MISMATCH = 2; public const STATUS_INVALID_SYNC_KEY = 3; public const STATUS_PROTOCOL_ERROR = 4; public const STATUS_SERVER_ERROR = 5; public const STATUS_ERROR_IN_CLIENT_SERVER_CONVERSION = 6; public const STATUS_CONFLICT_MATCHING_THE_CLIENT_AND_SERVER_OBJECT = 7; public const STATUS_OBJECT_NOT_FOUND = 8; public const STATUS_USER_ACCOUNT_MAYBE_OUT_OF_DISK_SPACE = 9; public const STATUS_ERROR_SETTING_NOTIFICATION_GUID = 10; public const STATUS_DEVICE_NOT_PROVISIONED_FOR_NOTIFICATIONS = 11; public const STATUS_FOLDER_HIERARCHY_HAS_CHANGED = 12; public const STATUS_RESEND_FULL_XML = 13; public const STATUS_WAIT_INTERVAL_OUT_OF_RANGE = 14; public const STATUS_TOO_MANY_COLLECTIONS = 15; public const CONFLICT_OVERWRITE_SERVER = 0; public const CONFLICT_OVERWRITE_PIM = 1; public const MIMESUPPORT_DONT_SEND_MIME = 0; public const MIMESUPPORT_SMIME_ONLY = 1; public const MIMESUPPORT_SEND_MIME = 2; public const BODY_TYPE_PLAIN_TEXT = 1; public const BODY_TYPE_HTML = 2; public const BODY_TYPE_RTF = 3; public const BODY_TYPE_MIME = 4; /** * truncate types */ public const TRUNCATE_ALL = 0; public const TRUNCATE_4096 = 1; public const TRUNCATE_5120 = 2; public const TRUNCATE_7168 = 3; public const TRUNCATE_10240 = 4; public const TRUNCATE_20480 = 5; public const TRUNCATE_51200 = 6; public const TRUNCATE_102400 = 7; public const TRUNCATE_NOTHING = 8; /** * filter types */ public const FILTER_NOTHING = 0; public const FILTER_1_DAY_BACK = 1; public const FILTER_3_DAYS_BACK = 2; public const FILTER_1_WEEK_BACK = 3; public const FILTER_2_WEEKS_BACK = 4; public const FILTER_1_MONTH_BACK = 5; public const FILTER_3_MONTHS_BACK = 6; public const FILTER_6_MONTHS_BACK = 7; public const FILTER_INCOMPLETE = 8; protected $_defaultNameSpace = 'uri:AirSync'; protected $_documentElement = 'Sync'; /** * list of collections * * @var array */ protected $_collections = []; protected $_modifications = []; /** * 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; 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; } $intervalDiv = 1; if (isset($requestXML->HeartbeatInterval)) { $intervalDiv = 1; $this->_heartbeatInterval = (int)$requestXML->HeartbeatInterval; } elseif (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 = ['options' => []]; if (!empty($this->_device->lastsynccollection)) { $lastSyncCollection = Zend_Json::decode($this->_device->lastsynccollection); if (!array_key_exists('options', $lastSyncCollection) || !is_array($lastSyncCollection['options'])) { $lastSyncCollection['options'] = []; } } $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 = []; 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([ '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([ 'device_id' => $this->_device, 'counter' => 0, 'type' => $collectionData->folder, 'lastsync' => $this->_syncTimeStamp, ]); $this->_collections[$collectionData->collectionId] = $collectionData; continue; } $syncKeyReused = $this->_syncStateBackend->haveNext($this->_device, $collectionData->folder, $collectionData->syncKey); if ($syncKeyReused) { if ($this->_logger instanceof Zend_Log) { $this->_logger->warn(__METHOD__ . '::' . __LINE__ . " already known synckey {$collectionData->syncKey} provided"); } } // check for invalid synckey 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'); } $clientModifications = [ 'added' => [], 'changed' => [], 'deleted' => [], 'forceAdd' => [], 'forceChange' => [], 'toBeFetched' => [], ]; // 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"); } $clientIdMap = []; if ($syncKeyReused && $collectionData->syncState->clientIdMap) { $clientIdMap = Zend_Json::decode($collectionData->syncState->clientIdMap); } 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"); } $clientId = (string)$add->ClientId; // If the sync key was reused, but we don't have a $clientId mapping, // this means the client sent a new item with the same sync_key. if ($syncKeyReused && array_key_exists($clientId, $clientIdMap)) { // We don't normally store the clientId, so if a command with Add's is resent, // we have to look-up the corresponding serverId using a cached clientId => serverId mapping, // otherwise we would duplicate all added items on resend. $serverId = $clientIdMap[$clientId]; $clientModifications['added'][$serverId] = [ 'clientId' => (string)$add->ClientId, 'serverId' => $serverId, 'status' => self::STATUS_SUCCESS, 'contentState' => null, ]; } else { $serverId = $dataController->createEntry($collectionData->collectionId, new $dataClass($add->ApplicationData)); $clientModifications['added'][$serverId] = [ 'clientId' => (string)$add->ClientId, 'serverId' => $serverId, 'status' => self::STATUS_SUCCESS, 'contentState' => $this->_contentStateBackend->create(new Syncroton_Model_Content([ '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'][] = [ 'clientId' => (string)$add->ClientId, 'status' => self::STATUS_SERVER_ERROR, ]; } } } // handle changes, but only if not first sync if(!$syncKeyReused && $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(!$syncKeyReused && $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 = []; 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('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; } } // Handle Calendar folders first. // Outlook can't match MeetingRequest with an event that wasn't synced yet, which // leads to duplicated events in Outlook's calendar. uasort( $this->_collections, function ($a, $b) { $ac = $a->folder && $a->folder->class == Syncroton_Data_Factory::CLASS_CALENDAR; $bc = $b->folder && $b->folder->class == Syncroton_Data_Factory::CLASS_CALENDAR; if ($ac) { return $bc ? 0 : -1; } return $bc ? 1 : 0; } ); foreach ($this->_collections as $collectionData) { if ($this->_logger instanceof Zend_Log) { $this->_logger->debug(__METHOD__ . '::' . __LINE__ . " Processing {$collectionData->collectionId}..."); } $collectionChanges = 0; /** * keep track of entries added on server side */ $newContentStates = []; /** * keep track of entries deleted on server side */ $deletedContentStates = []; // 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 = [ 'added' => [], 'changed' => [], 'deleted' => [], ]; $status = self::STATUS_SUCCESS; $hasChanges = 0; if ($collectionData->getChanges === true) { // continue sync session? if(is_array($collectionData->syncState->pendingdata)) { $serverModifications = $collectionData->syncState->pendingdata; if ($this->_logger instanceof Zend_Log) { - $this->_logger->info(__METHOD__ . '::' . __LINE__ . " restored from sync state: (added/changed/deleted) " . count($serverModifications['added']) . '/' . count($serverModifications['changed']) . '/' . count($serverModifications['deleted']) . ' entries for sync from server to client'); + $this->_logger->info(__METHOD__ . '::' . __LINE__ . " restored from sync state: (added/changed/deleted) " . count($serverModifications['added']) . '/' . count($serverModifications['changed']) . '/' . count($serverModifications['deleted']) . ' entries for sync from server to client'); } } 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('now', new DateTimeZone('UTC')); try { // fetch entries added since last sync $allClientEntries = $this->_contentStateBackend->getFolderState( $this->_device, $collectionData->folder, $collectionData->syncState->counter ); // fetch entries changed since last sync $allChangedEntries = $dataController->getChangedEntries( $collectionData->collectionId, $collectionData->syncState, $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 elseif (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'); if ($this->_logger instanceof Zend_Log) { $this->_logger->info(__METHOD__ . '::' . __LINE__ . " Processing collection " . $collectionData->collectionId); } - + // 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 if 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; } 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([ '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->info(__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')); $collectionData->options['_changesOnly'] = true; $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->info(__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; // If the client resent an old sync-key, we should still respond with the latest sync key if (isset($collectionData->syncState->counterNext)) { //TODO we're not resending the changes in between, but I'm not sure we have to. $collectionData->syncState->counter = $collectionData->syncState->counterNext; } // 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); } //Store next $collectionData->syncState->extraData = $dataController->getExtraData($collectionData->folder); } 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 = [ 'added' => $serverModifications['added'] ?? [], 'changed' => $serverModifications['changed'] ?? [], 'deleted' => $serverModifications['deleted'] ?? [], ]; } else { $collectionData->syncState->pendingdata = null; } $collectionData->syncState->lastsync = clone $this->_syncTimeStamp; // increment sync timestamp by 1 second $collectionData->syncState->lastsync->modify('+1 sec'); if (!empty($clientModifications['added'])) { // Store a client id mapping in case we encounter a reused sync_key in a future request. $newClientIdMap = []; foreach($clientModifications['added'] as $entryData) { // No serverId if we failed to add if ($entryData['status'] == self::STATUS_SUCCESS) { $newClientIdMap[$entryData['clientId']] = $entryData['serverId']; } } $collectionData->syncState->clientIdMap = Zend_Json::encode($newClientIdMap); } //Retry in case of deadlock $retryCounter = 0; while (true) { try { $transactionId = Syncroton_Registry::getTransactionManager()->startTransaction(Syncroton_Registry::getDatabase()); // store new synckey $this->_syncStateBackend->create($collectionData->syncState, true); // @phpstan-ignore-line // store contentstates for new entries added to client foreach($newContentStates as $state) { try { //This can happen if we rerun a previous sync-key $state = $this->_contentStateBackend->getContentState($state->device_id, $state->folder_id, $state->contentid); $this->_contentStateBackend->update($state); } catch(Exception $zdse) { $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); break; } catch (Syncroton_Exception_DeadlockDetected $zdse) { $retryCounter++; if ($retryCounter > 60) { if ($this->_logger instanceof Zend_Log) { $this->_logger->warn(__METHOD__ . '::' . __LINE__ . ' exception while storing new synckey. Aborting after 5 retries.'); } // something went wrong // maybe another parallel request added a new synckey // we must remove data added from client if (!empty($clientModifications['added']) && isset($dataController)) { foreach ($clientModifications['added'] as $added) { $this->_contentStateBackend->delete($added['contentState']); $dataController->deleteEntry($collectionData->collectionId, $added['serverId']); } } Syncroton_Registry::getTransactionManager()->rollBack(); throw $zdse; } Syncroton_Registry::getTransactionManager()->rollBack(); // Give the other transactions some time before we try again sleep(1); if ($this->_logger instanceof Zend_Log) { $this->_logger->warn(__METHOD__ . '::' . __LINE__ . ' error during transaction, trying again.'); } } catch (Exception $zdse) { if ($this->_logger instanceof Zend_Log) { $this->_logger->warn(__METHOD__ . '::' . __LINE__ . ' exception while storing new synckey.'); } // something went wrong // maybe another parallel request added a new synckey // we must remove data added from client if (!empty($clientModifications['added']) && isset($dataController)) { foreach ($clientModifications['added'] as $added) { $this->_contentStateBackend->delete($added['contentState']); $dataController->deleteEntry($collectionData->collectionId, $added['serverId']); } } Syncroton_Registry::getTransactionManager()->rollBack(); throw $zdse; } } } // store current filter type try { /** @var Syncroton_Model_Folder $folderState */ $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 (['Commands', 'Supported'] as $element) { /** @var DOMElement $collection */ $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 DOMDocument */ protected function _mergeSyncRequest($requestBody, Syncroton_Model_Device $device) { $lastSyncCollection = []; 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) { if (!empty($lastXML)) { $requestBody = $lastXML; } else { throw new Syncroton_Exception_UnexpectedValue('no xml body found'); } } if ($requestBody->getElementsByTagName('Partial')->length > 0) { $partialBody = clone $requestBody; $requestBody = $lastXML ?? (new DOMDocument()); $xpath = new DomXPath($requestBody); $xpath->registerNamespace('AirSync', 'uri:AirSync'); foreach ($partialBody->documentElement->childNodes as $child) { if (! $child instanceof DOMElement) { continue; } /** @var DOMElement $child */ 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) { /** @var DOMElement $existingCollection */ $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/kolab_sync_message.php b/lib/kolab_sync_message.php index 2ada9de..6c7b0cf 100644 --- a/lib/kolab_sync_message.php +++ b/lib/kolab_sync_message.php @@ -1,499 +1,498 @@ | | | | 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 | +--------------------------------------------------------------------------+ | Author: Aleksander Machniak | +--------------------------------------------------------------------------+ */ class kolab_sync_message { protected $headers = []; protected $body; protected $ctype; protected $ctype_params = []; /** * Constructor * * @param string|resource $source MIME message source */ public function __construct($source) { $this->parse_mime($source); } /** * Returns message headers * * @return array Message headers */ public function headers() { return $this->headers; } public function source() { $headers = []; // Build the message back foreach ($this->headers as $header => $header_value) { $headers[$header] = $header . ': ' . $header_value; } return trim(implode("\r\n", $headers)) . "\r\n\r\n" . ltrim($this->body); // @TODO: work with file streams } /** * Appends text at the end of the message body * * @todo: HTML support * * @param string $text Text to append * @param string $charset Text charset */ public function append($text, $charset = null) { if ($this->ctype == 'text/plain') { // decode body $body = $this->decode($this->body, $this->headers['Content-Transfer-Encoding']); $body = rcube_charset::convert($body, $this->ctype_params['charset'], $charset); // append text $body .= $text; // encode and save $body = rcube_charset::convert($body, $charset, $this->ctype_params['charset']); $this->body = $this->encode($body, $this->headers['Content-Transfer-Encoding']); } } /** * Adds attachment to the message * * @param string $body Attachment body (not encoded) * @param array $params Attachment parameters (Mail_mimePart format) */ public function add_attachment($body, $params = []) { // convert the message into multipart/mixed if ($this->ctype != 'multipart/mixed') { $boundary = '_' . md5(rand() . microtime()); $this->body = "--$boundary\r\n" . "Content-Type: " . $this->headers['Content-Type'] . "\r\n" . "Content-Transfer-Encoding: " . $this->headers['Content-Transfer-Encoding'] . "\r\n" . "\r\n" . trim($this->body) . "\r\n" . "--$boundary\r\n"; $this->ctype = 'multipart/mixed'; $this->ctype_params = ['boundary' => $boundary]; unset($this->headers['Content-Transfer-Encoding']); $this->save_content_type($this->ctype, $this->ctype_params); } // make sure MIME-Version header is set, it's required by some servers if (empty($this->headers['MIME-Version'])) { $this->headers['MIME-Version'] = '1.0'; } $boundary = $this->ctype_params['boundary']; $part = new Mail_mimePart($body, $params); $body = $part->encode(); foreach ($body['headers'] as $name => $value) { $body['headers'][$name] = $name . ': ' . $value; } $this->body = rtrim($this->body); $this->body = preg_replace('/--$/', '', $this->body); // add the attachment to the end of the message $this->body .= "\r\n" . implode("\r\n", $body['headers']) . "\r\n\r\n" . $body['body'] . "\r\n--$boundary--\r\n"; } /** * Sets the value of specified message header * * @param string $name Header name * @param string $value Header value */ public function set_header($name, $value) { $name = self::normalize_header_name($name); if ($name != 'Content-Type') { $this->headers[$name] = $value; } } /** * Send the given message using the configured method. * * @param array $smtp_error SMTP error array (reference) * @param array $smtp_opts SMTP options (e.g. DSN request) * * @return bool Send status. */ public function send(&$smtp_error = null, $smtp_opts = null) { $rcube = kolab_sync::get_instance(); $headers = $this->headers; $mailto = $headers['To']; $headers['User-Agent'] = $rcube->app_name . ' ' . kolab_sync::VERSION; if ($agent = $rcube->config->get('useragent')) { $headers['User-Agent'] .= '/' . $agent; } if (empty($headers['From'])) { $headers['From'] = $this->get_identity(); } // make sure there's sender name in From: elseif ($rcube->config->get('activesync_fix_from') && preg_match('/^?$/', trim($headers['From']), $m) ) { $identities = kolab_sync::get_instance()->user->list_identities(); $email = $m[1]; foreach ((array) $identities as $ident) { if ($ident['email'] == $email) { if ($ident['name']) { $headers['From'] = format_email_recipient($email, $ident['name']); } break; } } } if (empty($headers['Message-ID'])) { $headers['Message-ID'] = $rcube->gen_message_id(); } // remove empty headers $headers = array_filter($headers); $smtp_headers = $headers; // generate list of recipients $recipients = []; if (!empty($headers['To'])) { $recipients[] = $headers['To']; } if (!empty($headers['Cc'])) { $recipients[] = $headers['Cc']; } if (!empty($headers['Bcc'])) { $recipients[] = $headers['Bcc']; } if (empty($headers['To']) && empty($headers['Cc'])) { $headers['To'] = 'undisclosed-recipients:;'; } // remove Bcc header unset($smtp_headers['Bcc']); // send message if (!is_object($rcube->smtp)) { $rcube->smtp_init(true); } $sent = $rcube->smtp->send_mail($headers['From'], $recipients, $smtp_headers, $this->body, $smtp_opts); $smtp_response = $rcube->smtp->get_response(); $smtp_error = $rcube->smtp->get_error(); // log error if (!$sent) { rcube::raise_error(['code' => 800, 'type' => 'smtp', 'line' => __LINE__, 'file' => __FILE__, 'message' => "SMTP error: " . implode("\n", $smtp_response)], true, false); } if ($sent) { $rcube->plugins->exec_hook('message_sent', ['headers' => $headers, 'body' => $this->body]); // remove MDN headers after sending unset($headers['Return-Receipt-To'], $headers['Disposition-Notification-To']); if ($rcube->config->get('smtp_log')) { // get all recipient addresses $mailto = rcube_mime::decode_address_list(implode(',', $recipients), null, false, null, true); rcube::write_log( 'sendmail', sprintf( "User %s [%s]; Message %s for %s; %s", $rcube->get_user_name(), rcube_utils::remote_addr(), $headers['Message-ID'], implode(', ', $mailto), !empty($smtp_response) ? implode('; ', $smtp_response) : '' ) ); } } $this->headers = $headers; return $sent; } /** * Parses the message source and fixes 8bit data for ActiveSync. * This way any not UTF8 characters will be encoded before * sending to the device. * * @param string $message Message source * * @return string Fixed message source */ public static function recode_message($message) { // @TODO: work with stream, to workaround memory issues with big messages if (is_resource($message)) { $message = stream_get_contents($message); } [$headers, $message] = array_pad(preg_split('/\r?\n\r?\n/', $message, 2, PREG_SPLIT_NO_EMPTY), 2, ''); $hdrs = self::parse_headers($headers); // multipart message if (preg_match('/boundary="?([a-z0-9-\'\(\)+_\,\.\/:=\? ]+)"?/i', $hdrs['Content-Type'] ?? '', $matches)) { $boundary = '--' . $matches[1]; $message = explode($boundary, $message); for ($x = 1, $parts = count($message) - 1; $x < $parts; $x++) { $message[$x] = "\r\n" . self::recode_message(ltrim($message[$x])); } return $headers . "\r\n\r\n" . implode($boundary, $message); } // single part $enc = !empty($hdrs['Content-Transfer-Encoding']) ? strtolower($hdrs['Content-Transfer-Encoding']) : null; // do nothing if already encoded if ($enc != 'quoted-printable' && $enc != 'base64') { // recode body if any non-printable-ascii characters found if (preg_match('/[^\x20-\x7E\x0A\x0D\x09]/', $message)) { $hdrs['Content-Transfer-Encoding'] = 'base64'; foreach ($hdrs as $header => $header_value) { $hdrs[$header] = $header . ': ' . $header_value; } $headers = trim(implode("\r\n", $hdrs)); $message = rtrim(chunk_split(base64_encode(rtrim($message)), 76, "\r\n")) . "\r\n"; } } return $headers . "\r\n\r\n" . $message; } /** * Creates a fake plain text message source with predefined headers and body * * @param string $headers Message headers * @param string $body Plain text body * * @return string Message source */ public static function fake_message($headers, $body = '') { $hdrs = self::parse_headers($headers); $result = ''; $hdrs['Content-Type'] = 'text/plain; charset=UTF-8'; $hdrs['Content-Transfer-Encoding'] = 'quoted-printable'; foreach ($hdrs as $header => $header_value) { $result .= $header . ': ' . $header_value . "\r\n"; } return $result . "\r\n" . self::encode($body, 'quoted-printable'); } /** * MIME message parser * * @param string|resource $message MIME message source */ protected function parse_mime($message) { // @TODO: work with stream, to workaround memory issues with big messages if (is_resource($message)) { $message = stream_get_contents($message); } [$headers, $message] = preg_split('/\r?\n\r?\n/', $message, 2, PREG_SPLIT_NO_EMPTY); $headers = self::parse_headers($headers); // parse Content-Type header $ctype_parts = preg_split('/[; ]+/', $headers['Content-Type']); $this->ctype = strtolower(array_shift($ctype_parts)); foreach ($ctype_parts as $part) { if (preg_match('/^([a-z-_]+)\s*=\s*(.+)$/i', trim($part), $m)) { $this->ctype_params[strtolower($m[1])] = trim($m[2], '"'); } } if (!empty($headers['Content-Transfer-Encoding'])) { $headers['Content-Transfer-Encoding'] = strtolower($headers['Content-Transfer-Encoding']); } $this->headers = $headers; $this->body = $message; } /** * Parse message source with headers */ protected static function parse_headers($headers) { // Parse headers $headers = str_replace("\r\n", "\n", $headers); $headers = explode("\n", trim($headers)); $ln = 0; $lines = []; foreach ($headers as $line) { if (ord($line[0]) <= 32) { $lines[$ln] .= (empty($lines[$ln]) ? '' : "\r\n") . $line; } else { $lines[++$ln] = trim($line); } } // Unify char-case of header names $headers = []; foreach ($lines as $line) { if (strpos($line, ':') !== false) { [$field, $string] = explode(':', $line, 2); if ($field = self::normalize_header_name($field)) { $headers[$field] = trim($string); } } } return $headers; } /** * Normalize (fix) header names */ protected static function normalize_header_name($name) { $headers_map = [ 'subject' => 'Subject', 'from' => 'From', 'to' => 'To', 'cc' => 'Cc', 'bcc' => 'Bcc', 'message-id' => 'Message-ID', 'references' => 'References', 'content-type' => 'Content-Type', 'content-transfer-encoding' => 'Content-Transfer-Encoding', ]; $name_lc = strtolower($name); return $headers_map[$name_lc] ?? $name; } /** * Encodes message/part body * * @param string $body Message/part body * @param string $encoding Content encoding * * @return string Encoded body */ protected static function encode($body, $encoding) { switch ($encoding) { case 'base64': $body = base64_encode($body); $body = chunk_split($body, 76, "\r\n"); break; case 'quoted-printable': $body = quoted_printable_encode($body); break; } return $body; } /** * Decodes message/part body * * @param string $body Message/part body * @param string $encoding Content encoding * * @return string Decoded body */ protected function decode($body, $encoding) { $body = str_replace("\r\n", "\n", $body); switch ($encoding) { case 'base64': $body = base64_decode($body); break; case 'quoted-printable': $body = quoted_printable_decode($body); break; } return $body; } /** * Returns email address string from default identity of the current user */ protected function get_identity() { $user = kolab_sync::get_instance()->user; if ($identity = $user->get_identity()) { return format_email_recipient(format_email($identity['email']), $identity['name']); } } protected function save_content_type($ctype, $params = []) { $this->ctype = $ctype; $this->ctype_params = $params; $this->headers['Content-Type'] = $ctype; if (!empty($params)) { foreach ($params as $name => $value) { $this->headers['Content-Type'] .= sprintf('; %s="%s"', $name, $value); } } } - } diff --git a/lib/kolab_sync_storage.php b/lib/kolab_sync_storage.php index 82503ff..c93f7f6 100644 --- a/lib/kolab_sync_storage.php +++ b/lib/kolab_sync_storage.php @@ -1,2026 +1,2027 @@ | | | | 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 | +--------------------------------------------------------------------------+ | Author: Aleksander Machniak | +--------------------------------------------------------------------------+ */ /** * Storage handling class with basic Kolab support (everything stored in IMAP) */ class kolab_sync_storage { public const INIT_SUB_PERSONAL = 1; // all subscribed folders in personal namespace public const INIT_ALL_PERSONAL = 2; // all folders in personal namespace public const INIT_SUB_OTHER = 4; // all subscribed folders in other users namespace public const INIT_ALL_OTHER = 8; // all folders in other users namespace public const INIT_SUB_SHARED = 16; // all subscribed folders in shared namespace public const INIT_ALL_SHARED = 32; // all folders in shared namespace public const MODEL_CALENDAR = 'event'; public const MODEL_CONTACTS = 'contact'; public const MODEL_EMAIL = 'mail'; public const MODEL_NOTES = 'note'; public const MODEL_TASKS = 'task'; public const ROOT_MAILBOX = 'INBOX'; public const ASYNC_KEY = '/private/vendor/kolab/activesync'; public const UID_KEY = '/shared/vendor/cmu/cyrus-imapd/uniqueid'; public const CTYPE_KEY = '/shared/vendor/kolab/folder-type'; public const CTYPE_KEY_PRIVATE = '/private/vendor/kolab/folder-type'; public $syncTimeStamp; protected $storage; protected $folder_meta; protected $folder_uids; protected $folders = []; protected $root_meta; protected $relations = []; protected $relationSupport = true; protected $tag_rts = []; private $modseq = []; protected static $instance; protected static $types = [ 1 => '', 2 => 'mail.inbox', 3 => 'mail.drafts', 4 => 'mail.wastebasket', 5 => 'mail.sentitems', 6 => 'mail.outbox', 7 => 'task.default', 8 => 'event.default', 9 => 'contact.default', 10 => 'note.default', 11 => 'journal.default', 12 => 'mail', 13 => 'event', 14 => 'contact', 15 => 'task', 16 => 'journal', 17 => 'note', ]; /** * This implements the 'singleton' design pattern * * @return kolab_sync_storage The one and only instance */ public static function get_instance() { if (!self::$instance) { self::$instance = new kolab_sync_storage(); self::$instance->startup(); // init AFTER object was linked with self::$instance } return self::$instance; } /** * Class initialization */ public function startup() { $this->storage = kolab_sync::get_instance()->get_storage(); // set additional header used by libkolab $this->storage->set_options([ // @TODO: there can be Roundcube plugins defining additional headers, // we maybe would need to add them here 'fetch_headers' => 'X-KOLAB-TYPE X-KOLAB-MIME-VERSION', 'skip_deleted' => true, 'threading' => false, ]); // Disable paging $this->storage->set_pagesize(999999); } /** * Clear internal cache state */ public function reset() { $this->folders = []; } /** * List known devices * * @return array Device list as hash array */ public function devices_list() { if ($this->root_meta === null) { // @TODO: consider server annotation instead of INBOX if ($meta = $this->storage->get_metadata(self::ROOT_MAILBOX, self::ASYNC_KEY)) { $this->root_meta = $this->unserialize_metadata($meta[self::ROOT_MAILBOX][self::ASYNC_KEY]); } else { $this->root_meta = []; } } if (!empty($this->root_meta['DEVICE']) && is_array($this->root_meta['DEVICE'])) { return $this->root_meta['DEVICE']; } return []; } /** * Get list of folders available for sync * * @param string $deviceid Device identifier * @param string $type Folder type * @param bool $flat_mode Enables flat-list mode * * @return array|bool List of mailbox folders, False on backend failure */ public function folders_list($deviceid, $type, $flat_mode = false) { // get all folders of specified type $folders = kolab_storage::list_folders('', '*', $type, false, $typedata); // get folders activesync config $folderdata = $this->folder_meta(); if (!is_array($folders) || !is_array($folderdata)) { return false; } $folders_list = []; // check if folders are "subscribed" for activesync foreach ($folderdata as $folder => $meta) { if (empty($meta['FOLDER']) || empty($meta['FOLDER'][$deviceid]) || empty($meta['FOLDER'][$deviceid]['S']) ) { continue; } // force numeric folder name to be a string (T1283) $folder = (string) $folder; if (!empty($type) && !in_array($folder, $folders)) { continue; } // Activesync folder identifier (serverId) $folder_type = !empty($typedata[$folder]) ? $typedata[$folder] : 'mail'; $folder_id = $this->folder_id($folder, $folder_type); $folders_list[$folder_id] = $this->folder_data($folder, $folder_type); } if ($flat_mode) { $folders_list = $this->folders_list_flat($folders_list, $type, $typedata); } return $folders_list; } /** * Converts list of folders to a "flat" list */ protected function folders_list_flat($folders, $type, $typedata) { $delim = $this->storage->get_hierarchy_delimiter(); foreach ($folders as $idx => $folder) { if ($folder['parentId']) { // for non-mail folders we make the list completely flat if ($type != self::MODEL_EMAIL) { $display_name = kolab_storage::object_name($folder['imap_name']); $display_name = html_entity_decode($display_name, ENT_COMPAT, RCUBE_CHARSET); $folders[$idx]['parentId'] = 0; $folders[$idx]['displayName'] = $display_name; } // for mail folders we modify only folders with non-existing parents elseif (!isset($folders[$folder['parentId']])) { $items = explode($delim, $folder['imap_name']); $parent = 0; // find existing parent while (count($items) > 0) { array_pop($items); $parent_name = implode($delim, $items); $parent_type = !empty($typedata[$parent_name]) ? $typedata[$parent_name] : 'mail'; $parent_id = $this->folder_id($parent_name, $parent_type); if (isset($folders[$parent_id])) { $parent = $parent_id; break; } } if (!$parent) { $display_name = kolab_storage::object_name($folder['imap_name']); $display_name = html_entity_decode($display_name, ENT_COMPAT, RCUBE_CHARSET); } else { $parent_name = isset($parent_id) ? $folders[$parent_id]['imap_name'] : ''; $display_name = substr($folder['imap_name'], strlen($parent_name) + 1); $display_name = rcube_charset::convert($display_name, 'UTF7-IMAP'); $display_name = str_replace($delim, ' ยป ', $display_name); } $folders[$idx]['parentId'] = $parent; $folders[$idx]['displayName'] = $display_name; } } } return $folders; } /** * Getter for folder metadata * * @return array|bool Hash array with meta data for each folder, False on backend failure */ protected function folder_meta() { if (!isset($this->folder_meta)) { // get folders activesync config $folderdata = $this->storage->get_metadata("*", self::ASYNC_KEY); if (!is_array($folderdata)) { return $this->folder_meta = false; } $this->folder_meta = []; foreach ($folderdata as $folder => $meta) { if (isset($meta[self::ASYNC_KEY])) { if ($metadata = $this->unserialize_metadata($meta[self::ASYNC_KEY])) { $this->folder_meta[$folder] = $metadata; } } } } return $this->folder_meta; } /** * Creates folder and subscribes to the device * * @param string $name Folder name (UTF8) * @param int $type Folder (ActiveSync) type * @param string $deviceid Device identifier * @param ?string $parentid Parent folder id identifier * * @return string|false New folder identifier on success, False on failure */ public function folder_create($name, $type, $deviceid, $parentid = null) { $parent = null; $name = rcube_charset::convert($name, kolab_sync::CHARSET, 'UTF7-IMAP'); if ($parentid) { $parent = $this->folder_id2name($parentid, $deviceid); if ($parent === null) { throw new Syncroton_Exception_Status_FolderCreate(Syncroton_Exception_Status_FolderCreate::PARENT_NOT_FOUND); } } if ($parent !== null) { $delim = $this->storage->get_hierarchy_delimiter(); $name = $parent . $delim . $name; } if ($this->storage->folder_exists($name)) { throw new Syncroton_Exception_Status_FolderCreate(Syncroton_Exception_Status_FolderCreate::FOLDER_EXISTS); } $type = self::type_activesync2kolab($type); $created = kolab_storage::folder_create($name, $type, true); if ($created) { // Set ActiveSync subscription flag $this->folder_set($name, $deviceid, 1); return $this->folder_id($name, $type); } // Special case when client tries to create a subfolder of INBOX // which is not possible on Cyrus-IMAP (T2223) if ($parent === 'INBOX' && stripos($this->last_error(), 'invalid') !== false) { throw new Syncroton_Exception_Status_FolderCreate(Syncroton_Exception_Status_FolderCreate::SPECIAL_FOLDER); } return false; } /** * Renames a folder * * @param string $folderid Folder identifier * @param string $deviceid Device identifier * @param string $new_name New folder name (UTF8) * @param ?string $parentid Folder parent identifier * * @return bool True on success, False on failure */ public function folder_rename($folderid, $deviceid, $new_name, $parentid) { $old_name = $this->folder_id2name($folderid, $deviceid); if ($parentid) { $parent = $this->folder_id2name($parentid, $deviceid); } $name = rcube_charset::convert($new_name, kolab_sync::CHARSET, 'UTF7-IMAP'); if (isset($parent)) { $delim = $this->storage->get_hierarchy_delimiter(); $name = $parent . $delim . $name; } // Rename/move IMAP folder if ($name === $old_name) { return true; } $this->folder_meta = null; // TODO: folder type change? $type = kolab_storage::folder_type($old_name); // don't use kolab_storage for moving mail folders if (preg_match('/^mail/', $type)) { return $this->storage->rename_folder($old_name, $name); } else { return kolab_storage::folder_rename($old_name, $name); } } /** * Deletes folder * * @param string $folderid Folder identifier * @param string $deviceid Device identifier * * @return bool True on success, False otherwise */ public function folder_delete($folderid, $deviceid) { $name = $this->folder_id2name($folderid, $deviceid); $type = kolab_storage::folder_type($name); unset($this->folder_meta[$name]); // don't use kolab_storage for deleting mail folders if (preg_match('/^mail/', $type)) { return $this->storage->delete_folder($name); } return kolab_storage::folder_delete($name); } /** * Deletes contents of a folder * * @param string $folderid Folder identifier * @param string $deviceid Device identifier * @param bool $recursive Apply to the folder and its subfolders * * @return bool True on success, False otherwise */ public function folder_empty($folderid, $deviceid, $recursive = false) { $foldername = $this->folder_id2name($folderid, $deviceid); // Remove all entries if (!$this->storage->clear_folder($foldername)) { return false; } // Remove subfolders if ($recursive) { $delim = $this->storage->get_hierarchy_delimiter(); $folderdata = $this->folder_meta(); if (!is_array($folderdata)) { return false; } foreach ($folderdata as $subfolder => $meta) { if (!empty($meta['FOLDER'][$deviceid]['S']) && strpos((string) $subfolder, $foldername . $delim)) { if (!$this->storage->clear_folder((string) $subfolder)) { return false; } } } } return true; } /** * Sets ActiveSync subscription flag on a folder * * @param string $name Folder name (UTF7-IMAP) * @param string $deviceid Device identifier * @param int $flag Flag value (0|1|2) * * @return bool True on success, False on failure */ protected function folder_set($name, $deviceid, $flag) { if (empty($deviceid)) { return false; } // get folders activesync config $metadata = $this->folder_meta(); if (!is_array($metadata)) { return false; } $metadata = $metadata[$name] ?? []; if ($flag) { if (empty($metadata)) { $metadata = []; } if (empty($metadata['FOLDER'])) { $metadata['FOLDER'] = []; } if (empty($metadata['FOLDER'][$deviceid])) { $metadata['FOLDER'][$deviceid] = []; } // Z-Push uses: // 1 - synchronize, no alarms // 2 - synchronize with alarms $metadata['FOLDER'][$deviceid]['S'] = $flag; } else { unset($metadata['FOLDER'][$deviceid]['S']); if (empty($metadata['FOLDER'][$deviceid])) { unset($metadata['FOLDER'][$deviceid]); } if (empty($metadata['FOLDER'])) { unset($metadata['FOLDER']); } if (empty($metadata)) { $metadata = null; } } // Return if nothing's been changed if (!self::data_array_diff($this->folder_meta[$name] ?? null, $metadata)) { return true; } $this->folder_meta[$name] = $metadata; return $this->storage->set_metadata($name, [self::ASYNC_KEY => $this->serialize_metadata($metadata)]); } /** * Returns device metadata * * @param string $id Device ID * * @return array|null Device metadata */ public function device_get($id) { $devices_list = $this->devices_list(); return $devices_list[$id] ?? null; } /** * Registers new device on server * * @param array $device Device data * @param string $id Device ID * * @return bool True on success, False on failure */ public function device_create($device, $id) { // Fill local cache $this->devices_list(); // Some devices create dummy devices with name "validate" (#1109) // This device entry is used in two initial requests, but later // the device registers a real name. We can remove this dummy entry // on new device creation $this->device_delete('validate'); // Old Kolab_ZPush device parameters // MODE: -1 | 0 | 1 (not set | flatmode | foldermode) // TYPE: device type string // ALIAS: user-friendly device name // Syncroton (kolab_sync_backend_device) uses // ID: internal identifier in syncroton database // TYPE: device type string // ALIAS: user-friendly device name $metadata = $this->root_meta; $metadata['DEVICE'][$id] = $device; $metadata = [self::ASYNC_KEY => $this->serialize_metadata($metadata)]; $result = $this->storage->set_metadata(self::ROOT_MAILBOX, $metadata); if ($result) { // Update local cache $this->root_meta['DEVICE'][$id] = $device; // subscribe default set of folders $this->device_init_subscriptions($id); } return $result; } /** * Device update. * * @param array $device Device data * @param string $id Device ID * * @return bool True on success, False on failure */ public function device_update($device, $id) { $devices_list = $this->devices_list(); $old_device = $devices_list[$id]; if (!$old_device) { return false; } // Do nothing if nothing is changed if (!self::data_array_diff($old_device, $device)) { return true; } $device = array_merge($old_device, $device); $metadata = $this->root_meta; $metadata['DEVICE'][$id] = $device; $metadata = [self::ASYNC_KEY => $this->serialize_metadata($metadata)]; $result = $this->storage->set_metadata(self::ROOT_MAILBOX, $metadata); if ($result) { // Update local cache $this->root_meta['DEVICE'][$id] = $device; } return $result; } /** * Device delete. * * @param string $id Device ID * * @return bool True on success, False on failure */ public function device_delete($id) { $device = $this->device_get($id); if (!$device) { return false; } unset($this->root_meta['DEVICE'][$id], $this->root_meta['FOLDER'][$id]); if (empty($this->root_meta['DEVICE'])) { unset($this->root_meta['DEVICE']); } if (empty($this->root_meta['FOLDER'])) { unset($this->root_meta['FOLDER']); } $metadata = $this->serialize_metadata($this->root_meta); $metadata = [self::ASYNC_KEY => $metadata]; // update meta data $result = $this->storage->set_metadata(self::ROOT_MAILBOX, $metadata); if ($result) { // remove device annotation for every folder foreach ($this->folder_meta() as $folder => $meta) { // skip root folder (already handled above) if ($folder == self::ROOT_MAILBOX) { continue; } if (!empty($meta['FOLDER']) && isset($meta['FOLDER'][$id])) { unset($meta['FOLDER'][$id]); if (empty($meta['FOLDER'])) { unset($this->folder_meta[$folder]['FOLDER']); unset($meta['FOLDER']); } if (empty($meta)) { unset($this->folder_meta[$folder]); $meta = null; } $metadata = [self::ASYNC_KEY => $this->serialize_metadata($meta)]; $res = $this->storage->set_metadata($folder, $metadata); if ($res && $meta) { $this->folder_meta[$folder] = $meta; } } } } return $result; } /** * Creates an item in a folder. * * @param string $folderid Folder identifier * @param string $deviceid Device identifier * @param string $type Activesync model name (folder type) * @param string|array $data Object data (string for email, array for other types) * @param array $params Additional parameters (e.g. mail flags) * * @return string|null Item UID on success or null on failure */ public function createItem($folderid, $deviceid, $type, $data, $params = []) { if ($type == self::MODEL_EMAIL) { $foldername = $this->folder_id2name($folderid, $deviceid); $uid = $this->storage->save_message($foldername, $data, '', false, $params['flags'] ?? []); if (!$uid) { // $this->logger->error("Error while storing the message " . $this->storage->get_error_str()); } return $uid; } $useTags = $this->relationSupport && ($type == self::MODEL_TASKS || $type == self::MODEL_NOTES); // convert categories into tags, save them after creating an object if ($useTags && !empty($data['categories'])) { $tags = $data['categories']; unset($data['categories']); } $folder = $this->getFolder($folderid, $deviceid, $type); // Set User-Agent for saved objects $app = kolab_sync::get_instance(); $app->config->set('useragent', $app->app_name . ' ' . kolab_sync::VERSION); if ($folder && $folder->valid && $folder->save($data)) { if (!empty($tags) && ($type == self::MODEL_TASKS || $type == self::MODEL_NOTES)) { $this->setCategories($data['uid'], $tags); } return $data['uid']; } return null; } /** * Deletes an item from a folder by UID. * * @param string $folderid Folder identifier * @param string $deviceid Device identifier * @param string $type Activesync model name (folder type) * @param string $uid Requested object UID * @param bool $moveToTrash Move to trash, instead of delete (for mail messages only) * * @return bool True on success, False on failure */ public function deleteItem($folderid, $deviceid, $type, $uid, $moveToTrash = false) { if ($type == self::MODEL_EMAIL) { $foldername = $this->folder_id2name($folderid, $deviceid); $trash = kolab_sync::get_instance()->config->get('trash_mbox'); // move message to the Trash folder if ($moveToTrash && strlen($trash) && $trash != $foldername && $this->storage->folder_exists($trash)) { return $this->storage->move_message($uid, $trash, $foldername); } // delete the message // According to the ActiveSync spec. "If the DeletesAsMoves element is set to false, // the deletion is PERMANENT.", therefore we delete the message, and not flag as deleted. // FIXME: We could consider acting according to the 'flag_for_deletion' setting. // Don't forget about 'read_when_deleted' setting then. // $this->storage->set_flag($uid, 'DELETED', $foldername); // $this->storage->set_flag($uid, 'SEEN', $foldername); return $this->storage->delete_message($uid, $foldername); } $useTags = $this->relationSupport && ($type == self::MODEL_TASKS || $type == self::MODEL_NOTES); $folder = $this->getFolder($folderid, $deviceid, $type); if (!$folder || !$folder->valid) { throw new Syncroton_Exception_Status(Syncroton_Exception_Status::SERVER_ERROR); } if ($folder->delete($uid)) { if ($useTags) { $this->setCategories($uid, []); } return true; } return false; } /** * Updates an item in a folder. * * @param string $folderid Folder identifier * @param string $deviceid Device identifier * @param string $type Activesync model name (folder type) * @param string $uid Object UID * @param string|array $data Object data (string for email, array for other types) * @param array $params Additional parameters (e.g. mail flags) * * @return string|null Item UID on success or null on failure */ public function updateItem($folderid, $deviceid, $type, $uid, $data, $params = []) { if ($type == self::MODEL_EMAIL) { $foldername = $this->folder_id2name($folderid, $deviceid); // Note: We do not support a message body update, as it's not needed foreach (($params['flags'] ?? []) as $flag) { $this->storage->set_flag($uid, $flag, $foldername); } // Categories (Tags) change if (isset($params['categories']) && $this->relationSupport) { $message = new rcube_message($uid, $foldername); if (empty($message->headers)) { throw new Syncroton_Exception_Status_Sync(Syncroton_Exception_Status_Sync::SYNC_SERVER_ERROR); } $this->setCategories($message, $params['categories']); } return $uid; } $folder = $this->getFolder($folderid, $deviceid, $type); $useTags = $this->relationSupport && ($type == self::MODEL_TASKS || $type == self::MODEL_NOTES); // convert categories into tags, save them after updating an object if ($useTags && array_key_exists('categories', $data)) { $tags = (array) $data['categories']; unset($data['categories']); } // Set User-Agent for saved objects $app = kolab_sync::get_instance(); $app->config->set('useragent', $app->app_name . ' ' . kolab_sync::VERSION); if ($folder && $folder->valid && $folder->save($data, $type, $uid)) { if (isset($tags)) { $this->setCategories($uid, $tags); } return $uid; } return null; } /** * Returns list of categories assigned to an object * * @param object|string $object UID or rcube_message object * @param array $categories Addition tag names to merge with * * @return array List of categories */ public function getCategories($object, $categories = []) { if (is_object($object)) { // support only messages with message-id if (!($msg_id = $object->headers->get('message-id', false))) { return []; } $config = kolab_storage_config::get_instance(); $delta = Syncroton_Registry::getPingTimeout(); $folder = $object->folder; $uid = $object->uid; // get tag objects raleted to specified message-id $tags = $config->get_tags($msg_id); foreach ($tags as $idx => $tag) { // resolve members if it wasn't done recently $force = empty($this->tag_rts[$tag['uid']]) || $this->tag_rts[$tag['uid']] <= time() - $delta; $members = $config->resolve_members($tag, $force); if (empty($members[$folder]) || !in_array($uid, $members[$folder])) { unset($tags[$idx]); } if ($force) { $this->tag_rts[$tag['uid']] = time(); } } // make sure current folder is set correctly again $this->storage->set_folder($folder); } else { $config = kolab_storage_config::get_instance(); $tags = $config->get_tags($object); } $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; } /** * Gets kolab_storage_folder object from Activesync folder ID. * * @param string $folderid Folder identifier * @param string $deviceid Device identifier * @param string $type Activesync model name (folder type) * * @return ?kolab_storage_folder */ public function getFolder($folderid, $deviceid, $type) { $unique_key = "$folderid:$deviceid:$type"; if (array_key_exists($unique_key, $this->folders)) { return $this->folders[$unique_key]; } $foldername = $this->folder_id2name($folderid, $deviceid); return $this->folders[$unique_key] = kolab_storage::get_folder($foldername, $type); } /** * Gets Activesync preferences for a folder. * * @param string $folderid Folder identifier * @param string $deviceid Device identifier * @param string $type Activesync model name (folder type) * * @return array Folder preferences */ public function getFolderConfig($folderid, $deviceid, $type) { $foldername = $this->folder_id2name($folderid, $deviceid); $metadata = $this->folder_meta(); $config = []; if (!empty($metadata[$foldername]['FOLDER'][$deviceid])) { $config = $metadata[$foldername]['FOLDER'][$deviceid]; } return [ 'ALARMS' => ($config['S'] ?? 0) == 2, ]; } /** * Gets an item from a folder by UID. * * @param string $folderid Folder identifier * @param string $deviceid Device identifier * @param string $type Activesync model name (folder type) * @param string $uid Requested object UID * * @return array|rcube_message|null Object properties */ public function getItem($folderid, $deviceid, $type, $uid) { if ($type == self::MODEL_EMAIL) { $foldername = $this->folder_id2name($folderid, $deviceid); $message = new rcube_message($uid, $foldername); if (!empty($message->headers)) { if ($this->relationSupport) { $message->headers->others['categories'] = $this->getCategories($message); } return $message; } return null; } $folder = $this->getFolder($folderid, $deviceid, $type); if (!$folder || !$folder->valid) { throw new Syncroton_Exception_Status(Syncroton_Exception_Status::SERVER_ERROR); } $result = $folder->get_object($uid); if ($result === false) { throw new Syncroton_Exception_Status(Syncroton_Exception_Status::SERVER_ERROR); } $useTags = $this->relationSupport && ($type == self::MODEL_TASKS || $type == self::MODEL_NOTES); if ($useTags) { $result['categories'] = $this->getCategories($uid, $result['categories'] ?? []); } return $result; } /** * Gets items matching UID by prefix. * * @param string $folderid Folder identifier * @param string $deviceid Device identifier * @param string $type Activesync model name (folder type) * @param string $uid Requested object UID prefix * * @return array|iterable List of objects */ public function getItemsByUidPrefix($folderid, $deviceid, $type, $uid) { $folder = $this->getFolder($folderid, $deviceid, $type); if (!$folder || !$folder->valid) { throw new Syncroton_Exception_Status(Syncroton_Exception_Status::SERVER_ERROR); } $result = $folder->select([['uid', '~*', $uid]]); if ($result === null) { throw new Syncroton_Exception_Status(Syncroton_Exception_Status::SERVER_ERROR); } return $result; } /** * Move an item from one folder to another. * * @param string $srcFolderId Source folder identifier * @param string $deviceid Device identifier * @param string $type Activesync model name (folder type) * @param string $uid Object UID * @param string $dstFolderId Destination folder identifier * * @return string New object UID * @throws Syncroton_Exception_Status */ public function moveItem($srcFolderId, $deviceid, $type, $uid, $dstFolderId) { if ($type === self::MODEL_EMAIL) { $src_name = $this->folder_id2name($srcFolderId, $deviceid); $dst_name = $this->folder_id2name($dstFolderId, $deviceid); if ($dst_name === null) { throw new Syncroton_Exception_Status_MoveItems(Syncroton_Exception_Status_MoveItems::INVALID_DESTINATION); } if ($src_name === null) { throw new Syncroton_Exception_Status_MoveItems(Syncroton_Exception_Status_MoveItems::INVALID_SOURCE); } if (!$this->storage->move_message($uid, $dst_name, $src_name)) { throw new Syncroton_Exception_Status_MoveItems(Syncroton_Exception_Status_MoveItems::INVALID_DESTINATION); } // Use COPYUID feature (RFC2359) to get the new UID of the copied message if (empty($this->storage->conn->data['COPYUID'])) { throw new Syncroton_Exception_Status(Syncroton_Exception_Status::SERVER_ERROR); } return $this->storage->conn->data['COPYUID'][1]; } $srcFolder = $this->getFolder($srcFolderId, $deviceid, $type); $dstFolder = $this->getFolder($dstFolderId, $deviceid, $type); if (!$srcFolder || !$dstFolder) { throw new Syncroton_Exception_Status_MoveItems(Syncroton_Exception_Status_MoveItems::INVALID_DESTINATION); } if (!$srcFolder->move($uid, $dstFolder)) { throw new Syncroton_Exception_Status_MoveItems(Syncroton_Exception_Status_MoveItems::INVALID_SOURCE); } return $uid; } /** * Set categories to an object * * @param object|string $object UID or rcube_message object * @param array $categories List of Category names */ public function setCategories($object, $categories) { if (!is_object($object)) { $config = kolab_storage_config::get_instance(); $config->save_tags($object, $categories); return; } $config = kolab_storage_config::get_instance(); $delta = Syncroton_Registry::getPingTimeout(); $uri = kolab_storage_config::get_message_uri($object->headers, $object->folder); // for all tag objects... foreach ($config->get_tags() as $relation) { // resolve members if it wasn't done recently $uid = $relation['uid']; $force = empty($this->tag_rts[$uid]) || $this->tag_rts[$uid] <= time() - $delta; if ($force) { $config->resolve_members($relation, $force); $this->tag_rts[$relation['uid']] = time(); } $selected = !empty($categories) && in_array($relation['name'], $categories); $found = !empty($relation['members']) && in_array($uri, $relation['members']); $update = false; // remove member from the relation if ($found && !$selected) { $relation['members'] = array_diff($relation['members'], (array) $uri); $update = true; } // add member to the relation elseif (!$found && $selected) { $relation['members'][] = $uri; $update = true; } if ($update) { $config->save($relation, 'relation'); } $categories = array_diff($categories, (array) $relation['name']); } // create new relations if (!empty($categories)) { foreach ($categories as $tag) { $relation = [ 'name' => $tag, 'members' => (array) $uri, 'category' => 'tag', ]; $config->save($relation, 'relation'); } } // make sure current folder is set correctly again $this->storage->set_folder($object->folder); } /** * Search for existing objects in a folder * * @param string $folderid Folder identifier * @param string $deviceid Device identifier * @param string $device_key Device primary key * @param string $type Activesync model name (folder type) * @param array $filter Filter * @param int $result_type Type of the result (see kolab_sync_data::RESULT_* constants) * @param bool $force Force IMAP folder cache synchronization * @param string $extraData Extra data as extracted by the getExtraData during the last sync * * @return array|int Search result as count or array of uids */ public function searchEntries($folderid, $deviceid, $device_key, $type, $filter, $result_type, $force, $extraData) { if ($type != self::MODEL_EMAIL) { return $this->searchKolabEntries($folderid, $deviceid, $device_key, $type, $filter, $result_type, $force); } $filter_str = 'ALL UNDELETED'; $getChangesMode = false; // convert filter into one IMAP search string foreach ($filter as $idx => $filter_item) { if (is_array($filter_item)) { if ($filter_item[0] == 'changed' && $filter_item[1] == '>') { $getChangesMode = true; } } else { $filter_str .= ' ' . $filter_item; } } $result = $result_type == kolab_sync_data::RESULT_COUNT ? 0 : []; $foldername = $this->folder_id2name($folderid, $deviceid); if ($foldername === null) { return $result; } $this->storage->set_folder($foldername); // Synchronize folder (if it wasn't synced in this request already) if ($force) { $this->storage->folder_sync($foldername); } $modified = true; // We're in "get changes" mode if ($getChangesMode) { $folder_data = $this->storage->folder_data($foldername); // If HIGHESTMODSEQ doesn't exist we can't get changes if (!empty($folder_data['HIGHESTMODSEQ'])) { // Store modseq for later in getExtraData if (!array_key_exists($deviceid, $this->modseq)) { $this->modseq[$deviceid] = []; } $this->modseq[$deviceid][$folderid] = $folder_data['HIGHESTMODSEQ']; // After the initial sync we have no extraData if ($extraData) { $modseq_old = json_decode($extraData)->modseq; // Skip search if HIGHESTMODSEQ didn't change if ($folder_data['HIGHESTMODSEQ'] == $modseq_old) { $modified = false; } else { $filter_str .= " MODSEQ " . ($modseq_old + 1); } } else { // If we don't have extra data we can't search for changes. // Either we are in initial sync, which means there are no changes to find, // or we are in the migration (no previous extraData), in which case we ignore changes for one sync key // because we don't have the means to search for the changes. Going forward we'll have the modseq info. $modified = false; } } else { // We have no way of finding the changes. // We could fall back to search by date or ignore changes, but both seems suboptimal. throw new Syncroton_Exception_Status(Syncroton_Exception_Status::SERVER_ERROR); } } // We could use messages cache by replacing search() with index() // in some cases. This however is possible only if user has skip_deleted=true, // in his Roundcube preferences, otherwise we'd make often cache re-initialization, // because Roundcube message cache can work only with one skip_deleted // setting at a time. We'd also need to make sure folder_sync() was called // before (see above). // // if ($filter_str == 'ALL UNDELETED') // $search = $this->storage->index($foldername, null, null, true, true); // else if ($modified) { $search = $this->storage->search_once($foldername, $filter_str); if (!($search instanceof rcube_result_index) || $search->is_error()) { throw new Syncroton_Exception_Status(Syncroton_Exception_Status::SERVER_ERROR); } switch ($result_type) { case kolab_sync_data::RESULT_COUNT: $result = $search->count(); break; case kolab_sync_data::RESULT_UID: $result = $search->get(); break; } } // get members of modified relations if ($this->relationSupport) { $changed_msgs = $this->getChangesByRelations($folderid, $device_key, $type, $filter); // handle relation changes if (!empty($changed_msgs)) { $members = $this->findRelationMembersInFolder($foldername, $changed_msgs, $filter); switch ($result_type) { case kolab_sync_data::RESULT_COUNT: $result += count($members); break; case kolab_sync_data::RESULT_UID: $result = array_values(array_unique(array_merge($result, $members))); break; } } } return $result; } /** * Return extra data that is stored with the sync key and passed in during the search to find changes. * * @param string $folderid Folder identifier * @param string $deviceid Device identifier * * @return string|null Extra data (JSON-encoded) */ public function getExtraData($folderid, $deviceid) { //We explicitly return a cached value that was used during the search. //Otherwise we'd risk storing a higher modseq value and missing an update. if (isset($this->modseq[$deviceid][$folderid])) { return json_encode(['modseq' => intval($this->modseq[$deviceid][$folderid])]); } //If we didn't fetch modseq in the first place we have to fetch it now. $foldername = $this->folder_id2name($folderid, $deviceid); if ($foldername !== null) { $folder_data = $this->storage->folder_data($foldername); if (!empty($folder_data['HIGHESTMODSEQ'])) { return json_encode(['modseq' => intval($folder_data['HIGHESTMODSEQ'])]); } } return null; } /** * Search for existing objects in a folder * * @param string $folderid Folder identifier * @param string $deviceid Device identifier * @param string $device_key Device primary key * @param string $type Activesync model name (folder type) * @param array $filter Filter * @param int $result_type Type of the result (see kolab_sync_data::RESULT_* constants) * @param bool $force Force IMAP folder cache synchronization * * @return array|int Search result as count or array of uids */ protected function searchKolabEntries($folderid, $deviceid, $device_key, $type, $filter, $result_type, $force) { // there's a PHP Warning from kolab_storage if $filter isn't an array if (empty($filter)) { $filter = []; } elseif ($this->relationSupport && ($type == self::MODEL_TASKS || $type == self::MODEL_NOTES)) { $changed_objects = $this->getChangesByRelations($folderid, $device_key, $type, $filter); } $folder = $this->getFolder($folderid, $deviceid, $type); if (!$folder || !$folder->valid) { throw new Syncroton_Exception_Status(Syncroton_Exception_Status::SERVER_ERROR); } $error = false; switch ($result_type) { case kolab_sync_data::RESULT_COUNT: $count = $folder->count($filter); if ($count === null) { throw new Syncroton_Exception_Status(Syncroton_Exception_Status::SERVER_ERROR); } $result = (int) $count; break; case kolab_sync_data::RESULT_UID: default: $uids = $folder->get_uids($filter); if (!is_array($uids)) { throw new Syncroton_Exception_Status(Syncroton_Exception_Status::SERVER_ERROR); } $result = $uids; break; } // 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 = [['uid', '=', $changed_objects]]; foreach ($filter as $f) { if ($f[0] != 'changed') { $tag_filter[] = $f; } } switch ($result_type) { case kolab_sync_data::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) { $result += (int) $count; } break; case kolab_sync_data::RESULT_UID: default: $uids = $folder->get_uids($tag_filter); if (is_array($uids) && !empty($uids)) { $result = array_unique(array_merge($result, $uids)); } break; } } return $result; } /** * Find members (messages) in specified folder */ protected function findRelationMembersInFolder($foldername, $members, $filter) { foreach ($members as $member) { // IMAP URI members if ($url = kolab_storage_config::parse_member_url($member)) { $result[$url['folder']][$url['uid']] = $url['params']; } } // convert filter into one IMAP search string $filter_str = 'ALL UNDELETED'; foreach ($filter as $filter_item) { if (is_string($filter_item)) { $filter_str .= ' ' . $filter_item; } } $found = []; // first find messages by UID if (!empty($result[$foldername])) { $index = $this->storage->search_once($foldername, 'UID ' . rcube_imap_generic::compressMessageSet(array_keys($result[$foldername]))); $found = $index->get(); // remove found messages from the $result if (!empty($found)) { $result[$foldername] = array_diff_key($result[$foldername], array_flip($found)); if (empty($result[$foldername])) { unset($result[$foldername]); } // now apply the current filter to the found messages $index = $this->storage->search_once($foldername, $filter_str . ' UID ' . rcube_imap_generic::compressMessageSet($found)); $found = $index->get(); } } // search by message parameters if (!empty($result)) { // @TODO: do this search in chunks (for e.g. 25 messages)? $search = ''; $search_count = 0; foreach ($result as $data) { foreach ($data as $p) { $search_params = []; $search_count++; foreach ($p as $key => $val) { $key = strtoupper($key); // don't search by subject, we don't want false-positives if ($key != 'SUBJECT') { $search_params[] = 'HEADER ' . $key . ' ' . rcube_imap_generic::escape($val); } } $search .= ' (' . implode(' ', $search_params) . ')'; } } $search_str = str_repeat(' OR', $search_count - 1) . $search; // search messages in current folder $search = $this->storage->search_once($foldername, $search_str); $uids = $search->get(); if (!empty($uids)) { // add UIDs into the result $found = array_unique(array_merge($found, $uids)); } } return $found; } /** * Detect changes of relation (tag) objects data and assigned objects * Returns relation member identifiers */ protected function getChangesByRelations($folderid, $device_key, $type, $filter) { // 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->relations_state_get($device_key, $folderid, $since); // get current relations state $config = kolab_storage_config::get_instance(); $default = true; $filter = [ ['type', '=', 'relation'], ['category', '=', 'tag'], ]; $relations = $config->get_objects($filter, $default, 100); $result = []; $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... elseif ($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... elseif ($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 = []; foreach ($relations as $relation) { $data[$relation['uid']] = [ 'name' => $relation['name'], 'changed' => $relation['changed']->format('U'), 'members' => implode("\n", (array)$relation['members']), ]; } $now = new DateTime('now', new DateTimeZone('UTC')); $this->relations_state_set($device_key, $folderid, $now, $data); } // in mail mode return only message URIs if ($type == self::MODEL_EMAIL) { // 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; } /** * Subscribe default set of folders on device registration */ protected function device_init_subscriptions($deviceid) { // INBOX always exists $this->folder_set('INBOX', $deviceid, 1); $supported_types = [ 'mail.drafts', 'mail.wastebasket', 'mail.sentitems', 'mail.outbox', 'event.default', 'contact.default', 'note.default', 'task.default', 'event', 'contact', 'note', 'task', 'event.confidential', 'event.private', 'task.confidential', 'task.private', ]; $rcube = rcube::get_instance(); $config = $rcube->config; $mode = (int) $config->get('activesync_init_subscriptions'); $folders = []; // Subscribe to default folders $foldertypes = kolab_storage::folders_typedata(); if (!empty($foldertypes)) { $_foldertypes = array_intersect($foldertypes, $supported_types); // get default folders foreach ($_foldertypes as $folder => $type) { // only personal folders if ($this->storage->folder_namespace($folder) == 'personal') { $flag = preg_match('/^(event|task)/', $type) ? 2 : 1; $this->folder_set($folder, $deviceid, $flag); $folders[] = $folder; } } } // we're in default mode, exit if (!$mode) { return; } // below we support additionally all mail folders $supported_types[] = 'mail'; $supported_types[] = 'mail.junkemail'; // get configured special folders $special_folders = []; $map = [ 'drafts' => 'mail.drafts', 'junk' => 'mail.junkemail', 'sent' => 'mail.sentitems', 'trash' => 'mail.wastebasket', ]; foreach ($map as $folder => $type) { if ($folder = $config->get($folder . '_mbox')) { $special_folders[$folder] = $type; } } // get folders list(s) if (($mode & self::INIT_ALL_PERSONAL) || ($mode & self::INIT_ALL_OTHER) || ($mode & self::INIT_ALL_SHARED)) { $all_folders = $this->storage->list_folders(); if (($mode & self::INIT_SUB_PERSONAL) || ($mode & self::INIT_SUB_OTHER) || ($mode & self::INIT_SUB_SHARED)) { $subscribed_folders = $this->storage->list_folders_subscribed(); } } else { $all_folders = $this->storage->list_folders_subscribed(); } foreach ($all_folders as $folder) { // folder already subscribed if (in_array($folder, $folders)) { continue; } $type = ($foldertypes[$folder] ?? null) ?: 'mail'; if ($type == 'mail' && isset($special_folders[$folder])) { $type = $special_folders[$folder]; } if (!in_array($type, $supported_types)) { continue; } $ns = strtoupper($this->storage->folder_namespace($folder)); // subscribe the folder according to configured mode // and folder namespace/subscription status if (($mode & constant("self::INIT_ALL_{$ns}")) || (($mode & constant("self::INIT_SUB_{$ns}")) && (!isset($subscribed_folders) || in_array($folder, $subscribed_folders))) ) { $flag = preg_match('/^(event|task)/', $type) ? 2 : 1; $this->folder_set($folder, $deviceid, $flag); } } } /** * Helper method to decode saved IMAP metadata */ protected function unserialize_metadata($str) { if (!empty($str)) { $data = json_decode($str, true); return $data; } return null; } /** * Helper method to encode IMAP metadata for saving */ protected function serialize_metadata($data) { if (!empty($data) && is_array($data)) { $data = json_encode($data); return $data; } return null; } /** * Returns Kolab folder type for specified ActiveSync type ID */ protected static function type_activesync2kolab($type) { if (!empty(self::$types[$type])) { return self::$types[$type]; } return ''; } /** * Returns ActiveSync folder type for specified Kolab type */ protected static function type_kolab2activesync($type) { $type = preg_replace('/\.(confidential|private)$/i', '', $type); if ($key = array_search($type, self::$types)) { return $key; } return key(self::$types); } /** * Returns folder data in Syncroton format */ protected function folder_data($folder, $type) { // Folder name parameters $delim = $this->storage->get_hierarchy_delimiter(); $items = explode($delim, $folder); $name = array_pop($items); // Folder UID $folder_id = $this->folder_id($folder, $type); // Folder type if (strcasecmp($folder, 'INBOX') === 0) { // INBOX is always inbox, prevent from issues related with a change of // folder type annotation (it can be initially unset). $as_type = 2; } else { $as_type = self::type_kolab2activesync($type); // fix type, if there's no type annotation it's detected as UNKNOWN we'll use 'mail' (12) if ($as_type == 1) { $as_type = 12; } } // Syncroton folder data array return [ 'serverId' => $folder_id, 'parentId' => count($items) ? $this->folder_id(implode($delim, $items), $type) : 0, 'displayName' => rcube_charset::convert($name, 'UTF7-IMAP', kolab_sync::CHARSET), 'type' => $as_type, // for internal use 'imap_name' => $folder, ]; } /** * Builds folder ID based on folder name */ protected function folder_id($name, $type = null) { // ActiveSync expects folder identifiers to be max.64 characters // So we can't use just folder name $name = (string) $name; if ($name === '') { return null; } if (isset($this->folder_uids[$name])) { return $this->folder_uids[$name]; } /* @TODO: For now uniqueid annotation doesn't work, we will create UIDs by ourselves. There's one inconvenience of this solution: folder name/type change would be handled in ActiveSync as delete + create. // get folders unique identifier $folderdata = $this->storage->get_metadata($name, self::UID_KEY); if ($folderdata && !empty($folderdata[$name])) { $uid = $folderdata[$name][self::UID_KEY]; return $this->folder_uids[$name] = $uid; } */ if (strcasecmp($name, 'INBOX') === 0) { // INBOX is always inbox, prevent from issues related with a change of // folder type annotation (it can be initially unset). $type = 'mail.inbox'; } else { if ($type === null) { $type = kolab_storage::folder_type($name); } if ($type != null) { $type = preg_replace('/\.(confidential|private)$/i', '', $type); } } // Add type to folder UID hash, so type change can be detected by Syncroton $uid = $name . '!!' . $type; $uid = md5($uid); return $this->folder_uids[$name] = $uid; } /** * Returns IMAP folder name * * @param string $id Folder identifier * @param string $deviceid Device dentifier * * @return string|null Folder name (UTF7-IMAP) */ public function folder_id2name($id, $deviceid) { // check in cache first if (!empty($this->folder_uids)) { if (($name = array_search($id, $this->folder_uids)) !== false) { return $name; } } /* @TODO: see folder_id() // get folders unique identifier $folderdata = $this->storage->get_metadata('*', self::UID_KEY); foreach ((array)$folderdata as $folder => $data) { if (!empty($data[self::UID_KEY])) { $uid = $data[self::UID_KEY]; $this->folder_uids[$folder] = $uid; if ($uid == $id) { $name = $folder; } } } */ // get all folders of specified type $folderdata = $this->folder_meta(); if (!is_array($folderdata) || empty($id)) { return null; } $name = null; // check if folders are "subscribed" for activesync foreach ($folderdata as $folder => $meta) { if (empty($meta['FOLDER']) || empty($meta['FOLDER'][$deviceid]) || empty($meta['FOLDER'][$deviceid]['S']) ) { continue; } if ($uid = $this->folder_id($folder)) { $this->folder_uids[$folder] = $uid; } if ($uid === $id) { $name = $folder; } } return $name; } /** * Set state of relation objects at specified point in time */ public function relations_state_set($device_key, $folderid, $synctime, $relations) { $synctime = $synctime->format('Y-m-d H:i:s'); $rcube = rcube::get_instance(); $db = $rcube->get_dbh(); $old_data = $this->relations[$folderid][$synctime] ?? null; if (empty($old_data)) { $this->relations[$folderid][$synctime] = $relations; $data = rcube_charset::clean(json_encode($relations)); $result = $db->query( "INSERT INTO `syncroton_relations_state`" . " (`device_id`, `folder_id`, `synctime`, `data`)" . " VALUES (?, ?, ?, ?)", $device_key, $folderid, $synctime, $data ); + if ($err = $db->is_error($result)) { throw new Exception("Failed to save relation: {$err}"); } } } /** * Get state of relation objects at specified point in time */ protected function relations_state_get($device_key, $folderid, $synctime) { $synctime = $synctime->format('Y-m-d H:i:s'); if (empty($this->relations[$folderid][$synctime])) { $this->relations[$folderid] = []; $rcube = rcube::get_instance(); $db = $rcube->get_dbh(); $db->limitquery( "SELECT `data`, `synctime` FROM `syncroton_relations_state`" . " WHERE `device_id` = ? AND `folder_id` = ? AND `synctime` <= ?" . " ORDER BY `synctime` DESC", 0, 1, $device_key, $folderid, $synctime ); if ($row = $db->fetch_assoc()) { $synctime = $row['synctime']; // @TODO: make sure synctime from sql is in "Y-m-d H:i:s" format $this->relations[$folderid][$synctime] = json_decode($row['data'], true); } // Cleanup: remove all records except the current one $db->query( "DELETE FROM `syncroton_relations_state`" . " WHERE `device_id` = ? AND `folder_id` = ? AND `synctime` <> ?", $device_key, $folderid, $synctime ); } return $this->relations[$folderid][$synctime] ?? null; } /** * Return last storage error */ public static function last_error() { return kolab_storage::$last_error; } /** * Compares two arrays * * @param array $array1 * @param array $array2 * * @return bool True if arrays differs, False otherwise */ protected static function data_array_diff($array1, $array2) { if (!is_array($array1) || !is_array($array2)) { return $array1 != $array2; } if (count($array1) != count($array2)) { return true; } foreach ($array1 as $key => $val) { if (!array_key_exists($key, $array2)) { return true; } if ($val !== $array2[$key]) { return true; } } return false; } }