一、TCP粘包現象

what?

TCP是個“流”協議，即沒有邊界。由于這個特性以及實際的網絡情況，在進行數據傳輸時假設我們連續調用send分別發送兩段數據data1和data2，在接收端有以下幾種代表性的情況：

1. 先接收到data1，然后接收到data2。
2. 先接收到data1的部分數據，然后接收到data1余下的部分以及data2的全部。
3. 先接收到data1的全部數據和data2的部分數據，然后接收到data2余下的數據。
4. 一次性接收到了data1和data2的全部數據。

其中，1是理想情況，也就是我們需要的。對于2,3,4的情況就是常說的“粘包”，就需要把接收到的數據進行拆包，拆成一個個獨立的數據包，而為了拆包就必須在發送端進行封包。

對于UDP來說不存在拆包問題，因為UDP是一個“數據包“協議，也就是兩段數據是有界限的，在接收端要么接收不到數據要么就是一段完整的數據，不會少接收也不會多接收。

這里，筆者在發送端連續發送4096個字節的數據，然后在接收端打印接收到的數據字節數，可以很明顯的看到出現了粘包現象。

receive num=2648
------------------------
receive num=1448
------------------------
receive num=2648
------------------------
receive num=2896
------------------------
receive num=1200
------------------------
receive num=1448
------------------------
receive num=2648
------------------------
receive num=2896
------------------------
receive num=1200
------------------------
receive num=1448
------------------------

why?

為什么會出現粘包這種現象呢，以下幾點原因。

1. 由Nagle算法造成的發送端粘包。Nagle算法是一種改善網絡傳輸效率的算法，但也可能造成困擾。簡單的說，當提交一端數據給TCP時，TCP并不立刻發送此段數據，而是等待一段時間，看看在等待期間是否還有要發送的數據，若有則會一次吧多段數據發送出去。
2. 接收端接收不及時造成的接收端粘包。TCP會把接收到的數據存在自己的緩沖區中，然后通知應用層取數據。當應用層由于某些原因不能及時取出TCP的數據，就會造成TCP緩沖區中存放多段數據。
3. 這種原因是筆者根據實踐得出的，不知道對不對。若發送端發送很大的數據包，比如4096字節，由于網卡和路由器中MTU的限制。MTU規定為1500字節，那么每次數據包要低于1500字節（除去IP頭部等字節），否則網口以及網絡傳輸途徑中路由器等會自動對其進行分包操作。造成接收端并不能一次接收到發送的字節數。

附：

TCP粘包和拆包產生的原因

1. 應用程序寫入數據的字節大小大于套接字發送緩沖區的大小
2. 進行MSS大小的TCP分段。MSS是最大報文段長度的縮寫。MSS是TCP報文段中的數據字段的最大長度。數據字段加上TCP首部才等于整個的TCP報文段。所以MSS并不是TCP報文段的最大長度，而是：MSS=TCP報文段長度-TCP首部長度
3. 以太網的payload大于MTU進行IP分片。MTU指：一種通信協議的某一層上面所能通過的最大數據包大小。如果IP層有一個數據包要傳，而且數據的長度比鏈路層的MTU大，那么IP層就會進行分片，把數據包分成若干片，讓每一片都不超過MTU。注意，IP分片可以發生在原始發送端主機上，也可以發生在中間路由器上。

二、封包和解包

How?

最初解決“粘包”的問題，采用在兩次send之間調用sleep休眠小一段時間來解決，缺點是顯而易見的：傳輸效率大大降低，而且也并不可靠。

對數據包進行封包和解包就能解決這個問題：

封包就是給一段數據加上包頭，這樣一來數據包就分為包頭和包體兩部分內容了（可加上包尾）。包頭其實是一個大小固定的結構體，其中有個結構體成員變量表示包體的長度，這是個很重要的變量，其他的結構體成員可根據需要自己定義。根據固定的包頭長度以及包頭中含有的包體長度變量值就能正確的拆分出一個完整的數據包。

