Linux 网络编程详解五（TCP/IP协议粘包解决方案二）

最新推荐文章于 2023-10-18 17:10:24 发布
最新推荐文章于 2023-10-18 17:10:24 发布
阅读量119 收藏
点赞数
文章标签： 网络 
ssize_t recv(int s, void *buf, size_t len, int flags);
--与read相比，只能用于网络套接字文件描述符
--当flags参数的值设置为MSG_PEEK时，recv可以从socket缓存中读取数据，但是不会将缓存中该部分数据清除
  使用read函数直接读取socket缓存区中的内容，会清空缓存区中的内容。假设两段报文粘包，read会清空缓存
  区中所有内容，从而导致后一段报文中的粘包的部分数据丢失
--强调：粘包解决方案包尾加\n，必须使用recv()函数，并且设置参数flags的值是MSG_PEEK
//粘包解决方案--包尾加\r\n
//服务器
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

/*
 * 思想，客户端发送报文时，每段报文都以\n结尾，服务端先用recv函数中的flag参数查看缓存区中的数据
 * 以\n分割每个报文
 * 注意，包尾加\r\n这个方案和包头加上包体长度方案最大的区别是包尾加\r\n这个方案并不清楚每次的包体长度是多少，
 * 而包头加上包体长度方案确定确定包体的长度
 * */

ssize_t readn(int fd, const void * buf, ssize_t count)
{
    if (buf == NULL || fd < 0)
    {
        printf("readn() params not allow NULL!\n");
        return -1;
    }
    //定义剩余字符数
    ssize_t lread = count;
    //定义每次读取字符个数
    ssize_t nread = 0;
    //定义字符串移动指针
    char *pbuf = (char *) buf;
    while (lread > 0)
    {
        nread = read(fd, pbuf, lread);
        if (nread == -1)
        {
            //屏蔽信号
            if (errno == EINTR)
                continue;
            return -1;
        } else if (nread == 0)
        {
            printf("client is closed !\n");
            return count - lread;
        }
        //重置剩余字节数
        lread -= nread;
        //指针后移
        pbuf += nread;
    }
    return count;
}

ssize_t writen(int fd, const void * buf, ssize_t count)
{
    if (buf == NULL || fd < 0)
    {
        printf("writen() params not allow NULL!\n");
        return -1;
    }
    //定义剩余字符数
    ssize_t lread = count;
    //定义每次写入字符数
    ssize_t nread = 0;
    //定义临时指针变量--假设pbuf的大小大于网络传输字符串的长度
    char * pbuf = (char *) buf;
    while (lread > 0)
    {
        nread = write(fd, pbuf, lread);
        if (nread == -1)
        {
            //屏蔽信号
            if (errno == EINTR)
                continue;
            return -1;
        } else if (nread == 0)
        {
            printf("client is closed !\n");
            return count - lread;
        }
        //重置剩余字节数
        lread -= nread;
        pbuf += nread;
    }
    return count;
}

ssize_t recv_peek(int fd, const void * buf, ssize_t count)
{
    int ret = 0;
    while (1)
    {
        /*
         * 当recv中flags参数的值是MSG_PEEK时，
         * recv函数会将socket缓存区中的数据读取到内存，并且不会清空socket缓存区（read()获取recv()不加参数时读取完数据后，会清空缓存）
         * 遍历缓存区中的数据，找到\n，分割报文数据
         * */
        ret = recv(fd,(void *)buf, count, MSG_PEEK);
        if (ret == -1 && errno == EINTR)
        {
            continue;
        }
        return ret;
    }
    return -1;
}

