// Token: 0x06001BF9 RID: 7161 RVA: 0x0006D354 File Offset: 0x0006B554
private static void AddDLMembersToResults(List <string> results, ADRecipientExpansion expansion, string dlSmtpAddress)
{
ADRawEntry adrawEntryFromSmtpAddress = UpdateAttachmentPermissions.GetADRawEntryFromSmtpAddress(dlSmtpAddress);
if (adrawEntryFromSmtpAddress != null)
{
new List <ADRawEntry>();
ADRecipientExpansion.HandleRecipientDelegate handleRecipient = delegate(ADRawEntry recipient, ExpansionType recipientExpansionType, ADRawEntry parent, ExpansionType parentExpansionType)
{
if (recipientExpansionType == ExpansionType.GroupMembership)
{
return(ExpansionControl.Continue);
}
string item = recipient[ADRecipientSchema.PrimarySmtpAddress].ToString();
if (!results.Contains(item))
{
results.Add(item);
}
return(ExpansionControl.Skip);
};
expansion.Expand(adrawEntryFromSmtpAddress, handleRecipient, null);
return;
}
ExTraceGlobals.AttachmentHandlingTracer.TraceError(0L, "[UpdateAttachmentPermissions : AddDLMembersToResults] Unable to get RawADEntry from SmtpAddress.");
}
private IEnumerable <ADObjectId> ExpandGroupMembers(IEnumerable <string> sourceLegacyDNs, OrganizationId organizationId, IList <string> notFoundMailboxes)
{
ADRecipientExpansion adrecipientExpansion = new ADRecipientExpansion(organizationId);
HashSet <ADObjectId> expandedMemberIds = new HashSet <ADObjectId>();
foreach (string text in sourceLegacyDNs)
{
this.CheckRecipientSessionIsNotNull();
ADRecipient adrecipient = this.recipientSession.FindByLegacyExchangeDN(text);
if (adrecipient == null)
{
notFoundMailboxes.Add(text);
}
else
{
adrecipientExpansion.Expand(adrecipient, delegate(ADRawEntry recipient, ExpansionType recipientExpansionType, ADRawEntry parent, ExpansionType parentType)
{
if (recipientExpansionType == ExpansionType.GroupMembership)
{
return(ExpansionControl.Continue);
}
if (((RecipientType)recipient[ADRecipientSchema.RecipientType] == RecipientType.UserMailbox || (RecipientTypeDetails)recipient[ADRecipientSchema.RecipientTypeDetails] == (RecipientTypeDetails)((ulong)-2147483648) || (RecipientTypeDetails)recipient[ADRecipientSchema.RecipientTypeDetails] == RecipientTypeDetails.RemoteRoomMailbox || (RecipientTypeDetails)recipient[ADRecipientSchema.RecipientTypeDetails] == RecipientTypeDetails.RemoteEquipmentMailbox || (RecipientTypeDetails)recipient[ADRecipientSchema.RecipientTypeDetails] == RecipientTypeDetails.RemoteTeamMailbox || (RecipientTypeDetails)recipient[ADRecipientSchema.RecipientTypeDetails] == RecipientTypeDetails.RemoteSharedMailbox) && !expandedMemberIds.Contains(recipient.Id))
{
expandedMemberIds.Add(recipient.Id);
}
return(ExpansionControl.Skip);
}, delegate(ExpansionFailure expansionFailure, ADRawEntry recipient, ExpansionType recipientExpansionType, ADRawEntry parent, ExpansionType parentExpansionType)
{
Util.Tracer.TraceDebug <ADObjectId, ExpansionType>((long)this.GetHashCode(), "Expand group member failed for {0}, reason {1}", recipient.Id, recipientExpansionType);
return(ExpansionControl.Skip);
});
}
}
return(expandedMemberIds);
}
public DLExpansionHandler(Participant organizerParticipant, Dictionary <ADObjectId, UserObject> individualAttendees, HashSet <ADObjectId> allVisitedAttendees, int expandedDLCount, Attendee attendee, ADRawEntry attendeeRawEntry, IRecipientSession session, ADRecipientExpansion expansionManager)
{
this.OrganizerParticipant = organizerParticipant;
this.IndividualAttendees = individualAttendees;
this.AllVisitedAttendees = allVisitedAttendees;
this.ExpandedDLCount = expandedDLCount;
this.Attendee = attendee;
this.AttendeeRawEntry = attendeeRawEntry;
this.Session = session;
this.ExpansionManager = expansionManager;
}
// Token: 0x06001BF8 RID: 7160 RVA: 0x0006D088 File Offset: 0x0006B288
private static string[] ExpandDLsAndGetAllUsers(UserContext userContext, string[] userIds, out List <string> largeDLsList, CallContext callContext)
{
List <string> list = new List <string>(userIds);
largeDLsList = new List <string>();
Stopwatch stopwatch = Stopwatch.StartNew();
GetMailTipsResponseMessage mailTipsForUsers = UpdateAttachmentPermissions.GetMailTipsForUsers(userContext, userIds);
stopwatch.Stop();
callContext.ProtocolLog.Set(UpdateAttachmentPermissionsMetadata.GetMailTipsTime, stopwatch.ElapsedMilliseconds);
if (mailTipsForUsers.ResponseMessages != null && mailTipsForUsers.ResponseMessages.Length > 0)
{
stopwatch = Stopwatch.StartNew();
int num = 0;
int num2 = 0;
int num3 = 0;
int num4 = int.MaxValue;
int num5 = 0;
ADRecipientExpansion expansion = new ADRecipientExpansion(userContext.ExchangePrincipal.MailboxInfo.OrganizationId);
foreach (MailTipsResponseMessage mailTipsResponseMessage in mailTipsForUsers.ResponseMessages)
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(mailTipsResponseMessage.MailTips.OuterXml);
XmlNode xmlNode = xmlDocument.SelectSingleNode("//*[local-name()=\"EmailAddress\"]");
XmlNode xmlNode2 = xmlDocument.SelectSingleNode("//*[local-name()=\"TotalMemberCount\"]");
if (xmlNode2 != null && !string.IsNullOrEmpty(xmlNode2.InnerText) && xmlNode != null && !string.IsNullOrEmpty(xmlNode.InnerText))
{
int num6 = int.Parse(xmlNode2.InnerText);
if (num6 != 1)
{
list.Remove(xmlNode.InnerText);
num++;
num3 += num6;
if (num4 > num6)
{
num4 = num6;
}
if (num5 < num6)
{
num5 = num6;
}
}
if (num6 > 1 && num6 <= 100)
{
UpdateAttachmentPermissions.AddDLMembersToResults(list, expansion, xmlNode.InnerText);
}
else if (num6 > 100)
{
largeDLsList.Add(xmlNode.InnerText);
ExTraceGlobals.AttachmentHandlingTracer.TraceError <string, int>(0L, "[UpdateAttachmentPermissions : ExpandDLsAndGetAllUsers] size of DL {0} was {1}, not setting permissions.", xmlNode.InnerText, num6);
num2++;
}
}
else
{
ExTraceGlobals.AttachmentHandlingTracer.TraceError(0L, "[UpdateAttachmentPermissions : ExpandDLsAndGetAllUsers] Error parsing GetMailTips response.");
}
}
stopwatch.Stop();
callContext.ProtocolLog.Set(UpdateAttachmentPermissionsMetadata.DLExpandTime, stopwatch.ElapsedMilliseconds);
callContext.ProtocolLog.Set(UpdateAttachmentPermissionsMetadata.NumberOfDLs, num);
if (num > 0)
{
callContext.ProtocolLog.Set(UpdateAttachmentPermissionsMetadata.NumberOfLargeDLs, num2);
callContext.ProtocolLog.Set(UpdateAttachmentPermissionsMetadata.NumberOfRecipientsInDLs, num3);
callContext.ProtocolLog.Set(UpdateAttachmentPermissionsMetadata.NumberOfRecipientsInSmallestDL, num4);
callContext.ProtocolLog.Set(UpdateAttachmentPermissionsMetadata.NumberOfRecipientsInLargestDL, num5);
}
}
else
{
ExTraceGlobals.AttachmentHandlingTracer.TraceError(0L, "[UpdateAttachmentPermissions : ExpandDLsAndGetAllUsers] GetMailTips response was empty.");
}
return(list.ToArray());
}
private bool IsGroupEmpty(ADGroup group)
{
if (group.Members.Count == 0)
{
if (!this.expandedRoleGroups.ContainsKey(group.Id))
{
this.expandedRoleGroups.Add(group.Id, 0);
}
return(true);
}
if (this.expandedRoleGroups.ContainsKey(group.Id))
{
return(this.expandedRoleGroups[group.Id] == 0);
}
int numberOfUsers = 0;
ADRecipientExpansion adrecipientExpansion = new ADRecipientExpansion(this.recipientSession, true);
adrecipientExpansion.Expand(group, delegate(ADRawEntry recipient, ExpansionType recipientExpansionType, ADRawEntry parent, ExpansionType parentExpansionType)
{
if (group.Id.Equals(recipient.Id))
{
return(ExpansionControl.Continue);
}
if (this.excludedFromEmptinessValidation != null && this.excludedFromEmptinessValidation.Contains(recipient.Id) && (this.isObjectRemovalValidation || (parent != null && parent.Id.Equals(group.Id))))
{
return(ExpansionControl.Skip);
}
if (recipientExpansionType == ExpansionType.None)
{
if (this.includeOnlyPowerShellEnabledRecipients)
{
if (this.IsPowerShellEnabled(recipient.Id))
{
numberOfUsers++;
}
}
else
{
numberOfUsers++;
}
}
if (this.expandedRoleGroups.ContainsKey(recipient.Id))
{
numberOfUsers += this.expandedRoleGroups[recipient.Id];
if (numberOfUsers == 0)
{
return(ExpansionControl.Skip);
}
}
if (numberOfUsers > 0)
{
return(ExpansionControl.Terminate);
}
return(ExpansionControl.Continue);
}, delegate(ExpansionFailure failure, ADRawEntry recipient, ExpansionType recipientExpansionType, ADRawEntry parent, ExpansionType parentExpansionType)
{
if (failure.Equals(ExpansionFailure.NoMembers))
{
return(ExpansionControl.Continue);
}
return(ExpansionControl.Skip);
});
this.expandedRoleGroups.Add(group.Id, numberOfUsers);
return(numberOfUsers == 0);
}
public IEnumerable <SearchRecipient> Query(ISearchPolicy policy, DirectoryQueryParameters request)
{
Recorder.Trace(5L, TraceType.InfoTrace, new object[]
{
"ActiveDirectoryProvider.Query Query:",
request.Query,
"PageSize:",
request.PageSize,
"Properties:",
request.Properties,
"ExpandGroups:",
request.ExpandGroups
});
ADPagedReader <ADRawEntry> pagedReader = policy.RecipientSession.FindPagedADRawEntry(null, QueryScope.SubTree, request.Query, null, request.PageSize, request.Properties);
new List <SearchRecipient>();
foreach (ADRawEntry entry in pagedReader)
{
if (request.ExpandGroups && SearchRecipient.IsMembershipGroup(entry))
{
Recorder.Trace(5L, TraceType.InfoTrace, "ActiveDirectoryProvider.Query Expanding:", entry);
List <ADRawEntry> groupEntries = new List <ADRawEntry>();
ADRecipientExpansion expansion = new ADRecipientExpansion(policy.RecipientSession, false, request.Properties);
ADRecipientExpansion.HandleRecipientDelegate handleDelegate = delegate(ADRawEntry recipient, ExpansionType recipientExpansionType, ADRawEntry parent, ExpansionType parentExpansionType)
{
if (recipientExpansionType == ExpansionType.GroupMembership)
{
return(ExpansionControl.Continue);
}
groupEntries.Add(recipient);
return(ExpansionControl.Skip);
};
ADRecipientExpansion.HandleFailureDelegate failureDelegate = delegate(ExpansionFailure expansionFailure, ADRawEntry recipient, ExpansionType recipientExpansionType, ADRawEntry parent, ExpansionType parentExpansionType)
{
Recorder.Trace(5L, TraceType.ErrorTrace, new object[]
{
"ActiveDirectoryProvider.Query Expansion Failed:",
recipient,
"Error:",
expansionFailure,
"ExpansionType:",
recipientExpansionType,
"Parent:",
parent,
"ParentyExpansionType:",
parentExpansionType
});
return(ExpansionControl.Skip);
};
expansion.Expand(entry, handleDelegate, failureDelegate);
foreach (ADRawEntry groupEntry in groupEntries)
{
yield return(new SearchRecipient(groupEntry, entry));
}
}
else
{
yield return(new SearchRecipient(entry, null));
}
}
yield break;
}
public ADDistributionListExpansion(CertificateManager manager, ADRecipientExpansion adrecipientExpansion)
{
this.manager = manager;
this.adrecipientExpansion = adrecipientExpansion;
}
// Token: 0x0600167E RID: 5758 RVA: 0x0007F8A0 File Offset: 0x0007DAA0
private List <RecipientToIndex> ExpandGroupMemberRecipients(MessageItem messageItem, List <ADRecipient> groupRecipients, RecipientItemType recipientType, out DistributionGroupExpansionError errorCode)
{
errorCode = DistributionGroupExpansionError.NoError;
DistributionGroupExpansionError tempErrorCode = errorCode;
List <RecipientToIndex> finalExpansionList = new List <RecipientToIndex>();
List <ADRecipient> list = new List <ADRecipient>(groupRecipients.Count);
foreach (ADRecipient adrecipient in groupRecipients)
{
OrganizationId organizationId = messageItem.Session.MailboxOwner.MailboxInfo.OrganizationId;
string uniqueLookupKey = RecipientDLExpansionCache.GetUniqueLookupKey(organizationId, adrecipient);
RecipientDLExpansionEventBasedAssistant.Tracer.TraceDebug <string>((long)this.GetHashCode(), "Get recipients list from the cache for lookup key: {0}", uniqueLookupKey);
List <RecipientToIndex> perRecipientExpansionList = RecipientDLExpansionCache.Instance.Get(uniqueLookupKey);
if (perRecipientExpansionList != null)
{
RecipientDLExpansionEventBasedAssistant.Tracer.TraceDebug <string>((long)this.GetHashCode(), "The recipients list exists in the cache for lookup key: {0}", uniqueLookupKey);
if (!this.AddPerRecipientListToFinalExpansionList(messageItem, perRecipientExpansionList, finalExpansionList, recipientType, out tempErrorCode))
{
break;
}
list.Add(adrecipient);
}
else
{
RecipientDLExpansionEventBasedAssistant.Tracer.TraceDebug((long)this.GetHashCode(), "Message with id: {0} and subject: '{1}' has recipient '{2}' which is not in the cache (with lookup key: {3}), hence need to make AD call.", new object[]
{
messageItem.StoreObjectId,
messageItem.Subject,
adrecipient.DisplayName,
uniqueLookupKey
});
perRecipientExpansionList = new List <RecipientToIndex>();
int numOfGroups = 0;
ADRecipientExpansion adrecipientExpansion = new ADRecipientExpansion(RecipientDLExpansionEventBasedAssistant.RecipientProperties, organizationId);
adrecipientExpansion.Expand(adrecipient, delegate(ADRawEntry recipient, ExpansionType recipientExpansionType, ADRawEntry parent, ExpansionType parentType)
{
if (recipientExpansionType == ExpansionType.GroupMembership)
{
if ((long)numOfGroups++ >= (long)((ulong)this.maxExpansionNestedDGs))
{
if (recipientType == RecipientItemType.Cc)
{
tempErrorCode = DistributionGroupExpansionError.CcGroupExpansionHitDepthsLimit;
}
else if (recipientType == RecipientItemType.Bcc)
{
tempErrorCode = DistributionGroupExpansionError.BccGroupExpansionHitDepthsLimit;
}
else
{
tempErrorCode = DistributionGroupExpansionError.ToGroupExpansionHitDepthsLimit;
}
RecipientDLExpansionEventBasedAssistant.Tracer.TraceWarning((long)this.GetHashCode(), "DL expansion on message with id: {0}, mailbox guid: {1}, tenant: {2} is terminated because number of nested DLs ({3}) is greater than the limit ({4})", new object[]
{
messageItem.StoreObjectId,
messageItem.Session.MailboxGuid,
organizationId,
numOfGroups,
this.maxExpansionNestedDGs
});
StorageGlobals.EventLogger.LogEvent(StorageEventLogConstants.Tuple_RecipientDLExpansionMaxNestedDLsLimit, null, new object[]
{
this.maxExpansionNestedDGs,
messageItem.StoreObjectId,
messageItem.Session.MailboxGuid,
organizationId
});
DistributionGroupExpansionError distributionGroupExpansionError = DistributionGroupExpansionError.NoError;
this.AddRecipientToExpansionList(messageItem, recipient, perRecipientExpansionList, finalExpansionList, recipientType, out distributionGroupExpansionError);
if (distributionGroupExpansionError != DistributionGroupExpansionError.NoError)
{
tempErrorCode |= distributionGroupExpansionError;
}
return(ExpansionControl.Terminate);
}
RecipientDLExpansionPerfmon.TotalExpandedNestedDLs.Increment();
if (this.AddRecipientToExpansionList(messageItem, recipient, perRecipientExpansionList, finalExpansionList, recipientType, out tempErrorCode))
{
return(ExpansionControl.Continue);
}
return(ExpansionControl.Terminate);
}
else
{
if (!this.AddRecipientToExpansionList(messageItem, recipient, perRecipientExpansionList, finalExpansionList, recipientType, out tempErrorCode))
{
return(ExpansionControl.Terminate);
}
return(ExpansionControl.Skip);
}
}, delegate(ExpansionFailure expansionFailure, ADRawEntry recipient, ExpansionType recipientExpansionType, ADRawEntry parent, ExpansionType parentExpansionType)
{
if (recipientType == RecipientItemType.Cc)
{
tempErrorCode = DistributionGroupExpansionError.CcGroupExpansionFailed;
}
else if (recipientType == RecipientItemType.Bcc)
{
tempErrorCode = DistributionGroupExpansionError.BccGroupExpansionFailed;
}
else
{
tempErrorCode = DistributionGroupExpansionError.ToGroupExpansionFailed;
}
return(ExpansionControl.Skip);
});
errorCode = tempErrorCode;
if (tempErrorCode != DistributionGroupExpansionError.NoError)
{
RecipientDLExpansionEventBasedAssistant.Tracer.TraceDebug <string>((long)this.GetHashCode(), "Failed or partially success when performing the DG expansion: {0}", tempErrorCode.ToString());
break;
}
RecipientDLExpansionEventBasedAssistant.Tracer.TraceDebug <string>((long)this.GetHashCode(), "Add the recipients list to the cache for key: {0}", uniqueLookupKey);
RecipientDLExpansionCache.Instance.Add(uniqueLookupKey, perRecipientExpansionList);
list.Add(adrecipient);
}
}
if (list.Count != groupRecipients.Count)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendFormat("There are total of {0} group recipients, which only {1} of them successfully expanded.\r\n", groupRecipients.Count, list.Count);
StringBuilder stringBuilder2 = new StringBuilder();
stringBuilder.AppendLine("List of successful expanded group recipients:");
foreach (ADRecipient adrecipient2 in groupRecipients)
{
if (list.Contains(adrecipient2))
{
stringBuilder.AppendLine(adrecipient2.DisplayName);
}
else
{
stringBuilder2.AppendLine(adrecipient2.DisplayName);
}
}
stringBuilder.AppendLine("List of not successful expanded group recipients:");
stringBuilder.AppendLine(stringBuilder2.ToString());
RecipientDLExpansionEventBasedAssistant.Tracer.TraceWarning((long)this.GetHashCode(), stringBuilder.ToString());
if (!this.IsDLExpansionLimitError(errorCode))
{
StorageGlobals.EventLogger.LogEvent(StorageEventLogConstants.Tuple_RecipientDLExpansionMismatchResults, null, new object[]
{
messageItem.StoreObjectId,
messageItem.Session.MailboxGuid,
messageItem.Session.MailboxOwner.MailboxInfo.OrganizationId,
stringBuilder.ToString()
});
}
}
return(finalExpansionList);
}
internal static MultiValuedProperty <string> ConvertSourceMailboxesCollection(IEnumerable <RecipientIdParameter> recipientIds, bool inplaceHoldEnabled, Func <RecipientIdParameter, ADRecipient> recipientGetter, IRecipientSession recipientSession, Task.TaskErrorLoggingDelegate writeErrorDelegate, Action <LocalizedString> writeWarningDelegate, Func <LocalizedString, bool> shouldContinueDelegate)
{
MultiValuedProperty <string> results = null;
if (recipientIds != null)
{
RecipientType[] source = new RecipientType[]
{
RecipientType.UserMailbox,
RecipientType.Group,
RecipientType.MailUniversalDistributionGroup,
RecipientType.MailUniversalSecurityGroup,
RecipientType.MailNonUniversalGroup,
RecipientType.DynamicDistributionGroup
};
bool flag = false;
foreach (RecipientIdParameter arg in recipientIds)
{
if (results == null)
{
results = new MultiValuedProperty <string>();
}
ADRecipient adrecipient = recipientGetter(arg);
string text = null;
ADSessionSettings sessionSettings = adrecipient.OrganizationId.ToADSessionSettings();
if (Utils.IsPublicFolderMailbox(adrecipient))
{
writeErrorDelegate(new MailboxSearchTaskException(Strings.ErrorInvalidRecipientTypeDetails(adrecipient.ToString())), ErrorCategory.InvalidArgument, null);
}
else if (Utils.IsValidMailboxType(adrecipient))
{
if (adrecipient.ExchangeVersion.IsOlderThan(ExchangeObjectVersion.Exchange2012) && !RemoteMailbox.IsRemoteMailbox(adrecipient.RecipientTypeDetails) && ExchangePrincipal.FromADUser(sessionSettings, (ADUser)adrecipient, RemotingOptions.AllowCrossSite).MailboxInfo.Location.ServerVersion < Server.E15MinVersion)
{
writeErrorDelegate(new MailboxSearchTaskException(Strings.SourceMailboxMustBeE15OrLater(adrecipient.DisplayName)), ErrorCategory.InvalidArgument, null);
}
text = adrecipient.LegacyExchangeDN;
}
else if (source.Contains(adrecipient.RecipientType))
{
if (inplaceHoldEnabled)
{
if (!flag)
{
if (shouldContinueDelegate(Strings.ShouldContinueToExpandGroupsForHold))
{
flag = true;
}
else
{
writeErrorDelegate(new MailboxSearchTaskException(Strings.GroupsIsNotAllowedForHold(adrecipient.DisplayName)), ErrorCategory.InvalidArgument, null);
}
}
bool invalidTypeSkipped = false;
bool oldVersionMailboxSkipped = false;
ADRecipientExpansion adrecipientExpansion = new ADRecipientExpansion(new PropertyDefinition[]
{
ADRecipientSchema.LegacyExchangeDN,
ADRecipientSchema.RecipientTypeDetailsValue,
ADObjectSchema.ExchangeVersion
}, adrecipient.OrganizationId);
adrecipientExpansion.Expand(adrecipient, delegate(ADRawEntry expandedRecipient, ExpansionType expansionType, ADRawEntry parent, ExpansionType parentType)
{
if (expansionType == ExpansionType.GroupMembership)
{
return(ExpansionControl.Continue);
}
if (Utils.IsValidMailboxType(expandedRecipient))
{
ExchangeObjectVersion exchangeObjectVersion = (ExchangeObjectVersion)expandedRecipient[ADObjectSchema.ExchangeVersion];
string text2 = (string)expandedRecipient[ADRecipientSchema.LegacyExchangeDN];
if (!oldVersionMailboxSkipped && exchangeObjectVersion.IsOlderThan(ExchangeObjectVersion.Exchange2012) && !RemoteMailbox.IsRemoteMailbox((RecipientTypeDetails)expandedRecipient[ADRecipientSchema.RecipientTypeDetails]) && ExchangePrincipal.FromLegacyDN(sessionSettings, text2).MailboxInfo.Location.ServerVersion < Server.E15MinVersion)
{
oldVersionMailboxSkipped = true;
writeWarningDelegate(Strings.OldVersionMailboxSkipped);
}
if (!results.Contains(text2))
{
results.Add(text2);
}
}
else if (!invalidTypeSkipped)
{
invalidTypeSkipped = true;
writeWarningDelegate(Strings.SkippingInvalidTypeInGroupExpansion);
}
return(ExpansionControl.Skip);
}, delegate(ExpansionFailure failure, ADRawEntry expandedRecipient, ExpansionType expansionType, ADRawEntry parent, ExpansionType parentType)
{
TaskLogger.Trace("Skipping invalid AD entry {0} because of failure: {1}", new object[]
{
expandedRecipient,
failure
});
return(ExpansionControl.Skip);
});
}
else
{
text = adrecipient.LegacyExchangeDN;
}
}
else
{
writeErrorDelegate(new MailboxSearchTaskException(Strings.ErrorInvalidRecipientType(adrecipient.ToString(), adrecipient.RecipientType.ToString())), ErrorCategory.InvalidArgument, null);
}
if (text != null && !results.Contains(text))
{
results.Add(text);
}
if (results.Count > Utils.MaxNumberOfMailboxesInSingleHold)
{
writeErrorDelegate(new MailboxSearchTaskException(Strings.ErrorTooManyMailboxesInSingleHold(Utils.MaxNumberOfMailboxesInSingleHold)), ErrorCategory.InvalidArgument, null);
}
}
if (results != null)
{
uint discoveryMaxMailboxes = SearchUtils.GetDiscoveryMaxMailboxes(recipientSession);
if ((long)results.Count > (long)((ulong)discoveryMaxMailboxes) && !shouldContinueDelegate(Strings.ShouldContinueMoreMailboxesThanMaxSearch(results.Count, discoveryMaxMailboxes)))
{
writeErrorDelegate(new MailboxSearchTaskException(Strings.ErrorTaskCancelledBecauseMoreMailboxesThanSearchSupported), ErrorCategory.InvalidArgument, null);
}
}
}
return(results);
}
// Token: 0x0600108A RID: 4234 RVA: 0x00060890 File Offset: 0x0005EA90
internal void GetMetricsForSingleGroup(IRecipientSession session, string groupDN, TypedHashSet calculatedGroups, Dictionary <string, object> parentGroupDictionary, IList <string> parentGroupList)
{
ADObjectId id = new ADObjectId(groupDN);
ADRawEntry group = null;
ADOperationResult adoperationResult = this.TryRunPerGroupADOperation(delegate
{
group = session.ReadADRawEntry(id, GroupMetricsGenerator.groupProperties);
}, groupDN);
if (!adoperationResult.Succeeded || group == null)
{
return;
}
ulong hash = GroupMetricsUtility.GetHash(group.Id.ObjectGuid);
if (calculatedGroups.Contains(hash))
{
return;
}
int externalMemberCount = 0;
HashSet <ulong> allMemberHashes = new HashSet <ulong>(2000);
ADRecipientExpansion expander = new ADRecipientExpansion(session, false);
adoperationResult = this.TryRunPerGroupADOperation(delegate
{
if (GroupMetricsUtility.Fault == GroupMetricsFault.TransientExceptionInExpansion)
{
throw new ADTransientException(new LocalizedString("Fault Injection"));
}
if (GroupMetricsUtility.Fault == GroupMetricsFault.InvalidCredentialExceptionInExpansion)
{
throw new ADInvalidCredentialException(new LocalizedString("Fault Injection"));
}
if (GroupMetricsUtility.Fault == GroupMetricsFault.PermanentExceptionInExpansion)
{
throw new DataSourceOperationException(new LocalizedString("Fault Injection"));
}
expander.Expand(group, delegate(ADRawEntry member, ExpansionType recipientExpansionType, ADRawEntry parent, ExpansionType parentExpansionType)
{
this.RunData.ThrowIfShuttingDown();
if (recipientExpansionType == ExpansionType.GroupMembership)
{
return(ExpansionControl.Continue);
}
ulong hash2 = GroupMetricsUtility.GetHash(member.Id.ObjectGuid);
if (allMemberHashes.TryAdd(hash2) && this.IsExternal(member))
{
externalMemberCount++;
}
if (allMemberHashes.Count >= 1000)
{
return(ExpansionControl.Terminate);
}
if (recipientExpansionType != ExpansionType.None)
{
return(ExpansionControl.Skip);
}
return(ExpansionControl.Continue);
}, (ExpansionFailure failure, ADRawEntry member, ExpansionType recipientExpansionType, ADRawEntry parent, ExpansionType parentExpansionType) => ExpansionControl.Continue);
}, groupDN);
if (!adoperationResult.Succeeded)
{
return;
}
MultiValuedProperty <ADObjectId> multiValuedProperty = group[ADRecipientSchema.MemberOfGroup] as MultiValuedProperty <ADObjectId>;
foreach (ADObjectId adobjectId in multiValuedProperty)
{
string distinguishedName = adobjectId.DistinguishedName;
if (!parentGroupDictionary.ContainsKey(distinguishedName))
{
parentGroupDictionary.Add(distinguishedName, null);
parentGroupList.Add(distinguishedName);
}
}
int count = allMemberHashes.Count;
calculatedGroups.Add(hash);
this.groupsExpanded++;
int oldValue = (int)group[ADGroupSchema.GroupMemberCount];
int oldValue2 = (int)group[ADGroupSchema.GroupExternalMemberCount];
if (this.ShouldSaveToAD(oldValue, count) || this.ShouldSaveToAD(oldValue2, externalMemberCount))
{
this.SaveGroupMetricsToAD(session, group, count, externalMemberCount);
}
}