利用底層的緩沖區來進行拆包時，由于TCP也維護了一個緩沖區，所以可以利用TCP的緩沖區來拆包，也就是循環不停地接收包頭給出的數據，直到收夠為止，這就是一個完整的TCP包。
三、代碼示例

為了解決“粘包”問題，大家通常會在所發送的內容前，加上發送內容的長度，所以對方會先收到4Byte，解析獲得接下來所需要接收的長度，再進行收包。

當然這個代碼中還有一些待改進的地方：我們并不能保證接收到的4Byte數據正好表示的是數據的實際長度，改進辦法是在包頭這個結構體變量里添加表示數據頭的標志。

發送端：

#include < stdio.h >
#include < stdlib.h >
#include < string.h >
#include < unistd.h >
#include < sys/types.h >
#include < sys/socket.h >
#include < netinet/in.h >
#include < arpa/inet.h >
#include < errno.h >
/*
客戶端給服務端發送一個字符串，由于雙方都不知道這個字符串有多長，因此發送數據前的前面4個字節表示字符串的大小
數據格式：4字節（存儲字符串實際長度） + 字符串內容
*/
/*
該函數能夠發送指定長度的數據。一次發送不完，可以接著發送，直到發送完指定長度為止
*/
int MySend( int iSock, char * pchBuf, size_t tLen){
        int iThisSend;
        unsigned int iSended=0;//has send bytes
        if(tLen == 0)
               return(0);
        while(iSended< tLen){
              do{
                     iThisSend = send(iSock, pchBuf, tLen-iSended, 0);//this time  
              } while((iThisSend< 0) && (errno==EINTR));
               if(iThisSend < 0){
                      return(iSended);
              }
              iSended += iThisSend;
              pchBuf += iThisSend;
       }
        return(tLen);
}

#define DEFAULT_PORT 6666

int main( int argc, char * argv[]){
    int connfd = 0;
    int cLen = 0;
    struct sockaddr_in client;
    if(argc < 2){
        printf(" Uasge: clientent [server IP address]n");
        return -1;
    }
    client.sin_family = AF_INET;
    client.sin_port = htons(DEFAULT_PORT);
    client.sin_addr.s_addr = inet_addr(argv[1]);
    connfd = socket(AF_INET, SOCK_STREAM, 0);
    if(connfd < 0){
        printf("socket() failure!n" );
        return -1;
    }

    if(connect(connfd, (struct sockaddr*)&client, sizeof(client)) < 0){
        printf("connect() failure!n" );
        return -1;
    }
	//
    ssize_t writeLen;
    char *sendMsg = "0123456789";
    int tLen=strlen(sendMsg);
    printf("tLen:%dn" ,tLen);
    int iLen=0;
    char * pBuff= new char [100];
    *(int*)(pBuff+iLen)= htonl(tLen);
    iLen+=sizeof( int);
    memcpy(pBuff+iLen,sendMsg,tLen);
    iLen+=tLen;
    writeLen= MySend(connfd, pBuff, iLen);
    if (writeLen < 0) {
       printf("write failedn" );
       close(connfd);
       return 0;
    }
    else{
       printf("write sucess, writelen :%d, sendMsg:%sn",writeLen,sendMsg);
    }
    close(connfd);
    return 0;
}

服務器端：

#include < sys/types.h >
#include < sys/socket.h >
#include < netinet/in.h >
#include < arpa/inet.h >
#include < unistd.h >
#include < stdio.h >
#include < stdlib.h >
#include < strings.h >
#include < sys/wait.h >
#include < string.h >
#include < errno.h >

