tcp粘包问题(封包)

tcp粘包分析     http://blog.csdn.net/zhangxinrun/article/details/6721495

解决TCP网络传输“粘包”问题（经典）       http://blog.csdn.net/zhangxinrun/article/details/6721508

粘包出现原因：在流传输中出现，UDP不会出现粘包，因为它有消息边界(参考Windows 网络编程)
1 发送端需要等缓冲区满才发送出去，造成粘包
2 接收方不及时接收缓冲区的包，造成多个包接收

解决办法：
为了避免粘包现象，可采取以下几种措施。一是对于发送方引起的粘包现象，用户可通过编程设置来避免，TCP提供了强制数据立即传送的操作指令push，TCP软件收到该操作指令后，就立即将本段数据发送出去，而不必等待发送缓冲区满；二是对于接收方引起的粘包，则可通过优化程序设计、精简接收进程工作量、提高接收进程优先级等措施，使其及时接收数据，从而尽量避免出现粘包现象；三是由接收方控制，将一包数据按结构字段，人为控制分多次接收，然后合并，通过这种手段来避免粘包。

以上提到的三种措施，都有其不足之处。第一种编程设置方法虽然可以避免发送方引起的粘包，但它关闭了优化算法，降低了网络发送效率，影响应用程序的性能，一般不建议使用。第二种方法只能减少出现粘包的可能性，但并不能完全避免粘包，当发送频率较高时，或由于网络突发可能使某个时间段数据包到达接收方较快，接收方还是有可能来不及接收，从而导致粘包。第三种方法虽然避免了粘包，但应用程序的效率较低，对实时应用的场合不适合。

载自：http://blog.csdn.net/binghuazh/archive/2009/05/28/4222516.aspx

封包:

封包就是给一段数据加上包头,这样一来数据包就分为包头和包体两部分内容了(以后讲过滤非法包时封包会加入"包尾"内容).包头其实上是个大小固定的结构体,其中有个结构体成员变量表示包体的长度,这是个很重要的变量,其他的结构体成员可根据需要自己定义.根据包头长度固定以及包头中含有包体长度的变量就能正确的拆分出一个完整的数据包.

服务端程序：

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/un.h>
#include<sys/wait.h>      //*进程用的头文件*/
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
#define MAXLINE  1024  //通信内容的最大长度

struct message
        {
                int len;
                char buffer[1024];
        } ;

ssize_t readn(int fd, void *buf, size_t count)
{
    ssize_t nleft=count;
    ssize_t nread;
    char *charbuf=(char*) buf;

    while(nleft>0)
    {
        nread=read(fd,charbuf,nleft);
        if(nread<0)
          {
              if(errno==EINTR)
               continue;
                        return -1;
          }
        else if(nread==0)
                       return count-nleft;
                
        charbuf +=nread;
                nleft=count-nread;
    }
    
    return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
        ssize_t nleft=count;
        ssize_t nwrite;
        char *charbuf=(char*) buf;

        while(nleft>0)
        {
                nwrite=write(fd,charbuf,nleft);
                if(nwrite<0)
                  {
                        if(errno==EINTR)
                           continue;
                        return -1;
                  }
                else if(nwrite==0)
                       return count-nleft;
               
                charbuf +=nwrite;
                nleft=count-nwrite;
        }

        return count;
}

