private void InitOption(HttpStatus status, HttpCause cause) { this.mStatus = status; this.mCause = cause; this.mHttpErrorResponse = null; this.mWebStatus = WebExceptionStatus.Success; }
internal WebException(string message, string data, Exception innerException, WebExceptionStatus status, WebResponse response, WebExceptionInternalStatus internalStatus) : base(message + ((data != null) ? (": '" + data + "'") : ""), innerException) { this.m_Status = WebExceptionStatus.UnknownError; this.m_Status = status; this.m_Response = response; this.m_InternalStatus = internalStatus; }
public WebException(String msg, Exception inner, WebExceptionStatus status, WebResponse response) : base(msg, inner) { myresponse = response; mystatus = status; }
/// <summary> /// Represents errors that occur during application execution /// </summary> /// <param name="message">The message that describes the error</param> /// <param name="response">The response from server</param> /// <param name="status">The <see cref="System.Net.WebExceptionStatus"/> that triggered this exception.</param> /// <param name="request">HTTP request sent by this SDK.</param> public ConnectionException(string message, string response, WebExceptionStatus status, HttpWebRequest request) : base(message) { this.Response = response; this.WebExceptionStatus = status; this.Request = request; }
internal override IAsyncResult BeginMultipleWrite(BufferOffsetSize[] buffers, AsyncCallback callback, object state) { IAsyncResult result2; if (!this.m_Worker.IsAuthenticated) { BufferAsyncResult result = new BufferAsyncResult(this, buffers, state, callback); if (this.ProcessAuthentication(result)) { return result; } } try { result2 = this.m_Worker.SecureStream.BeginWrite(buffers, callback, state); } catch { if (this.m_Worker.IsCertValidationFailed) { this.m_ExceptionStatus = WebExceptionStatus.TrustFailure; } else if (this.m_Worker.LastSecurityStatus != SecurityStatus.OK) { this.m_ExceptionStatus = WebExceptionStatus.SecureChannelFailure; } else { this.m_ExceptionStatus = WebExceptionStatus.SendFailure; } throw; } return result2; }
// // This version of an Ssl Stream is for internal HttpWebrequest use. // This Ssl client owns the underlined socket // The TlsStream will own secured read/write and disposal of the passed "networkStream" stream. // public TlsStream(string destinationHost, NetworkStream networkStream, X509CertificateCollection clientCertificates, ServicePoint servicePoint, object initiatingRequest, ExecutionContext executionContext) :base(networkStream, true) { // WebRequest manages the execution context manually so we have to ensure we get one for SSL client certificate demand _ExecutionContext = executionContext; if (_ExecutionContext == null) { _ExecutionContext = ExecutionContext.Capture(); } // GlobalLog.Enter("TlsStream::TlsStream", "host="+destinationHost+", #certs="+((clientCertificates == null) ? "none" : clientCertificates.Count.ToString(NumberFormatInfo.InvariantInfo))); if (Logging.On) Logging.PrintInfo(Logging.Web, this, ".ctor", "host="+destinationHost+", #certs="+((clientCertificates == null) ? "null" : clientCertificates.Count.ToString(NumberFormatInfo.InvariantInfo))); m_ExceptionStatus = WebExceptionStatus.SecureChannelFailure; m_Worker = new SslState(networkStream, initiatingRequest is HttpWebRequest, SettingsSectionInternal.Section.EncryptionPolicy); m_DestinationHost = destinationHost; m_ClientCertificates = clientCertificates; RemoteCertValidationCallback certValidationCallback = servicePoint.SetupHandshakeDoneProcedure(this, initiatingRequest); m_Worker.SetCertValidationDelegate(certValidationCallback); // The Handshake is NOT done at this point GlobalLog.Leave("TlsStream::TlsStream (Handshake is not done)"); }
public WebException(String msg, WebExceptionStatus status) : base(msg) { myresponse = null; mystatus = status; #if !ECMA_COMPAT HResult = unchecked((int)0x80131509); #endif }
public WebException(string message, Exception innerException, WebExceptionStatus status, WebResponse response) : base (message, innerException) { this.status = status; this.response = response; }
static HttpWebException() { #if PORTABLE if (!Enum.TryParse("ProtocolError", out ProtocolError)) ProtocolError = WebExceptionStatus.UnknownError; #else ProtocolError = WebExceptionStatus.ProtocolError; #endif }
public HttpExceptionEx(HttpStatus status, HttpCause cause, object baseException) { this.InitOption(status, cause); if (baseException.GetType() == typeof(WebException)) { this.mException = (WebException) baseException; this.mWebStatus = ((WebException) baseException).Status; this.mHttpErrorResponse = (HttpWebResponse) ((WebException) baseException).Response; } else { this.mException = (Exception) baseException; } }
public WebException(string message, Exception innerException, WebExceptionStatus status, WebResponse response) : base(message, innerException) { _status = status; _response = response; if (innerException != null) { HResult = innerException.HResult; } }
public WebException(string message, Exception innerException, WebExceptionStatus status, WebResponse response) : base(message, innerException) { _status = status; _response = response; if (innerException != null) { HResult = innerException.HResult; } }
public static Resposta Get(string url) { Resposta resposta = new Resposta(); try { HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url); request.Method = WebRequestMethods.Http.Get; request.Accept = "application/json"; request.Timeout = 2400000; HttpWebResponse response = (HttpWebResponse)request.GetResponse(); Stream dataStream = response.GetResponseStream(); StreamReader reader = new StreamReader(dataStream); string responseFromServer = reader.ReadToEnd(); resposta = JsonConvert.DeserializeObject <Resposta>(responseFromServer); resposta.httpStatusCode = (int)response.StatusCode; reader.Close(); dataStream.Close(); response.Close(); } catch (WebException ex) { WebExceptionStatus status = ex.Status; using (var stream = ex.Response.GetResponseStream()) using (var _reader = new StreamReader(stream)) { var r = _reader.ReadToEnd(); resposta = JsonConvert.DeserializeObject <Resposta>(r); } if (status == WebExceptionStatus.ProtocolError) { HttpWebResponse httpResponse = (HttpWebResponse)ex.Response; resposta.httpStatusCode = (int)httpResponse.StatusCode; } } catch (Exception e) { resposta.httpStatusCode = 500; resposta.message = e.InnerException.ToString(); return(resposta); } return(resposta); }
bool CreateStream(HttpWebRequest request) { try { NetworkStream serverStream = new NetworkStream(socket, false); if (request.Address.Scheme == Uri.UriSchemeHttps) { ssl = true; EnsureSSLStreamAvailable(); if (!reused || nstream == null || nstream.GetType() != sslStream) { byte [] buffer = null; if (sPoint.UseConnect) { bool ok = CreateTunnel(request, serverStream, out buffer); if (!ok) { return(false); } } object[] args = new object [4] { serverStream, request.ClientCertificates, request, buffer }; nstream = (Stream)Activator.CreateInstance(sslStream, args); certsAvailable = false; } // we also need to set ServicePoint.Certificate // and ServicePoint.ClientCertificate but this can // only be done later (after handshake - which is // done only after a read operation). } else { ssl = false; nstream = serverStream; } } catch (Exception) { if (!request.Aborted) { status = WebExceptionStatus.ConnectFailure; } return(false); } return(true); }
public static async Task PostRequestAsync(string url, string postData) { try { WebRequest request = WebRequest.Create(url); request.Method = "POST"; // данные для отправки string data = postData; // Example: "sName=Иван Иванов&age=31" // преобразуем данные в массив байтов byte[] byteArray = System.Text.Encoding.UTF8.GetBytes(data); // устанавливаем тип содержимого - параметр ContentType request.ContentType = "application/x-www-form-urlencoded"; // Устанавливаем заголовок Content-Length запроса - свойство ContentLength request.ContentLength = byteArray.Length; //записываем данные в поток запроса using (Stream dataStream = request.GetRequestStream()) { dataStream.Write(byteArray, 0, byteArray.Length); } WebResponse response = await request.GetResponseAsync(); using (Stream stream = response.GetResponseStream()) { using (StreamReader reader = new StreamReader(stream)) { Console.WriteLine(reader.ReadToEnd()); } } response.Close(); } catch (WebException e) { // получаем статус исключения WebExceptionStatus status = e.Status; if (status == WebExceptionStatus.ProtocolError) { HttpWebResponse httpResponse = (HttpWebResponse)e.Response; Console.WriteLine("Статусный код ошибки: {0} - {1}", (int)httpResponse.StatusCode, httpResponse.StatusCode); } } }
bool CreateStream(HttpWebRequest request) { try { NetworkStream serverStream = new NetworkStream(socket, false); if (request.Address.Scheme == Uri.UriSchemeHttps) { #if SECURITY_DEP if (!reused || nstream == null || tlsStream == null) { byte [] buffer = null; if (sPoint.UseConnect) { bool ok = CreateTunnel(request, sPoint.Address, serverStream, out buffer); if (!ok) { return(false); } } tlsStream = new MonoTlsStream(request, serverStream); nstream = tlsStream.CreateStream(buffer); } // we also need to set ServicePoint.Certificate // and ServicePoint.ClientCertificate but this can // only be done later (after handshake - which is // done only after a read operation). #else throw new NotSupportedException(); #endif } else { nstream = serverStream; } } catch (Exception ex) { if (tlsStream != null) { status = tlsStream.ExceptionStatus; } else if (!request.Aborted) { status = WebExceptionStatus.ConnectFailure; } connect_exception = ex; return(false); } return(true); }
private string GetMessage(WebExceptionStatus code, string msg) { string message = "异常"; IsSuccess = false; switch (code) { case WebExceptionStatus.Success: message = "成功"; IsSuccess = true; break; case WebExceptionStatus.NameResolutionFailure: case WebExceptionStatus.ConnectFailure: message = "请检测网络"; // 无法解析服务器名称 break; case WebExceptionStatus.ReceiveFailure: case WebExceptionStatus.SendFailure: case WebExceptionStatus.PipelineFailure: case WebExceptionStatus.ProtocolError: case WebExceptionStatus.ConnectionClosed: case WebExceptionStatus.TrustFailure: case WebExceptionStatus.SecureChannelFailure: case WebExceptionStatus.ServerProtocolViolation: case WebExceptionStatus.KeepAliveFailure: case WebExceptionStatus.ProxyNameResolutionFailure: case WebExceptionStatus.UnknownError: case WebExceptionStatus.MessageLengthLimitExceeded: case WebExceptionStatus.CacheEntryNotFound: case WebExceptionStatus.RequestProhibitedByCachePolicy: case WebExceptionStatus.RequestProhibitedByProxy: message = msg; //"发生未知类型的异常"; break; case WebExceptionStatus.RequestCanceled: message = "请求被取消"; break; case WebExceptionStatus.Timeout: message = "请求超时"; break; case WebExceptionStatus.Pending: IsSuccess = true; break; } return(message); }
public async Task <T> GenericGetAsync <T>(string path) where T : class { try { T result = null; if (_inMemoryCache.ContainsKey(path)) { Console.WriteLine($"Data from cache for: {path}"); result = _inMemoryCache[path] as T; return(result); } HttpResponseMessage response = await client.GetAsync(path); if (response.IsSuccessStatusCode) { result = await response.Content.ReadAsAsync <T>(); _inMemoryCache[path] = result; } else { var errorMessage = $"Unsuccess Response for: {RootUri}{path}"; errorMessage += $"\nstatus code: {response.StatusCode.ToString()}"; throw (new Exception(errorMessage)); } return(result); } catch (WebException webExcp) { var errorMessage = $"WebException has been caught for: {RootUri}{path}"; errorMessage += $"\nwebExcp: {webExcp.ToString()}"; WebExceptionStatus status = webExcp.Status; if (status == WebExceptionStatus.ProtocolError) { errorMessage += $"\nThe server returned protocol error "; HttpWebResponse httpResponse = (HttpWebResponse)webExcp.Response; errorMessage += $"\n{(int)httpResponse.StatusCode} - {httpResponse.StatusCode}"; } throw (new Exception(errorMessage)); } catch (Exception ex) { var errorMessage = $"An Exception has been caught for: {RootUri}{path}"; var ex2 = new Exception(errorMessage, ex); throw ex2; } }
private string GetAllData(string Url) { string result = ""; try { // Create a request for the URL. WebRequest request = WebRequest.Create(Url); // If required by the server, set the credentials. request.Credentials = CredentialCache.DefaultCredentials; // Get the response. WebResponse response = request.GetResponse(); // Display the status. var data = ((HttpWebResponse)response).GetResponseStream(); StreamReader sr = new StreamReader(response.GetResponseStream()); result = sr.ReadToEnd(); sr.Close(); } catch (WebException webExcp) { // If you reach this point, an exception has been caught. Console.WriteLine("A WebException has been caught."); // Write out the WebException message. Console.WriteLine(webExcp.ToString()); //this.ErrorMsg("Error: A WebException has been caught."); // Get the WebException status code. WebExceptionStatus status = webExcp.Status; //System.Windows.Forms.MessageBox.Show(status + ". Please press refresh icon!", "Message"); // If status is WebExceptionStatus.ProtocolError, // there has been a protocol error and a WebResponse // should exist. Display the protocol error. if (status == WebExceptionStatus.ProtocolError) { Console.Write("The server returned protocol error "); //this.ErrorMsg("Error: The server returned protocol error."); //System.Windows.Forms.MessageBox.Show("The server returned protocol error. Please press refresh icon!", "Message"); // Get HttpWebResponse so that you can check the HTTP status code. HttpWebResponse httpResponse = (HttpWebResponse)webExcp.Response; Console.WriteLine((int)httpResponse.StatusCode + " - " + httpResponse.StatusCode); } } catch (Exception e) { // Code to catch other exceptions goes here. } return(result); }
private WebHeaderCollection ReadHeaders(HttpWebRequest request, Stream stream, out byte[] retBuffer, out int status) { retBuffer = null; status = 200; byte[] array = new byte[1024]; MemoryStream memoryStream = new MemoryStream(); bool flag = false; WebHeaderCollection webHeaderCollection = null; while (true) { int num = stream.Read(array, 0, 1024); if (num == 0) { break; } memoryStream.Write(array, 0, num); int start = 0; string output = null; webHeaderCollection = new WebHeaderCollection(); while (ReadLine(memoryStream.GetBuffer(), ref start, (int)memoryStream.Length, ref output)) { if (output == null) { if (memoryStream.Length - start > 0) { retBuffer = new byte[memoryStream.Length - start]; Buffer.BlockCopy(memoryStream.GetBuffer(), start, retBuffer, 0, retBuffer.Length); } return(webHeaderCollection); } if (flag) { webHeaderCollection.Add(output); continue; } int num2 = output.IndexOf(' '); if (num2 == -1) { HandleError(WebExceptionStatus.ServerProtocolViolation, null, "ReadHeaders2"); return(null); } status = (int)uint.Parse(output.Substring(num2 + 1, 3)); flag = true; } } HandleError(WebExceptionStatus.ServerProtocolViolation, null, "ReadHeaders"); return(null); }
private void logNetworkRequestClick(object sender, RoutedEventArgs e) { Random random = new Random(); string[] methods = new string[] { "GET", "POST", "HEAD", "PUT" }; string method = methods[random.Next(0, methods.Length)]; string urlString = randomURLString(); // latency in milliseconds long latency = (long)Math.Floor(4000.0 * random.NextDouble()); long bytesRead = random.Next(0, 10000); long bytesSent = random.Next(0, 10000); long responseCode = 200; if (random.Next(0, 5) == 0) { // Some common response other than 200 == OK . long[] responseCodes = new long[] { 301, 308, 400, 401, 402, 403, 404, 405, 408, 500, 502, 503 }; responseCode = responseCodes[random.Next(0, responseCodes.Length)]; } ; WebExceptionStatus exceptionStatus = WebExceptionStatus.Success; if (random.Next(0, 5) == 0) { // Simulate a network WebException was encountered. WebExceptionStatus[] exceptionStatuses = new WebExceptionStatus[] { WebExceptionStatus.NameResolutionFailure, WebExceptionStatus.ConnectFailure, WebExceptionStatus.ReceiveFailure, WebExceptionStatus.SendFailure, WebExceptionStatus.ConnectionClosed, WebExceptionStatus.TrustFailure, WebExceptionStatus.KeepAliveFailure, WebExceptionStatus.Timeout }; exceptionStatus = exceptionStatuses[random.Next(0, exceptionStatuses.Length)]; // We didn't receive a simulated response, after all. responseCode = 0; } ; Crittercism.LogNetworkRequest( method, urlString, latency, bytesRead, bytesSent, (HttpStatusCode)responseCode, WebExceptionStatus.Success); }
private static void PrintStatusCode(WebExceptionStatus statusCode) { var color = Console.ForegroundColor; if (statusCode == WebExceptionStatus.Success) { Console.ForegroundColor = ConsoleColor.DarkGreen; } else { Console.ForegroundColor = ConsoleColor.DarkRed; } Console.WriteLine(String.Format("Status code was: {0}", statusCode)); Console.ForegroundColor = color; }
public static WebExceptionStatus ExecuteAndDeserialize <T>(this HttpWebRequest request, out HttpStatusCode statusCode, out T responseObject) { WebExceptionStatus status = request.Execute(out HttpWebResponse response); if (response.TryGetStatusCode(out statusCode)) { responseObject = JsonConvert.DeserializeObject <T>(response.GetReponseString()); } else { responseObject = default; } return(status); }
public EtcdResult Enqueue(string key, string value, long?ttl = null) { foreach (EtcdServer srv in serverList) { string uri = BuildRequestUri(srv.host, srv.port, "keys", key); NameValueCollection data = BuildRequestData(null, value, ttl); string responseStr = null; WebExceptionStatus status = DoWebRequest(uri, "POST", data, out responseStr); if (status == WebExceptionStatus.Success || status == WebExceptionStatus.ProtocolError) { return(EtcdResult.Parse(responseStr)); } } return(null); }
public MonoTlsStream(HttpWebRequest request, NetworkStream networkStream) { #if SECURITY_DEP this.request = request; this.networkStream = networkStream; settings = request.TlsSettings; provider = request.TlsProvider ?? MonoTlsProviderFactory.GetProviderInternal(); status = WebExceptionStatus.SecureChannelFailure; ChainValidationHelper.Create(provider, ref settings, this); #else throw new PlatformNotSupportedException(EXCEPTION_MESSAGE); #endif }
internal static string GetWebStatusString(WebExceptionStatus status) { int index = (int) status; if ((index >= s_Mapping.Length) || (index < 0)) { throw new InternalException(); } string str = s_Mapping[index]; if (str == null) { str = "net_webstatus_" + status.ToString(); s_Mapping[index] = str; } return str; }
internal bool EndWrite(IAsyncResult result) { if (nstream == null) { return(false); } try { nstream.EndWrite(result); return(true); } catch { status = WebExceptionStatus.SendFailure; return(false); } }
public HttpStatusCode GetHttpResponse() { try { response = client.GetResponse(); } catch (WebException e) { status = e.Status; response = e.Response; return(((HttpWebResponse)e.Response).StatusCode); } //Fix this status to enum return(HttpStatusCode.OK); }
/*++ GetWebStatusString - Get a WebExceptionStatus-specific resource string This method takes an input string and a WebExceptionStatus. We use the input string as a key to find a status message and the webStatus to produce a status-specific message, then we combine the two. Input: Res - Id for resource string. Status - The WebExceptionStatus to be formatted. Returns: string for localized message. --*/ public static string GetWebStatusString(string Res, WebExceptionStatus Status) { string Msg; string StatusMsg; StatusMsg = SR.GetString(WebExceptionMapping.GetWebStatusString(Status)); // Get the base status. Msg = SR.GetString(Res); // Format the status specific message into the base status and return // that return String.Format(CultureInfo.CurrentCulture, Msg, StatusMsg); }
private bool IsConnectionAlive(WebExceptionStatus stastus) { switch (stastus) { case WebExceptionStatus.ConnectFailure: case WebExceptionStatus.ConnectionClosed: case WebExceptionStatus.ReceiveFailure: case WebExceptionStatus.SendFailure: case WebExceptionStatus.NameResolutionFailure: return(false); default: return(true); } }
private static string GetErrorString(WebException webException) { WebExceptionStatus status = webException.Status; if (status == WebExceptionStatus.ProtocolError) { HttpWebResponse httpWebEx = (HttpWebResponse)webException.Response; string result = errors[(int)httpWebEx.StatusCode] != null ? errors[(int)httpWebEx.StatusCode].ToString() : "Неизвестная ошибка! Приносим свои извинения! Попробуйте, пожалуйста ещё раз."; return(result); } else { return("Проверьте подключение к интернету!"); } }
public HttpOperation(HttpServer server, string me, Handler handler, HttpOperationFlags flags, HttpStatusCode expectedStatus, WebExceptionStatus expectedError) { Server = server; Handler = handler; Flags = flags; ExpectedStatus = expectedStatus; ExpectedError = expectedError; ME = $"[{GetType ().Name}({ID}:{me})]"; requestTask = Listener.TaskSupport.CreateAsyncCompletionSource <Request> (); requestDoneTask = Listener.TaskSupport.CreateAsyncCompletionSource <Response> (); cts = new CancellationTokenSource(); }
public static string Http(string url, string data, string metod = "POST") { string result = null; try { WebRequest request = WebRequest.Create(url); request.Method = metod; // для отправки используется метод Post // данные для отправки // преобразуем данные в массив байтов byte[] byteArray = System.Text.Encoding.UTF8.GetBytes(data); // устанавливаем тип содержимого - параметр ContentType //request.ContentType = "application/x-www-form-urlencoded"; // Устанавливаем заголовок Content-Length запроса - свойство ContentLength request.ContentLength = byteArray.Length; //записываем данные в поток запроса using (Stream dataStream = request.GetRequestStream()) { dataStream.Write(byteArray, 0, byteArray.Length); } WebResponse response = request.GetResponse(); using (Stream stream = response.GetResponseStream()) { using (StreamReader reader = new StreamReader(stream)) { result = reader.ReadToEnd(); } } response.Close(); } catch (WebException ex) { // получаем статус исключения WebExceptionStatus status = ex.Status; if (status == WebExceptionStatus.ProtocolError) { HttpWebResponse httpResponse = (HttpWebResponse)ex.Response; Console.WriteLine("Статусный код ошибки: {0} - {1} ", (int)httpResponse.StatusCode, httpResponse.StatusCode); } } return(result); }
public void StartRun() { WebExceptionStatus outS = WebExceptionStatus.UnknownError; foreach (var linkExtraction in this.configurationHotProduct.HotProduct_Link.Split(new char[] { ',', '\n', ';' }, StringSplitOptions.RemoveEmptyEntries)) { this.LogData("Get html of cat page"); string html = downloadHtml.GetHTML(linkExtraction, 45, 2, out outS, this.configurationHotProduct.HotProduct_UseSelenium); if (!string.IsNullOrEmpty(html)) { HtmlDocument htmlDocument = new HtmlDocument(); htmlDocument.LoadHtml(html); var nodeLinks = htmlDocument.DocumentNode.SelectNodes(this.configurationHotProduct.HotProduct_Xpath); if (nodeLinks != null) { foreach (var VARIABLE in nodeLinks) { try { string shortLink = VARIABLE.GetAttributeValue("href", ""); string fullLink = Common.GetAbsoluteUrl(shortLink, new Uri(this.company.Website)); this.LogData(string.Format("Process link product {0}", fullLink)); string htmlLinkProduct = this.downloadHtml.GetHTML(fullLink, 45, 2, out outS); HtmlDocument h = new HtmlDocument(); h.LoadHtml(htmlLinkProduct); if (!string.IsNullOrEmpty(htmlLinkProduct)) { ProductEntity productEntity = new ProductEntity(); this.producerParser.Analytics(productEntity, h, fullLink, this.configuration, this.company.Domain); if (productEntity.IsSuccessData(true)) { this.productAdapter.UpsertProductHot(productEntity); this.LogData(string.Format("Saved a product to database. {0} {1} {2}", productEntity.ID, productEntity.Name, productEntity.Price)); } } } catch (Exception ex) { LogData(string.Format("Error: {0} {1}", ex.Message, ex.StackTrace)); } } } } } }
public static HttpWebHelper.ConnectivityError CheckConnectivityError(WebException e) { WebExceptionStatus status = e.Status; switch (status) { case WebExceptionStatus.NameResolutionFailure: return(HttpWebHelper.ConnectivityError.NonRetryable); case WebExceptionStatus.ConnectFailure: case WebExceptionStatus.SendFailure: break; case WebExceptionStatus.ReceiveFailure: goto IL_42; default: if (status != WebExceptionStatus.ConnectionClosed) { switch (status) { case WebExceptionStatus.KeepAliveFailure: break; case WebExceptionStatus.Pending: goto IL_42; case WebExceptionStatus.Timeout: case WebExceptionStatus.ProxyNameResolutionFailure: return(HttpWebHelper.ConnectivityError.NonRetryable); default: goto IL_42; } } break; } return(HttpWebHelper.ConnectivityError.Retryable); IL_42: HttpWebResponse httpWebResponse = (HttpWebResponse)e.Response; if (httpWebResponse != null && (httpWebResponse.StatusCode == HttpStatusCode.ServiceUnavailable || httpWebResponse.StatusCode == HttpStatusCode.BadGateway || httpWebResponse.StatusCode == HttpStatusCode.GatewayTimeout)) { return(HttpWebHelper.ConnectivityError.NonRetryable); } return(HttpWebHelper.ConnectivityError.None); }
private bool CreateStream(HttpWebRequest request) { try { NetworkStream networkStream = new NetworkStream(socket, owns_socket: false); if (request.Address.Scheme == Uri.UriSchemeHttps) { ssl = true; EnsureSSLStreamAvailable(); if (!reused || nstream == null || nstream.GetType() != sslStream) { byte[] array = null; if (sPoint.UseConnect && !CreateTunnel(request, networkStream, out array)) { return(false); } object[] args = new object[4] { networkStream, request.ClientCertificates, request, array }; nstream = (Stream)Activator.CreateInstance(sslStream, args); SslClientStream sslClientStream = (SslClientStream)nstream; ServicePointManager.ChainValidationHelper @object = new ServicePointManager.ChainValidationHelper(request); sslClientStream.ServerCertValidation2 += @object.ValidateChain; certsAvailable = false; } } else { ssl = false; nstream = networkStream; } } catch (Exception) { if (!request.Aborted) { status = WebExceptionStatus.ConnectFailure; } return(false); IL_011e :; } return(true); }
/// <summary> /// Determines whether an error code is likely to have been caused by internet reachability problems. /// </summary> public static bool IsCannotReachInternetError(this WebExceptionStatus status) { switch (status) { case WebExceptionStatus.NameResolutionFailure: case WebExceptionStatus.ConnectFailure: case WebExceptionStatus.ConnectionClosed: case WebExceptionStatus.ProxyNameResolutionFailure: case WebExceptionStatus.SendFailure: case WebExceptionStatus.Timeout: return(true); default: return(false); } }
/*++ * * GetWebStatusString - Get a WebExceptionStatus-specific resource string * * * This method takes an input string and a WebExceptionStatus. We use the input * string as a key to find a status message and the webStatus to produce * a status-specific message, then we combine the two. * * Input: * * Res - Id for resource string. * Status - The WebExceptionStatus to be formatted. * * Returns: * * string for localized message. * * --*/ public static string GetWebStatusString(string Res, WebExceptionStatus Status) { string Msg; string StatusMsg; StatusMsg = SR.GetString(WebExceptionMapping.GetWebStatusString(Status)); // Get the base status. Msg = SR.GetString(Res); // Format the status specific message into the base status and return // that return(String.Format(CultureInfo.CurrentCulture, Msg, StatusMsg)); }
public WebResponse GetHttpWebResponse() { try { response = client.GetResponse(); } catch (WebException e) { status = e.Status; response = e.Response; return(e.Response); } return(response); }
public static void LogNetworkRequest(string method, string uriString, long latency, long bytesRead, long bytesSent, HttpStatusCode responseCode, WebExceptionStatus exceptionStatus) { #if CRITTERCISM_ANDROID if (!isInitialized) { return; } PluginCallStatic("logNetworkRequest", method, uriString, latency, bytesRead, bytesSent, (int)responseCode, (int)exceptionStatus); #endif }
protected internal virtual void FailRequest(WebExceptionStatus webStatus) { if (Logging.On) { Logging.PrintError(Logging.RequestCache, SR.GetString("net_log_cache_failing_request_with_exception", new object[] { webStatus.ToString() })); } if (webStatus == WebExceptionStatus.CacheEntryNotFound) { throw ExceptionHelper.CacheEntryNotFoundException; } if (webStatus == WebExceptionStatus.RequestProhibitedByCachePolicy) { throw ExceptionHelper.RequestProhibitedByCachePolicyException; } throw new WebException(NetRes.GetWebStatusString("net_requestaborted", webStatus), webStatus); }
public MonoTlsStream(HttpWebRequest request, NetworkStream networkStream) { this.request = request; this.networkStream = networkStream; settings = request.TlsSettings; provider = request.TlsProvider ?? MonoTlsProviderFactory.GetProviderInternal(); status = WebExceptionStatus.SecureChannelFailure; if (settings == null) { settings = new MonoTlsSettings(); } validationHelper = ChainValidationHelper.Create(ref settings, this); }
static void OnFailed(string error, WebExceptionStatus status) { if (listenerCallBackFunctionID != -1) { Dictionary <string, object> dict = new Dictionary <string, object>(); dict.Add("progress", 0); dict.Add("responseCode", 404); dict.Add("isReachable", false); if (luaState != 0) { LuaManager.GetLuaManager(luaState).ExecuteCallBackFunctionWithTableParam(listenerCallBackFunctionID, dict); } listenerCallBackFunctionID = -1; luaState = 0; } }
public System.IO.Stream downloadURL(string url) { try { this.OpenReadCompleted += new OpenReadCompletedEventHandler(OnOpenReadCompleted); return this.OpenRead(url); } catch(WebException e) { _lastWebError = e.Status; #if DEBUG Debug.Print("Download:{1}. Error: {0}.", e.Message, url); #endif } return null; }
public string GetHTML(string url, int secondsTimeOut, int numTry, out WebExceptionStatus status, bool bUseSelenium = false) { if (!bUseSelenium) { return(downloadOld.GetHTML(url, secondsTimeOut, numTry, out status)); } else { IWebDriver websDriver = new ChromeDriver(); websDriver.Url = url; string str = websDriver.PageSource; websDriver.Close(); status = WebExceptionStatus.UnknownError; return(str); } }
public TlsStream(string destinationHost, NetworkStream networkStream, X509CertificateCollection clientCertificates, ServicePoint servicePoint, object initiatingRequest, ExecutionContext executionContext) : base(networkStream, true) { this.m_PendingIO = new ArrayList(); this._ExecutionContext = executionContext; if (this._ExecutionContext == null) { this._ExecutionContext = ExecutionContext.Capture(); } if (Logging.On) { Logging.PrintInfo(Logging.Web, this, ".ctor", "host=" + destinationHost + ", #certs=" + ((clientCertificates == null) ? "null" : clientCertificates.Count.ToString(NumberFormatInfo.InvariantInfo))); } this.m_ExceptionStatus = WebExceptionStatus.SecureChannelFailure; this.m_Worker = new SslState(networkStream, initiatingRequest is HttpWebRequest, SettingsSectionInternal.Section.EncryptionPolicy); this.m_DestinationHost = destinationHost; this.m_ClientCertificates = clientCertificates; RemoteCertValidationCallback certValidationCallback = servicePoint.SetupHandshakeDoneProcedure(this, initiatingRequest); this.m_Worker.SetCertValidationDelegate(certValidationCallback); }
public static string Send(string request) { try { HttpWebRequest req = (HttpWebRequest)WebRequest.Create(request); req.ReadWriteTimeout = 9000; req.Timeout = 10000; HttpWebResponse response = (HttpWebResponse)req.GetResponse(); status = KannelReqCode.SuccessfullyAccepted; // Get the stream associated with the response. Stream receiveStream = response.GetResponseStream(); // Pipes the stream to a higher level stream reader with the required encoding format. StreamReader readStream = new StreamReader(receiveStream, Encoding.UTF8); string answer = readStream.ReadLine(); //MessageBox.Show(response.StatusCode.ToString() + "\n" + readStream.ReadLine(), "SMS Sender", MessageBoxButtons.OK, MessageBoxIcon.Information); response.Close(); readStream.Close(); return answer; } catch (WebException ex) { if (ex.Status == WebExceptionStatus.Timeout) status = KannelReqCode.OperationTimeout; else status = KannelReqCode.UnknownError; wes = ex.Status; return ex.Message; } catch(Exception ex) { wes = WebExceptionStatus.SendFailure; status = KannelReqCode.UnknownError; return ex.Message; } }
private void ParseException(WebException exception) { _status = exception.Status; string responseText = String.Empty; using (StreamReader r = new StreamReader(exception.Response.GetResponseStream())) { responseText = r.ReadToEnd(); } _exceptionResponse = responseText; XElement element = XElement.Parse(responseText); if (element != null) foreach (var s in element.DescendantsAndSelf("error")) { _responseErrorText = s.Value; } element = null; }
private static RollbarResponseCode ToRollbarStatus(WebExceptionStatus status) { switch ((int) status) { case 200: return RollbarResponseCode.Success; case 400: return RollbarResponseCode.BadRequest; case 401: return RollbarResponseCode.Unauthorized; case 403: return RollbarResponseCode.AccessDenied; case 413: return RollbarResponseCode.RequestTooLarge; case 422: return RollbarResponseCode.UnprocessablePayload; case 429: return RollbarResponseCode.TooManyRequests; case 500: return RollbarResponseCode.InternalServerError; default: throw new ArgumentException("Invalid Status returned from Rollbar", "status"); } }
internal RESTResponse(HttpWebResponse response, long elapsedTime = 0, string error = null, WebExceptionStatus errorStatus = WebExceptionStatus.Success) { if (!object.ReferenceEquals(response, null)) { this.Content = this.GetContent(response); this.ContentEncoding = response.ContentEncoding; this.ContentLength = response.ContentLength; this.ContentType = response.ContentType; this.Cookies = response.Cookies; this.Headers = response.Headers; this.ResponseStatus = response.StatusCode.ToString(); this.ResponseUri = response.ResponseUri; this.ReturnedError = (this.ErrorStatus.Equals(WebExceptionStatus.Success)) ? false : true; this.Server = response.Server; this.StatusCode = response.StatusCode; this.StatusDescription = response.StatusDescription; } this.ElapsedTime = elapsedTime; this.Error = error; this.ErrorStatus = errorStatus; }
/*++ GetWebStatusString - Get a WebExceptionStatus-specific resource string This method takes an input string and a WebExceptionStatus. We use the input string as a key to find a status message and the webStatus to produce a status-specific message, then we combine the two. Input: Res - Id for resource string. Status - The WebExceptionStatus to be formatted. Returns: string for localized message. --*/ public static string GetWebStatusString(string Res, WebExceptionStatus Status) { string Msg; string StatusEnumName; string StatusMsg; // First, convert the WebExceptionStatus to its label. StatusEnumName = ((Enum)Status).ToString(); // Now combine the label with the base enum key and look up the // status msg. StatusMsg = SR.GetString("net_webstatus_" + StatusEnumName); // Get the base status. Msg = SR.GetString(Res); // Format the status specific message into the base status and return // that return String.Format(Msg, StatusMsg); }
void HandleError (WebExceptionStatus st, Exception e, string where) { status = st; lock (this) { if (st == WebExceptionStatus.RequestCanceled) Data = new WebConnectionData (); } if (e == null) { // At least we now where it comes from try { #if TARGET_JVM throw new Exception (); #else throw new Exception (new System.Diagnostics.StackTrace ().ToString ()); #endif } catch (Exception e2) { e = e2; } } HttpWebRequest req = null; if (Data != null && Data.request != null) req = Data.request; Close (true); if (req != null) { req.FinishedReading = true; req.SetResponseError (st, e, where); } }
public WebException(string message, WebExceptionStatus status) : base(message) { this.status = status; }
internal Stream CreateStream (byte[] buffer) { sslStream = provider.CreateSslStream (networkStream, false, settings); try { sslStream.AuthenticateAsClient ( request.Address.Host, request.ClientCertificates, (SslProtocols)ServicePointManager.SecurityProtocol, ServicePointManager.CheckCertificateRevocationList); status = WebExceptionStatus.Success; } catch (Exception ex) { status = WebExceptionStatus.SecureChannelFailure; throw; } finally { if (CertificateValidationFailed) status = WebExceptionStatus.TrustFailure; if (status == WebExceptionStatus.Success) request.ServicePoint.UpdateClientCertificate (sslStream.InternalLocalCertificate); else { request.ServicePoint.UpdateClientCertificate (null); sslStream = null; } } try { if (buffer != null) sslStream.Write (buffer, 0, buffer.Length); } catch { status = WebExceptionStatus.SendFailure; sslStream = null; throw; } return sslStream.AuthenticatedStream; }
public MonoTlsStream (HttpWebRequest request, NetworkStream networkStream) { this.request = request; this.networkStream = networkStream; settings = request.TlsSettings; provider = request.TlsProvider ?? MonoTlsProviderFactory.GetProviderInternal (); status = WebExceptionStatus.SecureChannelFailure; validationHelper = ChainValidationHelper.Create (provider.Provider, ref settings, this); }
public static string GetWebStatusString(WebExceptionStatus Status) { return SR.GetString(WebExceptionMapping.GetWebStatusString(Status)); }
internal bool EndWrite (HttpWebRequest request, IAsyncResult result) { if (request.FinishedReading) return true; Stream s = null; lock (this) { if (Data.request != request) throw new ObjectDisposedException (typeof (NetworkStream).FullName); if (nstream == null) throw new ObjectDisposedException (typeof (NetworkStream).FullName); s = nstream; } try { s.EndWrite (result); return true; } catch { status = WebExceptionStatus.SendFailure; return false; } }
internal void EndWrite2 (HttpWebRequest request, IAsyncResult result) { if (request.FinishedReading) return; Stream s = null; lock (this) { if (Data.request != request) throw new ObjectDisposedException (typeof (NetworkStream).FullName); if (nstream == null) throw new ObjectDisposedException (typeof (NetworkStream).FullName); s = nstream; } try { s.EndWrite (result); } catch (Exception exc) { status = WebExceptionStatus.SendFailure; if (exc.InnerException != null) throw exc.InnerException; throw; } }
internal IAsyncResult BeginWrite (HttpWebRequest request, byte [] buffer, int offset, int size, AsyncCallback cb, object state) { Stream s = null; lock (this) { if (Data.request != request) throw new ObjectDisposedException (typeof (NetworkStream).FullName); if (nstream == null) return null; s = nstream; } IAsyncResult result = null; try { result = s.BeginWrite (buffer, offset, size, cb, state); } catch (Exception) { status = WebExceptionStatus.SendFailure; throw; } return result; }
internal EventHandler SendRequest (HttpWebRequest request) { if (request.Aborted) return null; lock (this) { if (!busy) { busy = true; status = WebExceptionStatus.Success; ThreadPool.QueueUserWorkItem (initConn, request); } else { lock (queue) { queue.Enqueue (request); } } } return abortHandler; }