public bool CompareRootFolders()
{
ISourceFolder folder = base.SourceMailbox.GetFolder(null);
if (folder == null)
{
throw new RootFolderNotFoundPermananentException();
}
FolderRec folderRec;
using (folder)
{
folderRec = folder.GetFolderRec(null, GetFolderRecFlags.None);
}
IDestinationFolder folder2 = base.DestMailbox.GetFolder(null);
if (folder2 == null)
{
throw new RootFolderNotFoundPermananentException();
}
FolderRec folderRec2;
using (folder2)
{
folderRec2 = folder2.GetFolderRec(null, GetFolderRecFlags.None);
}
if (!CommonUtils.IsSameEntryId(folderRec.EntryId, folderRec2.EntryId))
{
MrsTracer.Service.Warning("Root folder IDs don't match on source and destination mailboxes. Restarting the move.", new object[0]);
return(false);
}
return(true);
}
public ManifestContentChangesFetcher(ISourceFolder folder, MapiFolder mapiFolder, MailboxProviderBase mailbox, bool isPagedEnumeration)
{
this.folder = folder;
this.mapiFolder = mapiFolder;
this.mailbox = mailbox;
this.isPagedEnumeration = isPagedEnumeration;
}
public static FolderContentsMapper Create(FolderMapping folderMapping, ISourceFolder srcFolder, FolderHierarchy sourceHierarchy, IDestinationFolder destFolder, FolderHierarchy destHierarchy, ConflictResolutionOption conflictResolutionOption, FAICopyOption faiCopyOption, FolderContentsMapperFlags mapperFlags)
{
if (!mapperFlags.HasFlag(FolderContentsMapperFlags.ImapSync))
{
return(new FolderContentsMapper(folderMapping, srcFolder, sourceHierarchy, destFolder, destHierarchy, conflictResolutionOption, faiCopyOption, mapperFlags));
}
return(new ImapFolderContentsMapper(folderMapping, srcFolder, sourceHierarchy, destFolder, destHierarchy, conflictResolutionOption, faiCopyOption, mapperFlags));
}
public override void ApplyContentsChanges(SyncContext ctx, MailboxChanges changes)
{
MrsTracer.Service.Function("MailboxMerger.ApplyContentsChanges", new object[0]);
if (changes.HasFolderRecoverySync)
{
return;
}
foreach (FolderChangesManifest folderChangesManifest in changes.FolderChanges.Values)
{
FolderMapping folderMapping = (FolderMapping)this.SourceHierarchy[folderChangesManifest.FolderId];
if (folderMapping == null)
{
MrsTracer.Service.Warning("Folder {0} is not discovered in source, will not apply changes", new object[]
{
TraceUtils.DumpEntryId(folderChangesManifest.FolderId)
});
return;
}
using (ISourceFolder folder = base.SourceMailbox.GetFolder(folderMapping.EntryId))
{
if (folder == null)
{
MrsTracer.Service.Warning("Folder {0} disappeared from source, will not apply changes", new object[]
{
TraceUtils.DumpEntryId(folderChangesManifest.FolderId)
});
return;
}
byte[] array = base.FolderIdTranslator.TranslateFolderId(folderChangesManifest.FolderId);
if (array == null)
{
MrsTracer.Service.Warning("Source folder {0} is not present in target mailbox, will not apply changes", new object[]
{
TraceUtils.DumpEntryId(folderChangesManifest.FolderId)
});
return;
}
using (IDestinationFolder folder2 = base.DestMailbox.GetFolder(array))
{
if (folder2 == null)
{
MrsTracer.Service.Warning("Destination folder {0} disappeared, will not apply changes", new object[]
{
TraceUtils.DumpEntryId(array)
});
return;
}
this.ApplyFolderChanges(ctx, folderChangesManifest, folderMapping, folder, folder2);
}
}
}
base.ReportContentChangesSynced(ctx);
base.ICSSyncState.ProviderState = base.SourceMailbox.GetMailboxSyncState();
base.SaveICSSyncState(false);
}
protected FolderContentsMapper(FolderMapping folderMapping, ISourceFolder srcFolder, FolderHierarchy sourceHierarchy, IDestinationFolder destFolder, FolderHierarchy destHierarchy, ConflictResolutionOption conflictResolutionOption, FAICopyOption faiCopyOption, FolderContentsMapperFlags mapperFlags)
{
this.folderMapping = folderMapping;
this.srcFolder = srcFolder;
this.destFolder = destFolder;
this.destHierarchy = destHierarchy;
this.sourceHierarchy = sourceHierarchy;
this.conflictResolutionOption = conflictResolutionOption;
this.faiCopyOption = faiCopyOption;
this.sourceMapping = new EntryIdMap <MessageRec>();
this.targetMapping = new EntryIdMap <MessageRec>();
this.mapperFlags = mapperFlags;
}
public void CopyFolderData(FolderMapping fm, ISourceFolder srcFolder, IDestinationFolder destFolder)
{
MrsTracer.Service.Debug("Loading mappable folder properties", new object[0]);
FolderRecDataFlags dataToCopy = FolderRecDataFlags.SearchCriteria;
if (!base.MRSJob.CachedRequestJob.IsPublicFolderMailboxRestore)
{
bool flag;
this.CopyFolderProperties(fm, srcFolder, destFolder, dataToCopy, out flag);
}
if (fm.FolderType != FolderType.Search)
{
this.MergeFolderContents(fm, srcFolder, destFolder);
}
}
public void FolderExportMessages(ISourceFolder folder, CopyMessagesFlags flags, byte[][] entryIds)
{
this.RunExportThread(delegate
{
using (BufferedTransmitter bufferedTransmitter = new BufferedTransmitter(this, this.service.ExportBufferSizeFromMrsKB, false, this.service.UseBufferring, this.service.UseCompression))
{
using (AsynchronousTransmitter asynchronousTransmitter = new AsynchronousTransmitter(bufferedTransmitter, false))
{
using (FxProxyTransmitter fxProxyTransmitter = new FxProxyTransmitter(asynchronousTransmitter, false))
{
folder.ExportMessages(fxProxyTransmitter, flags, entryIds);
}
}
}
});
}
public void FolderExport(ISourceFolder folder, CopyPropertiesFlags flags, PropTag[] excludeTags)
{
this.RunExportThread(delegate
{
using (BufferedTransmitter bufferedTransmitter = new BufferedTransmitter(this, this.service.ExportBufferSizeFromMrsKB, false, this.service.UseBufferring, this.service.UseCompression))
{
using (AsynchronousTransmitter asynchronousTransmitter = new AsynchronousTransmitter(bufferedTransmitter, false))
{
using (FxProxyTransmitter fxProxyTransmitter = new FxProxyTransmitter(asynchronousTransmitter, false))
{
folder.CopyTo(fxProxyTransmitter, flags, excludeTags);
}
}
}
});
}
private void ExportSingleFolder(IFxProxyPool proxyPool, byte[] folderEntryId, ExportFoldersDataToCopyFlags exportFoldersDataToCopyFlags, GetFolderRecFlags folderRecFlags, PropTag[] additionalFolderRecProps, CopyPropertiesFlags copyPropertiesFlags, PropTag[] excludePropertiesFromCopy, AclFlags extendedAclFlags)
{
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("StorageSourceMailbox.ExportSingleFolder", OperationType.None),
new EntryIDsDataContext(folderEntryId),
new SimpleValueDataContext("exportFoldersDataToCopyFlags", exportFoldersDataToCopyFlags),
new SimpleValueDataContext("folderRecFlags", folderRecFlags),
new PropTagsDataContext(additionalFolderRecProps),
new SimpleValueDataContext("copyPropertiesFlags", copyPropertiesFlags),
new PropTagsDataContext(excludePropertiesFromCopy),
new SimpleValueDataContext("extendedAclFlags", extendedAclFlags)
}).Execute(delegate
{
using (this.RHTracker.Start())
{
using (ISourceFolder folder = this.GetFolder <StorageSourceFolder>(folderEntryId))
{
if (folder == null)
{
MrsTracer.Provider.Debug("Folder {0} is missing in source. Skipping.", new object[]
{
TraceUtils.DumpEntryId(folderEntryId)
});
}
else
{
using (IFolderProxy folderProxyForExportFolder = StorageSourceMailbox.GetFolderProxyForExportFolder(proxyPool, folder, exportFoldersDataToCopyFlags, folderRecFlags, additionalFolderRecProps))
{
if (extendedAclFlags != AclFlags.None)
{
this.ExportExtendedAcls(extendedAclFlags, folder, folderProxyForExportFolder);
}
using (FxProxyBudgetWrapper fxProxyBudgetWrapper = new FxProxyBudgetWrapper(folderProxyForExportFolder, false, new Func <IDisposable>(this.RHTracker.StartExclusive), new Action <uint>(this.RHTracker.Charge)))
{
if (exportFoldersDataToCopyFlags.HasFlag(ExportFoldersDataToCopyFlags.IncludeCopyToStream))
{
folder.CopyTo(fxProxyBudgetWrapper, copyPropertiesFlags, excludePropertiesFromCopy);
}
}
}
}
}
}
});
}
public override FolderMap GetSourceFolderMap(GetFolderMapFlags flags)
{
base.SourceMailboxWrapper.LoadFolderMap(flags, delegate
{
List <FolderRecWrapper> list = new List <FolderRecWrapper>(this.hierarchyFolderEntryIds.Count);
foreach (byte[] entryId in this.hierarchyFolderEntryIds)
{
byte[] sessionSpecificEntryId = base.SourceMailbox.GetSessionSpecificEntryId(entryId);
using (ISourceFolder folder = base.SourceMailbox.GetFolder(sessionSpecificEntryId))
{
list.Add(new FolderRecWrapper(folder.GetFolderRec(null, GetFolderRecFlags.None)));
}
}
return(new PublicFolderMap(list));
});
return(base.SourceMailboxWrapper.FolderMap);
}
ISourceFolder ISourceMailbox.GetFolder(byte[] entryId)
{
ISourceFolder result = null;
base.CreateContext("ISourceMailbox.GetFolder", new DataContext[]
{
new EntryIDsDataContext(entryId)
}).Execute(delegate
{
result = ((ISourceMailbox)this.WrappedObject).GetFolder(entryId);
}, true);
if (result == null)
{
return(null);
}
return(new SourceFolderWrapper(result, base.CreateContext, base.ProviderInfo));
}
public void MergeFolderContentsPaged(FolderMapping folder, FolderContentsCrawler sourceFolderCrawler, IDestinationFolder destFolder, TimeSpan maxOperationDuration)
{
MrsTracer.Service.Function("MailboxMerger.MergeFolderContentsPaged({0})", new object[]
{
folder.FullFolderName
});
ISourceFolder wrappedObject = sourceFolderCrawler.WrappedObject;
if (this.ContentRestriction != null)
{
wrappedObject.SetContentsRestriction(this.ContentRestriction);
}
FolderContentsMapper folderContentsMapper = FolderContentsMapper.Create(folder, wrappedObject, this.SourceHierarchy, destFolder, this.DestHierarchy, this.GetConflictResolutionOption(folder), base.MRSJob.CachedRequestJob.AssociatedMessagesCopyOption ?? FAICopyOption.DoNotCopy, (base.MRSJob.CachedRequestJob.SyncProtocol == SyncProtocol.Imap) ? FolderContentsMapperFlags.ImapSync : FolderContentsMapperFlags.None);
DateTime utcNow = DateTime.UtcNow;
int alreadyCopiedCount;
ulong alreadyCopiedSize;
List <MessageRec> itemsToCopy;
List <MessageRec> list;
while (folderContentsMapper.ComputeMappingPaged(sourceFolderCrawler, (base.SyncState == null) ? null : base.SyncState.BadItems, out alreadyCopiedCount, out alreadyCopiedSize, out itemsToCopy, out list))
{
SyncProtocol syncProtocol = base.MRSJob.CachedRequestJob.SyncProtocol;
foreach (MessageRec messageRec in list)
{
destFolder.SetMessageProps(messageRec.EntryId, messageRec.AdditionalProps);
}
base.MailboxSizeTracker.TrackFolder(folder.EntryId, sourceFolderCrawler.TotalMessageCount, alreadyCopiedCount, alreadyCopiedSize);
base.MRSJob.MessagesWritten += base.MailboxSizeTracker.AlreadyCopiedCount;
base.MRSJob.MessageSizeWritten += base.MailboxSizeTracker.AlreadyCopiedSize;
base.MRSJob.TotalMessages = base.MailboxSizeTracker.MessageCount;
base.MRSJob.TotalMessageByteSize = base.MailboxSizeTracker.TotalMessageSize;
this.CopyMessageBatch(folderContentsMapper, itemsToCopy, folder);
DateTime utcNow2 = DateTime.UtcNow;
if (utcNow2 - utcNow >= maxOperationDuration)
{
MrsTracer.Service.Debug("MergeFolderContentsPaged times out for assigned duration {0}. Start:{1}, End:{2}", new object[]
{
maxOperationDuration,
utcNow,
utcNow2
});
return;
}
}
}
protected void CopyFolder(FolderMapping fm)
{
base.RefreshRequestIfNeeded();
base.TimeTracker.CurrentState = RequestState.CopyingMessages;
base.TestIntegration.Barrier("PostponeWriteMessages", new Action(base.RefreshRequestIfNeeded));
base.CheckServersHealth();
ExecutionContext.Create(new DataContext[]
{
new FolderRecWrapperDataContext(fm)
}).Execute(delegate
{
if (this.CachedRequestJob.IsPublicFolderMailboxRestore && fm.TargetFolder == null)
{
this.Warnings.Add(MrsStrings.FolderIsMissing(HexConverter.ByteArrayToHexString(fm.EntryId)));
return;
}
using (ISourceFolder folder = this.MailboxMerger.SourceMailbox.GetFolder(fm.EntryId))
{
if (folder == null)
{
this.Report.Append(MrsStrings.ReportSourceFolderDeleted(fm.FullFolderName, TraceUtils.DumpEntryId(fm.EntryId)));
}
else
{
using (IDestinationFolder folder2 = this.MailboxMerger.DestMailbox.GetFolder(fm.TargetFolder.EntryId))
{
if (folder2 == null)
{
this.Report.Append(MrsStrings.ReportTargetFolderDeleted(fm.TargetFolder.FullFolderName, TraceUtils.DumpEntryId(fm.TargetFolder.EntryId), fm.FullFolderName));
}
else
{
this.Report.Append(MrsStrings.ReportMergingFolder(fm.FullFolderName, fm.TargetFolder.FullFolderName));
this.CopyFolderData(fm, folder, folder2);
folder2.Flush();
}
}
}
}
});
base.SaveState(SaveStateFlags.Lazy, null);
}
public override void CopyFolderProperties(FolderRecWrapper folderRec, ISourceFolder sourceFolder, IDestinationFolder destFolder, FolderRecDataFlags dataToCopy, out bool wasPropertyCopyingSkipped)
{
base.CopyFolderProperties(folderRec, sourceFolder, destFolder, dataToCopy, out wasPropertyCopyingSkipped);
MrsTracer.Service.Debug("Stamping additional properties on the target folder", new object[0]);
List <PropValueData> list = new List <PropValueData>(3);
list.Add(new PropValueData(this.DestHierarchy.SourceEntryIDPtag, folderRec.EntryId));
list.Add(new PropValueData(this.DestHierarchy.SourceLastModifiedTimestampPtag, folderRec.FolderRec.LastModifyTimestamp));
WellKnownFolderType wellKnownFolderType = WellKnownFolderType.None;
if (this.SourceHierarchy != null)
{
wellKnownFolderType = this.SourceHierarchy.GetWellKnownFolderType(folderRec.EntryId);
}
if (wellKnownFolderType != WellKnownFolderType.None)
{
list.Add(new PropValueData(this.DestHierarchy.SourceWKFTypePtag, (int)wellKnownFolderType));
}
destFolder.SetProps(list.ToArray());
}
private void ExportExtendedAcls(AclFlags extendedAclFlags, ISourceFolder srcFolder, IFolderProxy targetFolder)
{
base.VerifyCapability(MRSProxyCapabilities.SetItemProperties, CapabilityCheck.BothMRSAndOtherProvider);
if (extendedAclFlags.HasFlag(AclFlags.FolderAcl))
{
PropValueData[][] extendedAcl = srcFolder.GetExtendedAcl(AclFlags.FolderAcl);
if (extendedAcl != null)
{
targetFolder.SetItemProperties(new FolderAcl(AclFlags.FolderAcl, extendedAcl));
}
}
if (extendedAclFlags.HasFlag(AclFlags.FreeBusyAcl))
{
PropValueData[][] extendedAcl2 = srcFolder.GetExtendedAcl(AclFlags.FreeBusyAcl);
if (extendedAcl2 != null)
{
targetFolder.SetItemProperties(new FolderAcl(AclFlags.FreeBusyAcl, extendedAcl2));
}
}
}
protected override void BeforeDataCopy()
{
base.MailboxMerger.SourceHierarchy.EnumerateFolderHierarchy(EnumHierarchyFlags.NormalFolders | EnumHierarchyFlags.RootFolder, delegate(FolderRecWrapper folderRec, FolderMap.EnumFolderContext context)
{
FolderMapping folderMapping = (FolderMapping)folderRec;
if (!folderMapping.IsIncluded)
{
return;
}
using (ISourceFolder folder = base.MailboxMerger.SourceMailbox.GetFolder(folderMapping.EntryId))
{
if (folder != null)
{
FolderRec folderRec2 = folder.GetFolderRec(base.MailboxMerger.GetAdditionalFolderPtags(), GetFolderRecFlags.None);
base.MailboxMerger.CatchupFolder(folderRec2, folder);
}
}
});
base.MailboxMerger.ICSSyncState.ProviderState = base.MailboxMerger.SourceMailbox.GetMailboxSyncState();
base.MailboxMerger.SaveICSSyncState(true);
}
public void MergeFolderContents(FolderMapping fm, ISourceFolder srcFolder, IDestinationFolder destFolder)
{
MrsTracer.Service.Function("MailboxMerger.MergeFolderContents({0})", new object[]
{
fm.FullFolderName
});
if (this.ContentRestriction != null)
{
srcFolder.SetContentsRestriction(this.ContentRestriction);
}
FolderContentsMapper folderContentsMapper = FolderContentsMapper.Create(fm, srcFolder, this.SourceHierarchy, destFolder, this.DestHierarchy, this.GetConflictResolutionOption(fm), base.MRSJob.CachedRequestJob.AssociatedMessagesCopyOption ?? FAICopyOption.DoNotCopy, (base.MRSJob.CachedRequestJob.SyncProtocol == SyncProtocol.Imap) ? FolderContentsMapperFlags.ImapSync : FolderContentsMapperFlags.None);
int num;
ulong num2;
List <MessageRec> list;
List <MessageRec> list2;
folderContentsMapper.ComputeMapping((base.SyncState == null) ? null : base.SyncState.BadItems, out num, out num2, out list, out list2);
SyncProtocol syncProtocol = base.MRSJob.CachedRequestJob.SyncProtocol;
foreach (MessageRec messageRec in list2)
{
destFolder.SetMessageProps(messageRec.EntryId, messageRec.AdditionalProps);
}
base.MailboxSizeTracker.TrackFolder(fm.EntryId, list, num, num2);
int num3;
ulong num4;
base.MailboxSizeTracker.GetFolderSize(fm.EntryId, out num3, out num4);
base.Report.Append(MrsStrings.ReportFolderMergeStats(num3 - num, new ByteQuantifiedSize(num4 - num2).ToString(), num, new ByteQuantifiedSize(num2).ToString()));
base.MRSJob.TotalMessages = base.MailboxSizeTracker.MessageCount;
base.MRSJob.TotalMessageByteSize = base.MailboxSizeTracker.TotalMessageSize;
base.MRSJob.MessagesWritten = base.MailboxSizeTracker.AlreadyCopiedCount;
base.MRSJob.MessageSizeWritten = base.MailboxSizeTracker.AlreadyCopiedSize;
this.CopyMessageBatch(folderContentsMapper, list, fm);
base.MailboxSizeTracker.TrackFolder(fm.EntryId, null, num3, num4);
}
public override void CopyFolderProperties(FolderRecWrapper sourceFolderRecWrapper, ISourceFolder sourceFolder, IDestinationFolder destFolder, FolderRecDataFlags dataToCopy, out bool wasPropertyCopyingSkipped)
{
wasPropertyCopyingSkipped = false;
if (this.sessionSpecificEntryIds.ContainsKey(sourceFolderRecWrapper.EntryId) && destFolder != null)
{
if (base.SupportsPerUserReadUnreadDataTransfer)
{
using (IFxProxy fxProxy = destFolder.GetFxProxy(FastTransferFlags.PassThrough))
{
using (IFxProxy fxProxy2 = base.CreateFxProxyTransmissionPipeline(fxProxy))
{
sourceFolder.CopyTo(fxProxy2, CopyPropertiesFlags.CopyFolderPerUserData, Array <PropTag> .Empty);
}
}
}
base.CopyFolderProperties(sourceFolderRecWrapper, sourceFolder, destFolder, FolderRecDataFlags.Rules, out wasPropertyCopyingSkipped);
}
}
public void FinalSyncCopyMailboxData()
{
if (base.MRSJob.TestIntegration.RemoteExchangeGuidOverride == Guid.Empty)
{
using (IFxProxy fxProxy = base.DestMailbox.GetFxProxy())
{
using (IFxProxy fxProxy2 = base.CreateFxProxyTransmissionPipeline(fxProxy))
{
base.SourceMailbox.CopyTo(fxProxy2, new PropTag[]
{
PropTag.ContainerHierarchy,
PropTag.ContainerContents
});
}
}
if (this.ServerSupportsInferencePropertiesMove(base.SourceMailboxWrapper.MailboxVersion) && this.ServerSupportsInferencePropertiesMove(base.DestMailboxWrapper.MailboxVersion) && base.MRSJob.GetConfig <bool>("CopyInferenceProperties"))
{
byte[] badItemId = BitConverter.GetBytes(base.SourceMailbox.GetHashCode());
CommonUtils.ProcessKnownExceptions(delegate
{
List <PropValueData> list = new List <PropValueData>(2);
foreach (PropValueData propValueData in this.SourceMailbox.GetProps(MailboxMover.inferencePropertiesToMove))
{
if (((PropTag)propValueData.PropTag).ValueType() != PropType.Error)
{
list.Add(propValueData);
}
}
badItemId = BadMessageRec.ComputeKey(list.ToArray());
if (!this.SyncState.BadItems.ContainsKey(badItemId))
{
this.DestMailbox.SetProps(list.ToArray());
}
}, delegate(Exception failure)
{
if (MapiUtils.IsBadItemIndicator(failure))
{
List <BadMessageRec> list = new List <BadMessageRec>(1);
list.Add(BadMessageRec.InferenceData(failure, badItemId));
this.ReportBadItems(list);
return(true);
}
return(false);
});
}
}
if (base.SupportsPerUserReadUnreadDataTransfer)
{
base.Report.Append(MrsStrings.ReportCopyPerUserReadUnreadDataStarted);
using (ISourceFolder folder = base.SourceMailbox.GetFolder(null))
{
using (IDestinationFolder folder2 = base.DestMailbox.GetFolder(null))
{
using (IFxProxy fxProxy3 = folder2.GetFxProxy(FastTransferFlags.PassThrough))
{
using (IFxProxy fxProxy4 = base.CreateFxProxyTransmissionPipeline(fxProxy3))
{
folder.CopyTo(fxProxy4, CopyPropertiesFlags.CopyMailboxPerUserData, Array <PropTag> .Empty);
}
}
}
}
base.Report.Append(MrsStrings.ReportCopyPerUserReadUnreadDataCompleted);
}
}
protected override void CatchupFolderHierarchy()
{
if (!this.PrimaryHierarchyMbxWrapper.Mailbox.IsConnected())
{
this.PrimaryHierarchyMbxWrapper.Mailbox.Connect(MailboxConnectFlags.None);
}
bool flag = false;
bool flag2 = false;
Guid hierarchyMailboxGuid = this.publicFolderConfiguration.GetHierarchyMailboxInformation().HierarchyMailboxGuid;
if (hierarchyMailboxGuid == base.CachedRequestJob.SourceExchangeGuid)
{
flag = true;
}
else if (hierarchyMailboxGuid == base.CachedRequestJob.TargetExchangeGuid)
{
flag2 = true;
}
foreach (byte[] array in this.foldersToMove)
{
if (flag)
{
using (IFolder folder = ((ISourceMailbox)this.PrimaryHierarchyMbxWrapper.Mailbox).GetFolder(array))
{
using (IDestinationFolder folder2 = this.publicFolderMover.DestMailbox.GetFolder(this.publicFolderMover.DestMailbox.GetSessionSpecificEntryId(array)))
{
if (folder2 == null)
{
if (folder != null)
{
MrsTracer.Service.Error("Inconsistency of hierarchy seen at target mailbox...May be a delay in hierarchy synchronization", new object[0]);
throw new DestinationFolderHierarchyInconsistentTransientException();
}
MrsTracer.Service.Debug("Folder {0} unavailable at both source and destination mailbox during catchup", new object[]
{
HexConverter.ByteArrayToHexString(array)
});
}
}
continue;
}
}
if (flag2)
{
using (IFolder folder3 = ((IDestinationMailbox)this.PrimaryHierarchyMbxWrapper.Mailbox).GetFolder(array))
{
using (ISourceFolder folder4 = this.publicFolderMover.SourceMailbox.GetFolder(this.publicFolderMover.SourceMailbox.GetSessionSpecificEntryId(array)))
{
if (folder4 == null)
{
if (folder3 != null)
{
MrsTracer.Service.Error("Inconsistency of hierarchy seen at source mailbox...May be a delay in hierarchy synchronization", new object[0]);
throw new SourceFolderHierarchyInconsistentTransientException();
}
MrsTracer.Service.Debug("Folder {0} unavailable at both source and destination mailbox during catchup", new object[]
{
HexConverter.ByteArrayToHexString(array)
});
}
}
continue;
}
}
using (IFolder folder5 = ((IDestinationMailbox)this.PrimaryHierarchyMbxWrapper.Mailbox).GetFolder(array))
{
if (folder5 == null)
{
MrsTracer.Service.Debug("Folder {0} unavailable at hierarchy mailbox during catchup", new object[]
{
HexConverter.ByteArrayToHexString(array)
});
}
else
{
using (ISourceFolder folder6 = this.publicFolderMover.SourceMailbox.GetFolder(this.publicFolderMover.SourceMailbox.GetSessionSpecificEntryId(array)))
{
if (folder6 == null)
{
MrsTracer.Service.Error("Inconsistency of hierarchy seen at source mailbox...May be a delay in hierarchy synchronization", new object[0]);
throw new SourceFolderHierarchyInconsistentTransientException();
}
}
using (IDestinationFolder folder7 = this.publicFolderMover.DestMailbox.GetFolder(this.publicFolderMover.DestMailbox.GetSessionSpecificEntryId(array)))
{
if (folder7 == null)
{
MrsTracer.Service.Error("Inconsistency of hierarchy seen at target mailbox...May be a delay in hierarchy synchronization", new object[0]);
throw new DestinationFolderHierarchyInconsistentTransientException();
}
}
}
}
}
base.SyncStage = SyncStage.CreatingInitialSyncCheckpoint;
base.OverallProgress = 15;
base.TimeTracker.CurrentState = RequestState.CreatingInitialSyncCheckpoint;
base.SaveState(SaveStateFlags.Regular, delegate(TransactionalRequestJob moveRequest)
{
moveRequest.RestartFromScratch = false;
});
base.ScheduleWorkItem(new Action(base.CatchupFolders), WorkloadType.Unknown);
}
public TitaniumContentChangesFetcher(ISourceFolder folder, MapiFolder mapiFolder, MailboxProviderBase mailbox)
{
this.folder = folder;
this.mapiFolder = mapiFolder;
this.mailbox = mailbox;
}
protected virtual void CopyFolderData(FolderMapping fm, ISourceFolder srcFolder, IDestinationFolder destFolder)
{
this.MailboxMerger.CopyFolderData(fm, srcFolder, destFolder);
}
public override void CopyFolderProperties(FolderRecWrapper sourceFolderRecWrapper, ISourceFolder sourceFolder, IDestinationFolder destFolder, FolderRecDataFlags dataToCopy, out bool wasPropertyCopyingSkipped)
{
Guid empty = Guid.Empty;
bool isRoot = base.IsRoot;
bool flag = false;
wasPropertyCopyingSkipped = false;
FolderMapping folderMapping = sourceFolderRecWrapper as FolderMapping;
while (folderMapping.WKFType != WellKnownFolderType.Root)
{
if (folderMapping.IsLegacyPublicFolder)
{
return;
}
folderMapping = (folderMapping.Parent as FolderMapping);
}
if (destFolder == null)
{
if (!isRoot || ((FolderMapping)sourceFolderRecWrapper).IsSystemPublicFolder)
{
MrsTracer.Service.Debug("Skipping final property copying for \"{0}\" folder since it's contents don't reside in this mailbox", new object[]
{
sourceFolderRecWrapper.FullFolderName
});
return;
}
throw new FolderCopyFailedPermanentException(sourceFolderRecWrapper.FullFolderName);
}
else
{
PropValueData[] props = destFolder.GetProps(new PropTag[]
{
PropTag.ReplicaList,
PropTag.IpmWasteBasketEntryId
});
IDataConverter <PropValue, PropValueData> dataConverter = new PropValueConverter();
PropValue nativeRepresentation = dataConverter.GetNativeRepresentation(props[0]);
byte[] array = nativeRepresentation.Value as byte[];
if (!nativeRepresentation.IsNull() && !nativeRepresentation.IsError() && array != null)
{
StorePropertyDefinition replicaList = CoreFolderSchema.ReplicaList;
string[] stringArrayFromBytes = ReplicaListProperty.GetStringArrayFromBytes(array);
if (stringArrayFromBytes.Length > 0 && GuidHelper.TryParseGuid(stringArrayFromBytes[0], out empty))
{
flag = (empty == base.TargetMailboxGuid);
}
}
FolderStateSnapshot folderStateSnapshot = base.ICSSyncState[sourceFolderRecWrapper.EntryId];
FolderState state = folderStateSnapshot.State;
if (sourceFolder.GetFolderRec(this.GetAdditionalFolderPtags(), GetFolderRecFlags.None).IsGhosted)
{
folderStateSnapshot.State |= FolderState.IsGhosted;
}
else
{
folderStateSnapshot.State &= ~FolderState.IsGhosted;
}
if (state != folderStateSnapshot.State)
{
base.SaveICSSyncState(false);
}
if (!isRoot && !flag)
{
return;
}
List <PropValueData> list = new List <PropValueData>(2);
bool flag2 = false;
if (flag)
{
PropValue nativeRepresentation2 = dataConverter.GetNativeRepresentation(sourceFolder.GetProps(new PropTag[]
{
PropTag.PfProxy
})[0]);
if (!nativeRepresentation2.IsNull() && !nativeRepresentation2.IsError())
{
byte[] array2 = nativeRepresentation2.Value as byte[];
if (array2 != null && array2.Length == 16 && new Guid(array2) != Guid.Empty)
{
Guid a = Guid.Empty;
bool flag3 = base.Flags.HasFlag(MailboxCopierFlags.CrossOrg);
if (flag3)
{
a = destFolder.LinkMailPublicFolder(LinkMailPublicFolderFlags.EntryId, sourceFolderRecWrapper.EntryId);
}
else
{
a = destFolder.LinkMailPublicFolder(LinkMailPublicFolderFlags.ObjectGuid, array2);
}
if (a != Guid.Empty)
{
list.Add(new PropValueData(PropTag.PfProxy, a.ToByteArray()));
list.Add(new PropValueData(PropTag.PfProxyRequired, true));
flag2 = true;
}
else
{
base.Report.Append(new ReportEntry(MrsStrings.ReportFailedToLinkADPublicFolder(sourceFolderRecWrapper.FullFolderName, BitConverter.ToString(array2), BitConverter.ToString(sourceFolderRecWrapper.EntryId)), ReportEntryType.Warning));
}
}
}
}
if (!flag2)
{
list.Add(new PropValueData(PropTag.PfProxy, Guid.Empty.ToByteArray()));
list.Add(new PropValueData(PropTag.PfProxyRequired, false));
}
List <PropValueData> list2 = new List <PropValueData>(9);
if (isRoot)
{
if (!flag)
{
dataToCopy &= (FolderRecDataFlags.SecurityDescriptors | FolderRecDataFlags.FolderAcls | FolderRecDataFlags.ExtendedAclInformation);
}
list2.AddRange(list);
}
else
{
byte[] sessionSpecificEntryId = this.hierarchyMailbox.GetSessionSpecificEntryId(sourceFolderRecWrapper.EntryId);
using (IDestinationFolder folder = this.hierarchyMailbox.GetFolder(sessionSpecificEntryId))
{
if (folder == null)
{
MrsTracer.Service.Error("Something deleted destination hierarchy folder from under us", new object[0]);
throw new UnexpectedErrorPermanentException(-2147221238);
}
if (list.Count > 0)
{
folder.SetProps(list.ToArray());
}
}
}
base.CopyFolderProperties(sourceFolderRecWrapper, sourceFolder, destFolder, dataToCopy, out wasPropertyCopyingSkipped);
PropTag[] pta = new PropTag[]
{
PropTag.DisablePeruserRead,
PropTag.OverallAgeLimit,
PropTag.RetentionAgeLimit,
PropTag.PfQuotaStyle,
PropTag.PfOverHardQuotaLimit,
PropTag.PfStorageQuota,
PropTag.PfMsgSizeLimit
};
foreach (PropValueData propValueData in sourceFolder.GetProps(pta))
{
PropValue nativeRepresentation3 = dataConverter.GetNativeRepresentation(propValueData);
if (!nativeRepresentation3.IsNull() && !nativeRepresentation3.IsError())
{
if (propValueData.PropTag == 1721303043 && (int)propValueData.Value > 0)
{
propValueData.Value = (int)EnhancedTimeSpan.FromDays((double)((int)propValueData.Value)).TotalSeconds;
}
list2.Add(propValueData);
}
}
if (list2.Count > 0)
{
destFolder.SetProps(list2.ToArray());
}
return;
}
}
public SourceFolderWrapper(ISourceFolder folder, CommonUtils.CreateContextDelegate createContext, ProviderInfo mailboxProviderInfo) : base(folder, createContext)
{
base.ProviderInfo = mailboxProviderInfo;
}
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
});
}
private void ApplyFolderChanges(SyncContext ctx, FolderChangesManifest folderChanges, FolderMapping fm, ISourceFolder srcFolder, IDestinationFolder destFolder)
{
int num = 0;
int num2 = 0;
int num3 = 0;
int num4 = 0;
int num5 = 0;
FolderContentsMapper folderContentsMapper = FolderContentsMapper.Create(fm, srcFolder, this.SourceHierarchy, destFolder, this.DestHierarchy, base.MRSJob.CachedRequestJob.ConflictResolutionOption ?? ConflictResolutionOption.KeepSourceItem, base.MRSJob.CachedRequestJob.AssociatedMessagesCopyOption ?? FAICopyOption.DoNotCopy, (base.MRSJob.CachedRequestJob.SyncProtocol == SyncProtocol.Imap) ? FolderContentsMapperFlags.ImapSync : FolderContentsMapperFlags.None);
List <MessageRec> list;
byte[][] array;
byte[][] array2;
byte[][] array3;
int skipped;
folderContentsMapper.ComputeIncrementalMapping(folderChanges, (base.SyncState == null) ? null : base.SyncState.BadItems, out list, out array, out array2, out array3, out skipped);
this.CopyMessageBatch(folderContentsMapper, list, fm);
destFolder.DeleteMessages(array);
destFolder.SetReadFlagsOnMessages(SetReadFlags.None, array2);
destFolder.SetReadFlagsOnMessages(SetReadFlags.ClearRead, array3);
if (list != null)
{
foreach (MessageRec messageRec in list)
{
if (messageRec.IsNew)
{
num++;
}
else
{
num2++;
}
}
}
if (array != null)
{
num3 += array.Length;
}
if (array2 != null)
{
num4 += array2.Length;
}
if (array3 != null)
{
num5 += array3.Length;
}
ctx.CopyMessagesCount += new CopyMessagesCount(num, num2, num3, num4, num5, skipped);
}
public ImapFolderContentsMapper(FolderMapping folderMapping, ISourceFolder srcFolder, FolderHierarchy sourceHierarchy, IDestinationFolder destFolder, FolderHierarchy destHierarchy, ConflictResolutionOption conflictResolutionOption, FAICopyOption faiCopyOption, FolderContentsMapperFlags mapperFlags) : base(folderMapping, srcFolder, sourceHierarchy, destFolder, destHierarchy, conflictResolutionOption, faiCopyOption, mapperFlags)
{
}
protected override void CatchupFolderHierarchy()
{
if (!this.PrimaryHierarchyMbxWrapper.Mailbox.IsConnected())
{
this.PrimaryHierarchyMbxWrapper.Mailbox.Connect(MailboxConnectFlags.None);
}
FolderRecDataFlags folderRecDataFlags = FolderRecDataFlags.SearchCriteria;
if (!base.CachedRequestJob.SkipFolderPromotedProperties)
{
folderRecDataFlags |= FolderRecDataFlags.PromotedProperties;
}
if (!base.CachedRequestJob.SkipFolderViews)
{
folderRecDataFlags |= FolderRecDataFlags.Views;
}
if (!base.CachedRequestJob.SkipFolderRestrictions)
{
folderRecDataFlags |= FolderRecDataFlags.Restrictions;
}
List <WellKnownFolder> list = this.folderMover.SourceMailbox.DiscoverWellKnownFolders(0);
List <WellKnownFolder> destinationWellKnownFolders = this.folderMover.DestMailbox.DiscoverWellKnownFolders(0);
foreach (byte[] array in this.foldersToMove)
{
using (IFolder folder = ((ISourceMailbox)this.PrimaryHierarchyMbxWrapper.Mailbox).GetFolder(array))
{
using (IDestinationFolder folder2 = this.folderMover.DestMailbox.GetFolder(this.folderMover.DestMailbox.GetSessionSpecificEntryId(array)))
{
if (folder2 == null)
{
if (folder == null)
{
MrsTracer.Service.Debug("Folder {0} unavailable at both source and destination mailbox during catchup", new object[]
{
HexConverter.ByteArrayToHexString(array)
});
}
else
{
List <FolderRecWrapper> list2 = new List <FolderRecWrapper>();
byte[] entryId = array;
for (;;)
{
using (ISourceFolder folder3 = this.folderMover.SourceMailbox.GetFolder(entryId))
{
if (folder3 != null)
{
FolderRecWrapper folderRecWrapper = new FolderRecWrapper(folder3.GetFolderRec(null, GetFolderRecFlags.None));
if (folderRecWrapper.ParentId != null)
{
list2.Insert(0, folderRecWrapper);
bool flag = false;
foreach (WellKnownFolder wellKnownFolder in list)
{
if (CommonUtils.IsSameEntryId(wellKnownFolder.EntryId, folderRecWrapper.ParentId))
{
flag = true;
break;
}
}
if (!flag)
{
entryId = folderRecWrapper.ParentId;
continue;
}
}
}
}
break;
}
foreach (FolderRecWrapper folderRecWrapper2 in list2)
{
byte[] entryId2 = folderRecWrapper2.FolderRec.EntryId;
byte[] parentId = folderRecWrapper2.FolderRec.ParentId;
byte[] sessionSpecificEntryId = this.folderMover.DestMailbox.GetSessionSpecificEntryId(entryId2);
bool flag2 = false;
byte[] destinationFolderIdFromSourceFolderId = AuxFolderMoveJob.GetDestinationFolderIdFromSourceFolderId(list, destinationWellKnownFolders, this.folderMover.DestMailbox, parentId, out flag2);
using (IDestinationFolder folder4 = this.folderMover.DestMailbox.GetFolder(sessionSpecificEntryId))
{
if (folder4 == null)
{
using (ISourceFolder folder5 = this.folderMover.SourceMailbox.GetFolder(entryId2))
{
if (folder5 == null)
{
MrsTracer.Service.Warning("Source folder '{0}' {1} disappeared, skipping", new object[]
{
folderRecWrapper2.FolderName,
folderRecWrapper2.EntryId
});
break;
}
folderRecWrapper2.EnsureDataLoaded(folder5, folderRecDataFlags, this.folderMover);
this.folderMover.TranslateFolderData(folderRecWrapper2);
CreateFolderFlags createFolderFlags = CreateFolderFlags.None;
folderRecWrapper2.FolderRec.EntryId = sessionSpecificEntryId;
folderRecWrapper2.FolderRec.ParentId = destinationFolderIdFromSourceFolderId;
byte[] array2;
this.folderMover.CreateFolder(null, folderRecWrapper2, createFolderFlags, out array2);
folderRecWrapper2.FolderRec.EntryId = entryId2;
folderRecWrapper2.FolderRec.ParentId = parentId;
}
}
}
}
}
}
}
}
}
base.SyncStage = SyncStage.CreatingInitialSyncCheckpoint;
base.OverallProgress = 15;
base.TimeTracker.CurrentState = RequestState.CreatingInitialSyncCheckpoint;
base.SaveState(SaveStateFlags.Regular, delegate(TransactionalRequestJob moveRequest)
{
moveRequest.RestartFromScratch = false;
});
base.ScheduleWorkItem(new Action(base.CatchupFolders), WorkloadType.Unknown);
}
internal FolderMapping GetNextFolderToCopy(out FolderContentsCrawler folderContentsCrawler, out bool shouldCopyProperties)
{
MrsTracer.Service.Function("MailboxContentsCrawler.GetNextFolderToCopy", new object[0]);
base.CheckDisposed();
folderContentsCrawler = null;
shouldCopyProperties = false;
for (int i = 0; i <= this.folderCount; i++)
{
if (!this.folderEnumerator.MoveNext())
{
MrsTracer.Service.Debug("Tail is reached, move to head", new object[0]);
this.folderEnumerator.Reset();
if (!this.folderEnumerator.MoveNext())
{
break;
}
}
FolderMapping folderMapping = this.folderEnumerator.Current;
if (folderMapping.FolderType != FolderType.Search && folderMapping.IsIncluded && !this.crawledFolders.ContainsKey(folderMapping.EntryId))
{
FolderContentsCrawler folderContentsCrawler2;
if (!this.crawlers.TryGetValue(folderMapping.EntryId, out folderContentsCrawler2) && this.crawlers.Count < this.maxFoldersOpened)
{
MrsTracer.Service.Debug("Add crawler for the folder: '{0}'", new object[]
{
folderMapping.FullFolderName
});
ISourceFolder folder = this.sourceMalibox.GetFolder(folderMapping.EntryId);
if (folder != null)
{
folderContentsCrawler2 = new FolderContentsCrawler(folder, this.pageSize, this.maxPageSize)
{
MailboxCopier = this.mailboxCopier
};
using (DisposeGuard disposeGuard = folderContentsCrawler2.Guard())
{
this.crawlers.Add(folderMapping.EntryId, folderContentsCrawler2);
disposeGuard.Success();
shouldCopyProperties = true;
}
}
}
if (folderContentsCrawler2 != null)
{
if (folderContentsCrawler2.HasMoreMessages)
{
MrsTracer.Service.Debug("Return the folder to copy: '{0}'", new object[]
{
folderMapping.FullFolderName
});
folderContentsCrawler = folderContentsCrawler2;
return(folderMapping);
}
MrsTracer.Service.Debug("The folder has completed crawling: '{0}'", new object[]
{
folderMapping.FullFolderName
});
this.crawledFolders.Add(folderMapping.EntryId, folderMapping);
folderContentsCrawler2.Dispose();
this.crawlers.Remove(folderMapping.EntryId);
}
}
}
MrsTracer.Service.Debug("No more folders", new object[0]);
return(null);
}
