public static ActiveManager CreateRemoteActiveManager(string domainControllerName, NetworkCredential networkCredential, bool createCachingActiveManager)
{
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(domainControllerName, true, ConsistencyMode.FullyConsistent, networkCredential, ADSessionSettings.FromRootOrgScopeSet(), 1071, "CreateRemoteActiveManager", "f:\\15.00.1497\\sources\\dev\\data\\src\\storage\\ActiveManager\\ActiveManager.cs");
IADToplogyConfigurationSession adSession = ADSessionFactory.CreateWrapper(topologyConfigurationSession);
IFindAdObject <IADDatabaseAvailabilityGroup> dagLookup;
IFindAdObject <IADServer> serverLookup;
IFindMiniServer miniServerLookup;
IFindAdObject <IADClientAccessArray> casLookup;
IFindMiniClientAccessServerOrArray miniCasArrayLookup;
IFindAdObject <IADDatabase> databaseLookup;
if (createCachingActiveManager)
{
TimeSpan timeSpan = new TimeSpan(0, 0, 75);
dagLookup = new AdObjectLookupCache <IADDatabaseAvailabilityGroup>(adSession, timeSpan, timeSpan, ActiveManager.s_cacheLockTimeout, AdObjectLookupCache <IADDatabaseAvailabilityGroup> .AdOperationTimeout);
serverLookup = new AdObjectLookupCache <IADServer>(adSession, AdObjectLookupCache <IADServer> .TimeToLive, AdObjectLookupCache <IADServer> .TimeToNegativeLive, ActiveManager.s_cacheLockTimeout, AdObjectLookupCache <IADServer> .AdOperationTimeout);
miniServerLookup = new MiniServerLookupCache(adSession, MiniServerLookupCache.TimeToLive, MiniServerLookupCache.TimeToNegativeLive, ActiveManager.s_cacheLockTimeout, MiniServerLookupCache.AdOperationTimeout);
casLookup = new AdObjectLookupCache <IADClientAccessArray>(adSession, AdObjectLookupCache <IADClientAccessArray> .TimeToLive, AdObjectLookupCache <IADClientAccessArray> .TimeToNegativeLive, ActiveManager.s_cacheLockTimeout, AdObjectLookupCache <IADClientAccessArray> .AdOperationTimeout);
miniCasArrayLookup = new MiniClientAccessServerOrArrayLookupCache(topologyConfigurationSession, MiniClientAccessServerOrArrayLookupCache.TimeToLive, MiniClientAccessServerOrArrayLookupCache.TimeToNegativeLive, ActiveManager.s_cacheLockTimeout, MiniClientAccessServerOrArrayLookupCache.AdOperationTimeout);
databaseLookup = new AdObjectLookupCache <IADDatabase>(adSession, AdObjectLookupCache <IADDatabase> .TimeToLive, AdObjectLookupCache <IADDatabase> .TimeToNegativeLive, ActiveManager.s_cacheLockTimeout, AdObjectLookupCache <IADDatabase> .AdOperationTimeout);
}
else
{
dagLookup = new SimpleAdObjectLookup <IADDatabaseAvailabilityGroup>(adSession);
serverLookup = new SimpleAdObjectLookup <IADServer>(adSession);
miniServerLookup = new SimpleMiniServerLookup(adSession);
casLookup = new SimpleAdObjectLookup <IADClientAccessArray>(adSession);
miniCasArrayLookup = new SimpleMiniClientAccessServerOrArrayLookup(topologyConfigurationSession);
databaseLookup = new SimpleAdObjectLookup <IADDatabase>(adSession);
}
ActiveManager activeManager = new ActiveManager(createCachingActiveManager, dagLookup, serverLookup, miniServerLookup, casLookup, miniCasArrayLookup, databaseLookup, topologyConfigurationSession, false);
activeManager.m_networkCredential = networkCredential;
ExTraceGlobals.ActiveManagerClientTracer.TraceDebug <string>(0L, "Created an ActiveManager suitable for cross-forest queries, dcName={0}.", domainControllerName);
return(activeManager);
}
internal List <string> GetClassificationNames(IList <string> classificationGuids)
{
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 2087, "GetClassificationNames", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\Common\\recipient\\InboxRule.cs");
ADRecipient adrecipient = tenantOrRootOrgRecipientSession.Read(base.MailboxOwnerId);
IConfigurationSession systemConfigurationSession = this.provider.GetSystemConfigurationSession(adrecipient.OrganizationId);
List <string> list = new List <string>();
foreach (string text in classificationGuids)
{
if (!string.IsNullOrEmpty(text))
{
Guid guid;
try
{
guid = new Guid(text);
}
catch (OverflowException)
{
continue;
}
catch (FormatException)
{
continue;
}
ADObjectId entryId = new ADObjectId(guid);
MessageClassification messageClassification = systemConfigurationSession.Read <MessageClassification>(entryId);
if (messageClassification != null)
{
list.Add(messageClassification.DisplayName);
}
}
}
return(list);
}
private static bool LoadADConfiguration()
{
ADOperationResult adoperationResult = ADNotificationAdapter.TryRunADOperation(delegate()
{
IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(ConsistencyMode.PartiallyConsistent, ADSessionSettings.FromRootOrgScopeSet(), 196, "LoadADConfiguration", "f:\\15.00.1497\\sources\\dev\\DoMT\\src\\Service\\Configuration.cs");
tenantOrTopologyConfigurationSession.ServerTimeout = Configuration.ADTimeout;
ConfigurationContainer configurationContainer = tenantOrTopologyConfigurationSession.Read <ConfigurationContainer>(tenantOrTopologyConfigurationSession.ConfigurationNamingContext);
if (configurationContainer != null)
{
Guid objectGuid = (Guid)configurationContainer[ADObjectSchema.Guid];
Configuration.ConfigNamingContext = new ADObjectId(tenantOrTopologyConfigurationSession.ConfigurationNamingContext.DistinguishedName, objectGuid);
}
Configuration.MicrosoftExchangeConfigurationRoot = Configuration.ConfigNamingContext.GetDescendantId("Services", "Microsoft Exchange", new string[0]);
});
if (!adoperationResult.Succeeded)
{
Configuration.ServiceEnabled = false;
}
return(Configuration.ServiceEnabled);
}
public IADRootOrganizationRecipientSession CreateIgnoreInvalidRootOrgRecipientSession()
{
IRootOrganizationRecipientSession session = DirectorySessionFactory.Default.CreateRootOrgRecipientSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 226, "CreateIgnoreInvalidRootOrgRecipientSession", "f:\\15.00.1497\\sources\\dev\\data\\src\\HA\\DirectoryServices\\ADSessionFactory.cs");
return(ADRootOrganizationRecipientSessionWrapper.CreateWrapper(session));
}
private static Server GetLocalServer()
{
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 634, "GetLocalServer", "f:\\15.00.1497\\sources\\dev\\admin\\src\\ecp\\Utilities\\EcpUrl.cs");
topologyConfigurationSession.UseConfigNC = true;
topologyConfigurationSession.UseGlobalCatalog = true;
Server server = topologyConfigurationSession.FindLocalServer();
if (server == null)
{
ExTraceGlobals.ProxyTracer.TraceInformation(0, 0L, "Could not find local server in directory.");
throw new CmdletAccessDeniedException(Strings.FailedToGetLocalServerInfo);
}
return(server);
}
// Token: 0x0600015D RID: 349 RVA: 0x00006C38 File Offset: 0x00004E38
private ADSystemMailbox FindSystemMailbox()
{
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 526, "FindSystemMailbox", "f:\\15.00.1497\\sources\\dev\\assistants\\src\\Assistants\\DatabaseInfo.cs");
ADRecipient[] array = tenantOrRootOrgRecipientSession.Find(null, QueryScope.SubTree, new ComparisonFilter(ComparisonOperator.Equal, ADObjectSchema.Name, this.systemMailboxName), null, 1);
if (array.Length != 1 || !(array[0] is ADSystemMailbox))
{
ExTraceGlobals.DatabaseInfoTracer.TraceError <DatabaseInfo, int, string>((long)this.GetHashCode(), "{0}: Found {1} mailboxes named '{2}' in the AD", this, array.Length, this.systemMailboxName);
throw new MissingSystemMailboxException(this.DisplayName, base.Logger);
}
return((ADSystemMailbox)array[0]);
}
private static void InitializeEndpointLists()
{
if (TestEcpConnectivity2.consumerLiveIdHostNames == null)
{
lock (TestEcpConnectivity2.lockObject)
{
if (TestEcpConnectivity2.consumerLiveIdHostNames == null)
{
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(ConsistencyMode.FullyConsistent, ADSessionSettings.FromRootOrgScopeSet(), 102, "InitializeEndpointLists", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\Monitoring\\Tasks\\TestEcpConnectivity2.cs");
ServiceEndpointContainer endpointContainer = topologyConfigurationSession.GetEndpointContainer();
TestEcpConnectivity2.exchangeHostNames = new List <string>();
TestEcpConnectivity2.exchangeHostNames.Add(endpointContainer.GetEndpoint(ServiceEndpointId.ExchangeLoginUrl).Uri.Host);
TestEcpConnectivity2.businessLiveIdHostNames = new List <string>();
TestEcpConnectivity2.businessLiveIdHostNames.Add(endpointContainer.GetEndpoint(ServiceEndpointId.MsoServiceLogin2).Uri.Host);
TestEcpConnectivity2.consumerLiveIdHostNames = new List <string>();
TestEcpConnectivity2.consumerLiveIdHostNames.Add(endpointContainer.GetEndpoint(ServiceEndpointId.LiveServiceLogin2).Uri.Host);
}
}
}
}
public static ScpSearch FindLocal()
{
IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 114, "FindLocal", "f:\\15.00.1497\\sources\\dev\\infoworker\\src\\common\\RequestDispatch\\ScpSearch.cs");
ScpSearch scpSearch = ScpSearch.Find(tenantOrTopologyConfigurationSession, ScpSearch.localQueryFilter);
if (scpSearch != null && scpSearch.Exception != null)
{
Globals.AvailabilityLogger.LogEvent(InfoWorkerEventLogConstants.Tuple_SCPErrorSearchingLocalADForSCP, null, new object[]
{
Globals.ProcessId,
scpSearch.Exception
});
}
return(scpSearch);
}
public SetMoveRequestBase()
{
this.LocalADUser = null;
this.WriteableSession = null;
this.MRProvider = null;
this.UnreachableMrsServers = new List <string>(5);
this.ConfigSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(null, true, ConsistencyMode.PartiallyConsistent, null, ADSessionSettings.FromRootOrgScopeSet(), 82, ".ctor", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\MailboxReplication\\MoveRequest\\SetMoveRequestBase.cs");
}
protected override IConfigDataProvider CreateSession()
{
ADObjectId rootOrgContainerId = ADSystemConfigurationSession.GetRootOrgContainerId(this.DomainController, null);
ADSessionSettings adsessionSettings = ADSessionSettings.FromCustomScopeSet(base.ScopeSet, rootOrgContainerId, base.CurrentOrganizationId, base.ExecutingUserOrganizationId, true);
this.currentOrgConfigSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(this.DomainController, true, ConsistencyMode.PartiallyConsistent, null, adsessionSettings, 313, "CreateSession", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\MailboxReplication\\RequestBase\\GetRequestStatistics.cs");
adsessionSettings = ADSessionSettings.RescopeToSubtree(adsessionSettings);
if (MapiTaskHelper.IsDatacenter || MapiTaskHelper.IsDatacenterDedicated)
{
adsessionSettings.IncludeSoftDeletedObjects = true;
adsessionSettings.IncludeInactiveMailbox = true;
}
this.gcSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(this.DomainController, true, ConsistencyMode.PartiallyConsistent, adsessionSettings, 330, "CreateSession", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\MailboxReplication\\RequestBase\\GetRequestStatistics.cs");
this.recipSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(this.DomainController, true, ConsistencyMode.PartiallyConsistent, adsessionSettings, 337, "CreateSession", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\MailboxReplication\\RequestBase\\GetRequestStatistics.cs");
this.configSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(null, true, ConsistencyMode.PartiallyConsistent, null, ADSessionSettings.FromRootOrgScopeSet(), 343, "CreateSession", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\MailboxReplication\\RequestBase\\GetRequestStatistics.cs");
if (this.rjProvider != null)
{
this.rjProvider.Dispose();
this.rjProvider = null;
}
if (base.ParameterSetName.Equals("MigrationRequestQueue"))
{
MailboxDatabase mailboxDatabase = (MailboxDatabase)base.GetDataObject <MailboxDatabase>(this.RequestQueue, this.configSession, null, new LocalizedString?(Strings.ErrorMailboxDatabaseNotFound(this.RequestQueue.ToString())), new LocalizedString?(Strings.ErrorMailboxDatabaseNotUnique(this.RequestQueue.ToString())));
this.rjProvider = new RequestJobProvider(mailboxDatabase.Guid);
}
else
{
this.rjProvider = new RequestJobProvider(this.gcSession, this.currentOrgConfigSession);
}
this.rjProvider.LoadReport = this.IncludeReport;
return(this.rjProvider);
}
// Token: 0x06001A9D RID: 6813 RVA: 0x00071EC8 File Offset: 0x000700C8
public SeederInstanceContainer(RpcSeederArgs rpcArgs, ConfigurationArgs configArgs)
{
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(ConsistencyMode.FullyConsistent, ADSessionSettings.FromRootOrgScopeSet(), 66, ".ctor", "f:\\15.00.1497\\sources\\dev\\cluster\\src\\Replay\\seeder\\seederinstancecontainer.cs");
Database database = null;
Exception ex = null;
try
{
database = topologyConfigurationSession.FindDatabaseByGuid <Database>(configArgs.IdentityGuid);
}
catch (ADTransientException ex2)
{
ex = ex2;
}
catch (ADExternalException ex3)
{
ex = ex3;
}
catch (ADOperationException ex4)
{
ex = ex4;
}
if (ex != null)
{
throw new SeedPrepareException(ReplayStrings.CouldNotFindDatabase(configArgs.IdentityGuid.ToString(), ex.ToString()), ex);
}
this.m_seederArgs = rpcArgs;
this.m_configArgs = configArgs;
this.m_seedDatabase = rpcArgs.SeedDatabase;
this.m_seedCiFiles = (rpcArgs.SeedCiFiles && !database.IsPublicFolderDatabase);
if (this.m_seedDatabase)
{
if (this.m_seedCiFiles)
{
this.m_databaseSeeder = new DatabaseSeederInstance(rpcArgs, configArgs, new SeedCompletionCallback(this.LaunchCiFileSeeder), null);
}
else
{
this.m_databaseSeeder = new DatabaseSeederInstance(rpcArgs, configArgs, null, null);
}
}
if (this.m_seedCiFiles)
{
this.m_ciFilesSeeder = new CiFilesSeederInstance(rpcArgs, configArgs);
}
}
protected override void InternalProcessRecord()
{
if (base.ParameterSetName != "Identity")
{
ECIdParameter ecidParameter = null;
TaskLogger.LogEnter(new object[]
{
this.Server
});
if (base.IsVerboseOn)
{
base.WriteVerbose(Strings.FindingServer(this.Server.ToString()));
}
IConfigurationSession session = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(this.DomainController, false, ConsistencyMode.PartiallyConsistent, ADSessionSettings.FromRootOrgScopeSet(), 89, "InternalProcessRecord", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\EventLog\\GetEventLogLevel.cs");
IEnumerable <Server> objects = this.Server.GetObjects <Server>(null, session);
IEnumerator <Server> enumerator = objects.GetEnumerator();
Server server = null;
if (enumerator.MoveNext())
{
server = enumerator.Current;
if (enumerator.MoveNext())
{
base.WriteError(new ManagementObjectNotFoundException(Strings.ErrorServerNotUnique(this.Server.ToString())), ErrorCategory.InvalidData, this.Server);
}
}
else
{
base.WriteError(new ManagementObjectNotFoundException(Strings.ErrorServerNotFound(this.Server.ToString())), ErrorCategory.InvalidData, this.Server);
}
base.WriteVerbose(Strings.FindingEventSources);
try
{
try
{
ecidParameter = ECIdParameter.Parse(server.AdminDisplayName + "\\*");
IEnumerable <EventCategoryObject> dataObjects = base.GetDataObjects(ecidParameter);
this.WriteResult <EventCategoryObject>(dataObjects);
}
catch (SecurityException exception)
{
base.WriteError(exception, ErrorCategory.InvalidData, ecidParameter);
}
catch (IOException exception2)
{
base.WriteError(exception2, ErrorCategory.InvalidData, ecidParameter);
}
catch (DataSourceOperationException exception3)
{
base.WriteError(exception3, ErrorCategory.InvalidData, this.Identity);
}
return;
}
finally
{
TaskLogger.LogExit();
}
}
try
{
base.InternalProcessRecord();
}
catch (SecurityException exception4)
{
base.WriteError(exception4, ErrorCategory.InvalidData, this.Identity);
}
catch (IOException exception5)
{
base.WriteError(exception5, ErrorCategory.InvalidData, this.Identity);
}
catch (DataSourceOperationException exception6)
{
base.WriteError(exception6, ErrorCategory.InvalidData, this.Identity);
}
}
protected void RenderDiagnosticInformation()
{
try
{
base.Response.Write("<div class=\"errLbl\">");
base.Response.Write(Strings.UserEmailAddress);
base.Response.Write("</div><div>");
base.Response.Write(HttpUtility.HtmlEncode(HttpContextExtensions.CurrentUserLiveID()));
base.Response.Write("</div>");
string s = ActivityContext.ActivityId.FormatForLog();
base.Response.Write("<div class=\"errLbl\">");
base.Response.Write(Strings.CorrelationId);
base.Response.Write("</div><div>");
base.Response.Write(HttpUtility.HtmlEncode(s));
base.Response.Write("</div>");
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 230, "RenderDiagnosticInformation", "f:\\15.00.1497\\sources\\dev\\admin\\src\\ecp\\error.aspx.cs");
Server server = topologyConfigurationSession.FindLocalServer();
base.Response.Write("<div class=\"errLbl\">");
base.Response.Write(Strings.ClientAccessServerName);
base.Response.Write("</div><div>");
base.Response.Write(HttpUtility.HtmlEncode(server.Fqdn));
base.Response.Write("</div>");
base.Response.Write("<div class=\"errLbl\">");
base.Response.Write(Strings.ClientAccessServerVersion);
base.Response.Write("</div><div>");
base.Response.Write(HttpUtility.HtmlEncode(Globals.ApplicationVersion));
base.Response.Write("</div>");
base.Response.Write("<div class=\"errLbl\">");
base.Response.Write(Strings.UTCTime);
base.Response.Write("</div><div>");
base.Response.Write(HttpUtility.HtmlEncode(DateTime.UtcNow.ToString("o")));
base.Response.Write("</div>");
}
catch (Exception exception)
{
ExTraceGlobals.EventLogTracer.TraceError <EcpTraceFormatter <Exception> >(0, 0L, "Application Error: {0}", exception.GetTraceFormatter());
EcpPerfCounters.AspNetErrors.Increment();
throw;
}
}
public static ActiveManager CreateCustomActiveManager(bool cacheRpcRequests, IFindAdObject <IADDatabaseAvailabilityGroup> dagLookup, IFindAdObject <IADServer> serverLookup, IFindMiniServer miniServerLookup, IFindAdObject <IADClientAccessArray> casLookup, IFindMiniClientAccessServerOrArray miniCasArrayLookup, IFindAdObject <IADDatabase> databaseLookup, ITopologyConfigurationSession adSession, bool isService)
{
if (adSession == null)
{
adSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(ConsistencyMode.PartiallyConsistent, ADSessionSettings.FromRootOrgScopeSet(), 1200, "CreateCustomActiveManager", "f:\\15.00.1497\\sources\\dev\\data\\src\\storage\\ActiveManager\\ActiveManager.cs");
}
IADToplogyConfigurationSession adSession2 = ADSessionFactory.CreateWrapper(adSession);
dagLookup = (dagLookup ?? new SimpleAdObjectLookup <IADDatabaseAvailabilityGroup>(adSession2));
serverLookup = (serverLookup ?? new SimpleAdObjectLookup <IADServer>(adSession2));
miniServerLookup = (miniServerLookup ?? new SimpleMiniServerLookup(adSession2));
casLookup = (casLookup ?? new SimpleAdObjectLookup <IADClientAccessArray>(adSession2));
miniCasArrayLookup = (miniCasArrayLookup ?? new SimpleMiniClientAccessServerOrArrayLookup(adSession));
databaseLookup = (databaseLookup ?? new SimpleAdObjectLookup <IADDatabase>(adSession2));
return(new ActiveManager(cacheRpcRequests, dagLookup, serverLookup, miniServerLookup, casLookup, miniCasArrayLookup, databaseLookup, adSession, isService));
}
protected override IConfigDataProvider CreateSession()
{
return(DirectorySessionFactory.Default.CreateTopologyConfigurationSession(false, ConsistencyMode.PartiallyConsistent, ADSessionSettings.FromRootOrgScopeSet(), 67, "CreateSession", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\transport\\EdgeSync\\GetEdgeSyncServiceConfig.cs"));
}
private static IRootOrganizationRecipientSession CreateAdSession()
{
return(DirectorySessionFactory.Default.CreateRootOrgRecipientSession(null, null, CultureInfo.InvariantCulture.LCID, true, ConsistencyMode.PartiallyConsistent, null, ADSessionSettings.FromRootOrgScopeSet(), 238, "CreateAdSession", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\rms\\TestDataCenterDKMAccess.cs"));
}
// Token: 0x06000154 RID: 340 RVA: 0x000067F4 File Offset: 0x000049F4
private void Initialize(Guid guid, string databaseName, string databaseLegacyDN, bool isPublic)
{
this.guid = guid;
this.systemMailboxName = "SystemMailbox{" + this.guid + "}";
this.databaseName = databaseName;
this.isPublic = isPublic;
this.displayName = string.Concat(new object[]
{
this.databaseName,
" (",
this.guid,
")"
});
Exception ex = null;
if (!this.isPublic)
{
try
{
this.systemMailboxPrincipal = ExchangePrincipal.FromADSystemMailbox(ADSessionSettings.FromRootOrgScopeSet(), this.FindSystemMailbox(), LocalServer.GetServer());
}
catch (DataValidationException ex2)
{
ex = ex2;
}
catch (ObjectNotFoundException ex3)
{
ex = ex3;
}
catch (ADExternalException ex4)
{
ex = ex4;
}
if (ex != null)
{
ExTraceGlobals.DatabaseInfoTracer.TraceError <DatabaseInfo, Exception>((long)this.GetHashCode(), "{0}: Unable to find valid system mailbox. Exception: {1}", this, ex);
throw new MissingSystemMailboxException(this.DisplayName, ex, base.Logger);
}
Guid guid2 = Guid.Empty;
try
{
ADSystemAttendantMailbox systemAttendant = this.GetSystemAttendant();
if (systemAttendant != null && systemAttendant.Database != null)
{
guid2 = systemAttendant.Database.ObjectGuid;
this.systemAttendantMailboxGuid = ((systemAttendant.ExchangeGuid == Guid.Empty) ? systemAttendant.Guid : systemAttendant.ExchangeGuid);
ExTraceGlobals.DatabaseInfoTracer.TraceDebug <DatabaseInfo, Guid, Guid>((long)this.GetHashCode(), "{0}: System Attendant Mailbox: Database GUID: {1}, Mailbox GUID: {2}", this, guid2, this.systemAttendantMailboxGuid);
}
}
catch (DataValidationException ex5)
{
ex = ex5;
}
catch (ObjectNotFoundException ex6)
{
ex = ex6;
}
if (ex != null)
{
base.TracePfd("PFD AIS {0} {1}: System Attendant Mailbox: Database GUID: {2}, Mailbox GUID: {3}", new object[]
{
30551,
this,
ex
});
throw new MissingSystemMailboxException(this.DisplayName, ex, base.Logger);
}
this.systemAttendantMailboxPresent = (this.guid == guid2);
ExTraceGlobals.DatabaseInfoTracer.TraceDebug <DatabaseInfo>((long)this.GetHashCode(), "{0}: Created database info", this);
}
base.TracePfd("PFD AIS {0} {1}: Created database info Sucessfully", new object[]
{
19287,
this
});
}
private void Execute(MapiTransactionOutcome transactionOutcome)
{
ExchangePrincipal mailboxOwner = null;
MapiTransactionResultEnum resultEnum = MapiTransactionResultEnum.Failure;
string error = string.Empty;
TimeSpan latency = TimeSpan.Zero;
Guid? mailboxGuid = null;
MailboxMiscFlags?mailboxMiscFlags = null;
try
{
if (this.adRecipient == null)
{
try
{
string errorStringBasedOnDatabaseCopyState = this.GetErrorStringBasedOnDatabaseCopyState();
if (!string.IsNullOrWhiteSpace(errorStringBasedOnDatabaseCopyState))
{
error = errorStringBasedOnDatabaseCopyState;
}
else
{
error = Strings.MapiTransactionErrorMsgNoMailbox;
}
}
catch (MapiPermanentException ex)
{
error = Strings.MapiTransactionDiagnosticStoreStateCheckFailure(this.ShortErrorMsgFromException(ex));
this.diagnosticContext = ex.DiagCtx.ToCompactString();
}
catch (MapiRetryableException ex2)
{
error = Strings.MapiTransactionDiagnosticStoreStateCheckFailure(this.ShortErrorMsgFromException(ex2));
this.diagnosticContext = ex2.DiagCtx.ToCompactString();
}
transactionOutcome.Update(MapiTransactionResultEnum.Failure, TimeSpan.Zero, error, mailboxGuid, mailboxMiscFlags, this.isDatabaseCopyActive);
}
else
{
try
{
if (this.adRecipient is ADSystemMailbox)
{
mailboxOwner = ExchangePrincipal.FromADSystemMailbox(ADSessionSettings.FromRootOrgScopeSet(), (ADSystemMailbox)this.adRecipient, this.targetServer);
}
else
{
ADSessionSettings adSessionSettings = this.adRecipient.OrganizationId.ToADSessionSettings();
mailboxOwner = ExchangePrincipal.FromMailboxData(adSessionSettings, this.adRecipient.DisplayName, this.targetServer.Fqdn, this.targetServer.ExchangeLegacyDN, this.adRecipient.LegacyExchangeDN, this.isArchiveMailbox ? ((ADUser)this.adRecipient).ArchiveGuid : ((ADUser)this.adRecipient).ExchangeGuid, this.database.Guid, this.adRecipient.PrimarySmtpAddress.ToString(), this.adRecipient.Id, new List <CultureInfo>(), Array <Guid> .Empty, RecipientType.Invalid, RemotingOptions.AllowCrossSite);
}
}
catch (ObjectNotFoundException ex3)
{
transactionOutcome.Update(MapiTransactionResultEnum.Failure, TimeSpan.Zero, this.ShortErrorMsgFromException(ex3), mailboxGuid, mailboxMiscFlags, this.isDatabaseCopyActive);
this.diagnosticContext = this.GetDiagnosticContext(ex3);
return;
}
MailboxSession mailboxSession = null;
Stopwatch stopwatch = Stopwatch.StartNew();
try
{
if (!this.transactionTimeouted)
{
try
{
mailboxSession = MailboxSession.OpenAsAdmin(mailboxOwner, CultureInfo.InvariantCulture, "Client=StoreActiveMonitoring;Action=Test-MapiConnectivity", false, false, !this.isDatabaseCopyActive);
}
catch (StorageTransientException exception)
{
error = this.DiagnoseMapiOperationException(exception, out resultEnum);
return;
}
catch (StoragePermanentException exception2)
{
error = this.DiagnoseMapiOperationException(exception2, out resultEnum);
return;
}
if (!this.transactionTimeouted)
{
using (Folder.Bind(mailboxSession, DefaultFolderType.Inbox, new PropertyDefinition[]
{
FolderSchema.ItemCount
}))
{
resultEnum = MapiTransactionResultEnum.Success;
error = string.Empty;
}
mailboxSession.Mailbox.Load(new PropertyDefinition[]
{
MailboxSchema.MailboxGuid,
MailboxSchema.MailboxMiscFlags
});
byte[] array = mailboxSession.Mailbox.TryGetProperty(MailboxSchema.MailboxGuid) as byte[];
object obj = mailboxSession.Mailbox.TryGetProperty(MailboxSchema.MailboxMiscFlags);
if (array != null && array.Length == 16)
{
mailboxGuid = new Guid?(new Guid(array));
}
if (obj is int)
{
mailboxMiscFlags = new MailboxMiscFlags?((MailboxMiscFlags)obj);
}
latency = stopwatch.Elapsed;
}
}
}
finally
{
if (mailboxSession != null)
{
mailboxSession.Dispose();
}
}
}
}
catch (Exception exception3)
{
error = this.ShortErrorMsgFromException(exception3);
}
finally
{
lock (this.timeoutOperationLock)
{
if (!this.transactionTimeouted)
{
transactionOutcome.Update(resultEnum, latency, error, mailboxGuid, mailboxMiscFlags, this.isDatabaseCopyActive);
}
}
}
}
// Token: 0x0600015E RID: 350 RVA: 0x00006CCC File Offset: 0x00004ECC
private ADSystemAttendantMailbox GetSystemAttendant()
{
string text = LocalServer.GetServer().ExchangeLegacyDN + "/cn=Microsoft System Attendant";
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 571, "GetSystemAttendant", "f:\\15.00.1497\\sources\\dev\\assistants\\src\\Assistants\\DatabaseInfo.cs");
ADRecipient adrecipient = null;
try
{
adrecipient = tenantOrRootOrgRecipientSession.FindByLegacyExchangeDN(text);
}
catch (DataValidationException arg)
{
ExTraceGlobals.DatabaseInfoTracer.TraceError <DataValidationException>((long)this.GetHashCode(), "{0}: Invalid system attendant mailbox: {1}", arg);
}
if (adrecipient == null || !(adrecipient is ADSystemAttendantMailbox))
{
ExTraceGlobals.DatabaseInfoTracer.TraceError <DatabaseInfo, string>((long)this.GetHashCode(), "{0}: Unable to find valid SA mailbox with legDN: {1}", this, text);
return(null);
}
return((ADSystemAttendantMailbox)adrecipient);
}
static Canary()
{
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(true, ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 78, ".cctor", "f:\\15.00.1497\\sources\\dev\\clients\\src\\owa\\bin\\core\\Canary.cs");
byte[] array = ADSystemConfigurationSession.GetRootOrgContainerIdForLocalForest().ObjectGuid.ToByteArray();
byte[] array2 = topologyConfigurationSession.GetDatabasesContainerId().ObjectGuid.ToByteArray();
Canary.adObjectIdsBinary = new byte[array.Length + array2.Length];
array.CopyTo(Canary.adObjectIdsBinary, 0);
array2.CopyTo(Canary.adObjectIdsBinary, array.Length);
if (ExTraceGlobals.UserContextTracer.IsTraceEnabled(TraceType.DebugTrace))
{
using (SHA256Cng sha256Cng = new SHA256Cng())
{
byte[] bytes = sha256Cng.ComputeHash(Canary.adObjectIdsBinary);
ExTraceGlobals.UserContextTracer.TraceDebug <string, string>(2L, "{0}.Canary(): adObjectIdsBinaryHash={1}", "Owa.Core.Canary", Canary.GetHexString(bytes));
sha256Cng.Clear();
}
}
}
protected override void InternalBeginProcessing()
{
base.InternalBeginProcessing();
PerimeterConfig perimeterConfig = (PerimeterConfig)this.GetDynamicParameters();
if (base.Fields.IsModified(PerimeterConfigSchema.MailFlowPartner))
{
MailFlowPartnerIdParameter mailFlowPartner = this.MailFlowPartner;
if (mailFlowPartner != null)
{
IConfigurationSession session = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(base.DomainController, false, ConsistencyMode.PartiallyConsistent, ADSessionSettings.FromRootOrgScopeSet(), 81, "InternalBeginProcessing", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\transport\\PerimeterConfig\\SetPerimeterConfig.cs");
MailFlowPartner mailFlowPartner2 = (MailFlowPartner)base.GetDataObject <MailFlowPartner>(mailFlowPartner, session, this.RootId, new LocalizedString?(Strings.MailFlowPartnerNotExists(mailFlowPartner)), new LocalizedString?(Strings.MailFlowPartnerNotUnique(mailFlowPartner)), ExchangeErrorCategory.Client);
perimeterConfig.MailFlowPartner = (ADObjectId)mailFlowPartner2.Identity;
return;
}
perimeterConfig.MailFlowPartner = null;
}
}
protected override void InternalBeginProcessing()
{
base.InternalBeginProcessing();
if (this.serverId == null)
{
this.serverId = new ServerIdParameter();
}
IConfigurationSession session = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 160, "InternalBeginProcessing", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\SystemConfigurationTasks\\MessageHygiene\\IPAllowBlockListEntries\\GetIPListEntry.cs");
this.server = (Server)base.GetDataObject <Server>(this.serverId, session, null, new LocalizedString?(Strings.ErrorServerNotFound(this.serverId.ToString())), new LocalizedString?(Strings.ErrorServerNotUnique(this.serverId.ToString())));
if (this.server == null || !IPListEntryUtils.IsSupportedRole(this.server))
{
base.WriteError(new LocalizedException(Strings.ErrorInvalidServerRole((this.server != null) ? this.server.Name : Environment.MachineName)), ErrorCategory.InvalidOperation, null);
}
}
private IADToplogyConfigurationSession CreateSession(bool readOnly, ConsistencyMode consistencyMode)
{
ITopologyConfigurationSession session = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(readOnly, consistencyMode, ADSessionSettings.FromRootOrgScopeSet(), 239, "CreateSession", "f:\\15.00.1497\\sources\\dev\\data\\src\\HA\\DirectoryServices\\ADSessionFactory.cs");
return(ADSessionFactory.CreateWrapper(session));
}
protected void PersistManagedAvailabilityServersUsgSid()
{
SecurityIdentifier securityIdentifier = null;
try
{
IRootOrganizationRecipientSession rootOrganizationRecipientSession = DirectorySessionFactory.Default.CreateRootOrgRecipientSession(true, ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 153, "PersistManagedAvailabilityServersUsgSid", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\Monitoring\\Service\\ManageHealthManagerService.cs");
securityIdentifier = rootOrganizationRecipientSession.GetWellKnownExchangeGroupSid(WellKnownGuid.MaSWkGuid);
}
catch (Exception)
{
}
if (securityIdentifier != null)
{
using (RegistryKey registryKey = Registry.LocalMachine.CreateSubKey(ManageHealthManagerService.RegistryPathBase))
{
registryKey.SetValue("ManagedAvailabilityServersUsgSid", securityIdentifier.ToString());
}
string name = "SOFTWARE\\Microsoft\\ExchangeServer";
using (RegistryKey registryKey2 = Registry.LocalMachine.OpenSubKey(name, true))
{
if (registryKey2 != null)
{
RegistrySecurity accessControl = registryKey2.GetAccessControl();
accessControl.AddAccessRule(new RegistryAccessRule(securityIdentifier, RegistryRights.FullControl, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.InheritOnly, AccessControlType.Allow));
registryKey2.SetAccessControl(accessControl);
using (RegistryKey registryKey3 = Registry.LocalMachine.OpenSubKey("SYSTEM\\CurrentControlSet\\Control\\SecurePipeServers\\winreg", true))
{
RegistrySecurity accessControl2 = registryKey3.GetAccessControl();
accessControl2.AddAccessRule(new RegistryAccessRule(securityIdentifier, RegistryRights.ExecuteKey, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.InheritOnly, AccessControlType.Allow));
registryKey3.SetAccessControl(accessControl2);
}
}
}
}
}
public FullSyncObjectRequestDataProvider(bool readOnly, string serviceInstanceName)
{
this.lastRidMasterRefreshTime = DateTime.MinValue;
this.serviceInstanceName = serviceInstanceName;
this.configurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(null, readOnly, ConsistencyMode.PartiallyConsistent, ADSessionSettings.FromRootOrgScopeSet(), 55, ".ctor", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\ForwardSync\\FullSyncObjectRequestDataProvider.cs");
this.configurationSession.UseConfigNC = false;
this.RefreshRidMasterInformation();
}
private static void DiscoverUrlsIfNeeded()
{
if (GlobalServiceUrls.E15Services == null)
{
ExTraceGlobals.CafeTracer.TraceDebug <int>(0L, "[GlobalServiceUrls.DiscoverUrlsIfNeeded] VDir information is not yet cached, starting discovery of up to {0} Cafe servers", 20);
lock (GlobalServiceUrls.urlLockRoot)
{
if (GlobalServiceUrls.E15Services == null)
{
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.NonCacheSessionFactory.CreateTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 284, "DiscoverUrlsIfNeeded", "f:\\15.00.1497\\sources\\dev\\data\\src\\ApplicationLogic\\Cafe\\GlobalServiceUrls.cs");
ADPagedReader <MiniServer> adpagedReader = topologyConfigurationSession.FindAllServersWithVersionNumber(Server.E15MinVersion, GlobalServiceUrls.CafeFilter, null);
adpagedReader.PageSize = 20;
int num = 0;
string text = string.Empty;
bool flag2 = false;
bool flag3 = false;
bool flag4 = false;
bool flag5 = false;
bool flag6 = false;
bool flag7 = false;
foreach (MiniServer miniServer in adpagedReader)
{
text = miniServer.Name;
MiniVirtualDirectory[] array = topologyConfigurationSession.FindMiniVirtualDirectories(miniServer.Id);
ExTraceGlobals.CafeTracer.TraceDebug <int, string, int>(0L, "[GlobalServiceUrls.DiscoverUrlsIfNeeded] Attempt {0}: Processing {1} and its {2} VDirs", num, text, array.Length);
Dictionary <ServiceType, VDirInfo> e15Services = new Dictionary <ServiceType, VDirInfo>(6);
flag2 = false;
flag3 = false;
flag4 = false;
flag5 = false;
flag6 = false;
flag7 = false;
bool flag8 = false;
foreach (MiniVirtualDirectory miniVirtualDirectory in array)
{
if (miniVirtualDirectory.IsEcp)
{
GlobalServiceUrls.SelectUrl(ServiceType.ExchangeControlPanel, miniVirtualDirectory, e15Services, ref flag3);
}
else if (miniVirtualDirectory.IsOwa)
{
GlobalServiceUrls.SelectUrl(ServiceType.OutlookWebAccess, miniVirtualDirectory, e15Services, ref flag2);
}
else if (miniVirtualDirectory.IsWebServices)
{
GlobalServiceUrls.SelectUrl(ServiceType.WebServices, miniVirtualDirectory, e15Services, ref flag4);
}
else if (miniVirtualDirectory.IsMobile)
{
GlobalServiceUrls.SelectUrl(ServiceType.MobileSync, miniVirtualDirectory, e15Services, ref flag5);
}
else if (miniVirtualDirectory.IsOab)
{
GlobalServiceUrls.SelectUrl(ServiceType.OfflineAddressBook, miniVirtualDirectory, e15Services, ref flag6);
}
else if (miniVirtualDirectory.IsMapi)
{
GlobalServiceUrls.SelectUrl(ServiceType.MapiHttp, miniVirtualDirectory, e15Services, ref flag7);
}
else if (miniVirtualDirectory.IsRpcHttp)
{
GlobalServiceUrls.rpcHttpVdir = miniVirtualDirectory;
flag8 = true;
}
if (flag2 && flag3 && flag4 && flag5 && flag6 && flag7 && flag8)
{
ExTraceGlobals.CafeTracer.TraceDebug(0L, "[GlobalServiceUrls.DiscoverUrlsIfNeeded] Successfully found all needed VDirs");
GlobalServiceUrls.E15Services = e15Services;
return;
}
}
if (++num >= 20)
{
ExTraceGlobals.CafeTracer.TraceError(0L, "[GlobalServiceUrls.DiscoverUrlsIfNeeded] Retry limit reached, Could not find needed VDirs.");
break;
}
}
throw new VDirConfigurationMissingException(text, GlobalServiceUrls.IsDatacenter ? "ExternalUrl" : "InternalUrl", (flag2 ? string.Empty : "OWA,") + (flag3 ? string.Empty : "ECP,") + (flag4 ? string.Empty : "EWS"));
}
ExTraceGlobals.CafeTracer.TraceDebug(0L, "[GlobalServiceUrls.DiscoverUrlsIfNeeded] Another thread completed discovery first, nothing to do.");
}
}
}
protected override void InternalValidate()
{
base.InternalValidate();
if (!this.Identity.IsUnique())
{
base.WriteError(new NonUniqueEventCategoryInputException(), ErrorCategory.InvalidData, this.Identity);
}
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(null, true, ConsistencyMode.PartiallyConsistent, ADSessionSettings.FromRootOrgScopeSet(), 148, "InternalValidate", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\EventLog\\SetEventLogLevel.cs");
EventCategoryIdentity eventCategoryIdentity = null;
if (this.Identity.ToString() != null)
{
eventCategoryIdentity = EventCategoryIdentity.Parse(this.Identity.ToString());
}
Server obj;
if (eventCategoryIdentity == null || string.IsNullOrEmpty(eventCategoryIdentity.Server))
{
obj = topologyConfigurationSession.FindLocalServer();
}
else
{
ServerIdParameter serverIdParameter = ServerIdParameter.Parse(eventCategoryIdentity.Server);
obj = (Server)base.GetDataObject <Server>(serverIdParameter, topologyConfigurationSession, null, null, new LocalizedString?(Strings.ErrorServerNotUnique(serverIdParameter.ToString())), new LocalizedString?(Strings.ErrorServerNotFound(serverIdParameter.ToString())));
}
ADSessionSettings sessionSettings = ADSessionSettings.FromCustomScopeSet(base.ScopeSet, ADSystemConfigurationSession.GetRootOrgContainerIdForLocalForest(), base.CurrentOrganizationId, base.ExecutingUserOrganizationId, true);
MapiTaskHelper.VerifyIsWithinConfigWriteScope(sessionSettings, obj, new Task.ErrorLoggerDelegate(base.ThrowTerminatingError));
}
private static bool TryDiscoverProtocolSettings(bool useLocalSite)
{
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.NonCacheSessionFactory.CreateTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 413, "TryDiscoverProtocolSettings", "f:\\15.00.1497\\sources\\dev\\data\\src\\ApplicationLogic\\Cafe\\GlobalServiceUrls.cs");
ADObjectId id = LocalSiteCache.LocalSite.Id;
QueryFilter queryFilter = new ComparisonFilter(useLocalSite ? ComparisonOperator.Equal : ComparisonOperator.NotEqual, ServerSchema.ServerSite, id);
QueryFilter additionalFilter = new AndFilter(new QueryFilter[]
{
queryFilter,
GlobalServiceUrls.CafeFilter
});
ADPagedReader <MiniServer> adpagedReader = topologyConfigurationSession.FindAllServersWithVersionNumber(Server.E15MinVersion, additionalFilter, null);
adpagedReader.PageSize = 20;
int num = 0;
string text = string.Empty;
bool flag = false;
bool flag2 = false;
bool flag3 = false;
bool flag4 = false;
bool flag5 = false;
Dictionary <ServiceType, ProtocolConnectionSettings> dictionary = null;
Dictionary <ServiceType, ProtocolConnectionSettings> dictionary2 = null;
foreach (MiniServer miniServer in adpagedReader)
{
text = miniServer.Name;
ADEmailTransport[] source = topologyConfigurationSession.Find <ADEmailTransport>(miniServer.Id, QueryScope.SubTree, null, null, 1000, null);
IEnumerable <ADEmailTransport> enumerable = from adEmailTransport in source
where adEmailTransport is Pop3AdConfiguration
select adEmailTransport;
IEnumerable <ADEmailTransport> enumerable2 = from adEmailTransport in source
where adEmailTransport is Imap4AdConfiguration
select adEmailTransport;
ReceiveConnector[] array = topologyConfigurationSession.Find <ReceiveConnector>(miniServer.Id, QueryScope.SubTree, GlobalServiceUrls.ReceiveConnectorFilter, null, 1000, null);
ExTraceGlobals.CafeTracer.TraceDebug <int, string, int>(0L, "[GlobalServiceUrls.TryDiscoverProtocolSettings] Attempt {0}: Processing {1} and its {2} connectors", num, text, array.Length);
dictionary = new Dictionary <ServiceType, ProtocolConnectionSettings>(3);
dictionary2 = new Dictionary <ServiceType, ProtocolConnectionSettings>(3);
flag = false;
flag2 = false;
flag3 = false;
flag4 = false;
flag5 = false;
foreach (ADEmailTransport ademailTransport in enumerable)
{
Pop3AdConfiguration popImapConfiguration = (Pop3AdConfiguration)ademailTransport;
if (!flag && GlobalServiceUrls.TrySelectProtocolConnectionSettings(ServiceType.Pop3, popImapConfiguration, true, dictionary))
{
flag = true;
}
if (!flag2 && GlobalServiceUrls.TrySelectProtocolConnectionSettings(ServiceType.Pop3, popImapConfiguration, false, dictionary2))
{
flag2 = true;
}
if (flag && flag2)
{
break;
}
}
foreach (ADEmailTransport ademailTransport2 in enumerable2)
{
Imap4AdConfiguration popImapConfiguration2 = (Imap4AdConfiguration)ademailTransport2;
if (!flag3 && GlobalServiceUrls.TrySelectProtocolConnectionSettings(ServiceType.Imap4, popImapConfiguration2, true, dictionary))
{
flag3 = true;
}
if (!flag4 && GlobalServiceUrls.TrySelectProtocolConnectionSettings(ServiceType.Imap4, popImapConfiguration2, false, dictionary2))
{
flag4 = true;
}
if (flag3 && flag4)
{
break;
}
}
ProtocolConnectionSettings protocolConnectionSettings = null;
foreach (ReceiveConnector receiveConnector in array)
{
Hostname hostname;
if (!Hostname.TryParse(receiveConnector.ServiceDiscoveryFqdn, out hostname) && !Hostname.TryParse(receiveConnector.Fqdn, out hostname))
{
ExTraceGlobals.CafeTracer.TraceWarning <ADObjectId>(0L, "[GlobalServiceUrls.TryDiscoverProtocolSettings] Smtp connector {0} has no valid ServiceDiscoveryFqdn or Fqdn", receiveConnector.Id);
}
else
{
int port = receiveConnector.Bindings[0].Port;
bool flag6 = (receiveConnector.AuthMechanism & (AuthMechanisms.Tls | AuthMechanisms.BasicAuthRequireTLS)) != AuthMechanisms.None;
if (flag6)
{
protocolConnectionSettings = new ProtocolConnectionSettings(hostname, port, new EncryptionType?(EncryptionType.TLS));
break;
}
if (protocolConnectionSettings == null)
{
protocolConnectionSettings = new ProtocolConnectionSettings(hostname, port, null);
}
}
}
if (protocolConnectionSettings != null)
{
dictionary[ServiceType.Smtp] = protocolConnectionSettings;
dictionary2[ServiceType.Smtp] = protocolConnectionSettings;
flag5 = true;
}
if (flag2 && flag4 && flag5)
{
ExTraceGlobals.CafeTracer.TraceDebug(0L, "[GlobalServiceUrls.TryDiscoverProtocolSettings] Successfully found all needed internal protocol settings");
GlobalServiceUrls.E15ProtocolsInternal = dictionary2;
}
if (flag && flag3 && flag5)
{
ExTraceGlobals.CafeTracer.TraceDebug(0L, "[GlobalServiceUrls.TryDiscoverProtocolSettings] Successfully found all needed external protocol settings");
GlobalServiceUrls.E15Protocols = dictionary;
return(true);
}
if (++num >= 20)
{
ExTraceGlobals.CafeTracer.TraceError(0L, "[GlobalServiceUrls.TryDiscoverProtocolSettings] Retry limit reached, Could not find all of the needed Protocol configurations.");
break;
}
}
if (!GlobalServiceUrls.IsDatacenter)
{
if (dictionary != null && dictionary.Count > 0)
{
ExTraceGlobals.CafeTracer.TraceWarning(0L, "[GlobalServiceUrls.TryDiscoverProtocolSettings] Found only some of the needed external protocol settings. Missing:" + (flag ? string.Empty : "POP3,") + (flag3 ? string.Empty : "IMAP4,") + (flag5 ? string.Empty : "SMTP"));
GlobalServiceUrls.E15Protocols = dictionary;
}
if (dictionary2 != null && dictionary2.Count > 0)
{
ExTraceGlobals.CafeTracer.TraceWarning(0L, "[GlobalServiceUrls.TryDiscoverProtocolSettings] Found only some of the needed internal protocol settings. Missing:" + (flag2 ? string.Empty : "POP3,") + (flag4 ? string.Empty : "IMAP4,") + (flag5 ? string.Empty : "SMTP"));
GlobalServiceUrls.E15ProtocolsInternal = dictionary2;
}
}
if (!useLocalSite && GlobalServiceUrls.E15Protocols == null)
{
if (GlobalServiceUrls.IsDatacenter)
{
throw new ProtocolConfigurationMissingException(text, "ExternalSettings");
}
GlobalServiceUrls.E15Protocols = new Dictionary <ServiceType, ProtocolConnectionSettings>(0);
}
if (!useLocalSite && GlobalServiceUrls.E15ProtocolsInternal == null)
{
if (GlobalServiceUrls.IsDatacenter)
{
throw new ProtocolConfigurationMissingException(text, "InternalSettings");
}
GlobalServiceUrls.E15ProtocolsInternal = new Dictionary <ServiceType, ProtocolConnectionSettings>(0);
}
return(false);
}
private static void ExchangeRpcClientAccessChangeNotification(ADNotificationEventArgs args)
{
Configuration.GeneralTracer.TraceDebug(0L, "ExchangeRpcClientAccessChangeNotification called");
ADNotificationAdapter.TryRunADOperation(delegate()
{
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 280, "ExchangeRpcClientAccessChangeNotification", "f:\\15.00.1497\\sources\\dev\\DoMT\\src\\Service\\Configuration.cs");
topologyConfigurationSession.ServerTimeout = Configuration.ADTimeout;
Server server = topologyConfigurationSession.ReadLocalServer();
if (server == null)
{
Configuration.GeneralTracer.TraceError(0L, "Failed to find local server in AD");
Configuration.eventLog.LogEvent(AddressBookEventLogConstants.Tuple_FailedToFindLocalServerInAD, string.Empty, new object[0]);
if (args == null)
{
Configuration.ServiceEnabled = false;
return;
}
Configuration.stopService();
return;
}
else
{
ExchangeRpcClientAccess exchangeRpcClientAccess = topologyConfigurationSession.Read <ExchangeRpcClientAccess>(ExchangeRpcClientAccess.FromServerId(server.Id));
if (exchangeRpcClientAccess != null)
{
if (Configuration.exchangeRCANotificationCookie == null)
{
Configuration.exchangeRCANotificationCookie = ADNotificationAdapter.RegisterChangeNotification <ExchangeRpcClientAccess>(exchangeRpcClientAccess.Id, new ADNotificationCallback(Configuration.ExchangeRpcClientAccessChangeNotification));
}
if (Configuration.EncryptionRequired != exchangeRpcClientAccess.EncryptionRequired)
{
Configuration.GeneralTracer.TraceDebug <bool, bool>(0L, "Changing EncryptionRequired from {0} to {1}", Configuration.EncryptionRequired, exchangeRpcClientAccess.EncryptionRequired);
Configuration.EncryptionRequired = exchangeRpcClientAccess.EncryptionRequired;
}
return;
}
Configuration.GeneralTracer.TraceDebug(0L, "ExchangeRpcClientAccess disabled");
Configuration.eventLog.LogEvent(AddressBookEventLogConstants.Tuple_ExchangeRpcClientAccessDisabled, string.Empty, new object[0]);
if (args == null)
{
Configuration.ServiceEnabled = false;
return;
}
Configuration.stopService();
return;
}
});
}
public static ActiveManager GetNoncachingActiveManagerInstance()
{
if (ActiveManager.s_uncachedActiveManager == null)
{
lock (ActiveManager.s_singletonLock)
{
if (ActiveManager.s_uncachedActiveManager == null)
{
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(ConsistencyMode.FullyConsistent, ADSessionSettings.FromRootOrgScopeSet(), 1023, "GetNoncachingActiveManagerInstance", "f:\\15.00.1497\\sources\\dev\\data\\src\\storage\\ActiveManager\\ActiveManager.cs");
IADToplogyConfigurationSession adSession = ADSessionFactory.CreateWrapper(topologyConfigurationSession);
ActiveManager.s_uncachedActiveManager = new ActiveManager(false, new SimpleAdObjectLookup <IADDatabaseAvailabilityGroup>(adSession), new SimpleAdObjectLookup <IADServer>(adSession), new SimpleMiniServerLookup(adSession), new SimpleAdObjectLookup <IADClientAccessArray>(adSession), new SimpleMiniClientAccessServerOrArrayLookup(topologyConfigurationSession), new SimpleAdObjectLookup <IADDatabase>(adSession), topologyConfigurationSession, false);
ActiveManager.s_uncachedActiveManager.SuppressDisposeTracker();
}
}
}
return(ActiveManager.s_uncachedActiveManager);
}