internal IList <RecipientData> Query(string recipientSmtpAddress, ADObjectId recipientAdObjectId)
{
if (!string.IsNullOrEmpty(recipientSmtpAddress) && SmtpAddress.IsValidSmtpAddress(recipientSmtpAddress))
{
RecipientQueryResults recipientQueryResults = base.Query(new EmailAddress[]
{
new EmailAddress(string.Empty, recipientSmtpAddress)
});
if (recipientQueryResults != null && recipientQueryResults.Count > 0 && recipientQueryResults[0].Exception == null && recipientQueryResults[0].ProviderError == null)
{
return(recipientQueryResults);
}
}
if (recipientAdObjectId != null)
{
ADRecipient adrecipient = base.ADRecipientSession.Read(recipientAdObjectId);
if (adrecipient != null)
{
EmailAddress emailAddress = RecipientQuery.CreateEmailAddressFromADRecipient(adrecipient);
return(new RecipientData[]
{
RecipientData.Create(emailAddress, adrecipient, UserPhotoRecipientQuery.RecipientProperties)
});
}
}
this.tracer.TraceDebug <string, ADObjectId>((long)this.GetHashCode(), "Target user not found in directory. Search params were SMTP-address='{0}' OR ADObjectId='{1}'", recipientSmtpAddress, recipientAdObjectId);
return(Array <RecipientData> .Empty);
}
private IEnumerable <RecipientData> ProcessResults(EmailAddress[] emailAddressArray, int startIndex, int size, Result <ADRawEntry>[] resultsArray, List <int> indexList)
{
for (int index = 0; index < size; index++)
{
int resultIndex = indexList.IndexOf(index);
if (-1 == resultIndex)
{
EmailAddress invalidAddress = emailAddressArray[startIndex + index];
yield return(RecipientData.Create(emailAddressArray[startIndex + index], new InvalidSmtpAddressException(Strings.descInvalidSmtpAddress((invalidAddress == null) ? "null" : invalidAddress.ToString()))));
}
else
{
Result <ADRawEntry> result = resultsArray[resultIndex];
if (result.Error == null)
{
yield return(RecipientData.Create(emailAddressArray[startIndex + index], result.Data, this.propertyDefinitionArray));
}
else
{
yield return(RecipientData.Create(emailAddressArray[startIndex + index], result.Error));
}
}
}
yield break;
}
public AutoDiscoverQueryItem(RecipientData recipientData, LocalizedString applicationName, BaseQuery sourceQuery)
{
this.EmailAddress = recipientData.EmailAddress;
this.initialEmailAddress = recipientData.EmailAddress;
this.recipientData = recipientData;
this.applicationName = applicationName;
this.sourceQuery = sourceQuery;
}
internal List <RecipientData> ExpandDistributionGroup(RecipientData recipientData, DateTime queryPrepareDeadline, out bool groupCapped)
{
List <RecipientData> list = new List <RecipientData>(Configuration.MaximumGroupMemberCount);
groupCapped = false;
int num = 0;
Queue <RecipientData> queue = new Queue <RecipientData>(Configuration.MaximumGroupMemberCount);
HashSet <Guid> hashSet = new HashSet <Guid>(Configuration.MaximumGroupMemberCount);
queue.Enqueue(recipientData);
hashSet.Add(recipientData.Guid);
while (queue.Count > 0 && !groupCapped)
{
RecipientData recipientData2 = queue.Dequeue();
QueryFilter filter = new ComparisonFilter(ComparisonOperator.Equal, ADRecipientSchema.MemberOfGroup, recipientData2.Id);
ADPagedReader <ADRecipient> adpagedReader = base.ADRecipientSession.FindPaged(null, QueryScope.SubTree, filter, null, Configuration.MaximumGroupMemberCount);
ExTraceGlobals.DistributionListHandlingTracer.TraceDebug <object, SmtpAddress, int>((long)this.GetHashCode(), "{0}: Expanding group {1}, which has {2} members.", TraceContext.Get(), recipientData.PrimarySmtpAddress, recipientData.DistributionGroupMembersCount);
foreach (ADRecipient adrecipient in adpagedReader)
{
if (DateTime.UtcNow > queryPrepareDeadline)
{
groupCapped = true;
break;
}
if (!hashSet.Contains(adrecipient.Guid))
{
hashSet.Add(adrecipient.Guid);
if (adrecipient is ADUser || adrecipient is ADContact)
{
if (list.Count >= Configuration.MaximumGroupMemberCount)
{
groupCapped = true;
break;
}
EmailAddress emailAddress = RecipientQuery.CreateEmailAddressFromADRecipient(adrecipient);
list.Add(RecipientData.Create(emailAddress, adrecipient, base.PropertyDefinitionArray));
}
else if (adrecipient is ADGroup)
{
EmailAddress emailAddress2 = RecipientQuery.CreateEmailAddressFromADRecipient(adrecipient);
ADGroup configurableObject = (ADGroup)adrecipient;
queue.Enqueue(RecipientData.Create(emailAddress2, configurableObject, base.PropertyDefinitionArray));
}
else
{
ExTraceGlobals.DistributionListHandlingTracer.TraceDebug <object, ADRecipient>((long)this.GetHashCode(), "{0}: Group member {1} is not a ADUser, ADContact or ADGroup. This member is not being processed.", TraceContext.Get(), adrecipient);
}
}
else
{
ExTraceGlobals.DistributionListHandlingTracer.TraceDebug <object, ADRecipient>((long)this.GetHashCode(), "{0}: Group member {1} has been found to be a duplicate and not being processed.", TraceContext.Get(), adrecipient);
num++;
}
}
}
return(list);
}
internal static RecipientData Create(EmailAddress emailAddress, ConfigurableObject configurableObject, ICollection <PropertyDefinition> propertyDefinitionCollection)
{
if (Testability.HandleSmtpAddressAsContact(emailAddress.Address))
{
return(RecipientData.CreateAsContact(emailAddress));
}
RecipientData recipientData = new RecipientData(emailAddress);
recipientData.ParseConfigurableObject(configurableObject, propertyDefinitionCollection);
return(recipientData);
}
internal static RecipientData Create(EmailAddress emailAddress, Dictionary <PropertyDefinition, object> propertyMap)
{
if (Testability.HandleSmtpAddressAsContact(emailAddress.Address))
{
return(RecipientData.CreateAsContact(emailAddress));
}
return(new RecipientData(emailAddress)
{
propertyMap = propertyMap
});
}
internal static RecipientData CreateAsContact(EmailAddress emailAddress)
{
RecipientData recipientData = new RecipientData(emailAddress);
SmtpProxyAddress value = new SmtpProxyAddress(emailAddress.Address, true);
recipientData.propertyMap = new Dictionary <PropertyDefinition, object>();
recipientData.propertyMap[ADRecipientSchema.RecipientType] = RecipientType.MailUser;
recipientData.propertyMap[ADRecipientSchema.ExternalEmailAddress] = value;
SmtpAddress smtpAddress = new SmtpAddress(emailAddress.Address);
recipientData.propertyMap[ADRecipientSchema.PrimarySmtpAddress] = smtpAddress;
return(recipientData);
}
internal RestrictionCheckResult CheckDeliveryRestriction(RecipientData senderData, RecipientData recipientData)
{
RestrictionCheckResult checkResult = RestrictionCheckResult.AcceptedNoPermissionList;
ADOperationResult adoperationResult = ADNotificationAdapter.TryRunADOperation(delegate()
{
checkResult = ADRecipientRestriction.CheckDeliveryRestriction(senderData.IsEmpty ? null : senderData.Id, true, recipientData.RejectMessagesFrom, recipientData.RejectMessagesFromDLMembers, recipientData.AcceptMessagesOnlyFrom, recipientData.AcceptMessagesOnlyFromDLMembers, recipientData.BypassModerationFrom, recipientData.BypassModerationFromDLMembers, recipientData.ModeratedBy, recipientData.ManagedBy, true, recipientData.ModerationEnabled, recipientData.RecipientType, this.ADRecipientSession, null, 150);
});
if (!adoperationResult.Succeeded)
{
recipientData.Exception = adoperationResult.Exception;
}
return(checkResult);
}
private AutoDiscoverResult GetResult(RecipientData recipientData, WebServiceUri webServiceUri)
{
if (!base.Application.IsVersionSupported(webServiceUri.ServerVersion))
{
AutoDiscoverQuery.AutoDiscoverTracer.TraceError <object, int, Type>((long)this.GetHashCode(), "{0}: Remote server version {1} is considered a legacy server by {2} application.", TraceContext.Get(), webServiceUri.ServerVersion, base.Application.GetType());
return(new AutoDiscoverResult(base.Application.CreateExceptionForUnsupportedVersion(recipientData, webServiceUri.ServerVersion)));
}
AutoDiscoverQuery.AutoDiscoverTracer.TraceDebug <object, Uri, EmailAddress>((long)this.GetHashCode(), "{0}: Found availability service {1} that can fill request for mailbox {2}", TraceContext.Get(), webServiceUri.Uri, (recipientData != null) ? recipientData.EmailAddress : null);
SerializedSecurityContext serializedSecurityContext = null;
InternalClientContext internalClientContext = base.ClientContext as InternalClientContext;
if (this.targetForestConfiguration.IsPerUserAuthorizationSupported && internalClientContext != null)
{
serializedSecurityContext = internalClientContext.SerializedSecurityContext;
}
ProxyAuthenticator proxyAuthenticatorForAutoDiscover = this.targetForestConfiguration.GetProxyAuthenticatorForAutoDiscover(webServiceUri.Uri, serializedSecurityContext, base.ClientContext.MessageId);
return(new AutoDiscoverResult(webServiceUri, proxyAuthenticatorForAutoDiscover));
}
public override BaseQuery CreateFromGroup(RecipientData recipientData, BaseQuery[] groupMembers, bool groupCapped)
{
bool flag = (this.queryType & QueryType.FreeBusy) != (QueryType)0;
bool flag2 = (this.queryType & QueryType.MeetingSuggestions) != (QueryType)0 && !groupCapped;
FreeBusyQuery[] groupMembersForFreeBusy = null;
FreeBusyQuery[] groupMembersForSuggestions = null;
if (flag)
{
if (groupCapped)
{
Application.ProxyWebRequestTracer.TraceDebug <object, RecipientData>((long)this.GetHashCode(), "{0}:Not generating requests for members of group {1} because the group is larger than the allowed group size.", TraceContext.Get(), recipientData);
return(FreeBusyQuery.CreateFromGroup(recipientData, new FreeBusyDLLimitReachedException(Configuration.MaximumGroupMemberCount)));
}
groupMembersForFreeBusy = FreeBusyApplication.ConvertBaseToFreeBusyQuery(groupMembers);
}
if (flag2)
{
groupMembersForSuggestions = FreeBusyApplication.ConvertBaseToFreeBusyQuery(groupMembers);
}
return(FreeBusyQuery.CreateFromGroup(recipientData, groupMembersForFreeBusy, groupMembersForSuggestions));
}
private IEnumerable <RecipientData> HandleErrorFromRecipientLookup(Exception e, EmailAddress[] emailAddressArray, int start, int length, uint locationIdentifier)
{
LocalizedException exception;
if (e is LocalizedException)
{
exception = (LocalizedException)e;
ErrorHandler.SetErrorCodeIfNecessary(exception, ErrorConstants.FreeBusyGenerationFailed);
}
else if (e is ADTimelimitExceededException)
{
exception = new TimeoutExpiredException("LookupRecipients:ADTimeLimit");
}
else
{
exception = new MailRecipientNotFoundException(e, locationIdentifier);
}
ExTraceGlobals.RequestRoutingTracer.TraceError <object, LocalizedException>((long)this.GetHashCode(), "{0}: Failed to lookup recipients in AD. Exception {1}", TraceContext.Get(), exception);
for (int i = 0; i < length; i++)
{
yield return(RecipientData.Create(emailAddressArray[start + i], exception));
}
yield break;
}
public abstract AvailabilityException CreateExceptionForUnsupportedVersion(RecipientData recipient, int serverVersion);
public override BaseQuery CreateFromGroup(RecipientData recipientData, BaseQuery[] groupMembers, bool groupCapped)
{
throw new NotImplementedException();
}
public override BaseQuery CreateFromIndividual(RecipientData recipientData, LocalizedException exception)
{
throw new NotImplementedException();
}
public override AvailabilityException CreateExceptionForUnsupportedVersion(RecipientData recipient, int serverVersion)
{
throw new NotImplementedException();
}
public abstract BaseQuery CreateFromGroup(RecipientData recipientData, BaseQuery[] groupMembers, bool groupCapped);
private FreeBusyQuery(RecipientData recipientData, AttendeeKind attendeeKind, FreeBusyQuery[] groupMembersForFreeBusy, FreeBusyQuery[] groupMembersForSuggestions) : base(recipientData, null)
{
this.attendeeKind = attendeeKind;
this.groupMembersForFreeBusy = groupMembersForFreeBusy;
this.groupMembersForSuggestions = groupMembersForSuggestions;
}
public override BaseQuery CreateFromIndividual(RecipientData recipientData)
{
return(FreeBusyQuery.CreateFromIndividual(recipientData));
}
public static FreeBusyQuery CreateFromGroup(RecipientData recipientData, FreeBusyQuery[] groupMembersForFreeBusy, FreeBusyQuery[] groupMembersForSuggestions)
{
return(new FreeBusyQuery(recipientData, AttendeeKind.Group, groupMembersForFreeBusy, groupMembersForSuggestions));
}
public static FreeBusyQuery CreateFromGroup(RecipientData recipientData, LocalizedException exception)
{
return(new FreeBusyQuery(recipientData, AttendeeKind.Group, new FreeBusyQueryResult(exception)));
}
public abstract BaseQuery CreateFromIndividual(RecipientData recipientData);
public override AvailabilityException CreateExceptionForUnsupportedVersion(RecipientData recipient, int serverVersion)
{
return(new E14orHigherProxyServerNotFound((recipient != null) ? recipient.EmailAddress : null, Globals.E14Version));
}
public override BaseQuery CreateFromIndividual(RecipientData recipientData, LocalizedException exception)
{
return(FreeBusyQuery.CreateFromIndividual(recipientData, exception));
}
public abstract BaseQuery CreateFromIndividual(RecipientData recipientData, LocalizedException exception);
private FreeBusyQuery(RecipientData recipientData, AttendeeKind attendeeKind, FreeBusyQueryResult result) : base(recipientData, result)
{
this.attendeeKind = attendeeKind;
}
protected BaseQuery(RecipientData recipientData, BaseQueryResult result)
{
this.recipientData = recipientData;
this.result = result;
this.logData = new Dictionary <string, string>();
}
public static FreeBusyQuery CreateFromIndividual(RecipientData recipientData)
{
return(new FreeBusyQuery(recipientData, AttendeeKind.Individual, null));
}
public abstract BaseQuery CreateFromUnknown(RecipientData recipientData, LocalizedException exception);
