// Token: 0x06000779 RID: 1913 RVA: 0x0001D180 File Offset: 0x0001B380
public IAsyncResult BeginGetBackEndServerList(MiniRecipient miniRecipient, int maxServers, AsyncCallback callback, object state)
{
if (miniRecipient == null)
{
throw new ArgumentNullException("miniRecipient");
}
if (maxServers <= 0)
{
throw new ArgumentException("maxServers needs to be greater than zero");
}
this.database = miniRecipient.Database;
this.maxServers = maxServers;
OrganizationId organizationId = miniRecipient.OrganizationId;
SmtpAddress primarySmtpAddress = miniRecipient.PrimarySmtpAddress;
if (this.database == null)
{
ADUser defaultOrganizationMailbox = HttpProxyBackEndHelper.GetDefaultOrganizationMailbox(organizationId, null);
if (defaultOrganizationMailbox == null || defaultOrganizationMailbox.Database == null)
{
ExTraceGlobals.CafeTracer.TraceError <OrganizationId>(0L, "[BackEndLocator.BeginGetBackEndServerList] Cannot find organization mailbox for organization {1}", organizationId);
throw new AdUserNotFoundException(ServerStrings.ADUserNotFound);
}
this.database = defaultOrganizationMailbox.Database;
primarySmtpAddress = defaultOrganizationMailbox.PrimarySmtpAddress;
}
string domainName = null;
if (organizationId != null && !organizationId.Equals(OrganizationId.ForestWideOrgId))
{
domainName = primarySmtpAddress.Domain;
}
this.serverLocator = MailboxServerLocator.Create(this.database.ObjectGuid, domainName, this.database.PartitionFQDN);
bool flag = true;
IAsyncResult result;
try
{
result = this.serverLocator.BeginGetServer(callback, state);
flag = false;
}
catch (Exception ex)
{
ExTraceGlobals.CafeTracer.TraceError <Exception>(0L, "[AsyncBackEndLocator.BeginGetBackEndServerList] Caught exception {0}.", ex);
if (BackEndLocator.ShouldWrapInBackendLocatorException(ex))
{
throw new BackEndLocatorException(ex);
}
throw;
}
finally
{
if (flag)
{
this.serverLocator.Dispose();
this.serverLocator = null;
}
}
return(result);
}
public static NspiPrincipal FromUserSid(SecurityIdentifier sid, string userDomain)
{
NspiPrincipal principal = null;
if (!string.IsNullOrEmpty(userDomain))
{
MiniRecipient miniRecipient = NspiPrincipal.FindMiniRecipientBySid(ADSessionSettings.RootOrgOrSingleTenantFromAcceptedDomainAutoDetect(userDomain), sid);
if (miniRecipient != null)
{
principal = new NspiPrincipal(miniRecipient);
}
}
else if (Configuration.IsDatacenter)
{
ExTraceGlobals.NspiTracer.TraceWarning <SecurityIdentifier>(0L, "We have to do a fan out query for user {0} because of legacy client.", sid);
DirectoryHelper.DoAdCallAndTranslateExceptions(delegate
{
MiniRecipient miniRecipientFromUserId = PartitionDataAggregator.GetMiniRecipientFromUserId(sid);
if (miniRecipientFromUserId != null)
{
principal = new NspiPrincipal(miniRecipientFromUserId);
}
}, "ADAccountPartitionLocator::GetAllAccountPartitionIds");
}
else
{
principal = NspiPrincipal.FromUserSid(ADSessionSettings.FromRootOrgScopeSet(), sid);
}
return(principal ?? new NspiPrincipal(sid));
}
public IEnumerable <AcePermissionRecipientRow> ResolveSecurityPrincipalId(IEnumerable <SecurityPrincipalIdParameter> sidPrincipalId)
{
if (sidPrincipalId != null && sidPrincipalId.Any <SecurityPrincipalIdParameter>())
{
IRecipientSession recipientSession = (IRecipientSession)this.CreateAdSession();
List <AcePermissionRecipientRow> list = new List <AcePermissionRecipientRow>();
foreach (SecurityPrincipalIdParameter securityPrincipalIdParameter in sidPrincipalId)
{
SecurityIdentifier securityIdentifier = securityPrincipalIdParameter.SecurityIdentifier;
if (!securityIdentifier.IsWellKnown(WellKnownSidType.SelfSid))
{
MiniRecipient miniRecipient = recipientSession.FindMiniRecipientBySid <MiniRecipient>(securityIdentifier, AcePermissionRecipientRow.Properties.AsEnumerable <PropertyDefinition>());
if (miniRecipient != null)
{
Identity identity;
if (miniRecipient.MasterAccountSid == securityIdentifier)
{
identity = new Identity(miniRecipient.Guid.ToString(), securityPrincipalIdParameter.ToString());
}
else
{
identity = new Identity(miniRecipient.Guid.ToString(), string.IsNullOrEmpty(miniRecipient.DisplayName) ? miniRecipient.Name : miniRecipient.DisplayName);
}
list.Add(new AcePermissionRecipientRow(identity));
}
}
}
return(list);
}
return(new List <AcePermissionRecipientRow>());
}
public static IList <BackEndServer> GetBackEndServerList(MiniRecipient miniRecipient, int maxServers)
{
if (miniRecipient == null)
{
throw new ArgumentNullException("miniRecipient");
}
return(BackEndLocator.CallWithExceptionHandling <IList <BackEndServer> >(() => BackEndLocator.GetBackEndServerListForDatabase(miniRecipient.Database, miniRecipient.OrganizationId, miniRecipient.PrimarySmtpAddress, maxServers)));
}
public static BackEndServer GetBackEndServer(MiniRecipient miniRecipient)
{
if (miniRecipient == null)
{
throw new ArgumentNullException("miniRecipient");
}
return(BackEndLocator.CallWithExceptionHandling <BackEndServer>(() => BackEndLocator.GetBackEndServerByDatabase(miniRecipient.Database, miniRecipient.OrganizationId, miniRecipient.PrimarySmtpAddress)));
}
public Office365ConnectionSettings(MiniRecipient adUser) : base(ConnectionSettingsType.Office365)
{
if (adUser == null)
{
throw new ArgumentNullException("adUser", "The adUser cannot be null.");
}
this.AdUser = adUser;
}
public FeaturesManagerFactory(MiniRecipient recipient, IConfigurationContext configurationContext, ScopeFlightsSettingsProvider scopeFlightsSettingsProvider, Func <VariantConfigurationSnapshot, IFeaturesStateOverride> featureStateOverrideFactory, string rampId, bool isFirstRelease)
{
this.recipient = recipient;
this.configurationContext = configurationContext;
this.scopeFlightsSettingsProvider = scopeFlightsSettingsProvider;
this.featureStateOverrideFactory = featureStateOverrideFactory;
this.rampId = rampId;
this.isFirstRelease = isFirstRelease;
}
protected IThrottlingPolicy GetPolicyForRecipient(MiniRecipient recipient)
{
if (recipient == null)
{
ExTraceGlobals.ClientThrottlingTracer.TraceDebug <LookupBudgetKey>((long)this.GetHashCode(), "[LookupBudgetKey.GetPolicyForRecipient] Passed identifier did not resolve to an AD account: '{0}'. Using global policy.", this);
return(ThrottlingPolicyCache.Singleton.GetGlobalThrottlingPolicy());
}
return(recipient.ReadThrottlingPolicy());
}
internal static bool IsWorkingSetAgentFeatureEnabled(MiniRecipient miniRecipient)
{
if (miniRecipient != null)
{
VariantConfigurationSnapshot snapshot = VariantConfiguration.GetSnapshot(miniRecipient.GetContext(null), null, null);
return(snapshot.WorkingSet.WorkingSetAgent.Enabled);
}
return(false);
}
internal override IThrottlingPolicy InternalLookup()
{
IRecipientSession session = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(true, ConsistencyMode.PartiallyConsistent, this.SessionSettings, 201, "InternalLookup", "f:\\15.00.1497\\sources\\dev\\data\\src\\directory\\throttling\\SidBudgetKey.cs");
return(base.ADRetryLookup(delegate
{
MiniRecipient recipient = session.FindMiniRecipientBySid <MiniRecipient>(this.Sid, null);
return this.GetPolicyForRecipient(recipient);
}));
}
public static NspiPrincipal FromUserSid(ADSessionSettings sessionSettings, SecurityIdentifier sid)
{
MiniRecipient miniRecipient = NspiPrincipal.FindMiniRecipientBySid(sessionSettings, sid);
if (miniRecipient != null)
{
return(new NspiPrincipal(miniRecipient));
}
return(new NspiPrincipal(sid));
}
private static Uri GetBackEndHttpServiceUrl <ServiceType>(MiniRecipient miniRecipient) where ServiceType : HttpService
{
if (miniRecipient == null)
{
throw new ArgumentNullException("miniRecipient");
}
return(BackEndLocator.CallWithExceptionHandling <Uri>(delegate
{
BackEndServer backEndServer = BackEndLocator.GetBackEndServer(miniRecipient);
return HttpProxyBackEndHelper.GetBackEndServiceUrlByServer <ServiceType>(backEndServer);
}));
}
private static bool IsBulkMail(StoreDriverDeliveryEventArgsImpl argsImpl, MiniRecipient recipient)
{
bool result = false;
string name = InferenceXsoUtil.IsMicrosoft(recipient) ? "X-Forefront-Antispam-Report-Untrusted" : "X-MS-Exchange-Organization-Antispam-Report";
Header header = argsImpl.MailItem.Message.MimeDocument.RootPart.Headers.FindFirst(name);
string data;
if (header != null && header.TryGetValue(out data))
{
result = InferenceCommonUtility.MatchBulkHeader(data);
}
return(result);
}
private static int GetRetentionPeriod(MiniRecipient mailboxOwner)
{
if (mailboxOwner != null)
{
string value = VariantConfiguration.InvariantNoFlightingSnapshot.MailboxTransport.ParkedMeetingMessagesRetentionPeriod.Value;
int result;
if (!string.IsNullOrEmpty(value) && int.TryParse(value, out result))
{
return(result);
}
}
return(2);
}
public IMailboxOwner Create(MiniRecipient recipient)
{
if (recipient == null)
{
return(new NullMailboxOwnerAdapter());
}
if (this.session.IsGroupMailbox())
{
return(new GroupMailboxOwnerAdapter());
}
RecipientTypeDetails recipientTypeDetails = recipient.RecipientTypeDetails;
return(new MiniRecipientMailboxOwnerAdapter(recipient, recipient.GetContext(null), recipientTypeDetails, this.session.LogonType));
}
private bool TryCalculateConversationCreatorSid(IMailboxSession session, MiniRecipient mailboxOwner, ConversationAggregationResult aggregationResult, ICorePropertyBag deliveredMessage, out byte[] conversationCreatorSid)
{
conversationCreatorSid = null;
bool flag = false;
ConversationCreatorSidCalculatorFactory conversationCreatorSidCalculatorFactory = new ConversationCreatorSidCalculatorFactory(XSOFactory.Default);
IConversationCreatorSidCalculator conversationCreatorSidCalculator;
if (conversationCreatorSidCalculatorFactory.TryCreate(session, mailboxOwner, out conversationCreatorSidCalculator) && conversationCreatorSidCalculator.TryCalculateOnDelivery(deliveredMessage, aggregationResult.Stage, aggregationResult.ConversationIndex, out conversationCreatorSid, out flag))
{
if (flag)
{
conversationCreatorSidCalculator.UpdateConversationMessages(aggregationResult.ConversationIndex, conversationCreatorSid);
}
return(true);
}
return(false);
}
public bool TryCreate(IMailboxSession mailboxSession, MiniRecipient miniRecipient, out IConversationCreatorSidCalculator calculator)
{
calculator = null;
if (!this.CanSetConversationCreatorProperty(mailboxSession))
{
return(false);
}
if (miniRecipient != null && miniRecipient.GetContext(null) != null)
{
calculator = this.Create(mailboxSession, miniRecipient.GetContext(null));
}
else
{
calculator = new LegacyConversationCreatorSidCalculator(mailboxSession);
}
return(true);
}
internal static VariantConfigurationSnapshot GetSnapshot(ADRawEntry executingUser, IEnumerable <KeyValuePair <string, string> > additionalConstraints)
{
if (executingUser == null)
{
return(null);
}
VariantConfigurationSnapshot variantConfigurationSnapshot = null;
MiniRecipient miniRecipient = new MiniRecipient();
try
{
try
{
miniRecipient[MiniRecipientSchema.UserPrincipalName] = executingUser[ADUserSchema.UserPrincipalName];
miniRecipient[ADObjectSchema.OrganizationId] = executingUser[ADObjectSchema.OrganizationId];
miniRecipient[MiniRecipientSchema.ExternalDirectoryObjectId] = executingUser[ADRecipientSchema.ExternalDirectoryObjectId];
miniRecipient[MiniRecipientSchema.Languages] = executingUser[ADOrgPersonSchema.Languages];
}
catch (DataValidationException ex)
{
AuthZLogger.SafeAppendColumn(RpsAuthZMetadata.VariantConfigurationSnapshot, "DataValidationException", ex.Message);
}
ConstraintCollection constraintCollection = null;
if (additionalConstraints != null)
{
constraintCollection = ConstraintCollection.CreateEmpty();
foreach (KeyValuePair <string, string> keyValuePair in additionalConstraints)
{
constraintCollection.Add(keyValuePair.Key, keyValuePair.Value);
}
}
variantConfigurationSnapshot = VariantConfiguration.GetSnapshot(miniRecipient.GetContext(null), constraintCollection, null);
AuthZLogger.SafeAppendColumn(RpsAuthZMetadata.VariantConfigurationSnapshot, "Flights", string.Join(" ", variantConfigurationSnapshot.Flights));
}
catch (Exception ex2)
{
AuthZLogger.SafeAppendGenericError("VariantConfigurationSnapshot.Exception", ex2.Message, false);
}
finally
{
AuthZLogger.SafeAppendColumn(RpsAuthZMetadata.VariantConfigurationSnapshot, "User", executingUser[ADUserSchema.UserPrincipalName].ToString());
AuthZLogger.SafeAppendColumn(RpsAuthZMetadata.VariantConfigurationSnapshot, "Org", executingUser[ADObjectSchema.OrganizationId].ToString());
}
return(variantConfigurationSnapshot);
}
private NspiPrincipal(MiniRecipient miniRecipient)
{
this.LegacyDistinguishedName = miniRecipient.LegacyExchangeDN;
if (string.IsNullOrEmpty(this.LegacyDistinguishedName))
{
this.LegacyDistinguishedName = LegacyDN.FormatLegacyDnFromGuid(Guid.Empty, (Guid)miniRecipient[ADObjectSchema.Guid]);
}
this.AddressBookPolicy = miniRecipient.AddressBookPolicy;
this.OrganizationId = miniRecipient.OrganizationId;
this.DirectorySearchRoot = miniRecipient.QueryBaseDN;
this.PrimarySmtpAddress = miniRecipient.PrimarySmtpAddress;
this.ExchangeGuid = miniRecipient.ExchangeGuid;
this.MAPIEnabled = miniRecipient.MAPIEnabled;
this.Database = miniRecipient.Database;
this.ExchangeVersion = miniRecipient.ExchangeVersion;
if (miniRecipient.Languages != null && miniRecipient.Languages.Count > 0)
{
this.PreferredCulture = miniRecipient.Languages[0];
}
}
public static MiniRecipient GetMiniRecipientFromUserId(SecurityIdentifier sid, IEnumerable <PropertyDefinition> properties, ConsistencyMode consistencyMode)
{
MiniRecipient miniRecipient = null;
foreach (PartitionId partitionId in ADAccountPartitionLocator.GetAllAccountPartitionIds())
{
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(true, consistencyMode, ADSessionSettings.FromAllTenantsPartitionId(partitionId), 249, "GetMiniRecipientFromUserId", "f:\\15.00.1497\\sources\\dev\\data\\src\\directory\\PartitionDataAggregator.cs");
try
{
miniRecipient = tenantOrRootOrgRecipientSession.FindMiniRecipientBySid <MiniRecipient>(sid, properties);
}
catch (NonUniqueRecipientException)
{
}
if (miniRecipient != null)
{
break;
}
}
return(miniRecipient);
}
internal static OAuthCredentials GetOAuthCredential(string sipUri)
{
ProxyAddress proxyAddress = ProxyAddress.Parse(sipUri);
string sipDomain = OnlineMeetingHelper.GetSipDomain(sipUri);
if (string.IsNullOrEmpty(sipDomain))
{
ExTraceGlobals.OnlineMeetingTracer.TraceError <string>(0L, "[UcwaConfigurationUtilities.GetOAuthCredential] Unable to determine domain from sip uri: {0}", sipUri);
throw new OwaException(string.Format("Unable to determine domain from sip uri: {0}", sipUri));
}
MiniRecipient miniRecipient = null;
IRecipientSession recipientSession = null;
try
{
recipientSession = UserContextUtilities.CreateScopedRecipientSession(true, ConsistencyMode.FullyConsistent, sipDomain, null);
}
catch (OwaADObjectNotFoundException innerException)
{
throw new OwaException(string.Format("Couldn't create a scoped recipient session for {0}", sipDomain), innerException);
}
try
{
miniRecipient = recipientSession.FindByProxyAddress <MiniRecipient>(proxyAddress);
if (miniRecipient == null)
{
ExTraceGlobals.OnlineMeetingTracer.TraceError <string>(0L, "[UcwaConfigurationUtilities.GetOAuthCredential] IRecipientSession.FindByProxyAddress() unable to find to recipient with address: {0}", sipUri);
throw new OwaException(string.Format("Couldn't find a match for {0}", proxyAddress.ToString()));
}
}
catch (NonUniqueRecipientException innerException2)
{
ExTraceGlobals.OnlineMeetingTracer.TraceError <string>(0L, "[UcwaConfigurationUtilities.GetOAuthCredential] Couldn't find a unique match for: {0}", sipUri);
throw new OwaException(string.Format("Couldn't find a unique match for {0}", proxyAddress.ToString()), innerException2);
}
return(OAuthCredentials.GetOAuthCredentialsForAppActAsToken(miniRecipient.OrganizationId, miniRecipient, sipDomain));
}
internal static bool SeriesMessageOrderingEnabled(MiniRecipient mailboxOwner)
{
return(mailboxOwner != null && VariantConfiguration.GetSnapshot(mailboxOwner.GetContext(null), null, null).MailboxTransport.OrderSeriesMeetingMessages.Enabled);
}
public static Uri GetBackEndWebServicesUrl(MiniRecipient miniRecipient)
{
return(BackEndLocator.GetBackEndHttpServiceUrl <WebServicesService>(miniRecipient));
}
public FeaturesManagerFactory(MiniRecipient recipient, IConfigurationContext configurationContext, ScopeFlightsSettingsProvider scopeFlightsSettingsProvider) : this(recipient, configurationContext, scopeFlightsSettingsProvider, null, string.Empty, false)
{
}
// Token: 0x060003B5 RID: 949 RVA: 0x00015440 File Offset: 0x00013640
internal static ADObject CreateAndInitializeRecipientObject <TRecipientObject>(ADPropertyBag propertyBag, ADRawEntry dummyObject, IRecipientSession recipientSession) where TRecipientObject : IConfigurable, new()
{
ArgumentValidator.ThrowIfNull("propertyBag", propertyBag);
ArgumentValidator.ThrowIfNull("dummyObject", dummyObject);
MultiValuedProperty <string> multiValuedProperty = (MultiValuedProperty <string>)propertyBag[ADObjectSchema.ObjectClass];
ADObject adobject;
if (dummyObject is OWAMiniRecipient)
{
adobject = new OWAMiniRecipient();
}
else if (dummyObject is ActiveSyncMiniRecipient)
{
adobject = new ActiveSyncMiniRecipient();
}
else if (dummyObject is StorageMiniRecipient)
{
adobject = new StorageMiniRecipient();
}
else if (dummyObject is TransportMiniRecipient)
{
adobject = new TransportMiniRecipient();
}
else if (dummyObject is LoadBalancingMiniRecipient)
{
adobject = new LoadBalancingMiniRecipient();
}
else if (dummyObject is MiniRecipientWithTokenGroups)
{
adobject = new MiniRecipientWithTokenGroups();
}
else if (dummyObject is FrontEndMiniRecipient)
{
adobject = new FrontEndMiniRecipient();
}
else if (dummyObject is MiniRecipient)
{
adobject = new MiniRecipient();
}
else if (dummyObject is RemovedMailbox)
{
adobject = new RemovedMailbox();
}
else if (dummyObject is DeletedRecipient)
{
adobject = new DeletedRecipient();
}
else if (multiValuedProperty.Contains(ADComputerRecipient.MostDerivedClass))
{
adobject = new ADComputerRecipient();
}
else if (multiValuedProperty.Contains(ADUser.MostDerivedClass))
{
adobject = new ADUser();
}
else if (multiValuedProperty.Contains(ADContact.MostDerivedClass))
{
adobject = new ADContact();
}
else if (multiValuedProperty.Contains(ADGroup.MostDerivedClass))
{
adobject = new ADGroup();
}
else if (multiValuedProperty.Contains(ADDynamicGroup.MostDerivedClass))
{
adobject = new ADDynamicGroup();
}
else if (multiValuedProperty.Contains(ADPublicFolder.MostDerivedClass))
{
adobject = new ADPublicFolder();
}
else if (multiValuedProperty.Contains(ADSystemAttendantMailbox.MostDerivedClass))
{
adobject = new ADSystemAttendantMailbox();
}
else if (multiValuedProperty.Contains(ADSystemMailbox.MostDerivedClass))
{
adobject = new ADSystemMailbox();
}
else if (multiValuedProperty.Contains(ADPublicDatabase.MostDerivedClass))
{
adobject = new ADPublicDatabase();
}
else
{
if (!multiValuedProperty.Contains(ADMicrosoftExchangeRecipient.MostDerivedClass))
{
string objectClass = string.Empty;
foreach (string text in multiValuedProperty)
{
objectClass = text;
}
ObjectValidationError error = new ObjectValidationError(DirectoryStrings.UnsupportedObjectClass(objectClass), (ADObjectId)propertyBag[ADObjectSchema.Id], string.Empty);
ADProviderPerf.UpdateProcessCounter(Counter.ProcessRateCriticalValidationFailures, UpdateType.Update, 1U);
Globals.LogEvent(DirectoryEventLogConstants.Tuple_DSC_EVENT_VALIDATION_FAILED_FCO_MODE_RECIPIENT, ((ADObjectId)propertyBag[ADObjectSchema.Id]).ToString(), new object[]
{
((ADObjectId)propertyBag[ADObjectSchema.Id]).ToDNString()
});
throw new DataValidationException(error);
}
adobject = new ADMicrosoftExchangeRecipient();
}
adobject.m_Session = recipientSession;
adobject.propertyBag = propertyBag;
adobject.Initialize();
adobject.ResetChangeTracking(true);
if (recipientSession != null)
{
adobject.SetIsReadOnly(recipientSession.ReadOnly);
}
ExTraceGlobals.ADReadDetailsTracer.TraceDebug <string, RecipientType>((long)((recipientSession != null) ? recipientSession.GetHashCode() : 0), "ADRecipientObjectSession::CreateObject - Got {0} as {1}", adobject.DistinguishedName, (RecipientType)adobject[ADRecipientSchema.RecipientType]);
return(adobject);
}
public static IEasFeaturesManager Create(MiniRecipient recipient, Dictionary <EasFeature, bool> flightingOverrides)
{
VariantConfigurationSnapshot snapshot = VariantConfiguration.GetSnapshot(recipient.GetContext(null), null, null);
return(new EasFeaturesManager(snapshot, flightingOverrides));
}
public override void ReadData(IConfigurationSession configurationSession)
{
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.FullyConsistent, configurationSession.SessionSettings, 104, "ReadData", "f:\\15.00.1497\\sources\\dev\\data\\src\\directory\\SystemConfiguration\\ConfigurationCache\\TenantPublicFolderConfiguration.cs");
this.localPublicFolderRecipients = new Hashtable();
this.remotePublicFolderRecipients = new Hashtable();
this.estimatedSize = 0L;
Organization orgContainer = configurationSession.GetOrgContainer();
this.hierarchyMailboxInformation = orgContainer.DefaultPublicFolderMailbox;
this.publicFoldersDeploymentType = orgContainer.PublicFoldersEnabled;
this.estimatedSize += (long)this.hierarchyMailboxInformation.ItemSize;
this.HeuristicsFlags = orgContainer.Heuristics;
this.estimatedSize += 4L;
this.estimatedSize += 4L;
ADRawEntry[] array = Array <ADRawEntry> .Empty;
if (this.hierarchyMailboxInformation.HierarchyMailboxGuid != Guid.Empty)
{
array = tenantOrRootOrgRecipientSession.FindPaged <ADRawEntry>(null, QueryScope.SubTree, Filters.GetRecipientTypeDetailsFilterOptimization(RecipientTypeDetails.PublicFolderMailbox), new SortBy(ADObjectSchema.WhenCreatedUTC, SortOrder.Ascending), 0, TenantPublicFolderConfiguration.PublicFolderRecipientProperties).ReadAllPages();
}
List <PublicFolderRecipient> list = new List <PublicFolderRecipient>();
if (this.PublicFoldersDeploymentType == PublicFoldersDeployment.Remote && orgContainer.RemotePublicFolderMailboxes.Count > 0)
{
ADObjectId[] array2 = orgContainer.RemotePublicFolderMailboxes.ToArray();
foreach (ADObjectId adobjectId in array2)
{
if (!adobjectId.IsDeleted)
{
MiniRecipient miniRecipient = tenantOrRootOrgRecipientSession.ReadMiniRecipient(adobjectId, null);
if (miniRecipient != null)
{
PublicFolderRecipient publicFolderRecipient = new PublicFolderRecipient(miniRecipient.Name, Guid.Empty, null, miniRecipient.PrimarySmtpAddress, miniRecipient.Id, false);
this.estimatedSize += publicFolderRecipient.ItemSize;
this.remotePublicFolderRecipients.Add(publicFolderRecipient.ObjectId, publicFolderRecipient);
list.Add(publicFolderRecipient);
}
}
}
if (list.Count > 0)
{
this.consistentHashSetForRemoteMailboxes = new ConsistentHashSet <PublicFolderRecipient, Guid>(list.ToArray(), 1, 64);
this.estimatedSize += this.consistentHashSetForRemoteMailboxes.ItemSize;
}
}
list.Clear();
if (array.Length > 0)
{
for (int j = 0; j < array.Length; j++)
{
PublicFolderRecipient publicFolderRecipient = new PublicFolderRecipient((string)array[j][ADRecipientSchema.DisplayName], (Guid)array[j][ADMailboxRecipientSchema.ExchangeGuid], (ADObjectId)array[j][ADMailboxRecipientSchema.Database], (SmtpAddress)array[j][ADRecipientSchema.PrimarySmtpAddress], (ADObjectId)array[j][ADObjectSchema.Id], true);
this.estimatedSize += publicFolderRecipient.ItemSize;
this.localPublicFolderRecipients.Add(publicFolderRecipient.ObjectId, publicFolderRecipient);
if (!(bool)array[j][ADRecipientSchema.IsExcludedFromServingHierarchy] && (bool)array[j][ADRecipientSchema.IsHierarchyReady])
{
list.Add(publicFolderRecipient);
}
}
if (list.Count > 0)
{
this.consistentHashSetForLocalMailboxes = new ConsistentHashSet <PublicFolderRecipient, Guid>(list.ToArray(), 1, 64);
this.estimatedSize += this.consistentHashSetForLocalMailboxes.ItemSize;
}
}
}
// Token: 0x06000FB5 RID: 4021 RVA: 0x00040414 File Offset: 0x0003E614
public IEnumerable <ConnectionSettings> GetConnectionSettingsMatchingEmail(SmtpAddress email)
{
Office365ConnectionSettings connectionSettings = null;
this.log.ExecuteMonitoredOperation(ConnectionSettingsDiscoveryMetadata.GetOffice365ConnectionSettings, delegate
{
try
{
ADSessionSettings sessionSettings = ADSessionSettings.FromTenantAcceptedDomain(email.Domain);
ITenantRecipientSession recipientSession = DirectorySessionFactory.Default.CreateTenantRecipientSession(true, ConsistencyMode.IgnoreInvalid, sessionSettings, 78, "GetConnectionSettingsMatchingEmail", "f:\\15.00.1497\\sources\\dev\\data\\src\\ApplicationLogic\\ConnectionSettingsDiscovery\\ConnectionSettingsProviders\\O365ConnectionSettingsProvider.cs");
MiniRecipient adUser = null;
Action action = delegate()
{
adUser = recipientSession.FindByProxyAddress <MiniRecipient>(new SmtpProxyAddress(email.ToString(), true));
};
bool flag = false;
int i = 0;
while (i < 1)
{
i++;
try
{
action();
flag = true;
break;
}
catch (DataSourceTransientException ex)
{
this.log.Trace("Caught an exception from directory while trying to find an AD user object for email address {0}. Exception: {1}", new object[]
{
email,
ex
});
}
catch (DataSourceOperationException ex2)
{
this.log.Trace("Caught an exception from directory while trying to find an AD user object for email address {0}. Exception: {1}", new object[]
{
email,
ex2
});
}
}
if (!flag)
{
i++;
action();
}
if (adUser != null)
{
connectionSettings = new Office365ConnectionSettings(adUser);
}
else
{
this.log.Trace("Found Office365 connection settings for email address {0} when AD user object does not exist", new object[]
{
email
});
connectionSettings = new Office365ConnectionSettings();
}
}
catch (CannotResolveTenantNameException exception)
{
this.log.LogException(exception, "Failed to find Office365 connection settings for email address {0}. No tenant exists with domain name: ", new object[]
{
email,
email.Domain
});
}
});
if (connectionSettings != null)
{
this.log.LogOperationResult(ConnectionSettingsDiscoveryMetadata.Office365ConnectionSettingsFound, email.Domain, true);
yield return(new ConnectionSettings(this, connectionSettings, null));
}
this.log.LogOperationResult(ConnectionSettingsDiscoveryMetadata.Office365ConnectionSettingsFound, email.Domain, false);
yield break;
}
internal override bool OnApprove(MessageItem message)
{
AutoGroupApplication.diag.TraceFunction((long)this.GetHashCode(), "AutoGroupApplication.OnApprove");
message.Load(new PropertyDefinition[]
{
MessageItemSchema.ReceivedBy,
MessageItemSchema.ApprovalDecisionMaker,
MessageItemSchema.ApprovalRequestor,
MessageItemSchema.ApprovalAllowedDecisionMakers,
MessageItemSchema.ApprovalApplicationData
});
CultureInfo cultureInfo = null;
CultureInfo messageCulture = null;
string arg;
SmtpAddress smtpAddress;
SmtpAddress smtpAddress2;
SmtpAddress[] array;
if (!AutoGroupApplication.GetItemRecipients(message, out arg, out smtpAddress, out smtpAddress2, out array))
{
AutoGroupApplication.diag.TraceError <string, SmtpAddress, SmtpAddress>((long)this.GetHashCode(), "'{0}' message has invalid approver '{1}', requester '{2}', or empty moderators list.", arg, smtpAddress, smtpAddress2);
return(false);
}
SmtpAddress emailAddressFromMailboxItem = AutoGroupApplication.GetEmailAddressFromMailboxItem(message);
if (emailAddressFromMailboxItem == SmtpAddress.Empty)
{
AutoGroupApplication.diag.TraceError <string>((long)this.GetHashCode(), "'{0}' cannot get arbitration mailbox SMTP address from message.", arg);
return(false);
}
string valueOrDefault = message.GetValueOrDefault <string>(MessageItemSchema.ApprovalApplicationData);
string text;
ADObjectId adobjectId;
if (string.IsNullOrEmpty(valueOrDefault) || !AutoGroupApplication.ParseApprovalData(valueOrDefault, out text, out adobjectId))
{
AutoGroupApplication.diag.TraceError <string, string>((long)this.GetHashCode(), "'{0}' applicationData '{1}' cannot be parsed", arg, valueOrDefault);
return(false);
}
IRecipientSession recipientSession = ApprovalProcessor.CreateRecipientSessionFromSmtpAddress(smtpAddress);
ADRawEntry adrawEntry = null;
bool flag = true;
try
{
adrawEntry = recipientSession.FindByProxyAddress(new SmtpProxyAddress(smtpAddress.ToString(), true), new PropertyDefinition[]
{
ADObjectSchema.Id,
ADUserSchema.Languages
});
}
catch (NonUniqueRecipientException)
{
flag = false;
}
ADRawEntry adrawEntry2 = null;
bool flag2 = true;
try
{
adrawEntry2 = recipientSession.FindByProxyAddress(new SmtpProxyAddress(smtpAddress2.ToString(), true), new PropertyDefinition[]
{
ADObjectSchema.Id,
ADRecipientSchema.PrimarySmtpAddress,
ADUserSchema.Languages
});
}
catch (NonUniqueRecipientException)
{
flag2 = false;
}
MiniRecipient miniRecipient = recipientSession.ReadMiniRecipient(adobjectId, null);
if (miniRecipient == null)
{
AutoGroupApplication.diag.TraceError <string, ADObjectId>((long)this.GetHashCode(), "'{0}' group '{1}' not found in AD.", arg, adobjectId);
return(false);
}
string group;
if (string.IsNullOrEmpty(miniRecipient.DisplayName))
{
group = miniRecipient.Name;
}
else
{
group = miniRecipient.DisplayName;
}
if (adrawEntry == null)
{
if (flag)
{
AutoGroupApplication.diag.TraceError <string, SmtpAddress>((long)this.GetHashCode(), "'{0}' approver '{1}' not found in AD.", arg, smtpAddress);
}
else
{
AutoGroupApplication.diag.TraceError <string, SmtpAddress>((long)this.GetHashCode(), "'{0}' approver '{1}' not unique in AD.", arg, smtpAddress);
}
ApprovalProcessor.SendNotification(emailAddressFromMailboxItem, message.Id.ObjectId, new SmtpAddress[]
{
smtpAddress
}, Strings.AutoGroupRequestFailedSubject(group), Strings.AutoGroupRequestFailedHeader(group), Strings.AutoGroupRequestFailedBodyBadApprover(group, ApprovalProcessor.GetDisplayNameFromSmtpAddress(smtpAddress2.ToString()), ApprovalProcessor.GetDisplayNameFromSmtpAddress(smtpAddress.ToString())), LocalizedString.Empty, null);
return(false);
}
MultiValuedProperty <CultureInfo> multiValuedProperty = (MultiValuedProperty <CultureInfo>)adrawEntry[ADUserSchema.Languages];
if (multiValuedProperty.Count > 0)
{
cultureInfo = multiValuedProperty[0];
}
if (adrawEntry2 == null)
{
if (flag2)
{
AutoGroupApplication.diag.TraceError <string, SmtpAddress>((long)this.GetHashCode(), "'{0}' requester '{1}' not found in AD.", arg, smtpAddress2);
}
else
{
AutoGroupApplication.diag.TraceError <string, SmtpAddress>((long)this.GetHashCode(), "'{0}' requester '{1}' not unique in AD.", arg, smtpAddress2);
}
ApprovalProcessor.SendNotification(emailAddressFromMailboxItem, message.Id.ObjectId, new SmtpAddress[]
{
smtpAddress
}, Strings.AutoGroupRequestFailedSubject(group), Strings.AutoGroupRequestFailedHeader(group), Strings.AutoGroupRequestFailedBodyBadRequester(group, ApprovalProcessor.GetDisplayNameFromSmtpAddress(smtpAddress2.ToString())), LocalizedString.Empty, cultureInfo);
return(false);
}
MultiValuedProperty <CultureInfo> multiValuedProperty2 = (MultiValuedProperty <CultureInfo>)adrawEntry2[ADUserSchema.Languages];
if (multiValuedProperty2.Count > 0)
{
messageCulture = multiValuedProperty2[0];
}
bool flag3 = false;
string a;
if ((a = text) != null)
{
if (!(a == "Add-DistributionGroupMember"))
{
if (!(a == "Remove-DistributionGroupMember"))
{
goto IL_393;
}
flag3 = true;
}
PSCommand pscommand = new PSCommand().AddCommand(text);
pscommand.AddParameter("Identity", adobjectId);
pscommand.AddParameter("Member", adrawEntry2.Id);
if (flag3)
{
pscommand.AddParameter("Confirm", new SwitchParameter(false));
}
AutoGroupApplication.diag.Information <string, string>((long)this.GetHashCode(), "'{0}' executing command '{1}'.", arg, pscommand.ToString());
string text2;
string text3;
ApprovalApplication.ExecuteCommandsInRunspace(smtpAddress, pscommand, cultureInfo, out text2, out text3);
if (!text2.Equals(string.Empty))
{
AutoGroupApplication.diag.TraceError <string, string, string>((long)this.GetHashCode(), "'{0}' command '{1}' failed with error {2}.", arg, pscommand.ToString(), text2);
ApprovalProcessor.SendNotification(emailAddressFromMailboxItem, message.Id.ObjectId, new SmtpAddress[]
{
smtpAddress
}, Strings.AutoGroupRequestFailedSubject(group), Strings.AutoGroupRequestFailedHeader(group), Strings.AutoGroupRequestFailedBodyTaskError(text2), LocalizedString.Empty, cultureInfo);
return(false);
}
AutoGroupApplication.diag.Information <string, string>((long)this.GetHashCode(), "'{0}' command '{1}' completed successfully.", arg, pscommand.ToString());
ApprovalProcessor.SendApproveNotification(emailAddressFromMailboxItem, message.Id.ObjectId, new SmtpAddress[]
{
(SmtpAddress)adrawEntry2[ADRecipientSchema.PrimarySmtpAddress]
}, Strings.AutoGroupRequestApprovedSubject(group), Strings.AutoGroupRequestApprovedHeader(ApprovalProcessor.GetDisplayNameFromSmtpAddress(smtpAddress.ToString()), group), Strings.AutoGroupRequestApprovedBody, LocalizedString.Empty, messageCulture);
return(true);
}
IL_393:
AutoGroupApplication.diag.TraceError <string, string>((long)this.GetHashCode(), "'{0}' command '{1}' not recognized.", arg, text);
return(false);
}
internal override bool OnExpire(MessageItem message, out bool sendUpdate)
{
AutoGroupApplication.diag.TraceFunction((long)this.GetHashCode(), "AutoGroupApplication.OnExpire");
sendUpdate = true;
message.Load(new PropertyDefinition[]
{
MessageItemSchema.ReceivedBy,
MessageItemSchema.ApprovalDecisionMaker,
MessageItemSchema.ApprovalRequestor,
MessageItemSchema.ApprovalAllowedDecisionMakers,
MessageItemSchema.ApprovalApplicationData
});
CultureInfo messageCulture = null;
string arg;
SmtpAddress arg2;
SmtpAddress smtpAddress;
SmtpAddress[] array;
if (!AutoGroupApplication.GetItemRecipients(message, out arg, out arg2, out smtpAddress, out array))
{
AutoGroupApplication.diag.TraceError <string, SmtpAddress, SmtpAddress>((long)this.GetHashCode(), "'{0}' message has invalid approver '{1}', requester '{2}', or empty moderators list.", arg, arg2, smtpAddress);
return(false);
}
SmtpAddress emailAddressFromMailboxItem = AutoGroupApplication.GetEmailAddressFromMailboxItem(message);
if (emailAddressFromMailboxItem == SmtpAddress.Empty)
{
AutoGroupApplication.diag.TraceError <string>((long)this.GetHashCode(), "'{0}' cannot get arbitration mailbox SMTP address from message.", arg);
return(false);
}
string valueOrDefault = message.GetValueOrDefault <string>(MessageItemSchema.ApprovalApplicationData);
string text;
ADObjectId adobjectId;
if (string.IsNullOrEmpty(valueOrDefault) || !AutoGroupApplication.ParseApprovalData(valueOrDefault, out text, out adobjectId))
{
AutoGroupApplication.diag.TraceError <string, string>((long)this.GetHashCode(), "'{0}' applicationData '{1}' cannot be parsed", arg, valueOrDefault);
return(false);
}
IRecipientSession recipientSession = ApprovalProcessor.CreateRecipientSessionFromSmtpAddress(smtpAddress);
MiniRecipient miniRecipient = recipientSession.ReadMiniRecipient(adobjectId, null);
if (miniRecipient == null)
{
AutoGroupApplication.diag.TraceError <string, ADObjectId>((long)this.GetHashCode(), "'{0}' group '{1}' not found in AD.", arg, adobjectId);
return(false);
}
string group;
if (string.IsNullOrEmpty(miniRecipient.DisplayName))
{
group = miniRecipient.Name;
}
else
{
group = miniRecipient.DisplayName;
}
ADRawEntry adrawEntry = recipientSession.FindByProxyAddress(new SmtpProxyAddress(smtpAddress.ToString(), true), new PropertyDefinition[]
{
ADObjectSchema.Id,
ADUserSchema.Languages
});
if (adrawEntry != null)
{
MultiValuedProperty <CultureInfo> multiValuedProperty = (MultiValuedProperty <CultureInfo>)adrawEntry[ADUserSchema.Languages];
if (multiValuedProperty.Count > 0)
{
messageCulture = multiValuedProperty[0];
}
}
ApprovalProcessor.SendNotification(emailAddressFromMailboxItem, message.Id.ObjectId, new SmtpAddress[]
{
smtpAddress
}, Strings.AutoGroupRequestExpiredSubject(group), Strings.AutoGroupRequestExpiredBody(group), LocalizedString.Empty, LocalizedString.Empty, messageCulture);
return(true);
}