int main()
{
    int sock_fd,new_fd;//sock_fd用于监听，new_fd用于连接
    struct sockaddr_in srv_addr;//服务器的地址信息
    struct sockaddr_in client_addr;//客户机的地址信息
    int size; //地址结构数据的长度
    pid_t  pid;  //子进程id
    ssize_t n,ret;
    char buf[MAXLINE]; //用于存放通信的内容
     
        struct message sendbuf,recvbuf;
    memset(&sendbuf,0,sizeof(sendbuf));
    memset(&recvbuf,0,sizeof(recvbuf));

    /*创建套接字*/
    sock_fd=socket(AF_INET,SOCK_STREAM,0);//采用IPv4协议
    if(sock_fd==-1)
    {
        perror("creat socket failed");
        exit(1);
    }
    
    /*服务器地址参数*/
    srv_addr.sin_family=AF_INET;  
    srv_addr.sin_port=htons(3490);
    srv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
    bzero(&srv_addr.sin_zero,sizeof(struct sockaddr_in));//bzero位清零函数，将sin_zero清零，sin_zero为填充字段，必须全部为零
    
    int on=1; //表示开启reuseaddr
    if(setsockopt(sock_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on))<0)  //打开地址、端口重用
        perror("setsockopt");
    
    /*绑定地址和端口*/
    if(bind(sock_fd,(struct sockaddr*)&srv_addr,sizeof(struct sockaddr))==-1)
    {
        perror("bind failed");
        exit(1);
    }
    
    /*设置监听模式，等待客户机的监听*/
    if((listen(sock_fd,5))==-1)
    {
        perror("listen failed");
        exit(1);
    }
    
    /*接受连接,采用非阻塞是的模式调用accep*/
    //while(1)
    //{
        size=sizeof(struct sockaddr_in);
        new_fd=accept(sock_fd,(struct sockaddr*)&client_addr,&size);
        if(new_fd==-1)
        {
            perror("accept failed");
            //continue;//restart accept when EINTR
        }
        
        printf("server:got connection from IP= %s prot= %d 
",inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port));//连接成功，打印客户机IP地址和端口号
        /*char *inet_nota(struct sockaddr_in in);
        头文件：
        arpa/inet.h
        Winsock2.h
        参数：
        一个网络上的IP地址
        返回值：
          如果正确，返回一个字符指针，指向一块存储着点分格式IP地址的静态缓冲区（同一线程内共享此内存）；错误，返回NULL。
        uint31_t ntohs(uint32_t net32bitvalue);
        头文件：
        #include<netinet/in.h>
        把net32bitvalue有网络字节序转换为主机字节序。
        */
        if(send(new_fd,"Hello client,I am 192.168.229.125!
",50,0)==-1)  //192.168.229.125为子进程IP，可更改
            perror("send failed");

        pid=fork();  //父进程建立套接字的连接之后，创建子进程用于通信
        if(pid<0)
               perror("fork error
");
        if(!pid)//创建新的子进程,用于发送数据
        {  
            while(fgets(sendbuf.buffer,sizeof(sendbuf.buffer),stdin)!=NULL)
            {
                n=strlen(sendbuf.buffer);
                sendbuf.len=htonl(n);
                writen(new_fd,&sendbuf,4+n);
                memset(&sendbuf,0,sizeof(sendbuf));   //清空，以免和下一次混淆
           // exit(EXIT_SUCCESS);
                    }
            exit(EXIT_SUCCESS);
        }
        else    //父进程用于接收数据
        {
            while(1)
                {
                    memset(&recvbuf,0,sizeof(recvbuf)); 
                    ret=readn(new_fd,&recvbuf.len,4);
                    if(ret<0)
                        perror("read from server error");
                    else if(ret<4)
                        {
                            printf("peer closed
");
                            break;
                        }
                    n=ntohl(recvbuf.len);
                    ret=readn(new_fd,recvbuf.buffer,n);
                    if(ret<0)
                        perror("read from server error");
                    else if(ret<n)
                    {
                        printf("peer closed
");
                        break;
                    }
                 fputs(recvbuf.buffer,stdout);
            }
             exit(EXIT_SUCCESS);
        }
        //while(waitpid(-1,NULL,WNOHANG)>0);//等待子进程结束，进行新的连接
    //}
    return 0;
}

客户端程序

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/un.h>
#include<sys/wait.h>      //*进程用的头文件*/
#include<netinet/in.h>
#include<arpa/inet.h>

#define MAXBYTEMUN   1024

struct message
    {
        int len;
        char buffer[1024];
    } ;

ssize_t readn(int fd, void *buf, size_t count)
{
        ssize_t nleft=count;
        ssize_t nread;
        char *charbuf=(char*) buf;

        while(nleft>0)
        {
                nread=read(fd,charbuf,nleft);
                if(nread<0)
                  {
                        if(errno==EINTR)
                           continue;
                        return -1;
                  }
                else if(nread==0)
                       return count-nleft;

                charbuf +=nread;
                nleft=count-nread;
        }

        return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
        ssize_t nleft=count;
        ssize_t nwrite;
        char *charbuf=(char*) buf;

        while(nleft>0)
        {
                nwrite=write(fd,charbuf,nleft);
                if(nwrite<0)
                  {
                        if(errno==EINTR)
                           continue;
                        return -1;
                  }
                else if(nwrite==0)
                       return count-nleft;

                charbuf +=nwrite;
                nleft=count-nwrite;
        }

        return count;
}

int main(int argc,char *argv[])
{
    int sock_fd,numbytes;
    char buf[MAXBYTEMUN];
    struct hostent *he;
    struct sockaddr_in client_addr;//客户机的地址信息
    ssize_t n,ret;
    struct message recvbuf,sendbuf;
    memset(&recvbuf,0,sizeof(recvbuf));
    memset(&sendbuf,0,sizeof(sendbuf));
    
    if(argc!=2)
    {
        fprintf(stderr,"usage: client IPAddress
");   //执行客户端程序时，输入客户端程序名称和其IP地址
        exit(1);    
    }
    
    /*创建套接字*/
    sock_fd=socket(AF_INET,SOCK_STREAM,0);//采用IPv4协议
    if(sock_fd==-1)
    {
        perror("creat socket failed");
        exit(1);
    }
    
    /*服务器地址参数*/
    client_addr.sin_family=AF_INET;  
    client_addr.sin_port=htons(3490);
    client_addr.sin_addr.s_addr=inet_addr(argv[1]);
    bzero(&client_addr.sin_zero,sizeof(struct sockaddr_in));//bzero位清零函数，将sin_zero清零，sin_zero为填充字段，必须全部为零
    
    
    /*连接到服务器*/
    if(connect(sock_fd,(struct sockaddr*)&client_addr,sizeof(struct sockaddr))==-1)
    {
        perror("connect failed");
        exit(1);
    }
    if((numbytes=recv(sock_fd,buf,MAXBYTEMUN,0))==-1)
        {       
            perror("receive failed");
             exit(1);
        }
    buf[numbytes]='';//在字符串末尾加上，否则字符串无法输出
    printf("Received: %s
",buf);
    
    pid_t pid;
    pid=fork();
    if(!pid)//创建新的子进程,用于接收数据
        {
            while(1)
            {
                memset(&recvbuf,0,sizeof(recvbuf));
                ret=readn(sock_fd,&recvbuf.len,4);
                if(ret<0)
                                        perror("read from server error");
                else if(ret<4)
                {
                    printf("peer closed
");
                    break;
                }
                n=ntohl(recvbuf.len);
                ret=readn(sock_fd,recvbuf.buffer,n);
                                if(ret<0)
                                        perror("read from server error");
                                else if(ret<n)
                                {
                                        printf("peer closed
");
                                        break;
                                }

                fputs(recvbuf.buffer,stdout);
            }
            close(sock_fd);
        }
        else   //f=父进程用于发送数据
        {
            while(fgets(sendbuf.buffer,sizeof(sendbuf.buffer),stdin)!=NULL)
            {
                n=strlen(sendbuf.buffer);
                                sendbuf.len=htonl(n);
                                writen(sock_fd,&sendbuf,4+n);
    
                memset(&sendbuf,0,sizeof(sendbuf));    //清空，以免和下一次混淆
            }
             close(sock_fd);
        }
    return 0;
}