private string GetSyncState(StoreSession storeSession, byte[] key, CoreFolder folder)
{
using (QueryResult queryResult = folder.QueryExecutor.ItemQuery(ItemQueryType.None, new ComparisonFilter(ComparisonOperator.Equal, ItemSchema.ReplyTemplateId, this.GetSyncStateSearchKey(key)), null, new PropertyDefinition[]
{
ItemSchema.Id
}))
{
object[][] rows = queryResult.GetRows(1);
if (rows.Length == 1)
{
VersionedId versionedId = rows[0][0] as VersionedId;
if (versionedId == null)
{
return(null);
}
try
{
using (Item item = Item.Bind(storeSession, versionedId))
{
using (Stream stream = item.PropertyBag.OpenPropertyStream(MailboxProviderBase.SyncStateStorePropertyDefinition, PropertyOpenMode.ReadOnly))
{
using (StreamReader streamReader = new StreamReader(stream))
{
return(streamReader.ReadToEnd());
}
}
}
}
catch (ObjectNotFoundException)
{
}
}
}
return(null);
}
internal static void WriteFolderAclTable(CoreFolder coreFolder, byte[] propertyToSet)
{
using (FolderPropertyStream folderPropertyStream = (FolderPropertyStream)coreFolder.PropertyBag.OpenPropertyStream(CoreFolderSchema.AclTableAndSecurityDescriptor, PropertyOpenMode.Modify))
{
folderPropertyStream.Write(propertyToSet, 0, propertyToSet.Length);
}
}
private void OnBeforeCreateFolder(Folder parentFolder)
{
PublicFolderSession publicFolderSession = base.Session as PublicFolderSession;
if (publicFolderSession == null)
{
return;
}
if (this.isSearchFolder)
{
base.SetProperty(CoreFolderSchema.ReplicaList, new string[]
{
publicFolderSession.MailboxGuid.ToString()
});
return;
}
PublicFolderContentMailboxInfo contentMailboxInfo = CoreFolder.GetContentMailboxInfo(base.GetValueOrDefault <string[]>(CoreFolderSchema.ReplicaList, Array <string> .Empty));
PublicFolderContentMailboxInfo contentMailboxInfo2 = parentFolder.GetContentMailboxInfo();
Guid guid = contentMailboxInfo.IsValid ? contentMailboxInfo.MailboxGuid : (contentMailboxInfo2.IsValid ? contentMailboxInfo2.MailboxGuid : publicFolderSession.MailboxGuid);
base.SetProperty(CoreFolderSchema.ReplicaList, new string[]
{
guid.ToString()
});
}
private void LoadFolderHierarchy(StoreObjectId rootFolderId, NativeStorePropertyDefinition[] propertiesToLoad, List <FolderRec> result)
{
using (CoreFolder coreFolder = CoreFolder.Bind(this.StoreSession, rootFolderId))
{
FolderRec folderRec = this.GetFolderRec(coreFolder, propertiesToLoad);
if (base.Flags.HasFlag(LocalMailboxFlags.ParallelPublicFolderMigration))
{
folderRec.FolderName = "Public Root";
}
result.Add(folderRec);
using (QueryResult queryResult = coreFolder.QueryExecutor.FolderQuery(FolderQueryFlags.DeepTraversal, null, null, propertiesToLoad))
{
object[][] rows;
do
{
using (base.RHTracker.Start())
{
rows = queryResult.GetRows(1000);
}
foreach (object[] values in rows)
{
FolderRec folderRec2 = FolderRec.Create(this.StoreSession, propertiesToLoad, values);
if (folderRec2 != null)
{
result.Add(folderRec2);
}
}
}while (rows.Length != 0);
}
}
}
public static FolderRec Create(StoreSession storageSession, PropValue[] pva)
{
byte[] array = null;
byte[] array2 = null;
FolderType folderType = FolderType.Generic;
string text = null;
DateTime dateTime = DateTime.MinValue;
List <PropValueData> list = new List <PropValueData>();
foreach (PropValue native in pva)
{
if (!native.IsNull() && !native.IsError())
{
PropTag propTag = native.PropTag;
if (propTag <= PropTag.EntryId)
{
if (propTag == PropTag.ParentEntryId)
{
array2 = native.GetBytes();
goto IL_CD;
}
if (propTag == PropTag.EntryId)
{
array = native.GetBytes();
goto IL_CD;
}
}
else
{
if (propTag == PropTag.DisplayName)
{
text = native.GetString();
goto IL_CD;
}
if (propTag == PropTag.LastModificationTime)
{
dateTime = native.GetDateTime();
goto IL_CD;
}
if (propTag == PropTag.FolderType)
{
folderType = (FolderType)native.GetInt();
goto IL_CD;
}
}
list.Add(DataConverter <PropValueConverter, PropValue, PropValueData> .GetData(native));
}
IL_CD :;
}
if (array != null)
{
FolderRec folderRec = new FolderRec(array, array2, folderType, text, dateTime, (list.Count > 0) ? list.ToArray() : null);
if (storageSession != null && folderRec[PropTag.ReplicaList] != null)
{
folderRec.IsGhosted = !CoreFolder.IsContentAvailable(storageSession, CoreFolder.GetContentMailboxInfo(ReplicaListProperty.GetStringArrayFromBytes((byte[])folderRec[PropTag.ReplicaList])));
}
return(folderRec);
}
return(null);
}
public T GetFolder <T>(byte[] folderId) where T : StorageFolder, new()
{
base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None);
T result;
using (base.RHTracker.Start())
{
StoreObjectId folderId2 = this.GetFolderId(folderId);
CoreFolder coreFolder;
try
{
coreFolder = CoreFolder.Bind(this.StoreSession, folderId2);
}
catch (ObjectNotFoundException)
{
return(default(T));
}
if (MrsTracer.Provider.IsEnabled(TraceType.DebugTrace))
{
coreFolder.PropertyBag.Load(new PropertyDefinition[]
{
FolderSchema.DisplayName
});
object obj = coreFolder.PropertyBag.TryGetProperty(FolderSchema.DisplayName);
MrsTracer.Provider.Debug("Opened folder '{0}'", new object[]
{
obj
});
}
StorageFolder storageFolder = Activator.CreateInstance <T>();
storageFolder.Config(folderId, coreFolder, this);
result = (T)((object)storageFolder);
}
return(result);
}
internal ContactsFolder(CoreFolder coreFolder) : base(coreFolder)
{
if (base.IsNew)
{
this.Initialize();
}
}
void IDestinationMailbox.DeleteFolder(FolderRec folderRec)
{
MrsTracer.Provider.Function("StorageDestinationMailbox.DeleteFolder(\"{0}\")", new object[]
{
folderRec.FolderName
});
base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None);
using (base.RHTracker.Start())
{
using (CoreFolder coreFolder = CoreFolder.Bind(base.StoreSession, base.GetFolderId(folderRec.ParentId)))
{
GroupOperationResult groupOperationResult = coreFolder.DeleteFolder(DeleteFolderFlags.DeleteMessages | DeleteFolderFlags.DeleteSubFolders, StoreObjectId.FromProviderSpecificId(folderRec.EntryId));
if (groupOperationResult.OperationResult != OperationResult.Succeeded)
{
MrsTracer.Provider.Error("StorageDestinationMailbox.DeleteFolder failed with '{0}'. Folder name: '{1}', type: '{2}', entry id: '{3}'.", new object[]
{
groupOperationResult.Exception.ToString(),
folderRec.FolderName,
folderRec.FolderType,
TraceUtils.DumpEntryId(folderRec.EntryId)
});
groupOperationResult.Exception.PreserveExceptionStack();
throw groupOperationResult.Exception;
}
}
}
}
public static void ApplyPolicyToFolder(MailboxSession session, CoreFolder coreFolder)
{
if (coreFolder.Origin == Origin.Existing)
{
PropertyDefinition[] folderProperties = PolicyTagHelper.FolderProperties;
for (int i = 0; i < folderProperties.Length; i++)
{
if (coreFolder.PropertyBag.IsPropertyDirty(folderProperties[i]))
{
int num = 0;
object obj = coreFolder.PropertyBag.TryGetProperty(InternalSchema.RetentionFlags);
if (obj is int)
{
num = (int)obj;
}
num = FlagsMan.SetNeedRescan(num);
coreFolder.PropertyBag.SetProperty(InternalSchema.RetentionFlags, num);
return;
}
}
return;
}
int num2 = 0;
object obj2 = coreFolder.PropertyBag.TryGetProperty(InternalSchema.RetentionFlags);
if (obj2 is int)
{
num2 = (int)obj2;
}
num2 = FlagsMan.SetNeedRescan(num2);
coreFolder.PropertyBag.SetProperty(InternalSchema.RetentionFlags, num2);
}
protected SynchronizationUploadContextBase(CoreFolder folder, StorageIcsState initialState)
{
Util.ThrowOnNullArgument(folder, "folder");
this.folder = folder;
StoreSession session = this.Session;
bool flag = false;
try
{
if (session != null)
{
session.BeginMapiCall();
session.BeginServerHealthCall();
flag = true;
}
if (StorageGlobals.MapiTestHookBeforeCall != null)
{
StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod());
}
this.mapiCollector = this.MapiCreateCollector(initialState);
}
catch (MapiPermanentException ex)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.CannotCreateCollector(base.GetType()), ex, session, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("SynchronizationUploadContext::MapiCreateCollector failed", new object[0]),
ex
});
}
catch (MapiRetryableException ex2)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.CannotCreateCollector(base.GetType()), ex2, session, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("SynchronizationUploadContext::MapiCreateCollector failed", new object[0]),
ex2
});
}
finally
{
try
{
if (session != null)
{
session.EndMapiCall();
if (flag)
{
session.EndServerHealthCall();
}
}
}
finally
{
if (StorageGlobals.MapiTestHookAfterCall != null)
{
StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod());
}
}
}
this.mapiCollector.AllowWarnings = true;
}
internal FolderInformation(CoreFolder coreFolder)
{
this.propertyBag = CoreObject.GetPersistablePropertyBag(coreFolder);
this.propertyBag.Load(MapiAclTableRestriction.FolderInformation.PropertyDefinitions);
string valueOrDefault = this.propertyBag.GetValueOrDefault <string>(StoreObjectSchema.ContainerClass);
this.storeObjectType = ObjectClass.GetObjectType(valueOrDefault);
}
public static bool IsDumpsterFolder(CoreFolder folder)
{
if (!(folder.Session is PublicFolderSession))
{
throw new InvalidOperationException("folder must be associated with PublicFolderSession");
}
folder.PropertyBag.Load(PublicFolderCOWSession.propertiesToLoadForDumpster);
return((folder.PropertyBag.GetValueOrDefault <ELCFolderFlags>(FolderSchema.AdminFolderFlags, ELCFolderFlags.None) & ELCFolderFlags.DumpsterFolder) != ELCFolderFlags.None);
}
private FolderRec GetFolderRec(StoreObjectId folderId, NativeStorePropertyDefinition[] propertiesToLoad)
{
FolderRec folderRec;
using (CoreFolder coreFolder = CoreFolder.Bind(this.StoreSession, folderId))
{
folderRec = this.GetFolderRec(coreFolder, propertiesToLoad);
}
return(folderRec);
}
private FolderRec GetFolderRec(CoreFolder folder, NativeStorePropertyDefinition[] propertiesToLoad)
{
folder.PropertyBag.Load(propertiesToLoad);
object[] array = new object[propertiesToLoad.Length];
for (int i = 0; i < propertiesToLoad.Length; i++)
{
array[i] = folder.PropertyBag.TryGetProperty(propertiesToLoad[i]);
}
return(FolderRec.Create(this.StoreSession, propertiesToLoad, array));
}
public static StoreObjectId GetRecoverableItemsDeletionsFolderId(CoreFolder folder)
{
byte[] valueOrDefault = folder.PropertyBag.GetValueOrDefault <byte[]>(CoreFolderSchema.DeletedItemsEntryId, Array <byte> .Empty);
if (valueOrDefault.Length == 22)
{
return(folder.Session.IdConverter.CreateFolderId(folder.Session.IdConverter.GetIdFromLongTermId(valueOrDefault)));
}
if (valueOrDefault.Length == 46)
{
return(StoreObjectId.FromProviderSpecificId(valueOrDefault, StoreObjectType.Folder));
}
return(null);
}
protected UserConfiguration GetMailboxConfiguration(CoreFolder folder)
{
UserConfigurationManager userConfigurationManager = ((MailboxSession)folder.Session).UserConfigurationManager;
UserConfiguration result;
try
{
result = userConfigurationManager.GetFolderConfiguration("OlcCalendarFolderSettings", UserConfigurationTypes.Dictionary, folder.Id);
}
catch (ObjectNotFoundException)
{
result = userConfigurationManager.CreateFolderConfiguration("OlcCalendarFolderSettings", UserConfigurationTypes.Dictionary, folder.Id);
}
return(result);
}
internal PropertyTable(CoreFolder coreFolder, NativeStorePropertyDefinition property, ModifyTableOptions options, IModifyTableRestriction modifyTableRestriction)
{
Util.ThrowOnNullArgument(coreFolder, "coreFolder");
Util.ThrowOnNullArgument(property, "property");
EnumValidator.ThrowIfInvalid <ModifyTableOptions>(options);
using (DisposeGuard disposeGuard = this.Guard())
{
this.mapiModifyTable = PropertyTable.GetMapiModifyTable(coreFolder, property);
this.session = coreFolder.Session;
this.propertyReference = this.session.Mailbox.MapiStore;
this.tableNameForTracing = property.Name;
this.options = options;
this.modifyTableRestriction = modifyTableRestriction;
disposeGuard.Success();
}
}
internal void Save(CoreFolder coreFolder)
{
this.CheckValid();
Util.ThrowOnNullArgument(coreFolder, "coreFolder");
if (this.IsDirty)
{
this.EnforceRestriction(coreFolder);
this.SaveSharingPartnership(coreFolder.Session as MailboxSession);
using (IModifyTable permissionTable = coreFolder.GetPermissionTable(this.PermissionSet.ModifyTableOptions))
{
MapiAclTableAdapter mapiAclTableAdapter = new MapiAclTableAdapter(permissionTable);
this.AddPermissionEntriesForRemove(mapiAclTableAdapter);
this.AddPermissionEntriesForAddOrModify(mapiAclTableAdapter);
mapiAclTableAdapter.ApplyPendingChanges(true);
}
}
this.isInvalid = true;
}
private void ExecuteSyncStateOperation(Action <StoreSession, CoreFolder> operation)
{
using (base.RHTracker.Start())
{
if (base.IsPublicFolderMove || base.IsPublicFolderMailboxRestore)
{
PublicFolderSession publicFolderSession = this.GetPublicFolderSession();
using (CoreFolder coreFolder = CoreFolder.Bind(publicFolderSession, publicFolderSession.GetTombstonesRootFolderId()))
{
operation(publicFolderSession, coreFolder);
goto IL_A9;
}
}
MailboxSession mailboxSession = null;
bool flag = false;
try
{
if (base.UseHomeMDB)
{
mailboxSession = this.GetMailboxSession();
}
else
{
mailboxSession = this.OpenSystemMailbox();
flag = true;
}
using (CoreFolder coreFolder2 = CoreFolder.Create(mailboxSession, mailboxSession.GetDefaultFolderId(DefaultFolderType.Configuration), false, "MailboxReplicationService SyncStates", CreateMode.OpenIfExists))
{
coreFolder2.Save(SaveMode.FailOnAnyConflict);
operation(mailboxSession, coreFolder2);
}
}
finally
{
if (flag && mailboxSession != null)
{
mailboxSession.Dispose();
}
}
IL_A9 :;
}
}
public override void Apply(CoreFolder folder)
{
using (UserConfiguration mailboxConfiguration = this.GetMailboxConfiguration(folder))
{
IDictionary dictionary = mailboxConfiguration.GetDictionary();
dictionary["OlcIsVisible"] = this.IsVisible;
dictionary["OlcIsHidden"] = this.IsHidden;
dictionary["OlcColorIndex"] = this.ColorIndex;
dictionary["OlcIsDailySummaryEnabled"] = this.IsDailySummaryEnabled;
dictionary["ConsumerTaskPermissionLevel"] = this.ConsumerTaskPermissionLevel;
dictionary["OlcConsecutiveErrorCount"] = this.ConsecutiveErrorCount;
dictionary["OlcTotalErrorCount"] = this.TotalErrorCount;
dictionary["OlcPollingInterval"] = this.PollingInterval;
dictionary["OlcEntityTag"] = (this.EntityTag ?? string.Empty);
dictionary["OlcImportedEventCount"] = this.ImportedEventCount;
dictionary["OlcTotalEventCount"] = this.TotalEventCount;
dictionary["OlcUpdateStatus"] = this.UpdateStatus;
dictionary["OlcMissingUidCount"] = this.MissingUidCount;
dictionary["OlcConsecutiveCriticalErrorCount"] = this.ConsecutiveCriticalErrorCount;
dictionary["OlcPersonIdMigrated"] = this.PersonIdMigrated;
ConflictResolutionResult conflictResolutionResult = mailboxConfiguration.Save(SaveMode.ResolveConflicts);
if (conflictResolutionResult.SaveStatus == SaveResult.IrresolvableConflict)
{
throw new ConversionFailedException(ConversionFailureReason.ConverterInternalFailure, MrsStrings.ReportCalendarFolderFaiSaveFailed, null);
}
MrsTracer.Provider.Debug("Calendar folder user configuration has been updated.", new object[0]);
}
folder.PropertyBag.Load(CalendarFolderSchema.Instance.AutoloadProperties);
if (this.OlcCalendarType != OlcCalendarType.RegularEvents)
{
folder.PropertyBag[FolderSchema.DisplayName] = (this.Name ?? string.Empty);
}
folder.PropertyBag[CalendarFolderSchema.CharmId] = (this.CharmId ?? string.Empty);
FolderSaveResult folderSaveResult = folder.Save(SaveMode.NoConflictResolution);
if (folderSaveResult.OperationResult == OperationResult.Failed)
{
throw new ConversionFailedException(ConversionFailureReason.ConverterInternalFailure, MrsStrings.ReportCalendarFolderSaveFailed, null);
}
MrsTracer.Provider.Debug("Calendar folder has been updated with settings.", new object[0]);
folder.PropertyBag.Load(CalendarFolderSchema.Instance.AutoloadProperties);
}
internal AclModifyTable(CoreFolder coreFolder, ModifyTableOptions options, IModifyTableRestriction modifyTableRestriction, bool useSecurityDescriptorOnly, bool loadTableEntries)
{
using (DisposeGuard disposeGuard = this.Guard())
{
this.coreFolder = coreFolder;
this.options = options;
this.modifyTableRestriction = modifyTableRestriction;
this.recipientSession = coreFolder.Session.GetADRecipientSession(true, ConsistencyMode.IgnoreInvalid);
this.useSecurityDescriptorOnly = useSecurityDescriptorOnly;
if (loadTableEntries)
{
this.Load();
}
else
{
this.replaceAllRows = true;
}
disposeGuard.Success();
}
}
internal static void SyncPublicFolder(IConfigurationSession configurationSession, StoreObjectId folderId)
{
using (PublicFolderDataProvider publicFolderDataProvider = new PublicFolderDataProvider(configurationSession, "*-PublicFolderClientPermission", Guid.Empty))
{
PublicFolderSession publicFolderSession = publicFolderDataProvider.PublicFolderSession;
using (CoreFolder coreFolder = CoreFolder.Bind(publicFolderSession, folderId, new PropertyDefinition[]
{
CoreFolderSchema.AclTableAndSecurityDescriptor
}))
{
PublicFolderContentMailboxInfo contentMailboxInfo = coreFolder.GetContentMailboxInfo();
Guid guid = contentMailboxInfo.IsValid ? contentMailboxInfo.MailboxGuid : Guid.Empty;
ExchangePrincipal contentMailboxPrincipal;
if (guid != Guid.Empty && guid != publicFolderSession.MailboxGuid && PublicFolderSession.TryGetPublicFolderMailboxPrincipal(publicFolderSession.OrganizationId, guid, true, out contentMailboxPrincipal))
{
PublicFolderSyncJobRpc.SyncFolder(contentMailboxPrincipal, folderId.ProviderLevelItemId);
}
}
}
}
protected override void InternalProcessRecord()
{
try
{
if (this.Path != null)
{
PublicFolder publicFolder = (PublicFolder)base.GetDataObject <PublicFolder>(this.Path, base.DataSession, null, new LocalizedString?(Strings.ErrorPublicFolderNotFound(this.Path.ToString())), new LocalizedString?(Strings.ErrorPublicFolderNotUnique(this.Path.ToString())));
using (this.publicFolderDataProvider.PublicFolderSession.GetRestrictedOperationToken())
{
using (CoreFolder coreFolder = CoreFolder.Bind(this.publicFolderDataProvider.PublicFolderSession, publicFolder.InternalFolderIdentity.ObjectId))
{
coreFolder.MoveFolder(coreFolder, this.DataObject.InternalFolderIdentity.ObjectId);
this.folderUpdated = true;
}
}
}
if (this.OverrideContentMailbox != null && (this.Force || base.ShouldContinue(Strings.ConfirmationMessageOverrideContentMailbox)))
{
PublicFolder publicFolder2 = (PublicFolder)base.GetDataObject <PublicFolder>(this.Identity, base.DataSession, null, new LocalizedString?(Strings.ErrorPublicFolderNotFound(this.Identity.ToString())), new LocalizedString?(Strings.ErrorPublicFolderNotUnique(this.Identity.ToString())));
using (this.publicFolderDataProvider.PublicFolderSession.GetRestrictedOperationToken())
{
using (CoreFolder coreFolder2 = CoreFolder.Bind(this.publicFolderDataProvider.PublicFolderSession, publicFolder2.InternalFolderIdentity.ObjectId))
{
coreFolder2.PropertyBag.SetProperty(CoreFolderSchema.ReplicaList, new string[]
{
this.contentMailboxGuid.ToString()
});
coreFolder2.PropertyBag.SetProperty(CoreFolderSchema.LastMovedTimeStamp, ExDateTime.UtcNow);
coreFolder2.Save(SaveMode.NoConflictResolution);
this.folderUpdated = true;
}
}
}
base.InternalProcessRecord();
}
catch (NotSupportedException exception)
{
base.WriteError(exception, ErrorCategory.InvalidType, this.Identity);
}
}
public void ItemOperation(COWSettings settings, IDumpsterItemOperations dumpster, COWTriggerAction operation, COWTriggerActionState state, StoreSession session, StoreObjectId itemId, CoreItem item, CoreFolder folder, bool onBeforeNotification, OperationResult result, CallbackContext callbackContext)
{
Util.ThrowOnNullArgument(session, "session");
EnumValidator.ThrowIfInvalid <COWTriggerAction>(operation, "operation");
EnumValidator.ThrowIfInvalid <COWTriggerActionState>(state, "state");
EnumValidator.ThrowIfInvalid <OperationResult>(result, "result");
Util.ThrowOnNullArgument(item, "item");
MailboxSession mailboxSession = session as MailboxSession;
ExDateTime now = ExDateTime.Now;
try
{
item.PropertyBag.Load(COWSiteMailboxMessageDedup.PropsForMessageRemoval);
if (item.Id != null && item.Id.ObjectId != null)
{
StoreObjectId storeObjectId = item.PropertyBag.TryGetProperty(StoreObjectSchema.ParentItemId) as StoreObjectId;
if (storeObjectId != null)
{
using (CoreFolder coreFolder = CoreFolder.Bind(session, storeObjectId))
{
DeleteItemFlags deleteItemFlags = DeleteItemFlags.HardDelete | DeleteItemFlags.SuppressReadReceipt;
coreFolder.DeleteItems(deleteItemFlags, new StoreObjectId[]
{
item.Id.ObjectId
});
}
COWSiteMailboxMessageDedup.Tracer.TraceDebug <StoreObjectId, string, double>((long)this.GetHashCode(), "COWSiteMailboxMessageDedup.ItemOperation: deleting message {0} from site mailbox {1} used {2} milliseconds", itemId, mailboxSession.DisplayName, (ExDateTime.Now - now).TotalMilliseconds);
}
}
}
catch (StoragePermanentException arg)
{
COWSiteMailboxMessageDedup.Tracer.TraceError <StoragePermanentException>((long)this.GetHashCode(), "COWSiteMailboxMessageDedup.ItemOperation: got store permanent exception: {0}", arg);
}
catch (StorageTransientException arg2)
{
COWSiteMailboxMessageDedup.Tracer.TraceError <StorageTransientException>((long)this.GetHashCode(), "COWSiteMailboxMessageDedup.ItemOperation: got store transient exception: {0}", arg2);
}
callbackContext.SiteMailboxMessageDedupState = COWProcessorState.Processed;
}
public FolderBindHistoryManager(CoreFolder folder)
{
Util.ThrowOnNullArgument(folder, "folder");
this.currentFolder = folder;
this.ShouldSkipAudit = false;
this.bindingHistory.Add(this.GenerateBindingEntry());
string[] array = this.ReadRecentHistory();
if (array == null)
{
return;
}
string bindingEntryIdentity = this.GetBindingEntryIdentity();
long num = (long)(DateTime.UtcNow - FolderBindHistoryManager.Epoch).TotalMinutes;
foreach (string text in array)
{
if (text != null)
{
string[] array3 = text.Split(new char[0]);
long num2;
if (array3.Length == 2 && long.TryParse(array3[0], out num2))
{
if (bindingEntryIdentity.Equals(array3[1], StringComparison.OrdinalIgnoreCase))
{
if ((double)(num - num2) < FolderBindHistoryManager.HistoryRefreshTime.TotalMinutes)
{
this.ShouldSkipAudit = true;
}
}
else if ((double)(num - num2) < FolderBindHistoryManager.HistoryRefreshTime.TotalMinutes)
{
this.bindingHistory.Add(text);
}
}
}
}
}
private void LoadFrom(CoreFolder coreFolder)
{
using (IModifyTable permissionTable = coreFolder.GetPermissionTable(this.PermissionSet.ModifyTableOptions))
{
try
{
this.LoadFrom(new MapiAclTableAdapter(permissionTable));
}
catch (DataSourceOperationException ex)
{
throw StorageGlobals.TranslateDirectoryException(ServerStrings.ADException, ex, null, "PermissionsTable.LoadFrom. Failed due to directory exception {0}.", new object[]
{
ex
});
}
catch (DataSourceTransientException ex2)
{
throw StorageGlobals.TranslateDirectoryException(ServerStrings.ADException, ex2, null, "PermissionsTable.LoadFrom. Failed due to directory exception {0}.", new object[]
{
ex2
});
}
}
}
void IDestinationMailbox.MoveFolder(byte[] folderId, byte[] oldParentId, byte[] newParentId)
{
MrsTracer.Provider.Function("StorageDestinationMailbox.MoveFolder", new object[0]);
base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None);
using (base.RHTracker.Start())
{
using (CoreFolder coreFolder = CoreFolder.Bind(base.StoreSession, base.GetFolderId(oldParentId)))
{
using (CoreFolder coreFolder2 = CoreFolder.Bind(base.StoreSession, base.GetFolderId(newParentId)))
{
GroupOperationResult groupOperationResult = coreFolder.MoveFolder(coreFolder2, StoreObjectId.FromProviderSpecificId(folderId));
if (groupOperationResult.OperationResult != OperationResult.Succeeded)
{
MrsTracer.Provider.Error("StorageDestinationMailbox.MoveFolder failed with {0}", new object[]
{
groupOperationResult.Exception.ToString()
});
groupOperationResult.Exception.PreserveExceptionStack();
throw groupOperationResult.Exception;
}
}
}
}
}
public ContentsSynchronizationUploadContext(CoreFolder folder, StorageIcsState initialState) : base(folder, initialState)
{
}
internal override void Config(byte[] folderId, CoreFolder folder, StorageMailbox mailbox)
{
base.Config(folderId, folder, mailbox);
this.MapiFolder.AllowWarnings = true;
}
internal SearchFolder(CoreFolder coreFolder) : base(coreFolder)
{
}
