public static async Task <WsTrustResponse> SendRequestAsync(WsTrustAddress wsTrustAddress, UserCredential credential, CallState callState, string cloudAudience) { IHttpClient request = PlatformPlugin.HttpClientFactory.Create(wsTrustAddress.Uri.AbsoluteUri, callState); request.ContentType = "application/soap+xml"; if (credential.UserAuthType == UserAuthType.IntegratedAuth) { SetKerberosOption(request); } if (string.IsNullOrEmpty(cloudAudience)) { cloudAudience = defaultAppliesTo; } StringBuilder messageBuilder = BuildMessage(cloudAudience, wsTrustAddress, credential); string soapAction = XmlNamespace.Issue.ToString(); if (wsTrustAddress.Version == WsTrustVersion.WsTrust2005) { soapAction = XmlNamespace.Issue2005.ToString(); } WsTrustResponse wstResponse; try { request.BodyParameters = new StringRequestParameters(messageBuilder); request.Headers["SOAPAction"] = soapAction; IHttpWebResponse response = await request.GetResponseAsync().ConfigureAwait(false); wstResponse = WsTrustResponse.CreateFromResponse(EncodingHelper.GenerateStreamFromString(response.ResponseString), wsTrustAddress.Version); } catch (HttpRequestWrapperException ex) { string errorMessage; try { using (Stream stream = EncodingHelper.GenerateStreamFromString(ex.WebResponse.ResponseString)) { XDocument responseDocument = WsTrustResponse.ReadDocumentFromResponse(stream); errorMessage = WsTrustResponse.ReadErrorResponse(responseDocument, callState); } } catch (AdalException) { errorMessage = "See inner exception for detail."; } throw new AdalServiceException( AdalError.FederatedServiceReturnedError, string.Format(AdalErrorMessage.FederatedServiceReturnedErrorTemplate, wsTrustAddress.Uri, errorMessage), null, ex); } return(wstResponse); }
/// <summary> /// Execute request and returns entityResponse - ASYNC. /// </summary> /// <param name="httpWebRequest">Http web request.</param> /// <returns></returns> protected async Task <IHttpWebResponse> ExecuteRequestAsync(IHttpWebRequest httpWebRequest) { this.PreExecuteRequest(httpWebRequest); IHttpWebResponse httpWebResponse = await httpWebRequest.GetResponseAsync(); this.ProcessHttpWebResponseInternal(httpWebResponse); return(httpWebResponse); }
/// <summary> /// Execute request and returns entityResponse. /// </summary> /// <param name="httpWebRequest">Http web request.</param> /// <returns></returns> protected IHttpWebResponse ExecuteRequest(IHttpWebRequest httpWebRequest) { this.PreExecuteRequest(httpWebRequest); IHttpWebResponse httpWebResponse = httpWebRequest.GetResponse(); this.ProcessHttpWebResponseInternal(httpWebResponse); return(httpWebResponse); }
/// <summary> /// Execute POST request. /// </summary> /// <param name="content"></param> /// <returns></returns> protected IHttpWebResponse ExecuteRequest(string content) { using (IHttpWebRequest httpWebRequest = HttpWebRequest.Patch(this.RestUrl, content)) { IHttpWebResponse httpWebResponse = this.ExecuteRequest(httpWebRequest); return(httpWebResponse); } }
/// <summary> /// Reads the full stream from the response and returns the content as stream, /// using the correct encoding. /// </summary> /// <param name="response">Web response from request to Solr</param> private string ReadResponseToString(IHttpWebResponse response) { using (var responseStream = response.GetResponseStream()) using (var reader = new StreamReader(responseStream, TryGetEncoding(response))) { return(reader.ReadToEnd()); } }
private Encoding TryGetEncoding(IHttpWebResponse response) { try { return(Encoding.GetEncoding(response.CharacterSet)); } catch { return(Encoding.UTF8); } }
private async Task <string> ReadResponseToStringAsync(IHttpWebResponse response) { using (var responseStream = response.GetResponseStream()) using (var reader = new StreamReader(responseStream, TryGetEncoding(response))) { return(await reader.ReadToEndAsync()); } }
private bool isDeviceAuthChallenge(string endpointType, IHttpWebResponse response, bool respondToDeviceAuthChallenge) { return(PlatformPlugin.DeviceAuthHelper.CanHandleDeviceAuthChallenge && respondToDeviceAuthChallenge && (response.Headers.ContainsKey(WwwAuthenticateHeader) && response.Headers[WwwAuthenticateHeader].StartsWith(PKeyAuthName, StringComparison.CurrentCulture)) && endpointType.Equals(ClientMetricsEndpointType.Token)); }
/// <summary> /// Execute in async fashion. /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> internal async Task <T> ExecuteAsync <T>() { IHttpWebResponse response = await this.ExecuteRequestAsync(this.PatchContent); return(this.Deserialize <T>( response, this.DeserializationType)); }
private bool isDeviceAuthChallenge(IHttpWebResponse response, bool respondToDeviceAuthChallenge) { return(PlatformPlugin.DeviceAuthHelper.CanHandleDeviceAuthChallenge && respondToDeviceAuthChallenge && response?.Headers != null && response.Headers.ContainsKey(WwwAuthenticateHeader) && response.Headers[WwwAuthenticateHeader].StartsWith(PKeyAuthName, StringComparison.OrdinalIgnoreCase)); }
/// <summary> /// Attempts to deflate response stream if compressed in any way. /// </summary> /// <see cref="http://west-wind.com/weblog/posts/102969.aspx"/> /// <param name="response">Web response from request to Solr</param> /// <returns></returns> private string UncompressResponse(IHttpWebResponse response) { using (var responseStream = response.GetResponseStream()) using (var compressedStream = GetWrappedCompressionStream(response, responseStream)) { var reader = new StreamReader(compressedStream, TryGetEncoding(response)); return(reader.ReadToEnd()); } }
/// <summary> /// Execute and returns result. /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> internal T Execute <T>() { IHttpWebResponse response = this.ExecuteRequest(this.PatchContent); return(this.Deserialize <T>( response, this.DeserializationType)); }
private static void SetKeepAliveHeaders(HttpWebRequest request, IHttpWebResponse previousResponse) { if ((previousResponse == null) || !IsNtlmOrKerberos(previousResponse.AuthType)) { request.KeepAlive = false; request.ProtocolVersion = HttpVersion.Version10; } }
/// <summary> /// Initializes a new instance of the exception class with a specified /// error code, error message and a reference to the inner exception that is the cause of /// this exception. /// </summary> /// <param name="errorCode">The protocol error code returned by the service or generated by client. This is the code you can rely on for exception handling.</param> /// <param name="message">The error message that explains the reason for the exception.</param> /// <param name="serviceErrorCodes">The specific error codes that may be returned by the service.</param> /// <param name="innerException">The exception that is the cause of the current exception, or a null reference if no inner exception is specified. It may especially contain the actual error message returned by the service.</param> public AdalServiceException(string errorCode, string message, string[] serviceErrorCodes, WebException innerException) : base(errorCode, message, innerException) { IHttpWebResponse response = NetworkPlugin.HttpWebRequestFactory.CreateResponse(innerException.Response); this.StatusCode = (response != null) ? (int)response.StatusCode : 0; this.ServiceErrorCodes = serviceErrorCodes; }
public IHttpResponse CreateHttpResponse(IHttpWebResponse webResponse, Stream body) { var deserializer = transmissionSettings.FindSerializer(webResponse.ContentType); return(new HttpResponse( deserializer, body, webResponse.BuildState())); }
public IHttpResponse CreateHttpResponse(IHttpWebResponse webResponse, Stream body) { var deserializer = transmissionSettings.FindSerializer(webResponse.ContentType); return new HttpResponse( deserializer, body, webResponse.BuildState()); }
/// <summary> /// Execute POST request - Async /// </summary> /// <param name="content"></param> /// <returns></returns> protected async Task <IHttpWebResponse> ExecuteRequestAsync(string content) { using (IHttpWebRequest httpWebRequest = HttpWebRequest.Patch(this.RestUrl, content)) { IHttpWebResponse httpWebResponse = await this.ExecuteRequestAsync(httpWebRequest); return(httpWebResponse); } }
public static ExceptionDetail FromHttpResponse(IHttpWebResponse response) { return(new ExceptionDetail() { ResponseBody = response?.Body, StatusCode = response != null ? (int)response.StatusCode : -1, HttpResponseHeaders = response?.Headers }); }
/// <summary> /// Executes request. /// </summary> /// <returns></returns> public T Execute() { using (IHttpWebRequest httpWebRequest = HttpWebRequest.Get(this.RestUrl)) { IHttpWebResponse httpWebResponse = this.ExecuteRequest(httpWebRequest); return(this.Deserialize <T>( httpWebResponse, this.DeserializationType)); } }
private void ProcessResponse(IHttpWebResponse httpWebResponse) { if (httpWebResponse.Cookies != null) Cookies = httpWebResponse.Cookies.Cast<Cookie>().ToList(); using (var reader = new StreamReader(httpWebResponse.GetResponseStream())) { Content = reader.ReadToEnd(); } }
public Void Parse(IHttpWebResponse response) { using (response) { ResponseParseUtils.HandleStatusCode(response, HttpStatusCode.NoContent); var requestId = response.Headers.GetRequestIdFromHeader(); Log.Debug($"Request: {requestId}"); return(new Void()); } }
public static async Task <WsTrustResponse> SendRequestAsync(WsTrustAddress wsTrustAddress, UserCredential credential, CallState callState) { IHttpWebRequest request = NetworkPlugin.HttpWebRequestFactory.Create(wsTrustAddress.Uri.AbsoluteUri); request.ContentType = "application/soap+xml;"; if (credential.UserAuthType == UserAuthType.IntegratedAuth) { SetKerberosOption(request); } StringBuilder messageBuilder = BuildMessage(DefaultAppliesTo, wsTrustAddress, credential); string soapAction = XmlNamespace.Issue.ToString(); if (wsTrustAddress.Version == WsTrustVersion.WsTrust2005) { soapAction = XmlNamespace.Issue2005.ToString(); } Dictionary <string, string> headers = new Dictionary <string, string> { { "SOAPAction", soapAction } }; WsTrustResponse wstResponse; try { HttpHelper.SetPostRequest(request, new RequestParameters(messageBuilder), callState, headers); IHttpWebResponse response = await request.GetResponseSyncOrAsync(callState); wstResponse = WsTrustResponse.CreateFromResponse(response.GetResponseStream(), wsTrustAddress.Version); } catch (WebException ex) { string errorMessage; try { XDocument responseDocument = WsTrustResponse.ReadDocumentFromResponse(ex.Response.GetResponseStream()); errorMessage = WsTrustResponse.ReadErrorResponse(responseDocument, callState); } catch (AdalException) { errorMessage = "See inner exception for detail."; } throw new AdalServiceException( AdalError.FederatedServiceReturnedError, string.Format(AdalErrorMessage.FederatedServiceReturnedErrorTemplate, wsTrustAddress.Uri, errorMessage), null, ex); } return(wstResponse); }
public IHttpResponse CreateHttpResponse(IHttpWebResponse webResponse) { var deserializer = transmissionSettings.FindSerializer(webResponse.ContentType); var body = webResponse.ReadBody(); return new HttpResponse( webResponse.ResponseUri, webResponse.StatusCode, body, deserializer); }
public HttpWebHelperResult(IHttpWebRequest httpWebRequest, IHttpWebResponse httpWebResponse, Exception exception, Exception innerException, bool isCancelled, bool completeSynchronsouly, Stream responseSaveStream, object state) { _httpWebRequest = httpWebRequest; _httpWebResponse = httpWebResponse; _exception = exception; _innerException = innerException; _isCancelled = isCancelled; _completeSynchronsouly = completeSynchronsouly; _responseSaveStream = responseSaveStream; _state = state; }
/// <inheritdoc/> public async Task <WsTrustResponse> GetWsTrustResponseAsync( WsTrustEndpoint wsTrustEndpoint, string wsTrustRequest, RequestContext requestContext) { var headers = new Dictionary <string, string> { { "ContentType", "application/soap+xml" }, { "SOAPAction", (wsTrustEndpoint.Version == WsTrustVersion.WsTrust2005) ? XmlNamespace.Issue2005.ToString() : XmlNamespace.Issue.ToString() } }; var body = new StringContent( wsTrustRequest, Encoding.UTF8, headers["ContentType"]); IHttpWebResponse resp = await _httpManager.SendPostForceResponseAsync(wsTrustEndpoint.Uri, headers, body, requestContext).ConfigureAwait(false); if (resp.StatusCode != System.Net.HttpStatusCode.OK) { string errorMessage = null; try { errorMessage = WsTrustResponse.ReadErrorResponse(XDocument.Parse(resp.Body, LoadOptions.None), requestContext); } catch (System.Xml.XmlException) { errorMessage = resp.Body; } throw MsalExceptionFactory.GetServiceException( CoreErrorCodes.FederatedServiceReturnedError, string.Format( CultureInfo.CurrentCulture, CoreErrorMessages.FederatedServiceReturnedErrorTemplate, wsTrustEndpoint.Uri, errorMessage), new ExceptionDetail() { StatusCode = (int)resp.StatusCode, ResponseBody = resp.Body, HttpResponseHeaders = resp.Headers }); } try { return(WsTrustResponse.CreateFromResponse(resp.Body, wsTrustEndpoint.Version)); } catch (System.Xml.XmlException ex) { throw MsalExceptionFactory.GetClientException( CoreErrorCodes.ParsingWsTrustResponseFailed, CoreErrorCodes.ParsingWsTrustResponseFailed, ex); } }
/// <summary> /// Return the character set encoding for an IHttpWebResponse, or null if no encoding is /// specified. /// </summary> /// /// <param name="response"> /// The response. /// </param> /// /// <returns> /// The encoding, or null if no encoding was specified on the response, or the specified encoding /// was not recognized. /// </returns> public static Encoding GetEncoding(IHttpWebResponse response) { Encoding encoding = null; if (!String.IsNullOrEmpty(response.CharacterSet)) { HtmlParser.HtmlEncoding.TryGetEncoding(response.CharacterSet, out encoding); } return(encoding); }
private bool IsDeviceAuthChallenge(IHttpWebResponse response, bool respondToDeviceAuthChallenge) { return(DeviceAuthHelper.CanHandleDeviceAuthChallenge && response != null && respondToDeviceAuthChallenge && response?.Headers != null && response.StatusCode == HttpStatusCode.Unauthorized && response.Headers.Contains(WwwAuthenticateHeader) && response.Headers.GetValues(WwwAuthenticateHeader).FirstOrDefault() .StartsWith(PKeyAuthName, StringComparison.OrdinalIgnoreCase)); }
/// <summary> /// Execute request - ASYNC. /// </summary> /// <returns></returns> public async Task <T> ExecuteAsync() { using (IHttpWebRequest httpWebRequest = HttpWebRequest.Get(this.RestUrl)) { IHttpWebResponse httpWebResponse = await this.ExecuteRequestAsync(httpWebRequest); return(this.Deserialize <T>( httpWebResponse, this.DeserializationType)); } }
private static IHttpWebResponse GetResponse(WebResponse response) { IHttpWebResponse response2 = response as IHttpWebResponse; if (response2 != null) { return(response2); } HttpWebResponse response3 = response as HttpWebResponse; return((response3 != null) ? new HttpWebResponseWrapper(response3) : null); }
private void ProcessResponse(IHttpWebResponse httpWebResponse) { if (httpWebResponse.Cookies != null) { Cookies = httpWebResponse.Cookies.Cast <Cookie>().ToList(); } using (var reader = new StreamReader(httpWebResponse.GetResponseStream())) { Content = reader.ReadToEnd(); } }
private static bool ShouldKeepAliveBeUsedInRequest(HttpWebRequest request, IHttpWebResponse response) { if (request == null) { throw new ArgumentNullException("request"); } if (response == null) { throw new ArgumentNullException("response"); } return(!request.KeepAlive && IsNtlmOrKerberos(response.AuthType)); }
public virtual void GetResponse(IHttpWebRequest request, string filename, bool streamResponse) { try { _response = request.GetResponse(); } catch (WebException webException) { if (webException.Response == null) { throw; } _response = new HttpWebResponseWrapper((HttpWebResponse)webException.Response); } GetHeaders(); if (streamResponse) { return; } using (var stream = _response.GetResponseStream()) { if (stream == null) { return; } if (!string.IsNullOrEmpty(filename)) { using (var filestream = new FileStream(filename, FileMode.CreateNew)) { int count; var buffer = new byte[8192]; while ((count = stream.Read(buffer, 0, buffer.Length)) > 0) { filestream.Write(buffer, 0, count); } } } else { var encoding = string.IsNullOrEmpty(CharacterSet) ? Encoding.UTF8 : Encoding.GetEncoding(CharacterSet); using (var reader = new StreamReader(stream, encoding)) { RawText = reader.ReadToEnd(); } } } }
internal static void HandleStatusCode(IHttpWebResponse response, params HttpStatusCode[] expectedStatusCodes) { var actualStatusCode = response.StatusCode; if (expectedStatusCodes.Contains(actualStatusCode)) { return; } var errorResponse = GetErrorResponse(response); throw new ErrorResponseException(errorResponse); }
public static TokenResponse CreateFromErrorResponse(IHttpWebResponse webResponse) { if (webResponse == null) { return new TokenResponse { Error = AdalError.ServiceReturnedError, ErrorDescription = AdalErrorMessage.ServiceReturnedError }; } Stream responseStream = webResponse.ResponseStream; if (responseStream == null) { return new TokenResponse { Error = AdalError.Unknown, ErrorDescription = AdalErrorMessage.Unknown }; } TokenResponse tokenResponse; try { DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(TokenResponse)); tokenResponse = ((TokenResponse)serializer.ReadObject(responseStream)); // Reset stream position to make it possible for application to read HttpRequestException body again responseStream.Position = 0; } catch (SerializationException) { responseStream.Position = 0; tokenResponse = new TokenResponse { Error = (webResponse.StatusCode == HttpStatusCode.ServiceUnavailable) ? AdalError.ServiceUnavailable : AdalError.Unknown, ErrorDescription = ReadStreamContent(responseStream) }; } return tokenResponse; }
private static void SetKeepAliveHeaders(HttpWebRequest request, IHttpWebResponse previousResponse) { // KeepAlive is required for NTLM and Kerberos authentication. If we've never been authenticated or are using a different auth, we // should not require KeepAlive. // REVIEW: The WWW-Authenticate header is tricky to parse so a Equals might not be correct. if (previousResponse == null || (!String.Equals(previousResponse.AuthType, "NTLM", StringComparison.OrdinalIgnoreCase) && !String.Equals(previousResponse.AuthType, "Kerberos", StringComparison.OrdinalIgnoreCase))) { // This is to work around the "The underlying connection was closed: An unexpected error occurred on a receive." // exception. request.KeepAlive = false; request.ProtocolVersion = HttpVersion.Version10; } }
private static bool IsAuthenticationResponse(IHttpWebResponse response) { return response.StatusCode == HttpStatusCode.Unauthorized || response.StatusCode == HttpStatusCode.ProxyAuthenticationRequired; }
private HttpWebHelperResult CopyResponseStream(IHttpWebRequest httpWebRequest, IHttpWebResponse httpWebResponse, Exception innerException, Stream responseStream, Stream responseSaveStream) { try { CopyStream(responseStream, responseSaveStream, false, false); responseStream.Close(); return new HttpWebHelperResult(httpWebRequest, httpWebResponse, null, innerException, false, true, responseSaveStream, null); } catch (Exception ex) { return new HttpWebHelperResult(httpWebRequest, httpWebResponse, ex, innerException, false, true, responseSaveStream, null); } }
public HttpRequestWrapperException(IHttpWebResponse webResponse, Exception innerException) : base(string.Empty, innerException) { this.WebResponse = webResponse; }
private static void ReadResponseToFileStream(string localFilePath, IHttpWebResponse response) { IStream data = response.GetResponseStream(); var byteBuffer = new byte[4096]; using (IStream output = FileSystem.CreateStream(localFilePath, FileMode.Create)) { int bytesRead; do { bytesRead = data.Read(byteBuffer, 0, byteBuffer.Length); if (bytesRead > 0) { output.Write(byteBuffer, 0, bytesRead); } } while (bytesRead > 0); } data.Close(); response.Close(); }
private Encoding TryGetEncoding(IHttpWebResponse response) { try { return Encoding.GetEncoding(response.CharacterSet); } catch { return Encoding.UTF8; } }
private void CopyResponseStream(IHttpWebRequest httpWebRequest, IHttpWebResponse httpWebResponse, Exception innerException, Stream responseStream, Stream responseSaveStream, AsyncCallback callback, object state) { if (AsyncResponseStream && responseSaveStream != null) { // pure read/write async CopyStreamAsync(responseStream, responseSaveStream, FlushResponseStream, FlushResponseSaveStream, (source, destination, exception) => { source.Close(); callback(new HttpWebHelperResult(httpWebRequest, httpWebResponse, exception, null, false, false, responseSaveStream, state)); }); } else { try { if (responseSaveStream == null) ReadStream(responseStream, FlushResponseStream); else CopyStream(responseStream, responseSaveStream, FlushResponseStream, FlushResponseSaveStream); responseStream.Close(); if (callback != null) callback(new HttpWebHelperResult(httpWebRequest, httpWebResponse, null, innerException, false, false, responseSaveStream, state)); } catch (Exception ex) { if (callback != null) callback(new HttpWebHelperResult(httpWebRequest, httpWebResponse, ex, null, false, false, responseSaveStream, state)); } } }
/// <summary> /// Return the character set encoding for an IHttpWebResponse, or null if no encoding is /// specified. /// </summary> /// /// <param name="response"> /// The response. /// </param> /// /// <returns> /// The encoding, or null if no encoding was specified on the response, or the specified encoding /// was not recognized. /// </returns> public static Encoding GetEncoding(IHttpWebResponse response) { Encoding encoding = null; if (!String.IsNullOrEmpty(response.ContentType) && response.ContentType.Contains("charset=") && !String.IsNullOrEmpty(response.CharacterSet) ) { HtmlParser.HtmlEncoding.TryGetEncoding(response.CharacterSet, out encoding); } return encoding; }
static void SetKeepAliveHeaders(HttpWebRequest request, IHttpWebResponse previousResponse) { // KeepAlive is required for NTLM and Kerberos authentication. If we've never been authenticated or are // using a different auth, we should not require KeepAlive. // REVIEW: The WWW-Authenticate header is tricky to parse so a Equals might not be correct. if (previousResponse != null && IsNtlmOrKerberos (previousResponse.AuthType)) return; // This is to work around the "The underlying connection was closed: An unexpected error occurred on a receive." exception. request.KeepAlive = false; request.ProtocolVersion = HttpVersion.Version10; }
public CouchDbResponse(IHttpWebResponse webResponse, Exception exception) : this(webResponse) { _exception = exception; }
public CouchDbResponse(IHttpWebResponse webResponse) { _webResponse = webResponse; }
public static TokenResponse CreateFromErrorResponse(IHttpWebResponse webResponse) { if (webResponse == null) { return new TokenResponse { Error = MsalError.ServiceReturnedError, ErrorDescription = MsalErrorMessage.ServiceReturnedError }; } StringBuilder responseStreamString = new StringBuilder(); TokenResponse tokenResponse = null; using (Stream responseStream = webResponse.ResponseStream) { if (responseStream == null) { return new TokenResponse { Error = MsalError.Unknown, ErrorDescription = MsalErrorMessage.Unknown }; } try { responseStreamString.Append(ReadStreamContent(responseStream)); using (MemoryStream ms = new MemoryStream(responseStreamString.ToByteArray())) { DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(TokenResponse)); tokenResponse = ((TokenResponse)serializer.ReadObject(ms)); } } catch (SerializationException ex) { PlatformPlugin.Logger.Warning(null, ex.Message); tokenResponse = new TokenResponse { Error = (webResponse.StatusCode == HttpStatusCode.ServiceUnavailable) ? MsalError.ServiceUnavailable : MsalError.Unknown, ErrorDescription = responseStreamString.ToString() }; } } return tokenResponse; }
public MirthConnectResponse(IHttpWebResponse httpWebResponse) { ProcessResponse(httpWebResponse); }
/// <summary> /// Reads the full stream from the response and returns the content as stream, /// using the correct encoding. /// </summary> /// <param name="response">Web response from request to Solr</param> /// <returns></returns> private string ReadResponseToString(IHttpWebResponse response) { using (var responseStream = response.GetResponseStream()) using (var reader = new StreamReader(responseStream, TryGetEncoding(response))) { return reader.ReadToEnd(); } }
/// <summary> /// Return the character set encoding for an IHttpWebResponse. /// </summary> /// /// <param name="response"> /// The response. /// </param> /// /// <returns> /// The encoding, or null if no encoding was specified on the response, or the specified encoding /// was not recognized. /// </returns> public static Encoding GetEncoding(IHttpWebResponse response) { Encoding encoding = null; if (!String.IsNullOrEmpty(response.CharacterSet)) { EncodingInfo info; if (Encodings.TryGetValue(response.CharacterSet, out info)) { encoding = info.GetEncoding(); } } return encoding; }
static bool ShouldKeepAliveBeUsedInRequest(HttpWebRequest request, IHttpWebResponse response) { if (request == null) throw new ArgumentNullException ("request"); if (response == null) throw new ArgumentNullException ("response"); return !request.KeepAlive && IsNtlmOrKerberos (response.AuthType); }
/// <summary> /// Initializes a new instance of the <see cref="FluentHttpResponse"/> class. /// </summary> /// <param name="request"> /// The fluent http web request. /// </param> /// <param name="httpWebResponse"> /// The http web response. /// </param> public FluentHttpResponse(FluentHttpRequest request, IHttpWebResponse httpWebResponse) : this() { _request = request; _httpWebResponse = httpWebResponse; }
public ResponseReceivedEventArgs(IHttpWebResponse response, Exception exception, object asyncState) { _response = response; _exception = exception; _asyncState = asyncState; }
public WebResponse GetResponse() { _previousRequest = null; _previousResponse = null; _previousStatusCode = null; _usingSTSAuth = false; _continueIfFailed = true; _proxyCredentialsRetryCount = 0; _credentialsRetryCount = 0; int failureCount = 0; const int MaxFailureCount = 10; while (true) { // Create the request var request = (HttpWebRequest)_createRequest(); ConfigureRequest(request); try { if (_disableBuffering) { request.AllowWriteStreamBuffering = false; // When buffering is disabled, we need to add the Authorization header // for basic authentication by ourselves. bool basicAuth = _previousResponse != null && _previousResponse.AuthType != null && _previousResponse.AuthType.IndexOf("Basic", StringComparison.OrdinalIgnoreCase) != -1; var networkCredentials = request.Credentials.GetCredential(request.RequestUri, "Basic"); if (networkCredentials != null && basicAuth) { string authInfo = networkCredentials.UserName + ":" + networkCredentials.Password; authInfo = Convert.ToBase64String(System.Text.Encoding.Default.GetBytes(authInfo)); request.Headers["Authorization"] = "Basic " + authInfo; _basicAuthIsUsedInPreviousRequest = true; } } // Prepare the request, we do something like write to the request stream // which needs to happen last before the request goes out _prepareRequest(request); WebResponse response = request.GetResponse(); // Cache the proxy and credentials _proxyCache.Add(request.Proxy); ICredentials credentials = request.Credentials; _credentialCache.Add(request.RequestUri, credentials); _credentialCache.Add(response.ResponseUri, credentials); return response; } catch (WebException ex) { ++failureCount; if (failureCount >= MaxFailureCount) { throw; } 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; } if (!EnvironmentUtility.IsNet45Installed && request.AllowWriteStreamBuffering == false && response.AuthType != null && IsNtlmOrKerberos(response.AuthType)) { // integrated windows authentication does not work when buffering is // disabled on .net 4.0. throw; } _previousRequest = request; _previousResponse = response; _previousStatusCode = _previousResponse.StatusCode; } } } }
/// <summary> /// Retrieve the information from the HTTP ResponseInfo stream /// </summary> /// <param name="httpResponse">Reponse object from random.org</param> /// <returns>JSON object containing response from random.org</returns> private static string GetResponse(IHttpWebResponse httpResponse) { string response = null; Stream responseStream = httpResponse.GetResponseStream(); if (responseStream != null) { using (StreamReader reader = new StreamReader(responseStream)) response = reader.ReadToEnd(); } return response; }
public HttpWebResponse GetResponse(CancellationToken token) { _previousRequest = null; _previousResponse = null; _previousStatusCode = null; _usingSTSAuth = false; _continueIfFailed = true; _proxyCredentialsRetryCount = 0; _credentialsRetryCount = 0; int failureCount = 0; const int MaxFailureCount = 10; while (true) { // Create the request var request = (HttpWebRequest)_createRequest(); MakeCancelable (request, token); ConfigureRequest(request); try { var auth = request.Headers["Authorization"]; _basicAuthIsUsedInPreviousRequest = (auth != null) && auth.StartsWith("Basic ", StringComparison.Ordinal); // Prepare the request, we do something like write to the request stream // which needs to happen last before the request goes out _prepareRequest(request); HttpWebResponse response = (HttpWebResponse)request.GetResponse(); // Cache the proxy and credentials _proxyCache.Add(request.Proxy); ICredentials credentials = request.Credentials; _credentialCache.Add(request.RequestUri, credentials); _credentialCache.Add(response.ResponseUri, credentials); return response; } catch (WebException ex) { ++failureCount; if (failureCount >= MaxFailureCount) { throw; } 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; } } } }
private void ReadResponseStream(IHttpWebRequest httpWebRequest, IHttpWebResponse httpWebResponse, Exception innerException, Stream responseSaveStream, AsyncCallback callback, object state) { Stream responseStream = null; Exception exception = null; try { responseStream = httpWebResponse.GetResponseStream(); } catch (WebException ex) { exception = new WebExceptionWrapper(ex); } catch (Exception ex) { exception = ex; } finally { if (exception == null) { CopyResponseStream(httpWebRequest, httpWebResponse, innerException, responseStream, responseSaveStream, callback, state); } else { if (callback != null) callback(new HttpWebHelperResult(httpWebRequest, httpWebResponse, exception, null, false, false, responseSaveStream, state)); } } }
/// <summary> /// Return the character set encoding for an IHttpWebResponse /// </summary> /// /// <param name="response"> /// The response. /// </param> /// /// <returns> /// The encoding. /// </returns> public static Encoding GetEncoding(IHttpWebResponse response) { return String.IsNullOrEmpty(response.CharacterSet) ? Encoding.GetEncoding("ISO-8859-1") : Encoding.GetEncoding(response.CharacterSet); }
private HttpWebHelperResult ReadResponseStream(IHttpWebRequest httpWebRequest, IHttpWebResponse httpWebResponse, Exception innerException, Stream responseSaveStream) { Stream responseStream = null; Exception exception = null; try { responseStream = httpWebResponse.GetResponseStream(); } catch (WebException ex) { exception = new WebExceptionWrapper(ex); } return exception == null ? CopyResponseStream(httpWebRequest, httpWebResponse, innerException, responseStream, responseSaveStream) : new HttpWebHelperResult(httpWebRequest, httpWebResponse, exception, innerException, false, true, responseSaveStream, null); }
private static AuthenticationParameters CreateFromUnauthorizedResponseCommon(IHttpWebResponse response) { if (response == null) { throw new ArgumentNullException("response"); } AuthenticationParameters authParams; if (response.StatusCode == HttpStatusCode.Unauthorized) { if (response.Headers.Keys.Contains(AuthenticateHeader)) { authParams = CreateFromResponseAuthenticateHeader(response.Headers[AuthenticateHeader]); } else { var ex = new ArgumentException(MsalErrorMessage.MissingAuthenticateHeader, "response"); PlatformPlugin.Logger.Error(null, ex); throw ex; } } else { var ex = new ArgumentException(MsalErrorMessage.UnauthorizedHttpStatusCodeExpected, "response"); PlatformPlugin.Logger.Error(null, ex); throw ex; } return authParams; }