private HttpWebRequest SendRequest(ICredentials credentials)
{
HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(this.url);
AutoDiscoverClient.AddOutlook14Cookie(httpWebRequest);
httpWebRequest.Method = "POST";
httpWebRequest.ContentType = "text/xml; charset=utf-8";
httpWebRequest.Credentials = credentials;
httpWebRequest.PreAuthenticate = true;
httpWebRequest.Headers.Set(HttpRequestHeader.Pragma, "no-cache");
foreach (string text in this.additionalHeaders.Keys)
{
httpWebRequest.Headers.Add(text, this.additionalHeaders[text]);
}
httpWebRequest.UserAgent = string.Format("{0}/{1}/{2}", Environment.MachineName, this.componentId, this.emailAddress);
CertificateValidationManager.SetComponentId(httpWebRequest, this.componentId);
this.TraceHeaders(httpWebRequest.Headers);
using (Stream requestStream = httpWebRequest.GetRequestStream())
{
SafeXmlSerializer safeXmlSerializer = new SafeXmlSerializer(typeof(AutoDiscoverRequestXML));
AutoDiscoverRequestXML o = AutoDiscoverRequestXML.NewRequest(this.emailAddress);
safeXmlSerializer.Serialize(requestStream, o);
}
return(httpWebRequest);
}
private HttpWebRequest CreateWebRequest(Uri uri)
{
HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(uri);
httpWebRequest.UnsafeAuthenticatedConnectionSharing = !this.proxyInfo.RequiresImpersonation;
if (!this.proxyInfo.RequiresImpersonation)
{
httpWebRequest.ServicePoint.ConnectionLimit = GlobalSettings.ProxyConnectionPoolConnectionLimit;
}
httpWebRequest.ServicePoint.SetTcpKeepAlive(true, 240000, 5000);
httpWebRequest.PreAuthenticate = true;
httpWebRequest.AllowAutoRedirect = false;
httpWebRequest.KeepAlive = !this.proxyInfo.RequiresImpersonation;
CertificateValidationManager.SetComponentId(httpWebRequest, "AirSync");
if (this.proxyInfo.CanImpersonate)
{
ICredentials defaultCredentials = CredentialCache.DefaultCredentials;
httpWebRequest.Credentials = defaultCredentials.GetCredential(this.proxyInfo.RemoteUri, "Kerberos");
if (httpWebRequest.Credentials == null)
{
this.protocolLogger.SetValue(ProtocolLoggerData.Error, "NoKerberosCredentials");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.ServerError, null, false);
}
}
return(httpWebRequest);
}
public virtual async Task SendNotificationsAsync(PusherQueue queueToProcess)
{
bool success = false;
try
{
await Task.Delay(TimeSpan.FromMinutes((double)queueToProcess.FailureCount));
this.IncrementInTransit();
PusherQueuePayload[] payloads = queueToProcess.GetPayloads();
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(new Uri(queueToProcess.DestinationUrl));
webRequest.PreAuthenticate = true;
CertificateValidationManager.SetComponentId(webRequest, "RemoteNotification");
webRequest.ContentType = "text/plain";
webRequest.Method = "POST";
DateTime pushTime = DateTime.UtcNow;
await RemoteNotificationRequester.SendRequest(webRequest, RemoteNotificationRequester.GeneratePayload(payloads), queueToProcess.DestinationUrl, payloads.Length);
await RemoteNotificationRequester.ReceiveResponseAsync(webRequest);
success = true;
IEnumerable <NotificationPayloadBase> payloadsToBePushed = from p in payloads
select p.Payload;
NotificationStatisticsManager.Instance.NotificationPushed(queueToProcess.DestinationUrl, payloadsToBePushed, pushTime);
}
catch (WebException webException)
{
RemoteNotificationRequester.HandleWebException(webException, queueToProcess);
}
finally
{
queueToProcess.SendComplete(success);
this.DecrementInTransit();
}
}
private void Application_Start(object sender, EventArgs e)
{
Diagnostics.InitializeWatsonReporting();
if (Globals.InstanceType == InstanceType.NotInitialized)
{
string text = HttpProxyGlobals.ProtocolType.ToString();
text = "FE_" + text;
Globals.InitializeMultiPerfCounterInstance(text);
}
Diagnostics.SendWatsonReportOnUnhandledException(delegate()
{
Task.Factory.StartNew(delegate()
{
SettingOverrideSync.Instance.Start(true);
});
CertificateValidationManager.RegisterCallback(Constants.CertificateValidationComponentId, ProxyApplication.RemoteCertificateValidationCallback);
ProxyApplication.ConfigureServicePointManager();
if (DownLevelServerManager.IsApplicable)
{
DownLevelServerManager.Instance.Initialize();
}
});
PerfCounters.UpdateHttpProxyPerArrayCounters();
Diagnostics.Logger.LogEvent(FrontEndHttpProxyEventLogConstants.Tuple_ApplicationStart, null, new object[]
{
HttpProxyGlobals.ProtocolType
});
}
internal AutoDiscoverRequest(Application application, ClientContext clientContext, RequestLogger requestLogger, Uri targetUri, EmailAddress emailAddress, ICredentials credentialsForDiscovery, UriSource uriSource) : base(application, clientContext, requestLogger, "AutoDiscoverRequest")
{
this.uriSource = uriSource;
this.emailAddress = emailAddress;
this.credentialsForDiscovery = credentialsForDiscovery;
this.targetUri = targetUri;
CertificateValidationManager.RegisterCallback(Globals.CertificateValidationComponentId, new RemoteCertificateValidationCallback(CertificateErrorHandler.CertValidationCallback));
}
public HttpWebResponse AuthenticateAndGetResponse(HttpWebRequest request)
{
ArgumentValidator.ThrowIfNull("request", request);
NetworkServiceImpersonator.Initialize();
this.tracer.TraceDebug <string>((long)this.GetHashCode(), "LOCAL FOREST OTHER SERVER OUTBOUND AUTHENTICATOR: stamping component id '{0}' onto request.", this.certificateValidationComponentId);
CertificateValidationManager.SetComponentId(request, this.certificateValidationComponentId);
request.PreAuthenticate = true;
return(HttpAuthenticator.NetworkService.AuthenticateAndExecute <HttpWebResponse>(request, () => (HttpWebResponse)request.GetResponse()));
}
internal RestService(HttpAuthenticator authenticator, WebServiceUri webServiceUri, bool traceRequest, ITracer upstreamTracer)
{
this.authenticator = authenticator;
this.componentId = Globals.CertificateValidationComponentId;
this.httpHeaders = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
this.traceRequest = traceRequest;
this.tracer = upstreamTracer;
this.targetUri = webServiceUri.Uri;
CertificateValidationManager.RegisterCallback(this.componentId, new RemoteCertificateValidationCallback(CertificateErrorHandler.CertValidationCallback));
}
private static ExchangeService CreateExchangeService(string domain, EncryptionConfigurationTable.RequestData requestData)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
ADUser orgMailbox = EncryptionConfigurationTable.GetOrgMailbox(domain);
requestData.OrgMailboxAdUserLookupTime = stopwatch.ElapsedMilliseconds;
if (orgMailbox == null)
{
return(null);
}
ExchangePrincipal exchangePrincipal;
try
{
exchangePrincipal = ExchangePrincipal.FromADUser(orgMailbox, null);
}
catch (ObjectNotFoundException exception)
{
EncryptionConfigurationTable.logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_E4EOrganizationMailboxWebServiceUrlRetrievalFailed, domain, new object[]
{
"ProcessEncryptionConfiguration",
EncryptionConfigurationTable.GetLoggedExceptionString(exception)
});
return(null);
}
Uri backEndWebServicesUrl;
try
{
backEndWebServicesUrl = BackEndLocator.GetBackEndWebServicesUrl(exchangePrincipal.MailboxInfo);
stopwatch.Stop();
requestData.WebServiceUrlLookupTime = stopwatch.ElapsedMilliseconds - requestData.OrgMailboxAdUserLookupTime;
}
catch (BackEndLocatorException exception2)
{
EncryptionConfigurationTable.logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_E4EOrganizationMailboxWebServiceUrlRetrievalFailed, domain, new object[]
{
"ProcessEncryptionConfiguration",
EncryptionConfigurationTable.GetLoggedExceptionString(exception2)
});
return(null);
}
ExchangeService exchangeService = new ExchangeService(4);
exchangeService.Url = backEndWebServicesUrl;
exchangeService.PrivilegedUserId = new PrivilegedUserId(0, 2, orgMailbox.PrimarySmtpAddress.ToString());
exchangeService.PrivilegedUserId.BudgetType = new PrivilegedUserIdBudgetType?(2);
RemoteCertificateValidationCallback callback = (object param0, X509Certificate param1, X509Chain param2, SslPolicyErrors param3) => true;
CertificateValidationManager.RegisterCallback("E4E.EncryptionConfigurationTable", callback);
exchangeService.HttpHeaders.Add(CertificateValidationManager.ComponentIdHeaderName, "E4E.EncryptionConfigurationTable");
return(exchangeService);
}
public Exception Ping(Uri url)
{
if (url == null)
{
throw new ArgumentNullException("url");
}
ExTraceGlobals.VerboseTracer.TraceDebug <Uri>((long)this.GetHashCode(), "[ProtocolPingStrategyBase::Ctor]: Testing server with URL {0}.", url);
HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
httpWebRequest.ServicePoint.ConnectionLimit = HttpProxySettings.ServicePointConnectionLimit.Value;
httpWebRequest.Method = "HEAD";
httpWebRequest.Timeout = ProtocolPingStrategyBase.DownLevelServerPingTimeout.Value;
httpWebRequest.PreAuthenticate = true;
httpWebRequest.UserAgent = "HttpProxy.ClientAccessServer2010Ping";
httpWebRequest.KeepAlive = false;
if (!HttpProxySettings.UseDefaultWebProxy.Value)
{
httpWebRequest.Proxy = NullWebProxy.Instance;
}
httpWebRequest.ServerCertificateValidationCallback = ProxyApplication.RemoteCertificateValidationCallback;
CertificateValidationManager.SetComponentId(httpWebRequest, Constants.CertificateValidationComponentId);
this.PrepareRequest(httpWebRequest);
try
{
using (httpWebRequest.GetResponse())
{
}
}
catch (WebException ex)
{
ExTraceGlobals.VerboseTracer.TraceWarning <WebException>((long)this.GetHashCode(), "[ProtocolPingStrategyBase::TestServer]: Web exception: {0}.", ex);
if (!this.IsWebExceptionExpected(ex))
{
return(ex);
}
}
catch (Exception ex2)
{
ExTraceGlobals.VerboseTracer.TraceError <Exception>((long)this.GetHashCode(), "[ProtocolPingStrategyBase::TestServer]: General exception {0}.", ex2);
return(ex2);
}
finally
{
try
{
httpWebRequest.Abort();
}
catch
{
}
}
return(null);
}
protected virtual void FillRequestProperties(HttpWebRequest request)
{
request.ContentType = "text/xml;charset=utf-8";
request.UserAgent = this.UserAgent;
request.PreAuthenticate = true;
request.CookieContainer = new CookieContainer();
if (this.IgnoreSslCertError)
{
CertificateValidationManager.RegisterCallback(ServiceValidatorBase.ComponentId, new RemoteCertificateValidationCallback(ServiceValidatorBase.TrustAllCertValidationCallback));
CertificateValidationManager.SetComponentId(request, ServiceValidatorBase.ComponentId);
}
}
private HttpWebRequest ConfigureRequest(HttpWebRequest request)
{
request.CookieContainer = this.CookieContainer;
request.Proxy = this.Proxy;
request.Credentials = this.Credentials;
request.UserAgent = this.UserAgent;
request.Timeout = this.Timeout;
if (!string.IsNullOrEmpty(this.componentId))
{
CertificateValidationManager.SetComponentId(request, this.componentId);
}
return(this.ApplyHeadersToRequest(request));
}
// Token: 0x06001261 RID: 4705 RVA: 0x0006FF40 File Offset: 0x0006E140
internal static HttpWebRequest CreateHttpWebRequestForProxying(OwaContext owaContext, Uri requestUri)
{
HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(requestUri);
httpWebRequest.UnsafeAuthenticatedConnectionSharing = true;
httpWebRequest.PreAuthenticate = true;
httpWebRequest.AllowAutoRedirect = false;
httpWebRequest.Credentials = CredentialCache.DefaultNetworkCredentials.GetCredential(requestUri, "Kerberos");
if (httpWebRequest.Credentials == null)
{
throw new OwaInvalidOperationException("Can't get credentials for the proxy request");
}
httpWebRequest.AutomaticDecompression = DecompressionMethods.GZip;
CertificateValidationManager.SetComponentId(httpWebRequest, requestUri.IsLoopback ? "OWA_IgnoreCertErrors" : "OWA");
GccUtils.CopyClientIPEndpointsForServerToServerProxy(owaContext.HttpContext, httpWebRequest);
return(httpWebRequest);
}
private HttpWebRequest CopyClientRequest(HttpRequest clientrequest, Uri proxyuri)
{
string b = HttpRequestHeader.Authorization.ToString();
HttpWebRequest httpWebRequest = this.CreateWebRequest(proxyuri);
httpWebRequest.Method = clientrequest.HttpMethod;
for (int i = 0; i < clientrequest.Headers.Count; i++)
{
string text = clientrequest.Headers.Keys[i];
if ((!(text == b) || !this.proxyInfo.CanImpersonate) && !WebHeaderCollection.IsRestricted(text))
{
httpWebRequest.Headers[text] = clientrequest.Headers[text];
}
}
CertificateValidationManager.SetComponentId(httpWebRequest, "AirSync");
foreach (string text2 in this.proxyInfo.AdditionalHeaders.Keys)
{
httpWebRequest.Headers[text2] = this.proxyInfo.AdditionalHeaders[text2];
}
if (GlobalSettings.IsGCCEnabled)
{
if (GlobalSettings.AreGccStoredSecretKeysValid)
{
string text3 = httpWebRequest.Headers["x-gcc-proxyinfo"];
if (string.IsNullOrEmpty(text3) || (!string.IsNullOrEmpty(text3) && !ProxyHandler.HasValidAuthString(text3)))
{
StringBuilder stringBuilder = new StringBuilder(GccUtils.GetAuthStringForThisServer());
stringBuilder.Append(", ");
stringBuilder.Append(clientrequest.ServerVariables["REMOTE_ADDR"]);
stringBuilder.Append(", ");
stringBuilder.Append(clientrequest.ServerVariables["LOCAL_ADDR"]);
httpWebRequest.Headers["x-gcc-proxyinfo"] = stringBuilder.ToString();
}
}
else
{
AirSyncDiagnostics.LogPeriodicEvent(AirSyncEventLogConstants.Tuple_NoGccStoredSecretKey, "NoGccStoredSecretKey", new string[0]);
AirSyncDiagnostics.TraceError(ExTraceGlobals.RequestsTracer, null, "No gcc stored secret key");
}
}
httpWebRequest.Referer = clientrequest.Url.AbsoluteUri;
httpWebRequest.ContentType = clientrequest.ContentType;
httpWebRequest.UserAgent = clientrequest.UserAgent;
return(httpWebRequest);
}
static AutodiscoverProxy()
{
CertificateValidationManager.RegisterCallback("AutodiscoverProxy", delegate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
if (!(sender is HttpWebRequest))
{
return(false);
}
HttpWebRequest httpWebRequest = (HttpWebRequest)sender;
Common.EventLog.LogEvent(AutodiscoverEventLogConstants.Tuple_ErrProviderRedirectServerCertificate, Common.PeriodicKey, new object[]
{
(httpWebRequest.RequestUri != null) ? httpWebRequest.RequestUri.Host : "Unknown Host",
(certificate == null) ? "No Certificate" : certificate.Subject,
sslPolicyErrors
});
return(SslConfiguration.AllowExternalUntrustedCerts);
});
}
public NonIndexableDiscoveryEwsClient(GroupId groupId, MailboxInfo[] mailboxes, ExTimeZone timeZone, CallerInfo caller)
{
Util.ThrowOnNull(groupId, "groupId");
Util.ThrowOnNull(mailboxes, "mailboxes");
Util.ThrowOnNull(timeZone, "timeZone");
Util.ThrowOnNull(caller, "caller");
this.groupId = groupId;
this.mailboxes = mailboxes;
this.callerInfo = caller;
CertificateValidationManager.RegisterCallback(base.GetType().FullName, new RemoteCertificateValidationCallback(CertificateValidation.CertificateErrorHandler));
this.service = new ExchangeService(4, NonIndexableDiscoveryEwsClient.GetTimeZoneInfoFromExTimeZone(timeZone));
this.service.Url = this.groupId.Uri;
this.service.HttpHeaders[CertificateValidationManager.ComponentIdHeaderName] = base.GetType().FullName;
if (this.groupId.GroupType != GroupType.CrossPremise)
{
this.service.UserAgent = WellKnownUserAgent.GetEwsNegoAuthUserAgent(base.GetType().FullName);
}
this.service.ClientRequestId = this.callerInfo.QueryCorrelationId.ToString("N");
this.Authenticate();
}
private static bool TryProxyAutodiscoverRequest(ProxyRequestData proxyRequestData, string redirectServer, out string rawResponse)
{
ExTraceGlobals.AuthenticationTracer.TraceDebug <string>(0L, "AutodiscoverProxy::TryProxyAutodiscoverRequest. Entrypoint. redirectServer = {0}.", redirectServer);
rawResponse = null;
if (string.IsNullOrEmpty(redirectServer))
{
ExTraceGlobals.AuthenticationTracer.TraceError <string>(0L, "AutodiscoverProxy::TryProxyAutodiscoverRequest. This is an invalid server name. redirectServer = {0}.", redirectServer);
return(false);
}
try
{
HttpWebRequest httpWebRequest = proxyRequestData.CloneRequest(redirectServer);
CertificateValidationManager.SetComponentId(httpWebRequest, "AutodiscoverProxy");
using (WebResponse response = httpWebRequest.GetResponse())
{
using (Stream responseStream = response.GetResponseStream())
{
rawResponse = AutodiscoverProxy.GetResponse(responseStream);
if (rawResponse == null)
{
ExTraceGlobals.AuthenticationTracer.TraceError <string>(0L, "AutodiscoverProxy::TryProxyAutodiscoverRequest. received wrong number of user response. rawResponse = {0}.", rawResponse);
return(false);
}
ExTraceGlobals.AuthenticationTracer.TraceDebug <string, string>(0L, "AutodiscoverProxy::TryProxyAutodiscoverRequest. Received response for user. redirectServer = {0}, rawResponse = {1}.", redirectServer, rawResponse);
}
}
}
catch (LocalizedException arg)
{
ExTraceGlobals.AuthenticationTracer.TraceError <LocalizedException>(0L, "AutodiscoverProxy::TryProxyAutodiscoverRequest caught with a LocalizedException. LocalizedException = {0}.", arg);
return(false);
}
catch (WebException arg2)
{
ExTraceGlobals.AuthenticationTracer.TraceError <WebException>(0L, "AutodiscoverProxy::TryProxyAutodiscoverRequest caught with a WebException. WebException = {0}.", arg2);
return(false);
}
return(true);
}
protected override WebRequest GetWebRequest(Uri uri)
{
WebRequest webRequest = base.GetWebRequest(uri);
if (webRequest is HttpWebRequest)
{
HttpWebRequest request = webRequest as HttpWebRequest;
if (this.trustSslCert)
{
CertificateValidationManager.SetComponentId(request, "Microsoft.Exchange.Data.Directory.SystemConfiguration.AuthMetadataClient.NoSsl");
}
else
{
CertificateValidationManager.SetComponentId(request, "Microsoft.Exchange.Data.Directory.SystemConfiguration.AuthMetadataClient");
}
}
if (this.Timeout != 0)
{
webRequest.Timeout = this.Timeout;
}
return(webRequest);
}
public DiscoveryEwsClient(GroupId groupId, MailboxInfo[] mailboxes, SearchCriteria searchCriteria, PagingInfo pagingInfo, CallerInfo caller)
{
this.groupId = groupId;
this.mailboxes = mailboxes;
this.searchCriteria = searchCriteria;
this.pagingInfo = pagingInfo;
this.callerInfo = caller;
CertificateValidationManager.RegisterCallback(base.GetType().FullName, new RemoteCertificateValidationCallback(CertificateValidation.CertificateErrorHandler));
this.service = new ExchangeService(4, DiscoveryEwsClient.GetTimeZoneInfoFromExTimeZone(this.pagingInfo.TimeZone));
this.service.Url = this.groupId.Uri;
this.service.HttpHeaders[CertificateValidationManager.ComponentIdHeaderName] = base.GetType().FullName;
string text = string.Format("{0}&FOUT=true", caller.UserAgent);
if (this.groupId.GroupType != GroupType.CrossPremise)
{
this.service.UserAgent = WellKnownUserAgent.GetEwsNegoAuthUserAgent(string.Format("{0}-{1}", DiscoveryEwsClient.CrossServerUserAgent, text));
}
else
{
this.service.UserAgent = text;
}
this.service.ClientRequestId = this.callerInfo.QueryCorrelationId.ToString("N");
this.Authenticate();
}
static CommandInvocation()
{
CertificateValidationManager.RegisterCallback("CommandInvcocation", new RemoteCertificateValidationCallback(CommandInvocation.CertificateNoValidationCallback));
}
protected override IAsyncResult BeginInvoke()
{
this.timer = Stopwatch.StartNew();
string xmlBody = this.GetXmlBody();
byte[] bytes = Encoding.UTF8.GetBytes(xmlBody);
WindowsImpersonationContext windowsImpersonationContext = null;
Exception ex = null;
try
{
this.request = (HttpWebRequest)WebRequest.Create(this.targetUri);
this.request.Method = "POST";
this.request.ContentType = "text/xml";
this.request.Headers.Add("X-AnchorMailbox", this.emailAddress.Address);
if (this.credentialsForDiscovery == null)
{
if (Testability.WebServiceCredentials == null)
{
windowsImpersonationContext = NetworkServiceImpersonator.Impersonate();
this.impersonating = true;
}
this.credentialsForDiscovery = CredentialCache.DefaultCredentials;
this.request.Credentials = this.credentialsForDiscovery;
}
else
{
CredentialCache credentialCache = new CredentialCache();
credentialCache.Add(this.targetUri, "Basic", (NetworkCredential)this.credentialsForDiscovery);
this.request.Credentials = credentialCache;
this.request.PreAuthenticate = true;
}
this.request.Timeout = (int)this.timeout.TotalMilliseconds;
this.request.UserAgent = this.GetUserAgent();
this.request.AllowAutoRedirect = false;
this.request.ContentLength = (long)bytes.Length;
if (this.bypassProxy)
{
this.request.Proxy = new WebProxy();
}
CertificateValidationManager.SetComponentId(this.request, Globals.CertificateValidationComponentId);
using (Stream requestStream = this.request.GetRequestStream())
{
requestStream.Write(bytes, 0, bytes.Length);
}
AutoDiscoverRequest.AutoDiscoverTracer.TraceDebug <object, string>((long)this.GetHashCode(), "{0}: Sending request to AutoDiscover service, xml body: {1}", TraceContext.Get(), xmlBody);
if (base.Aborted)
{
this.request.Abort();
}
return(this.request.BeginGetResponse(new AsyncCallback(base.Complete), null));
}
catch (ProtocolViolationException ex2)
{
ex = ex2;
}
catch (SecurityException ex3)
{
ex = ex3;
}
catch (ArgumentException ex4)
{
ex = ex4;
}
catch (InvalidOperationException ex5)
{
ex = ex5;
}
catch (NotSupportedException ex6)
{
ex = ex6;
}
catch (XmlException ex7)
{
ex = ex7;
}
catch (XPathException ex8)
{
ex = ex8;
}
catch
{
throw;
}
finally
{
if (windowsImpersonationContext != null)
{
windowsImpersonationContext.Dispose();
this.impersonating = false;
}
}
if (ex != null)
{
this.HandleException(ex);
}
return(null);
}
static RemoteNotificationRequester()
{
CertificateValidationManager.RegisterCallback("RemoteNotification", new RemoteCertificateValidationCallback(RemoteNotificationRequester.SslCertificateValidationCallback));
}
// Token: 0x060011E4 RID: 4580 RVA: 0x0006C1A8 File Offset: 0x0006A3A8
public static void Initialize()
{
CertificateValidationManager.RegisterCallback("OWA", new RemoteCertificateValidationCallback(ProxyEventHandler.SslCertificateValidationCallback));
CertificateValidationManager.RegisterCallback("OWA_IgnoreCertErrors", new RemoteCertificateValidationCallback(ProxyEventHandler.SslCertificateIgnoreCallback));
ServicePointManager.DefaultConnectionLimit = Globals.ServicePointConnectionLimit;
}
// Token: 0x06001A9F RID: 6815 RVA: 0x00063D84 File Offset: 0x00061F84
static GetPersonaPhoto()
{
CertificateValidationManager.RegisterCallback("GetPersonaPhoto", new RemoteCertificateValidationCallback(CommonCertificateValidationCallbacks.InternalServerToServer));
}
static AuthMetadataClient()
{
CertificateValidationManager.RegisterCallback("Microsoft.Exchange.Data.Directory.SystemConfiguration.AuthMetadataClient.NoSsl", new RemoteCertificateValidationCallback(AuthMetadataClient.ServerCertificateValidatorIgnoreSslErrors));
CertificateValidationManager.RegisterCallback("Microsoft.Exchange.Data.Directory.SystemConfiguration.AuthMetadataClient", new RemoteCertificateValidationCallback(AuthMetadataClient.ServerCertificateValidator));
}
static GlobalSettings()
{
CertificateValidationManager.RegisterCallback("AirSync", new RemoteCertificateValidationCallback(ProxyHandler.SslCertificateValidationCallback));
}
