Linux 进程间通信--信号、TCP粘包处理

最新推荐文章于 2023-06-01 22:53:13 发布
最新推荐文章于 2023-06-01 22:53:13 发布
阅读量1.3k 收藏
点赞数
文章标签： signal
本文为博主原创文章，欢迎转载 、传播 !
本文链接：https://blog.csdn.net/leesagacious/article/details/50135381
版权

Server

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

#define ERR_EXIT(m)\
        do{\
            perror(m);\
            exit(EXIT_FAILURE);\
          }while(0)

struct packet
{
    int len; //包头 存放包体中数据的实际长度
    char buf[1024];
};

/**
    进程由于系统调用或者中断进入内核
    在从内核空间返回到用户空间之前，
    检查是否有信号产生,跳到用户态执行信号处理函数
    linux 信号处理机制，请见另篇博文的浅析

    信号产生的时候 ，不会立即响应，这是和中断不一样的一个地方
*/
void handler(int sig)
{
    exit(0);
}

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

    while(nleft > 0)
    {
        nread = read(fd,bufp,nleft);
        if (nread == -1)
        {
            /**
                EINVAL 传给系统调用的参数不正确
                EINTR  被信号中断
                EFAULT 参数中有一指针指向无法存取的内存空间

                信号会打断阻塞的系统调用。因此这里要判断一下。
            */
            if (errno == EINTR)//被信号中断
            {
                continue;
            }else if (errno == EFAULT)//参数中有一指针指向无法存取的内存空间  会报"bad address"错误
            {
                printf("参数有错误\n");
            }
            return -1;
        }else if (nread == 0) //对方关闭了连接
        {
            return count - nleft;
        }else{
            bufp += nread;
            nleft -= nread; //剩余的字节数，如果大于0，继续读取
        }   
    }

    return count;
}


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

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

void do_server(int conn)
{
    struct packet recvbuf;
    int n;
    while(1)
    {
        memset(&recvbuf,0,sizeof(recvbuf));
        /**
            先接收包头
        */
        int ret = readn(conn,&recvbuf.len,4);
        printf("packet header =%d \n",ret );
        if (ret == -1)
        {
            ERR_EXIT("read");

        }else if (ret < 4)
        {
            printf("client close\n");
            break;
        }
        /**
            接收包体
        */
        n = ntohl(recvbuf.len);

        ret = readn(conn,&recvbuf.buf,n);
        if (ret == -1)
        {
            ERR_EXIT("read");
        }else if (ret < n)
        {
            printf("client close\n");
            break;
        }

        fputs(recvbuf.buf,stdout);
    }
}

int main(int argc, char const *argv[])
{
    int listenfd;
    int ret;
    int conn;
    pid_t pid;
    listenfd = socket(AF_INET,SOCK_STREAM,0);
    if (listenfd == -1)
    {
        ERR_EXIT("socket");
    }
    struct sockaddr_in servaddr;
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(6666); //主机字节序转换成网络字节序
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    int on = 1;
    ret = setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));
    if (ret == -1)
    {
        ERR_EXIT("setsockopt");
    }

    ret = bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr));
    if (ret == -1)
    {
        ERR_EXIT("bind");
    }
    //SOMAXCONN = 三次握手已完成 + 三次握手为完成
    ret = listen(listenfd,SOMAXCONN);
    if (ret == -1)
    {
        ERR_EXIT("listen");
    }

    struct sockaddr_in clientaddr;
    socklen_t len = sizeof(clientaddr);

    conn = accept(listenfd,(struct sockaddr *)&clientaddr,&len);
    if (conn == -1)
    {
        ERR_EXIT("accept");
    }

    pid = fork();

    if (pid == 0)  //子进程
    {
        //标准C 写法
        //signal(SIGUSR1,handler);
        struct sigaction act;
        act.sa_handler = handler;
        //将阻塞信号集全部置 0 
        sigemptyset(&act.sa_mask);
        act.sa_flags = 0;

         /**
            int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);

            signum : 你要为那个信号注册捕捉函数 : SIGKILL、SIGSTOP 除外（这两个不能被捕捉、阻塞、忽略）.
            act    : 新设定的动作
            oldact : 信号原来的动作.输出参数

            返回值 : 0  成功 
                     -1 失败  

             struct sigaction
             {
                早期的函数 与下面的一个函数指针互斥
                通过sa_mask来选择采用那种捕捉函数
                void (*sa_handler)(int); 
                void (*sa_sigaction)(int ,siginfo_t *,void *);

                临时信号屏蔽字:
                在执行捕捉函数的时候，设置阻塞其他信号，
                退出捕捉函数后，还原原有的阻塞信号集
                sigset_t sa_mask;

                int sa_flags;
                void (*sa_restorer)(void);
             };      
       */
        int retval = sigaction(SIGUSR1,&act,NULL);
        if (retval == -1)
        {
            ERR_EXIT("sigaction");
        }

        int n;
        struct packet sendbuf;
        memset(&sendbuf,0,sizeof(sendbuf));
        while(fgets(sendbuf.buf,sizeof(sendbuf.buf),stdin) != NULL)
        {
            n = strlen(sendbuf.buf);
            sendbuf.len = htonl(n);

             writen(conn,&sendbuf,4 + n);
             memset(&sendbuf,0,sizeof(sendbuf));
        }

        exit(0);

    }else if (pid > 0)
    {
        while(1)
        {
            printf("---do_server\n");
            do_server(conn);
            break;
        }
        /**
            向子进程发信号
        */
        kill(pid,SIGUSR1);
        exit(0);

    }else{
        ERR_EXIT("fork");
    }

    close(conn);
    close(listenfd);

    return 0;
}