/*
該函數能夠接受指定長度(字節)的數據。循環接收，直到接受完指定數量為止。
*/
int MyRecv( int iSock, char * pchBuf, size_t tCount){
        size_t tBytesRead=0;
        int iThisRead;
        while(tBytesRead < tCount){
              do{
                     iThisRead = read(iSock, pchBuf, tCount-tBytesRead);
              } while((iThisRead< 0) && (errno==EINTR));
              if(iThisRead < 0){
                      return(iThisRead);
              }else if (iThisRead == 0)
                      return(tBytesRead);
              tBytesRead += iThisRead;
              pchBuf += iThisRead;
       }
}

#define DEFAULT_PORT 6666
int main( int argc, char ** argv){
    int sockfd,acceptfd; /* 監聽socket: sock_fd,數據傳輸socket: acceptfd */
    struct sockaddr_in my_addr; /* 本機地址信息 */
    struct sockaddr_in their_addr; /* 客戶地址信息 */
    unsigned int sin_size, myport=6666, lisnum=10;
    if ((sockfd = socket(AF_INET , SOCK_STREAM, 0)) == -1) {
       perror("socket" );
       return -1;
    }

    printf("socket ok n");
    my_addr.sin_family=AF_INET;
    my_addr.sin_port=htons(DEFAULT_PORT);
    my_addr.sin_addr.s_addr = INADDR_ANY;
    bzero(&(my_addr.sin_zero), 0);

    if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr )) == -1) {
        perror("bind" );
        return -2;
    }

    printf("bind ok n");
    if (listen(sockfd, lisnum) == -1) {
        perror("listen" );
        return -3;
    }
    printf("listen ok n");
    char recvMsg[10];
    sin_size = sizeof(my_addr);
    acceptfd = accept(sockfd,(struct sockaddr *)&my_addr,&sin_size);
    if (acceptfd < 0) {
       close(sockfd);
       printf("accept failedn" );
       return -4;
    }

    ssize_t readLen = MyRecv(acceptfd, recvMsg, sizeof( int));
    if (readLen < 0) {
       printf("read failedn" );
       return -1;
    }

    int len=( int)ntohl(*( int*)recvMsg);
    printf("len:%dn",len);
    readLen = MyRecv(acceptfd, recvMsg, len);
    if (readLen < 0) {
       printf("read failedn" );
       return -1;
    }
    recvMsg[len]='?';//接收到的數據并沒有結束符'?',因此需要加上結束符'?
    printf("recvMsg:%sn" ,recvMsg);
    close(acceptfd);
    return 0;
  }

Makefile：

all:tcpServer tcpClient
tcpServer:tcpServer.o
	gcc -g -o tcpServer tcpServer.o
tcpClient:tcpClient.o
	gcc -g -o tcpClient tcpClient.o
tcpServer.o:tcpServer.c
	gcc -g -c tcpServer.c
tcpClient.o:tcpClient.c
	gcc -g -c tcpClient.c
clean:all
	rm all

運行截圖：

四、總結思考

這篇文章一個非常核心的代碼就是readn和writen函數，說白了， 就一直讀， 讀到指定的字節數為止。其實， 在recv函數中， 最后參數如果是MSG_WAITALL, 那么就可以用recv函數一行代碼， 替代上述所有代碼。

大家可以對比下代碼：

ssize_t readn(int fd, void *buf, int n)
{
	size_t nleft = n;   // left的意思是“剩下”, 而非“左邊”
	char *bufptr = buf;
	ssize_t nread;
	while(nleft > 0)
	{
		if((nread = read(fd, bufptr, n)) < 0)
		{
			if(errno == EINTR) 	// 遇到中斷
			{ 
				continue;   // 或者用 nread = 0;
			}
			else
			{
				return -1;  // 真正錯誤
			}
		}
		else if(nread == 0) // 對端關閉
		{
			break;
		}

		nleft -= nread;
		bufptr += nread;
	}

	return (n - nleft);
}


//一句話代碼（MSG_WAITALL），前提套接字是阻塞的
 while ((num = recv(connectfd, recvbuf+buf_pos, recv_size,MSG_WAITALL)) > 0) {
 }