//读取缓存区中以\n结尾的字符串
ssize_t mreadline(int fd, const void *buf, ssize_t count)
{
    //定义临时指针变量
    char *pbuf = (char *) buf;
    //定义自定义buf剩余的字节数
    ssize_t lread = count;
    //定义recv每次使用的字节数
    ssize_t nread = 0;
    int ret = 0, i = 0;
    while (1)
    {
        ret = recv_peek(fd, pbuf, lread);
        if (ret < 0)
        {
            printf("recv_peek() failed !\n");
            return -1;
        } else if (ret == 0)
        {
            printf("client is closed !\n");
            return -1;
        }
        nread = ret;
        //遍历读取到的数据
        for (i = 0; i < ret; i++)
        {
            if (pbuf[i] == '\n')
            {
                //清空缓存区
                memset(pbuf, 0, lread);
                ret = readn(fd, pbuf, i + 1);
                if (ret != i + 1)
                    return -1;
                //返回已经读取到的数据
                return ret;
            }
        }
        //如果没有读到\n，需要判断自定义buf是否还有空间--这种情况是一段报文被分割在多个包体中发送
        //recv()函数的返回值只可能小于或者等于count
        if (nread == lread)
        {
            printf("自定义缓存buf的长度太小!\n");
            return -1;
        }
        //说明自定义buf还有空间，可以再接收一次
        //为了读取下一段报文，需要先把socket缓冲区数据全部读取完成
        ret = readn(fd, pbuf, nread);
        if (ret != nread)
            return -1;
        lread -= nread;
        pbuf += nread;
    }
    return -1;
}

int main(int arg, char *args[])
{
    //create socket
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd == -1)
    {
        perror("socket() err");
        return -1;
    }
    //reuseaddr
    int optval = 1;
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval))
            == -1)
    {
        perror("setsockopt() err");
        return -1;
    }
    //bind
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8080);
    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    if (bind(listenfd, (struct sockaddr *) &addr, sizeof(addr)) == -1)
    {
        perror("bind() err");
        return -1;
    }
    //listen
    if (listen(listenfd, SOMAXCONN) == -1)
    {
        perror("listen() err");
        return -1;
    }
    //accept
    struct sockaddr_in peeraddr;
    socklen_t peerlen = sizeof(peeraddr);
    int conn = accept(listenfd, (struct sockaddr *) &peeraddr, &peerlen);
    if (conn == -1)
    {
        perror("accept() err");
        return -1;
    }
    char buf[1024] = { 0 };
    while (1)
    {
        //获取一段报文
        int rc = mreadline(conn, buf, 1024);
        if (rc == -1)
        {
            exit(0);
        }
        //打印报文数据
        fputs(buf, stdout);
        //将原来的报文数据发送回去
        rc = writen(conn, buf, strlen(buf));
        if (rc == -1)
        {
            exit(0);
        }
    }
    return 0;
}
//粘包解决方案--包尾加\r\n
//客户端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

ssize_t readn(int fd, const void *buf, ssize_t count)
{
    //定义临时指针变量
    char *pbuf = (char *)buf;
    //定义每次已读数据
    ssize_t nread = 0;
    //定义剩余数据
    ssize_t lread = count;
    while (lread > 0)
    {
        nread = read(fd, pbuf, lread);
        /*
         * 情况分析：假设b缓冲区buf足够大
         * 如果nread==count,说明数据正好被读完
         * nread<count，说明数据没有被读完，这种情况就是由于粘包产生的
         * socket只接收了数据的一部分，TCP/IP协议不可能出现丢包情况
         * nread==0，说明对方关闭文件描述符
         * nread==-1，说明read函数报错
         * nread>count，这种情况不可能存在
         * */
        if (nread == -1)
        {
            //read()属于可中断睡眠函数，需要做信号处理
            if (errno == EINTR)
                continue;
            perror("read() err");
            return -1;
        } else if (nread == 0)
        {
            printf("client is closed !\n");
            //返回已经读取的字节数
            return count - lread;
        }
        //重新获取 剩余的 需要读取的 字节数
        lread = lread - nread;
        //指针后移
        pbuf = pbuf + nread;
    }
    return count;
}

/* fd：文件描述符
 * buf：数据缓存区
 * count：读取字符数
 * */
