11-服务端进程终止和SIGPIPE信号

最新推荐文章于 2022-06-08 18:16:31 发布
最新推荐文章于 2022-06-08 18:16:31 发布
阅读量858 收藏 4
点赞数 2
分类专栏： linux编程修炼心法 文章标签： linux编程 计算机网络 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35733751/article/details/82712695
版权

1. 服务端进程终止

  这一篇我们将讨论服务器进程终止的问题。

  先启动服务端，再启动客户端，然后杀死服务端子进程，以此来模拟服务器进程终止的情况。如果客户端再向服务端发送数据，这将会发生什么情况？


服务器程序：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sys/wait.h>
#include <stdlib.h>

#define SERV_PORT 10001

注册SIGCHLD信号回收子进程
void wait_child(int signo)
{
    printf("hello SIGCHILD\n");
    //非阻塞方式回收子进程
    while (waitpid(0, NULL, WNOHANG) > 0);
}

int main(void)
{
    pid_t pid;
    int lfd, cfd;
    struct sockaddr_in serv_addr, clie_addr;
    socklen_t clie_addr_len;
    char buf[BUFSIZ], clie_IP[BUFSIZ];
    int n, i ,n2;

    lfd = socket(AF_INET, SOCK_STREAM, 0);

    bzero(&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    bind(lfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    listen(lfd, 128);

    while (1) {
        clie_addr_len = sizeof(clie_addr);
        cfd = accept(lfd, (struct sockaddr *)&clie_addr, &clie_addr_len);
        printf("client IP:%s, port:%d\n", 
                inet_ntop(AF_INET, &clie_addr.sin_addr.s_addr, clie_IP, sizeof(clie_IP)), 
                ntohs(clie_addr.sin_port));

        //创建子进程
        pid = fork();
        if (pid < 0) {
            perror("fork error");
            close(cfd);
            exit(1);
        } else if (pid == 0) {
            close(lfd);
            break;
        } else {
            //父进程
            close(cfd);
            //捕捉SIGCHLD信号
            signal(SIGCHLD, wait_child);
        }
    }


    //子进程
    if (pid == 0) {
        while (1) {
            n = read(cfd, buf, sizeof(buf));
            if (n == 0) { 
               printf("peer close\n");
             //如果read返回0，说明对端已关闭，打印退出客户端信息
            printf("client IP:%s, port:%d ----- exit\n",
                    inet_ntop(AF_INET, &clie_addr.sin_addr.s_addr, clie_IP, sizeof(clie_IP)) ,
                    ntohs(clie_addr.sin_port));
                close(cfd);
                break;   //子进程退出
            } else if (n == -1) {
                perror("read error");
                close(cfd);
                break;
            } else {
                for (i = 0; i < n; i++){
                    buf[i] = toupper(buf[i]);
                }
                n2 = write(cfd, buf, n);
                if(n2 < n){
                        puts("short write");
                }
            }
        }
    }
    close(lfd);
	return 0;
}

客户端程序：

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <errno.h>
#include <stdlib.h>

#define SERV_IP "192.168.0.107"
#define SERV_PORT 10001

int main(void) {
	int sfd, len , ret;
	struct sockaddr_in serv_addr;
	char buf[BUFSIZ];
	sfd = socket(AF_INET, SOCK_STREAM, 0);
	bzero(&serv_addr, sizeof(serv_addr));                       
	serv_addr.sin_family = AF_INET;                         
	inet_pton(AF_INET, SERV_IP, &serv_addr.sin_addr.s_addr); 
	serv_addr.sin_port = htons(SERV_PORT);                      
	ret = connect(sfd, (struct sockaddr *)&serv_addr ,  sizeof(serv_addr));
	if(ret < 0){
		perror("connect error:");
		close(sfd);
		exit(0);
	}

	//循环读写数据
	while (1) {
		fgets(buf, sizeof(buf), stdin);
		write(sfd, buf, strlen(buf)); 
		len = read(sfd, buf, sizeof(buf));
        //服务端的RST是什么时候到达，如果是在read返回前到达，那么read将返回错误
        //如果是在read之后到达，那么read将返回0，判断为对端已关闭
		if(len == 0){
			puts("peer close");
			break;
		}else if(len < 0){
             perror("read error: ");
}
		write(STDOUT_FILENO, buf, len);
	}
	//关闭链接
	close(sfd);
	return 0;
}

1 . 先启动服务端

2.然后执行./client命令，启动客户端，并在客户端输入hello，然后服务端回射HELLO，验证客户端和服务端之间通信正常
这里写图片描述

3.然后将服务端进程切换到后台执行，并找到子进程，通过kill命令将子进程杀死。
这里写图片描述

  当通过kill命令把服务端子进程终止后，父进程收到SIGCHLD信号后回收了子进程，并且子进程打开的所有套接字都被关闭，这将导致服务端子进程将发送了一个FIN，同时客户端响应一个ACK，这只是代表服务端到客户端的连接关闭了而已，也就是所谓的半关闭，进入了FIN_WAIT2状态。
这里写图片描述

  从tcpdump抓取到的数据包来看，服务端子进程确实发送了FIN，并接收到了客户端响应的ACK。


  对此，客户端并不做任何事情，但问题是客户端将阻塞在fgets调用处，等待从终端读取数据。此时我们在客户端的终端上输入world，因为此时只是半关闭，所以tcp允许这样做。

这里写图片描述

  当服务端子进程的tcp收到客户端的world时，于是就响应一个RST段（这是因为之前打开的套接字服务端子进程已经终止掉了，无法再接收数据了，此时服务端期望对端下一个发送FIN，而不是发送一个数据报文，所以才会以RST响应）。我们通过tcpdump查看发现，确实验证了这一点，重点关注最后4个报文。

这里写图片描述

  但是对于客户端来说，它并不知道这个RST，因为它执行的太快了，在调用了write后又立即调用了read，也就是说在收到对端发送的RST段之前，它所调用的read就已经返回了，所以read返回0得出对端已经关闭，于是打印peer closed，退出循环，执行 close(sockfd)。然后向对端发送 FIN 段，然后服务端以一个RST响应了客户端的FIN。


2. SIGPIPE信号

   继续前面所说的服务器进程终止的情况，从而又引发出了另一个问题：如果客户端忽略了read返回的错误，继续向服务端写入数据，这时又会发生什么情况呢？

  比如说客户端可能在读取任何数据之前，调用了两次write对服务端进行写操作，在第一次writen后，休眠1秒，保证第二次write写操作前收到RST报文。为了模拟这种情况，我们需要对客户端代码做以下的修改，同时注册SIGPIPE信号捕捉函数，具体示例代码如下：

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

#define SERV_IP "192.168.0.107"
#define SERV_PORT 10001

//捕捉SIGPIPE信号函数
void signal_handler(int signo){
        if(signo == SIGPIPE){
                puts("hello SIGPIPE");
        }
}

int main(void) {
        int sfd, nr , nw , ret;
        struct sockaddr_in serv_addr;
        char buf[BUFSIZ];
        sfd = socket(AF_INET, SOCK_STREAM, 0);
        bzero(&serv_addr, sizeof(serv_addr));                       
        serv_addr.sin_family = AF_INET;                         
        inet_pton(AF_INET, SERV_IP, &serv_addr.sin_addr.s_addr); 
        serv_addr.sin_port = htons(SERV_PORT);                      
        ret = connect(sfd, (struct sockaddr *)&serv_addr ,  sizeof(serv_addr));
        if(ret < 0){
                perror("connect error:");
                close(sfd);
                exit(0);
        }

        //注册SIGPIPE信号
        signal(SIGPIPE , signal_handler);

        //循环读写数据
        while (1) {
                fgets(buf, sizeof(buf), stdin);
                //把写操作分成两次
                nw = write(sfd, buf, strlen(buf));
                sleep(1);
                //休眠1秒，保证第二次调用writen收到RST，并捕获SIGPIPE信号
                nw = write(sfd, buf, strlen(buf));
                nr = read(sfd, buf, sizeof(buf));

                if(nr == 0){
                        puts("read by peer close");
                        break;
                }else if(nr < 0){
                        perror("read error: ");
                }
                write(STDOUT_FILENO, buf, nr);
        }
        //关闭链接
        close(sfd);
        return 0;
}

程序执行结果：

这里写图片描述

这里写图片描述

  那么根据上一篇服务器进程终止的情况，服务端发送的RST无论是在read前到达还是read后到达，如果客户端忽略了read返回的错误，再次循环调用write对服务端进行写操作。于是客户端进行了两次write操作，在第一次write操作后，sleep了1秒，而这1秒的时间已经足够RST段到达客户端，所以客户端第二次write时就会出现EPIPE错误。

   如果客户端调用write向一个已经收到RST的套接字进行写操作时，内核会向该进程发送一个SIGPIPE信号，以此终止该进程，并返回EPIPE错误。

song->_->
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
进程间通信之无名管道（pipe） 完整代码
01-24
2 SIGPIPE信号的处理 七种进程间通信方式： 一 无名管道（ pipe ） 二 有名管道（ fifo ） 三 共享内存 shared memory 四 信号 sinal 五 消息队列 message queue ） 六 信号量 semophore 七 套接字 socket ...
Linux多线程服务端编程：使用muduo C++网络库
08-17
2.3不要用读写锁和信号量. . . . . . . . . . . . . . . . .. . . . . . . . . . . 43 2.4封装MutexLock、MutexLockGuard、Condition. . . . . . . . . . . . . . 44 2.5线程安全的Singleton 实现.. . . . . . . . ....
golang使用linux共享内存及信号实现崩溃重启
小屋
06-12 1756
golang使用linux共享内存及信号实现崩溃重启 最近项目里有用到共享内存,来实现程序崩溃自启,具体做法就是建立一个守护进程,守护进程实时监测一片共享内存,发现有程序崩溃的时候往里写的数据是某个程序崩溃前写进去的,就把程序重新拉起来 第一步:拦截程序崩溃的信号 要实现程序意外崩溃的时候往共享内存里写东西,首先就要拦截那个让它崩溃的信号,自行处理,比如数组越界,往关闭的套接字里写数据,...
Linux系统进程间通信基础
qq_45698138的博客
06-08 175
①无名管道（PIPE）和有名管道（FIFO）②信号（signal）③system V-IPC 之共享内存④system V-IPC 之消息队列⑤system V-IPC 之信号量⑥套接字socket特点：无名管道是最简单的常用于一对一的亲缘进程间通信的方式有名管道存在于文件系统之中，提供写入原子性特征，信号是唯一一种异步通信方式共享内存的效率最高，但是要结合信号量等同步互斥机制一起使用消息队列提供一种带简单消息标识的通信方套接字是一种更为宽泛意义上的进程间通信方式——它允许进程间跨网络特点：1，没有名字，因
Linux操作系统学习笔记（十六）进程间通信之信号
ty的博客
08-30 589
一. 前言   众所周知，System V IPC进程间通信机制体系中有着多种多样的进程间通信方式，如管道和有名管道，消息队列，信号，共享内存和信号量，套接字。从本文开始我们就逐个剖析进程间通信的机制和底层原理，就从信号开始讲起吧。 二. 信号基本知识   信号是进程处理紧急情况所用的一种方式，它没有特别复杂的数据结构，就是用一个代号一样的数字。Linux 提供了几十种信号，分别代表不同的意义。我们可以通过kill -l命令查看信号。 # kill -l 1) SIGHUP 2) SIGIN
golang 非正常退出信号捕捉处理
石牌桥网管笔记
12-16 4622
最近用golang写一个P2P程序，发现在安卓(arm linux )环境下按ctrl+c退出程序，占用udp端口不会在程序退出后自动释放 而普通x86/x64 Linux和win 不会出现这种情况 查阅资料 可以通过捕捉信号处理。 os.Interrupt(即syscall.SIGINT， Ctrl+C 产生) os.Kill(即syscall.SIGKILL， 程序关闭产生，调试中还没...
实现动态库捕获异常信号并保存函数堆栈信息
chenzhjlf的专栏
05-14 673
signal traceback
【linux】kill命令信号总结
TomRen
06-17 2万+
kill 命令的详细总结，除了kill -9 还有很多
常见可能导致服务器莫名退出需要（SIG_IGN）的信号
W_J_F_的博客
07-14 928
在编写项目时可能会遇见连接或者进程莫名退出的情况，不会报错也很按找出原因，通过日志不断定位，最终发现与信号有关 一下列出我在项目中遇见过的常见需要改变默认处理动作的信号 可以通过 函数：kill(pid,0) 或 命令行：kill -0 pid 对进程进行检测，0不会发送任何信号，但是会进行错误检查，如果进程存在，命令返回0！ signal(SIGHUP, SIG_IGN);...
kill 命令信号全解
田振靓的博客
07-29 7996
$ kill -l 1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM 17) SIGCHLD 18) SIGC.
Linux信号列表
热门推荐
吾欲乘风
08-25 5万+
我们运行如下命令，可看到Linux支持的信号列表：$ kill -l1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1 11) SIGSEGV
对一个对端已经关闭的socket调用两次write, 第二次将会生成SIGPIPE信号, 该信号默认结束进程.zip
01-18
对一个对端已经关闭的socket调用两次write, 第二次将会生成SIGPIPE信号, 该信号默认结束进程.zip
linux gcc如何处理sigpipe导致的程序退出.zip
01-18
linux gcc如何处理sigpipe导致的程序退出.zip
linux信号量说明
12-10
1352) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-956) SIGRTMAX-8 57) SIGRTMAX-7 58) SIGRTMAX-6 59) SIGRTMAX-560) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2 63) SIGRTMAX-164)
18-用fork函数创建新进程
网络安全
09-05 8752
1. 程序和进程   简单来说，程序是一组存储在磁盘的机器语言指令集合（本质上是一个二进制文件），不占用cpu、内存等系统资源。   而进程是一个可执行程序的运行实例，说白了就是运行着的程序，每一个运行着的进程可以看做是一个独立的程序，会占用系统资源。 2. 感受进程   如果同一个程序多次运行，每次都在内存中创建出不同的进程，每个进程都有自己的代码空间和数据空间，且进程间彼此独立，...
3-listen函数（主动socket和被动socket）
网络安全
06-12 5624
1. 主动socket和被动socket   一般来说，使用socket函数创建的socket默认是主动socket，这意味着一个主动的socket可以调用connect跟一个被动socket建立一个连接，对主动socket来说，这叫主动打开。   被动socket是一个通过调用listen函数监听要发起连接的socket，当被动socket接受一个连接通常称为被动打开。   在大多数网络程...
21-非阻塞accept
网络安全
01-07 5572
1. 回忆accept函数 之前在10-在accept之前中止连接（连接异常）这一篇中已经讨论过在accept之前中止连接的情况了，不过从最终的结果来看，accept并没有返回错误，而是之后调用read读取已连接套接字时产生了错误。 另外，当一个已完成连接正等待被服务端accept时，select会把该连接的套接字作为读描述符并返回。这意味着之后的accept就不应该阻塞，但是会引发一个...
14-unlink函数和删除文件
网络安全
07-02 5474
  在阅读此篇之前，需要对linux下的硬链接和软链接非常熟悉，如果不熟悉的话可以参考先参考这篇文章：https://blog.csdn.net/q1007729991/article/details/53424961 1. unlink函数   对于硬链接来说，unlink 用来删除目录项，并把 inode 引用计数减 1，这两步也是一个原子过程。直到 inode 引用计数为 0，才会真正删...
6-改变文件偏移量—lseek函数
网络安全
06-24 5474
1. 文件偏移    通常调用read或write每读写一个字节，就会改变文件的读写位置。而在linux中同样也可以使用lseek函数来修改文件偏移量，即读写位置。    不知道大家是否还有印象没，其实标准C库的fseek函数和系统函数lseek比较类似，fseek函数也可以移动当前读写位置（或者叫偏移量），其实fseek就是对lseek系统函数封装后实现的，快速回忆一下之前学习的fseek函...
SIGPIPE是什么信号
最新发布
07-14
SIGPIPE是一个在进程中收到"管道破裂...通常情况下，进程会终止默认行为是终止进程。可以通过捕获SIGPIPE信号并自定义处理函数来改变其行为。这可以用来处理管道通信中的错误以及避免因为管道破裂而导致进程异常终止。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值