TCP/IP協議三次握手與四次揮手與使用異步方式進行消息的接收

三次握手

所謂三次握手（Three-Way Handshake）即建立TCP連接，就是指建立一個TCP連接時，需要客戶端和服務端總共發送3個包以確認連接的建立。在socket編程中，這一過程由客戶端執行connect來觸發，整個流程如下圖所示：

20131022025346218.png

（1）第一次握手：Client將標志位SYN置為1，隨機產生一個值seq=J，并將該數據包發送給Server，Client進入SYN_SENT狀態，等待Server確認。（通俗的說就是客戶端向服務器申請通話）
（2）第二次握手：Server收到數據包后由標志位SYN=1知道Client請求建立連接，Server將標志位SYN和ACK都置為1，ack=J+1，隨機產生一個值seq=K，并將該數據包發送給Client以確認連接請求，Server進入SYN_RCVD狀態。（通俗的說就是服務器同意與客戶端連接并返回消息給客戶端）
（3）第三次握手：Client收到確認后，檢查ack是否為J+1，ACK是否為1，如果正確則將標志位ACK置為1，ack=K+1，并將該數據包發送給Server，Server檢查ack是否為K+1，ACK是否為1，如果正確則連接建立成功，Client和Server進入ESTABLISHED狀態，完成三次握手，隨后Client與Server之間可以開始傳輸數據了。（通俗的說就是客戶端與服務器建立通話連接）

四次揮手

所謂四次揮手（Four-Way Wavehand）即終止TCP連接，就是指斷開一個TCP連接時，需要客戶端和服務端總共發送4個包以確認連接的斷開。在socket編程中，這一過程由客戶端或服務端任一方執行close來觸發，整個流程如下圖所示：

20131022025350523.png

由于TCP連接時全雙工的，因此，每個方向都必須要單獨進行關閉，這一原則是當一方完成數據發送任務后，發送一個FIN來終止這一方向的連接，收到一個FIN只是意味著這一方向上沒有數據流動了，即不會再收到數據了，但是在這個TCP連接上仍然能夠發送數據，直到這一方向也發送了FIN。首先進行關閉的一方將執行主動關閉，而另一方則執行被動關閉，上圖描述的即是如此。
（1）第一次揮手：Client發送一個FIN，用來關閉Client到Server的數據傳送，Client進入FIN_WAIT_1狀態。(客戶端請求服務器切斷連接)
（2）第二次揮手：Server收到FIN后，發送一個ACK給Client，確認序號為收到序號+1（與SYN相同，一個FIN占用一個序號），Server進入CLOSE_WAIT狀態。（針對客戶端的請求做出確認應答）
（3）第三次揮手：Server發送一個FIN，用來關閉Server到Client的數據傳送，Server進入LAST_ACK狀態。（服務器請求客戶端切斷連接）
（4）第四次揮手：Client收到FIN后，Client進入TIME_WAIT狀態，接著發送一個ACK給Server，確認序號為收到序號+1，Server進入CLOSED狀態，完成四次揮手。（針對服務器的請求做出應答）

為什么建立連接是三次握手，而關閉連接卻是四次揮手呢？
這是因為服務端在LISTEN狀態下，收到建立連接請求的SYN報文后，把ACK和SYN放在一個報文里發送給客戶端。而關閉連接時，當收到對方的FIN報文時，僅僅表示對方不再發送數據了但是還能接收數據，己方也未必全部數據都發送給對方了，所以己方可以立即close，也可以發送一些數據給對方后，再發送FIN報文給對方來表示同意現在關閉連接，因此，己方ACK和FIN一般都會分開發送。

下面我們來實現下服務器的異步消息的接收與服務器處理客戶端正常關閉和非正常關閉的操作，下面附上代碼

namespace TCP服務器端
{
    class Program
    {
        static void Main(string[] args)
        {
            StartServerAsync();

            Console.ReadKey();
        }

      static  void StartServerAsync() {
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //本機ip ：127.0.0.1（永遠是本地IP地址）

            IPAddress ipAddress = IPAddress.Parse("192.168.0.144");
            IPEndPoint ipEndPoint = new IPEndPoint(ipAddress, 4747);
            serverSocket.Bind(ipEndPoint);//綁定ip和端口號
            Console.WriteLine("服務器已連接");
            serverSocket.Listen(50);//開始監聽端口號

           // Socket clientSocket = serverSocket.Accept();//接收一個客戶端連接
            serverSocket.BeginAccept(AcceptCallBack,serverSocket);

           
        }

      static void AcceptCallBack(IAsyncResult ar) {

          Socket serverSocket = ar.AsyncState as Socket;
         Socket clientSocket= serverSocket.EndAccept(ar);

          //向客戶端發送一條消息
          string msg = "Hello client! 你好...";
          byte[] data = Encoding.UTF8.GetBytes(msg);
          clientSocket.Send(data);
          clientSocket.BeginReceive(dataBuffer, 0, 1024, SocketFlags.None, ReceivecallBack, clientSocket);//異步進行接受數據

          serverSocket.BeginAccept(AcceptCallBack, serverSocket);
      }

