protected override void CopySingleMessage(MessageRec messageRec, IFolderProxy folderProxy, PropTag[] propTagsToExclude, PropTag[] excludeProps)
{
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("EasSourceMailbox.CopySingleMessage", OperationType.None),
new EntryIDsDataContext(messageRec.EntryId)
}).Execute(delegate
{
Add add;
if (this.EasFolderCache.TryGetValue(messageRec.FolderId, out add))
{
EasFolderType easFolderType = add.GetEasFolderType();
if (EasFolder.IsCalendarFolder(easFolderType))
{
Properties calendarItemProperties = this.ReadCalendarItem(messageRec);
EasSourceMailbox.CopyCalendarItem(messageRec, calendarItemProperties, folderProxy);
return;
}
if (EasFolder.IsContactFolder(easFolderType))
{
EasSourceMailbox.CopyContactItem(messageRec, folderProxy);
return;
}
SyncEmailUtils.CopyMimeStream(this, messageRec, folderProxy);
}
});
}
IFolderProxy IFxProxyPool.GetFolderProxy(byte[] folderId)
{
folderId = this.TranslateFolderId(folderId);
IFolderProxy folderProxy = base.WrappedObject.GetFolderProxy(folderId);
return(new FolderContentsMapper.TranslatingProxyPool.TranslatingFolderProxy(this, folderProxy, this.mapper));
}
private static void CopyContactItem(MessageRec messageRec, IFolderProxy folderProxy)
{
ArgumentValidator.ThrowIfNull("messageRec", messageRec);
ArgumentValidator.ThrowIfNull("folderProxy", folderProxy);
EasFxContactMessage message = new EasFxContactMessage(messageRec);
FxUtils.CopyItem(messageRec, message, folderProxy, EasSourceMailbox.EmptyPropTagArray);
}
IMessageProxy IFolderProxy.OpenMessage(byte[] entryId)
{
MessageRec messageRec;
if (!base.Mapper.sourceMapping.TryGetValue(entryId, out messageRec))
{
return(null);
}
List <PropValueData> list = new List <PropValueData>(6);
list.Add(new PropValueData(base.Mapper.destHierarchy.SourceEntryIDPtag, messageRec.EntryId));
object obj = messageRec[PropTag.LastModificationTime];
if (obj == null)
{
obj = CommonUtils.DefaultLastModificationTime;
}
list.Add(new PropValueData(base.Mapper.destHierarchy.SourceLastModifiedTimestampPtag, obj));
if (messageRec.IsFAI)
{
list.Add(new PropValueData(base.Mapper.destHierarchy.SourceMessageClassPtag, messageRec[PropTag.MessageClass]));
}
if (base.Mapper.mapperFlags.HasFlag(FolderContentsMapperFlags.ImapSync))
{
object obj2 = messageRec[base.Mapper.sourceHierarchy.SourceSyncMessageIdPtag];
if (obj2 != null)
{
list.Add(new PropValueData(base.Mapper.destHierarchy.SourceSyncMessageIdPtag, (string)obj2));
}
object obj3 = messageRec[base.Mapper.sourceHierarchy.SourceSyncAccountNamePtag];
if (obj3 != null)
{
list.Add(new PropValueData(base.Mapper.destHierarchy.SourceSyncAccountNamePtag, (string)obj3));
}
byte[] array = messageRec[base.Mapper.sourceHierarchy.SourceSyncFolderIdPtag] as byte[];
if (array != null)
{
list.Add(new PropValueData(base.Mapper.destHierarchy.SourceSyncFolderIdPtag, array));
}
}
IFolderProxy folderProxy = (IFolderProxy)base.WrappedObject;
MessageRec messageRec2;
IMessageProxy destMessage;
if (base.Mapper.targetMapping.TryGetValue(entryId, out messageRec2))
{
folderProxy.DeleteMessage(messageRec2.EntryId);
destMessage = folderProxy.CreateMessage(messageRec.IsFAI);
}
else
{
destMessage = folderProxy.CreateMessage(messageRec.IsFAI);
}
this.owner.uploadedSourceIDs.Add(entryId);
return(new FolderContentsMapper.TranslatingProxyPool.TranslatingMessageProxy(destMessage, list.ToArray(), base.Mapper));
}
protected override void CopySingleMessage(MessageRec curMsg, IFolderProxy folderProxy, PropTag[] propsToCopyExplicitly, PropTag[] excludeProps)
{
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("MapiSourceMailbox.CopySingleMessage", OperationType.None),
new EntryIDsDataContext(curMsg.EntryId)
}).Execute(delegate
{
using (this.RHTracker.Start())
{
using (MapiMessage mapiMessage = (MapiMessage)this.OpenMapiEntry(curMsg.FolderId, curMsg.EntryId, OpenEntryFlags.DontThrowIfEntryIsMissing))
{
if (mapiMessage == null)
{
MrsTracer.Provider.Debug("Message {0} is missing in source, ignoring", new object[]
{
TraceUtils.DumpEntryId(curMsg.EntryId)
});
}
else
{
using (IMessageProxy messageProxy = folderProxy.OpenMessage(curMsg.EntryId))
{
using (FxProxyBudgetWrapper fxProxyBudgetWrapper = new FxProxyBudgetWrapper(messageProxy, false, new Func <IDisposable>(this.RHTracker.StartExclusive), new Action <uint>(this.RHTracker.Charge)))
{
mapiMessage.ExportObject(fxProxyBudgetWrapper, CopyPropertiesFlags.None, excludeProps);
}
if (propsToCopyExplicitly != null && propsToCopyExplicitly.Length > 0)
{
PropValue[] props = mapiMessage.GetProps(propsToCopyExplicitly);
using (this.RHTracker.StartExclusive())
{
List <PropValueData> list = new List <PropValueData>();
foreach (PropValue propValue in props)
{
if (!propValue.IsNull() && !propValue.IsError())
{
list.Add(new PropValueData(propValue.PropTag, propValue.Value));
}
}
if (list.Count > 0)
{
messageProxy.SetProps(list.ToArray());
}
}
}
using (this.RHTracker.StartExclusive())
{
messageProxy.SaveChanges();
}
}
}
}
}
});
}
IFolderProxy IFxProxyPool.CreateFolder(FolderRec folder)
{
IFolderProxy proxy = null;
using (base.CreateCostHandle())
{
proxy = base.WrappedObject.CreateFolder(folder);
}
return(new FxProxyPoolBudgetWrapper.FolderProxyBudgetWrapper(proxy, true, base.CreateCostHandle, base.Charge));
}
IFolderProxy IFxProxyPool.GetFolderProxy(byte[] folderId)
{
IFolderProxy folderProxy = base.WrappedObject.GetFolderProxy(folderId);
if (folderProxy == null)
{
return(null);
}
return(new FxProxyPoolFxCallbackWrapper.FolderProxyFxCallbackWrapper(folderProxy, true, this.updateDuration));
}
protected override void CopySingleMessage(MessageRec message, IFolderProxy folderProxy, PropTag[] propTagsToExclude, PropTag[] excludeProps)
{
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("PopSourceMailbox.CopySingleMessage", OperationType.None),
new EntryIDsDataContext(message.EntryId)
}).Execute(delegate
{
SyncEmailUtils.CopyMimeStream(this, message, folderProxy);
});
}
IFolderProxy IFxProxyPool.CreateFolder(FolderRec folder)
{
IFolderProxy result = null;
base.CreateContext("IFxProxyPool.CreateFolder", new DataContext[]
{
new FolderRecDataContext(folder)
}).Execute(delegate
{
result = this.WrappedObject.CreateFolder(folder);
}, true);
return(new FxProxyPoolWrapper.FolderProxyWrapper(result, base.CreateContext));
}
public SaveConfigurationOperation(
IConverterOptions options,
IDirectoryHelper directoryHelper,
IFileProxy fileProxy,
IFolderProxy folderProxy,
IOutputConfigurationFileHelper outputConfigurationHelper)
{
this.options = options;
this.directoryHelper = directoryHelper;
this.fileProxy = fileProxy;
this.folderProxy = folderProxy;
this.outputConfigurationHelper = outputConfigurationHelper;
}
IFolderProxy IFxProxyPool.GetFolderProxy(byte[] folderId)
{
IFolderProxy folderProxy = null;
using (base.CreateCostHandle())
{
folderProxy = base.WrappedObject.GetFolderProxy(folderId);
}
if (folderProxy == null)
{
return(null);
}
return(new FxProxyPoolBudgetWrapper.FolderProxyBudgetWrapper(folderProxy, true, base.CreateCostHandle, base.Charge));
}
public ExtractSaveOperation(
IConverterOptions options,
ICompressedSaveChecker saveChecker,
IZipFileHelper zipFileHelper,
IEnvironmentProxy environmentProxy,
IFileProxy fileProxy,
IFolderProxy folderProxy)
{
this.options = options;
this.saveChecker = saveChecker;
this.zipFileHelper = zipFileHelper;
this.environmentProxy = environmentProxy;
_fileProxy = fileProxy;
_folderProxy = folderProxy;
}
public ExtractSaveOperation(
IConverterOptions options,
ICompressedSaveChecker saveChecker,
IZipFileHelper zipFileHelper,
IEnvironmentProxy environmentProxy,
IFileProxy fileProxy,
IFolderProxy folderProxy)
{
this.options = options;
this.saveChecker = saveChecker;
this.zipFileHelper = zipFileHelper;
this.environmentProxy = environmentProxy;
_fileProxy = fileProxy;
_folderProxy = folderProxy;
}
public static void CopyItem(MessageRec messageRec, IMessage message, IFolderProxy folderProxy, PropTag[] propsToExclude)
{
using (IMessageProxy messageProxy = folderProxy.OpenMessage(messageRec.EntryId))
{
FxCollectorSerializer fxCollectorSerializer = new FxCollectorSerializer(messageProxy);
fxCollectorSerializer.Config(0, 1);
using (FastTransferDownloadContext fastTransferDownloadContext = FastTransferDownloadContext.CreateForDownload(FastTransferSendOption.Unicode | FastTransferSendOption.UseCpId | FastTransferSendOption.ForceUnicode, 1U, Encoding.Default, NullResourceTracker.Instance, new PropertyFilterFactory(false, false, (from ptag in propsToExclude
select new PropertyTag((uint)ptag)).ToArray <PropertyTag>()), false))
{
FastTransferMessageCopyTo fastTransferObject = new FastTransferMessageCopyTo(false, message, true);
fastTransferDownloadContext.PushInitial(fastTransferObject);
FxUtils.TransferFxBuffers(fastTransferDownloadContext, fxCollectorSerializer);
messageProxy.SaveChanges();
}
}
}
IFolderProxy IFxProxyPool.GetFolderProxy(byte[] folderId)
{
IFolderProxy result = null;
base.CreateContext("IFxProxyPool.GetFolderProxy", new DataContext[]
{
new EntryIDsDataContext(folderId)
}).Execute(delegate
{
result = this.WrappedObject.GetFolderProxy(folderId);
}, true);
if (result == null)
{
return(null);
}
return(new FxProxyPoolWrapper.FolderProxyWrapper(result, base.CreateContext));
}
public ModCopier(
IConverterOptions options,
IFileProxy fileProxy,
IFolderProxy folderProxy,
IDirectoryHelper directoryHelper,
IMessageBoxProxy messageBoxProxy,
IDirectoryCopyHelper directoryCopyHelper,
ISaveGameNameTranslator nameTranslator)
{
this.options = options;
this.fileProxy = fileProxy;
this.folderProxy = folderProxy;
this.directoryHelper = directoryHelper;
this.messageBoxProxy = messageBoxProxy;
this.directoryCopyHelper = directoryCopyHelper;
this.nameTranslator = nameTranslator;
}
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);
}
}
}
}
}
}
});
}
protected override void CopySingleMessage(MessageRec message, IFolderProxy targetFolderProxy, PropTag[] propsToCopyExplicitly, PropTag[] propTagsToExclude)
{
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("PstSourceMailbox.CopySingleMessage", OperationType.None),
new EntryIDsDataContext(message.EntryId)
}).Execute(delegate
{
try
{
uint nodeIdFromEntryId = PstMailbox.GetNodeIdFromEntryId(this.IPst.MessageStore.Guid, message.EntryId);
IMessage message2 = this.IPst.ReadMessage(nodeIdFromEntryId);
if (message2 == null)
{
throw new UnableToReadPSTMessagePermanentException(this.IPst.FileName, nodeIdFromEntryId);
}
PSTMessage pstmessage = new PSTMessage(this, message2);
using (IMessageProxy messageProxy = targetFolderProxy.OpenMessage(message.EntryId))
{
FxCollectorSerializer fxCollectorSerializer = new FxCollectorSerializer(messageProxy);
fxCollectorSerializer.Config(0, 1);
using (FastTransferDownloadContext fastTransferDownloadContext = FastTransferDownloadContext.CreateForDownload(FastTransferSendOption.Unicode | FastTransferSendOption.UseCpId | FastTransferSendOption.ForceUnicode, 1U, pstmessage.RawPropertyBag.CachedEncoding, NullResourceTracker.Instance, this.GetPropertyFilterFactory(PstMailbox.MoMTPtaFromPta(propTagsToExclude)), false))
{
FastTransferMessageCopyTo fastTransferObject = new FastTransferMessageCopyTo(false, pstmessage, true);
fastTransferDownloadContext.PushInitial(fastTransferObject);
FxUtils.TransferFxBuffers(fastTransferDownloadContext, fxCollectorSerializer);
messageProxy.SaveChanges();
}
}
}
catch (PSTExceptionBase innerException)
{
throw new UnableToReadPSTMessagePermanentException(this.IPst.FileName, PstMailbox.GetNodeIdFromEntryId(this.IPst.MessageStore.Guid, message.EntryId), innerException);
}
});
}
IFolderProxy IFxProxyPool.CreateFolder(FolderRec folder)
{
IFolderProxy proxy = base.WrappedObject.CreateFolder(folder);
return(new FxProxyPoolFxCallbackWrapper.FolderProxyFxCallbackWrapper(proxy, true, this.updateDuration));
}
private static void CopyCalendarItem(MessageRec messageRec, Properties calendarItemProperties, IFolderProxy folderProxy)
{
ArgumentValidator.ThrowIfNull("messageRec", messageRec);
ArgumentValidator.ThrowIfNull("folderProxy", folderProxy);
if (calendarItemProperties == null)
{
return;
}
EasFxCalendarMessage message = new EasFxCalendarMessage(calendarItemProperties);
FxUtils.CopyItem(messageRec, message, folderProxy, EasSourceMailbox.EmptyPropTagArray);
}
private IFolderProxy CreateFolder(FolderRec folder)
{
IFolderProxy result = null;
bool flag;
folder.EntryId = this.syncContext.MapSourceToDestinationFolderId(folder.EntryId, out flag);
folder.ParentId = this.syncContext.MapSourceToDestinationFolderId(folder.ParentId, out flag);
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
IDestinationFolder folder2 = this.destinationMailbox.GetFolder(folder.EntryId);
if (folder2 != null)
{
disposeGuard.Add <IDestinationFolder>(folder2);
folder2.SetProps(CommonUtils.PropertiesToDelete);
FolderRec folderRec = folder2.GetFolderRec(null, GetFolderRecFlags.None);
if (!CommonUtils.IsSameEntryId(folderRec.ParentId, folder.ParentId))
{
try
{
this.destinationMailbox.MoveFolder(folderRec.EntryId, folderRec.ParentId, folder.ParentId);
}
catch (ObjectNotFoundException arg)
{
PublicFolderHierarchyProxyPool.Tracer.TraceWarning <FolderRec, FolderRec, ObjectNotFoundException>((long)this.GetHashCode(), "ObjectNotFoundException caught during MoveFolder. Calling to FixParentChain before reattempting the folder move. SourceFolder={0}. DestinationFolder={1}. Exception={2}", folder, folderRec, arg);
this.FixParentChain(folder);
this.destinationMailbox.MoveFolder(folderRec.EntryId, folderRec.ParentId, folder.ParentId);
}
}
result = base.WrappedObject.GetFolderProxy(folder.EntryId);
PublicFolderHierarchyProxyPool.Tracer.TraceDebug <FolderRec>((long)this.GetHashCode(), "Folder updated: {0}", folder);
this.syncContext.Logger.LogFolderUpdated(folder.EntryId);
}
else
{
try
{
result = base.WrappedObject.CreateFolder(folder);
}
catch (ObjectNotFoundException arg2)
{
PublicFolderHierarchyProxyPool.Tracer.TraceWarning <FolderRec, ObjectNotFoundException>((long)this.GetHashCode(), "ObjectNotFoundException caught during CreateFolder. Calling to FixParentChain before reattempting the folder creation. Folder={0}. Exception={1}", folder, arg2);
this.FixParentChain(folder);
result = base.WrappedObject.CreateFolder(folder);
}
folder2 = this.destinationMailbox.GetFolder(folder.EntryId);
disposeGuard.Add <IDestinationFolder>(folder2);
PublicFolderHierarchyProxyPool.Tracer.TraceDebug <FolderRec>((long)this.GetHashCode(), "Folder created: {0}", folder);
this.syncContext.Logger.LogFolderCreated(folder.EntryId);
}
byte[] dumpsterEntryIdFromFolderRec = PublicFolderHierarchyProxyPool.GetDumpsterEntryIdFromFolderRec(folder);
if (dumpsterEntryIdFromFolderRec != null)
{
bool flag2;
byte[] value = this.syncContext.MapSourceToDestinationFolderId(dumpsterEntryIdFromFolderRec, out flag2);
folder2.SetProps(new PropValueData[]
{
new PropValueData(PropTag.IpmWasteBasketEntryId, value)
});
}
}
return(result);
}
public FolderProxyWrapper(IFolderProxy proxy, CommonUtils.CreateContextDelegate createContext) : base(proxy, createContext)
{
}
public FolderProxyBudgetWrapper(IFolderProxy proxy, bool ownsObject, Func <IDisposable> createCostHandleDelegate, Action <uint> chargeDelegate) : base(proxy, ownsObject, createCostHandleDelegate, chargeDelegate)
{
}
public TranslatingFolderProxy(FolderContentsMapper.TranslatingProxyPool owner, IFolderProxy destFolder, FolderContentsMapper mapper) : base(destFolder, mapper)
{
this.owner = owner;
}
public static void CopyMimeStream(ISupportMime mimeSource, MessageRec message, IFolderProxy folderProxy)
{
ArgumentValidator.ThrowIfNull("mimeSource", mimeSource);
ArgumentValidator.ThrowIfNull("message", message);
ArgumentValidator.ThrowIfNull("folderProxy", folderProxy);
using (mimeSource.RHTracker.Start())
{
PropValueData[] array;
using (Stream mimeStream = mimeSource.GetMimeStream(message, out array))
{
using (IMessageProxy messageProxy = folderProxy.OpenMessage(message.EntryId))
{
BufferPool bufferPool = BufferPoolCollection.AutoCleanupCollection.Acquire(BufferPoolCollection.BufferSize.Size128K);
byte[] array2 = bufferPool.Acquire();
try
{
for (;;)
{
int num = mimeStream.Read(array2, 0, array2.Length);
if (num == 0)
{
break;
}
if (num == array2.Length)
{
messageProxy.WriteToMime(array2);
}
else
{
byte[] array3 = new byte[num];
Array.Copy(array2, 0, array3, 0, num);
messageProxy.WriteToMime(array3);
}
}
}
finally
{
bufferPool.Release(array2);
}
List <PropValueData> list = new List <PropValueData>(SyncEmailUtils.SyncEmailPropTags.Length);
list.AddRange(Array.FindAll <PropValueData>(message.AdditionalProps, (PropValueData propValue) => Array.IndexOf <PropTag>(SyncEmailUtils.SyncEmailPropTags, (PropTag)propValue.PropTag) >= 0));
if (array != null)
{
list.AddRange(array);
}
using (mimeSource.RHTracker.StartExclusive())
{
messageProxy.SetProps(list.ToArray());
messageProxy.SaveChanges();
}
}
}
}
}
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));
}
}
}
