private void AddRequestXml(string url, HttpWebRequest req)
    {
        Stream stream = (Stream)req.GetRequestStream();
        using (XmlTextWriter writer = new XmlTextWriter(stream, Encoding.UTF8))
        {
            writer.WriteStartDocument(true);
            writer.WriteStartElement("methodCall");
            writer.WriteElementString("methodName", "pingback.ping");
            writer.WriteStartElement("params");

            writer.WriteStartElement("param");
            writer.WriteStartElement("value");
            writer.WriteElementString("string", Blogsa.Url);
            writer.WriteEndElement();
            writer.WriteEndElement();

            writer.WriteStartElement("param");
            writer.WriteStartElement("value");
            writer.WriteElementString("string", url);
            writer.WriteEndElement();
            writer.WriteEndElement();

            writer.WriteEndElement();
            writer.WriteEndElement();
        }
    }

            private void set_option(string rel)
            {
                string url = "http://" + URI + "/web/cgi-bin/hi3510/param.cgi?"+rel+"&usr=" + Login + "&pwd=" + Password;

                Console.WriteLine("Call "+url+" - start");
                HttpWebRequest req = (HttpWebRequest)WebRequest.Create (url);
                req.KeepAlive = false;
                req.Headers.Add ("Accept-Encoding", "gzip,deflate");
                req.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
                req.UseDefaultCredentials = true;
                req.Credentials = new NetworkCredential (Login, Password);
                req.Proxy = null;
                req.Timeout = 1000;
                WebResponse resp = null;
                req.KeepAlive = false;

                pause = true;
                try{
                    resp = req.GetResponse();
                    resp.Close();
                } catch(Exception e) {
                    Console.WriteLine (e.Message);
                }

                req = null;

                Console.WriteLine("Call "+url+" - end");
            }

    public void Request(string url)
    {
        Stopwatch timer = new Stopwatch();
        StringBuilder respBody = new StringBuilder();

        this.request = (HttpWebRequest)WebRequest.Create(url);

        try {
            timer.Start();
            this.response = (HttpWebResponse)this.request.GetResponse();
            byte[] buf = new byte[8192];
            Stream respStream = this.response.GetResponseStream();
            int count = 0;
            do {
                count = respStream.Read(buf, 0, buf.Length);
                if (count != 0)
                    respBody.Append(Encoding.ASCII.GetString(buf, 0, count));
            }
            while (count > 0);
            timer.Stop();

            this.responseBody = respBody.ToString();
            this.statusCode = (int)(HttpStatusCode)this.response.StatusCode;
            this.responseTime = timer.ElapsedMilliseconds / 1000.0;
        } catch (WebException ex) {
            this.response = (HttpWebResponse)ex.Response;
            this.responseBody = "No Server Response";
            this.escapedBody = "No Server Response";
            this.responseTime = 0.0;
        }
    }

	public State (int id, HttpWebRequest req)
	{
		this.id = id;
		request = req;
		handle = new ManualResetEvent (false);
		handleList.Add (handle);
	}

    // fields

    // constructors

    // properties

    // methods

        internal static void OnSendingHeaders(HttpWebRequest httpWebRequest) {
            GlobalLog.Print("CookieModule::OnSendingHeaders()");
            try {
                if (httpWebRequest.CookieContainer == null) {
                    return;
                }
                //
                // remove all current cookies. This could be a redirect
                //
                httpWebRequest.Headers.RemoveInternal(HttpKnownHeaderNames.Cookie);
                //
                // add in the new headers from the cookie container for this request
                //
                string optCookie2;
                string cookieString = httpWebRequest.CookieContainer.GetCookieHeader(
                    httpWebRequest.GetRemoteResourceUri(), out optCookie2);

                if (cookieString.Length > 0) {
                    GlobalLog.Print("CookieModule::OnSendingHeaders() setting Cookie header to:[" + cookieString + "]");
                    httpWebRequest.Headers[HttpKnownHeaderNames.Cookie] = cookieString;

//<





                }
            }
            catch {
            }

        }

        internal static void OnReceivedHeaders(HttpWebRequest httpWebRequest) {
            GlobalLog.Print("CookieModule.OnReceivedHeaders()");
            //
            // if the app doesn't want us to handle cookies then there's nothing
            // to do. Note that we're leaving open the possibility that these
            // settings could be changed between the request being made and the
            // response received
            //
            try {
                if (httpWebRequest.CookieContainer == null) {
                    return;
                }

                //
                // add any received cookies for this response to the container
                //
                HttpWebResponse response = (HttpWebResponse)httpWebRequest._HttpResponse;
                CookieCollection cookies = null;
                try {
                    string cookieString = response.Headers[HttpKnownHeaderNames.SetCookie];
                    GlobalLog.Print("CookieModule::OnSendingHeaders() received Set-Cookie:[" + cookieString + "]");
                    if ((cookieString != null) && (cookieString.Length > 0)) {
                        cookies = httpWebRequest.CookieContainer.CookieCutter(
                                                            response.ResponseUri,
                                                            HttpKnownHeaderNames.SetCookie,
                                                            cookieString,
                                                            false);
                    }
                }
                catch {
                }

                try {
                    string cookieString = response.Headers[HttpKnownHeaderNames.SetCookie2];
                    GlobalLog.Print("CookieModule::OnSendingHeaders() received Set-Cookie2:[" + cookieString + "]");
                    if ((cookieString != null) && (cookieString.Length > 0)) {
                        CookieCollection cookies2 = httpWebRequest.CookieContainer.CookieCutter(
                                                                    response.ResponseUri,
                                                                    HttpKnownHeaderNames.SetCookie2,
                                                                    cookieString,
                                                                    false);
                        if (cookies != null && cookies.Count != 0) {
                            cookies.Add(cookies2);
                        }
                        else {
                            cookies = cookies2;
                        }
                    }
                }
                catch {
                }
                if (cookies != null) {
                    response.Cookies = cookies;
                }
            }
            catch {
            }

        }

 public static void InitializeRequest(HttpWebRequest request)
 {
     request.Headers.Add("aw-tenant-code", API_TENANT_CODE);
     request.Credentials = new NetworkCredential(USER_NAME, PASSWORD);
     request.KeepAlive = false;
     request.AddRange(1024);
     request.Timeout = 10000;
 }

 /// <summary>
 /// For every request, there are things we expect to remain constant. Verify that they do.
 /// </summary>
 /// <param name="request"></param>
 /// <param name="method"></param>
 public void AssertRequestDefaults(HttpWebRequest request, string method)
 {
     Assert.IsTrue(request.Address == new Uri(host));
     Assert.IsTrue(request.Headers.ToString() == "Authorization: Bearer\r\nContent-Type: application/json\r\n\r\n");
     Assert.IsTrue(request.Host == "localhost");
     Assert.IsTrue(request.KeepAlive == true);
     Assert.IsTrue(request.Method == method);
     Assert.IsTrue(request.Timeout == 90000);
 }

            protected HttpWebResponse getResponse(HttpWebRequest request)
            {
                // execute the request

                    HttpWebResponse response = (HttpWebResponse)
                        request.GetResponse();

                    return response;
            }

    private void InitGCMClient()
    {
        //對GCM Server發出Http post
        gcmRequest = WebRequest.Create(GCM_URI) as HttpWebRequest;
        gcmRequest.ContentType = "application/json";
        gcmRequest.UserAgent = "Android GCM Message Sender Client 1.0";
        gcmRequest.Method = "POST";

        // Credential info
        gcmRequest.Headers.Add("Authorization", "key=" + APIKey);
    }

 /// <summary>
 /// Constructs a new async result object
 /// </summary>
 /// <param name="source">The source of the operation.</param>
 /// <param name="method">Name of the method which is invoked asynchronously.</param>
 /// <param name="request">The <see cref="HttpWebRequest"/> object which is wrapped by this async result.</param>
 /// <param name="callback">User specified callback for the async operation.</param>
 /// <param name="state">User state for the async callback.</param>
 internal GetReadStreamResult(
     object source, 
     string method, 
     HttpWebRequest request, 
     AsyncCallback callback, 
     object state)
     : base(source, method, callback, state)
 {
     Debug.Assert(request != null, "Null request can't be wrapped to a result.");
     this.request = request;
     this.Abortable = request;
 }

 public Stream createDataStream(Dictionary<string,string> body ,HttpWebRequest request)
 {
     string theBody = "";
     foreach(KeyValuePair<string,string> bodyPart in body){
         theBody = theBody + bodyPart.Key + "=" + bodyPart.Value + "&";
     }
     byte[] byteArray = Encoding.UTF8.GetBytes(theBody);
     request.ContentLength = byteArray.Length;
     Stream dataStream = request.GetRequestStream();
     dataStream.Write(byteArray, 0,byteArray.Length);
     dataStream.Close ();
     return dataStream;
 }

    public static HttpWebRequest AddProxyInfoToRequest(HttpWebRequest httpRequest, Uri proxyUri, string proxyId, string proxyPassword, string proxyDomain)
    {
        if (httpRequest != null)
            {

                WebProxy proxyInfo = new WebProxy();
                proxyInfo.Address = proxyUri;
                proxyInfo.BypassProxyOnLocal = true;
                proxyInfo.Credentials = new NetworkCredential(proxyId, proxyPassword, proxyDomain);
                httpRequest.Proxy = proxyInfo;

            }
            return httpRequest;
    }

		public HttpWebRequestCore (HttpWebRequest parent, Uri uri)
		{
			if (uri == null)
				throw new ArgumentNullException ("uri");

			this.uri = uri;
			if (parent == null) {
				// special case used for policy
				allow_read_buffering = true;
				method = "GET";
			} else {
				allow_read_buffering = parent.AllowReadStreamBuffering;
				method = parent.Method;
				headers = parent.Headers;
			}
		}

    private string GetResponse(string url, ref HttpWebRequest request)
    {
        StringBuilder sb = new StringBuilder();
        Stream resStream = null;
        HttpWebResponse response = null;
        byte[] buf = new byte[8192];

        try
        {
            // execute the request
            response = (HttpWebResponse)request.GetResponse();

            // we will read data via the response stream
            resStream = response.GetResponseStream();
            string tempString = null;
            int count = 0;
            do
            {
                // fill the buffer with data
                count = resStream.Read(buf, 0, buf.Length);
                // make sure we read some data
                if (count != 0)
                {
                    // translate from bytes to ASCII text
                    tempString = Encoding.ASCII.GetString(buf, 0, count);
                    // continue building the string
                    sb.Append(tempString);
                }
            }
            while (count > 0); // any more data to read?
        }
        catch (Exception err)
        {
            String exc = err.Message;
        }
        finally
        {
            response.Close();
            resStream.Close();
        }

        return sb.ToString();
    }

  /**
   * Constructs and returns the full URL associated with the passed request
   * object.
   * 
   * @param  request Servlet request object with methods for retrieving the
   *         various components of the request URL
   */
  public static String getRequestUrl(HttpWebRequest request) {
    StringBuilder requestUrl = new StringBuilder();
    String scheme = request.RequestUri.Scheme;
    int port = request.RequestUri.Port;

    requestUrl.Append(scheme);
    requestUrl.Append("://");
    requestUrl.Append(request.RequestUri.Host);

    if ((scheme.Equals("http") && port != 80)
            || (scheme.Equals("https") && port != 443)) {
      requestUrl.Append(":");
      requestUrl.Append(port);
    }

    requestUrl.Append(request.RequestUri.AbsolutePath);
      // query string?

    return requestUrl.ToString();
  }

 public static string getResponce(HttpWebRequest request)
 {
     try
     {
         HttpWebResponse resp = (HttpWebResponse)request.GetResponse();
         StreamReader reader = new StreamReader(resp.GetResponseStream());
         string result = reader.ReadToEnd();
         reader.Close();
         return result + "&status=200";
     }
     catch (Exception ex)
     {
         string statusCode = "";
         if (ex.Message.Contains("403"))
             statusCode = "403";
         else if (ex.Message.Contains("401"))
             statusCode = "401";
         return string.Format("status={0}&error={1}", statusCode, ex.Message);
     }
 }

 public static void FillRequestWithContent(HttpWebRequest request, string contentPath)
 {
     using (BinaryReader reader = new BinaryReader(File.OpenRead(contentPath)))
     {
         request.ContentLength = reader.BaseStream.Length;
         using (Stream stream = request.GetRequestStream())
         {
             byte[] buffer = new byte[reader.BaseStream.Length];
             while (true)
             {
                 int bytesRead = reader.Read(buffer, 0, buffer.Length);
                 if (bytesRead == 0)
                 {
                     break;
                 }
                 stream.Write(buffer, 0, bytesRead);
             }
         }
     }
 }

		public BrowserHttpWebResponse (HttpWebRequest request, IntPtr native)
		{
			this.request = request;
			this.response = new MemoryStream ();
			progressive = request.AllowReadStreamBuffering;
			Headers = new WebHeaderCollection ();
			SetMethod (request.Method);

			if (native == IntPtr.Zero)
				return;
			
			// Get the status code and status text asap, this way we don't have to 
			// ref/unref the native ptr
			int status_code = NativeMethods.http_response_get_response_status (native);
			SetStatus ((HttpStatusCode) status_code, (status_code == 200 || status_code == 404) ?
				NativeMethods.http_response_get_response_status_text (native) :
				"Requested resource was not found");

			GCHandle handle = GCHandle.Alloc (this);
			NativeMethods.http_response_visit_headers (native, OnHttpHeader, GCHandle.ToIntPtr (handle));
			handle.Free ();
		}

  /**
   * Validates the passed request by reconstructing the original URL and
   * parameters and generating a signature following the OAuth HMAC-SHA1
   * specification and using the passed secret key.
   * 
   * @param  request Servlet request containing required information for
   *         reconstructing the signature such as the request's URL
   *         components and parameters
   * @param  consumerSecret Secret key shared between application owner and
   *         container. Used by containers when issuing signed makeRequests
   *         and by client applications to verify the source of these
   *         requests and the authenticity of its parameters.
   * @return {@code true} if the signature generated in this function matches
   *         the signature in the passed request, {@code false} otherwise
   * @throws IOException
   * @throws URISyntaxException
   */
  public static bool verifyHmacSignature(
      HttpWebRequest request, String consumerSecret)
    {

    String method = request.Method;
    String requestUrl = getRequestUrl(request);
    List<OAuth.Parameter> requestParameters = getRequestParameters(request);

    OAuthMessage message =
        new OAuthMessage(method, requestUrl, requestParameters);

    OAuthConsumer consumer =
        new OAuthConsumer(null, null, consumerSecret, null);
    OAuthAccessor accessor = new OAuthAccessor(consumer);

    try {
      message.validateMessage(accessor, new SimpleOAuthValidator());
    } catch (OAuthException e) {
      return false;
    }

    return true;
  }