1. 程式人生 > >通過Socket進行HttP/HTTPS網頁操作

通過Socket進行HttP/HTTPS網頁操作

但是由於學藝不精或經驗不夠豐富,仍有很多困惑和疑問?

那麼下面就通過一系列演示來解決其中一些問題。

廢話不多,先列舉一些HTTP/HTTPS操作過程經常遇到的問題:

1、HTTP協議頭引數?

     示例:

      image

     上圖是瀏覽google時通過IE9.0開發者工具抓到的HTTP資料包,如圖中所示,HTTP協議頭

      存在一些固定的鍵值對;很多人經常搞不清楚這些協議頭到底是否必須要?是否必須和瀏覽器

      提交時抓去到的一模一樣去提交?

      要回答這2個問題,一是需要對HTTP協議有一個簡單瞭解,二是要根據具體應用進行分析;

      如:Accept引數,細心一點就會發現請求頁面時可能為 text/html 請求圖片時就為image/jpeg

            當然根據系統環境,還有Application/xml一類等。 那麼你需要根據需求………         

      又比如:user-Agent引數,很明顯裡面包含的是系統型別與瀏覽器型別,假設你需要偽造!!

      還有如:Accept-Encoding引數,如果大家在使用HttpWebRequest請求網頁時也添加了如上圖的 Accept-Encoding引數,那自己會很杯具的發現,請求回來的內容需要先gzip解壓;該怎麼做你應該知道了!!

      類似上面提交的三種情況,我們需要的就是經驗和靈活應用,作為開發者,我們的優勢是可以換位

      以一個開發者的角度來思考問題:比如我是否會通過Http Header中的Referer引數頭來判斷訪問者

      來路,是否允許它請求;

      我的做法就是簡單、簡單、簡單:

 StringBuilder bulider = new StringBuilder();
                bulider.AppendLine("POST /user/pass_request HTTP/1.1");
                bulider.AppendLine();
                bulider.AppendLine("User-Agent: Mozilla/5.0 (Windows NT 6.1; IE 9.0)");
                bulider.AppendLine("Accept: text"
);
                bulider.AppendLine("Content-Type: application/x-www-form-urlencoded");
                bulider.AppendLine(string.Format("Content-Length: {0}\r\n", Encoding.Default.GetBytes(strPost).Length));
                bulider.Append(strPost);
   需要補充的是Post操作時必須包含Content-Type: application/x-www-form-urlencoded引數;

2、HTTP與HTTPS的區別?

     HTTPS相比HTTP是一種安全可靠的連線,開啟一個HTTPS連線,我們會發現瀏覽器都會有相應的提示,image   類似這樣的,可以通過點選其圖示檢視安全狀態和證書;

那麼我們用HttpWebRequest操作HTTPS和HTTP時有什麼區別或者不一定的地方呢?

其實大部分地方都是一樣的,很多網站在伺服器段並沒有做非常嚴格的限制和配置,在做HTTPS操作時甚至不需要新增證書,但是如果遇到必須要使用證書的,那就需要指定HttpWebRequest的Credentials屬性;

另外關注HttpWebRequest操作HTTPS的文章網上也較多,大家可自行搜尋!

3、Cookies問題?

HttpwebRequest好的一點是我們不需要去關注Cookies,.NET中提供了CookieContainer類來做 Cookies容器,很好的與HttpWebRequest結合,使得我們不必要自己去處理Cookies,當然一些涉及到修改Cookies內容的時候還是有必要的。

例如一年前我分析過拍拍網->財付通的跳轉,它就在Cookies中存放了一個引數導致在跳轉過程中不需要重新登入,而直接從HTTP頁面訪問至HTTPS;

下面在講Socket操作時就需要特別關注下這個Cookies咯!

4、速度問題?

    毫無疑問由於HTTP協議是基於TCP/IP的,而HttpWebRequest在封裝過程中的一些處理或多或少的會影響到訪問速度;至於影響多少,我在前段時間做一個國外網站操作的時候簡單對比了下,HttpWebRequest和Socket原生操作的速度相差大概在5倍以上;

   很多時候其實我們並不是很關注速度影響,但是實際應用過程中就會遇到有客戶要求的飛速(當然不排除一些客戶認為執行緒越多速度越快)。

