void ISourceMailbox.CopyTo(IFxProxy fxProxy, PropTag[] excludeTags)
{
MrsTracer.Provider.Function("MapiSourceMailbox.CopyTo", new object[0]);
base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None);
bool flag = false;
try
{
CopyPropertiesFlags copyPropertiesFlags = CopyPropertiesFlags.None;
if ((base.Flags & LocalMailboxFlags.StripLargeRulesForDownlevelTargets) != LocalMailboxFlags.None)
{
copyPropertiesFlags |= CopyPropertiesFlags.StripLargeRulesForDownlevelTargets;
}
using (base.RHTracker.Start())
{
using (FxProxyBudgetWrapper fxProxyBudgetWrapper = new FxProxyBudgetWrapper(fxProxy, false, new Func <IDisposable>(base.RHTracker.StartExclusive), new Action <uint>(base.RHTracker.Charge)))
{
base.MapiStore.ExportObject(fxProxyBudgetWrapper, copyPropertiesFlags, excludeTags);
}
}
flag = true;
fxProxy.Flush();
}
finally
{
if (!flag)
{
MrsTracer.Provider.Debug("Flushing target proxy after receiving an exception.", new object[0]);
CommonUtils.CatchKnownExceptions(new Action(fxProxy.Flush), null);
}
}
}
void ISourceFolder.CopyTo(IFxProxy destFxProxy, CopyPropertiesFlags flags, PropTag[] excludeTags)
{
MrsTracer.ProxyClient.Function("ISourceFolder.CopyTo({0}): {1}", new object[]
{
flags,
base.FolderName
});
byte[] objectData = destFxProxy.GetObjectData();
DataExportBatch dataExportBatch;
if (base.ServerVersion[30])
{
dataExportBatch = base.MrsProxy.ISourceFolder_CopyTo(base.Handle, (int)flags, DataConverter <PropTagConverter, PropTag, int> .GetData(excludeTags), objectData);
}
else
{
dataExportBatch = base.MrsProxy.ISourceFolder_Export2(base.Handle, DataConverter <PropTagConverter, PropTag, int> .GetData(excludeTags), objectData);
}
long dataExportHandle = dataExportBatch.DataExportHandle;
using (FxProxyReceiver fxProxyReceiver = new FxProxyReceiver(destFxProxy, false))
{
using (BufferedReceiver bufferedReceiver = new BufferedReceiver(fxProxyReceiver, false, base.MrsProxyClient.UseBuffering, base.MrsProxyClient.UseCompression))
{
RemoteDataExport.ExportRoutine(base.MrsProxy, dataExportHandle, bufferedReceiver, dataExportBatch, base.MrsProxyClient.UseCompression);
}
}
}
void ISourceFolder.CopyTo(IFxProxy destFolderProxy, CopyPropertiesFlags flags, PropTag[] excludeTags)
{
MrsTracer.Provider.Function("MapiSourceFolder.CopyTo", new object[0]);
if ((base.Mailbox.Flags & LocalMailboxFlags.StripLargeRulesForDownlevelTargets) != LocalMailboxFlags.None)
{
flags |= CopyPropertiesFlags.StripLargeRulesForDownlevelTargets;
}
bool flag = false;
try
{
using (base.Mailbox.RHTracker.Start())
{
using (FxProxyBudgetWrapper fxProxyBudgetWrapper = new FxProxyBudgetWrapper(destFolderProxy, false, new Func <IDisposable>(base.Mailbox.RHTracker.StartExclusive), new Action <uint>(base.Mailbox.RHTracker.Charge)))
{
base.Folder.ExportObject(fxProxyBudgetWrapper, flags, excludeTags);
}
}
flag = true;
destFolderProxy.Flush();
}
catch (LocalizedException)
{
if (!flag)
{
MrsTracer.Provider.Debug("Flushing target proxy after receiving an exception.", new object[0]);
CommonUtils.CatchKnownExceptions(new Action(destFolderProxy.Flush), null);
}
throw;
}
}
void ISourceFolder.CopyTo(IFxProxy fxFolderProxy, CopyPropertiesFlags flags, PropTag[] propTagsToExclude)
{
MrsTracer.Provider.Function("PstSourceFolder.ISourceFolder.CopyTo", new object[0]);
bool exportCompleted = false;
CommonUtils.ProcessKnownExceptions(delegate
{
FxCollectorSerializer fxCollectorSerializer = new FxCollectorSerializer(fxFolderProxy);
fxCollectorSerializer.Config(0, 1);
using (FastTransferDownloadContext fastTransferDownloadContext = FastTransferDownloadContext.CreateForDownload(FastTransferSendOption.Unicode | FastTransferSendOption.UseCpId | FastTransferSendOption.ForceUnicode, 1U, Encoding.ASCII, NullResourceTracker.Instance, this.GetPropertyFilterFactory(PstMailbox.MoMTPtaFromPta(propTagsToExclude)), false))
{
IFastTransferProcessor <FastTransferDownloadContext> fastTransferObject = FastTransferFolderCopyTo.CreateDownloadStateMachine(this.Folder, FastTransferFolderContentBase.IncludeSubObject.None);
fastTransferDownloadContext.PushInitial(fastTransferObject);
FxUtils.TransferFxBuffers(fastTransferDownloadContext, fxCollectorSerializer);
}
exportCompleted = true;
fxFolderProxy.Flush();
}, delegate(Exception ex)
{
if (!exportCompleted)
{
MrsTracer.Provider.Debug("Flushing target proxy after receiving an exception.", new object[0]);
CommonUtils.CatchKnownExceptions(new Action(fxFolderProxy.Flush), null);
}
return(false);
});
}
void ISourceFolder.CopyTo(IFxProxy destFolderProxy, CopyPropertiesFlags flags, PropTag[] excludeTags)
{
MrsTracer.Provider.Function("StorageSourceFolder.CopyTo({0})", new object[]
{
base.DisplayNameForTracing
});
if ((base.Mailbox.Flags & LocalMailboxFlags.StripLargeRulesForDownlevelTargets) != LocalMailboxFlags.None)
{
flags |= CopyPropertiesFlags.StripLargeRulesForDownlevelTargets;
}
bool exportCompleted = false;
CommonUtils.ProcessKnownExceptions(delegate
{
using (this.Mailbox.RHTracker.Start())
{
using (FxProxyBudgetWrapper fxProxyBudgetWrapper = new FxProxyBudgetWrapper(destFolderProxy, false, new Func <IDisposable>(this.Mailbox.RHTracker.StartExclusive), new Action <uint>(this.Mailbox.RHTracker.Charge)))
{
this.MapiFolder.ExportObject(fxProxyBudgetWrapper, flags, excludeTags);
}
}
exportCompleted = true;
destFolderProxy.Flush();
}, delegate(Exception ex)
{
if (!exportCompleted)
{
MrsTracer.Provider.Debug("Flushing target proxy after receiving an exception.", new object[0]);
CommonUtils.CatchKnownExceptions(new Action(destFolderProxy.Flush), null);
}
return(false);
});
}
public PropertyError[] CopyProperties(CoreAttachment destinationAttachment, CopyPropertiesFlags copyPropertiesFlags, NativeStorePropertyDefinition[] includeProperties)
{
this.CheckDisposed(null);
Util.ThrowOnNullArgument(destinationAttachment, "destinationAttachment");
Util.ThrowOnNullArgument(includeProperties, "includeProperties");
EnumValidator.ThrowIfInvalid <CopyPropertiesFlags>(copyPropertiesFlags, "copyPropertiesFlags");
return(CoreObject.MapiCopyProps(this.PropertyBag.MapiProp, destinationAttachment.PropertyBag.MapiProp, this.Session, destinationAttachment.Session, copyPropertiesFlags, includeProperties));
}
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 static CopyPropertiesFlags ToCopyPropertiesFlags(CopyPropertiesFlags copyPropertiesFlags)
{
switch (copyPropertiesFlags)
{
case CopyPropertiesFlags.None:
return(CopyPropertiesFlags.None);
case CopyPropertiesFlags.Move:
return(CopyPropertiesFlags.Move);
case CopyPropertiesFlags.NoReplace:
return(CopyPropertiesFlags.NoReplace);
default:
throw new ArgumentException("copyPropertiesFlags");
}
}
void ISourceFolder.CopyTo(IFxProxy destFolder, CopyPropertiesFlags flags, PropTag[] excludeTags)
{
string text = "ISourceFolder.CopyTo";
TimeSpan targetDuration = TimeSpan.Zero;
Stopwatch stopwatch = Stopwatch.StartNew();
base.CreateContext(text, new DataContext[]
{
new PropTagsDataContext(excludeTags)
}).Execute(delegate
{
using (FxProxyCallbackWrapper fxProxyCallbackWrapper = new FxProxyCallbackWrapper(destFolder, true, delegate(TimeSpan duration)
{
targetDuration += duration;
}))
{
((ISourceFolder)this.WrappedObject).CopyTo(fxProxyCallbackWrapper, flags, excludeTags);
}
}, false);
base.UpdateDuration(text, stopwatch.Elapsed.Subtract(targetDuration));
}
void ISourceMailbox.ExportFolders(List <byte[]> folderIds, IFxProxyPool proxyPool, ExportFoldersDataToCopyFlags exportFoldersDataToCopyFlags, GetFolderRecFlags folderRecFlags, PropTag[] additionalFolderRecProps, CopyPropertiesFlags copyPropertiesFlags, PropTag[] excludeProps, AclFlags extendedAclFlags)
{
throw new NotImplementedException();
}
PropertyError[] ICoreItem.CopyItem(ICoreItem destinationItem, CopyPropertiesFlags copyPropertiesFlags, CopySubObjects copySubObjects, NativeStorePropertyDefinition[] excludeProperties)
{
return(this.CoreItem.CopyItem(destinationItem, copyPropertiesFlags, copySubObjects, excludeProperties));
}
PropertyError[] ICoreItem.CopyProperties(ICoreItem destinationItem, CopyPropertiesFlags copyPropertiesFlags, NativeStorePropertyDefinition[] includeProperties)
{
return(this.CoreItem.CopyProperties(destinationItem, copyPropertiesFlags, includeProperties));
}
void ISourceMailbox.ExportFolders(List <byte[]> folderIds, IFxProxyPool proxyPool, ExportFoldersDataToCopyFlags exportFoldersDataToCopyFlags, GetFolderRecFlags folderRecFlags, PropTag[] additionalFolderRecProps, CopyPropertiesFlags copyPropertiesFlags, PropTag[] excludeProps, AclFlags extendedAclFlags)
{
MrsTracer.ProxyClient.Function("StorageSourceMailbox.ExportFolders", new object[0]);
base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None);
bool exportCompleted = false;
CommonUtils.ProcessKnownExceptions(delegate
{
foreach (byte[] folderEntryId in folderIds)
{
this.ExportSingleFolder(proxyPool, folderEntryId, exportFoldersDataToCopyFlags, folderRecFlags, additionalFolderRecProps, copyPropertiesFlags, excludeProps, extendedAclFlags);
}
exportCompleted = true;
proxyPool.Flush();
}, delegate(Exception ex)
{
if (!exportCompleted)
{
MrsTracer.Provider.Debug("Flushing target proxy after receiving an exception.", new object[0]);
CommonUtils.CatchKnownExceptions(new Action(proxyPool.Flush), null);
}
return(false);
});
}
internal static PropertyError[] MapiCopyProps(MapiProp source, MapiProp destination, StoreSession sourceSession, StoreSession destSession, CopyPropertiesFlags copyPropertiesFlags, params NativeStorePropertyDefinition[] includedProperties)
{
Util.ThrowOnNullArgument(source, "sources");
Util.ThrowOnNullArgument(destination, "destination");
ICollection <PropTag> collection = PropertyTagCache.Cache.PropTagsFromPropertyDefinitions(source, sourceSession, true, includedProperties);
PropProblem[] problems = null;
bool flag = false;
try
{
if (sourceSession != null)
{
sourceSession.BeginMapiCall();
sourceSession.BeginServerHealthCall();
flag = true;
}
if (StorageGlobals.MapiTestHookBeforeCall != null)
{
StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod());
}
CopyPropertiesFlags copyPropertiesFlags2 = CoreObject.ToCopyPropertiesFlags(copyPropertiesFlags);
try
{
problems = source.CopyProps(destination, copyPropertiesFlags2, collection);
}
catch (MapiExceptionNamedPropsQuotaExceeded)
{
List <PropTag> list = new List <PropTag>(collection.Count);
foreach (PropTag propTag in collection)
{
if (propTag != PropTag.Unresolved)
{
list.Add(propTag);
}
}
problems = source.CopyProps(destination, copyPropertiesFlags2, list);
}
}
catch (MapiPermanentException ex)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotCopyMapiProps, ex, sourceSession, source, "{0}. MapiException = {1}.", new object[]
{
string.Format("CoreItem::MapiCopyProperties.", new object[0]),
ex
});
}
catch (MapiRetryableException ex2)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotCopyMapiProps, ex2, sourceSession, source, "{0}. MapiException = {1}.", new object[]
{
string.Format("CoreItem::MapiCopyProperties.", new object[0]),
ex2
});
}
finally
{
try
{
if (sourceSession != null)
{
sourceSession.EndMapiCall();
if (flag)
{
sourceSession.EndServerHealthCall();
}
}
}
finally
{
if (StorageGlobals.MapiTestHookAfterCall != null)
{
StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod());
}
}
}
CoreObject.ProcessCopyPropertyProblems(problems, sourceSession, source);
return(CoreObject.ToXsoPropertyErrors(destSession, destination, problems));
}
void ISourceMailbox.ExportFolders(List <byte[]> folderIds, IFxProxyPool proxyPool, ExportFoldersDataToCopyFlags exportFoldersDataToCopyFlags, GetFolderRecFlags folderRecFlags, PropTag[] additionalFolderRecProps, CopyPropertiesFlags copyPropertiesFlags, PropTag[] excludeProps, AclFlags extendedAclFlags)
{
string text = "ISourceMailbox.ExportFolders";
TimeSpan targetDuration = TimeSpan.Zero;
Stopwatch stopwatch = Stopwatch.StartNew();
base.CreateContext(text, new DataContext[]
{
new EntryIDsDataContext(folderIds),
new SimpleValueDataContext("exportFoldersDataToCopyFlags", exportFoldersDataToCopyFlags),
new SimpleValueDataContext("folderRecFlags", folderRecFlags),
new PropTagsDataContext(additionalFolderRecProps),
new SimpleValueDataContext("copyPropertiesFlags", copyPropertiesFlags),
new PropTagsDataContext(excludeProps),
new SimpleValueDataContext("extendedAclFlags", extendedAclFlags)
}).Execute(delegate
{
using (FxProxyPoolFxCallbackWrapper fxProxyPoolFxCallbackWrapper = new FxProxyPoolFxCallbackWrapper(proxyPool, true, delegate(TimeSpan duration)
{
targetDuration += duration;
}))
{
((ISourceMailbox)this.WrappedObject).ExportFolders(folderIds, fxProxyPoolFxCallbackWrapper, exportFoldersDataToCopyFlags, folderRecFlags, additionalFolderRecProps, copyPropertiesFlags, excludeProps, extendedAclFlags);
}
}, false);
base.UpdateDuration(text, stopwatch.Elapsed.Subtract(targetDuration));
}
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);
}
}
}
}
}
}
});
}
void ISourceFolder.CopyTo(IFxProxy fxFolderProxy, CopyPropertiesFlags flags, PropTag[] propTagsToExclude)
{
}
public void FoldersExport(ISourceMailbox mailbox, List <byte[]> folderIds, ExportFoldersDataToCopyFlags exportFoldersDataToCopyFlags, GetFolderRecFlags folderRecFlags, PropTag[] additionalFolderRecProps, CopyPropertiesFlags copyPropertiesFlags, PropTag[] excludeProps, AclFlags extendedAclFlags)
{
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 (FxProxyPoolTransmitter fxProxyPoolTransmitter = new FxProxyPoolTransmitter(asynchronousTransmitter, false, this.service.ClientVersion))
{
mailbox.ExportFolders(folderIds, fxProxyPoolTransmitter, exportFoldersDataToCopyFlags, folderRecFlags, additionalFolderRecProps, copyPropertiesFlags, excludeProps, extendedAclFlags);
}
}
}
});
}
void ISourceMailbox.ExportFolders(List <byte[]> folderIds, IFxProxyPool proxyPool, ExportFoldersDataToCopyFlags exportFoldersDataToCopyFlags, GetFolderRecFlags folderRecFlags, PropTag[] additionalFolderRecProps, CopyPropertiesFlags copyPropertiesFlags, PropTag[] excludeProps, AclFlags extendedAclFlags)
{
MrsTracer.ProxyClient.Function("RemoteSourceMailbox.ExportFolders", new object[0]);
base.VerifyMailboxConnection();
if (!base.ServerVersion[54])
{
throw new UnsupportedRemoteServerVersionWithOperationPermanentException(base.MrsProxyClient.ServerName, base.ServerVersion.ToString(), "ISourceMailbox_ExportFolders");
}
DataExportBatch dataExportBatch = base.MrsProxy.ISourceMailbox_ExportFolders(base.Handle, folderIds, (int)exportFoldersDataToCopyFlags, (int)folderRecFlags, DataConverter <PropTagConverter, PropTag, int> .GetData(additionalFolderRecProps), (int)copyPropertiesFlags, DataConverter <PropTagConverter, PropTag, int> .GetData(excludeProps), (int)extendedAclFlags);
using (IDataImport dataImport = new FxProxyPoolReceiver(proxyPool, false))
{
using (BufferedReceiver bufferedReceiver = new BufferedReceiver(dataImport, false, base.MrsProxyClient.UseBuffering, base.MrsProxyClient.UseCompression))
{
RemoteDataExport.ExportRoutine(base.MrsProxy, dataExportBatch.DataExportHandle, bufferedReceiver, dataExportBatch, base.MrsProxyClient.UseCompression);
}
}
}