ssize_t writen(int fd, const void *buf, ssize_t count)
{
    //定义临时指针变量
    char *pbuf = (char *)buf;
    //每次写入字节数
    ssize_t nwrite = 0;
    //剩余未写字节数
    ssize_t lwrite = count;
    while (lwrite > 0)
    {
        nwrite = write(fd, pbuf, lwrite);
        if (nwrite == -1)
        {
            if (errno == EINTR)
                continue;
            perror("write() err");
            return -1;
        } else if (nwrite == 0)
        {
            printf("client is closed !\n");
            //对方关闭文件描述符，返回已经写完的字节数
            return count - lwrite;
        }
        lwrite -= nwrite;
        pbuf += nwrite;
    }
    return count;
}

ssize_t recv_peek(int fd, const void * buf, ssize_t count)
{
    int ret = 0;
    while (1)
    {
        /*
         * 当recv中flags参数的值是MSG_PEEK时，
         * recv函数会将socket缓存区中的数据读取到内存，并且不会清空socket缓存区（read()获取recv()不加参数时读取完数据后，会清空缓存）
         * 遍历缓存区中的数据，找到\n，分割报文数据
         * */
        ret = recv(fd, (void *)buf, count, MSG_PEEK);
        if (ret == -1 && errno == EINTR)
        {
            continue;
        }
        return ret;
    }
    return -1;
}

//读取缓存区中以\n结尾的字符串
ssize_t mreadall(int fd, const void *buf, ssize_t count)
{
    //定义临时指针变量
    char *pbuf = (char *) buf;
    //定义自定义buf剩余的字节数
    ssize_t lread = count;
    //定义recv每次使用的字节数
    ssize_t nread = 0;
    int ret = 0, i = 0;
    while (1)
    {
        ret = recv_peek(fd, pbuf, lread);
        if (ret < 0)
        {
            printf("recv_peek() failed !\n");
            return -1;
        } else if (ret == 0)
        {
            printf("client is closed !\n");
            return -1;
        }
        nread = ret;
        //遍历读取到的数据
        for (i = 0; i < ret; i++)
        {
            if (pbuf[i] == '\n')
            {
                //清空缓存区
                memset(pbuf, 0, lread);
                ret = readn(fd, pbuf, i + 1);
                if (ret != i + 1)
                    return -1;
                //返回已经读取到的数据
                return ret;
            }
        }
        //如果没有读到\n，需要判断自定义buf是否还有空间--这种情况是一段报文被分割在多个包体中发送
        //recv()函数的返回值只可能小于或者等于count
        if (nread == lread)
        {
            printf("自定义缓存buf的长度太小!\n");
            return -1;
        }
        //说明自定义buf还有空间，可以再接收一次
        //为了读取下一段报文，需要先把socket缓冲区数据全部读取完成
        ret = readn(fd, pbuf, nread);
        if (ret != nread)
            return -1;
        lread -= nread;
        pbuf += nread;
    }
    return -1;
}

int main(int arg, char *args[])
{
    //create socket
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1)
    {
        perror("socket() err");
        return -1;
    }
    //connect
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8080);
    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    if (connect(sockfd, (struct sockaddr *) &addr, sizeof(addr)) == -1)
    {
        perror("connect() err");
        return -1;
    }
    int rc = 0;
    char buf[1024]={0};
    while (fgets(buf, sizeof(buf), stdin) != NULL)
    {
        //发送数据
        rc=writen(sockfd,buf,strlen(buf));
        if (rc != strlen(buf))
        {
            return -1;
        }
        //接收数据
        memset(buf, 0, sizeof(buf));
        rc = mreadall(sockfd,buf,sizeof(buf));
        if(rc==-1)
        {
            return -1;
        }
        //打印包体
        fputs(buf,stdout);
        memset(buf, 0, sizeof(buf));
    }
    return 0;
}

 

