internal Response(HttpWebResponse response) { using (response) { using (Stream response_stream = response.GetResponseStream()) { if (response_stream.CanRead) { byte[] buffer = new byte[16654]; int read; using (MemoryStream s = new MemoryStream()) { while((read = response_stream.Read(buffer, 0, buffer.Length)) > 0) { s.Write(buffer, 0, read); } Body = new byte[s.Length]; s.Seek(0, SeekOrigin.Begin); s.Read(Body, 0, Body.Length); } } } Status = response.StatusCode; ContentType = response.GetResponseHeader("Content-Type"); ETag = response.GetResponseHeader("ETag"); } }
public ASOptionsResponse(HttpWebResponse httpResponse) { // Get the MS-ASProtocolCommands header to determine the // supported commands commands = httpResponse.GetResponseHeader("MS-ASProtocolCommands"); // Get the MS-ASProtocolVersions header to determine the // supported versions versions = httpResponse.GetResponseHeader("MS-ASProtocolVersions"); }
public string GetResponseHeader(string headerName) { if (_raw == null) { throw new NotImplementedException("Can not call method without existing underlying HttpWebResponse"); } return(_raw.GetResponseHeader(headerName)); }
public override void Handle(HttpWebResponse web_response) { string header = web_response.GetResponseHeader("Location"); if (header != null) { this._context.Fifa.next_url = header; } else throw new RequestException<SignInPage>("Unable to find Location Header"); }
private static IEnumerable<KeyValuePair<string, string>> ExtractHeaderFrom(HttpWebResponse webResponse) { return webResponse .Headers .AllKeys .Select( headerKey => new KeyValuePair<string, string>( headerKey, webResponse.GetResponseHeader(headerKey))).ToList(); }
private void CopyHeaderValues(HttpWebResponse response) { var keys = response.Headers.Keys; _headerNames = new string[keys.Count]; _headers = new Dictionary<string, string>(keys.Count, StringComparer.OrdinalIgnoreCase); for (int i = 0; i < keys.Count; i++) { var key = keys[i]; var headerValue = response.GetResponseHeader(key); _headerNames[i] = key; _headers.Add(key, headerValue); } _headerNamesSet = new HashSet<string>(_headerNames, StringComparer.OrdinalIgnoreCase); }
public override void Handle(HttpWebResponse web_response) { string header = web_response.GetResponseHeader("Location"); if (header != null) { this._context.Fifa.next_url = header; if (web_response.Cookies.Count == 0) throw new RequestException<SetPropertys>("Unable to find Cookie Headers"); } else throw new RequestException<SetPropertys>("Unable to find Location Header"); }
public override void Handle(HttpWebResponse web_response) { string header = web_response.GetResponseHeader("Location"); if (header != null) { this._context.Fifa.next_url = header; Cookie cookie = web_response.Cookies["webun"]; if (cookie != null) { if (!cookie.Value.Contains(this._context.Authentication.UserName)) throw new RequestException<Login>("Wrong Login Info"); } else throw new RequestException<Login>("Unable to find webun Cookie"); } else throw new RequestException<Login>("Unable to find Location Header"); }
/// <summary> /// Create a SimpleVoc value from a WebResponse for a given key asynchronously /// </summary> /// <param name="res"></param> /// <param name="key"></param> /// <returns></returns> private async Task<SimpleVocValue> GetValueFromResponseAsync(HttpWebResponse res, string key) { return new SimpleVocValue { Key = key, Data = await GetResponseDataAsync(res), Created = DateTime.Parse(res.GetResponseHeader("x-voc-created")), Expires = !string.IsNullOrWhiteSpace(res.GetResponseHeader("x-voc-expires")) ? DateTime.Parse(res.GetResponseHeader("x-voc-expires")) : DateTime.MinValue, Flags = int.Parse(res.GetResponseHeader("x-voc-flags")), Extended = !string.IsNullOrWhiteSpace(res.GetResponseHeader("x-voc-extended")) ? (Dictionary<string, string>)_serializer.DeserializeObject(res.GetResponseHeader("x-voc-extended")) : null }; }
public static DateTime GetExpiresHeader(HttpWebResponse response) { string expires = response.GetResponseHeader("Expires"); if (expires != null && expires != String.Empty && expires.Trim() != "-1") { try { DateTime expiresDate = DateTime.Parse(expires, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal); return expiresDate; } catch (Exception ex) { // look for ANSI c's asctime() format as a last gasp try { string asctimeFormat = "ddd' 'MMM' 'd' 'HH':'mm':'ss' 'yyyy"; DateTime expiresDate = DateTime.ParseExact(expires, asctimeFormat, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces); return expiresDate; } catch { } Trace.Fail("Exception parsing HTTP date - " + expires + ": " + ex.ToString()); return DateTime.MinValue; } } else { return DateTime.MinValue; } }
private void UpdateLwssoTokenFromResponse(HttpWebResponse httpResponse) { //update security token if it was modified String setCookieAll = httpResponse.GetResponseHeader("Set-Cookie"); String[] setCookies = setCookieAll.Split(';'); foreach (String setCookie in setCookies) { if (setCookie.StartsWith(LWSSO_COOKIE_NAME)) { String[] setCookiesParts = setCookie.Split('='); lwssoToken = setCookiesParts[1]; } } }
public string GetResponseHeader(string headerName) => _httpWebResponse.GetResponseHeader(headerName);
/// <summary> /// Handle a 3xx redirect status. /// </summary> /// <param name="state"> /// The state. /// </param> /// <param name="response"> /// The response. /// </param> /// <param name="statusCode"> /// The status Code. /// </param> private void HandleRedirect(State state, HttpWebResponse response, HttpStatusCode statusCode) { Debug.WriteLine("got HTTP redirect " + statusCode); if (state.RedirectCount >= DownloaderService.MaxRedirects) { throw new StopRequestException(ExpansionDownloadStatus.TooManyRedirects, "too many redirects"); } string header = response.GetResponseHeader("Location"); if (header == null) { return; } Debug.WriteLine("Redirecting to " + header); string newUri; try { newUri = new URI(this.downloadInfo.Uri).Resolve(new URI(header)).ToString(); } catch (URISyntaxException) { Debug.WriteLine("Couldn't resolve redirect URI {0} for {1}", header, this.downloadInfo.Uri); throw new StopRequestException(ExpansionDownloadStatus.HttpDataError, "Couldn't resolve redirect URI"); } ++state.RedirectCount; state.RequestUri = newUri; if ((int)statusCode == 301 || (int)statusCode == 303) { // use the new URI for all future requests (should a retry/resume be necessary) state.NewUri = newUri; } throw new RetryDownloadException(); }
/// <summary> /// Initially used via a response callback for commands which expect a async response /// </summary> /// <param name="webResponse">the HttpWebResponse that will be sent back to the user from the request</param> protected virtual void ResponseCallback(HttpWebResponse webResponse) { //Track and throw up the X-ms request id (x-ms-request-id) MsftAsyncResponseId = webResponse.GetResponseHeader("x-ms-request-id"); ElastaLogger.MessageLogger.Trace("Hosted Service Response Id: {0}", MsftAsyncResponseId); for (;;) { var asyncCommand = new GetAsyncStatusCommand { HttpVerb = HttpVerbGet, SubscriptionId = SubscriptionId, OperationId = MsftAsyncResponseId, ServiceType = "operations", Certificate = Certificate }; asyncCommand.Execute(); Thread.Sleep(1000); OperationStatus status = asyncCommand.GetOperationStatus(); switch (status) { case OperationStatus.InProgress: break; case OperationStatus.Failed: ElastaLogger.MessageLogger.Error("Hosted Service Response Id: {0}", MsftAsyncResponseId); SitAndWait.Set(); return; case OperationStatus.Succeeded: ElastaLogger.MessageLogger.Trace("Hosted Service Response Id: {0}", MsftAsyncResponseId); SitAndWait.Set(); return; } } }
/// <summary> /// Handle a 503 Service Unavailable status by processing the Retry-After header. /// </summary> /// <param name="state"> /// The state. /// </param> /// <param name="response"> /// The response. /// </param> private static void HandleServiceUnavailable(State state, HttpWebResponse response) { string header = response.GetResponseHeader("Retry-After"); Debug.WriteLine("DownloadThread : got HTTP response code 503 (retry after {0})", header); state.CountRetry = true; int retryAfter; int.TryParse(header, out retryAfter); state.RetryAfter = Math.Max(retryAfter, 0); if (state.RetryAfter < DownloaderService.MinimumRetryAfter) { state.RetryAfter = DownloaderService.MinimumRetryAfter; } else if (state.RetryAfter > DownloaderService.MaxRetryAfter) { state.RetryAfter = DownloaderService.MaxRetryAfter; } state.RetryAfter += Helpers.Random.Next(DownloaderService.MinimumRetryAfter + 1); state.RetryAfter *= 1000; throw new StopRequestException( ExpansionDownloadStatus.WaitingToRetry, "got 503 Service Unavailable, will retry later"); }
/* private static Stream GetStreamForResponse(HttpWebResponse webResponse) { Stream stream; switch (webResponse.ContentEncoding.ToUpperInvariant()) { case "GZIP": stream = new GZipStream(webResponse.GetResponseStream(), CompressionMode.Decompress); break; case "DEFLATE": stream = new DeflateStream(webResponse.GetResponseStream(), CompressionMode.Decompress); break; default: stream = webResponse.GetResponseStream(); //stream.ReadTimeout = readTimeOut; break; } return stream; } */ private IOResponse ReadWebResponse(HttpWebRequest webRequest, HttpWebResponse webResponse, IOService service) { IOResponse response = new IOResponse (); // result types (string or byte array) byte[] resultBinary = null; string result = null; string responseMimeTypeOverride = webResponse.GetResponseHeader ("Content-Type"); using (Stream stream = webResponse.GetResponseStream()) { SystemLogger.Log (SystemLogger.Module.CORE, "getting response stream..."); if (ServiceType.OCTET_BINARY.Equals (service.Type)) { int lengthContent = -1; if (webResponse.GetResponseHeader ("Content-Length") != null && webResponse.GetResponseHeader ("Content-Length") != "") { lengthContent = Int32.Parse (webResponse.GetResponseHeader ("Content-Length")); } // testing log line // SystemLogger.Log (SystemLogger.Module.CORE, "content-length header: " + lengthContent +", max file size: " + MAX_BINARY_SIZE); int bufferReadSize = DEFAULT_BUFFER_READ_SIZE; if (lengthContent >= 0 && lengthContent<=bufferReadSize) { bufferReadSize = lengthContent; } if(lengthContent>MAX_BINARY_SIZE) { SystemLogger.Log (SystemLogger.Module.CORE, "WARNING! - file exceeds the maximum size defined in platform (" + MAX_BINARY_SIZE+ " bytes)"); } else { // Read to end of stream in blocks SystemLogger.Log (SystemLogger.Module.CORE, "buffer read: " + bufferReadSize + " bytes"); MemoryStream memBuffer = new MemoryStream (); byte[] readBuffer = new byte[bufferReadSize]; int readLen = 0; do { readLen = stream.Read (readBuffer, 0, readBuffer.Length); memBuffer.Write (readBuffer, 0, readLen); } while (readLen >0); resultBinary = memBuffer.ToArray (); memBuffer.Close (); memBuffer = null; } } else { SystemLogger.Log (SystemLogger.Module.CORE, "reading response content..."); using (StreamReader reader = new StreamReader(stream, Encoding.UTF8)) { result = reader.ReadToEnd (); } } } /************* * CACHE *************/ // preserve cache-control header from remote server, if any /* string cacheControlHeader = webResponse.GetResponseHeader ("Cache-Control"); if (cacheControlHeader != null && cacheControlHeader != "") { SystemLogger.Log (SystemLogger.Module.CORE, "Found Cache-Control header on response: " + cacheControlHeader + ", using it on internal response..."); if(response.Headers == null) { response.Headers = new IOHeader[1]; } IOHeader cacheHeader = new IOHeader(); cacheHeader.Name = "Cache-Control"; cacheHeader.Value = cacheControlHeader; response.Headers[0] = cacheHeader; } */ /************* * HEADERS HANDLING *************/ if (webResponse.Headers != null) { response.Headers = new IOHeader[webResponse.Headers.Count]; int size = 0; foreach(string headerKey in webResponse.Headers.AllKeys) { string headerValue = webResponse.GetResponseHeader(headerKey); IOHeader objHeader = new IOHeader(); objHeader.Name = headerKey; objHeader.Value = headerValue; SystemLogger.Log(SystemLogger.Module.CORE, "Found Header on response: " + headerKey + "=" + headerValue); response.Headers[size++] = objHeader; } } /************* * COOKIES HANDLING *************/ // get response cookies (stored on cookiecontainer) if (response.Session == null) { response.Session = new IOSessionContext (); } response.Session.Cookies = new IOCookie[this.cookieContainer.Count]; IEnumerator enumerator = this.cookieContainer.GetCookies (webRequest.RequestUri).GetEnumerator (); int i = 0; while (enumerator.MoveNext()) { Cookie cookieFound = (Cookie)enumerator.Current; SystemLogger.Log (SystemLogger.Module.CORE, "Found cookie on response: " + cookieFound.Name + "=" + cookieFound.Value); IOCookie cookie = new IOCookie (); cookie.Name = cookieFound.Name; cookie.Value = cookieFound.Value; response.Session.Cookies [i] = cookie; i++; } if (ServiceType.OCTET_BINARY.Equals (service.Type)) { if (responseMimeTypeOverride != null && !responseMimeTypeOverride.Equals (contentTypes [service.Type])) { response.ContentType = responseMimeTypeOverride; } else { response.ContentType = contentTypes [service.Type]; } response.ContentBinary = resultBinary; // Assign binary content here } else { response.ContentType = contentTypes [service.Type]; response.Content = result; } return response; }
private static bool? ProcessResponse(HttpWebResponse response) { bool isSubscribed; if (!bool.TryParse(response.GetResponseHeader(QuickPulseConstants.XMsQpsSubscribedHeaderName), out isSubscribed)) { return null; } return isSubscribed; }
/// <summary> /// Read headers from the HTTP response and store them into local state. /// </summary> /// <param name="innerState"> /// The inner State. /// </param> /// <param name="response"> /// The response. /// </param> private void ReadResponseHeaders(InnerState innerState, HttpWebResponse response) { string header = response.GetResponseHeader("Content-Disposition"); if (header != null) { innerState.HeaderContentDisposition = header; } header = response.GetResponseHeader("Content-Location"); if (header != null) { innerState.HeaderContentLocation = header; } header = response.GetResponseHeader("ETag"); if (header != null) { innerState.HeaderETag = header; } header = response.GetResponseHeader("Content-Type"); if (header != null && header != "application/vnd.android.obb") { throw new StopRequestException( ExpansionDownloadStatus.FileDeliveredIncorrectly, "file delivered with incorrect Mime type"); } string headerTransferEncoding = response.GetResponseHeader("Transfer-Encoding"); // todo - there seems to be no similar thing in .NET // if (!string.IsNullOrEmpty(headerTransferEncoding)) // { header = response.GetResponseHeader("Content-Length"); if (header != null) { innerState.HeaderContentLength = header; // this is always set from Market long contentLength = long.Parse(innerState.HeaderContentLength); if (contentLength != -1 && contentLength != this.downloadInfo.TotalBytes) { // we're most likely on a bad wifi connection -- we should probably // also look at the mime type --- but the size mismatch is enough // to tell us that something is wrong here Debug.WriteLine("LVLDL Incorrect file size delivered."); } } // } // else // { // // Ignore content-length with transfer-encoding - 2616 4.4 3 // System.Diagnostics.Debug.WriteLine("DownloadThread : ignoring content-length because of xfer-encoding"); // } Debug.WriteLine("DownloadThread : Content-Disposition: " + innerState.HeaderContentDisposition); Debug.WriteLine("DownloadThread : Content-Length: " + innerState.HeaderContentLength); Debug.WriteLine("DownloadThread : Content-Location: " + innerState.HeaderContentLocation); Debug.WriteLine("DownloadThread : ETag: " + innerState.HeaderETag); Debug.WriteLine("DownloadThread : Transfer-Encoding: " + headerTransferEncoding); bool noSizeInfo = innerState.HeaderContentLength == null && (headerTransferEncoding == null || !"chunked".Equals(headerTransferEncoding, StringComparison.OrdinalIgnoreCase)); if (noSizeInfo) { throw new StopRequestException(ExpansionDownloadStatus.HttpDataError, "can't know size of download, giving up"); } }
private static void print_log_oa1(HttpWebResponse response) { Stream streamResponse = response.GetResponseStream(); StreamReader streamRead = new StreamReader(streamResponse, System.Text.Encoding.GetEncoding(-0)); string content = response.GetResponseHeader("Set-Cookie"); session_id = content.Substring(content.IndexOf("JSESSIONID=") + "JSESSIONID=".Length, 32); string content_length = response.GetResponseHeader("Content-Length"); if (content_length == "") { streamResponse.Close(); streamRead.Close(); return; } if (Int32.Parse(content_length) <= 0) { streamResponse.Close(); streamRead.Close(); return; } Char[] readBuff = new Char[256]; int count = streamRead.Read(readBuff, 0, 256); Console.WriteLine("The contents of the Html page are.......\n"); while (count > 0) { String outputData = new String(readBuff, 0, count); Console.Write(outputData); count = streamRead.Read(readBuff, 0, 256); } Console.WriteLine(); // Close the Stream object. streamResponse.Close(); streamRead.Close(); }
private static void print_log1(HttpWebResponse response) { Stream streamResponse = response.GetResponseStream(); StreamReader streamRead = new StreamReader(streamResponse, System.Text.Encoding.GetEncoding(-0)); string content_length = response.GetResponseHeader("Content-Length"); if (content_length == "") { streamResponse.Close(); streamRead.Close(); return; } if (Int32.Parse(content_length) <= 0) { streamResponse.Close(); streamRead.Close(); return; } string readBuff = streamRead.ReadLine(); do { //Console.Write(readBuff); //Console.WriteLine(); search_ip(readBuff); readBuff = streamRead.ReadLine(); } while (!streamRead.EndOfStream); // Close the Stream object. streamResponse.Close(); streamRead.Close(); }
private string ReadWebResponseAndStore(HttpWebRequest webRequest, HttpWebResponse webResponse, IOService service, string storePath) { using (Stream stream = webResponse.GetResponseStream()) { SystemLogger.Log (SystemLogger.Module.CORE, "getting response stream..."); int lengthContent = -1; if (webResponse.GetResponseHeader ("Content-Length") != null && webResponse.GetResponseHeader ("Content-Length") != "") { lengthContent = Int32.Parse (webResponse.GetResponseHeader ("Content-Length")); } // testing log line // SystemLogger.Log (SystemLogger.Module.CORE, "content-length header: " + lengthContent +", max file size: " + MAX_BINARY_SIZE); int bufferReadSize = DEFAULT_BUFFER_READ_SIZE; if (lengthContent >= 0 && lengthContent<=bufferReadSize) { bufferReadSize = lengthContent; } SystemLogger.Log (SystemLogger.Module.CORE, "buffer read: " + bufferReadSize + " bytes"); string fullStorePath = Path.Combine(this.GetDirectoryRoot (), storePath); SystemLogger.Log (SystemLogger.Module.CORE, "storing file at: " + fullStorePath); FileStream streamWriter = new FileStream (fullStorePath, FileMode.Create); byte[] readBuffer = new byte[bufferReadSize]; int readLen = 0; int totalRead = 0; do { readLen = stream.Read (readBuffer, 0, readBuffer.Length); streamWriter.Write (readBuffer, 0, readLen); totalRead = totalRead + readLen; } while (readLen >0); SystemLogger.Log (SystemLogger.Module.CORE, "total bytes: " + totalRead); streamWriter.Close (); streamWriter = null; return storePath; } }
public string GetWebServiceData(string url) { lock (this) { request = HttpWebRequest.Create(url) as HttpWebRequest; request.Method = "GET"; string responseText = null; try { response = request.GetResponse() as HttpWebResponse; if (request.HaveResponse == true && response == null) { String msg = "response was not returned or is null"; throw new WebException(msg); } if (response.StatusCode != HttpStatusCode.OK) { String msg = "response with status: " + response.StatusCode + " " + response.StatusDescription; throw new WebException(msg); } // check response headers for the content type string contentType = response.GetResponseHeader("Content-Type"); // get the response content StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8); responseText = reader.ReadToEnd(); reader.Close(); reader.Dispose(); // handle failures } catch (WebException e) { if (e.Response != null) { System.Console.Write(response.StatusCode + " " + response.StatusDescription); response = (HttpWebResponse)e.Response; } else { System.Console.Write(e.Message); } } finally { if (response != null) { response.Close(); } } return responseText; } }
/// <summary> /// Gets the CoAP response from an incoming HTTP response. No null value is /// returned. The response is created from a predefined mapping of the HTTP /// response codes. If the code is 204, which has /// multiple meaning, the mapping is handled looking on the request method /// that has originated the response. The options are set thorugh the HTTP /// headers and the option max-age, if not indicated, is set to the default /// value (60 seconds). if the response has an enclosing entity, it is mapped /// to a CoAP payload and the content-type of the CoAP message is set /// properly. /// </summary> /// <param name="httpResponse">the http response</param> /// <param name="coapRequest">the coap response</param> /// <returns></returns> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="TranslationException"></exception> public static Response GetCoapResponse(HttpWebResponse httpResponse, Request coapRequest) { if (httpResponse == null) throw ThrowHelper.ArgumentNull("httpResponse"); if (coapRequest == null) throw ThrowHelper.ArgumentNull("coapRequest"); HttpStatusCode httpCode = httpResponse.StatusCode; StatusCode coapCode = 0; // the code 204-"no content" should be managed // separately because it can be mapped to different coap codes // depending on the request that has originated the response if (httpCode == HttpStatusCode.NoContent) { if (coapRequest.Method == Method.DELETE) coapCode = StatusCode.Deleted; else coapCode = StatusCode.Changed; } else { if (!http2coapCode.TryGetValue(httpCode, out coapCode)) throw ThrowHelper.TranslationException("Cannot convert the HTTP status " + httpCode); } // create the coap reaponse Response coapResponse = new Response(coapCode); // translate the http headers in coap options IEnumerable<Option> coapOptions = GetCoapOptions(httpResponse.Headers); coapResponse.SetOptions(coapOptions); // the response should indicate a max-age value (CoAP 10.1.1) if (!coapResponse.HasOption(OptionType.MaxAge)) { // The Max-Age Option for responses to POST, PUT or DELETE requests // should always be set to 0 (draft-castellani-core-http-mapping). coapResponse.MaxAge = coapRequest.Method == Method.GET ? CoapConstants.DefaultMaxAge : 0; } Byte[] buffer = new Byte[4096]; using (Stream ms = new MemoryStream(buffer.Length), dataStream = httpResponse.GetResponseStream()) { Int32 read; while ((read = dataStream.Read(buffer, 0, buffer.Length)) > 0) { ms.Write(buffer, 0, read); } Byte[] payload = ((MemoryStream)ms).ToArray(); if (payload.Length > 0) { coapResponse.Payload = payload; coapResponse.ContentType = GetCoapMediaType(httpResponse.GetResponseHeader("content-type")); } } return coapResponse; }
public static string GetStringHeader(HttpWebResponse response, string headerName) { string headerValue = response.GetResponseHeader(headerName); if (headerValue != null) return headerValue; else return String.Empty; }
private APIResponse GetResponse(HttpWebResponse webResponse) { APIResponse response = new APIResponse(); try { if (webResponse.GetResponseHeader("Set-Cookie").Length > 0) { this.sessionCookie = webResponse.GetResponseHeader("Set-Cookie"); } response.Code = webResponse.StatusCode; Stream responseStream = webResponse.GetResponseStream(); StreamReader streamReader = new StreamReader(responseStream); response.ResponseData = streamReader.ReadToEnd(); streamReader.Close(); webResponse.Close(); } catch (WebException exception) { response.Code = HttpStatusCode.BadRequest; response.ResponseData = exception.Message; } catch (Exception exception) { response.Code = HttpStatusCode.InternalServerError; response.ResponseData = exception.Message; } return response; }
internal static string Write(Options options, RunResult result, HttpWebResponse response) { var output = new StringBuilder(); var oldColor = Console.ForegroundColor; if (result.ResponseCode != 0 && response == null) { Console.ForegroundColor = ConsoleColor.Red; var line = string.Format("ERROR {0} {1} ", options.Item.Url, result.ResponseCode ); output.Append(line); Console.Write(line); } if (response != null) { Console.ForegroundColor = ConsoleColor.Yellow; var line = string.Format("{0}/{1} {2} ", (response.ResponseUri.OriginalString.ToLower().Contains("https") ? Consts.HTTPS : Consts.HTTP), response.ProtocolVersion, result.ResponseCode ); Console.Write(line); output.Append(line); Console.ForegroundColor = ConsoleColor.DarkGreen; Console.WriteLine(response.StatusDescription); output.Append(response.StatusDescription + Environment.NewLine); if (options.ShowHeaders) { foreach (string header in response.Headers) { output.Append(WriteColored(header, response.GetResponseHeader(header))); } } if (options.ShowBody) { if (response.ContentType == "application/json") { var obj = JObject.Parse(result.ResponseBody); output.Append(WriteJsonTree(obj, 1)); } else { Console.ForegroundColor = oldColor; output.Append(result.ResponseBody + Environment.NewLine); Console.WriteLine(result.ResponseBody); } } } Console.ForegroundColor = oldColor; return output.ToString(); }