簡單談了下以上4個問題,其實還很是很片面,鑑於個人表達能力有限,有些東西還需要大家在實踐中去認識瞭解;下面就來著重看下通過Socket操作HTTP/HTTPS;

前面我們已經知道了簡單的HTTP協議,也知道HTTP是基於TCP/IP協議的,對於有網路經驗的同學,我們就可以直接寫Socket提交HTTP協議,這一步相對比較簡單,我們直接看一下程式碼就OK了:

static byte[] InternalSocketHttp(IPEndPoint endpoint,
           HttpArgs args,
           HttpMethod method)
        {
            using (Socket sK = new Socket(AddressFamily.InterNetwork,
                        SocketType.Stream,
                        ProtocolType.Tcp))
            {
                try
                {
                    sK.Connect(endpoint);
                    if (sK.Connected)
                    {
                        byte[] buff = ParseHttpArgs(method, args);
                        if (sK.Send(buff) > 0)
                        {
                            return ParseResponse(endpoint,sK,args);
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
            return null;
        }

其中有2個比較重要的函式一個是ParseHttpArgs(),另外一個是ParseResponse();

先看第一個函式:

static byte[] ParseHttpArgs(HttpMethod method, HttpArgs args)
        {
            StringBuilder bulider = new StringBuilder();
            if (method.Equals(HttpMethod.POST))
            {
                bulider.AppendLine(string.Format("POST {0} HTTP/1.1",
                    args.Url));
                bulider.AppendLine("Content-Type: application/x-www-form-urlencoded");
            }
            else
            {
                bulider.AppendLine(string.Format("GET {0} HTTP/1.1",
                args.Url));
            }
            bulider.AppendLine(string.Format("Host: {0}",
                args.Host));
            bulider.AppendLine("User-Agent: Mozilla/5.0 (Windows NT 6.1; IE 9.0)");
            if (!string.IsNullOrEmpty(args.Referer))
                bulider.AppendLine(string.Format("Referer: {0}",
                    args.Referer));
            bulider.AppendLine("Connection: keep-alive");
            bulider.AppendLine(string.Format("Accept: {0}",
                args.Accept));
            bulider.AppendLine(string.Format("Cookie: {0}",
                args.Cookie));
            if (method.Equals(HttpMethod.POST))
            {
                bulider.AppendLine(string.Format("Content-Length: {0}\r\n",
                   Encoding.Default.GetBytes(args.Body).Length));
                bulider.Append(args.Body);
            }
            else
            {
                bulider.Append("\r\n");
            }
            string header = bulider.ToString();
            return Encoding.Default.GetBytes(header);
        }

通過上面的程式碼,很清晰的我們就能看到ParseHttpArgs其實就是將HttpArgs的一些屬性填充為HTTP協議,並返回其二進位制內容用於Socket提交,其中值得注意的一點就是在HTTP協議頭完畢後實際上需要一個空行,這一點有疑惑的同學請看HTTP協議詳解:http://www.cnblogs.com/li0803/archive/2008/11/03/1324746.html

至於ParseResponse函式我們暫時先不講解,其大致過程是先讀取Socket ,讀取出Http返回包的協議頭,

然後根據不同的協議頭進行下一步處理;

-----------------------到此為止,簡單的利用Socket進行HTTP操作的例子已經有了,無非就是填充協議,提交資料,解析返回資料;

下面我們來了解下HTTP返回協議頭:

HTTP/1.1 200   HTTP/1.1 404 大家都比較熟悉,一個是成功 一個是404無法訪問,我們需要關注的是 HTTP/1.1 302 ,對於302的解釋大家可以google下.

而我們的任務是需要處理302,在瀏覽器操作時遇到301 302之類的協議時,一般瀏覽器會自動幫我們進行跳轉,而我們使用HttpWebRequest操作時也可以通過指定AllowAutoRedirect屬性來響應重定向;

那麼在Socket提交時,可就沒有那麼智慧了,這時候就需要我們自己處理302,否則你會發現你請求的結果和你的預期不一樣;

 if (header.StartsWith("HTTP/1.1 302"))
                {
                    int start = header
                        .ToUpper().IndexOf("LOCATION");
                    if (start > 0)
                    {
                        string temp = header.Substring(start, header.Length - start);
                        string[] sArry = Regex.Split(temp, "\r\n");
                        args.Url = sArry[0].Remove(0, 10);
                        return Get(endpoint, args, certificates);  //注意:302協議需要重定向
                    }
                }

上面這段程式碼時前面提到的ParseResponse函式的一部分,根據302協議描述,我們知道它有一個Location引數,這個引數內容就是需要重定向的地址,當我們判斷到302操作時就需要重新提交;

這裡有一個問題插播下:HTTP協議是一種短連線,而我們一般做網路通訊做Socket操作時,大多數是長連線操作,那麼這裡我們遇到302 或者 發起一個請求,這個過程是也應該按照HTTP協議的要求進行短連線,即 連線伺服器-> 發起一個HTTP請求->收到一個HTTP請求->斷開伺服器連線。(所以細心的同學就會發現之前的示例中的using語句以及此處的 Get(*,*,*)方法)

OK,簡單的瞭解了302如何處理,還有重要的一點就是Cookies,很多同學都知道Cookies也是HTTP協議的一個引數,在用Socket提交時也需要指定Cookies,這一點很好理解,服務端會根據Cookies來判斷頁面跳轉之間的狀態,那麼假設你需要你的提交能被服務端正確判斷到,那你必須提交Cookies讓服務端知道就是你;

知道了這一點,那我們一些同學在新增Cookies的時候就犯難了,抓包的時候發現Cookies裡面類似SessionID的一段隨機字串不知道哪裡來的,oh my god,我用瀏覽器瀏覽的時候會有這個值,那用Socket的時候怎麼辦呢,其實在.NET中有一個類SessionIDManager (System.Web.SessionState下)可以幫助我們,

 sessionID = sessionIDManager.CreateSessionID(null);
bulider.AppendLine(string.Format("Cookie: Language=en-US;ASP.NET_SessionId={0}",
                    sessionID));

這下應該明白了吧;

說了這麼多,我們還是來看下ParseResponse函式吧(注意:這只是一個簡單示例,並不一定完全正確,不完善,請酌情使用)

private static byte[] ParseResponse(IPEndPoint endpoint,
             Socket sK,
             HttpArgs args)
        {
            //嘗試10秒時間讀取協議頭
            CancellationTokenSource source = new CancellationTokenSource();
            Task<string> myTask = Task.Factory.StartNew<string>(
                new Func<object, string>(ReadHeaderProcess),
                sK,
                source.Token);
            if (myTask.Wait(10000))
            {
                string header = myTask.Result;
                if (header.StartsWith("HTTP/1.1 302"))
                {
                    int start = header
                        .ToUpper().IndexOf("LOCATION");
                    if (start > 0)
                    {
                        string temp = header.Substring(start, header.Length - start);
                        string[] sArry = Regex.Split(temp, "\r\n");
                        args.Url = sArry[0].Remove(0, 10);
                        return Get(endpoint, args);  //注意:302協議需要重定向
                    }
                }
                else if (header.StartsWith("HTTP/1.1 200"))  //繼續讀取內容
                {
                    int start = header
                           .ToUpper().IndexOf("CONTENT-LENGTH");
                    int content_length = 0;
                    if (start > 0)
                    {
                        string temp = header.Substring(start, header.Length - start);
                        string[] sArry = Regex.Split(temp, "\r\n");
                        content_length = Convert.ToInt32(sArry[0].Split(':')[1]);
                        if (content_length > 0)
                        {
                            byte[] bytes = new byte[content_length];
                            if (sK.Receive(bytes) > 0)
                            {
                                return bytes;
                            }
                        }
                    }
                    else
                    {
                        //不存在Content-Length協議頭
                        return ParseResponse(sK);
                    }
                }
                else
                {
                    return Encoding.Default.GetBytes(header);
                }
            }
            else
            {
                source.Cancel();  //超時的話,別忘記取消任務哦
            }
            return null;
        }

解析下上面這段程式碼:

1)非同步讀取返回的協議頭;設定超時時間!!!!!

2)解析協議頭 ,200  / 302  /404 等!!!!

    示例:

        /// <summary>
        ///  讀取協議頭
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        static string ReadHeaderProcess(object args)
        {
            Socket sK = (Socket)args;
            StringBuilder bulider = new StringBuilder();
            while (true)
            {
                byte[] buff = new byte[1];
                int read = sK.Receive(buff, SocketFlags.None);
                if (read > 0)
                {
                    bulider.Append((char)buff[0]);
                }
                string temp = bulider.ToString();
                if (temp.Contains("\r\n\r\n"))
                {
                    break;
                }
            }
            return bulider.ToString();
        }

3)根據不同返回型別做不同操作!!!!

在返回協議中沒有判斷到Content-Length引數時通過ParseResponse(sK)方法去解析內容,這裡需要說明的是這個函式並不完全正確,通過迴圈讀取 判斷直到讀取到</html> 就認為結束,所以很有可能產生死迴圈,其程式碼如下:

 /// <summary>
        /// 注意:此函式可能產生死迴圈
        /// </summary>
        /// <param name="ssl"></param>
        /// <returns></returns>
        static byte[] ParseResponse(Socket sK)
        {
            ArrayList array = new ArrayList();
            StringBuilder bulider = new StringBuilder();
            int length = 0;
            while (true)
            {
                byte[] buff = new byte[1024];
                int len = sK.Receive(buff);
                if (len > 0)
                {
                    length += len;
                    byte[] reads = new byte[len];
                    Array.Copy(buff, 0, reads, 0, len);
                    array.Add(reads);
                    bulider.Append(Encoding.Default.GetString(reads));
                }
                string temp = bulider.ToString();
                if (temp.ToUpper().Contains("</HTML>"))
                {
                    break;
                }
            }
            byte[] bytes = new byte[length];
            int index = 0;
            for (int i = 0; i < array.Count; i++)
            {
                byte[] temp = (byte[])array[i];
                Array.Copy(temp, 0, bytes,
                    index, temp.Length);
                index += temp.Length;
            }
            return bytes;
        }

OK,OK,又說了一大堆關於Socket操作HTTP的東東,其中提到了Cookies 提到了302 提到了HTTP協議,也基本對應與文章開頭提到的幾個問題;下面我們還要繼續關注下Socket如何操作HTTPS;

其實使用Socket操作HTTPS時與HTTP還是有一些不同的,首先證書載入無疑,還有一點就是連線,一般HTTP伺服器埠80,而HTTPS服務埠是443,

如果有人妄圖通過Socket提交 適用HTTPS協議的加密資料的話,那我沒話說,您牛! 我這裡需要講解的是通過SslStream 載入證書來完成Socket下對HTTPS的操作;

來看下示例程式碼:

 static byte[] InternalSslSocketHttp(IPEndPoint endpoint,
            X509CertificateCollection certificates,
            HttpArgs args,
            HttpMethod method)
        {
            TcpClient tcp = new TcpClient();
            try
            {
                tcp.Connect(endpoint);
                if (tcp.Connected)
                {
                    using (SslStream ssl = new SslStream(tcp.GetStream(),
                        false,
                        new RemoteCertificateValidationCallback(ValidateServerCertificate),
                        null))
                    {
                        ssl.AuthenticateAsClient("ServerName",
                            certificates,
                            SslProtocols.Tls,
                            false);
                        if (ssl.IsAuthenticated)
                        {
                            byte[] buff = ParseHttpArgs(method, args);  //生成協議包
                            ssl.Write(buff);
                            ssl.Flush();
                            return ParseSslResponse(endpoint, ssl, args, certificates);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            return null;
        }

怎麼樣,是否是似曾相識,跟Socket操作HTTP時結構很相似唉~~  ,不同的是這裡使用TcpClient,

這裡有個引數是X509CertificateCollection ,

其實這一切都只為了SslStream,有了SslStream 我想大家也都明白了,剩下的事情是差不多的了。

提一點關於ValidateServerCertificate這個函式,有過證書操作經驗的同學應該不陌生了,大部分情況下,驗證客戶端證書也好,服務端證書也好,我們經常是直接返回一個 true~~  (我不知道為啥, 但是我做上一個WCF應用的時候也是這樣乾的) 所以在有遇到證書檢驗的時候,大家不妨也直接來個return true試試先;

至於剩下的程式碼我就不詳細說咯:貼一下我自己用到的HttpHelper,其中一些程式碼是剛寫的,有錯誤的地方還請大家海涵,有需要的就直接copy下去,自己用的時候自己除錯吧!

using System;
using System.Collections;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
/************************************************************************/
/* Author:huliang
 * Email:[email protected]
 * QQ:12658501
 * 說明:轉載請註明出處
/************************************************************************/
namespace iGame
{
    class HttpArgs
    {
        public string Url { get; set; }
        public string Host { get; set; }
        public string Accept { get; set; }
        public string Referer { get; set; }
        public string Cookie { get; set; }
        public string Body { get; set; }
    }
    static class HttpHelper
    {
        /// <summary>
        /// 提交方法
        /// </summary>
        enum HttpMethod
        {
            GET,
            POST
        }
        #region HttpWebRequest & HttpWebResponse
        /// <summary>
        /// Get方法
        /// </summary>
        /// <param name="geturl">請求地址</param>
        /// <param name="cookieser">Cookies儲存器</param>
        /// <returns>請求返回的Stream</returns>
        public static string Get(string url,
            CookieContainer cookies,
            Encoding encoding)
        {
            return InternalHttp(HttpMethod.GET, url, null, cookies, encoding);
        }
        public static Stream Get(string url,
            CookieContainer cookies)
        {
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
            request.Method = "GET";
            request.UserAgent = "Mozilla/5.0 (Windows NT 6.1;MSIE 6.0;)";
            request.CookieContainer = cookies;
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            return response.GetResponseStream();
        }
        /// <summary>
        /// Post方法
        /// </summary>
        /// <param name="posturl">請求地址</param>
        /// <param name="bytes">Post資料</param>
        /// <param name="cookieser">Cllkies儲存器</param>
        /// <returns>請求返回的流</returns>
        public static string Post(string url,
            byte[] bytes,
            CookieContainer cookies,
            Encoding encoding)
        {
            return InternalHttp(HttpMethod.POST, url, bytes, cookies, encoding);
        }
        /// <summary>
        /// Http操作
        /// </summary>
        /// <param name="method">請求方式</param>
        /// <param name="url">請求地址</param>
        /// <param name="bytes">提交資料</param>
        /// <param name="cookieser">Cookies儲存器</param>
        /// <returns>請求結果</returns>
        static string InternalHttp(HttpMethod method,
            string url,
            byte[] bytes,
            CookieContainer cookies,
            Encoding encoding)
        {
            if (string.IsNullOrEmpty(url))
                throw new ArgumentNullException("訪問url不能為空");
            if (method == HttpMethod.POST)
            {
                if (bytes == null)
                    throw new ArgumentNullException("提交的post資料不能為空");
            }
            if (cookies == null)
                throw new ArgumentNullException("Cookies儲存器不能為空");
            try
            {
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
                request.Method = method.ToString();
                request.UserAgent = "Mozilla/5.0 (Windows NT 6.1;MSIE 9.0;)";
                request.CookieContainer = cookies;
                if (method == HttpMethod.POST)
                {
                    request.ContentType = "application/x-www-form-urlencoded";
                    request.ContentLength = bytes.Length;
                    using (Stream stream = request.GetRequestStream())
                    {
                        stream.Write(bytes, 0, bytes.Length);
                        stream.Flush();
                        stream.Close();
                    }
                }
                HttpWebResponse response = (HttpWebResponse)request.GetResponse();
                if (response.StatusCode == HttpStatusCode.OK)
                {
                    using (StreamReader reader = new StreamReader(response.GetResponseStream(), encoding))
                    {
                        return reader.ReadToEnd();
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
            return null;
        }
        #endregion
        #region Ssl Socket
        static bool ValidateServerCertificate(
                 object sender,
                 X509Certificate certificate,
                 X509Chain chain,
                 SslPolicyErrors sslPolicyErrors)
        {
            /*
            if (sslPolicyErrors == SslPolicyErrors.None)
                return true;
            Console.WriteLine("Certificate error: {0}", sslPolicyErrors);
            return false;
            */
            return true;
        }
        public static byte[] Get(IPEndPoint endpoint, HttpArgs args, X509CertificateCollection certificates)
        {
            return InternalSslSocketHttp(endpoint, certificates, args, HttpMethod.GET);
        }
        public static byte[] Post(IPEndPoint endpoint,
            HttpArgs args,
            X509CertificateCollection certificates)
        {
            return InternalSslSocketHttp(endpoint, certificates, args, HttpMethod.POST);
        }
        static byte[] InternalSslSocketHttp(IPEndPoint endpoint,
            X509CertificateCollection certificates,
            HttpArgs args,
            HttpMethod method)
        {
            TcpClient tcp = new TcpClient();
            try
            {
                tcp.Connect(endpoint);
                if (tcp.Connected)
                {
                    using (SslStream ssl = new SslStream(tcp.GetStream(),
                        false,
                        new RemoteCertificateValidationCallback(ValidateServerCertificate),
                        null))
                    {
                        ssl.AuthenticateAsClient("ServerName",
                            certificates,
                            SslProtocols.Tls,
                            false);
                        if (ssl.IsAuthenticated)
                        {
                            byte[] buff = ParseHttpArgs(method, args);  //生成協議包
                            ssl.Write(buff);
                            ssl.Flush();
                            return ParseSslResponse(endpoint, ssl, args, certificates);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            return null;
        }
        /// <summary>
        /// 解析 Ssl Response
        /// </summary>
        /// <param name="endpoint"></param>
        /// <param name="ssl"></param>
        /// <param name="args"></param>
        /// <param name="certificates"></param>
        /// <returns></returns>
        private static byte[] ParseSslResponse(IPEndPoint endpoint,
            SslStream ssl,
            HttpArgs args,
            X509CertificateCollection certificates)
        {
            //嘗試10秒時間讀取協議頭
            CancellationTokenSource source = new CancellationTokenSource();
            Task<string> myTask = Task.Factory.StartNew<string>(
                new Func<object, string>(ReadSslHeaderProcess),
                ssl,
                source.Token);
            if (myTask.Wait(10000))
            {
                string header = myTask.Result;
                if (header.StartsWith("HTTP/1.1 302"))
                {
                    int start = header
                        .ToUpper().IndexOf("LOCATION");
                    if (start > 0)
                    {
                        string temp = header.Substring(start, header.Length - start);
                        string[] sArry = Regex.Split(temp, "\r\n");
                        args.Url = sArry[0].Remove(0, 10);
                        return Get(endpoint, args, certificates);  //注意:302協議需要重定向
                    }
                }
                else if (header.StartsWith("HTTP/1.1 200"))  //繼續讀取內容
                {
                    int start = header
                           .ToUpper().IndexOf("CONTENT-LENGTH");
                    int content_length = 0;
                    if (start > 0)
                    {
                        string temp = header.Substring(start, header.Length - start);
                        string[] sArry = Regex.Split(temp, "\r\n");
                        content_length = Convert.ToInt32(sArry[0].Split(':')[1]);
                        if (content_length > 0)
                        {
                            byte[] bytes = new byte[content_length];
                            if (ssl.Read(bytes, 0, bytes.Length) > 0)
                            {
                                return bytes;
                            }
                        }
                    }
                    else
                    {
                        //不存在Content-Length協議頭
                        return ParseSslResponse(ssl);
                    }
                }
                else
                {
                    return Encoding.Default.GetBytes(header);
                }
            }
            else
            {
                source.Cancel();  //超時的話,別忘記取消任務哦
            }
            return null;
        }
        /// <summary>
        ///  讀取協議頭
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        static string ReadSslHeaderProcess(object args)
        {
            SslStream ssl = (SslStream)args;
            StringBuilder bulider = new StringBuilder();
            while (true)
            {
                int read = ssl.ReadByte();
                if (read != -1)
                {
                    byte b = (byte)read;
                    bulider.Append((char)b);
                }
                string temp = bulider.ToString();
                if (temp.Contains("\r\n\r\n"))
                {
                    break;
                }
            }
            return bulider.ToString();
        }
        /// <summary>
        /// 注意:此函式可能產生死迴圈
        /// </summary>
        /// <param name="ssl"></param>
        /// <returns></returns>
        static byte[] ParseSslResponse(SslStream ssl)
        {
            //沒有指定協議頭,嘗試讀取至</html>
            ArrayList array = new ArrayList();
            StringBuilder bulider = new StringBuilder();
            int length = 0;
            while (true)
            {
                byte[] buff = new byte[1024];
                int len = ssl.Read(buff, 0, buff.Length);
                if (len > 0)
                {
                    length += len;
                    byte[] reads = new byte[len];
                    Array.Copy(buff, 0, reads, 0, len);
                    array.Add(reads);
                    bulider.Append(Encoding.Default.GetString(reads));
                }
                string temp = bulider.ToString();
                if (temp.ToUpper().Contains("</HTML>"))
                {
                    break;
                }
            }
            byte[] bytes = new byte[length];
            int index = 0;
            for (int i = 0; i < array.Count; i++)
            {
                byte[] temp = (byte[])array[i];
                Array.Copy(temp, 0, bytes,
                    index, temp.Length);
                index += temp.Length;
            }
            return bytes;
        }
        #endregion
        #region Socket
        public static byte[] Get(IPEndPoint endpoint,
            HttpArgs args)
        {
            return InternalSocketHttp(endpoint, args, HttpMethod.GET);
        }
        public static byte[] Post(IPEndPoint endpoint,
            HttpArgs args)
        {
            return InternalSocketHttp(endpoint, args, HttpMethod.POST);
        }
        static byte[] InternalSocketHttp(IPEndPoint endpoint,
           HttpArgs args,
           HttpMethod method)
        {
            using (Socket sK = new Socket(AddressFamily.InterNetwork,
                        SocketType.Stream,
                        ProtocolType.Tcp))
            {
                try
                {
                    sK.Connect(endpoint);
                    if (sK.Connected)
                    {
                        byte[] buff = ParseHttpArgs(method, args);
                        if (sK.Send(buff) > 0)
                        {
                            return ParseResponse(endpoint,sK,args);
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
            return null;
        }
        private static byte[] ParseResponse(IPEndPoint endpoint,
             Socket sK,
             HttpArgs args)
        {
            //嘗試10秒時間讀取協議頭
            CancellationTokenSource source = new CancellationTokenSource();
            Task<string> myTask = Task.Factory.StartNew<string>(
                new Func<object, string>(ReadHeaderProcess),
                sK,
                source.Token);
            if (myTask.Wait(10000))
            {
                string header = myTask.Result;
                if (header.StartsWith("HTTP/1.1 302"))
                {
                    int start = header
                        .ToUpper().IndexOf("LOCATION");
                    if (start > 0)
                    {
                        string temp = header.Substring(start, header.Length - start);
                        string[] sArry = Regex.Split(temp, "\r\n");
                        args.Url = sArry[0].Remove(0, 10);
                        return Get(endpoint, args);  //注意:302協議需要重定向
                    }
                }
                else if (header.StartsWith("HTTP/1.1 200"))  //繼續讀取內容
                {
                    int start = header
                           .ToUpper().IndexOf("CONTENT-LENGTH");
                    int content_length = 0;
                    if (start > 0)
                    {
                        string temp = header.Substring(start, header.Length - start);
                        string[] sArry = Regex.Split(temp, "\r\n");
                        content_length = Convert.ToInt32(sArry[0].Split(':')[1]);
                        if (content_length > 0)
                        {
                            byte[] bytes = new byte[content_length];
                            if (sK.Receive(bytes) > 0)
                            {
                                return bytes;
                            }
                        }
                    }
                    else
                    {
                        //不存在Content-Length協議頭
                        return ParseResponse(sK);
                    }
                }
                else
                {
                    return Encoding.Default.GetBytes(header);
                }
            }
            else
            {
                source.Cancel();  //超時的話,別忘記取消任務哦
            }
            return null;
        }
        /// <summary>
        ///  讀取協議頭
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        static string ReadHeaderProcess(object args)
        {
            Socket sK = (Socket)args;
            StringBuilder bulider = new StringBuilder();
            while (true)
            {
                byte[] buff = new byte[1];
                int read = sK.Receive(buff, SocketFlags.None);
                if (read > 0)
                {
                    bulider.Append((char)buff[0]);
                }
                string temp = bulider.ToString();
                if (temp.Contains("\r\n\r\n"))
                {
                    break;
                }
            }
            return bulider.ToString();
        }
        /// <summary>
        /// 注意:此函式可能產生死迴圈
        /// </summary>
        /// <param name="ssl"></param>
        /// <returns></returns>
        static byte[] ParseResponse(Socket sK)
        {
            ArrayList array = new ArrayList();
            StringBuilder bulider = new StringBuilder();
            int length = 0;
            while (true)
            {
                byte[] buff = new byte[1024];
                int len = sK.Receive(buff