internal IEnumerable <DatabaseEvent> ReadEvents(MapiSession mapiSession, Database database, long startCounter, Restriction restriction, bool includeMoveDestinationEvents, int resultSize)
{
if (mapiSession == null)
{
throw new ArgumentException("mapiSession");
}
if (database == null)
{
throw new ArgumentException("database");
}
int count = 0;
long endCounter = (0L < startCounter) ? (startCounter - 1L) : 0L;
MapiEvent[] events = null;
DatabaseId databaseId = MapiTaskHelper.ConvertDatabaseADObjectToDatabaseId(database);
MapiEventManager eventManager = MapiEventManager.Create(mapiSession.Administration, Guid.NewGuid(), databaseId.Guid);
for (;;)
{
startCounter = endCounter + 1L;
ReadEventsFlags flags = includeMoveDestinationEvents ? ReadEventsFlags.IncludeMoveDestinationEvents : ReadEventsFlags.None;
mapiSession.InvokeWithWrappedException(delegate()
{
events = eventManager.ReadEvents(startCounter, (0 < resultSize) ? resultSize : 1000, 0, restriction, flags, out endCounter);
}, Strings.ErrorCannotReadDatabaseEvents(databaseId.ToString()), databaseId);
foreach (MapiEvent mapiEvent in events)
{
yield return(new DatabaseEvent(mapiEvent, databaseId, this.server, database.Server.ObjectGuid == this.server.Guid));
count++;
if (0 < resultSize && count == resultSize)
{
goto Block_6;
}
}
if (endCounter == startCounter)
{
goto Block_8;
}
}
Block_6:
yield break;
Block_8:
yield break;
}
internal static void UpdateSDAndRefreshMailbox(MapiAdministrationSession mapiAdministrationSession, ADUser userToConnect, MailboxDatabase database, Guid mailboxGuid, string parameterSetName, Task.TaskVerboseLoggingDelegate verboseLogger, Task.TaskWarningLoggingDelegate warningLogger)
{
ConnectMailbox.UpdateMailboxSecurityDescriptor(userToConnect.Sid, userToConnect, mapiAdministrationSession, database, mailboxGuid, parameterSetName, verboseLogger);
try
{
mapiAdministrationSession.ForceStoreToRefreshMailbox(new MailboxId(MapiTaskHelper.ConvertDatabaseADObjectToDatabaseId(database), mailboxGuid));
}
catch (FailedToRefreshMailboxException ex)
{
TaskLogger.Trace("An exception is caught and ignored when refreshing the mailbox '{0}'. Exception: {1}", new object[]
{
mailboxGuid,
ex.Message
});
warningLogger(Strings.WarningReplicationLatency);
}
try
{
mapiAdministrationSession.SyncMailboxWithDS(new MailboxId(MapiTaskHelper.ConvertDatabaseADObjectToDatabaseId(database), mailboxGuid));
}
catch (DataSourceTransientException ex2)
{
TaskLogger.Trace("Swallowing exception {0} from mapi.net", new object[]
{
ex2
});
warningLogger(ex2.LocalizedString);
}
catch (DataSourceOperationException ex3)
{
TaskLogger.Trace("Swallowing exception {0} from mapi.net", new object[]
{
ex3
});
warningLogger(ex3.LocalizedString);
}
catch (ArgumentNullException ex4)
{
TaskLogger.Trace("Swallowing exception {0} from mapi.net", new object[]
{
ex4
});
warningLogger(Strings.ErrorNoDatabaseInfor);
}
}
protected override void InternalValidate()
{
TaskLogger.LogEnter();
this.isToInactiveMailbox = false;
this.isDisconnectInactiveMailbox = false;
if (this.Identity != null)
{
base.InternalValidate();
this.isToInactiveMailbox = this.IsToInactiveMailbox();
this.isDisconnectInactiveMailbox = this.IsDisconnectInactiveMailbox();
if (!this.isToInactiveMailbox && !this.isDisconnectInactiveMailbox)
{
MailboxTaskHelper.BlockRemoveOrDisableIfLitigationHoldEnabled(base.DataObject, new Task.ErrorLoggerDelegate(base.WriteError), false, this.IgnoreLegalHold.ToBool());
MailboxTaskHelper.BlockRemoveOrDisableIfDiscoveryHoldEnabled(base.DataObject, new Task.ErrorLoggerDelegate(base.WriteError), false, this.IgnoreLegalHold.ToBool());
}
MailboxTaskHelper.BlockRemoveOrDisableIfJournalNDRMailbox(base.DataObject, this.TenantLocalConfigurationSession, new Task.ErrorLoggerDelegate(base.WriteError), false);
if (ComplianceConfigImpl.JournalArchivingHardeningEnabled && !this.skipJournalArchivingCheck)
{
MailboxTaskHelper.BlockRemoveOrDisableMailboxIfJournalArchiveEnabled(base.DataSession as IRecipientSession, this.ConfigurationSession, base.DataObject, new Task.ErrorLoggerDelegate(base.WriteError), false);
}
if (base.DataObject.RecipientTypeDetails == RecipientTypeDetails.ArbitrationMailbox && this.ArbitrationMailboxUsageValidationRequired)
{
ADUser dataObject = base.DataObject;
Task.ErrorLoggerDelegate writeError = new Task.ErrorLoggerDelegate(base.WriteError);
TIdentity identity = this.Identity;
MailboxTaskHelper.ValidateNotBuiltInArbitrationMailbox(dataObject, writeError, Strings.ErrorRemoveArbitrationMailbox(identity.ToString()));
ADUser dataObject2 = base.DataObject;
IRecipientSession tenantGlobalCatalogSession = base.TenantGlobalCatalogSession;
Task.ErrorLoggerDelegate writeError2 = new Task.ErrorLoggerDelegate(base.WriteError);
TIdentity identity2 = this.Identity;
MailboxTaskHelper.ValidateArbitrationMailboxHasNoGroups(dataObject2, tenantGlobalCatalogSession, writeError2, Strings.ErrorRemoveMailboxWithAssociatedApprovalRecipents(identity2.ToString()));
ADUser dataObject3 = base.DataObject;
bool overrideCheck = this.RemoveArbitrationMailboxWithOABsAllowed.ToBool();
Task.ErrorLoggerDelegate writeError3 = new Task.ErrorLoggerDelegate(base.WriteError);
TIdentity identity3 = this.Identity;
MailboxTaskHelper.ValidateNoOABsAssignedToArbitrationMailbox(dataObject3, overrideCheck, writeError3, Strings.ErrorRemoveArbitrationMailboxWithOABsAssigned(identity3.ToString()));
ADUser dataObject4 = base.DataObject;
IRecipientSession tenantGlobalCatalogSession2 = base.TenantGlobalCatalogSession;
ADObjectId rootOrgContainerId = base.RootOrgContainerId;
bool isPresent = this.RemoveLastArbitrationMailboxAllowed.IsPresent;
Task.ErrorLoggerDelegate writeError4 = new Task.ErrorLoggerDelegate(base.WriteError);
TIdentity identity4 = this.Identity;
MailboxTaskHelper.ValidateNotLastArbitrationMailbox(dataObject4, tenantGlobalCatalogSession2, rootOrgContainerId, isPresent, writeError4, Strings.ErrorCannotRemoveLastArbitrationMailboxInOrganization(identity4.ToString()));
}
if (this.AuditLog)
{
if (base.DataObject.RecipientTypeDetails != RecipientTypeDetails.AuditLogMailbox)
{
LocalizedException exception = new RecipientTaskException(Strings.ErrorSpecifiedMailboxShouldBeAuditLogMailbox(base.DataObject.Identity.ToString()));
ExchangeErrorCategory category = ExchangeErrorCategory.Context;
TIdentity identity5 = this.Identity;
base.WriteError(exception, category, identity5.ToString());
}
}
else if (base.DataObject.RecipientTypeDetails == RecipientTypeDetails.AuditLogMailbox)
{
LocalizedException exception2 = new RecipientTaskException(Strings.ErrorAuditLogMailboxShouldBeDeletedWithAuditLogSpecified(base.DataObject.Identity.ToString()));
ExchangeErrorCategory category2 = ExchangeErrorCategory.Context;
TIdentity identity6 = this.Identity;
base.WriteError(exception2, category2, identity6.ToString());
}
}
else
{
this.InternalValidateStoreMailboxIdentity();
try
{
this.mailboxStatistics = (MailboxStatistics)base.GetDataObject <MailboxStatistics>(this.StoreMailboxIdentity, this.mapiSession, MapiTaskHelper.ConvertDatabaseADObjectToDatabaseId(this.database), new LocalizedString?(Strings.ErrorStoreMailboxNotFound(this.StoreMailboxIdentity.ToString(), this.Database.ToString())), new LocalizedString?(Strings.ErrorStoreMailboxNotUnique(this.StoreMailboxIdentity.ToString(), this.Database.ToString())), ExchangeErrorCategory.Client);
MailboxTaskHelper.ValidateMailboxIsDisconnected(base.TenantGlobalCatalogSession, this.mailboxStatistics.MailboxGuid, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError));
this.mailboxStatistics.Database = this.database.Identity;
}
catch (DataSourceTransientException exception3)
{
base.WriteError(exception3, ExchangeErrorCategory.ServerTransient, this.StoreMailboxIdentity);
}
}
if (this.PublicFolder)
{
Organization orgContainer = this.TenantLocalConfigurationSession.GetOrgContainer();
if (orgContainer.DefaultPublicFolderMailbox.HierarchyMailboxGuid == Guid.Empty && !this.Force)
{
LocalizedException exception4 = new RecipientTaskException(Strings.ErrorPrimaryPublicFolderMailboxNotFound);
ExchangeErrorCategory category3 = ExchangeErrorCategory.Context;
TIdentity identity7 = this.Identity;
base.WriteError(exception4, category3, identity7.ToString());
}
if (this.currentOrganizationId == null || this.currentOrganizationId != base.DataObject.OrganizationId)
{
this.currentOrganizationId = base.DataObject.OrganizationId;
TenantPublicFolderConfigurationCache.Instance.RemoveValue(base.DataObject.OrganizationId);
}
MailboxTaskHelper.RemoveOrDisablePublicFolderMailbox(base.DataObject, Guid.Empty, this.tenantLocalConfigurationSession, new Task.ErrorLoggerDelegate(base.WriteError), false, this.Force);
}
TaskLogger.LogExit();
}
internal bool GetMailboxQuarantineStatus()
{
if (this.mapiSession == null)
{
this.mapiSession = new MapiAdministrationSession(this.DbLocationInfo.ServerLegacyDN, Fqdn.Parse(this.DbLocationInfo.ServerFqdn));
}
StoreMailboxIdParameter id = StoreMailboxIdParameter.Parse(this.exchangeGuid.ToString());
bool isQuarantined;
using (MailboxStatistics mailboxStatistics = (MailboxStatistics)base.GetDataObject <MailboxStatistics>(id, this.mapiSession, MapiTaskHelper.ConvertDatabaseADObjectToDatabaseId(this.database), new LocalizedString?(Strings.ErrorStoreMailboxNotFound(this.Identity.ToString(), this.Database.Identity.ToString())), new LocalizedString?(Strings.ErrorStoreMailboxNotUnique(this.Identity.ToString(), this.Database.Identity.ToString()))))
{
isQuarantined = mailboxStatistics.IsQuarantined;
}
return(isQuarantined);
}
private static RawSecurityDescriptor UpdateMailboxSecurityDescriptor(SecurityIdentifier userSid, ADUser userToConnect, MapiAdministrationSession mapiAdministrationSession, MailboxDatabase database, Guid deletedMailboxGuid, string parameterSetName, Task.TaskVerboseLoggingDelegate verboseLogger)
{
RawSecurityDescriptor rawSecurityDescriptor = null;
try
{
rawSecurityDescriptor = mapiAdministrationSession.GetMailboxSecurityDescriptor(new MailboxId(MapiTaskHelper.ConvertDatabaseADObjectToDatabaseId(database), deletedMailboxGuid));
}
catch (Microsoft.Exchange.Data.Mapi.Common.MailboxNotFoundException)
{
rawSecurityDescriptor = new RawSecurityDescriptor(ControlFlags.DiscretionaryAclDefaulted | ControlFlags.SystemAclDefaulted | ControlFlags.SelfRelative, WindowsIdentity.GetCurrent().User, WindowsIdentity.GetCurrent().User, null, null);
DiscretionaryAcl discretionaryAcl = new DiscretionaryAcl(true, true, 0);
byte[] binaryForm = new byte[discretionaryAcl.BinaryLength];
discretionaryAcl.GetBinaryForm(binaryForm, 0);
rawSecurityDescriptor.DiscretionaryAcl = new RawAcl(binaryForm, 0);
}
bool flag = false;
foreach (GenericAce genericAce in rawSecurityDescriptor.DiscretionaryAcl)
{
KnownAce knownAce = (KnownAce)genericAce;
if (knownAce.SecurityIdentifier.IsWellKnown(WellKnownSidType.SelfSid))
{
flag = true;
break;
}
}
if (!flag)
{
CommonAce ace = new CommonAce(AceFlags.ContainerInherit, AceQualifier.AccessAllowed, 131073, new SecurityIdentifier(WellKnownSidType.SelfSid, null), false, null);
rawSecurityDescriptor.DiscretionaryAcl.InsertAce(0, ace);
}
rawSecurityDescriptor.SetFlags(rawSecurityDescriptor.ControlFlags | ControlFlags.SelfRelative);
if ("Linked" == parameterSetName || "Shared" == parameterSetName || "Room" == parameterSetName || "Equipment" == parameterSetName)
{
RawSecurityDescriptor sd = userToConnect.ReadSecurityDescriptor();
MailboxTaskHelper.GrantPermissionToLinkedUserAccount(userToConnect.MasterAccountSid, ref rawSecurityDescriptor, ref sd);
verboseLogger(Strings.VerboseSaveADSecurityDescriptor(userToConnect.Id.ToString()));
userToConnect.SaveSecurityDescriptor(sd);
}
mapiAdministrationSession.Administration.PurgeCachedMailboxObject(deletedMailboxGuid);
return(rawSecurityDescriptor);
}
protected override void InternalValidate()
{
TaskLogger.LogEnter();
try
{
MailboxState?mailboxState = null;
Database database = null;
database = (MailboxDatabase)base.GetDataObject <MailboxDatabase>(this.Database, base.DataSession, null, new LocalizedString?(Strings.ErrorDatabaseNotFound(this.Database.ToString())), new LocalizedString?(Strings.ErrorDatabaseNotUnique(this.Database.ToString())), ExchangeErrorCategory.Client);
if (database.Recovery)
{
base.WriteError(new TaskArgumentException(Strings.ErrorInvalidOperationOnRecoveryMailboxDatabase(this.Database.ToString())), ExchangeErrorCategory.Client, this.Identity);
}
DatabaseLocationInfo databaseLocationInfo = null;
try
{
databaseLocationInfo = ActiveManager.GetActiveManagerInstance().GetServerForDatabase(database.Id.ObjectGuid);
}
catch (ObjectNotFoundException exception)
{
base.WriteError(exception, ExchangeErrorCategory.ServerOperation, null);
}
if (base.IsVerboseOn)
{
base.WriteVerbose(Strings.VerboseConnectionAdminRpcInterface(databaseLocationInfo.ServerFqdn));
}
this.mapiSession = new MapiAdministrationSession(databaseLocationInfo.ServerLegacyDN, Fqdn.Parse(databaseLocationInfo.ServerFqdn));
this.guidMdb = database.Guid;
this.Identity.Flags |= 1UL;
this.mailboxStatistics = (MailboxStatistics)base.GetDataObject <MailboxStatistics>(this.Identity, this.mapiSession, MapiTaskHelper.ConvertDatabaseADObjectToDatabaseId(database), new LocalizedString?(Strings.ErrorStoreMailboxNotFound(this.Identity.ToString(), this.Database.ToString())), new LocalizedString?(Strings.ErrorStoreMailboxNotUnique(this.Identity.ToString(), this.Database.ToString())));
this.guidMailbox = this.mailboxStatistics.MailboxGuid;
mailboxState = this.mailboxStatistics.DisconnectReason;
if (mailboxState == null)
{
this.mapiSession.Administration.SyncMailboxWithDS(this.guidMdb, this.guidMailbox);
this.mailboxStatistics.Dispose();
this.mailboxStatistics = null;
this.mailboxStatistics = (MailboxStatistics)base.GetDataObject <MailboxStatistics>(this.Identity, this.mapiSession, MapiTaskHelper.ConvertDatabaseADObjectToDatabaseId(database), new LocalizedString?(Strings.ErrorStoreMailboxNotFound(this.Identity.ToString(), this.Database.ToString())), new LocalizedString?(Strings.ErrorStoreMailboxNotUnique(this.Identity.ToString(), this.Database.ToString())));
mailboxState = this.mailboxStatistics.DisconnectReason;
if (mailboxState == null)
{
base.WriteError(new RemoveNotDisconnectedStoreMailboxPermanentException(this.Identity.ToString()), ErrorCategory.InvalidArgument, this.Identity);
}
}
if (MailboxStateParameter.SoftDeleted == this.MailboxState && Microsoft.Exchange.Data.Mapi.MailboxState.SoftDeleted == mailboxState)
{
this.deleteMailboxFlags = 18;
}
else if (MailboxStateParameter.Disabled == this.MailboxState && Microsoft.Exchange.Data.Mapi.MailboxState.Disabled == mailboxState)
{
this.deleteMailboxFlags = 2;
}
else
{
base.WriteError(new UnexpectedRemoveStoreMailboxStatePermanentException(this.Identity.ToString(), mailboxState.ToString(), this.MailboxState.ToString()), ErrorCategory.InvalidArgument, this.Identity);
}
}
catch (MapiPermanentException exception2)
{
base.WriteError(exception2, ExchangeErrorCategory.ServerOperation, this.Identity);
}
catch (MapiRetryableException exception3)
{
base.WriteError(exception3, ExchangeErrorCategory.ServerTransient, this.Identity);
}
finally
{
TaskLogger.LogExit();
}
}
internal IEnumerable <DatabaseEventWatermark> ReadWatermarks(MapiSession mapiSession, Database database, Guid?consumerGuid, Guid?mailboxGuid)
{
if (mapiSession == null)
{
throw new ArgumentException("mapiSession");
}
if (database == null)
{
throw new ArgumentException("database");
}
Watermark[] wms = null;
long lastCounter = 0L;
DatabaseId databaseId = MapiTaskHelper.ConvertDatabaseADObjectToDatabaseId(database);
if (consumerGuid != null)
{
MapiEventManager eventManager = MapiEventManager.Create(mapiSession.Administration, consumerGuid.Value, databaseId.Guid);
mapiSession.InvokeWithWrappedException(delegate()
{
lastCounter = eventManager.ReadLastEvent().EventCounter;
if (mailboxGuid != null)
{
Watermark watermark = eventManager.GetWatermark(mailboxGuid.Value);
wms = ((watermark == null) ? new Watermark[0] : new Watermark[]
{
watermark
});
return;
}
wms = eventManager.GetWatermarks();
}, Strings.ErrorCannotReadDatabaseWatermarks(databaseId.ToString()), databaseId);
foreach (Watermark wm in wms)
{
yield return(new DatabaseEventWatermark(wm, databaseId, lastCounter, this.server, database.Server.ObjectGuid == this.server.Guid));
}
}
else
{
GetDatabaseEventWatermark.< > c__DisplayClass7 CS$ < > 8__locals3 = new GetDatabaseEventWatermark.< > c__DisplayClass7();
CS$ < > 8__locals3.eventManager = MapiEventManager.Create(mapiSession.Administration, Guid.Empty, databaseId.Guid);
if (mailboxGuid != null)
{
CS$ < > 8__locals3.mailboxGuids = new Guid[]
{
mailboxGuid.Value
};
}
else if (database.IsPublicFolderDatabase)
{
CS$ < > 8__locals3.mailboxGuids = new Guid[]
{
Guid.Empty
};
}
else
{
PropValue[][] mailboxTable = null;
mapiSession.InvokeWithWrappedException(delegate()
{
mailboxTable = mapiSession.Administration.GetMailboxTable(databaseId.Guid, new PropTag[]
{
PropTag.UserGuid
});
}, Strings.ErrorCannotReadDatabaseWatermarks(databaseId.ToString()), databaseId);
CS$ < > 8__locals3.mailboxGuids = new Guid[mailboxTable.Length + 1];
CS$ < > 8__locals3.mailboxGuids[0] = Guid.Empty;
for (int j = 0; j < mailboxTable.Length; j++)
{
CS$ < > 8__locals3.mailboxGuids[j + 1] = new Guid(mailboxTable[j][0].GetBytes());
}
}
CS$ < > 8__locals3.databaseVersionGuid = Guid.Empty;
int i;
for (i = 0; i < CS$ < > 8__locals3.mailboxGuids.Length; i++)
{
mapiSession.InvokeWithWrappedException(delegate()
{
lastCounter = CS$ < > 8__locals3.eventManager.ReadLastEvent().EventCounter;
wms = mapiSession.Administration.GetWatermarksForMailbox(databaseId.Guid, ref CS$ < > 8__locals3.databaseVersionGuid, CS$ < > 8__locals3.mailboxGuids[i]);
}, Strings.ErrorCannotReadDatabaseWatermarks(databaseId.ToString()), databaseId);
foreach (Watermark wm2 in wms)
{
yield return(new DatabaseEventWatermark(wm2, databaseId, lastCounter, this.server, database.Server.ObjectGuid == this.server.Guid));
}
}
}
yield break;
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
foreach (Database database in this.databases)
{
try
{
Guid mailboxGuid = Guid.Empty;
MailboxTableFlags mailboxTableFlags = MailboxTableFlags.MailboxTableFlagsNone;
if (null != this.identity)
{
mailboxGuid = this.identity.MailboxGuid;
}
if (this.isRunningMailboxStatisticsTask)
{
mailboxTableFlags |= MailboxTableFlags.IncludeSoftDeletedMailbox;
}
QueryFilter filter = new MailboxContextFilter(mailboxGuid, (ulong)((long)mailboxTableFlags), this.NoADLookupForMailboxStatistics);
IEnumerable <TPresentationObject> enumerable = this.mapiSession.FindPaged <TDataObject, TPresentationObject>(filter, MapiTaskHelper.ConvertDatabaseADObjectToDatabaseId(database), QueryScope.SubTree, null, 0, 0);
foreach (TPresentationObject tpresentationObject in enumerable)
{
try
{
MailboxId mailboxId = tpresentationObject.Identity as MailboxId;
if (this.Identity == null || (null != mailboxId && ((Guid.Empty != this.identity.MailboxGuid && this.identity.MailboxGuid == mailboxId.MailboxGuid) || (!string.IsNullOrEmpty(this.identity.MailboxExchangeLegacyDn) && string.Equals(this.identity.MailboxExchangeLegacyDn, mailboxId.MailboxExchangeLegacyDn, StringComparison.OrdinalIgnoreCase)))))
{
if (this.isRunningLogonStatisticsTask)
{
((LogonStatistics)((object)tpresentationObject)).ServerName = database.ServerName;
((LogonStatistics)((object)tpresentationObject)).DatabaseName = database.Name;
}
else if (this.isRunningResourceMonitorDigestTask)
{
((MailboxResourceMonitor)((object)tpresentationObject)).ServerName = this.server.Name;
((MailboxResourceMonitor)((object)tpresentationObject)).DatabaseName = database.Name;
((MailboxResourceMonitor)((object)tpresentationObject)).IsDatabaseCopyActive = (database.Server.ObjectGuid == this.server.Guid);
}
else if (this.isRunningMailboxStatisticsTask)
{
Microsoft.Exchange.Management.MapiTasks.Presentation.MailboxStatistics mailboxStatistics = (Microsoft.Exchange.Management.MapiTasks.Presentation.MailboxStatistics)((object)tpresentationObject);
mailboxStatistics.ServerName = this.server.Name;
mailboxStatistics.DatabaseName = database.Name;
mailboxStatistics.Database = database.Identity;
mailboxStatistics.IsDatabaseCopyActive = (database.Server.ObjectGuid == this.server.Guid);
MailboxDatabase mailboxDatabase = database as MailboxDatabase;
if (mailboxDatabase != null)
{
mailboxStatistics.DatabaseIssueWarningQuota = mailboxDatabase.IssueWarningQuota;
mailboxStatistics.DatabaseProhibitSendQuota = mailboxDatabase.ProhibitSendQuota;
mailboxStatistics.DatabaseProhibitSendReceiveQuota = mailboxDatabase.ProhibitSendReceiveQuota;
}
if (mailboxId != null && this.GetMoveHistoryOption() != MoveHistoryOption.None)
{
UserMailboxFlags userMailboxFlags = UserMailboxFlags.None;
if (database.Recovery)
{
userMailboxFlags |= UserMailboxFlags.RecoveryMDB;
}
if (mailboxStatistics.IsMoveDestination ?? false)
{
userMailboxFlags |= UserMailboxFlags.MoveDestination;
}
else if (mailboxStatistics.DisconnectReason != null)
{
if (mailboxStatistics.DisconnectReason.Value == MailboxState.SoftDeleted)
{
userMailboxFlags |= UserMailboxFlags.SoftDeleted;
}
else
{
userMailboxFlags |= UserMailboxFlags.Disconnected;
}
}
try
{
mailboxStatistics.MoveHistory = MoveHistoryEntry.LoadMoveHistory(mailboxId.MailboxGuid, database.Id.ObjectGuid, this.GetMoveHistoryOption() == MoveHistoryOption.IncludeMoveHistoryAndReport, userMailboxFlags);
}
catch (LocalizedException exception)
{
base.WriteError(exception, ErrorCategory.ResourceUnavailable, mailboxId);
}
}
}
bool flag = true;
if (this.isRunningMailboxStatisticsTask)
{
Exception ex = null;
try
{
QueryFilter internalFilter = this.InternalFilter;
if (internalFilter != null && !OpathFilterEvaluator.FilterMatches(internalFilter, (Microsoft.Exchange.Data.Mapi.MailboxStatistics)((object)tpresentationObject)))
{
flag = false;
}
}
catch (InvalidCastException ex2)
{
ex = ex2;
}
catch (ParsingException ex3)
{
ex = ex3;
}
catch (ArgumentOutOfRangeException ex4)
{
ex = ex4;
}
if (ex != null)
{
base.WriteError(new MdbAdminTaskException(Strings.ErrorInvalidMailboxStatisticsFilter(this.InternalFilter.ToString())), ErrorCategory.InvalidArgument, this.InternalFilter);
}
}
if (flag)
{
this.WriteResult(tpresentationObject);
}
if (this.Identity != null && this.isRunningMailboxStatisticsTask)
{
TaskLogger.LogExit();
return;
}
}
}
finally
{
if (tpresentationObject != null)
{
tpresentationObject.Dispose();
}
}
}
}
catch (DatabaseUnavailableException ex5)
{
if (this.Identity == null && this.Database == null)
{
base.WriteWarning(ex5.Message);
}
else
{
base.WriteError(ex5, ErrorCategory.ResourceUnavailable, database);
}
}
catch (MapiObjectNotFoundException exception2)
{
if (this.Identity == null || !this.isRunningMailboxStatisticsTask)
{
base.WriteError(exception2, ErrorCategory.ObjectNotFound, this.Identity);
}
}
}
if (this.Identity != null && this.isRunningMailboxStatisticsTask)
{
TIdentity tidentity = this.Identity;
this.WriteWarning(Strings.WarningMailboxNeverBeenLoggedOn(tidentity.ToString(), this.identity.ToString()));
}
TaskLogger.LogExit();
}
protected override void InternalValidate()
{
TaskLogger.LogEnter();
try
{
base.ValidateRootFolders(this.SourceRootFolder, this.TargetRootFolder);
bool wildcardedSearch = false;
if (!string.IsNullOrEmpty(base.Name))
{
base.ValidateName();
base.RequestName = base.Name;
}
else
{
wildcardedSearch = true;
base.RequestName = "MailboxRestore";
}
this.targetUser = RequestTaskHelper.ResolveADUser(base.RecipSession, base.GCSession, base.ServerSettings, this.TargetMailbox, base.OptionalIdentityData, base.DomainController, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ADUser>), new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError), true);
this.CheckForInvalidPublicFolderRestoreParameters();
if (this.targetUser.HasLocalArchive && this.targetUser.RecipientType == RecipientType.MailUser && this.targetUser.Database == null && !this.TargetIsArchive)
{
base.WriteError(new MissingArchiveParameterForRestorePermanentException(this.targetUser.ToString()), ErrorCategory.InvalidArgument, this.TargetMailbox);
}
if (this.targetUser.RecipientType != RecipientType.UserMailbox && (!this.TargetIsArchive || this.targetUser.RecipientType != RecipientType.MailUser))
{
base.WriteError(new InvalidRecipientTypePermanentException(this.targetUser.ToString(), this.targetUser.RecipientType.ToString()), ErrorCategory.InvalidArgument, this.TargetMailbox);
}
if (this.TargetIsArchive && (this.targetUser.ArchiveGuid == Guid.Empty || this.targetUser.ArchiveDatabase == null))
{
base.WriteError(new MailboxLacksArchivePermanentException(this.targetUser.ToString()), ErrorCategory.InvalidArgument, this.TargetIsArchive);
}
if (!this.TargetIsArchive && this.targetUser.Database == null)
{
base.WriteError(new MailboxLacksDatabasePermanentException(this.targetUser.ToString()), ErrorCategory.InvalidArgument, this.TargetMailbox);
}
if (base.ParameterSetName.Equals("RemoteMailboxRestore"))
{
if (!Guid.TryParse(this.SourceStoreMailbox.RawIdentity, out this.sourceMailboxGuid))
{
base.WriteError(new RecipientTaskException(Strings.ErrorParameterValueNotAllowed("SourceStoreMailbox")), ErrorCategory.InvalidArgument, this.SourceStoreMailbox);
}
if (!base.Fields.IsModified("AllowLegacyDNMismatch") || !this.AllowLegacyDNMismatch)
{
base.WriteError(new RecipientTaskException(Strings.ErrorParameterValueNotAllowed("AllowLegacyDNMismatch")), ErrorCategory.InvalidArgument, this.AllowLegacyDNMismatch);
}
base.Flags = (RequestFlags.CrossOrg | RequestFlags.Pull);
switch (this.RemoteRestoreType)
{
case RemoteRestoreType.RecoveryDatabase:
this.restoreFlags |= MailboxRestoreType.Recovery;
this.restoreFlags |= MailboxRestoreType.SoftDeleted;
break;
case RemoteRestoreType.DisconnectedMailbox:
this.restoreFlags |= MailboxRestoreType.SoftDeleted;
break;
case RemoteRestoreType.SoftDeletedRecipient:
this.restoreFlags |= MailboxRestoreType.SoftDeletedRecipient;
break;
default:
base.WriteError(new RecipientTaskException(Strings.ErrorParameterValueNotAllowed("RemoteRestoreType")), ErrorCategory.InvalidArgument, this.RemoteRestoreType);
break;
}
}
else
{
base.Flags = (RequestFlags.IntraOrg | RequestFlags.Pull);
string fqdn;
string serverExchangeLegacyDn;
ADObjectId adobjectId;
int num;
MailboxDatabase mailboxDatabase = base.CheckDatabase <MailboxDatabase>(this.SourceDatabase, NewRequest <MailboxRestoreRequest> .DatabaseSide.Source, this.SourceDatabase, out fqdn, out serverExchangeLegacyDn, out adobjectId, out num);
if (mailboxDatabase.Recovery)
{
this.restoreFlags |= MailboxRestoreType.Recovery;
}
this.sourceDatabase = mailboxDatabase.Id;
this.SourceStoreMailbox.Flags |= 1UL;
using (MapiSession mapiSession = new MapiAdministrationSession(serverExchangeLegacyDn, Fqdn.Parse(fqdn)))
{
using (MailboxStatistics mailboxStatistics = (MailboxStatistics)base.GetDataObject <MailboxStatistics>(this.SourceStoreMailbox, mapiSession, MapiTaskHelper.ConvertDatabaseADObjectToDatabaseId(mailboxDatabase), new LocalizedString?(Strings.ErrorStoreMailboxNotFound(this.SourceStoreMailbox.ToString(), this.SourceDatabase.ToString())), new LocalizedString?(Strings.ErrorStoreMailboxNotUnique(this.SourceStoreMailbox.ToString(), this.SourceDatabase.ToString()))))
{
MailboxState?disconnectReason = mailboxStatistics.DisconnectReason;
if (mailboxStatistics.MailboxType == StoreMailboxType.PublicFolderPrimary || mailboxStatistics.MailboxType == StoreMailboxType.PublicFolderSecondary)
{
this.restoreFlags |= MailboxRestoreType.PublicFolderMailbox;
}
bool flag = false;
if (disconnectReason == null && !mailboxDatabase.Recovery)
{
mapiSession.Administration.SyncMailboxWithDS(mailboxDatabase.Guid, mailboxStatistics.MailboxGuid);
using (MailboxStatistics mailboxStatistics2 = (MailboxStatistics)base.GetDataObject <MailboxStatistics>(this.SourceStoreMailbox, mapiSession, MapiTaskHelper.ConvertDatabaseADObjectToDatabaseId(mailboxDatabase), new LocalizedString?(Strings.ErrorStoreMailboxNotFound(this.SourceStoreMailbox.ToString(), this.SourceDatabase.ToString())), new LocalizedString?(Strings.ErrorStoreMailboxNotUnique(this.SourceStoreMailbox.ToString(), this.SourceDatabase.ToString()))))
{
disconnectReason = mailboxStatistics2.DisconnectReason;
if (disconnectReason == null)
{
if (this.targetUser.OrganizationId != null && this.targetUser.OrganizationId.OrganizationalUnit != null && VariantConfiguration.GetSnapshot(MachineSettingsContext.Local, null, null).Global.MultiTenancy.Enabled)
{
IRecipientSession recipientSession = CommonUtils.CreateRecipientSession(mailboxStatistics.ExternalDirectoryOrganizationId, null, null);
ADRecipient adrecipient = this.TargetIsArchive ? recipientSession.FindByExchangeGuidIncludingArchive(mailboxStatistics.MailboxGuid) : recipientSession.FindByExchangeGuid(mailboxStatistics.MailboxGuid);
flag = (adrecipient != null && adrecipient.RecipientSoftDeletedStatus != 0);
}
if (!this.IsPublicFolderMailboxRestore && !flag)
{
base.WriteError(new CannotRestoreConnectedMailboxPermanentException(this.SourceStoreMailbox.ToString()), ErrorCategory.InvalidArgument, this.SourceStoreMailbox);
}
}
}
}
if (flag)
{
this.restoreFlags |= MailboxRestoreType.SoftDeletedRecipient;
}
else if (disconnectReason != null)
{
if (disconnectReason != MailboxState.SoftDeleted)
{
this.restoreFlags |= MailboxRestoreType.Disabled;
}
else
{
this.restoreFlags |= MailboxRestoreType.SoftDeleted;
}
}
this.sourceMailboxGuid = mailboxStatistics.MailboxGuid;
this.sourceMailboxDN = mailboxStatistics.LegacyDN;
}
}
if ((this.TargetIsArchive && this.sourceMailboxGuid == this.targetUser.ArchiveGuid && this.sourceDatabase.Equals(this.targetUser.ArchiveDatabase)) || (!this.TargetIsArchive && this.sourceMailboxGuid == this.targetUser.ExchangeGuid && this.sourceDatabase.Equals(this.targetUser.Database)))
{
base.WriteError(new CannotRestoreIntoSelfPermanentException(this.targetUser.ToString()), ErrorCategory.InvalidArgument, this.TargetMailbox);
}
}
if (this.restoreFlags.HasFlag(MailboxRestoreType.PublicFolderMailbox))
{
if (this.targetUser.RecipientTypeDetails != RecipientTypeDetails.PublicFolderMailbox)
{
base.WriteError(new RecipientTaskException(Strings.ErrorCannotRestoreFromPublicToPrivateMailbox), ErrorCategory.InvalidArgument, this.SourceStoreMailbox);
}
}
else if (this.targetUser.RecipientTypeDetails == RecipientTypeDetails.PublicFolderMailbox)
{
base.WriteError(new RecipientTaskException(Strings.ErrorCannotRestoreFromPrivateToPublicMailbox), ErrorCategory.InvalidArgument, this.SourceStoreMailbox);
}
base.RescopeToOrgId(this.targetUser.OrganizationId);
if (base.ParameterSetName.Equals("RemoteMailboxRestore"))
{
base.PerRecordReportEntries.Add(new ReportEntry(MrsStrings.ReportRequestAllowedMismatch(base.ExecutingUserIdentity)));
}
else
{
base.ValidateLegacyDNMatch(this.sourceMailboxDN, this.targetUser, this.TargetMailbox);
}
ADObjectId mdbId = null;
ADObjectId mdbServerSite = null;
this.LocateAndChooseMdb(null, this.TargetIsArchive ? this.targetUser.ArchiveDatabase : this.targetUser.Database, null, this.TargetMailbox, this.TargetMailbox, out mdbId, out mdbServerSite);
base.MdbId = mdbId;
base.MdbServerSite = mdbServerSite;
base.RequestName = this.CheckRequestNameAvailability(base.RequestName, this.targetUser.Id, true, MRSRequestType.MailboxRestore, this.TargetMailbox, wildcardedSearch);
base.InternalValidate();
}
finally
{
TaskLogger.LogExit();
}
}
