// Token: 0x06001809 RID: 6153 RVA: 0x0008D7B8 File Offset: 0x0008B9B8 private void UpdateMapping(Dictionary <string, StoreObjectId> mapping) { FolderIdMapping folderIdMapping = (FolderIdMapping)this.folderIdMappingSyncState[CustomStateDatumType.IdMapping]; Dictionary <StoreObjectId, FolderStateEntry> data = ((GenericDictionaryData <StoreObjectIdData, StoreObjectId, FolderStateEntry>) this.syncState[SyncStateProp.ClientState]).Data; foreach (string text in mapping.Keys) { StoreObjectId storeObjectId = mapping[text]; folderIdMapping.Add(MailboxSyncItemId.CreateForNewItem(storeObjectId), text); if (data.ContainsKey(storeObjectId)) { FolderStateEntry folderStateEntry = data[storeObjectId]; if (folderStateEntry.ChangeKey.Length == 1 && folderStateEntry.ChangeKey[0] == 1) { folderStateEntry.ChangeTrackingHash = "blah".GetHashCode(); } else { folderStateEntry.ChangeTrackingHash = FolderCommand.ComputeChangeTrackingHash(this.mailboxSession, mapping[text], null); } } } folderIdMapping.CommitChanges(); StoreObjectId defaultFolderId = this.mailboxSession.GetDefaultFolderId(DefaultFolderType.Inbox); mapping.Add("EmailSyncFile", defaultFolderId); defaultFolderId = this.mailboxSession.GetDefaultFolderId(DefaultFolderType.Contacts); mapping.Add("ContactsSyncFile", defaultFolderId); defaultFolderId = this.mailboxSession.GetDefaultFolderId(DefaultFolderType.Calendar); mapping.Add("CalendarSyncFile", defaultFolderId); defaultFolderId = this.mailboxSession.GetDefaultFolderId(DefaultFolderType.Tasks); mapping.Add("TasksSyncFile", defaultFolderId); }
// Token: 0x06001805 RID: 6149 RVA: 0x0008D4A8 File Offset: 0x0008B6A8 public void UpdateLastFolderId(int folderId) { FolderIdMappingSyncStateInfo syncStateInfo = new FolderIdMappingSyncStateInfo(); this.folderIdMappingSyncState = this.syncStateStorage.GetCustomSyncState(syncStateInfo, new PropertyDefinition[0]); FolderIdMapping folderIdMapping = (FolderIdMapping)this.folderIdMappingSyncState[CustomStateDatumType.IdMapping]; folderIdMapping.IncreaseCounterTo((long)folderId); this.folderIdMappingSyncState.Commit(); }
// Token: 0x060009BF RID: 2495 RVA: 0x000395CC File Offset: 0x000377CC private static string GetOrAddSyncFolderId(SyncState folderIdMappingSyncState, StoreObjectId mailboxFolderId) { FolderIdMapping folderIdMapping = (FolderIdMapping)folderIdMappingSyncState[CustomStateDatumType.IdMapping]; FolderTree folderTree = (FolderTree)folderIdMappingSyncState[CustomStateDatumType.FullFolderTree]; MailboxSyncItemId mailboxSyncItemId = MailboxSyncItemId.CreateForNewItem(mailboxFolderId); string text = folderIdMapping[mailboxSyncItemId]; if (text == null) { text = folderIdMapping.Add(mailboxSyncItemId); folderTree.AddFolder(mailboxSyncItemId); } return(text); }
protected override void ProcessCommand(FolderCommand.FolderRequest folderRequest, XmlDocument doc) { string namespaceURI = doc.DocumentElement.NamespaceURI; DefaultFolderType defaultFolderType = base.MailboxSession.IsDefaultFolderType(folderRequest.ServerId); AirSyncPermanentException ex; if (defaultFolderType != DefaultFolderType.None) { base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "DeleteOfDefaultFolder"); ex = new AirSyncPermanentException(StatusCode.Sync_InvalidSyncKey, base.ConstructErrorXml(StatusCode.Sync_InvalidSyncKey), null, false); throw ex; } AggregateOperationResult aggregateOperationResult = base.MailboxSession.Delete(DeleteItemFlags.SoftDelete, new StoreObjectId[] { folderRequest.ServerId }); if (aggregateOperationResult.OperationResult != OperationResult.Failed) { base.FolderHierarchySync.RecordClientOperation(folderRequest.ServerId, ChangeType.Delete, null); folderRequest.RecoverySyncKey = folderRequest.SyncKey; folderRequest.SyncKey = base.GetNextNumber(folderRequest.SyncKey); base.SyncStateChanged = true; base.FolderHierarchySyncState[CustomStateDatumType.SyncKey] = new Int32Data(folderRequest.SyncKey); base.FolderHierarchySyncState[CustomStateDatumType.RecoverySyncKey] = new Int32Data(folderRequest.RecoverySyncKey); FolderIdMapping folderIdMapping = (FolderIdMapping)base.FolderIdMappingSyncState[CustomStateDatumType.IdMapping]; FolderTree folderTree = (FolderTree)base.FolderIdMappingSyncState[CustomStateDatumType.FullFolderTree]; MailboxSyncItemId folderId = MailboxSyncItemId.CreateForNewItem(folderRequest.ServerId); folderTree.RemoveFolderAndChildren(folderId, folderIdMapping); folderIdMapping.CommitChanges(); base.ProtocolLogger.IncrementValue("F", PerFolderProtocolLoggerData.ClientDeletes); XmlNode xmlNode = doc.CreateElement("Status", namespaceURI); xmlNode.InnerText = "1"; XmlNode xmlNode2 = doc.CreateElement("SyncKey", namespaceURI); xmlNode2.InnerText = folderRequest.SyncKey.ToString(CultureInfo.InvariantCulture); doc.DocumentElement.AppendChild(xmlNode); doc.DocumentElement.AppendChild(xmlNode2); return; } if (aggregateOperationResult.GroupOperationResults != null && aggregateOperationResult.GroupOperationResults.Length > 0 && aggregateOperationResult.GroupOperationResults[0] != null && aggregateOperationResult.GroupOperationResults[0].Exception is ObjectNotFoundException) { base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "DeleteOfNonExistentFolder"); ex = new AirSyncPermanentException(StatusCode.Sync_ProtocolError, base.ConstructErrorXml(StatusCode.Sync_ProtocolError), null, false); throw ex; } base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "DeleteFailed"); ex = new AirSyncPermanentException(StatusCode.Sync_ClientServerConversion, base.ConstructErrorXml(StatusCode.Sync_ClientServerConversion), null, false); throw ex; }
private bool RemoveFolderAndChildren(ISyncItemId folderId, FolderIdMapping folderIdMapping, int foldersSeen, int numberOfFoldersInTree) { FolderTree.FolderInfo folderInfo = this.GetFolderInfo(folderId); foldersSeen++; if (foldersSeen > numberOfFoldersInTree) { AirSyncDiagnostics.TraceError <int>(ExTraceGlobals.AlgorithmTracer, this, "Error: Loop detected in folder tree. NumberOfFoldersInTree: {0}", numberOfFoldersInTree); this.TraceTree(); return(false); } int num = 0; while (folderInfo.Children.Count > num) { ISyncItemId syncItemId = folderInfo.Children[num]; if (this.folderTree.ContainsKey(syncItemId)) { if (!this.RemoveFolderAndChildren(syncItemId, folderIdMapping, foldersSeen, numberOfFoldersInTree)) { return(false); } } else { num++; MailboxSyncItemId mailboxSyncItemId = syncItemId as MailboxSyncItemId; AirSyncDiagnostics.TraceError <string>(ExTraceGlobals.AlgorithmTracer, this, "FolderTree.RemoveFolderAndChildren could not find child folder: {0} to remove.", (mailboxSyncItemId == null) ? "<folder is not a MailboxSyncItemId>" : mailboxSyncItemId.ToString()); } } if (folderIdMapping.Contains(folderId)) { folderIdMapping.Delete(new ISyncItemId[] { folderId }); } this.RemoveFolder(folderId); return(true); }
// Token: 0x0600052E RID: 1326 RVA: 0x0001E8B4 File Offset: 0x0001CAB4 protected override void ProcessCommand(MailboxSession mailboxSession, XmlDocument doc) { if (base.CollectionRequest.CollectionId == null) { base.Context.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidURLParameters"); throw new AirSyncPermanentException(HttpStatusCode.BadRequest, StatusCode.InvalidCombinationOfIDs, null, false); } mailboxSession.Delete(DeleteItemFlags.SoftDelete, new StoreObjectId[] { base.CollectionRequest.CollectionId }); FolderIdMapping folderIdMapping = (FolderIdMapping)base.SyncState[CustomStateDatumType.IdMapping]; folderIdMapping.Delete(new ISyncItemId[] { MailboxSyncItemId.CreateForNewItem(base.CollectionRequest.CollectionId) }); XmlNode xmlNode = doc.CreateElement("Response", "FolderHierarchy:"); XmlNode xmlNode2 = doc.CreateElement("Status", "FolderHierarchy:"); xmlNode2.InnerText = "1"; doc.AppendChild(xmlNode); xmlNode.AppendChild(xmlNode2); }
// Token: 0x060008C8 RID: 2248 RVA: 0x00034B7C File Offset: 0x00032D7C protected override void ProcessCommand(FolderCommand.FolderRequest folderRequest, XmlDocument doc) { if (FolderCommand.IsEmptyOrWhiteSpacesOnly(folderRequest.DisplayName)) { base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "EmptyDisplayName"); AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_NotificationGUID, base.ConstructErrorXml(StatusCode.Sync_NotificationGUID), null, false); throw ex; } using (Folder folder = Folder.Create(base.MailboxSession, folderRequest.ParentId, StoreObjectType.Folder)) { string namespaceURI = doc.DocumentElement.NamespaceURI; folder.DisplayName = folderRequest.DisplayName; string classNameFromType = AirSyncUtility.GetClassNameFromType(folderRequest.Type); if (classNameFromType == null) { AirSyncPermanentException ex; if (!this.IsValidSpecialFolderType(base.Version, folderRequest.Type)) { base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidFolderType"); ex = new AirSyncPermanentException(StatusCode.Sync_NotificationGUID, base.ConstructErrorXml(StatusCode.Sync_NotificationGUID), null, false); throw ex; } base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "CreateOfSpecialFolder"); ex = new AirSyncPermanentException(StatusCode.Sync_InvalidSyncKey, base.ConstructErrorXml(StatusCode.Sync_InvalidSyncKey), null, false); throw ex; } else { folder.ClassName = classNameFromType; try { folder.Save(); folder.Load(); } catch (ObjectExistedException innerException) { base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "FolderExistsOnCreate"); AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, base.ConstructErrorXml(StatusCode.Sync_ProtocolVersionMismatch), innerException, false); throw ex; } catch (InvalidOperationException innerException2) { base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidOperationOnCreate"); AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_NotificationGUID, base.ConstructErrorXml(StatusCode.Sync_NotificationGUID), innerException2, false); throw ex; } catch (ObjectValidationException innerException3) { base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ObjectValidationOnCreate"); AirSyncPermanentException ex = new AirSyncPermanentException(StatusCode.Sync_ProtocolVersionMismatch, base.ConstructErrorXml(StatusCode.Sync_ProtocolVersionMismatch), innerException3, false); throw ex; } base.FolderHierarchySync.RecordClientOperation(folder.Id.ObjectId, ChangeType.Add, folder); folderRequest.RecoverySyncKey = folderRequest.SyncKey; folderRequest.SyncKey = base.GetNextNumber(folderRequest.SyncKey); base.SyncStateChanged = true; base.FolderHierarchySyncState[CustomStateDatumType.SyncKey] = new Int32Data(folderRequest.SyncKey); base.FolderHierarchySyncState[CustomStateDatumType.RecoverySyncKey] = new Int32Data(folderRequest.RecoverySyncKey); XmlNode xmlNode = doc.CreateElement("Status", namespaceURI); xmlNode.InnerText = "1"; XmlNode xmlNode2 = doc.CreateElement("SyncKey", namespaceURI); xmlNode2.InnerText = folderRequest.SyncKey.ToString(CultureInfo.InvariantCulture); XmlNode xmlNode3 = doc.CreateElement("ServerId", namespaceURI); FolderIdMapping folderIdMapping = (FolderIdMapping)base.FolderIdMappingSyncState[CustomStateDatumType.IdMapping]; ISyncItemId syncItemId = MailboxSyncItemId.CreateForNewItem(folder.Id.ObjectId); xmlNode3.InnerText = folderIdMapping.Add(syncItemId); folderIdMapping.CommitChanges(); doc.DocumentElement.AppendChild(xmlNode); doc.DocumentElement.AppendChild(xmlNode2); doc.DocumentElement.AppendChild(xmlNode3); FolderTree folderTree = (FolderTree)base.FolderIdMappingSyncState[CustomStateDatumType.FullFolderTree]; folderTree.AddFolder(syncItemId); if (!base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Root).Equals(folderRequest.ParentId)) { ISyncItemId parentId = MailboxSyncItemId.CreateForNewItem(folderRequest.ParentId); folderTree.LinkChildToParent(parentId, syncItemId); } base.ProtocolLogger.IncrementValue("F", PerFolderProtocolLoggerData.ClientAdds); } } }
// Token: 0x0600088E RID: 2190 RVA: 0x00032DC8 File Offset: 0x00030FC8 private void LoadSyncState(int syncKey) { FolderIdMappingSyncStateInfo syncStateInfo = new FolderIdMappingSyncStateInfo(); if (syncKey == 0) { base.SendServerUpgradeHeader = true; this.folderIdMappingSyncState = base.SyncStateStorage.GetCustomSyncState(syncStateInfo, new PropertyDefinition[0]); if (this.folderIdMappingSyncState == null || this.folderIdMappingSyncState[CustomStateDatumType.IdMapping] == null) { CustomSyncState customSyncState = base.SyncStateStorage.GetCustomSyncState(new GlobalSyncStateInfo(), new PropertyDefinition[0]); if (customSyncState == null) { AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "Could not find policy sync state. Deleting all sync states."); base.SyncStateStorage.DeleteAllSyncStates(); } else { customSyncState.Dispose(); using (FolderHierarchySyncState folderHierarchySyncState = base.SyncStateStorage.GetFolderHierarchySyncState()) { if (folderHierarchySyncState != null) { AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "Deleting all sync states."); base.SyncStateStorage.DeleteAllSyncStates(); } } } this.folderIdMappingSyncState = base.SyncStateStorage.CreateCustomSyncState(syncStateInfo); this.folderIdMappingSyncState[CustomStateDatumType.IdMapping] = new FolderIdMapping(); this.folderHierarchySyncState = base.SyncStateStorage.CreateFolderHierarchySyncState(); } else { AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "Deleting folder hierarchy sync state."); base.SyncStateStorage.DeleteFolderHierarchySyncState(); this.folderHierarchySyncState = base.SyncStateStorage.CreateFolderHierarchySyncState(); ((FolderIdMapping)this.folderIdMappingSyncState[CustomStateDatumType.IdMapping]).CommitChanges(); } this.folderIdMappingSyncState[CustomStateDatumType.FullFolderTree] = new FolderTree(); this.folderIdMappingSyncState[CustomStateDatumType.RecoveryFullFolderTree] = this.folderIdMappingSyncState[CustomStateDatumType.FullFolderTree]; base.InitializeSyncStatusSyncState(); base.SyncStatusSyncData.ClearClientCategoryHash(); this.shouldSaveSyncStatus = true; Interlocked.Exchange(ref this.validToCommitSyncStatusSyncState, 1); } else { this.folderIdMappingSyncState = base.SyncStateStorage.GetCustomSyncState(syncStateInfo, new PropertyDefinition[0]); this.folderHierarchySyncState = base.SyncStateStorage.GetFolderHierarchySyncState(); if (this.folderHierarchySyncState == null || this.folderIdMappingSyncState == null || this.folderIdMappingSyncState[CustomStateDatumType.IdMapping] == null) { base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "NoHierarchyState"); throw new AirSyncPermanentException(StatusCode.Sync_OutOfDisk, this.ConstructErrorXml(StatusCode.Sync_OutOfDisk), null, false); } FolderIdMapping folderIdMapping = (FolderIdMapping)this.folderIdMappingSyncState[CustomStateDatumType.IdMapping]; StoreObjectId defaultFolderId = base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Inbox); MailboxSyncItemId mailboxId = MailboxSyncItemId.CreateForNewItem(defaultFolderId); if (!folderIdMapping.Contains(mailboxId)) { base.SyncStateStorage.DeleteAllSyncStates(); base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InboxStoreObjectIdChanged"); throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.SyncStateCorrupt, new LocalizedString("The sync state is corrupt. It is most likely due to a recent mailbox migration."), false); } } if (this.folderHierarchySyncState.CustomVersion != null && this.folderHierarchySyncState.CustomVersion.Value > 5) { base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "SyncStateVersionMismatch"); throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.SyncStateVersionInvalid, EASServerStrings.MismatchSyncStateError, true); } }
// Token: 0x06000886 RID: 2182 RVA: 0x00032504 File Offset: 0x00030704 internal override Command.ExecutionState ExecuteCommand() { try { FolderCommand.FolderRequest folderRequest = this.ParseRequest(); XmlDocument xmlDocument = new SafeXmlDocument(); XmlNode newChild = xmlDocument.CreateElement(base.XmlRequest.LocalName, base.XmlRequest.NamespaceURI); xmlDocument.AppendChild(newChild); try { base.ProtocolLogger.SetValue("F", PerFolderProtocolLoggerData.ClientSyncKey, folderRequest.SyncKey); this.LoadSyncState(folderRequest.SyncKey); this.ConvertSyncIdsToXsoIds(folderRequest); this.folderHierarchySync = this.folderHierarchySyncState.GetFolderHierarchySync(new ChangeTrackingDelegate(FolderCommand.ComputeChangeTrackingHash)); if (folderRequest.SyncKey != 0) { if (!this.folderHierarchySyncState.Contains(CustomStateDatumType.SyncKey)) { base.ProtocolLogger.SetValue("F", PerFolderProtocolLoggerData.SyncType, "I"); base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "RecoveryNotAllowed"); throw new AirSyncPermanentException(StatusCode.Sync_OutOfDisk, this.ConstructErrorXml(StatusCode.Sync_OutOfDisk), null, false); } int data = this.folderHierarchySyncState.GetData <Int32Data, int>(CustomStateDatumType.SyncKey, -1); int data2 = this.folderHierarchySyncState.GetData <Int32Data, int>(CustomStateDatumType.RecoverySyncKey, -1); if (folderRequest.SyncKey != data && (!this.allowRecovery || folderRequest.SyncKey != data2)) { base.ProtocolLogger.SetValue("F", PerFolderProtocolLoggerData.SyncType, "I"); base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "InvalidSyncKey"); throw new AirSyncPermanentException(StatusCode.Sync_OutOfDisk, this.ConstructErrorXml(StatusCode.Sync_OutOfDisk), null, false); } FolderIdMapping folderIdMapping = (FolderIdMapping)this.folderIdMappingSyncState[CustomStateDatumType.IdMapping]; if (folderRequest.SyncKey == data) { AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "Committing folderIdMapping."); base.ProtocolLogger.SetValue("F", PerFolderProtocolLoggerData.SyncType, "S"); folderIdMapping.CommitChanges(); this.folderHierarchySync.AcknowledgeServerOperations(); } else { AirSyncDiagnostics.TraceDebug(ExTraceGlobals.RequestsTracer, this, "Clearing changes on folderIdMapping."); base.ProtocolLogger.SetValue("F", PerFolderProtocolLoggerData.SyncType, "R"); folderIdMapping.ClearChanges(); this.folderIdMappingSyncState[CustomStateDatumType.FullFolderTree] = this.folderIdMappingSyncState[CustomStateDatumType.RecoveryFullFolderTree]; } } else { base.ProtocolLogger.SetValue("F", PerFolderProtocolLoggerData.SyncType, "F"); base.SendServerUpgradeHeader = true; } this.ProcessCommand(folderRequest, xmlDocument); if (this.folderHierarchySyncState != null) { int data3 = this.folderHierarchySyncState.GetData <Int32Data, int>(CustomStateDatumType.AirSyncProtocolVersion, -1); if (base.Version > data3) { AirSyncDiagnostics.TraceDebug <int, int>(ExTraceGlobals.RequestsTracer, this, "Changing sync state protocol version from {0} to {1}.", data3, base.Version); this.folderHierarchySyncState[CustomStateDatumType.AirSyncProtocolVersion] = new Int32Data(base.Version); this.syncStateChanged = true; } } if (this.syncStateChanged) { if (this.folderHierarchySyncState != null) { this.folderHierarchySyncState.CustomVersion = new int?(5); this.folderHierarchySyncState.Commit(); } if (this.folderIdMappingSyncState != null) { FolderIdMapping folderIdMapping2 = this.folderIdMappingSyncState[CustomStateDatumType.IdMapping] as FolderIdMapping; FolderTree folderTree = this.folderIdMappingSyncState[CustomStateDatumType.FullFolderTree] as FolderTree; if (folderIdMapping2.IsDirty || folderTree.IsDirty) { this.folderIdMappingSyncState.Commit(); } } } } finally { if (this.folderIdMappingSyncState != null) { this.folderIdMappingSyncState.Dispose(); } if (this.folderHierarchySyncState != null) { this.folderHierarchySyncState.Dispose(); } } base.XmlResponse = xmlDocument; } catch (ObjectNotFoundException innerException) { base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "FolderNotFound"); throw new AirSyncPermanentException(StatusCode.Sync_ProtocolError, this.ConstructErrorXml(StatusCode.Sync_ProtocolError), innerException, false); } catch (CorruptDataException ex) { AirSyncUtility.ExceptionToStringHelper arg = new AirSyncUtility.ExceptionToStringHelper(ex); base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "CorruptData"); AirSyncDiagnostics.TraceDebug <AirSyncUtility.ExceptionToStringHelper>(ExTraceGlobals.RequestsTracer, this, "Corrupted data found, replacing error with wrongsynckey error to force client to refresh.\r\n{0}", arg); throw new AirSyncPermanentException(StatusCode.Sync_OutOfDisk, this.ConstructErrorXml(StatusCode.Sync_OutOfDisk), ex, false); } catch (QuotaExceededException) { throw; } catch (StoragePermanentException ex2) { base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, ex2.GetType().ToString()); throw new AirSyncPermanentException(StatusCode.Sync_ClientServerConversion, this.ConstructErrorXml(StatusCode.Sync_ClientServerConversion), ex2, false); } catch (ArgumentException innerException2) { base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ArgumentException"); throw new AirSyncPermanentException(StatusCode.Sync_NotificationGUID, this.ConstructErrorXml(StatusCode.Sync_NotificationGUID), innerException2, false); } catch (FormatException innerException3) { base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "FormatException"); throw new AirSyncPermanentException(StatusCode.Sync_NotificationGUID, this.ConstructErrorXml(StatusCode.Sync_NotificationGUID), innerException3, false); } return(Command.ExecutionState.Complete); }
// Token: 0x060008A6 RID: 2214 RVA: 0x00033214 File Offset: 0x00031414 protected override void ProcessCommand(FolderCommand.FolderRequest folderRequest, XmlDocument doc) { bool flag = folderRequest.SyncKey == 0; string namespaceURI = doc.DocumentElement.NamespaceURI; XmlNode xmlNode = doc.CreateElement("Status", namespaceURI); doc.DocumentElement.AppendChild(xmlNode); xmlNode.InnerText = "1"; base.DeviceSyncStateMetadata.RecordLatestFolderHierarchySnapshot(base.MailboxSession, base.Context); HierarchySyncOperations hierarchySyncOperations = base.FolderHierarchySync.EnumerateServerOperations(base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Root), false); if (hierarchySyncOperations.Count > 0) { folderRequest.RecoverySyncKey = folderRequest.SyncKey; folderRequest.SyncKey = base.GetNextNumber(folderRequest.SyncKey); base.FolderHierarchySyncState[CustomStateDatumType.SyncKey] = new Int32Data(folderRequest.SyncKey); if (folderRequest.RecoverySyncKey > 0) { base.FolderHierarchySyncState[CustomStateDatumType.RecoverySyncKey] = new Int32Data(folderRequest.RecoverySyncKey); base.FolderIdMappingSyncState[CustomStateDatumType.RecoveryFullFolderTree] = base.FolderIdMappingSyncState[CustomStateDatumType.FullFolderTree]; } base.SyncStateChanged = true; } XmlNode xmlNode2 = doc.CreateElement("SyncKey", namespaceURI); doc.DocumentElement.AppendChild(xmlNode2); xmlNode2.InnerText = folderRequest.SyncKey.ToString(CultureInfo.InvariantCulture); Dictionary <ISyncItemId, XmlNode> dictionary = new Dictionary <ISyncItemId, XmlNode>(flag ? (hierarchySyncOperations.Count + FolderSyncCommand.virtualFolders.Length) : hierarchySyncOperations.Count); XmlNode xmlNode3 = doc.CreateElement("Changes", namespaceURI); doc.DocumentElement.AppendChild(xmlNode3); StoreObjectId defaultFolderId = base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Root); FolderIdMapping folderIdMapping = (FolderIdMapping)base.FolderIdMappingSyncState[CustomStateDatumType.IdMapping]; FolderTree folderTree = (FolderTree)base.FolderIdMappingSyncState[CustomStateDatumType.FullFolderTree]; HashSet <ISyncItemId> hashSet = new HashSet <ISyncItemId>(); HashSet <ISyncItemId> hashSet2 = new HashSet <ISyncItemId>(); bool flag2 = false; AirSyncDiagnostics.TraceDebug <int>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). changes.Count={0}", hierarchySyncOperations.Count); for (int i = 0; i < hierarchySyncOperations.Count; i++) { HierarchySyncOperation hierarchySyncOperation = hierarchySyncOperations[i]; MailboxSyncItemId mailboxSyncItemId = MailboxSyncItemId.CreateForNewItem(hierarchySyncOperation.ItemId); MailboxSyncItemId mailboxSyncItemId2 = MailboxSyncItemId.CreateForNewItem(hierarchySyncOperation.ParentId); AirSyncDiagnostics.TraceDebug(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). change# {0}. changeType{1}. Processing folder: {2} with parent {3}", new object[] { i, Enum.GetName(typeof(ChangeType), hierarchySyncOperation.ChangeType), mailboxSyncItemId, mailboxSyncItemId2 }); string parentShortId = null; bool flag3 = false; switch (hierarchySyncOperation.ChangeType) { case ChangeType.Add: { if (folderTree.AddFolder(mailboxSyncItemId)) { AirSyncDiagnostics.TraceDebug <MailboxSyncItemId, MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Adding folder {0} with Parent {1} to Full Folder Tree.", mailboxSyncItemId, mailboxSyncItemId2); } folderTree.SetOwner(mailboxSyncItemId, hierarchySyncOperation.Owner); folderTree.SetPermissions(mailboxSyncItemId, hierarchySyncOperation.Permissions); if (!defaultFolderId.Equals(mailboxSyncItemId2.NativeId)) { if (folderTree.AddFolder(mailboxSyncItemId2)) { AirSyncDiagnostics.TraceDebug <MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Adding parent folder {0} to Full Folder Tree.", mailboxSyncItemId2); hashSet2.Add(mailboxSyncItemId2); } folderTree.LinkChildToParent(mailboxSyncItemId2, mailboxSyncItemId, hashSet); parentShortId = (folderIdMapping.Contains(mailboxSyncItemId2) ? folderIdMapping[mailboxSyncItemId2] : folderIdMapping.Add(mailboxSyncItemId2)); flag3 = folderTree.IsHidden(mailboxSyncItemId2); } bool sharedFolder = folderTree.IsSharedFolder(mailboxSyncItemId); AirSyncUtility.GetAirSyncFolderType(base.MailboxSession, sharedFolder, hierarchySyncOperation.ItemId, hierarchySyncOperation.ClassName); if (!this.IsFolderVisible(hierarchySyncOperation, flag3)) { folderTree.SetHidden(mailboxSyncItemId, true, hashSet); AirSyncDiagnostics.TraceDebug <MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Added folder {0} is set to hidden and will not be sent to client.", mailboxSyncItemId); } else { AirSyncDiagnostics.TraceDebug <MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Added folder {0} will be sent to client. Details next...", mailboxSyncItemId); string text = folderIdMapping.Contains(mailboxSyncItemId) ? folderIdMapping[mailboxSyncItemId] : folderIdMapping.Add(mailboxSyncItemId); dictionary[mailboxSyncItemId] = this.CreateChangeNode(doc, namespaceURI, hierarchySyncOperation.ChangeType, folderTree, mailboxSyncItemId, hierarchySyncOperation, text, parentShortId, ref flag2); hashSet2.Add(mailboxSyncItemId); } break; } case ChangeType.Change: if (!folderTree.Contains(mailboxSyncItemId)) { AirSyncDiagnostics.TraceError(ExTraceGlobals.RequestsTracer, this, "Could not find folder {0} with item ID {1} in the full folder tree, skipping... FolderIdMappingSyncState backend version is {2} and current version is {3}.", new object[] { hierarchySyncOperation.DisplayName, mailboxSyncItemId, base.FolderIdMappingSyncState.BackendVersion, base.FolderIdMappingSyncState.Version }); } else { if (!defaultFolderId.Equals(mailboxSyncItemId2.NativeId)) { if (folderTree.AddFolder(mailboxSyncItemId2)) { AirSyncDiagnostics.TraceDebug <MailboxSyncItemId, MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Changed folder {0} has new parent {1} to be sent to client.", mailboxSyncItemId, mailboxSyncItemId2); hashSet2.Add(mailboxSyncItemId2); } flag3 = folderTree.IsHidden(mailboxSyncItemId2); if (!flag3) { parentShortId = (folderIdMapping.Contains(mailboxSyncItemId2) ? folderIdMapping[mailboxSyncItemId2] : folderIdMapping.Add(mailboxSyncItemId2)); } } ISyncItemId parentId = folderTree.GetParentId(mailboxSyncItemId); if (!mailboxSyncItemId2.Equals(parentId)) { if (parentId != null) { folderTree.UnlinkChild(parentId, mailboxSyncItemId); AirSyncDiagnostics.TraceDebug <MailboxSyncItemId, ISyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Removing changed folder {0} as child from old parent {1} in Full Folder Tree.", mailboxSyncItemId, parentId); } if (!defaultFolderId.Equals(mailboxSyncItemId2.NativeId)) { folderTree.LinkChildToParent(mailboxSyncItemId2, mailboxSyncItemId, hashSet); AirSyncDiagnostics.TraceDebug <MailboxSyncItemId, MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Adding changed folder {0} as child to new parent {1} in Full Folder Tree.", mailboxSyncItemId, mailboxSyncItemId2); } else { AirSyncDiagnostics.TraceDebug <MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Changed folder {0} now has no parent in Full Folder Tree.", mailboxSyncItemId); } } folderTree.SetOwner(mailboxSyncItemId, hierarchySyncOperation.Owner); folderTree.SetPermissions(mailboxSyncItemId, hierarchySyncOperation.Permissions); bool sharedFolder = folderTree.IsSharedFolder(mailboxSyncItemId); AirSyncUtility.GetAirSyncFolderType(base.MailboxSession, sharedFolder, hierarchySyncOperation.ItemId, hierarchySyncOperation.ClassName); if (!this.IsFolderVisible(hierarchySyncOperation, flag3)) { folderTree.SetHidden(mailboxSyncItemId, true, hashSet); if (folderIdMapping.Contains(mailboxSyncItemId)) { string text = folderIdMapping[mailboxSyncItemId]; folderIdMapping.Delete(new ISyncItemId[] { mailboxSyncItemId }); dictionary[mailboxSyncItemId] = this.CreateDeleteNode(doc, namespaceURI, text); AirSyncDiagnostics.TraceDebug <MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Changed folder {0} is now hidden; deleting from client.", mailboxSyncItemId); } } else { folderTree.SetHidden(mailboxSyncItemId, false, hashSet); string text; if (!folderIdMapping.Contains(mailboxSyncItemId)) { text = folderIdMapping.Add(mailboxSyncItemId); hierarchySyncOperation.ChangeType = ChangeType.Add; AirSyncDiagnostics.TraceDebug <MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Changed folder {0} is now visible; adding to client.", mailboxSyncItemId); } else { text = folderIdMapping[mailboxSyncItemId]; AirSyncDiagnostics.TraceDebug <MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Changed folder {0} is being sent to client.", mailboxSyncItemId); } dictionary[mailboxSyncItemId] = this.CreateChangeNode(doc, namespaceURI, hierarchySyncOperation.ChangeType, folderTree, mailboxSyncItemId, hierarchySyncOperation, text, parentShortId, ref flag2); } } break; case ChangeType.Delete: if (folderTree.Contains(mailboxSyncItemId)) { if (folderIdMapping.Contains(mailboxSyncItemId)) { string text = folderIdMapping[mailboxSyncItemId]; dictionary[mailboxSyncItemId] = this.CreateDeleteNode(doc, namespaceURI, text); AirSyncDiagnostics.TraceDebug <MailboxSyncItemId, string>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Deleted folder {0} with Short Id {1} is being sent to client.", mailboxSyncItemId, text); } folderTree.RemoveFolderAndChildren(mailboxSyncItemId, folderIdMapping); AirSyncDiagnostics.TraceDebug <MailboxSyncItemId>(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Deleted folder {0} and children are being removed from Full Folder Tree.", mailboxSyncItemId); } break; } } if (flag) { this.AddVirtualFolders(doc, namespaceURI, dictionary); } using (HashSet <ISyncItemId> .Enumerator enumerator = hashSet.GetEnumerator()) { while (enumerator.MoveNext()) { ISyncItemId itemId = enumerator.Current; if (folderTree.IsHidden(itemId)) { dictionary.Remove(itemId); AirSyncDiagnostics.TraceDebug(ExTraceGlobals.AlgorithmTracer, this, "FolderSyncCommand.ProcessCommand(). Removing hidden folder {0} from list of changes being sent to client.", new object[] { itemId.NativeId }); if (folderIdMapping.Contains(itemId)) { if (!hashSet2.Contains(itemId)) { dictionary[itemId] = this.CreateDeleteNode(doc, namespaceURI, folderIdMapping[itemId]); } folderIdMapping.Delete(new ISyncItemId[] { itemId }); } } else if (!dictionary.ContainsKey(itemId)) { HierarchySyncOperation hierarchySyncOperation2 = (from change in hierarchySyncOperations where change.ItemId == (StoreObjectId)itemId.NativeId select change).First <HierarchySyncOperation>(); string parentShortId2 = folderIdMapping[folderTree.GetParentId(itemId)]; if (folderIdMapping.Contains(itemId)) { flag2 = true; AirSyncDiagnostics.TraceError <string, object>(ExTraceGlobals.RequestsTracer, this, "Hidden folder {0} with item ID {1} is in folderIdMapping table.", hierarchySyncOperation2.DisplayName, itemId.NativeId); } else { string shortId = folderIdMapping.Add(itemId); dictionary[itemId] = this.CreateChangeNode(doc, namespaceURI, ChangeType.Add, folderTree, itemId, hierarchySyncOperation2, shortId, parentShortId2, ref flag2); } } } } XmlNode xmlNode4 = doc.CreateElement("Count", namespaceURI); xmlNode4.InnerText = dictionary.Count.ToString(CultureInfo.InvariantCulture); xmlNode3.AppendChild(xmlNode4); foreach (XmlNode newChild in dictionary.Values) { xmlNode3.AppendChild(newChild); } if (flag2) { Exception exception = new InvalidOperationException("FolderSyncCommand.ProcessCommand found errors. See traces above."); if (GlobalSettings.SendWatsonReport) { AirSyncDiagnostics.SendWatson(exception, false); } } }
// Token: 0x060006CE RID: 1742 RVA: 0x00025F84 File Offset: 0x00024184 private void FillFidMapping(GetSyncStateResult results, MailboxSession session) { foreach (DeviceData deviceData in results.Devices) { foreach (SyncStateFolderData syncStateFolderData in deviceData.SyncFolders) { if (syncStateFolderData != null && !string.IsNullOrEmpty(syncStateFolderData.SyncStateBlob)) { syncStateFolderData.FolderMapping = new List <FolderMappingData>(); using (PooledMemoryStream pooledMemoryStream = new PooledMemoryStream(102400)) { byte[] array = Convert.FromBase64String(syncStateFolderData.SyncStateBlob); pooledMemoryStream.Write(array, 0, array.Length); pooledMemoryStream.Flush(); pooledMemoryStream.Position = 0L; int num; int num2; long num3; long num4; Dictionary <string, bool> dictionary; GenericDictionaryData <ConstStringData, string, DerivedData <ICustomSerializableBuilder> > genericDictionaryData = SyncState.InternalDeserializeData(pooledMemoryStream, out num, out num2, out num3, out num4, out dictionary); FolderIdMapping folderIdMapping = genericDictionaryData.Data["IdMapping"].Data as FolderIdMapping; IDictionaryEnumerator syncIdIdEnumerator = folderIdMapping.SyncIdIdEnumerator; while (syncIdIdEnumerator.MoveNext()) { string shortId = syncIdIdEnumerator.Key as string; ISyncItemId syncItemId = syncIdIdEnumerator.Value as ISyncItemId; StoreObjectId storeObjectId = syncItemId.NativeId as StoreObjectId; try { using (Folder folder = Folder.Bind(session, storeObjectId, new PropertyDefinition[] { FolderSchema.DisplayName })) { DefaultFolderType defaultFolderType = session.IsDefaultFolderType(folder.Id); syncStateFolderData.FolderMapping.Add(new FolderMappingData { ShortId = shortId, LongId = storeObjectId.ToString(), Name = folder.DisplayName, DefaultFolderType = defaultFolderType.ToString(), Exception = null }); } } catch (Exception ex) { syncStateFolderData.FolderMapping.Add(new FolderMappingData { ShortId = shortId, LongId = "[Error]", Name = "[Error]", DefaultFolderType = "[Error]", Exception = ex.ToString() }); } } } } } } }
public void ParseQueryNode(XmlElement queryNode) { this.searchCriteriaBuilder = new MailboxSearchCriteriaBuilder(this.context.Request.Culture); if (!this.mailboxSession.Mailbox.IsContentIndexingEnabled) { AirSyncDiagnostics.LogPeriodicEvent(AirSyncEventLogConstants.Tuple_ContentIndexingNotEnabled, "ContentIndexingNotEnabled", new string[] { this.mailboxSession.MailboxOwner.MailboxInfo.Location.ServerFqdn }); } this.queryFilter = this.searchCriteriaBuilder.ParseTopLevelClassAndFolders(queryNode, this.mailboxSession.Mailbox.IsContentIndexingEnabled, this.versionFactory, this.context); this.schemaCache = this.searchCriteriaBuilder.SchemaCache; if (this.FolderIdMappingSyncState == null || !this.FolderIdMappingSyncState.Contains(CustomStateDatumType.FullFolderTree)) { AirSyncDiagnostics.TraceDebug <string>(ExTraceGlobals.AlgorithmTracer, this, "FolderIdMappingSyncState error: {0}", (this.FolderIdMappingSyncState != null) ? "no FullFolderTree" : "FolderIdMappingSyncState is null"); throw new SearchNeedToFolderSyncException(); } List <string> list = this.searchCriteriaBuilder.FolderScope; FolderIdMapping folderIdMapping = (FolderIdMapping)this.FolderIdMappingSyncState[CustomStateDatumType.IdMapping]; FolderTree folderTree = (FolderTree)this.FolderIdMappingSyncState[CustomStateDatumType.FullFolderTree]; if (list.Count == 0) { this.folderScope = new StoreId[] { this.mailboxSession.GetDefaultFolderId(DefaultFolderType.Root) }; } else { int num = 0; this.folderScope = new StoreId[list.Count]; foreach (string text in list) { StoreObjectId storeObjectId = null; if (text == "0") { storeObjectId = this.mailboxSession.GetDefaultFolderId(DefaultFolderType.Root); } else { SyncCollection.CollectionTypes collectionType = AirSyncUtility.GetCollectionType(text); if (collectionType != SyncCollection.CollectionTypes.Mailbox && collectionType != SyncCollection.CollectionTypes.Unknown) { throw new AirSyncPermanentException(StatusCode.InvalidCombinationOfIDs, false) { ErrorStringForProtocolLogger = "BadIdComboInMbxSearch" }; } MailboxSyncItemId mailboxSyncItemId = folderIdMapping[text] as MailboxSyncItemId; if (mailboxSyncItemId != null) { if (folderTree.IsSharedFolder(mailboxSyncItemId)) { throw new AirSyncPermanentException(StatusCode.Sync_InvalidParameters, false) { ErrorStringForProtocolLogger = "AccessDeniedInMbxSearch" }; } storeObjectId = (StoreObjectId)mailboxSyncItemId.NativeId; } } if (storeObjectId == null) { throw new SearchNeedToFolderSyncException(); } try { using (Folder.Bind(this.mailboxSession, storeObjectId)) { } } catch (ObjectNotFoundException) { throw new SearchNeedToFolderSyncException(); } this.folderScope[num++] = storeObjectId; } } foreach (object obj in folderTree) { ISyncItemId syncItemId = (ISyncItemId)obj; MailboxSyncItemId mailboxSyncItemId2 = syncItemId as MailboxSyncItemId; if (mailboxSyncItemId2 != null && (folderTree.IsHidden(syncItemId) || folderTree.IsSharedFolder(syncItemId))) { this.searchCriteriaBuilder.ExcludedFolders.Add((StoreObjectId)mailboxSyncItemId2.NativeId); } } if (this.mailboxSchemaOptions.HasBodyPartPreferences) { if (this.searchCriteriaBuilder.Conversation == null) { AirSyncDiagnostics.TraceDebug(ExTraceGlobals.AlgorithmTracer, this, "<BodyPartPreference> is only supported when search for ConversationId"); throw new AirSyncPermanentException(StatusCode.Sync_ObjectNotFound, false) { ErrorStringForProtocolLogger = "BodyPartNotSupported" }; } this.searchCriteriaBuilder.Conversation.LoadBodySummaries(); } }
public void RemoveFolderAndChildren(ISyncItemId folderId, FolderIdMapping folderIdMapping) { this.RemoveFolderAndChildren(folderId, folderIdMapping, 0, this.folderTree.Keys.Count); }