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);
}
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);
}
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 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;
}
});
}
}
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 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
});
}