Client

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

#define ERR_EXIT(m)\
        do{\
            perror(m);\
            exit(EXIT_FAILURE);\
          }while(0)

struct packet
{
    int len; //包头 存放包体中数据的实际长度
    char buf[1024];
};

void handler(int sig)
{
    exit(0);
}

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

    while(nleft > 0)
    {
        nread = read(fd,bufp,nleft);
        if (nread == -1)
        {
            /**
                EINVAL 传给系统调用的参数不正确
                EINTR  被信号中断
                EFAULT 参数中有一指针指向无法存取的内存空间
            */
            if (errno == EINTR)//被信号中断
            {
                continue;
            }else if (errno == EFAULT)//参数中有一指针指向无法存取的内存空间  会报"bad address"错误
            {
                printf("参数有错误\n");
            }
            return -1;
        }else if (nread == 0) //对方关闭了连接
        {
            return count - nleft;
        }else{
            bufp += nread;
            nleft -= nread; //剩余的字节数，如果大于0，继续读取
        }   
    }

    return count;
}

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

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

void do_server(int conn)
{
    struct packet recvbuf;
    int n;
    while(1)
    {
        memset(&recvbuf,0,sizeof(recvbuf));
        /**
            先接收包头
        */
        int ret = readn(conn,&recvbuf.len,4);
        if (ret == -1)
        {
            ERR_EXIT("read");

        }else if (ret < 4)
        {
            printf("client close\n");
            break;
        }
        /**
            接收包体
        */
        n = ntohl(recvbuf.len);
        ret = readn(conn,&recvbuf.buf,n);   
        if (ret == -1)
        {
            ERR_EXIT("read");
        }else if (ret < n)
        {
            printf("client close\n");
            break;
        }
        fputs(recvbuf.buf,stdout);
    }
}

int main(int argc, char const *argv[])
{
    int sock;
    int ret;
    pid_t pid;
    sock = socket(AF_INET,SOCK_STREAM,0);
    if (sock == -1)
    {
        ERR_EXIT("socket");
    }

    struct sockaddr_in servaddr;
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(6666);
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    ret = connect(sock,(struct sockaddr *)&servaddr,sizeof(servaddr));
    if (ret == -1)
    {
        ERR_EXIT("connect");
    }

    pid = fork();

    if (pid == 0)
    {
        //标准C 写法
        //signal(SIGUSR1,handler);
        struct sigaction act;
        act.sa_handler = handler;
        sigemptyset(&act.sa_mask);
        act.sa_flags = 0;

        sigaction(SIGUSR1,&act,NULL);

        int n;
        struct packet recvbuf;
        memset(&recvbuf,0,sizeof(recvbuf));
        while(fgets(recvbuf.buf,sizeof(recvbuf.buf),stdin) != NULL)
        {
            n = strlen(recvbuf.buf);
            recvbuf.len = htonl(n);

            writen(sock,&recvbuf,4 + n);
            memset(&recvbuf,0,sizeof(recvbuf));
        }

        exit(0);
    }else if (pid > 0)
    {
        struct packet recvbuf;
        memset(&recvbuf,0,sizeof(recvbuf));
        while(1)
        {
            do_server(sock);
            break;
        }
        /**
            向子进程发送信号
        */
        kill(pid,SIGUSR1);
        exit(0);
    }else{
        ERR_EXIT("fork");
    }

    close(sock);

    return 0;
}

