public void Set(WebServiceUri webServiceUri, int versionBucket)
{
if (webServiceUri == null)
{
throw new ArgumentNullException("webServiceUri");
}
if (!LocalizedString.Empty.Equals(webServiceUri.AutodiscoverFailedExceptionString))
{
this.uriByVersionBuckets[versionBucket] = webServiceUri;
return;
}
for (int i = versionBucket; i > -1; i--)
{
if (i == versionBucket)
{
this.uriByVersionBuckets[i] = webServiceUri;
}
else
{
WebServiceUri webServiceUri2 = this.uriByVersionBuckets[i];
if (webServiceUri2 == null)
{
this.uriByVersionBuckets[i] = webServiceUri;
}
else if (!LocalizedString.Empty.Equals(webServiceUri2.AutodiscoverFailedExceptionString))
{
this.uriByVersionBuckets[i] = webServiceUri;
}
}
}
}
protected override void SetResult(AutoDiscoverQueryItem queryItem, LocalizedString exceptionString, uint locationIdentifier)
{
WebServiceUri webServiceUri = new WebServiceUri(null, exceptionString, queryItem.EmailAddress);
base.AddWebServiceUriToCache(queryItem, webServiceUri);
queryItem.SetResult(new AutoDiscoverResult(new AutoDiscoverFailedException(exceptionString, locationIdentifier)));
}
internal static WebServiceUri Get(EmailAddress email, int versionBucket)
{
string text = email.Address.ToLower();
VersionedWebServiceUri versionedWebServiceUri;
lock (RemoteServiceUriCache.cacheLocker)
{
versionedWebServiceUri = (VersionedWebServiceUri)RemoteServiceUriCache.cache[text];
}
if (versionedWebServiceUri != null)
{
RemoteServiceUriCache.AutoDiscoverTracer.TraceDebug <object, VersionedWebServiceUri, string>(0L, "{0}: Found service URI {1} for email {2} in the cache.", TraceContext.Get(), versionedWebServiceUri, text);
WebServiceUri webServiceUri = versionedWebServiceUri.Get(versionBucket);
if (webServiceUri == null)
{
RemoteServiceUriCache.AutoDiscoverTracer.TraceDebug <object, string, int>(0L, "{0}: Service URI for email {1} was not found in version bucket {2}.", TraceContext.Get(), text, versionBucket);
}
else if (webServiceUri.Expired(DateTime.UtcNow) && (LocalizedString.Empty.Equals(webServiceUri.AutodiscoverFailedExceptionString) || RemoteServiceUriCache.IsBadUri(webServiceUri)))
{
RemoteServiceUriCache.AutoDiscoverTracer.TraceDebug <object, WebServiceUri>(0L, "{0}: URI {1} was found to be a bad URL, resetting and returning NULL.", TraceContext.Get(), webServiceUri);
lock (RemoteServiceUriCache.cacheLocker)
{
if (webServiceUri == versionedWebServiceUri.Get(versionBucket))
{
versionedWebServiceUri.Clear(versionBucket);
}
}
return(null);
}
return(webServiceUri);
}
RemoteServiceUriCache.AutoDiscoverTracer.TraceDebug <object, string>(0L, "{0}: Service URI for email {1} was not found in the cache.", TraceContext.Get(), text);
return(null);
}
public SharingInformation(SmtpAddress requestorSmtpAddress, WebServiceUri targetSharingEpr, Uri targetAutodiscoverEpr)
{
this.RequestorSmtpAddress = requestorSmtpAddress;
this.TargetSharingEpr = targetSharingEpr;
this.TargetAutodiscoverEpr = targetAutodiscoverEpr;
this.IsFromIntraOrgConnector = true;
}
protected override void SetResult(AutoDiscoverQueryItem queryItem, WebServiceUri webServiceUri)
{
WebServiceUri webServiceUri2 = new WebServiceUri(webServiceUri, this.targetForestConfiguration.Credentials, queryItem.EmailAddress);
base.AddWebServiceUriToCache(queryItem, webServiceUri2);
queryItem.SetResult(this.GetResult(queryItem.RecipientData, webServiceUri2));
}
public static VersionedWebServiceUri Create(WebServiceUri webServiceUri, int versionBucket)
{
VersionedWebServiceUri versionedWebServiceUri = new VersionedWebServiceUri();
versionedWebServiceUri.Set(webServiceUri, versionBucket);
return(versionedWebServiceUri);
}
public AutoDiscoverRequestResult(Uri url, string redirectAddress, Uri autoDiscoverRedirectUri, WebServiceUri webServiceUri, string frontEndServerName, string backEnderServerName)
{
this.Url = url;
this.RedirectAddress = redirectAddress;
this.AutoDiscoverRedirectUri = autoDiscoverRedirectUri;
this.WebServiceUri = webServiceUri;
this.FrontEndServerName = frontEndServerName;
this.BackEndServerName = backEnderServerName;
}
protected void AddWebServiceUriToCache(AutoDiscoverQueryItem queryItem, WebServiceUri webServiceUri)
{
int autodiscoverVersionBucket = this.Application.GetAutodiscoverVersionBucket(this.autodiscoverType);
RemoteServiceUriCache.Add(queryItem.EmailAddress, webServiceUri, autodiscoverVersionBucket);
if (queryItem.InitialEmailAddress != queryItem.EmailAddress)
{
RemoteServiceUriCache.Add(queryItem.InitialEmailAddress, webServiceUri, autodiscoverVersionBucket);
}
}
public override IService CreateService(WebServiceUri webServiceUri, TargetServerVersion targetVersion, RequestType requestType)
{
Service service = new Service(webServiceUri);
if (targetVersion >= TargetServerVersion.E14R3OrLater || targetVersion == TargetServerVersion.Unknown)
{
this.SetTimeZoneDefinitionHeader(service);
}
return(service);
}
internal WebServiceUri(WebServiceUri uri, NetworkCredential credentials, EmailAddress emailAddress)
{
this.credentials = credentials;
this.whenCached = uri.WhenCached;
this.uri = uri.Uri;
this.protocol = uri.Protocol;
this.source = this.Source;
this.emailAddress = emailAddress;
this.serverVersion = uri.ServerVersion;
this.AutodiscoverFailedExceptionString = uri.AutodiscoverFailedExceptionString;
}
internal WebServiceUri(WebServiceUri uri, DateTime whenCached)
{
this.whenCached = whenCached;
this.credentials = uri.credentials;
this.uri = uri.Uri;
this.protocol = uri.Protocol;
this.source = uri.Source;
this.emailAddress = uri.EmailAddress;
this.serverVersion = uri.ServerVersion;
this.AutodiscoverFailedExceptionString = uri.AutodiscoverFailedExceptionString;
}
protected override void SetResult(AutoDiscoverQueryItem queryItem, WebServiceUri webServiceUri)
{
WebServiceUri webServiceUri2 = new WebServiceUri(webServiceUri, null, queryItem.EmailAddress);
base.AddWebServiceUriToCache(queryItem, webServiceUri2);
AutoDiscoverResult result;
if (!base.Application.IsVersionSupportedForExternalUser(webServiceUri.ServerVersion))
{
AutoDiscoverQuery.AutoDiscoverTracer.TraceError <object, int, Type>((long)this.GetHashCode(), "{0}: Remote server version {1} is considered a legacy server by {2} application for external user.", TraceContext.Get(), webServiceUri.ServerVersion, base.Application.GetType());
result = new AutoDiscoverResult(base.Application.CreateExceptionForUnsupportedVersion(queryItem.RecipientData, webServiceUri.ServerVersion));
}
else
{
result = new AutoDiscoverResult(webServiceUri2, base.Authenticator.ProxyAuthenticator);
}
queryItem.SetResult(result);
}
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 string ToString()
{
StringBuilder stringBuilder = new StringBuilder(1000);
for (int i = 0; i < this.uriByVersionBuckets.Length; i++)
{
WebServiceUri webServiceUri = this.uriByVersionBuckets[i];
if (webServiceUri != null)
{
stringBuilder.Append(string.Concat(new object[]
{
i,
":",
webServiceUri.ToString(),
";"
}));
}
}
return(stringBuilder.ToString());
}
internal static bool IsBadUri(WebServiceUri uri)
{
bool result = false;
if (uri.Uri != null)
{
string text = uri.Uri.ToString();
if (text != null)
{
text = text.ToLower();
lock (RemoteServiceUriCache.badUrlListLocker)
{
if (RemoteServiceUriCache.badUrlList.Contains(text))
{
result = true;
}
}
}
}
return(result);
}
internal static void Add(EmailAddress email, WebServiceUri uri, int versionBucket)
{
RemoteServiceUriCache.AutoDiscoverTracer.TraceDebug <object, WebServiceUri, EmailAddress>(0L, "{0}: Adding/Updating AS URI {1} for email {2} in cache.", TraceContext.Get(), uri, email);
string key = email.Address.ToLower();
WebServiceUri webServiceUri = new WebServiceUri(uri, DateTime.UtcNow);
lock (RemoteServiceUriCache.cacheLocker)
{
VersionedWebServiceUri versionedWebServiceUri = (VersionedWebServiceUri)RemoteServiceUriCache.cache[key];
if (versionedWebServiceUri == null)
{
if (500000 == RemoteServiceUriCache.cache.Count)
{
RemoteServiceUriCache.cache.RemoveAt(0);
}
versionedWebServiceUri = VersionedWebServiceUri.Create(webServiceUri, versionBucket);
RemoteServiceUriCache.cache[key] = versionedWebServiceUri;
}
else
{
versionedWebServiceUri.Set(webServiceUri, versionBucket);
}
}
}
internal ProxyWebRequest(Application application, ClientContext clientContext, RequestType requestType, RequestLogger requestLogger, QueryList queryList, TargetServerVersion targetVersion, ProxyAuthenticator proxyAuthenticator, WebServiceUri webServiceUri, UriSource source) : base(application, clientContext, requestLogger, "ProxyWebRequest")
{
this.proxyAuthenticator = proxyAuthenticator;
this.url = webServiceUri.Uri.OriginalString;
this.protocol = webServiceUri.Protocol;
this.source = source;
this.queryList = queryList;
this.requestType = requestType;
this.service = application.CreateService(webServiceUri, targetVersion, requestType);
if (proxyAuthenticator.AuthenticatorType == AuthenticatorType.WSSecurity || proxyAuthenticator.AuthenticatorType == AuthenticatorType.OAuth)
{
if (webServiceUri.ServerVersion >= Globals.E15Version && clientContext.RequestSchemaVersion >= ExchangeVersionType.Exchange2012)
{
this.service.RequestServerVersionValue = new RequestServerVersion
{
Version = ExchangeVersionType.Exchange2012
};
}
else
{
this.service.RequestServerVersionValue = new RequestServerVersion
{
Version = ExchangeVersionType.Exchange2009
};
}
}
else if (targetVersion >= TargetServerVersion.E15 && clientContext.RequestSchemaVersion == ExchangeVersionType.Exchange2012)
{
this.service.RequestServerVersionValue = new RequestServerVersion
{
Version = ExchangeVersionType.Exchange2012
};
}
this.service.CookieContainer = new CookieContainer();
this.service.requestTypeValue = new RequestTypeHeader();
if (requestType == RequestType.CrossSite || requestType == RequestType.IntraSite)
{
if (Configuration.BypassProxyForCrossSiteRequests)
{
this.service.Proxy = new WebProxy();
}
this.service.requestTypeValue.RequestType = ProxyRequestType.CrossSite;
if (requestType == RequestType.CrossSite)
{
this.failedCounter = PerformanceCounters.CrossSiteCalendarFailuresPerSecond;
this.averageProcessingTimeCounter = PerformanceCounters.AverageCrossSiteFreeBusyRequestProcessingTime;
this.averageProcessingTimeCounterBase = PerformanceCounters.AverageCrossSiteFreeBusyRequestProcessingTimeBase;
this.requestStatisticsType = RequestStatisticsType.CrossSiteProxy;
}
else
{
this.failedCounter = PerformanceCounters.IntraSiteProxyFreeBusyFailuresPerSecond;
this.averageProcessingTimeCounter = PerformanceCounters.AverageIntraSiteProxyFreeBusyRequestProcessingTime;
this.averageProcessingTimeCounterBase = PerformanceCounters.AverageIntraSiteProxyFreeBusyRequestProcessingTimeBase;
this.requestStatisticsType = RequestStatisticsType.IntraSiteProxy;
}
}
else
{
bool flag = false;
if (Configuration.BypassProxyForCrossForestRequests)
{
this.service.Proxy = new WebProxy();
flag = true;
}
this.service.requestTypeValue.RequestType = ProxyRequestType.CrossForest;
if (requestType == RequestType.FederatedCrossForest)
{
if (proxyAuthenticator.AuthenticatorType == AuthenticatorType.OAuth)
{
this.failedCounter = PerformanceCounters.FederatedByOAuthFreeBusyFailuresPerSecond;
this.averageProcessingTimeCounter = PerformanceCounters.AverageFederatedByOAuthFreeBusyRequestProcessingTime;
this.averageProcessingTimeCounterBase = PerformanceCounters.AverageFederatedByOAuthFreeBusyRequestProcessingTimeBase;
this.requestStatisticsType = RequestStatisticsType.OAuthProxy;
this.service.requestTypeValue = null;
}
else
{
this.failedCounter = PerformanceCounters.FederatedFreeBusyFailuresPerSecond;
this.averageProcessingTimeCounter = PerformanceCounters.AverageFederatedFreeBusyRequestProcessingTime;
this.averageProcessingTimeCounterBase = PerformanceCounters.AverageFederatedFreeBusyRequestProcessingTimeBase;
this.requestStatisticsType = RequestStatisticsType.FederatedProxy;
}
if (!flag)
{
Server localServer = LocalServerCache.LocalServer;
if (localServer != null && localServer.InternetWebProxy != null)
{
ProxyWebRequest.ProxyWebRequestTracer.TraceDebug <object, Uri>((long)this.GetHashCode(), "{0}: Using custom InternetWebProxy {1}", TraceContext.Get(), localServer.InternetWebProxy);
this.service.Proxy = new WebProxy(localServer.InternetWebProxy);
}
}
}
else
{
this.failedCounter = PerformanceCounters.CrossForestCalendarFailuresPerSecond;
this.averageProcessingTimeCounter = PerformanceCounters.AverageCrossForestFreeBusyRequestProcessingTime;
this.averageProcessingTimeCounterBase = PerformanceCounters.AverageCrossForestFreeBusyRequestProcessingTimeBase;
this.requestStatisticsType = RequestStatisticsType.CrossForestProxy;
}
}
if (!Configuration.DisableGzipForProxyRequests)
{
this.service.EnableDecompression = true;
}
string address = this.queryList[0].Email.Address;
ProxyWebRequest.ProxyWebRequestTracer.TraceDebug <object, string, WebServiceUri>((long)this.GetHashCode(), "{0}: Adding Anchor Mailbox Header {1} to the request to {2}.", TraceContext.Get(), address, webServiceUri);
this.service.HttpHeaders.Add("X-AnchorMailbox", address);
if (!string.IsNullOrEmpty(base.ClientContext.RequestId))
{
this.service.HttpHeaders.Add("client-request-id", base.ClientContext.RequestId);
}
}
protected override void EndInvoke(IAsyncResult asyncResult)
{
WebResponse webResponse = null;
try
{
AutoDiscoverRequest.FaultInjectionTracer.TraceTest(2263231805U);
webResponse = this.request.EndGetResponse(asyncResult);
if (webResponse != null)
{
this.headers = webResponse.Headers;
HttpWebResponse httpWebResponse = webResponse as HttpWebResponse;
if (httpWebResponse != null && httpWebResponse.StatusCode == HttpStatusCode.Found)
{
string text = this.headers["Location"];
if (string.IsNullOrEmpty(text))
{
this.HandleException(Strings.descAutoDiscoverBadRedirectLocation(this.emailAddress.ToString(), "null"), 50492U);
}
else
{
AutoDiscoverRequest.AutoDiscoverTracer.TraceDebug <object, string, Uri>((long)this.GetHashCode(), "{0}: Got a redirect from AutoDiscover to {1}, original location was {1}.", TraceContext.Get(), text, this.targetUri);
Uri uri;
try
{
uri = new Uri(text);
}
catch (UriFormatException exception)
{
this.HandleException(Strings.descAutoDiscoverBadRedirectLocation(this.emailAddress.ToString(), text), exception);
return;
}
UriBuilder uriBuilder = new UriBuilder(uri);
uriBuilder.Scheme = (Configuration.UseSSLForAutoDiscoverRequests ? "https" : "http");
this.Result = new AutoDiscoverRequestResult(this.targetUri, null, uriBuilder.Uri, null, this.headers[WellKnownHeader.XFEServer], this.headers[WellKnownHeader.XBEServer]);
}
}
else
{
this.responseText = this.GetResponseText(webResponse);
if (this.responseText == null || this.responseText.Length == 0)
{
this.HandleException(Strings.descNullAutoDiscoverResponse, new XmlException());
}
else
{
string text2 = this.FindError();
if (text2 != null)
{
this.HandleException(Strings.descAutoDiscoverFailedWithException(this.emailAddress.ToString(), text2), 47420U);
}
else
{
string text3 = this.FindRedirectAddress();
if (text3 != null)
{
string frontEndServerName = null;
string backEnderServerName = null;
if (this.headers != null)
{
frontEndServerName = this.headers[WellKnownHeader.XFEServer];
backEnderServerName = this.headers[WellKnownHeader.XBEServer];
}
this.Result = new AutoDiscoverRequestResult(this.targetUri, text3, null, null, frontEndServerName, backEnderServerName);
}
else
{
WebServiceUri webServiceUri = this.FindWebServiceUrlForProtocol("EXPR");
if (webServiceUri != null)
{
this.Result = new AutoDiscoverRequestResult(this.targetUri, null, null, webServiceUri, null, null);
}
else
{
webServiceUri = this.FindWebServiceUrlForProtocol("EXCH");
if (webServiceUri != null)
{
this.Result = new AutoDiscoverRequestResult(this.targetUri, null, null, webServiceUri, null, null);
}
else
{
this.HandleException(Strings.descProtocolNotFoundInAutoDiscoverResponse("EXCH", this.targetUri.ToString()), null);
}
}
}
}
}
}
}
}
catch (WebException exception2)
{
this.HandleException(exception2);
}
catch (ArgumentNullException exception3)
{
this.HandleException(exception3);
}
catch (ArgumentException exception4)
{
this.HandleException(exception4);
}
catch (InvalidOperationException exception5)
{
this.HandleException(exception5);
}
catch (NotSupportedException exception6)
{
this.HandleException(exception6);
}
catch (XmlException exception7)
{
this.HandleException(exception7);
}
catch (XPathException exception8)
{
this.HandleException(exception8);
}
catch (UriFormatException exception9)
{
this.HandleException(exception9);
}
finally
{
if (webResponse != null)
{
webResponse.Close();
}
this.timer.Stop();
base.RequestLogger.Add(RequestStatistics.Create(RequestStatisticsType.AutoDiscoverRequest, this.timer.ElapsedMilliseconds, this.targetUri.ToString()));
}
}
private AsyncRequest CreateRequest(QueryList queryList, ProxyAuthenticator proxyAuthenticator, WebServiceUri webServiceUri, UriSource source)
{
return(new ProxyWebRequest(base.Application, base.ClientContext, RequestType.FederatedCrossForest, base.RequestLogger, queryList, TargetServerVersion.Unknown, proxyAuthenticator, webServiceUri, source));
}
public SharingInformation Read(EmailAddress emailAddress, Application application)
{
if (this.requester == null)
{
SharingReader.RequestRoutingTracer.TraceError <object, string>((long)this.GetHashCode(), "{0}: Unable to get the requestor from the client context - address {1}", TraceContext.Get(), emailAddress.Address);
return(new SharingInformation(new InvalidClientSecurityContextException()));
}
if (this.supportsPersonalSharing)
{
SharingSubscriptionData userSubscription = this.SubscriptionLoader.GetUserSubscription(emailAddress);
if (!this.SubscriptionLoader.IsValid)
{
SharingReader.RequestRoutingTracer.TraceError <object, EmailAddress, Exception>((long)this.GetHashCode(), "{0}: SubscriptionLoader cannot open mailbox {1}. Exception: {2}", TraceContext.Get(), emailAddress, this.SubscriptionLoader.HandledException);
}
if (userSubscription != null)
{
SharingReader.RequestRoutingTracer.TraceDebug <object, string>((long)this.GetHashCode(), "{0}: Found a personal relationship for {1}", TraceContext.Get(), emailAddress.Address);
if (SmtpAddress.IsValidSmtpAddress(userSubscription.SubscriberIdentity) && SmtpAddress.IsValidSmtpAddress(userSubscription.SharingKey))
{
Uri sharingUrl = userSubscription.SharingUrl;
return(new SharingInformation(new SmtpAddress(userSubscription.SubscriberIdentity), new SmtpAddress(userSubscription.SharingKey), new TokenTarget(userSubscription.SharerIdentityFederationUri), new WebServiceUri(sharingUrl.OriginalString, sharingUrl.Scheme, UriSource.Directory, Globals.E14SP2Version), null));
}
SharingReader.RequestRoutingTracer.TraceError <object, EmailAddress>((long)this.GetHashCode(), "{0}: The subscriber information in the mailbox is invalid for address {1}. Personal subscription can't be used.", TraceContext.Get(), emailAddress);
}
}
string domain = emailAddress.Domain;
OrganizationId key = (this.requester.OrganizationId == null) ? OrganizationId.ForestWideOrgId : this.requester.OrganizationId;
OrganizationIdCacheValue organizationIdCacheValue = OrganizationIdCache.Singleton.Get(key);
SharingReader.RequestRoutingTracer.TraceDebug <object, string>((long)this.GetHashCode(), "{0}: Looking for an Intra-Organization connector with domain {1}.", TraceContext.Get(), domain);
IntraOrganizationConnector intraOrganizationConnector = organizationIdCacheValue.GetIntraOrganizationConnector(domain);
WebServiceUri targetSharingEpr;
if (intraOrganizationConnector != null && intraOrganizationConnector.Enabled)
{
Uri discoveryEndpoint = intraOrganizationConnector.DiscoveryEndpoint;
int autodiscoverVersionBucket = application.GetAutodiscoverVersionBucket(AutodiscoverType.External);
targetSharingEpr = RemoteServiceUriCache.Get(emailAddress, autodiscoverVersionBucket);
return(new SharingInformation(this.requester.PrimarySmtpAddress, targetSharingEpr, discoveryEndpoint));
}
SharingReader.RequestRoutingTracer.TraceDebug <object, string>((long)this.GetHashCode(), "{0}: Looking for an Organization Relationship with domain {1}.", TraceContext.Get(), domain);
OrganizationRelationship organizationRelationship = organizationIdCacheValue.GetOrganizationRelationship(domain);
if (organizationRelationship == null)
{
SharingReader.RequestRoutingTracer.TraceError <object, string, EmailAddress>((long)this.GetHashCode(), "{0}: Unable to find a organization Relationship with domain {1} for emailAddress {2}.", TraceContext.Get(), emailAddress.Domain, emailAddress);
return(null);
}
if (!organizationRelationship.Enabled)
{
SharingReader.RequestRoutingTracer.TraceError <object, OrganizationRelationship, string>((long)this.GetHashCode(), "{0}: Organization Relationship {1} is not enabled for access to domain {2}. Ignoring this relationship.", TraceContext.Get(), organizationRelationship, emailAddress.Domain);
return(null);
}
if (!application.EnabledInRelationship(organizationRelationship))
{
SharingReader.RequestRoutingTracer.TraceError((long)this.GetHashCode(), "{0}: Organization Relationship {1} is not enabled for application {2} to domain {3}. Ignoring this relationship.", new object[]
{
TraceContext.Get(),
organizationRelationship,
application.GetType(),
emailAddress.Domain
});
return(null);
}
if (!organizationRelationship.IsValidForRequestDispatcher())
{
SharingReader.RequestRoutingTracer.TraceError((long)this.GetHashCode(), "{0}: Organization Relationship is invalid for dispatching requests, TargetApplicationUri:{1}, TargetSharingEpr:{2}, AutoDiscoverEpr:{3}.", new object[]
{
TraceContext.Get(),
organizationRelationship.TargetApplicationUri,
organizationRelationship.TargetSharingEpr,
organizationRelationship.TargetAutodiscoverEpr
});
return(new SharingInformation(new InvalidOrganizationRelationshipForRequestDispatcherException(organizationRelationship.ToString())));
}
if (DateTime.UtcNow > this.readDeadline)
{
return(new SharingInformation(new TimeoutExpiredException("OrganizationRelationship lookup")));
}
Uri targetSharingEpr2 = organizationRelationship.TargetSharingEpr;
if (targetSharingEpr2 == null)
{
int autodiscoverVersionBucket2 = application.GetAutodiscoverVersionBucket(AutodiscoverType.External);
targetSharingEpr = RemoteServiceUriCache.Get(emailAddress, autodiscoverVersionBucket2);
}
else
{
targetSharingEpr = new WebServiceUri(targetSharingEpr2.OriginalString, targetSharingEpr2.Scheme, UriSource.Directory, Globals.E14SP2Version);
}
return(new SharingInformation(this.requester.PrimarySmtpAddress, SmtpAddress.Empty, organizationRelationship.GetTokenTarget(), targetSharingEpr, organizationRelationship.TargetAutodiscoverEpr));
}
protected abstract void SetResult(AutoDiscoverQueryItem queryItem, WebServiceUri webServiceUri);
public SharingInformation(SmtpAddress requestorSmtpAddress, SmtpAddress sharingKey, TokenTarget tokenTarget, WebServiceUri targetSharingEpr, Uri targetAutodiscoverEpr)
{
this.RequestorSmtpAddress = requestorSmtpAddress;
this.SharingKey = sharingKey;
this.TokenTarget = tokenTarget;
this.TargetSharingEpr = targetSharingEpr;
this.TargetAutodiscoverEpr = targetAutodiscoverEpr;
this.IsFromIntraOrgConnector = false;
}
public abstract IService CreateService(WebServiceUri webServiceUri, TargetServerVersion targetVersion, RequestType requestType);
public ExternalProxyWebRequest(Application application, ClientContext clientContext, RequestLogger requestLogger, QueryList queryList, ExternalAuthenticationRequest externalAuthenticationRequest, WebServiceUri webServiceUri, SmtpAddress sharingKey) : base(application, clientContext, RequestType.FederatedCrossForest, requestLogger, queryList)
{
this.externalAuthenticationRequest = externalAuthenticationRequest;
this.webServiceUri = webServiceUri;
this.sharingKey = sharingKey;
}
private AsyncRequestWithQueryList CreateRequest(QueryList queryList, ProxyAuthenticator proxyAuthenticator, WebServiceUri webServiceUri, UriSource source)
{
return(new GetFolderAndProxyRequest(base.Application, (InternalClientContext)base.ClientContext, RequestType.CrossForest, base.RequestLogger, queryList, TargetServerVersion.Unknown, proxyAuthenticator, webServiceUri));
}
public override IService CreateService(WebServiceUri webServiceUri, TargetServerVersion targetVersion, RequestType requestType)
{
throw new NotImplementedException();
}
public ExternalByOAuthProxyWebRequest(Application application, ClientContext clientContext, RequestLogger requestLogger, QueryList queryList, WebServiceUri webServiceUri) : base(application, clientContext, RequestType.FederatedCrossForest, requestLogger, queryList)
{
this.webServiceUri = webServiceUri;
}
public AutoDiscoverResult(WebServiceUri webServiceUri, ProxyAuthenticator proxyAuthenticator)
{
this.ProxyAuthenticator = proxyAuthenticator;
this.WebServiceUri = webServiceUri;
}
public GetFolderAndProxyRequest(Application application, InternalClientContext clientContext, RequestType requestType, RequestLogger requestLogger, QueryList queryList, TargetServerVersion targetVersion, ProxyAuthenticator proxyAuthenticator, WebServiceUri webServiceUri) : base(application, clientContext, requestType, requestLogger, queryList)
{
this.targetVersion = targetVersion;
this.proxyAuthenticator = proxyAuthenticator;
this.webServiceUri = webServiceUri;
}