     static byte[] dataBuffer = new byte[1024];
     static void ReceivecallBack(IAsyncResult ar)
     {
         Socket clientSocket=null;
         try
         {
             clientSocket = ar.AsyncState as Socket;
             int count = clientSocket.EndReceive(ar);

             if (count==0){
                 clientSocket.Close();
                 return;
             }

             string msg = Encoding.UTF8.GetString(dataBuffer, 0, count);
             Console.WriteLine("從客戶端接收到數據:" + msg);
             clientSocket.BeginReceive(dataBuffer, 0, 1024, SocketFlags.None, ReceivecallBack, clientSocket);//異步進行接受數據
         }
         catch (Exception e)
         {
             Console.WriteLine(e);
             if (clientSocket != null)
             {
                 clientSocket.Close();
             }
         }
        }
}

namespace TCP客戶端
{
    class Program
    {
        static void Main(string[] args)
        {
            Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            clientSocket.Connect(new IPEndPoint(IPAddress.Parse("192.168.0.144"), 4747));//連接ip和端口號
 Console.WriteLine("客戶端已連接");
            byte[] data = new byte[1024];
            int count = clientSocket.Receive(data);
            string msg = Encoding.UTF8.GetString(data,0,count);

            Console.WriteLine(msg);

            while (true) {
                string s = Console.ReadLine();
                if (s=="c") {
                    clientSocket.Close();
                    return;
                }
                clientSocket.Send(Encoding.UTF8.GetBytes(s));
            }

            clientSocket.Close();
        }
    }
}

設計異步監聽和異步接收數據后發現可以連接多個客戶端，可以發送多條消息


Paste_Image.png

當我們異常關閉客戶端一號的時候


Paste_Image.png
當然按c回車就是正常關閉客戶端這樣就不會報錯
粘包和分包

解決方案直接上代碼
客戶端發送的時候使用BitConverter.GetBytes將數據長度轉成byte數組，并且將數據長度和數據放到同一個byte里面一起發送給服務器端，下面是客戶端發送的代碼

namespace 客戶端
{
    class Message
    {
        public static byte[] GetButes(string data)
        {
            byte[] dataBytes = Encoding.UTF8.GetBytes(data);
            int dataLength = dataBytes.Length;
            byte[] lengthBytes = BitConverter.GetBytes(dataLength);
            byte[] newBytes = lengthBytes.Concat(dataBytes).ToArray();
            return newBytes;
        }
    }
}

namespace 客戶端
{
    class Program
    {
        static void Main(string[] args)
        {
            Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            clientSocket.Connect(new IPEndPoint(IPAddress.Parse("192.168.31.145"), 4747));//連接ip和端口號
            Console.WriteLine("客戶端已連接");
            byte[] data = new byte[1024];
            int count = clientSocket.Receive(data);
            string msg = Encoding.UTF8.GetString(data, 0, count);

            Console.WriteLine(msg);
            for (int i = 0; i < 100; i++)
            {
                clientSocket.Send(Message.GetButes("客戶端發送了消息"+i.ToString()));
            }
            Console.ReadKey();
            clientSocket.Close();
        }
    }
}

服務器端接收的時候也是需要去將數據長度解析出來。

namespace Tcp服務器端
{
    class Message
    {
        public int RemainSize
        {
            get {return Data.Length - startIndex; }
        }
        public byte[] Data { get; } = new byte[1024];

        public int startIndex { get; private set; } = 0;

        public void AddCount(int count)
        {
            startIndex += count;
        }
        public void ReadMessage()
        {
            while (true)
            {
                if (startIndex <=4)
                    return;
                int count = BitConverter.ToInt32(Data, 0);
                if (startIndex - 4 >= count)
                {
                    string s = Encoding.UTF8.GetString(Data, 4, count);
                    Console.WriteLine("解析出一條數據" + s);
                    Array.Copy(Data, count + 4, Data, 0, startIndex - 4 - count);
                    startIndex  -= (count + 4);
                }
                else
                {
                    break;
                }
            }
        }
    }
}

namespace Tcp服務器端
{
    class Program
    {
        static void Main(string[] args)
        {
            StartServerAsync();
            Console.ReadKey();

        }
        static void  StartServerAsync()
        {
            Socket serverSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
   
            IPAddress ipAddress = IPAddress.Parse("192.168.31.145");
            IPEndPoint end =new IPEndPoint(ipAddress, 4747);
            serverSocket.Bind(end);
            serverSocket.Listen(50);

            serverSocket.BeginAccept(AcceptCallBack,serverSocket);
        }
        static  Message msg=new Message();


        static void AcceptCallBack(IAsyncResult ar)
        {
            Socket serverSocket = ar.AsyncState as Socket;
            Socket clientSocket = serverSocket.EndAccept(ar);

            string msgStr = "Hello client! 你好...";
            byte[] data = Encoding.UTF8.GetBytes(msgStr);
            clientSocket.Send(data);
            clientSocket.BeginReceive(msg.Data, msg.startIndex, msg.RemainSize, SocketFlags.None, ReceivecallBack, clientSocket);
            serverSocket.BeginAccept(AcceptCallBack,serverSocket);

        }
        static byte[] dataBuffer=new byte[1024];
        static void ReceivecallBack(IAsyncResult ar)
        {
            Socket clientsocket =null;
        
            try
            {
                clientsocket = ar.AsyncState as Socket;
                int count = clientsocket.EndReceive(ar);
                if (count == 0)
                {
                    clientsocket.Close();
                    return;
                }
                msg.AddCount(count);
                msg.ReadMessage();
                clientsocket.BeginReceive(msg.Data, msg.startIndex, msg.RemainSize, SocketFlags.None, ReceivecallBack, clientsocket);

            }
            catch (Exception e)
            {

                Console.WriteLine(e);
                if (clientsocket != null)
                    clientsocket.Close();
            }
        }
    }
}

發送到服務器端的時候可以看到前面4個是數據長度25，后面的第4個到第28個是接收到的數據。
數據
最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容