weixin_34015860
关注
python 基于TCP协议的套接字编程详解
09-19
在本文中，我们将深入探讨基于TCP协议的Python套接字编程，包括服务器端和客户端的实现，以及一个简单的SSH远程执行命令的模拟。 首先，TCP（传输控制协议）是一种面向连接的、可靠的传输协议，它确保数据的顺序...
基于LWIPTCP粘包处理
最新发布
wangxiansheng121的博客
12-19 1389
/事务标识符. 默认为0x0000.本例用作RS485串口号：0x0001->UART0、0x0002->UART1、0x0003->UART2、0x0004->UART3。while( ((HTONS(aru->Len)+6) <= tot_len) && (tot_len > 0) ) //adu_rtu帧头为6个字节.
TCP粘包问题解决
03-27 1066
出现粘包的情况如下： 比如你一次性接收固定 BUF 大小的数据(比如1024字节) 尤其是在处理 iocp 接收数据的时候， 发送端的一个数据包可能没有1024字节大小，比方说发送聊天内容，一个聊天内容即一个数据包，1024字节就可能包含很多个 数据包，第二次接收固定BUF大小的数据的时候，就可能会出现了粘包，半包问题! ==》 这种情况就必须要做粘包，半包处理了!! 该固定BUF
Linux Socket 分包 和 粘包 问题 - 解决方案
cpp_learner的博客
06-01 2195
针对TCP分包和粘包的问题，提供解决办法！
关于W5500网卡使用过程的部分问题记录
u011116085的博客
10-18 1083
某个项目中用到了W5500这种自带网络协议栈的网卡芯片，由于该项目开发时间很紧，就临时网上买了一些模块拼凑到了一套系统，经过验证果真这种拼积木的方法只能用在学生实验开发中，真不能拿来做工程应用，硬件太不稳定很容易掉坑。
一个简单的TCP自定义通信协议
热门推荐
rotation博客
06-06 3万+
我们为什么要自定义TCP应用层传输协议？因为在TCP流传输的过程中，可能会出现分包与黏包的现象。我们为了解决这些问题，需要我们自定义通信协议进行封包与解包。什么是分包与黏包？分包：指接受方没有接受到一个完整的包，只接受了部分。 黏包：指发送方发送的若干包数据到接收方接收时粘成一包，从接收缓冲区看，后一包数据的头紧接着前一包数据的尾。产生分包与黏包现象的原因是什么？产生分包原因：可能是IP分片传输导
python TCP Socket的粘包和分包的处理详解
09-20
在进行TCP Socket编程时，粘包和分包是两个需要特别注意的问题。TCP是一种面向流的协议，它保证数据传输的顺序性和可靠性，但它本身不包含记录边界信息，因此应用层必须自己处理消息的边界问题。粘包和分包是由于TCP...
GO语言如何手动处理TCP粘包详解
09-20
在TCP/IP协议中，"粘包"是指多个TCP数据包在接收端被合并成一个大的数据包进行处理的情况。这通常发生在数据传输过程中，由于TCP的流式特性，多个小的数据段可能会被组合在一起，而接收方如果没有正确处理，可能会...
python设计tcp数据包协议类的例子
09-19
### Python设计TCP数据包协议类详解 #### 一、引言 在计算机网络通信中，TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。在实际应用中，特别是进行...
c#网络高级编程
11-25
- 解决TCP协议的无消息边界问题，避免数据粘包。 - 异步TCP应用编程，引入EventWaitHandle类、AsyncCallback委托、Begin/End系列方法等，提高网络通信效率。 - 通过异步TCP聊天程序实例，展示服务器端和客户端的设计...
linux网络编程之socket（五）：tcp流协议产生的粘包问题和解决方案
Meditation
06-06 1万+
我们在前面曾经说过，发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），在底层通讯中这些数据可能被拆成很多数据包来发送，但是一个数据包有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向
如何自定义TCP通信协议
南山男的忧伤的博客
04-14 9270
物联网行业智能硬件之间的通信、异构系统之间的对接、中间件的研发、以及各种即时聊天软件等，都会涉及自定义协议。 为了满足不同的业务场景的需要， 应用层之间通信需要实现各种各样的网络协议。以异构系统的对接为例。在早期，我们使用 Web Service 来解决异构系统的对接，后来我们逐渐使用 MQ、RPC 等方式来实现异构系统的通信和整合。 Web Service 是使用 SOAP 协议通过 HTTP 进行传输。MQ 有很多常用的消息队列协议，例如 AMQP、MQTT、STOMP...
TCP协议详解-三次握手、四次挥手
RaphetS的博客
08-09 2889
为什么会有TCP/IP协议在世界上各地，各种各样的电脑运行着各自不同的操作系统为大家服务，这些电脑在表达同一种信息的时候所使用的方法是千差万别。就好像圣经中上帝打乱了各地人的口音，让他们无法合作一样。计算机使用者意识到，计算机只是单兵作战并不会发挥太大的作用。只有把它们联合起来，电脑才会发挥出它最大的潜力。于是人们就想方设法的用电线把电脑连接到了一起。但是简单的连到一起是远远不够的，就好像语言不同的
TCP通讯socket自定义协议的实现
weixin_34281477的博客
12-04 757
转发(JAVA)：http://blog.csdn.net/u010818425/article/details/53448817 　　　　一个简单的自定义通信协议（socket），http://blog.csdn.net/lincyang/article/details/6109076 　　　　http://vtrtbb.iteye.com/blog/849336 　　　　socket编程...
Linux下网络编程之自定义协议进行并发多客户端与服务器的通信(多进程处理并发)不足占用资源太多
时间溜走了的博客
09-01 929
自定义协议消息体#include #include #include #include #include #include #include #include "msg.h" /*计算校验码 */ static unsigned char msg_check(Msg* message) { //将头部和体部进行累加 unsigned char s = 0; int i
TCP协议详解
Cdreamfly的博客
12-12 8246
TCP服务的特点 传输层协议主要有两个: TCP协议和UDP协议。TCP协议相对于UDP协议的特点是:面向连接、字节流和可靠传输。 使用TCP协议通信的双方必须先建立连接，然后才能开始数据的读写。双方都必须为该连接分配必要的内核资源，以管理连接的状态和连接上数据的传输。TCP连接是全双工的，即双方的数据读写可以通过一个连接进行。完成数据交换之后，通信双方都必须断开连接以释放系统资源。 TCP协议的这种连接是一对一的，所以基于广播和多播(目标是多个主机地址)的应用程序不能使用TCP服务。而无连接协议UDP则非
Linux 网络编程——TCP 粘包及其解决方案
程序员「阿基米东」的编程之旅
08-20 4027
首先，我们回顾一下 TCP 和 UDP 的头部信息： 图1. TCP 头部 图2. UDP 头部　　我们知道，TCP 和 UDP 是 TCP/IP 协议族传输层中的两个具有代表性的协议。其中，TCP 是面向连接的复杂的、可靠的字节流传输协议，而 UDP 是面向无连接的简单的、不可靠的数据报传输协议。“流”的概念就是指不间断的数据结构，可以把它想象成你们家里的自来水管道中的水流。什么意思呢？举个例
TCP/IP协议分析及Linux下的编程
菜鸟的博客
07-03 385
title: TCP/IP协议分析及Linux下的编程 date: 2019-07-22 18:34:41 tags: [Linux,TCP/IP] categories: 通信协议 一、TCP/IP体系结构         tcp/ip是一个四层的体系结构，包含应用层、运输层、网络层和网络接口层。四层结构及相应协议如下 层次 相关协议 应用层 HTTP(超文本传输协议)、FTP(文本传输协议)TELNET(远程登录)、SSH(安全外壳协议)、S.
Python网络编程：TCP/IP基础与IO操作详解
本资源主要介绍Python网络编程的相关知识，包括TCP/IP协议和UDP的区别，套接字的基本操作，以及与之相关的函数如`fileno()`、`getpeername()`和`setsockopt()`。此外，内容涵盖了网络通信中的广播功能和HTTP协议的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值