static Systems()
{
_exCookieManager = (ICookieManager)Providers.GetProvider(ProviderType.ICookieManager);
_exLogSystem = (ILogSystem)Providers.GetProvider(ProviderType.ILogSystem);
_exCredentialCache = (ICredentialCache)Providers.GetProvider(ProviderType.ICredentialCache);
_exUAC = (IUAC)Providers.GetProvider(ProviderType.IUAC);
}
static Systems()
{
_exCookieManager = (ICookieManager)Providers.GetProvider(ProviderType.ICookieManager);
_exLogSystem = (ILogSystem)Providers.GetProvider(ProviderType.ILogSystem);
_exCredentialCache = (ICredentialCache)Providers.GetProvider(ProviderType.ICredentialCache);
_exUAC = (IUAC)Providers.GetProvider(ProviderType.IUAC);
}
public RequestHelper(Func <WebRequest> createRequest, Action <WebRequest> prepareRequest, IProxyCache proxyCache, ICredentialCache credentialCache, ICredentialProvider credentialProvider, bool disableBuffering)
{
this._createRequest = createRequest;
this._prepareRequest = prepareRequest;
this._proxyCache = proxyCache;
this._credentialCache = credentialCache;
this._credentialProvider = credentialProvider;
this._disableBuffering = disableBuffering;
}
public RequestHelper(Func <HttpWebRequest> createRequest,
Action <HttpWebRequest> prepareRequest,
IProxyCache proxyCache,
ICredentialCache credentialCache,
ICredentialProvider credentialProvider)
{
_createRequest = createRequest;
_prepareRequest = prepareRequest;
_proxyCache = proxyCache;
_credentialCache = credentialCache;
_credentialProvider = credentialProvider;
}
public RequestHelper(Func<HttpWebRequest> createRequest,
Action<HttpWebRequest> prepareRequest,
IProxyCache proxyCache,
ICredentialCache credentialCache,
ICredentialProvider credentialProvider)
{
_createRequest = createRequest;
_prepareRequest = prepareRequest;
_proxyCache = proxyCache;
_credentialCache = credentialCache;
_credentialProvider = credentialProvider;
}
public RequestHelper(Func<WebRequest> createRequest,
Action<WebRequest> prepareRequest,
IProxyCache proxyCache,
ICredentialCache credentialCache,
ICredentialProvider credentialProvider,
bool disableBuffering)
{
_createRequest = createRequest;
_prepareRequest = prepareRequest;
_proxyCache = proxyCache;
_credentialCache = credentialCache;
_credentialProvider = credentialProvider;
_disableBuffering = disableBuffering;
}
public RequestHelper(Func <WebRequest> createRequest,
Action <WebRequest> prepareRequest,
IProxyCache proxyCache,
ICredentialCache credentialCache,
ICredentialProvider credentialProvider,
bool disableBuffering,
bool bypassProxy)
{
_createRequest = createRequest;
_prepareRequest = prepareRequest;
_proxyCache = proxyCache;
_credentialCache = credentialCache;
_credentialProvider = credentialProvider;
_disableBuffering = disableBuffering;
_bypassProxy = bypassProxy;
}
internal static WebResponse GetResponse(Func <WebRequest> createRequest,
Action <WebRequest> prepareRequest,
IProxyCache proxyCache,
ICredentialCache credentialCache,
ICredentialProvider credentialProvider)
{
HttpWebRequest previousRequest = null;
IHttpWebResponse previousResponse = null;
HttpStatusCode? previousStatusCode = null;
bool usingSTSAuth = false;
bool continueIfFailed = true;
int proxyCredentialsRetryCount = 0;
int credentialsRetryCount = 0;
while (true)
{
// Create the request
var request = (HttpWebRequest)createRequest();
request.Proxy = proxyCache.GetProxy(request.RequestUri);
if (request.Proxy != null && request.Proxy.Credentials == null)
{
request.Proxy.Credentials = CredentialCache.DefaultCredentials;
}
if (previousResponse == null || ShouldKeepAliveBeUsedInRequest(previousRequest, previousResponse))
{
// Try to use the cached credentials (if any, for the first request)
request.Credentials = credentialCache.GetCredentials(request.RequestUri);
// If there are no cached credentials, use the default ones
if (request.Credentials == null)
{
request.UseDefaultCredentials = true;
}
}
else if (previousStatusCode == HttpStatusCode.ProxyAuthenticationRequired)
{
request.Proxy.Credentials = credentialProvider.GetCredentials(request, CredentialType.ProxyCredentials, retrying: proxyCredentialsRetryCount > 0);
continueIfFailed = request.Proxy.Credentials != null;
proxyCredentialsRetryCount++;
}
else if ((previousStatusCode == HttpStatusCode.Unauthorized) && !usingSTSAuth)
{
// If we are using STS, the auth's being performed by a request header. We do not need to ask the user for credentials at this point.
request.Credentials = credentialProvider.GetCredentials(request, CredentialType.RequestCredentials, retrying: credentialsRetryCount > 0);
continueIfFailed = request.Credentials != null;
credentialsRetryCount++;
}
try
{
ICredentials credentials = request.Credentials;
SetKeepAliveHeaders(request, previousResponse);
if (usingSTSAuth)
{
// Add request headers if the server requires STS based auth.
STSAuthHelper.PrepareSTSRequest(request);
}
// Prepare the request, we do something like write to the request stream
// which needs to happen last before the request goes out
prepareRequest(request);
// Wrap the credentials in a CredentialCache in case there is a redirect
// and credentials need to be kept around.
request.Credentials = request.Credentials.AsCredentialCache(request.RequestUri);
WebResponse response = request.GetResponse();
// Cache the proxy and credentials
proxyCache.Add(request.Proxy);
credentialCache.Add(request.RequestUri, credentials);
credentialCache.Add(response.ResponseUri, credentials);
return(response);
}
catch (WebException ex)
{
using (IHttpWebResponse response = GetResponse(ex.Response))
{
if (response == null &&
ex.Status != WebExceptionStatus.SecureChannelFailure)
{
// No response, something went wrong so just rethrow
throw;
}
// Special case https connections that might require authentication
if (ex.Status == WebExceptionStatus.SecureChannelFailure)
{
if (continueIfFailed)
{
// Act like we got a 401 so that we prompt for credentials on the next request
previousStatusCode = HttpStatusCode.Unauthorized;
continue;
}
throw;
}
// If we were trying to authenticate the proxy or the request and succeeded, cache the result.
if (previousStatusCode == HttpStatusCode.ProxyAuthenticationRequired &&
response.StatusCode != HttpStatusCode.ProxyAuthenticationRequired)
{
proxyCache.Add(request.Proxy);
}
else if (previousStatusCode == HttpStatusCode.Unauthorized &&
response.StatusCode != HttpStatusCode.Unauthorized)
{
credentialCache.Add(request.RequestUri, request.Credentials);
credentialCache.Add(response.ResponseUri, request.Credentials);
}
usingSTSAuth = STSAuthHelper.TryRetrieveSTSToken(request.RequestUri, response);
if (!IsAuthenticationResponse(response) || !continueIfFailed)
{
throw;
}
previousRequest = request;
previousResponse = response;
previousStatusCode = previousResponse.StatusCode;
}
}
}
}
/// <summary>
/// Keeps sending requests until a response code that doesn't require authentication happens or if
/// the request requires authentication and the user has stopped trying to enter them (i.e. they hit cancel when they are prompted).
/// </summary>
internal static WebResponse GetResponse(Func<WebRequest> createRequest,
Action<WebRequest> prepareRequest,
IProxyCache proxyCache,
ICredentialCache credentialCache,
ICredentialProvider credentialProvider)
{
IHttpWebResponse previousResponse = null;
HttpStatusCode? previousStatusCode = null;
bool usingSTSAuth = false;
bool continueIfFailed = true;
int proxyCredentialsRetryCount = 0;
int credentialsRetryCount = 0;
while (true)
{
// Create the request
var request = (HttpWebRequest)createRequest();
request.Proxy = proxyCache.GetProxy(request.RequestUri);
if (request.Proxy != null && request.Proxy.Credentials == null)
{
request.Proxy.Credentials = CredentialCache.DefaultCredentials;
}
if (previousResponse == null)
{
// Try to use the cached credentials (if any, for the first request)
request.Credentials = credentialCache.GetCredentials(request.RequestUri);
// If there are no cached credentials, use the default ones
if (request.Credentials == null)
{
request.UseDefaultCredentials = true;
}
}
else if (previousStatusCode == HttpStatusCode.ProxyAuthenticationRequired)
{
request.Proxy.Credentials = credentialProvider.GetCredentials(request, CredentialType.ProxyCredentials, retrying: proxyCredentialsRetryCount > 0);
continueIfFailed = request.Proxy.Credentials != null;
proxyCredentialsRetryCount++;
}
else if ((previousStatusCode == HttpStatusCode.Unauthorized) && !usingSTSAuth)
{
// If we are using STS, the auth's being performed by a request header. We do not need to ask the user for credentials at this point.
request.Credentials = credentialProvider.GetCredentials(request, CredentialType.RequestCredentials, retrying: credentialsRetryCount > 0);
continueIfFailed = request.Credentials != null;
credentialsRetryCount++;
}
try
{
ICredentials credentials = request.Credentials;
SetKeepAliveHeaders(request, previousResponse);
if (usingSTSAuth)
{
// Add request headers if the server requires STS based auth.
STSAuthHelper.PrepareSTSRequest(request);
}
// Prepare the request, we do something like write to the request stream
// which needs to happen last before the request goes out
prepareRequest(request);
// Wrap the credentials in a CredentialCache in case there is a redirect
// and credentials need to be kept around.
request.Credentials = request.Credentials.AsCredentialCache(request.RequestUri);
WebResponse response = request.GetResponse();
// Cache the proxy and credentials
proxyCache.Add(request.Proxy);
credentialCache.Add(request.RequestUri, credentials);
credentialCache.Add(response.ResponseUri, credentials);
return response;
}
catch (WebException ex)
{
using (IHttpWebResponse response = GetResponse(ex.Response))
{
if (response == null &&
ex.Status != WebExceptionStatus.SecureChannelFailure)
{
// No response, something went wrong so just rethrow
throw;
}
// Special case https connections that might require authentication
if (ex.Status == WebExceptionStatus.SecureChannelFailure)
{
if (continueIfFailed)
{
// Act like we got a 401 so that we prompt for credentials on the next request
previousStatusCode = HttpStatusCode.Unauthorized;
continue;
}
throw;
}
// If we were trying to authenticate the proxy or the request and succeeded, cache the result.
if (previousStatusCode == HttpStatusCode.ProxyAuthenticationRequired &&
response.StatusCode != HttpStatusCode.ProxyAuthenticationRequired)
{
proxyCache.Add(request.Proxy);
}
else if (previousStatusCode == HttpStatusCode.Unauthorized &&
response.StatusCode != HttpStatusCode.Unauthorized)
{
credentialCache.Add(request.RequestUri, request.Credentials);
credentialCache.Add(response.ResponseUri, request.Credentials);
}
usingSTSAuth = STSAuthHelper.TryRetrieveSTSToken(request.RequestUri, response);
if (!IsAuthenticationResponse(response) || !continueIfFailed)
{
throw;
}
previousResponse = response;
previousStatusCode = previousResponse.StatusCode;
}
}
}
}
/// <summary>
/// Keeps sending requests until a response code that doesn't require authentication happens or if
/// the request requires authentication and the user has stopped trying to enter them (i.e. they hit cancel when they are prompted).
/// </summary>
internal static WebResponse GetResponse(Func<WebRequest> createRequest,
Action<WebRequest> prepareRequest,
IProxyCache proxyCache,
ICredentialCache credentialCache,
ICredentialProvider credentialProvider)
{
HttpStatusCode? previousStatusCode = null;
string authType = null;
bool continueIfFailed = true;
while (true)
{
// Create the request
WebRequest request = createRequest();
request.Proxy = proxyCache.GetProxy(request.RequestUri);
if (request.Proxy != null && request.Proxy.Credentials == null)
{
request.Proxy.Credentials = CredentialCache.DefaultCredentials;
}
if (previousStatusCode == null)
{
// Try to use the cached credentials (if any, for the first request)
request.Credentials = credentialCache.GetCredentials(request.RequestUri);
if (request.Credentials == null)
{
// If there are no cached credentials, use the default ones
request.UseDefaultCredentials = true;
}
}
else if (previousStatusCode == HttpStatusCode.ProxyAuthenticationRequired)
{
request.Proxy.Credentials = credentialProvider.GetCredentials(request, CredentialType.ProxyCredentials);
continueIfFailed = request.Proxy.Credentials != null;
}
else if (previousStatusCode == HttpStatusCode.Unauthorized)
{
request.Credentials = credentialProvider.GetCredentials(request, CredentialType.RequestCredentials);
continueIfFailed = request.Credentials != null;
}
try
{
ICredentials credentials = request.Credentials;
// KeepAlive is required for NTLM and Kerberos authentication.
// REVIEW: The WWW-Authenticate header is tricky to parse so a Equals might not be correct
if (!String.Equals(authType, "NTLM", StringComparison.OrdinalIgnoreCase) &&
!String.Equals(authType, "Kerberos", StringComparison.OrdinalIgnoreCase))
{
// This is to work around the "The underlying connection was closed: An unexpected error occurred on a receive."
// exception.
var httpRequest = (HttpWebRequest)request;
httpRequest.KeepAlive = false;
httpRequest.ProtocolVersion = HttpVersion.Version10;
}
// Prepare the request, we do something like write to the request stream
// which needs to happen last before the request goes out
prepareRequest(request);
// Wrap the credentials in a CredentialCache in case there is a redirect
// and credentials need to be kept around.
request.Credentials = request.Credentials.AsCredentialCache(request.RequestUri);
WebResponse response = request.GetResponse();
// Cache the proxy and credentials
proxyCache.Add(request.Proxy);
credentialCache.Add(request.RequestUri, credentials);
credentialCache.Add(response.ResponseUri, credentials);
return response;
}
catch (WebException ex)
{
IHttpWebResponse response = GetResponse(ex.Response);
if (response == null &&
ex.Status != WebExceptionStatus.SecureChannelFailure)
{
// No response, something went wrong so just rethrow
throw;
}
// Special case https connections that might require authentication
if (ex.Status == WebExceptionStatus.SecureChannelFailure)
{
if (continueIfFailed)
{
// Act like we got a 401 so that we prompt for credentials on the next request
previousStatusCode = HttpStatusCode.Unauthorized;
continue;
}
throw;
}
// If we were trying to authenticate the proxy or the request and succeeded, cache the result.
if (previousStatusCode == HttpStatusCode.ProxyAuthenticationRequired &&
response.StatusCode != HttpStatusCode.ProxyAuthenticationRequired)
{
proxyCache.Add(request.Proxy);
}
else if (previousStatusCode == HttpStatusCode.Unauthorized &&
response.StatusCode != HttpStatusCode.Unauthorized)
{
credentialCache.Add(request.RequestUri, request.Credentials);
credentialCache.Add(response.ResponseUri, request.Credentials);
}
if (!IsAuthenticationResponse(response) || !continueIfFailed)
{
throw;
}
using (response)
{
previousStatusCode = response.StatusCode;
authType = response.AuthType;
}
}
}
}