public GetResponse( WebRequest request ) :
     base(request)
 {
     SortedList metadata = extractMetadata( response );
     string body = Utils.slurpInputStream( response.GetResponseStream() );
     this.obj = new S3Object( body, metadata );
 }

        private static void CopyHttpRequestProps (WebRequest source, WebRequest copy)
        {
            var httpSource = source as HttpWebRequest;
            if (httpSource == null)
                return;

            var httpCopy = (HttpWebRequest)copy;
            //httpCopy.Accept = httpSource.Accept;
            //httpCopy.Connection = httpSource.Connection;
            //httpCopy.ContentLength = httpSource.ContentLength;
            //httpCopy.Date = httpSource.Date;
            //httpCopy.Expect = httpSource.Expect;
            //httpCopy.Host = httpSource.Host;
            //httpCopy.IfModifiedSince = httpSource.IfModifiedSince;
            //httpCopy.Referer = httpSource.Referer;
            //httpCopy.TransferEncoding = httpSource.TransferEncoding;
            //httpCopy.UserAgent = httpSource.UserAgent;
            httpCopy.AllowAutoRedirect = httpSource.AllowAutoRedirect;
            httpCopy.AllowReadStreamBuffering = httpSource.AllowReadStreamBuffering;
            httpCopy.AllowWriteStreamBuffering = httpSource.AllowWriteStreamBuffering;
            httpCopy.AutomaticDecompression = httpSource.AutomaticDecompression;
            httpCopy.ClientCertificates = httpSource.ClientCertificates;
            httpCopy.ContinueTimeout = httpSource.ContinueTimeout;
            httpCopy.CookieContainer = httpSource.CookieContainer;
            httpCopy.KeepAlive = httpSource.KeepAlive;
            httpCopy.MaximumAutomaticRedirections = httpSource.MaximumAutomaticRedirections;
            httpCopy.MaximumResponseHeadersLength = httpSource.MaximumResponseHeadersLength;
            httpCopy.MediaType = httpSource.MediaType;
            httpCopy.Pipelined = httpSource.Pipelined;
            httpCopy.ProtocolVersion = httpSource.ProtocolVersion;
            httpCopy.ReadWriteTimeout = httpSource.ReadWriteTimeout;
            httpCopy.SendChunked = httpSource.SendChunked;
            httpCopy.ServerCertificateValidationCallback = httpSource.ServerCertificateValidationCallback;
            httpCopy.UnsafeAuthenticatedConnectionSharing = httpSource.UnsafeAuthenticatedConnectionSharing;
        }

        public void SignRequestLite(WebRequest webRequest)
        {
            if (webRequest == null)
                throw new ArgumentNullException("webRequest");

            webRequest.Headers[this.headerName] = this.headerValue();
        }

        public void StartAsync(HttpContext context, string url)
        {
            this.m_context = context;

            this.m_request = HttpWebRequest.Create(url);
            this.m_request.BeginGetResponse(this.EndGetResponseCallback, null);
        }

 public RequestState(WebRequest request)
 {
     BufferRead = new byte[BUFFER_SIZE];
     RequestData = new StringBuilder(String.Empty);
     Request = request;
     ResponseStream = null;
 }

 public HttpJsonRequest(string url, string method, JObject metadata)
 {
     webRequest = WebRequest.Create(url);
     WriteMetadata(metadata);
     webRequest.Method = method;
     webRequest.ContentType = "application/json";
 }

        //---------------------------------------------------
        // @Name:		attemptConnection
        // @Author:		Lane - PeePeeSpeed
        // @Inputs:		string url, string queue
        // @Outputs:	NULL
        //
        // @Desc:		Attempts to create a connection
        //                to the server for data transfer.
        //---------------------------------------------------
        public void attemptConnection(string u, string q)
        {
            try
            {
                wrGetUrl = WebRequest.Create(u + "?cmd=get&Value=" + q);
                objStream = wrGetUrl.GetResponse().GetResponseStream();
                objReader = new StreamReader(objStream);

                //assert here?
            }
            catch (System.Net.WebException)
            {
                DialogResult dialogResult = MessageBox.Show("Could not establish connection to server\n\nDo you want to try again? System will exit on No.", "Error", MessageBoxButtons.YesNo);

                switch (dialogResult)
                {
                    case DialogResult.Yes:
                        attemptConnection(u, q);
                        break;
                    case DialogResult.No:
                        System.Environment.Exit(0);
                        break;
                }
            }
        }

        public ListAllMyBucketsResponse( WebRequest request )
            : base(request)
        {
            buckets = new ArrayList();
            string rawBucketXML = Utils.slurpInputStreamAsString( response.GetResponseStream() );

            XmlDocument doc = new XmlDocument();
            doc.LoadXml( rawBucketXML );
            foreach (XmlNode node in doc.ChildNodes)
            {
                if (node.Name.Equals("ListAllMyBucketsResult"))
                {
                    foreach (XmlNode child in node.ChildNodes)
                    {
                        if (child.Name.Equals("Owner"))
                        {
                            owner = new Owner(child);
                        }
                        else if (child.Name.Equals("Buckets"))
                        {
                            foreach (XmlNode bucket in child.ChildNodes)
                            {
                                if (bucket.Name.Equals("Bucket"))
                                {
                                    buckets.Add(new Bucket(bucket));
                                }
                            }
                        }
                    }
                }
            }
        }

        internal bool Invoke(string hostName,
                             ServicePoint servicePoint,
                             X509Certificate certificate,
                             WebRequest request,
                             X509Chain chain,
                             SslPolicyErrors sslPolicyErrors)
        {
            PolicyWrapper policyWrapper = new PolicyWrapper(m_CertificatePolicy,
                                                            servicePoint,
                                                            (WebRequest) request);

            if (m_Context == null)
            {
                return policyWrapper.CheckErrors(hostName,
                                                 certificate,
                                                 chain,
                                                 sslPolicyErrors);
            }
            else
            {
                ExecutionContext execContext = m_Context.CreateCopy();
                CallbackContext callbackContext = new CallbackContext(policyWrapper,
                                                                      hostName,
                                                                      certificate,
                                                                      chain,
                                                                      sslPolicyErrors);
                ExecutionContext.Run(execContext, Callback, callbackContext);
                return callbackContext.result;
            }
        }

        /// <summary>
        /// Authorizes the specified context.
        /// </summary>
        /// <param name="context">The context.</param>
        protected override void AuthenticateCore(WebRequest context)
        {
            context = Enforce.NotNull(context, () => context);

            // Authorize the request.
            context.Credentials = this.Credentials;
        }

 private Request(string url, HttpMethod httpMethod, string entity = null)
 {
     _url = url;
     _httpMethod = httpMethod;
     _entity = entity;
     _webRequest = CreateWebRequest(_url, _entity, _httpMethod);
 }

        /// <summary>
        /// Populates WebRequest using the operation context in telemetry item.
        /// </summary>
        /// <param name="dependencyTelemetry">Dependency telemetry item.</param>
        /// <param name="webRequest">Http web request.</param>
        internal static void SetCorrelationContextForWebRequest(DependencyTelemetry dependencyTelemetry, WebRequest webRequest)
        {
            if (dependencyTelemetry == null)
            {
                throw new ArgumentNullException("dependencyTelemetry");
            }

            if (webRequest != null)
            {
                OperationContext context = dependencyTelemetry.Context.Operation;

                if (!string.IsNullOrEmpty(context.Id))
                {
                    webRequest.Headers.Add(RequestResponseHeaders.StandardRootIdHeader, context.Id);
                }

                if (!string.IsNullOrEmpty(dependencyTelemetry.Id))
                {
                    webRequest.Headers.Add(RequestResponseHeaders.StandardParentIdHeader, dependencyTelemetry.Id);
                }
            }
            else
            {
                DependencyCollectorEventSource.Log.WebRequestIsNullWarning();
            }
        }

		public Authorization Authenticate (string challenge, WebRequest webRequest, ICredentials credentials) 
		{
			if (authObject == null)
				return null;

			return authObject.Authenticate (challenge, webRequest, credentials);
		}

		static Authorization InternalAuthenticate (WebRequest webRequest, ICredentials credentials)
		{
			HttpWebRequest request = webRequest as HttpWebRequest;
			if (request == null || credentials == null)
				return null;

			NetworkCredential cred = credentials.GetCredential (request.AuthUri, "basic");
			if (cred == null)
				return null;

			string userName = cred.UserName;
			if (userName == null || userName == "")
				return null;

			string password = cred.Password;
			string domain = cred.Domain;
			byte [] bytes;

			// If domain is set, MS sends "domain\user:password". 
			if (domain == null || domain == "" || domain.Trim () == "")
				bytes = GetBytes (userName + ":" + password);
			else
				bytes = GetBytes (domain + "\\" + userName + ":" + password);

			string auth = "Basic " + Convert.ToBase64String (bytes);
			return new Authorization (auth);
		}

 // Overrides WebClien'ts GetWebResponse to add response cookies to the cookie container
 protected override WebResponse GetWebResponse(WebRequest request, IAsyncResult result)
 {
     WebResponse response = base.GetWebResponse(request, result);
     ReadCookies(response);
     responseURL = response.ResponseUri;
     return response;
 }

 static WebResponse InitiateRequest(WebRequest request)
 {
     var response = request.GetResponse();
     var status = ((HttpWebResponse)response).StatusCode;
     if (Convert.ToInt32(status) >= 400) throw new Exception("Error making request");
     return response;
 }

		public void UpdateHeaders(WebRequest webRequest)
		{
			if (operationsHeadersDictionary != null)
			{
				foreach (var kvp in operationsHeadersDictionary)
				{
					webRequest.Headers[kvp.Key] = kvp.Value;
				}
			}
			if(operationsHeadersColletion != null)
			{
				foreach (string header in operationsHeadersColletion)
				{
					try
					{
						webRequest.Headers[header] = operationsHeadersColletion[header];
					}
					catch (Exception e)
					{
						throw new InvalidOperationException(
							"Failed to set header '" + header + "' to the value: " + operationsHeadersColletion[header], e);
					}
				}
			}
		}

        public static string SendHttpGet(WebRequest request, YahooMessengerAuthentication authentication)
        {
            request.Method = "GET";

            if(authentication!=null)
            {
                if(!authentication.IsUsingOAuth)
                    request.Headers.Add("Cookie",authentication.Cookie);
                else request.Headers.Add("Authorization", "OAuth");
            }

            using(var response = (HttpWebResponse)request.GetResponse())
            {
                if(response == null) throw new NullReferenceException();

                var respCode = response.StatusCode;

                if (respCode != HttpStatusCode.OK)
                    throw new HttpException(HttpException.HTTP_OK_NOT_RECEIVED, respCode.ToString());

                var dataStream = response.GetResponseStream();

                if (dataStream == null) throw new NullReferenceException();
                var reader = new StreamReader(dataStream);

                // Read the content.
                var responseFromServer = new StringBuilder("");
                responseFromServer.Append(reader.ReadToEnd());
                reader.Close();
                dataStream.Close();
                response.Close();

                return responseFromServer.ToString();
            }
        }

        private static string ExecuteWebRequest(WebRequest webRequest)
        {
            try
            {
                using (var response = webRequest.GetResponse())
                {
                    return ReadStream(response.GetResponseStream());
                }
            }
            catch (WebException webException)
            {
                if (webException.Response != null)
                {
                    var statusCode = ((HttpWebResponse)webException.Response).StatusCode;

                    var romitError = new RomitError();

                    if (webRequest.RequestUri.ToString().Contains("oauth"))
                        romitError = Mapper<RomitError>.MapFromJson(ReadStream(webException.Response.GetResponseStream()));
                    else
                        romitError = Mapper<RomitError>.MapFromJson(ReadStream(webException.Response.GetResponseStream()), "error");

                    throw new RomitException(statusCode, romitError, romitError.Message);
                }

                throw;
            }
        }

        public static string SendHttpPost(WebRequest request, YahooMessengerAuthentication authentication, string content)
        {
            request.Method = "POST";
            byte[] byteArray = Encoding.UTF8.GetBytes(content);
            request.ContentLength = byteArray.Length;
            var dataStream = request.GetRequestStream();
            // Write the data to the request stream.
            dataStream.Write(byteArray, 0, byteArray.Length);
            // Close the Stream object.
            dataStream.Close();
            using(var response = (HttpWebResponse) request.GetResponse())
            {
                if (response == null) throw new NullReferenceException();

                var respCode = response.StatusCode;

                if (respCode != HttpStatusCode.OK)
                    throw new HttpException(HttpException.HTTP_OK_NOT_RECEIVED, respCode.ToString());

                dataStream = response.GetResponseStream();
                if (dataStream == null) throw new NullReferenceException();
                var reader = new StreamReader(dataStream);

                var responseFromServer = new StringBuilder("");
                responseFromServer.Append(reader.ReadToEnd());
                reader.Close();
                dataStream.Close();
                response.Close();

                return responseFromServer.ToString();
            }
        }