private void LoadMailboxOwner(byte[] tenantPartitionHintBlob, string nonLocalizedAssistantName)
{
if (this.mailboxOwner == null)
{
this.InvokeAndMapException(delegate
{
ExTraceGlobals.EventDispatcherTracer.TraceDebug <MailboxDispatcher>((long)this.GetHashCode(), "{0}: Looking up ExchangePrincipal...", this);
ADSessionSettings adSettings;
if (tenantPartitionHintBlob != null && tenantPartitionHintBlob.Length != 0)
{
adSettings = ADSessionSettings.FromTenantPartitionHint(TenantPartitionHint.FromPersistablePartitionHint(tenantPartitionHintBlob));
}
else
{
adSettings = ADSessionSettings.FromRootOrgScopeSet();
}
this.mailboxOwner = ExchangePrincipal.FromLocalServerMailboxGuid(adSettings, this.DatabaseInfo.Guid, this.MailboxGuid);
}, nonLocalizedAssistantName);
}
}
// Token: 0x06000E5E RID: 3678 RVA: 0x000566C5 File Offset: 0x000548C5
internal static SharingPolicyCache Get(ADObjectId policyId, TenantPartitionHint tenantPartitionHint)
{
ArgumentValidator.ThrowIfNull("policyId", policyId);
ArgumentValidator.ThrowIfNull("tenantPartitionHint", tenantPartitionHint);
return(SharingPolicyCache.InternalGet(ADSessionSettings.FromTenantPartitionHint(tenantPartitionHint).CurrentOrganizationId, policyId));
}
// Token: 0x06001248 RID: 4680 RVA: 0x000689D4 File Offset: 0x00066BD4
private AssistantTaskContext InitializeContextInternal(MailboxData mailbox, TimeBasedDatabaseJob job)
{
OABLogger.LogRecord(TraceType.FunctionTrace, "OABGeneratorAssistant.InitializeContextInternal: start", new object[0]);
AssistantTaskContext result;
try
{
if (mailbox is OABGeneratorMailboxData)
{
result = OABGeneratorTaskContext.FromAssistantTaskContext(new AssistantTaskContext(mailbox, job, null));
}
else if (mailbox is StoreMailboxData)
{
StoreMailboxData storeMailboxData = (StoreMailboxData)mailbox;
ADSessionSettings sessionSettings = OABVariantConfigurationSettings.IsMultitenancyEnabled ? ADSessionSettings.FromTenantPartitionHint(storeMailboxData.TenantPartitionHint) : ADSessionSettings.FromRootOrgScopeSet();
ADUser organizationalMailboxFromAD = this.GetOrganizationalMailboxFromAD(sessionSettings, storeMailboxData.Guid);
if (organizationalMailboxFromAD == null)
{
OABLogger.LogRecord(TraceType.ErrorTrace, "OABGeneratorAssistant.InitializeContext: ignoring scheduled job due to unknown organization mailbox: {0}", new object[]
{
storeMailboxData.Guid
});
result = null;
}
else if (organizationalMailboxFromAD.RecipientTypeDetails != RecipientTypeDetails.ArbitrationMailbox || !organizationalMailboxFromAD.PersistedCapabilities.Contains(Capability.OrganizationCapabilityOABGen))
{
OABLogger.LogRecord(TraceType.ErrorTrace, "OABGeneratorAssistant.InitializeContext: The mailbox {0} is not an organizational mailbox with OABGen capability", new object[]
{
storeMailboxData.Guid
});
result = null;
}
else
{
OABGeneratorMailboxData mailboxData = new OABGeneratorMailboxData(organizationalMailboxFromAD.OrganizationId, base.DatabaseInfo.Guid, organizationalMailboxFromAD.ExchangeGuid, organizationalMailboxFromAD.DisplayName, organizationalMailboxFromAD.Sid, organizationalMailboxFromAD.PrimarySmtpAddress.Domain, Guid.Empty, storeMailboxData.TenantPartitionHint, string.Empty);
OABGeneratorTaskContext oabgeneratorTaskContext = OABGeneratorTaskContext.FromAssistantTaskContext(new AssistantTaskContext(mailboxData, job, null));
oabgeneratorTaskContext.OrganizationMailbox = organizationalMailboxFromAD;
result = oabgeneratorTaskContext;
}
}
else
{
OABLogger.LogRecord(TraceType.ErrorTrace, "OABGeneratorAssistant.InitializeContext: MailboxData is neither StoreMailboxData nor OABGeneratorMailboxData", new object[0]);
result = null;
}
}
catch (CannotResolveExternalDirectoryOrganizationIdException ex)
{
OABLogger.LogRecord(TraceType.ErrorTrace, "OABGeneratorAssistant.InitializeContext: {0}", new object[]
{
ex.ToString()
});
result = null;
}
finally
{
OABLogger.LogRecord(TraceType.FunctionTrace, "OABGeneratorAssistant.InitializeContextInternal: finish", new object[0]);
}
return(result);
}
// Token: 0x06001253 RID: 4691 RVA: 0x00069994 File Offset: 0x00067B94
private OfflineAddressBook[] GetCandidateOABsFromAD(OABGeneratorTaskContext context)
{
if (!OABVariantConfigurationSettings.IsLinkedOABGenMailboxesEnabled)
{
QueryFilter filter = OABGeneratorAssistant.versionFilter;
return(context.PerOrgAdSystemConfigSession.Find <OfflineAddressBook>(null, QueryScope.SubTree, filter, null, 0));
}
if (context.OrganizationMailbox == null)
{
ADSessionSettings sessionSettings = OABVariantConfigurationSettings.IsMultitenancyEnabled ? ADSessionSettings.FromTenantPartitionHint(((OABGeneratorMailboxData)context.MailboxData).TenantPartitionHint) : ADSessionSettings.FromRootOrgScopeSet();
context.OrganizationMailbox = this.GetOrganizationalMailboxFromAD(sessionSettings, ((OABGeneratorMailboxData)context.MailboxData).Guid);
}
if (context.OrganizationMailbox.GeneratedOfflineAddressBooks != null && context.OrganizationMailbox.GeneratedOfflineAddressBooks.Count > 0)
{
OABLogger.LogRecord(TraceType.InfoTrace, "OABGeneratorAssistant.GetCandidateOABsFromAD: Found {0} generated offline address books in org mailbox {1}", new object[]
{
context.OrganizationMailbox.GeneratedOfflineAddressBooks.Count.ToString(),
context.OrganizationMailbox.Id
});
List <OfflineAddressBook> list = new List <OfflineAddressBook>(context.OrganizationMailbox.GeneratedOfflineAddressBooks.Count);
foreach (ADObjectId entryId in context.OrganizationMailbox.GeneratedOfflineAddressBooks)
{
OfflineAddressBook offlineAddressBook = context.PerOrgAdSystemConfigSession.Read <OfflineAddressBook>(entryId);
if (offlineAddressBook != null)
{
list.Add(offlineAddressBook);
}
}
return(list.ToArray());
}
OABLogger.LogRecord(TraceType.InfoTrace, "OABGeneratorAssistant.GetCandidateOABsFromAD: No offline address books found in org mailbox {0}", new object[]
{
context.OrganizationMailbox.Id
});
return(null);
}
private StoreSession OpenMailboxSession(StoreMailboxData mailbox)
{
Guid activityId = (ActivityContext.ActivityId != null) ? ActivityContext.ActivityId.Value : Guid.Empty;
AssistantBase assistant = this.Assistant as AssistantBase;
string nonLocalizedName = this.Assistant.NonLocalizedName;
Guid mailboxGuid = mailbox.MailboxGuid;
StoreSession result;
try
{
ExchangePrincipal exchangePrincipal;
if (mailbox.TenantPartitionHint != null)
{
ADSessionSettings adSettings = ADSessionSettings.FromTenantPartitionHint(mailbox.TenantPartitionHint);
exchangePrincipal = ExchangePrincipal.FromLocalServerMailboxGuid(adSettings, this.DatabaseInfo.Guid, mailbox.Guid);
}
else
{
exchangePrincipal = ExchangePrincipal.FromMailboxData(mailbox.Guid, this.DatabaseInfo.Guid, mailbox.OrganizationId ?? OrganizationId.ForestWideOrgId, Array <CultureInfo> .Empty);
}
if (mailbox.IsPublicFolderMailbox)
{
StoreSession storeSession = PublicFolderSession.OpenAsAdmin(null, exchangePrincipal, null, CultureInfo.InstalledUICulture, string.Format("{0};Action={1}", "Client=TBA", this.Assistant.GetType().Name), null);
AssistantsLog.LogMailboxSucceedToOpenStoreSessionEvent(activityId, nonLocalizedName, assistant, mailboxGuid, mailbox.DisplayName, this);
result = storeSession;
}
else
{
bool flag = false;
MailboxSession mailbox2 = this.DatabaseInfo.GetMailbox(exchangePrincipal, ClientType.TimeBased, this.Assistant.GetType().Name);
try
{
mailbox2.ReconstructExchangePrincipal();
mailbox2.ExTimeZone = ExTimeZone.CurrentTimeZone;
flag = true;
AssistantsLog.LogMailboxSucceedToOpenStoreSessionEvent(activityId, nonLocalizedName, assistant, mailboxGuid, mailbox.DisplayName, this);
result = mailbox2;
}
finally
{
if (!flag)
{
mailbox2.Dispose();
}
}
}
}
catch (ObjectNotFoundException ex)
{
string text = "MailboxNotFound";
string message = string.Format("{0}: {1}", this, text);
string value = string.Format("{0}:{1}", text, mailbox.MailboxGuid);
ExTraceGlobals.TimeBasedDatabaseJobTracer.TraceError((long)this.GetHashCode(), message);
AssistantsLog.LogMailboxFailedToOpenStoreSessionEvent(activityId, nonLocalizedName, assistant, ex, mailboxGuid, mailbox.DisplayName, this);
throw new SkipException(new LocalizedString(value), ex);
}
catch (StorageTransientException ex2)
{
string message2 = string.Format("{0}: Could not open mailbox store session due to storage transient error: {1}", this, ex2.Message);
ExTraceGlobals.TimeBasedDatabaseJobTracer.TraceError((long)this.GetHashCode(), message2);
AssistantsLog.LogMailboxFailedToOpenStoreSessionEvent(activityId, nonLocalizedName, assistant, ex2, mailboxGuid, mailbox.DisplayName, this);
Interlocked.Increment(ref this.mailboxesFailedToOpenStoreSessionCount);
throw;
}
catch (Exception ex3)
{
string message3 = string.Format("{0}: Could not open mailbox store session due to error: {1}", this, ex3.Message);
ExTraceGlobals.TimeBasedDatabaseJobTracer.TraceError((long)this.GetHashCode(), message3);
AssistantsLog.LogMailboxFailedToOpenStoreSessionEvent(activityId, nonLocalizedName, assistant, ex3, mailboxGuid, mailbox.DisplayName, this);
Interlocked.Increment(ref this.mailboxesFailedToOpenStoreSessionCount);
throw;
}
return(result);
}
public TObject FindByExchangeGuidIncludingAlternate <TObject>(Guid mailboxGuid, TenantPartitionHint tenantPartitionHint) where TObject : ADObject, new()
{
IRecipientSession tenantOrRootOrgRecipientSession;
if (tenantPartitionHint == null)
{
tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 68, "FindByExchangeGuidIncludingAlternate", "f:\\15.00.1497\\sources\\dev\\MailboxTransport\\src\\MailboxTransportSubmission\\StoreDriverSubmission\\Providers\\ADStoreProvider.cs");
}
else
{
tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromTenantPartitionHint(tenantPartitionHint), 74, "FindByExchangeGuidIncludingAlternate", "f:\\15.00.1497\\sources\\dev\\MailboxTransport\\src\\MailboxTransportSubmission\\StoreDriverSubmission\\Providers\\ADStoreProvider.cs");
}
return(tenantOrRootOrgRecipientSession.FindByExchangeGuidIncludingAlternate <TObject>(mailboxGuid));
}
protected virtual StoreSession CreateStoreConnection(MailboxConnectFlags mailboxConnectFlags)
{
MrsTracer.Provider.Function("StorageMailbox.CreateStoreConnection", new object[0]);
base.CheckDisposed();
if (!base.IsRestore)
{
Guid guid = base.IsArchiveMailbox ? base.MbxArchiveMdbGuid : base.MbxHomeMdbGuid;
if (mailboxConnectFlags.HasFlag(MailboxConnectFlags.NonMrsLogon) && base.TestIntegration.GetIntValueAndDecrement("InjectNFaultsTargetConnectivityVerification", 0, 0, 2147483647) > 0)
{
guid = new Guid("F00DBABE-0000-0000-0000-000000000000");
}
if (base.MdbGuid != guid)
{
MrsTracer.Provider.Warning("Source mailbox does not exist or is in the wrong database.", new object[0]);
throw new MailboxIsNotInExpectedMDBPermanentException(guid);
}
}
MrsTracer.Provider.Debug("Opening StoreSession: mailbox=\"{0}\"", new object[]
{
base.TraceMailboxId
});
StoreSession result;
try
{
using (base.RHTracker.Start())
{
ADSessionSettings adsessionSettings = (base.PartitionHint != null) ? ADSessionSettings.FromTenantPartitionHint(base.PartitionHint) : ADSessionSettings.FromRootOrgScopeSet();
adsessionSettings.IncludeSoftDeletedObjects = true;
adsessionSettings.IncludeInactiveMailbox = true;
ExchangePrincipal exchangePrincipal;
if (base.IsRestore)
{
exchangePrincipal = ExchangePrincipal.FromMailboxData(base.MailboxGuid, base.MdbGuid, StorageMailbox.CultureInfos);
}
else
{
exchangePrincipal = ExchangePrincipal.FromMailboxGuid(adsessionSettings, base.MailboxGuid, base.MdbGuid, RemotingOptions.LocalConnectionsOnly, base.EffectiveDomainControllerName, false);
}
string text = ((mailboxConnectFlags & MailboxConnectFlags.NonMrsLogon) != MailboxConnectFlags.None) ? "Client=Management" : "Client=MSExchangeMigration";
if ((mailboxConnectFlags & MailboxConnectFlags.PublicFolderHierarchyReplication) != MailboxConnectFlags.None)
{
text = "Client=PublicFolderSystem;Action=PublicFolderHierarchyReplication";
}
if (base.IsPublicFolderMailbox)
{
OpenMailboxSessionFlags openMailboxSessionFlags = OpenMailboxSessionFlags.None;
if (base.RestoreFlags.HasFlag(MailboxRestoreType.Recovery))
{
openMailboxSessionFlags |= OpenMailboxSessionFlags.UseRecoveryDatabase;
}
result = PublicFolderSession.OpenAsMRS(exchangePrincipal, text, openMailboxSessionFlags);
}
else
{
MailboxSession.InitializationFlags initializationFlags = MailboxSession.InitializationFlags.None;
if (base.IsRestore)
{
initializationFlags |= MailboxSession.InitializationFlags.OverrideHomeMdb;
if (base.RestoreFlags.HasFlag(MailboxRestoreType.Recovery))
{
initializationFlags |= MailboxSession.InitializationFlags.UseRecoveryDatabase;
}
if (base.RestoreFlags.HasFlag(MailboxRestoreType.SoftDeleted) || base.RestoreFlags.HasFlag(MailboxRestoreType.Disabled))
{
initializationFlags |= MailboxSession.InitializationFlags.DisconnectedMailbox;
}
base.VerifyRestoreSource(mailboxConnectFlags);
}
if (base.IsFolderMove && this is StorageDestinationMailbox)
{
initializationFlags |= MailboxSession.InitializationFlags.MoveUser;
}
if (base.IsOlcSync)
{
initializationFlags |= MailboxSession.InitializationFlags.OlcSync;
}
this.PerformPreLogonOperations(exchangePrincipal, mailboxConnectFlags, text);
result = MailboxSession.OpenAsMrs(exchangePrincipal, initializationFlags, text);
}
}
}
catch (ObjectNotFoundException originalException)
{
base.VerifyMdbIsOnline(originalException);
throw;
}
catch (MailboxInTransitException innerException)
{
throw this.GetMailboxInTransitException(innerException);
}
return(result);
}
private StoreSession ConnectToTargetMailbox(bool mailboxMustExist, MailboxConnectFlags mailboxConnectFlags)
{
MrsTracer.Provider.Function("StorageDestinationMailbox.ConnectToTargetMailbox", new object[0]);
base.CheckDisposed();
StoreSession result = null;
ConnectFlag connectFlag = ConnectFlag.UseAdminPrivilege;
connectFlag |= ConnectFlag.UseRpcContextPool;
if (!mailboxMustExist)
{
bool flag = false;
MrsTracer.Provider.Debug("Checking if destination mailbox exists...", new object[0]);
using (ExRpcAdmin rpcAdmin = base.GetRpcAdmin())
{
using (base.RHTracker.Start())
{
flag = MapiUtils.IsMailboxInDatabase(rpcAdmin, base.MdbGuid, base.MailboxGuid);
}
}
if (!flag)
{
MrsTracer.Provider.Debug("Mailbox {0} does not exist in database {1}", new object[]
{
base.MailboxGuid,
base.MdbGuid
});
return(null);
}
MrsTracer.Provider.Debug("Mailbox {0} exists in database {1}", new object[]
{
base.MailboxGuid,
base.MdbGuid
});
}
StoreSession storeSession = null;
try
{
using (base.RHTracker.Start())
{
DefaultFolderType[] foldersToInit = (DefaultFolderType[])Enum.GetValues(typeof(DefaultFolderType));
MailboxSession.InitializationFlags initializationFlags = MailboxSession.InitializationFlags.DefaultFolders | MailboxSession.InitializationFlags.UserConfigurationManager | MailboxSession.InitializationFlags.DeadSessionChecking | MailboxSession.InitializationFlags.RequestLocalRpc | MailboxSession.InitializationFlags.OverrideHomeMdb | MailboxSession.InitializationFlags.SuppressFolderIdPrefetch | MailboxSession.InitializationFlags.UseNamedProperties | MailboxSession.InitializationFlags.DisconnectedMailbox | MailboxSession.InitializationFlags.MoveUser;
if (base.MbxType == MailboxType.DestMailboxCrossOrg)
{
initializationFlags |= MailboxSession.InitializationFlags.XForestMove;
}
MrsTracer.Provider.Debug("Opening Mailbox Session: mailbox='{0}', mailboxGuid={1}, dbGuid={2}, connectFlags=[{3}], initFlags=[{4}]", new object[]
{
base.TraceMailboxId,
base.MailboxGuid.ToString(),
base.MdbGuid.ToString(),
connectFlag,
initializationFlags
});
OrganizationId organizationId;
if (base.PartitionHint != null)
{
ADSessionSettings adsessionSettings = ADSessionSettings.FromTenantPartitionHint(base.PartitionHint);
organizationId = adsessionSettings.CurrentOrganizationId;
}
else
{
organizationId = OrganizationId.ForestWideOrgId;
}
ExchangePrincipal exchangePrincipal = ExchangePrincipal.FromMailboxData(base.MailboxGuid, base.MdbGuid, organizationId, StorageMailbox.CultureInfos);
string clientInfoString = "Client=MSExchangeMigration";
if ((mailboxConnectFlags & MailboxConnectFlags.PublicFolderHierarchyReplication) != MailboxConnectFlags.None)
{
clientInfoString = "Client=PublicFolderSystem;Action=PublicFolderHierarchyReplication";
}
if (base.IsPublicFolderMailbox)
{
storeSession = PublicFolderSession.OpenAsMRS(exchangePrincipal, clientInfoString, OpenMailboxSessionFlags.None);
}
else
{
MailboxAccessInfo accessInfo = new MailboxAccessInfo(new WindowsPrincipal(WindowsIdentity.GetCurrent()));
storeSession = MailboxSession.ConfigurableOpen(exchangePrincipal, accessInfo, CultureInfo.InvariantCulture, clientInfoString, LogonType.SystemService, null, initializationFlags, foldersToInit);
}
if (!base.TestIntegration.DisableFolderCreationBlockFeature)
{
storeSession.BlockFolderCreation = true;
}
if (storeSession != null && base.Flags.HasFlag(LocalMailboxFlags.WordBreak))
{
bool invalidateAnnotations = base.Flags.HasFlag(LocalMailboxFlags.InvalidateContentIndexAnnotations);
storeSession.ContentIndexingSession = ContentIndexingSession.CreateSession(storeSession, invalidateAnnotations);
}
result = storeSession;
storeSession = null;
}
}
catch (Exception ex)
{
if (CommonUtils.ExceptionIs(ex, new WellKnownException[]
{
WellKnownException.MapiNotFound
}))
{
base.VerifyMdbIsOnline(ex);
if (mailboxMustExist)
{
throw;
}
}
else
{
if (CommonUtils.ExceptionIs(ex, new WellKnownException[]
{
WellKnownException.MapiMailboxInTransit
}))
{
throw this.GetMailboxInTransitException(ex);
}
throw;
}
}
finally
{
if (storeSession != null)
{
storeSession.Dispose();
}
}
return(result);
}