public void GetSignatureModeInfo(bool jobIsPreservingMailboxSignature, out bool serverSupportsSignaturePreservationCheck, out bool serverIsInSignaturePreservingMode, out bool mrsIsInSignaturePreservingMode)
{
MrsTracer.Service.Debug("GetSignatureModeInfo().", new object[0]);
serverSupportsSignaturePreservationCheck = false;
serverIsInSignaturePreservingMode = jobIsPreservingMailboxSignature;
mrsIsInSignaturePreservingMode = jobIsPreservingMailboxSignature;
PropValue[] native = DataConverter <PropValueConverter, PropValue, PropValueData> .GetNative(base.DestMailbox.GetProps(new PropTag[]
{
PropTag.PreservingMailboxSignature,
PropTag.MRSPreservingMailboxSignature
}));
if (native != null)
{
for (int i = 0; i < 2; i++)
{
if (!native[i].IsNull())
{
if (PropTag.PreservingMailboxSignature == native[i].PropTag && native[i].Value != null && native[i].Value is bool)
{
MrsTracer.Service.Debug("Retrieved StorePreservingSignature PropTag.", new object[0]);
serverIsInSignaturePreservingMode = (bool)native[i].Value;
serverSupportsSignaturePreservationCheck = true;
}
if (PropTag.MRSPreservingMailboxSignature == native[i].PropTag && native[i].Value != null && native[i].Value is bool)
{
MrsTracer.Service.Debug("Retrieved MrsPreservingSignature PropTag.", new object[0]);
mrsIsInSignaturePreservingMode = (bool)native[i].Value;
jobIsPreservingMailboxSignature &= (!base.Flags.HasFlag(MailboxCopierFlags.ContainerAggregated) && !base.Flags.HasFlag(MailboxCopierFlags.ContainerOrg));
}
}
}
}
}
PropProblemData[] IFolder.SetProps(PropValueData[] pvda)
{
PropProblemData[] result = null;
PropValue[] native = DataConverter <PropValueConverter, PropValue, PropValueData> .GetNative(pvda);
PropValue[] array = new PropValue[native.Length];
for (int i = 0; i < native.Length; i++)
{
PropTag propTag = native[i].PropTag;
object obj = native[i].Value;
if (propTag == PropTag.IpmWasteBasketEntryId)
{
byte[] array2 = obj as byte[];
if (array2 != null)
{
obj = this.Mailbox.MapiStore.GlobalIdFromId(this.Mailbox.MapiStore.GetFidFromEntryId(array2));
}
}
array[i] = new PropValue(propTag, obj);
}
using (this.Mailbox.RHTracker.Start())
{
result = DataConverter <PropProblemConverter, PropProblem, PropProblemData> .GetData(this.Folder.SetProps(array));
}
return(result);
}
public Rule GetRule()
{
Rule rule = new Rule();
rule.ExecutionSequence = this.ExecutionSequence;
rule.Level = this.Level;
rule.StateFlags = (RuleStateFlags)this.StateFlags;
rule.UserFlags = this.UserFlags;
rule.Condition = DataConverter <RestrictionConverter, Restriction, RestrictionData> .GetNative(this.Condition);
rule.Actions = DataConverter <RuleActionConverter, RuleAction, RuleActionData> .GetNative(this.Actions);
rule.Name = this.Name;
rule.Provider = this.Provider;
rule.ProviderData = this.ProviderData;
rule.IsExtended = this.IsExtended;
if (this.IsExtended)
{
rule.ExtraProperties = DataConverter <PropValueConverter, PropValue, PropValueData> .GetNative(this.ExtraProperties);
}
else if (this.ExtraProperties != null && this.ExtraProperties.Length > 0)
{
MrsTracer.Common.Error("Non-extended rule '{0}' has {1} extra properties", new object[]
{
this.Name,
this.ExtraProperties.Length
});
}
return(rule);
}
void IDestinationFolder.SetRules(RuleData[] rules)
{
Rule[] native = DataConverter <RuleConverter, Rule, RuleData> .GetNative(rules);
using (base.Mailbox.RHTracker.Start())
{
base.Folder.SetRules(native);
}
}
internal override Restriction GetRestriction()
{
PropValue[] array = new PropValue[this.PropValues.Length];
for (int i = 0; i < this.PropValues.Length; i++)
{
array[i] = DataConverter <PropValueConverter, PropValue, PropValueData> .GetNative(this.PropValues[i]);
}
return(Restriction.Comment(base.GetRestrictions()[0], array));
}
private static void FindWellKnownFolders(IMailbox mailbox, PropTagFolderMapping[] map, FolderHierarchyUtils.GetPropsDelegate getProps, Dictionary <WellKnownFolderType, byte[]> wellKnownFolders)
{
NamedPropMapper namedPropMapper = CommonUtils.CreateNamedPropMapper(mailbox);
PropTag[] array = new PropTag[map.Length];
for (int i = 0; i < map.Length; i++)
{
InboxNamedPropFolderMapping inboxNamedPropFolderMapping = map[i] as InboxNamedPropFolderMapping;
if (inboxNamedPropFolderMapping != null)
{
namedPropMapper.ByNamedProp.AddKey(inboxNamedPropFolderMapping.NamedPropData);
}
}
for (int j = 0; j < map.Length; j++)
{
InboxNamedPropFolderMapping inboxNamedPropFolderMapping2 = map[j] as InboxNamedPropFolderMapping;
if (inboxNamedPropFolderMapping2 != null)
{
array[j] = namedPropMapper.MapNamedProp(inboxNamedPropFolderMapping2.NamedPropData, PropType.Binary);
}
else
{
array[j] = map[j].Ptag;
}
}
PropValueData[] a = getProps(array);
PropValue[] native = DataConverter <PropValueConverter, PropValue, PropValueData> .GetNative(a);
for (int k = 0; k < map.Length; k++)
{
byte[] array2 = null;
if (!native[k].IsNull() && !native[k].IsError())
{
InboxIndexedFolderMapping inboxIndexedFolderMapping = map[k] as InboxIndexedFolderMapping;
if (inboxIndexedFolderMapping == null)
{
array2 = native[k].GetBytes();
}
else
{
byte[][] bytesArray = native[k].GetBytesArray();
if (bytesArray != null && bytesArray.Length > inboxIndexedFolderMapping.EntryIndex)
{
array2 = bytesArray[inboxIndexedFolderMapping.EntryIndex];
}
else
{
array2 = null;
}
}
}
if (array2 != null)
{
wellKnownFolders[map[k].WKFType] = array2;
}
}
}
bool IDestinationFolder.SetSearchCriteria(RestrictionData restriction, byte[][] entryIds, SearchCriteriaFlags flags)
{
Restriction native = DataConverter <RestrictionConverter, Restriction, RestrictionData> .GetNative(restriction);
using (base.Mailbox.RHTracker.Start())
{
base.Folder.SetSearchCriteria(native, entryIds, flags);
}
return(true);
}
PropProblemData[] IDestinationMailbox.SetProps(PropValueData[] pvda)
{
MrsTracer.Provider.Function("MapiDestinationMailbox.SetProps", new object[0]);
base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None);
PropValue[] native = DataConverter <PropValueConverter, PropValue, PropValueData> .GetNative(pvda);
PropProblemData[] data;
using (base.RHTracker.Start())
{
data = DataConverter <PropProblemConverter, PropProblem, PropProblemData> .GetData(base.MapiStore.SetProps(native));
}
return(data);
}
void IDestinationFolder.SetRules(RuleData[] rules)
{
MrsTracer.Provider.Function("StorageDestinationFolder.SetRules: {0}", new object[]
{
base.DisplayNameForTracing
});
Rule[] native = DataConverter <RuleConverter, Rule, RuleData> .GetNative(rules);
using (base.Mailbox.RHTracker.Start())
{
base.Folder.MapiFolder.SetRules(native);
}
}
public void SetProps(PropValueData[] pvda)
{
try
{
foreach (PropValueData data in pvda)
{
this.message.PropertyBag.SetProperty(PstMailbox.MoMTPvFromPv(DataConverter <PropValueConverter, PropValue, PropValueData> .GetNative(data)));
}
}
catch (PSTExceptionBase innerException)
{
throw new UnableToCreatePSTMessagePermanentException(this.message.PstMailbox.IPst.FileName, innerException);
}
}
PropProblemData[] IFolder.SetProps(PropValueData[] pvda)
{
MrsTracer.Provider.Function("PstFolder.SetProps(num of props={0})", new object[]
{
pvda.Length
});
foreach (PropValueData data in pvda)
{
this.Folder.PropertyBag.SetProperty(PstMailbox.MoMTPvFromPv(DataConverter <PropValueConverter, PropValue, PropValueData> .GetNative(data)));
}
try
{
this.Folder.IPstFolder.Save();
}
catch (PSTExceptionBase innerException)
{
throw new MailboxReplicationPermanentException(new LocalizedString(this.Folder.PstMailbox.IPst.FileName), innerException);
}
return(null);
}
public void CopyMailboxProperties()
{
MrsTracer.Service.Function("MailboxMerger.CopyMailboxProperties", new object[0]);
PropValue[] native = DataConverter <PropValueConverter, PropValue, PropValueData> .GetNative(base.SourceMailbox.GetProps(MailboxMerger.MailboxPtags));
List <PropValue> list = new List <PropValue>();
foreach (PropValue item in native)
{
if (!item.IsNull() && !item.IsError())
{
if (item.PropTag == PropTag.SentMailEntryId)
{
byte[] array2 = item.Value as byte[];
if (array2 != null)
{
FolderMapping folderMapping = this.SourceHierarchy[array2] as FolderMapping;
if (folderMapping != null && folderMapping.IsIncluded && folderMapping.TargetFolder != null)
{
MrsTracer.Service.Debug("Remapped SentItemsEntryId from {0} to {1}", new object[]
{
TraceUtils.DumpEntryId(array2),
TraceUtils.DumpEntryId(folderMapping.TargetFolder.EntryId)
});
list.Add(new PropValue(item.PropTag, folderMapping.TargetFolder.EntryId));
}
}
}
else
{
list.Add(item);
}
}
}
if (list.Count > 0)
{
base.DestMailbox.SetProps(DataConverter <PropValueConverter, PropValue, PropValueData> .GetData(list.ToArray()));
}
}
List <MessageRec> IFolder.EnumerateMessages(EnumerateMessagesFlags emFlags, PropTag[] additionalPtagsToLoad)
{
List <MessageRec> result = new List <MessageRec>();
if (!this.Folder.IsContentAvailable)
{
return(result);
}
ContentsTableFlags[] array = new ContentsTableFlags[]
{
ContentsTableFlags.None,
ContentsTableFlags.Associated,
ContentsTableFlags.ShowSoftDeletes,
ContentsTableFlags.ShowSoftDeletes | ContentsTableFlags.Associated
};
ContentsTableFlags[] array2 = new ContentsTableFlags[]
{
ContentsTableFlags.None,
ContentsTableFlags.Associated
};
ContentsTableFlags[] array3 = (this.Folder.MapiStore.VersionMajor < 15) ? array : array2;
for (int i = 0; i < array3.Length; i++)
{
ContentsTableFlags flags = ContentsTableFlags.DeferredErrors | array3[i];
bool doingFAI = (flags & ContentsTableFlags.Associated) != ContentsTableFlags.None;
bool doingDeletes = (flags & ContentsTableFlags.ShowSoftDeletes) != ContentsTableFlags.None;
if ((emFlags & ((!doingDeletes || 2 != 0) ? EnumerateMessagesFlags.RegularMessages : ((EnumerateMessagesFlags)0))) != (EnumerateMessagesFlags)0)
{
List <PropTag> pta = new List <PropTag>(5);
int idxEntryId = -1;
int idxCreationTime = -1;
int idxMessageClass = -1;
int idxRuleMsgVersion = -1;
int idxMessageSize = -1;
idxEntryId = pta.Count;
pta.Add(PropTag.EntryId);
if ((emFlags & EnumerateMessagesFlags.IncludeExtendedData) != (EnumerateMessagesFlags)0)
{
idxMessageSize = pta.Count;
pta.Add(PropTag.MessageSize);
idxCreationTime = pta.Count;
pta.Add(PropTag.CreationTime);
}
if (doingFAI)
{
idxMessageClass = pta.Count;
pta.Add(PropTag.MessageClass);
idxRuleMsgVersion = pta.Count;
pta.Add(PropTag.RuleMsgVersion);
}
int idxExtraPtags = pta.Count;
if (additionalPtagsToLoad != null)
{
pta.AddRange(additionalPtagsToLoad);
}
MrsTracer.Provider.Debug("MapiFolder.GetContentsTable({0})", new object[]
{
flags
});
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("MapiFolder.GetContentsTable", OperationType.None),
new SimpleValueDataContext("Flags", flags)
}).Execute(delegate
{
int lcidValue = (!doingFAI && this.contentsRestriction != null) ? this.contentsRestriction.LCID : 0;
MapiTable contentsTable;
using (this.Mailbox.RHTracker.Start())
{
contentsTable = this.Folder.GetContentsTable(flags);
}
using (contentsTable)
{
using (new SortLCIDContext(this.Folder.MapiStore, lcidValue))
{
Restriction restriction = null;
if (!doingFAI && this.contentsRestriction != null)
{
restriction = DataConverter <RestrictionConverter, Restriction, RestrictionData> .GetNative(this.contentsRestriction);
}
MapiUtils.InitQueryAllRows(contentsTable, restriction, pta);
for (;;)
{
PropValue[][] array4;
using (this.Mailbox.RHTracker.Start())
{
array4 = contentsTable.QueryRows(1000);
}
if (array4.GetLength(0) == 0)
{
break;
}
MrsTracer.Provider.Debug("QueryRows returned {0} items.", new object[]
{
array4.Length
});
PropValue[][] array5 = array4;
int j = 0;
while (j < array5.Length)
{
PropValue[] array6 = array5[j];
if (!doingFAI)
{
goto IL_1F9;
}
string @string = array6[idxMessageClass].GetString();
if ((this.Mailbox.Options & MailboxOptions.IgnoreExtendedRuleFAIs) != MailboxOptions.None)
{
if (!StringComparer.OrdinalIgnoreCase.Equals(@string, "IPM.Rule.Message") && !StringComparer.OrdinalIgnoreCase.Equals(@string, "IPM.Rule.Version2.Message"))
{
if (!StringComparer.OrdinalIgnoreCase.Equals(@string, "IPM.ExtendedRule.Message"))
{
goto IL_1F9;
}
}
}
else if (!StringComparer.OrdinalIgnoreCase.Equals(@string, "IPM.Rule.Message") || array6[idxRuleMsgVersion].GetInt(0) != 1)
{
goto IL_1F9;
}
IL_423:
j++;
continue;
IL_1F9:
DateTime dateTime = (idxCreationTime != -1) ? MapiUtils.GetDateTimeOrDefault(array6[idxCreationTime]) : DateTime.MinValue;
byte[] bytes = array6[idxEntryId].GetBytes();
if (emFlags.HasFlag(EnumerateMessagesFlags.SkipICSMidSetMissing) && bytes != null && this.Mailbox.SupportsSavingSyncState)
{
SyncContentsManifestState syncContentsManifestState = this.Mailbox.SyncState[this.FolderId];
if (syncContentsManifestState != null && !syncContentsManifestState.IdSetGivenContainsEntryId(bytes))
{
MrsTracer.Provider.Debug("entry id {0} with creation time {1} not found in given items.", new object[]
{
TraceUtils.DumpEntryId(bytes),
dateTime
});
goto IL_423;
}
}
List <PropValueData> list = null;
if (additionalPtagsToLoad != null && additionalPtagsToLoad.Length > 0)
{
list = new List <PropValueData>();
for (int k = idxExtraPtags; k < array6.Length; k++)
{
list.Add(DataConverter <PropValueConverter, PropValue, PropValueData> .GetData(array6[k]));
}
}
if ((emFlags & EnumerateMessagesFlags.ReturnLongTermIDs) == EnumerateMessagesFlags.ReturnLongTermIDs && bytes != null)
{
if (list == null)
{
list = new List <PropValueData>();
}
list.Add(new PropValueData(PropTag.LTID, this.Mailbox.MapiStore.GlobalIdFromId(this.Mailbox.MapiStore.GetMidFromMessageEntryId(bytes))));
}
MsgRecFlags msgRecFlags = doingFAI ? MsgRecFlags.Associated : MsgRecFlags.None;
if (doingDeletes)
{
msgRecFlags |= MsgRecFlags.Deleted;
}
MessageRec item = new MessageRec(bytes, this.FolderId, dateTime, (idxMessageSize != -1) ? array6[idxMessageSize].GetInt(1000) : 1000, msgRecFlags, (list == null) ? null : list.ToArray());
result.Add(item);
goto IL_423;
}
}
}
}
});
}
}
MrsTracer.Provider.Debug("MapiFolder.EnumerateMessages returns {0} items.", new object[]
{
result.Count
});
return(result);
}
public void SetExtendedProps(PropTag[] promotedProperties, RestrictionData[] restrictions, SortOrderData[] views, ICSViewData[] icsViews)
{
MrsTracer.Provider.Function("MapiDestinationFolder.SetExtendedProps", new object[0]);
if (promotedProperties != null && promotedProperties.Length > 0)
{
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("MapiDestinationFolder.SetPromotedProps", OperationType.None),
new PropTagsDataContext(promotedProperties)
}).Execute(delegate
{
using (this.Mailbox.RHTracker.Start())
{
using (MapiTable contentsTable = this.Folder.GetContentsTable(ContentsTableFlags.DeferredErrors))
{
contentsTable.SetColumns(promotedProperties);
contentsTable.QueryRows(1);
}
}
});
}
if (restrictions != null && restrictions.Length > 0)
{
MrsTracer.Provider.Debug("Applying restrictions.", new object[0]);
for (int i = 0; i < restrictions.Length; i++)
{
RestrictionData rd = restrictions[i];
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("MapiDestinationFolder.ApplyRestriction", OperationType.None),
new RestrictionDataContext(rd)
}).Execute(delegate
{
Restriction native = DataConverter <RestrictionConverter, Restriction, RestrictionData> .GetNative(rd);
using (this.Mailbox.RHTracker.Start())
{
using (MapiTable contentsTable = this.Folder.GetContentsTable(ContentsTableFlags.DeferredErrors))
{
using (new SortLCIDContext(this.Folder.MapiStore, rd.LCID))
{
contentsTable.Restrict(native);
contentsTable.QueryRows(1);
}
}
}
});
}
}
if (views != null && views.Length > 0)
{
MrsTracer.Provider.Debug("Applying views.", new object[0]);
for (int j = 0; j < views.Length; j++)
{
SortOrderData sod = views[j];
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("MapiDestinationFolder.ApplySortOrder", OperationType.None),
new SortOrderDataContext(sod)
}).Execute(delegate
{
SortOrder native = DataConverter <SortOrderConverter, SortOrder, SortOrderData> .GetNative(sod);
ContentsTableFlags contentsTableFlags = ContentsTableFlags.DeferredErrors;
if (sod.FAI)
{
contentsTableFlags |= ContentsTableFlags.Associated;
}
else if (sod.Conversation)
{
contentsTableFlags |= ContentsTableFlags.ShowConversations;
}
using (this.Mailbox.RHTracker.Start())
{
using (MapiTable contentsTable = this.Folder.GetContentsTable(contentsTableFlags))
{
using (new SortLCIDContext(this.Folder.MapiStore, sod.LCID))
{
contentsTable.SortTable(native, SortTableFlags.None);
contentsTable.QueryRows(1);
}
}
}
});
}
}
if (icsViews != null && icsViews.Length > 0)
{
MrsTracer.Provider.Debug("Applying ICS views.", new object[0]);
for (int k = 0; k < icsViews.Length; k++)
{
ICSViewData icsView = icsViews[k];
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("MapiDestinationFolder.ApplyICSView", OperationType.None),
new ICSViewDataContext(icsView)
}).Execute(delegate
{
ManifestConfigFlags flags = ManifestConfigFlags.Associated | ManifestConfigFlags.Normal;
if (icsView.Conversation)
{
flags = ManifestConfigFlags.Conversations;
}
using (this.Mailbox.RHTracker.Start())
{
using (MapiManifest mapiManifest = this.Folder.CreateExportManifest())
{
PropTag[] array = Array <PropTag> .Empty;
if (icsView.CoveringPropertyTags != null)
{
array = new PropTag[icsView.CoveringPropertyTags.Length];
for (int l = 0; l < icsView.CoveringPropertyTags.Length; l++)
{
array[l] = (PropTag)icsView.CoveringPropertyTags[l];
}
}
mapiManifest.Configure(flags, null, null, MapiDestinationFolder.DummyManifestContentsCallback.Instance, array);
while (mapiManifest.Synchronize() != ManifestStatus.Done)
{
}
}
}
});
}
}
}
protected override void FolderSetProps(MapiFxProxyPool.FolderEntry folder, PropValueData[] pvda)
{
PropValue[] native = DataConverter <PropValueConverter, PropValue, PropValueData> .GetNative(pvda);
folder.WrappedObject.SetProps(native);
}
protected override void MessageSetProps(MapiFxProxyPool.MessageEntry entry, PropValueData[] pvda)
{
PropValue[] native = DataConverter <PropValueConverter, PropValue, PropValueData> .GetNative(pvda);
entry.WrappedObject.SetProps(native);
}
protected override RuleAction GetRuleActionInternal()
{
return(new RuleAction.Delegate(DataConverter <AdrEntryConverter, AdrEntry, AdrEntryData> .GetNative(base.Recipients)));
}
public PropTag[] GetPromotedProperties()
{
return(DataConverter <PropTagConverter, PropTag, int> .GetNative(this.promotedProperties));
}
internal override Restriction GetRestriction()
{
return(new Restriction.PropertyRestriction((Restriction.RelOp) this.RelOp, (PropTag)this.PropTag, this.MultiValued, DataConverter <PropValueConverter, PropValue, PropValueData> .GetNative(this.Value).Value));
}
internal override Restriction GetRestriction()
{
return(new Restriction.ContentRestriction((PropTag)this.PropTag, this.MultiValued, DataConverter <PropValueConverter, PropValue, PropValueData> .GetNative(this.Value).Value, (ContentFlags)this.Flags));
}
protected override RuleAction GetRuleActionInternal()
{
return(new RuleAction.Forward(DataConverter <AdrEntryConverter, AdrEntry, AdrEntryData> .GetNative(base.Recipients), (RuleAction.Forward.ActionFlags)base.Flags));
}
AdrEntry IDataConverter <AdrEntry, AdrEntryData> .GetNativeRepresentation(AdrEntryData data)
{
return(new AdrEntry(DataConverter <PropValueConverter, PropValue, PropValueData> .GetNative(data.Values)));
}
protected override RuleAction GetRuleActionInternal()
{
return new RuleAction.Tag(DataConverter<PropValueConverter, PropValue, PropValueData>.GetNative(this.Value));
}
