public static bool ShouldItemBeIgnored(MessageRec msgRec, EntryIdMap <BadItemMarker> badItemMarkers, FAICopyOption faiCopyOption, out string faiMessageClass)
{
faiMessageClass = null;
if (msgRec.IsFAI)
{
if (faiCopyOption == FAICopyOption.DoNotCopy)
{
return(true);
}
faiMessageClass = (msgRec[PropTag.MessageClass] as string);
if (!string.IsNullOrEmpty(faiMessageClass) && FolderContentsMapper.IgnoredFaiMessageClasses.Contains(faiMessageClass))
{
return(true);
}
}
if (badItemMarkers != null && badItemMarkers.ContainsKey(msgRec.EntryId))
{
BadItemMarker badItemMarker = badItemMarkers[msgRec.EntryId];
if (FolderContentsMapper.SkippedBadItemKinds.Contains(badItemMarker.Kind))
{
return(true);
}
}
return(false);
}
public bool ComputeMappingPaged(FolderContentsCrawler folderCrawler, EntryIdMap <BadItemMarker> badItemMarkers, out int skippedItemCount, out ulong skippedItemSize, out List <MessageRec> itemsToCopy, out List <MessageRec> targetMessagePropsChanges)
{
MrsTracer.Service.Function("FolderContentsMapper.ComputeMappingPaged", new object[0]);
MrsTracer.Service.Debug("Loading source folder contents", new object[0]);
IReadOnlyCollection <MessageRec> messagesNextPage = folderCrawler.GetMessagesNextPage();
if (messagesNextPage.Count == 0)
{
itemsToCopy = null;
targetMessagePropsChanges = null;
skippedItemCount = 0;
skippedItemSize = 0UL;
return(false);
}
List <byte[]> list = new List <byte[]>(messagesNextPage.Count);
foreach (MessageRec messageRec in messagesNextPage)
{
list.Add(messageRec.EntryId);
}
MrsTracer.Service.Debug("Looking up target messages", new object[0]);
List <MessageRec> targetMessages = this.destFolder.LookupMessages(this.destHierarchy.SourceEntryIDPtag, list, this.GetTargetPTagsInitialSync());
this.ComputeMapping(messagesNextPage, targetMessages, badItemMarkers, out skippedItemCount, out skippedItemSize, out itemsToCopy, out targetMessagePropsChanges);
return(true);
}
private void MapSourceToTargetMessageBySourceEntryId(MessageRec sourceMR, EntryIdMap <MessageRec> targetBySourceEntryId, out MessageRec targetMR)
{
targetMR = null;
byte[] keyPlusLMTHash = this.GetKeyPlusLMTHash(sourceMR, PropTag.EntryId, PropTag.LastModificationTime);
if (keyPlusLMTHash != null)
{
targetBySourceEntryId.TryGetValue(keyPlusLMTHash, out targetMR);
}
}
protected override MailboxChangesManifest EnumerateSourceHierarchyChanges(MailboxCopierBase mbxCtx, bool catchup, SyncContext syncContext)
{
if (catchup)
{
if (!mbxCtx.IsRoot)
{
return(null);
}
return(base.EnumerateSourceHierarchyChanges(mbxCtx, catchup, syncContext));
}
else
{
if (mbxCtx.IsRoot)
{
return(base.EnumerateSourceHierarchyChanges(mbxCtx, catchup, syncContext));
}
FolderMap destinationFolderMap = base.GetRootMailboxContext().GetDestinationFolderMap(GetFolderMapFlags.None);
EntryIdMap <FolderRecWrapper> primaryMailboxFolderRecWrappers = new EntryIdMap <FolderRecWrapper>();
destinationFolderMap.EnumerateFolderHierarchy(EnumHierarchyFlags.NormalFolders | EnumHierarchyFlags.RootFolder, delegate(FolderRecWrapper primaryFolderRecWrapper, FolderMap.EnumFolderContext enumFolderContext)
{
if (mbxCtx.IsContentAvailableInTargetMailbox(primaryFolderRecWrapper))
{
byte[] key = (byte[])primaryFolderRecWrapper.FolderRec[PropTag.LTID];
primaryMailboxFolderRecWrappers[key] = primaryFolderRecWrapper;
}
});
EntryIdMap <FolderRecWrapper> secondaryMailboxFolderRecWrappers = new EntryIdMap <FolderRecWrapper>();
syncContext.TargetFolderMap.EnumerateFolderHierarchy(EnumHierarchyFlags.NormalFolders | EnumHierarchyFlags.RootFolder, delegate(FolderRecWrapper secondaryFolderRecWrapper, FolderMap.EnumFolderContext enumFolderContext)
{
if (mbxCtx.IsContentAvailableInTargetMailbox(secondaryFolderRecWrapper))
{
byte[] key = (byte[])secondaryFolderRecWrapper.FolderRec[PropTag.LTID];
secondaryMailboxFolderRecWrappers[key] = secondaryFolderRecWrapper;
}
});
MailboxChangesManifest mailboxChangesManifest = new MailboxChangesManifest();
mailboxChangesManifest.ChangedFolders = new List <byte[]>();
mailboxChangesManifest.DeletedFolders = new List <byte[]>();
foreach (KeyValuePair <byte[], FolderRecWrapper> keyValuePair in primaryMailboxFolderRecWrappers)
{
FolderRecWrapper folderRecWrapper;
if (!secondaryMailboxFolderRecWrappers.TryGetValue(keyValuePair.Key, out folderRecWrapper) || folderRecWrapper.FolderRec.LastModifyTimestamp != keyValuePair.Value.FolderRec.LastModifyTimestamp)
{
mailboxChangesManifest.ChangedFolders.Add(mbxCtx.SourceMailbox.GetSessionSpecificEntryId(keyValuePair.Key));
}
}
foreach (KeyValuePair <byte[], FolderRecWrapper> keyValuePair2 in secondaryMailboxFolderRecWrappers)
{
FolderRecWrapper folderRecWrapper2;
if (!primaryMailboxFolderRecWrappers.TryGetValue(keyValuePair2.Key, out folderRecWrapper2))
{
mailboxChangesManifest.DeletedFolders.Add(mbxCtx.SourceMailbox.GetSessionSpecificEntryId(keyValuePair2.Key));
}
}
return(mailboxChangesManifest);
}
}
public EntryIdMap <WellKnownFolderType> GetEntryIdToWkfTypeMap()
{
EntryIdMap <WellKnownFolderType> entryIdMap = new EntryIdMap <WellKnownFolderType>();
foreach (KeyValuePair <byte[], WellKnownFolderType> keyValuePair in this.wellKnownFolderTypes)
{
entryIdMap[keyValuePair.Key] = keyValuePair.Value;
}
return(entryIdMap);
}
EntryIdMap <byte[]> IFxProxyPool.GetFolderData()
{
EntryIdMap <byte[]> result = null;
using (base.CreateCostHandle())
{
result = base.WrappedObject.GetFolderData();
}
return(result);
}
EntryIdMap <byte[]> IFxProxyPool.GetFolderData()
{
EntryIdMap <byte[]> result = null;
base.CreateContext("IFxProxyPool.GetFolderData", new DataContext[0]).Execute(delegate
{
result = this.WrappedObject.GetFolderData();
}, true);
return(result);
}
public void ComputeMapping(EntryIdMap <BadItemMarker> badItemMarkers, out int skippedItemCount, out ulong skippedItemSize, out List <MessageRec> itemsToCopy, out List <MessageRec> targetMessagePropsChanges)
{
MrsTracer.Service.Function("FolderContentsMapper.ComputeMapping", new object[0]);
MrsTracer.Service.Debug("Loading source folder contents", new object[0]);
List <MessageRec> sourceMessages = this.srcFolder.EnumerateMessages(EnumerateMessagesFlags.RegularMessages | EnumerateMessagesFlags.IncludeExtendedData, this.GetSourcePTagsInitialSync());
MrsTracer.Service.Debug("Loading target folder contents", new object[0]);
List <MessageRec> targetMessages = this.destFolder.EnumerateMessages(EnumerateMessagesFlags.RegularMessages, this.GetTargetPTagsInitialSync());
this.ComputeMapping(sourceMessages, targetMessages, badItemMarkers, out skippedItemCount, out skippedItemSize, out itemsToCopy, out targetMessagePropsChanges);
}
protected virtual void MapSourceToTargetMessage(MessageRec sourceMR, EntryIdMap <MessageRec> targetBySourceEntryId, EntryIdMap <MessageRec> targetBySecondaryKey, HashSet <byte[]> duplicateTargetSecondaryKeys, HashSet <byte[]> duplicateSourceSecondaryKeys, out MessageRec targetMR)
{
targetMR = null;
this.MapSourceToTargetMessageBySourceEntryId(sourceMR, targetBySourceEntryId, out targetMR);
if (targetMR == null)
{
byte[] keyPlusLMTHash = this.GetKeyPlusLMTHash(sourceMR, PropTag.SearchKey, PropTag.LastModificationTime);
if (keyPlusLMTHash != null && !duplicateSourceSecondaryKeys.Contains(keyPlusLMTHash))
{
targetBySecondaryKey.TryGetValue(keyPlusLMTHash, out targetMR);
}
}
}
EntryIdMap <byte[]> IFxProxyPool.GetFolderData()
{
EntryIdMap <byte[]> entryIdMap = new EntryIdMap <byte[]>();
foreach (KeyValuePair <byte[], byte[]> keyValuePair in base.WrappedObject.GetFolderData())
{
if (keyValuePair.Key.Length == 46)
{
entryIdMap.Add(this.sourceMailbox.GetSessionSpecificEntryId(keyValuePair.Key), keyValuePair.Value);
}
}
return(entryIdMap);
}
protected void RefreshFolderCache(EasHierarchySyncState state)
{
IReadOnlyCollection <Add> folders = state.Folders;
EntryIdMap <Add> entryIdMap = new EntryIdMap <Add>(folders.Count);
this.defaultCalendarId = null;
foreach (Add add in folders)
{
EasFolderType easFolderType = add.GetEasFolderType();
if (easFolderType == EasFolderType.Calendar)
{
this.defaultCalendarId = EasMailbox.GetEntryId(add.ServerId);
}
EasFolderType easFolderType2 = easFolderType;
if (easFolderType2 == EasFolderType.UserGeneric)
{
goto IL_8B;
}
bool flag;
switch (easFolderType2)
{
case EasFolderType.Contacts:
case EasFolderType.UserContacts:
flag = !ConfigBase <MRSConfigSchema> .GetConfig <bool>("DisableContactSync");
goto IL_9D;
case EasFolderType.UserMail:
case EasFolderType.UserCalendar:
goto IL_8B;
}
flag = EasMailbox.folderTypeMap.ContainsKey(easFolderType);
IL_9D:
if (flag)
{
entryIdMap.Add(EasMailbox.GetEntryId(add.ServerId), add);
continue;
}
MrsTracer.Provider.Debug("EasMailbox.RefreshFolderCache: ignore {0} folder '{1}' since it is not supported yet", new object[]
{
easFolderType,
add.DisplayName
});
continue;
IL_8B:
flag = true;
goto IL_9D;
}
this.EasFolderCache = entryIdMap;
}
protected override MailboxChangesManifest RunManualHierarchySync(bool catchup, SyncHierarchyManifestState hierState)
{
MrsTracer.Provider.Function("EasSourceMailbox.RunManualHierarchySync", new object[0]);
base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None);
EasHierarchySyncState easHierarchySyncState = EasHierarchySyncState.Deserialize(hierState.ProviderSyncState);
hierState.ProviderSyncState = null;
EasHierarchySyncState easHierarchySyncState2 = base.RefreshFolderCache();
EntryIdMap <EasHierarchySyncState.EasFolderData> entryIdMap = new EntryIdMap <EasHierarchySyncState.EasFolderData>();
foreach (EasHierarchySyncState.EasFolderData easFolderData in easHierarchySyncState.FolderData)
{
entryIdMap[EasMailbox.GetEntryId(easFolderData.ServerId)] = easFolderData;
}
EntryIdMap <EasHierarchySyncState.EasFolderData> entryIdMap2 = new EntryIdMap <EasHierarchySyncState.EasFolderData>();
foreach (EasHierarchySyncState.EasFolderData easFolderData2 in easHierarchySyncState2.FolderData)
{
entryIdMap2[EasMailbox.GetEntryId(easFolderData2.ServerId)] = easFolderData2;
}
MailboxChangesManifest mailboxChangesManifest = new MailboxChangesManifest();
mailboxChangesManifest.DeletedFolders = new List <byte[]>();
foreach (byte[] array in entryIdMap.Keys)
{
if (!entryIdMap2.ContainsKey(array))
{
mailboxChangesManifest.DeletedFolders.Add(array);
}
}
mailboxChangesManifest.ChangedFolders = new List <byte[]>();
foreach (KeyValuePair <byte[], EasHierarchySyncState.EasFolderData> keyValuePair in entryIdMap2)
{
byte[] key = keyValuePair.Key;
EasHierarchySyncState.EasFolderData value = keyValuePair.Value;
EasHierarchySyncState.EasFolderData easFolderData3;
if (entryIdMap.TryGetValue(key, out easFolderData3))
{
if (easFolderData3.ParentId != value.ParentId || easFolderData3.DisplayName != value.DisplayName)
{
mailboxChangesManifest.ChangedFolders.Add(key);
}
}
else
{
mailboxChangesManifest.ChangedFolders.Add(key);
}
}
return(mailboxChangesManifest);
}
protected override void MapSourceToTargetMessage(MessageRec sourceMR, EntryIdMap <MessageRec> targetBySourceEntryId, EntryIdMap <MessageRec> targetBySecondaryKey, HashSet <byte[]> duplicateTargetSecondaryKeys, HashSet <byte[]> duplicateSourceSecondaryKeys, out MessageRec targetMR)
{
targetMR = null;
byte[] array = ImapFolderContentsMapper.GetImapSyncPropertiesHash(sourceMR, this.sourceHierarchy);
if (array != null)
{
targetBySecondaryKey.TryGetValue(array, out targetMR);
}
if (targetMR == null)
{
array = ImapFolderContentsMapper.GetSyncMessageIdHash(sourceMR, MessageRecType.Source, this.sourceHierarchy);
targetBySecondaryKey.TryGetValue(array, out targetMR);
}
}
public void PrefetchSourceMessageIdsFromTargetMessageIds(EntryIdMap <List <byte[]> > destMessagesToTranslate)
{
this.prefetchedSourceEntryIdMap.Clear();
PropTag sourceEntryIDPtag = this.Merger.DestHierarchy.SourceEntryIDPtag;
PropTag[] additionalPtagsToLoad = new PropTag[]
{
sourceEntryIDPtag
};
foreach (KeyValuePair <byte[], List <byte[]> > keyValuePair in destMessagesToTranslate)
{
byte[] key = keyValuePair.Key;
List <byte[]> value = keyValuePair.Value;
foreach (byte[] key2 in value)
{
this.prefetchedSourceEntryIdMap[key2] = null;
}
using (IDestinationFolder folder = this.Merger.DestMailbox.GetFolder(key))
{
if (folder == null)
{
MrsTracer.Service.Warning("Destination folder {0} disappeared", new object[]
{
TraceUtils.DumpEntryId(key)
});
}
else
{
List <MessageRec> list = folder.LookupMessages(PropTag.EntryId, value, additionalPtagsToLoad);
foreach (MessageRec messageRec in list)
{
byte[] array = messageRec[sourceEntryIDPtag] as byte[];
if (array == null)
{
MrsTracer.Service.Warning("Destination message {0} doesn't have mapped source message", new object[]
{
TraceUtils.DumpEntryId(messageRec.EntryId)
});
}
else
{
this.prefetchedSourceEntryIdMap[messageRec.EntryId] = array;
}
}
}
}
}
}
EntryIdMap <byte[]> IFxProxyPool.GetFolderData()
{
EntryIdMap <byte[]> folderData = base.WrappedObject.GetFolderData();
EntryIdMap <byte[]> entryIdMap = new EntryIdMap <byte[]>();
foreach (KeyValuePair <byte[], byte[]> keyValuePair in folderData)
{
byte[] array = keyValuePair.Key;
if (CommonUtils.IsSameEntryId(array, this.mapper.folderMapping.TargetFolder.EntryId))
{
array = this.mapper.folderMapping.EntryId;
}
entryIdMap.Add(array, keyValuePair.Value);
}
return(entryIdMap);
}
protected override IFxProxyPool GetFxProxyPoolTransmissionPipeline(EntryIdMap <byte[]> sourceMap)
{
IFxProxyPool result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
IFxProxyPool fxProxyPool = base.DestMailbox.GetFxProxyPool(sourceMap.Keys);
disposeGuard.Add <IFxProxyPool>(fxProxyPool);
IFxProxyPool fxProxyPool2 = new MailboxMerger.SimpleTranslatingProxyPool(fxProxyPool, sourceMap);
disposeGuard.Success();
disposeGuard.Add <IFxProxyPool>(fxProxyPool2);
IFxProxyPool fxProxyPool3 = base.CreateFxProxyPoolTransmissionPipeline(fxProxyPool2);
disposeGuard.Success();
result = fxProxyPool3;
}
return(result);
}
List <MessageRec> IFolder.LookupMessages(PropTag ptagToLookup, List <byte[]> keysToLookup, PropTag[] additionalPtagsToLoad)
{
MrsTracer.Provider.Function("StorageFolder.LookupMessages: {0}", new object[]
{
this.DisplayNameForTracing
});
EntryIdMap <MessageRec> result = new EntryIdMap <MessageRec>();
ItemQueryType[] array = new ItemQueryType[]
{
ItemQueryType.None,
ItemQueryType.Associated
};
int capacity = 3 + ((additionalPtagsToLoad == null) ? 0 : additionalPtagsToLoad.Length);
List <PropertyDefinition> columns = new List <PropertyDefinition>(capacity)
{
CoreObjectSchema.EntryId,
CoreItemSchema.Size,
CoreObjectSchema.CreationTime
};
int idxEntryId = 0;
int idxMessageSize = 1;
int idxCreationTime = 2;
int idxExtraProperties = 3;
if (additionalPtagsToLoad != null && additionalPtagsToLoad.Length > 0)
{
columns.AddRange(this.Mailbox.ConvertPropTagsToDefinitions(additionalPtagsToLoad));
}
ItemQueryType[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
StorageFolder.< > c__DisplayClassb CS$ < > 8__locals2 = new StorageFolder.< > c__DisplayClassb();
CS$ < > 8__locals2.queryType = array2[i];
if (result.Count >= keysToLookup.Count)
{
break;
}
bool doingFAI = CS$ < > 8__locals2.queryType == ItemQueryType.Associated;
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("StorageFolder.GetContentsTable", OperationType.None),
new SimpleValueDataContext("QueryType", CS$ < > 8__locals2.queryType)
}).Execute(delegate
public ReplayActionsQueue GetAndTranslateActions(string replaySyncState, int maxNumberOfActions, MergeSyncContext syncContext, out string retrieveSyncState, out bool moreActions)
{
MrsTracer.Service.Function("MailboxMerger.GetAndTranslateActions", new object[0]);
List <ReplayAction> actions = base.DestMailbox.GetActions(replaySyncState, maxNumberOfActions);
moreActions = (actions.Count == maxNumberOfActions);
retrieveSyncState = ((actions.Count == 0) ? replaySyncState : actions[actions.Count - 1].Watermark);
ReplayActionsQueue replayActionsQueue = new ReplayActionsQueue(actions.Count);
foreach (ReplayAction action in actions)
{
replayActionsQueue.Enqueue(action);
}
EntryIdMap <List <byte[]> > entryIdMap = new EntryIdMap <List <byte[]> >();
foreach (ReplayAction replayAction in actions)
{
if (!replayAction.Ignored)
{
foreach (KeyValuePair <byte[], byte[]> keyValuePair in replayAction.GetMessageEntryIdsToTranslate())
{
byte[] key = keyValuePair.Key;
byte[] value = keyValuePair.Value;
List <byte[]> list;
if (!entryIdMap.TryGetValue(key, out list))
{
list = new List <byte[]>();
entryIdMap.Add(key, list);
}
list.Add(value);
}
}
}
syncContext.PrefetchSourceMessageIdsFromTargetMessageIds(entryIdMap);
foreach (ReplayAction replayAction2 in actions)
{
if (!replayAction2.Ignored)
{
replayAction2.TranslateEntryIds(syncContext);
}
}
return(replayActionsQueue);
}
EntryIdMap <byte[]> IFxProxyPool.GetFolderData()
{
EntryIdMap <byte[]> entryIdMap = new EntryIdMap <byte[]>();
if (this.folderIds != null)
{
foreach (byte[] array in this.folderIds)
{
using (TFolderEntry tfolderEntry = this.OpenFolder(array))
{
entryIdMap[array] = ((tfolderEntry != null) ? this.FolderGetObjectData(tfolderEntry) : null);
}
}
}
byte[] array2 = this.MessageGetObjectData(default(TMessageEntry));
if (array2 != null)
{
entryIdMap[CommonUtils.MessageData] = array2;
}
return(entryIdMap);
}
public MailboxChanges(EntryIdMap <FolderChangesManifest> folderChanges)
{
this.hierarchyChanges = new MailboxChangesManifest();
this.folderChanges = folderChanges;
}
public void ComputeFolderMapping(FolderHierarchy targetHierarchy, bool createMissingFolderRecs)
{
if (!this.folderFilterApplied)
{
this.SetFolderFilter(null, false, null, string.Empty, false, Guid.Empty);
}
EntryIdMap <FolderMapping> targetBySourceEntryID = new EntryIdMap <FolderMapping>();
targetHierarchy.EnumerateSubtree(EnumHierarchyFlags.AllFolders, targetHierarchy.RootFolder, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx)
{
FolderMapping folderMapping = (FolderMapping)fRec;
byte[] array = folderMapping.FolderRec[targetHierarchy.SourceEntryIDPtag] as byte[];
if (array != null && !targetBySourceEntryID.ContainsKey(array))
{
targetBySourceEntryID.Add(array, folderMapping);
}
});
base.EnumerateFolderHierarchy(EnumHierarchyFlags.AllFolders, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx)
{
FolderMapping folderMapping = (FolderMapping)fRec;
FolderMapping wellKnownFolder;
if (folderMapping.WKFType != WellKnownFolderType.None)
{
wellKnownFolder = targetHierarchy.GetWellKnownFolder(folderMapping.WKFType);
if (wellKnownFolder != null)
{
folderMapping.TargetFolder = wellKnownFolder;
wellKnownFolder.SourceFolder = folderMapping;
this.MapPublicFolderDumpster(folderMapping, wellKnownFolder);
return;
}
}
if (targetBySourceEntryID.TryGetValue(folderMapping.EntryId, out wellKnownFolder))
{
folderMapping.TargetFolder = wellKnownFolder;
wellKnownFolder.SourceFolder = folderMapping;
this.MapPublicFolderDumpster(folderMapping, wellKnownFolder);
}
});
base.EnumerateFolderHierarchy(EnumHierarchyFlags.AllFolders, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx)
{
FolderMapping folderMapping = (FolderMapping)fRec;
if (folderMapping.TargetFolder != null)
{
this.MapSubtreeByName(folderMapping, createMissingFolderRecs);
ctx.Result = EnumHierarchyResult.SkipSubtree;
}
});
FolderMapping ipmSubtree = this.GetWellKnownFolder(WellKnownFolderType.IpmSubtree);
if (ipmSubtree != null)
{
base.EnumerateFolderHierarchy(EnumHierarchyFlags.AllFolders, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx)
{
FolderMapping folderMapping = (FolderMapping)fRec;
if (folderMapping.IsIncluded && folderMapping.TargetFolder == null)
{
this.MapFolderByName(folderMapping, ipmSubtree.TargetFolder, createMissingFolderRecs);
if (folderMapping.TargetFolder != null)
{
this.MapSubtreeByName(folderMapping, createMissingFolderRecs);
}
ctx.Result = EnumHierarchyResult.SkipSubtree;
}
});
}
}
public static void LookupBadMessagesInMailbox(ISourceMailbox mailbox, List <MessageRec> messages, out EntryIdMap <MessageRec> lookedUpMsgs, out EntryIdMap <FolderRec> folderRecs)
{
EntryIdMap <EntryIdMap <MessageRec> > entryIdMap = new EntryIdMap <EntryIdMap <MessageRec> >();
folderRecs = new EntryIdMap <FolderRec>();
lookedUpMsgs = new EntryIdMap <MessageRec>();
foreach (MessageRec messageRec in messages)
{
EntryIdMap <MessageRec> entryIdMap2;
if (!entryIdMap.TryGetValue(messageRec.FolderId, out entryIdMap2))
{
entryIdMap2 = new EntryIdMap <MessageRec>();
entryIdMap.Add(messageRec.FolderId, entryIdMap2);
}
entryIdMap2[messageRec.EntryId] = null;
}
MrsTracer.Common.Debug("Looking up {0} messages in {1} folders.", new object[]
{
messages.Count,
entryIdMap.Count
});
foreach (KeyValuePair <byte[], EntryIdMap <MessageRec> > keyValuePair in entryIdMap)
{
using (ISourceFolder folder = mailbox.GetFolder(keyValuePair.Key))
{
if (folder == null)
{
MrsTracer.Common.Warning("Folder {0} disappeared.", new object[]
{
TraceUtils.DumpEntryId(keyValuePair.Key)
});
}
else
{
FolderRec folderRec = folder.GetFolderRec(null, GetFolderRecFlags.None);
folderRecs[folderRec.EntryId] = folderRec;
EntryIdMap <MessageRec> value = keyValuePair.Value;
MrsTracer.Common.Debug("Looking up {0} messages in folder '{1}'.", new object[]
{
value.Count,
folderRec.FolderName
});
int num = 0;
if (mailbox.IsCapabilitySupported(MRSProxyCapabilities.SimpleExport))
{
List <byte[]> keysToLookup = new List <byte[]>(value.Keys);
List <MessageRec> list = folder.LookupMessages(PropTag.EntryId, keysToLookup, BadMessageRec.BadItemPtags);
if (list == null)
{
goto IL_230;
}
using (List <MessageRec> .Enumerator enumerator3 = list.GetEnumerator())
{
while (enumerator3.MoveNext())
{
MessageRec messageRec2 = enumerator3.Current;
lookedUpMsgs[messageRec2.EntryId] = messageRec2;
num++;
}
goto IL_230;
}
}
List <MessageRec> list2 = folder.EnumerateMessages(EnumerateMessagesFlags.RegularMessages, BadMessageRec.BadItemPtags);
foreach (MessageRec messageRec3 in list2)
{
if (value.ContainsKey(messageRec3.EntryId))
{
lookedUpMsgs[messageRec3.EntryId] = messageRec3;
num++;
}
}
IL_230:
MrsTracer.Common.Debug("Found {0} messages.", new object[]
{
num
});
}
}
}
MrsTracer.Common.Debug("Looked up {0} messages.", new object[]
{
lookedUpMsgs.Count
});
}
List <MessageRec> IFolder.LookupMessages(PropTag ptagToLookup, List <byte[]> keysToLookup, PropTag[] additionalPtagsToLoad)
{
EntryIdMap <MessageRec> result = new EntryIdMap <MessageRec>();
ContentsTableFlags[] array = new ContentsTableFlags[]
{
ContentsTableFlags.None,
ContentsTableFlags.Associated
};
List <PropTag> pta = new List <PropTag>(5);
int idxEntryId = pta.Count;
pta.Add(PropTag.EntryId);
int idxMessageSize = pta.Count;
pta.Add(PropTag.MessageSize);
int idxCreationTime = pta.Count;
pta.Add(PropTag.CreationTime);
int idxExtraPtags = pta.Count;
if (additionalPtagsToLoad != null)
{
pta.AddRange(additionalPtagsToLoad);
}
for (int i = 0; i < array.Length; i++)
{
if (result.Count >= keysToLookup.Count)
{
break;
}
ContentsTableFlags flags = ContentsTableFlags.DeferredErrors | array[i];
bool doingFAI = (flags & ContentsTableFlags.Associated) != ContentsTableFlags.None;
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("MapiFolder.GetContentsTable", OperationType.None),
new SimpleValueDataContext("Flags", flags)
}).Execute(delegate
{
MapiTable msgTable;
using (this.Mailbox.RHTracker.Start())
{
msgTable = this.Folder.GetContentsTable(flags);
}
using (msgTable)
{
if (ptagToLookup != PropTag.EntryId)
{
using (this.Mailbox.RHTracker.Start())
{
msgTable.SortTable(new SortOrder(ptagToLookup, SortFlags.Ascend), SortTableFlags.None);
}
}
msgTable.SetColumns(pta);
using (List <byte[]> .Enumerator enumerator = keysToLookup.GetEnumerator())
{
while (enumerator.MoveNext())
{
byte[] key = enumerator.Current;
if (!result.ContainsKey(key))
{
ExecutionContext.Create(new DataContext[]
{
new EntryIDsDataContext(key)
}).Execute(delegate
{
try
{
using (this.Mailbox.RHTracker.Start())
{
if (!msgTable.FindRow(Restriction.EQ(ptagToLookup, key), BookMark.Beginning, FindRowFlag.None))
{
return;
}
}
}
catch (MapiExceptionNotFound)
{
return;
}
PropValue[][] array2;
using (this.Mailbox.RHTracker.Start())
{
array2 = msgTable.QueryRows(1);
}
if (array2.Length == 1)
{
PropValue[] array3 = array2[0];
if (array3.Length != pta.Count)
{
return;
}
PropValueData[] array4 = null;
if (additionalPtagsToLoad != null && additionalPtagsToLoad.Length > 0)
{
array4 = new PropValueData[additionalPtagsToLoad.Length];
for (int j = idxExtraPtags; j < array3.Length; j++)
{
array4[j - idxExtraPtags] = DataConverter <PropValueConverter, PropValue, PropValueData> .GetData(array3[j]);
}
}
MessageRec value = new MessageRec(array3[idxEntryId].GetBytes(), this.FolderId, MapiUtils.GetDateTimeOrDefault(array3[idxCreationTime]), array3[idxMessageSize].GetInt(1000), doingFAI ? MsgRecFlags.Associated : MsgRecFlags.None, array4);
result.Add(key, value);
return;
}
});
}
}
}
}
});
}
MrsTracer.Provider.Debug("MapiFolder.LookupMessages returns {0} items.", new object[]
{
result.Count
});
return(new List <MessageRec>(result.Values));
}
public void ComputeIncrementalMapping(FolderChangesManifest folderChanges, EntryIdMap <BadItemMarker> badItemMarkers, out List <MessageRec> itemsToCopy, out byte[][] deletedTargetEntryIDs, out byte[][] readTargetEntryIDs, out byte[][] unreadTargetEntryIDs, out int skippedItemCount)
{
MrsTracer.Service.Function("FolderContentsMapper.ComputeIncrementalMapping", new object[0]);
skippedItemCount = 0;
itemsToCopy = null;
deletedTargetEntryIDs = null;
readTargetEntryIDs = null;
unreadTargetEntryIDs = null;
List <byte[]> list = new List <byte[]>();
List <byte[]> list2 = new List <byte[]>();
List <byte[]> list3 = new List <byte[]>();
if (folderChanges.ChangedMessages != null)
{
foreach (MessageRec messageRec in folderChanges.ChangedMessages)
{
list2.Add(messageRec.EntryId);
if (!messageRec.IsDeleted)
{
list.Add(messageRec.EntryId);
}
else
{
list3.Add(messageRec.EntryId);
}
}
}
if (folderChanges.ReadMessages != null)
{
list2.AddRange(folderChanges.ReadMessages);
}
if (folderChanges.UnreadMessages != null)
{
list2.AddRange(folderChanges.UnreadMessages);
}
if (list2.Count == 0)
{
return;
}
list2.Sort(ArrayComparer <byte> .Comparer);
List <PropTag> list4 = new List <PropTag>();
list4.Add(PropTag.SearchKey);
list4.Add(PropTag.LastModificationTime);
list4.Add(PropTag.MessageClass);
List <MessageRec> list5 = null;
if (list.Count > 0)
{
MrsTracer.Service.Debug("Loading changed source messages", new object[0]);
list.Sort(ArrayComparer <byte> .Comparer);
list5 = this.srcFolder.LookupMessages(PropTag.EntryId, list, list4.ToArray());
}
EntryIdMap <MessageRec> entryIdMap = new EntryIdMap <MessageRec>();
if (this.conflictResolutionOption != ConflictResolutionOption.KeepAll)
{
list4.Add(this.destHierarchy.SourceEntryIDPtag);
list4.Add(this.destHierarchy.SourceLastModifiedTimestampPtag);
MrsTracer.Service.Debug("Looking up target messages", new object[0]);
List <MessageRec> list6 = this.destFolder.LookupMessages(this.destHierarchy.SourceEntryIDPtag, list2, list4.ToArray());
foreach (MessageRec messageRec2 in list6)
{
byte[] array = messageRec2[this.destHierarchy.SourceEntryIDPtag] as byte[];
if (array != null)
{
this.targetMapping[array] = messageRec2;
}
byte[] keyPlusLMTHash = this.GetKeyPlusLMTHash(messageRec2, this.destHierarchy.SourceEntryIDPtag, this.destHierarchy.SourceLastModifiedTimestampPtag);
if (keyPlusLMTHash != null)
{
entryIdMap[keyPlusLMTHash] = messageRec2;
}
}
}
if (list5 == null)
{
MrsTracer.Service.Debug("ChangedSourceIds {0}, SourceMessages looked up is null", new object[]
{
list.Count
});
}
else
{
if (list5.Count != list.Count)
{
MrsTracer.Service.Debug("ChangedSourceIds {0}, SourceMessages looked up {1}", new object[]
{
list.Count,
list5.Count
});
}
itemsToCopy = new List <MessageRec>();
foreach (MessageRec messageRec3 in list5)
{
string text;
if (FolderContentsMapper.ShouldItemBeIgnored(messageRec3, badItemMarkers, this.faiCopyOption, out text))
{
skippedItemCount++;
}
else
{
MessageRec messageRec4 = null;
this.MapSourceToTargetMessageBySourceEntryId(messageRec3, entryIdMap, out messageRec4);
if (!this.ShouldItemBeCopied(messageRec3, messageRec4, null))
{
skippedItemCount++;
}
else
{
if (messageRec4 == null)
{
messageRec3.Flags |= MsgRecFlags.New;
}
itemsToCopy.Add(messageRec3);
this.sourceMapping[messageRec3.EntryId] = messageRec3;
}
}
}
}
if (list3.Count > 0)
{
deletedTargetEntryIDs = this.RemapSourceIDsToTargetIDs(list3);
}
if (folderChanges.ReadMessages != null && folderChanges.ReadMessages.Count > 0)
{
readTargetEntryIDs = this.RemapSourceIDsToTargetIDs(folderChanges.ReadMessages);
}
if (folderChanges.UnreadMessages != null && folderChanges.UnreadMessages.Count > 0)
{
unreadTargetEntryIDs = this.RemapSourceIDsToTargetIDs(folderChanges.UnreadMessages);
}
}
private void RegisterUniqueTargetSecondaryKeys(MessageRec message, List <byte[]> secondaryKeys, EntryIdMap <MessageRec> messageMap, HashSet <byte[]> duplicateKeys)
{
foreach (byte[] array in secondaryKeys)
{
if (array != null && !duplicateKeys.Contains(array))
{
if (!messageMap.ContainsKey(array))
{
messageMap.Add(array, message);
}
else
{
MrsTracer.Service.Debug("Duplicate SecondaryKey found for target message {0}", new object[]
{
TraceUtils.DumpEntryId(message.EntryId)
});
messageMap.Remove(array);
duplicateKeys.Add(array);
}
}
}
}
public SimpleTranslatingProxyPool(IFxProxyPool destinationProxyPool, EntryIdMap <byte[]> sourceMap) : base(destinationProxyPool, true)
{
this.sourceMap = sourceMap;
}
public FxProxyPoolGetFolderDataResponseMessage(EntryIdMap <byte[]> folderData)
{
this.folderData = folderData;
}
public void ComputeMapping(IReadOnlyCollection <MessageRec> sourceMessages, IReadOnlyCollection <MessageRec> targetMessages, EntryIdMap <BadItemMarker> badItemMarkers, out int skippedItemCount, out ulong skippedItemSize, out List <MessageRec> itemsToCopy, out List <MessageRec> targetMessagePropsChanges)
{
itemsToCopy = new List <MessageRec>(sourceMessages.Count);
targetMessagePropsChanges = new List <MessageRec>();
skippedItemCount = 0;
skippedItemSize = 0UL;
if (sourceMessages.Count == 0)
{
MrsTracer.Service.Debug("No more contents in source folder", new object[0]);
return;
}
EntryIdMap <MessageRec> entryIdMap = new EntryIdMap <MessageRec>();
HashSet <byte[]> hashSet = new HashSet <byte[]>(ArrayComparer <byte> .EqualityComparer);
EntryIdMap <MessageRec> entryIdMap2 = new EntryIdMap <MessageRec>();
Dictionary <string, List <MessageRec> > dictionary = null;
Dictionary <string, List <MessageRec> > dictionary2 = null;
if (this.faiCopyOption == FAICopyOption.MapByMessageClass)
{
dictionary = this.CreateFaiMap(sourceMessages, badItemMarkers);
dictionary2 = this.CreateFaiMap(targetMessages, badItemMarkers);
}
foreach (MessageRec messageRec in targetMessages)
{
byte[] keyPlusLMTHash = this.GetKeyPlusLMTHash(messageRec, this.destHierarchy.SourceEntryIDPtag, this.destHierarchy.SourceLastModifiedTimestampPtag);
if (keyPlusLMTHash != null)
{
entryIdMap2[keyPlusLMTHash] = messageRec;
}
List <byte[]> secondaryKeys = this.GetSecondaryKeys(messageRec, MessageRecType.Target);
this.RegisterUniqueTargetSecondaryKeys(messageRec, secondaryKeys, entryIdMap, hashSet);
}
HashSet <byte[]> uniqueSecondaryKeys = new HashSet <byte[]>(ArrayComparer <byte> .EqualityComparer);
HashSet <byte[]> hashSet2 = new HashSet <byte[]>(ArrayComparer <byte> .EqualityComparer);
foreach (MessageRec message in sourceMessages)
{
List <byte[]> secondaryKeys2 = this.GetSecondaryKeys(message, MessageRecType.Source);
this.IdentifyDuplicateSecondaryKeys(message, secondaryKeys2, uniqueSecondaryKeys, hashSet2);
}
foreach (MessageRec messageRec2 in sourceMessages)
{
string text;
if (FolderContentsMapper.ShouldItemBeIgnored(messageRec2, badItemMarkers, this.faiCopyOption, out text))
{
skippedItemCount++;
skippedItemSize += (ulong)((long)messageRec2.MessageSize);
}
else
{
MessageRec messageRec3 = null;
List <MessageRec> list;
List <MessageRec> list2;
if (this.faiCopyOption == FAICopyOption.MapByMessageClass && messageRec2.IsFAI && !string.IsNullOrEmpty(text) && dictionary.TryGetValue(text, out list) && list.Count == 1 && dictionary2.TryGetValue(text, out list2) && list2.Count == 1)
{
messageRec3 = list2[0];
MrsTracer.Service.Debug("Mapped FAI message with message class '{0}'", new object[]
{
text
});
}
if (messageRec3 == null)
{
this.MapSourceToTargetMessage(messageRec2, entryIdMap2, entryIdMap, hashSet, hashSet2, out messageRec3);
}
MessageRec item = null;
if (this.ShouldTargetMessagePropsBeUpdated(messageRec2, messageRec3, out item))
{
skippedItemCount++;
skippedItemSize += (ulong)((long)messageRec2.MessageSize);
targetMessagePropsChanges.Add(item);
}
else if (this.ShouldItemBeCopied(messageRec2, messageRec3, hashSet))
{
itemsToCopy.Add(messageRec2);
this.sourceMapping[messageRec2.EntryId] = messageRec2;
if (messageRec3 != null)
{
this.targetMapping[messageRec2.EntryId] = messageRec3;
}
}
else
{
skippedItemCount++;
skippedItemSize += (ulong)((long)messageRec2.MessageSize);
}
}
}
}
private Dictionary <string, List <MessageRec> > CreateFaiMap(IReadOnlyCollection <MessageRec> messages, EntryIdMap <BadItemMarker> badItemMarkers)
{
Dictionary <string, List <MessageRec> > dictionary = new Dictionary <string, List <MessageRec> >(StringComparer.OrdinalIgnoreCase);
foreach (MessageRec messageRec in messages)
{
string text;
if (messageRec.IsFAI && !FolderContentsMapper.ShouldItemBeIgnored(messageRec, badItemMarkers, this.faiCopyOption, out text) && !string.IsNullOrEmpty(text))
{
List <MessageRec> list;
if (!dictionary.TryGetValue(text, out list))
{
list = new List <MessageRec>(1);
dictionary.Add(text, list);
}
list.Add(messageRec);
}
}
return(dictionary);
}
