希望打开这篇能对你有所帮助
文章目录
- 为什么会产生粘包？
- 什么时候容易出现TCP粘包？
- 解决粘包的方案
- 方案变现
- Client
- Server
为什么会产生粘包？
对于TCP：一次一个小包太慢了吧！！！ 大包也就算了，小包还一次一个。合在一起凑够缓冲区一起发吧。所以TCP叫流式数据传输啊！ 对于UDP：不会使用块的合并优化算法，采用了链式结构来记录每一个到达的UDP包。所以不会粘包。所以UDP叫报文数据传输啊。
TCP为用户提供了高可靠性的网络传输服务，但可靠性保障措施也影响了传输效率。因此，在实际工程应用中，只有关键数据的传输才采用TCP，而普通数据的传输一般采用高效率的UDP。
什么时候容易出现TCP粘包？
长连接 不定长包 发包频繁。
总不能说TCP就一直等着缓冲区差不多了发吧，是得有个时间限制的。
解决粘包的方案
定长。不过算了吧，浪费网络资源，IO那么脆弱。
此定长非彼定长。彼定长，怕不是每次都只发送某个固定长度的包吧，那就没意思了。我的定长的意思是，在包头里面预留四个字节的空间，用来在封包的时候加上包的长度，收包的时候这样收：
代码语言：javascript复制1、recv,return n;
2、读取包头，长度 m;
3、解析包头，获取整包（或包体）长度k
4、读取包体(4)
5、读取包尾
6、若包正常，标兵位置后移 m k 4，相应n减小。返回步2，直到n为0。
7、若包不正常，那完了，一整串全没了。开玩笑，只要正常找到包尾就好了，向前向后遍历，不过就很麻烦，会丢一个包，至少一个。
8、一般不会不正常吧，TCP检测很严格的，包破了怎么能正常通信哈哈。原来曾经就使用过，但是不知道解决方法竟然在身边。不过我后面做不定长包那个确实是没有拆包的。。。
一种比较周全的对策是：接收方创建一预处理线程，对接收到的数据包进行预处理，将粘连的包分开。
方案变现
Client
代码语言：javascript复制#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <errno.h>
#define MAX_BUF 1024
//自定义封包的结构体
typedef struct _my_pkt
{
int len;//自定义的包头，包含了包的大小
char buf[MAX_BUF];//包存放的数据
}my_pkt;
void handle(int sig)
{
printf("recv : %dn",sig);
exit(0);
}
//@ssize_t：返回读的长度 若ssize_t<count 读失败
//@buf：接受数据内存首地址
//@count：接受数据长度
ssize_t readn(int fd,void *buf,size_t cnt)
{
size_t nleft = cnt;//定义剩余没有读取的个数
ssize_t nread = 0;//读取的个数
char * bufp = (char *)buf;//将参数接过来
while(nleft > 0)//当剩余需要读取的个数>0
{
if((nread = read(fd,bufp,nleft)) < 0)//成功读取的个数小于0,则判断出错的原因
{
//如果errno被设置为EINTR为被信号中断，如果是被信号中断继续，
//不是信号中断则退出。
if(errno == EINTR)
{
continue;
}
perror("write");
exit(-1);
}
else if(nread == 0)//若对方已关闭
{
return cnt - nleft;
}
bufp = nread;//将 字符串指针向后移动已经成功读取个数的大小。
nleft -= nread;//需要读取的个数=需要读取的个数-以及成功读取的个数
}
return cnt;
}
//@ssize_t：返回写的长度 -1失败
//@buf：待写数据首地址
//@count：待写长度
ssize_t writen(int fd,const void *buf,size_t cnt)
{
size_t nleft = cnt;//需要写入的个数
ssize_t nwritten = 0;//已经成功写入的个数
char * bufp = (char *)buf;//接参数
while(nleft > 0)//如果需要写入的个数>0
{
//如果写入成功的个数<0 判断是否是被信号打断
if((nwritten = write(fd,bufp,nleft)) < 0)
{
if(errno == EINTR)//信号打断，则继续
{
continue;
}
perror("write");
exit(-1);
}
//需要写入的数据个数>0
//如果成功写入的个数为0 则继续
else if(nwritten == 0)
{
continue;
}
bufp = nwritten;//将bufp指针向后移动已经
nleft -= nwritten;//剩余个数
}
return cnt;
}
int main()
{
int clt_fd;
struct sockaddr_in serv_addr;
char addr_dst[INET_ADDRSTRLEN] = {0};
ssize_t ret;
my_pkt sendbuf;
my_pkt recvbuf;
int num = 0;
memset(&sendbuf,0,sizeof(sendbuf));//清空结构体
memset(&recvbuf,0,sizeof(recvbuf));//清空结构体
signal(SIGUSR1,handle);
clt_fd = socket(AF_INET,SOCK_STREAM,0);
if(-1 == clt_fd)
{
perror("socket");
exit(-1);
}
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(8001);
serv_addr.sin_addr.s_addr = inet_addr("192.168.1.110");
if(connect(clt_fd,(struct sockaddr*)&serv_addr,sizeof(serv_addr)) == -1)
{
perror("connect");
exit(-1);
}
printf("Connect successfullyt%s at PORT %dn",inet_ntop(AF_INET,&serv_addr.sin_addr,addr_dst,sizeof(addr_dst)),ntohs(serv_addr.sin_port));
while(fgets(sendbuf.buf,sizeof(sendbuf.buf),stdin) != NULL)
{
num = strlen(sendbuf.buf);
sendbuf.len = htonl(num);
writen(clt_fd,&sendbuf,sizeof(sendbuf.len) num);
ret = readn(clt_fd,&(recvbuf.len),sizeof(recvbuf.len));//读包头 4个字节
if(-1 == ret)
{
perror("readn for len");
exit(-1);
}
else if(ret < 4)//如果读取的个数小于4,则对方已经关闭
{
printf("client close");
break;
}
num = ntohl(recvbuf.len);//将网络数据转换为本地数据结构，比如网络数据为大端，而本地数据为小端
ret = readn(clt_fd,recvbuf.buf,num);//根据包头里包含的大小读取数据
if(-1 == ret)
{
perror("readn for buf");
exit(-1);
}
else if(ret < num)//如果读取的数据的大小小于封包包头中包的大小，那么对方已经关闭
{
printf("client close");
break;
}
fputs(recvbuf.buf,stdout);//将数据打印出
memset(&sendbuf,0,sizeof(sendbuf));//清空结构体
memset(&recvbuf,0,sizeof(recvbuf));//清空结构体
}
return 0;
}Server
代码语言：javascript复制/*server04*/
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <errno.h>
#define MAX_CLIENT 10
#define MAX_BUF 1024
//自定义封包的结构体
typedef struct _my_pkt
{
int len;//自定义的包头，包含了包的大小
char buf[MAX_BUF];//包存放的数据
}my_pkt;
void handle(int sig)//辅助杀死子进程或者父进程
{
printf("recv : %dn",sig);
exit(0);
}
//@ssize_t：返回读的长度 若ssize_t<count 读失败
//@buf：接受数据内存首地址
//@count：接受数据长度
ssize_t readn(int fd,void *buf,size_t cnt)
{
size_t nleft = cnt;//定义剩余没有读取的个数
ssize_t nread = 0;//读取的个数
char * bufp = (char *)buf;//将参数接过来
while(nleft > 0)//当剩余需要读取的个数>0
{
if((nread = read(fd,bufp,nleft)) < 0)//成功读取的个数小于0,则判断出错的原因
{
//如果errno被设置为EINTR为被信号中断，如果是被信号中断继续，
//不是信号中断则退出。
if(errno == EINTR)
{
continue;
}
perror("write");
exit(-1);
}
else if(nread == 0)//若对方已关闭
{
return cnt - nleft;
}
bufp = nread;//将 字符串指针向后移动已经成功读取个数的大小。
nleft -= nread;//需要读取的个数=需要读取的个数-以及成功读取的个数
}
return cnt;
}
//@ssize_t：返回写的长度 -1失败
//@buf：待写数据首地址
//@count：待写长度
ssize_t writen(int fd,const void *buf,size_t cnt)
{
size_t nleft = cnt;//需要写入的个数
ssize_t nwritten = 0;//已经成功写入的个数
char * bufp = (char *)buf;//接参数
while(nleft > 0)//如果需要写入的个数>0
{
//如果写入成功的个数<0 判断是否是被信号打断
if((nwritten = write(fd,bufp,nleft)) < 0)
{
if(errno == EINTR)//信号打断，则继续
{
continue;
}
perror("write");
exit(-1);
}
//需要写入的数据个数>0
//如果成功写入的个数为0 则继续
else if(nwritten == 0)
{
continue;
}
bufp = nwritten;//将bufp指针向后移动已经
nleft -= nwritten;//剩余个数
}
return cnt;
}
void do_service(int fd)
{
my_pkt rcv_pkt;//定义了封包结构体
int num = 0;//数据包长度--封包的包头
int ret = 0;
while(1)
{
memset(&rcv_pkt,0,sizeof(rcv_pkt));//清空结构体
ret = readn(fd,&(rcv_pkt.len),sizeof(rcv_pkt.len));//读包头 4个字节
if(-1 == ret)
{
perror("readn for len");
exit(-1);
}
else if(ret < 4)//如果读取的个数小于4,则对方已经关闭
{
printf("client close");
break;
}
num = ntohl(rcv_pkt.len);//将网络数据转换为本地数据结构，比如网络数据为大端，而本地数据为小端
ret = readn(fd,rcv_pkt.buf,num);//根据包头里包含的大小读取数据
if(-1 == ret)
{
perror("readn for buf");
exit(-1);
}
else if(ret < num)//如果读取的数据的大小小于封包包头中包的大小，那么对方已经关闭
{
printf("client close");
break;
}
fputs(rcv_pkt.buf,stdout);//将数据打印出
//将接受到的数据再直接发出去。
writen(fd,&rcv_pkt,sizeof(rcv_pkt.len) num); //注意写数据的时候，多加包头长度（len）部分
}
}
int main()
{
int serv_fd,con_fd;//服务器端至少要有两个套接字文件描述符--一个用来监听，一个/其余多个用来和客户端通信
struct sockaddr_in serv_addr;//IPV4套接字结构体--服务器
struct sockaddr_in clt_addr;//IPV4套接字结构体--客户端
int optvar;//地址复用使用的参数
pid_t pid;//子进程PID
socklen_t addr_len;
signal(SIGUSR1,handle);//注册新号和处理函数
serv_fd = socket(AF_INET,SOCK_STREAM,0);//建立套接字
if(-1 == serv_fd)
{
perror("socket");
exit(-1);
}
if(setsockopt(serv_fd, SOL_SOCKET,SO_REUSEADDR,&optvar,sizeof(optvar)) == -1 )//地址复用
{
perror("setsockopt");
exit(-1);
}
/*设置地址*/
bzero(&serv_addr,sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(8001);
serv_addr.sin_addr.s_addr = htons(INADDR_ANY);
if(bind(serv_fd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) == -1)//绑定端口
{
perror("bind");
exit(-1);
}
/*一旦调用listen函数--套接字就会变成被动套接字--用来监听客户端，让客户端连接他
被动套接字--只能接受连接，不能主动发送连接
做了两个队列：
一个已经完成三次握手，建立连接的队列--客户端发connect请求被响应，已经成功完成连接
一个是未完成成三次握手的队列--正在握手
*/
if(listen(serv_fd,MAX_CLIENT)== -1)//开始监听
{
perror("listen");
exit(-1);
}
addr_len = sizeof(clt_addr);
printf("Accepting connections ...n");
while(1)
{
if((con_fd = accept(serv_fd,(struct sockaddr *)&clt_addr,&addr_len)) == -1)//可以支持多并发访问
{
perror("accept");
exit(-1);
}
printf("received from %s at PORT %dn",inet_ntoa(clt_addr.sin_addr),ntohs(clt_addr.sin_port));
pid = fork();//创建子进程
if(pid == -1)
{
perror("fork");
close(serv_fd);
exit(-1);
}
else if(pid == 0)//子进程负责接收客户端数据
{
close(serv_fd);
do_service(con_fd);
close(con_fd);
kill(getppid(),SIGUSR1);
exit(1);
}
else//父进程负责监听客户端连接请求
{
close(con_fd);
}
}
return 0;
}