这里写图片描述
这里写图片描述

leesagacious
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux进程间的通信——信号处理
MR_Allen_Lwx的博客
10-15 662
1、实现两个程序mysignal、mycontrl，mycontrl给mysignal发送SIGINT信号， 控制mysignal是否在屏幕打印“hello”字符串。
Linux---进程间通信IPC之信号量
phonycat的博客
08-08 176
SYSTEM V信号量，这是信号量值的集合，不是单个的信号量，相关的信号量操作函数由“sys/ipc.h”引用，这篇主要描述了这个信号量集 信号量 也称信号灯，主要用来控制多个进程对共享资源的访问，信号量是进程通信的一种重要方法，但其本身并不进行数据交换，和管道、消息队列不同，而是以同步，互斥，协调于各个进程之间，协调进程对共享资源的访问，共享内存的使用就要用到信号量。把多个执行流能够访问到的...
Linux Socket 分包 和 粘包 问题 - 解决方案
cpp_learner的博客
06-01 1780
针对TCP分包和粘包的问题，提供解决办法！
Linux网络编程TCP粘包问题解析及解决方法
m0_49476241的博客
04-22 840
本篇文章将引入一个重要的知识：TCP的粘包问题，在发送数据的时候可能会出现粘包的问题，很多初学者应该都不知道什么是粘包，那么本篇文章将讲解什么是粘包，又怎么样解决粘包，这将是一个重点问题，希望大家好好理解。下面我们先做一个小实验。本篇文章是非常重要的，希望大家好好吸收和消化，理解TCP发送数据的工程中为什么会出现粘包问题。后续的文章将会讲解如何指定通信协议。
Linux 网络编程——TCP 粘包及其解决方案
weixin_43841155的博客
02-15 260
Linux 网络编程——TCP 粘包及其解决方案
【Linux】粘包问题
Demok123的博客
11-04 328
粘包的产生会对后面数据的逻辑判断产生影响，但对于粘包的处理取决于粘包是否有影响，如果粘包会产生影响就需要我们去解决，没有影响可以选择不解决（比如文件传输没有影响）。
linux下socket编程处理TCP粘包
qq_40170041的博客
04-18 172
关于数据包的包头大小可以根据自己的实际需求进行设定，这里没有啥特殊需求，因此规定包头的固定大小为4个字节，用于存储当前数据块的总字节数。这样，在进行套接字通信的时候通过调用封装的 sendMsg() 和 recvMsg() 就可以发送和接收带数据头的数据包了，而且完美地解决了粘包的问题。1、首先接收 4 字节数据，并将其从网络字节序转换为主机字节序，这样就得到了即将要接收的数据的总长度。3、将待发送的数据拷贝到包头后边的地址空间中，将完整的数据包发送出去（字符串没有字节序问题）5、释放存储数据的堆内存。
linux网络编程
07-11
23进程间通信介绍（一） 进程同步与进程互斥 进程间通信目的 进程间通信发展 进程间通信分类 进程间共享信息的三种方式 IPC对象的持续性 24进程间通信介绍（二） 死锁 信号量 PV原语 用PV原语解决司机与售票员问题 ...
Linux下用C++实现Socket通信
07-05
Socket接口提供了进程间通过网络进行通信的机制，它允许两个运行在网络上的程序交换数据，无论它们是在同一台机器上还是在不同的机器上。 首先，我们需要了解Socket的基本概念。Socket可以看作是网络通信中的端点，...
Linux网络编程 视频 教程
08-16
Linux网络编程之进程间通信篇 Linux网络编程之线程篇 Linux网络编程之TCP/IP基础篇 01TCPIP基础（一） ISO/OSI参考模型 TCP/IP四层模型 基本概念（对等通信、封装、分用、端口） 02TCPIP基础（二） 最大传输...
C++教程网《Linux网络编程》视频百度云地址
05-23
Linux网络编程之进程间通信篇 Linux网络编程之线程篇 Linux网络编程之TCP/IP基础篇 01TCPIP基础（一） ISO/OSI参考模型 TCP/IP四层模型 基本概念（对等通信、封装、分用、端口） 02TCPIP基础（二） 最大传输...
linux下的简易聊天室
07-24
例如，程序可能需要使用fork()创建子进程，pipe()或socket()进行进程间通信，unistd.h库中的read()和write()函数用于数据传输。 2. **C语言**：作为基础编程语言，C语言在这个项目中用于实现聊天室的逻辑。你需要...
C++ 百万并发网络通信引擎架构与实现 （Socket、全栈、跨平台） Version 1.0
10-17
本课程由刘远东、张立铜两位工程师将两人在企业多年积累的开发经验结合而成。从基础的网络知识开始由浅入深地讲解如何使用C++实现一套支持百万级别并发的网络通信引擎。包含：高频并发、多线程、多进程、线程池、内存池、软件硬件瓶颈、如何测试优化网络处理能力等技术知识。可以应用在Windows、Linux、Android、IOS系统上。对从事高性能网络处理的前后端开发人员有极大帮助。咨询群：648738912
TCP的粘包拆包技术
Free雅轩的博客
05-12 2996
TCP 是一个面向「流」的协议，所谓流就是没有界限的一长串二进制数据。在实际的传输过程中，TCP 会根据网络情况将数据包进行拆分或者拼装，如果业务没有定义一个明确的界限规则，在应用层的业务上就会出现粘包拆包的现象。 平时大家在网络编程过程中可能会遇到这样一种现象：客户端发送了一长串消息，服务端接受的消息揉在一起或者被拆分了，这样就会造成消息难以被正确理解。比如说有一天你特别想喝奶茶，看了一下外卖，「一点点」的奶茶看着不错，(一点点赶紧给我打钱 doge)，于是你在群里发了一条消息，想找几个人拼奶茶： 一
linux网络编程之socket（五）：tcp流协议产生的粘包问题和解决方案
yijiu0711的专栏
12-16 1024
我们在前面曾经说过，发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消
linux服务器开发问题(tcp粘包)
hpx12345678的博客
10-24 1224
a. 成功执行时，返回接收到的字节数。另一端已关闭则返回0。b. 失败返回-1，errno被设为以下的某个值 EAGAIN：套接字已标记为非阻塞，而接收操作被阻塞或者接收超时 EBADF：sock不是有效的描述词 ECONNREFUSE：远程主机阻绝网络连接 EFAULT：内存空间访问出错 EINTR：操作被信号中断 EINVAL：参数无效 ENOMEM：内存不足 ENOTCONN：与面向连接关联的套接字尚未被连接上 ENOTSOCK：sock索引的不是套接字c. 当返回值是0时，为正常关闭连接；在使用非阻
Linux中TCP黏包问题及其解决方案
playboy307
08-10 2138
黏包问题的产生：     由于TCP协议是基于字节流并且无边界的传输协议, 因此很有可能产生粘包问题，然而出现黏包问题与客户端还有服务端都是有关系的。     TCP内置有内格尔算法，当send次数很多，但是每次的数据量又很小的时候，TCP默认将这些数据一起发送，但是接受端并不知道要接收的数据长度，所以会产生黏包问题。 粘包问题产生的多种原因：  1、SQ_SNDBUF 套接字
matlab下载.pdf
最新发布
07-14
matlab下载下载方式及注意事项
linux TCP粘包处理代码
06-01
在Linux中，TCP粘包是指发送方在发送一段数据时，由于网络缓冲区大小限制或者网络拥塞等原因，导致接收方一次性接收到了多个数据包，即多个TCP数据包被合并成一个数据包接收，这就是TCP粘包现象。 处理TCP粘包问题...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值