如何使用 C 模拟 bash 中的信号（Ctrl+\ 和 Ctrl+C）？

Question

我想模拟 bash 中的信号（ Ctrl + \和Ctrl + C ），但使用 C。

我想使用信号 function void (*signal(int sig, void (*func)(int)))(int);杀死一个子进程 .

我到目前为止：

#include <assert.h>
#include <signal.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

pid_t     cpid = 0;

void signal_handler(int sig) {
    // char parent_str[] = "this is ctrl + c in the parent prosess\n";
    char child_str[] = "this is ctrl + c in the child prosess\n";
    // signal(sig, signal_handler);
    if (sig == SIGINT) {
        write(STDOUT_FILENO, child_str, sizeof(child_str) - 1);
        kill(cpid, SIGINT);
    }
    else if (sig == SIGQUIT)
    {
        write(STDOUT_FILENO, "this is ctrl + \\ in the child prosess\n", sizeof("this is ctrl + \\ in the child prosess\n") - 1);
        kill(cpid, SIGQUIT);
    }
}

int main(int argc, char **argv) {
    pid_t pid, pgid;

    (void)argv;
    signal(SIGINT, signal_handler);
    signal(SIGQUIT, signal_handler);
    pid = fork();
    cpid = pid;
    if (pid == 0) {
        cpid = 1;
        while(1);
        exit(EXIT_SUCCESS);
    }
    wait (NULL);
    printf("pid = %d\ncpisd = %d", pid, cpid);
    while (1);
}

但是当我编译这段代码时，进程不会终止，为什么？

Answer 1

当你fork一个进程时，迄今为止发生的几乎所有事情都会在子进程中重复 - 也就是说，在fork成功返回的那一刻，子进程与其父进程具有几乎相同的环境。 虽然对此有一些例外（如fork手册页中所述），但仍保留了信号处理程序。

当您键入^C时，终端中发生的情况是SIGINT被发送到您的父进程和子进程。 这以相同的方式处理，因为信号处理 function 在父级和子级中是相同的，但由于cpid的值而具有不同的结果。

在父级中， cpid为0 ，因此kill具有以下效果：

如果 pid 等于 0，则将 sig 发送到调用进程的进程组中的每个进程。

因此父进程“转发”该信号给子进程，因为它属于父进程组。

子进程因此接收到两个信号； 一个直接来自终端，一个来自父进程。 使用相同的处理程序，但这次cpid为1 ，它调用kill并满足以下条件：

如果 pid 为正，则将信号 sig 发送到具有 pid 指定的 ID 的进程。

所以这调用

kill(1, SIGINT)

其中 PID 1 几乎可以肯定是init ，负责整个系统的根进程。 这可能是一件好事，这没有效果，因为另一种结果可能是您的系统关闭。

最后，当每个进程沿着这条链推送信号时，实际上什么都没有发生，但这就是为什么我们会看到三行文本：一行来自父级，两行来自子级。

---

我们希望在父子节点中以不同的方式处理我们的信号，因此最好使用两个不同的处理程序。

由于从终端发送信号导致信号重叠，如果我们只想直接接受来自父进程的信号，我们将不得不确定谁在子进程中发送信号。 signal处理程序无法提供这种详细程度，因此我们需要sigaction处理程序。

这是一个在父子之间拆分信号处理的小示例。 在子进程中，我们使用SA_SIGINFO标志设置struct sigaction ，这表明我们要使用sa_sigaction处理程序。 我们使用getppid并将其与info->si_pid进行比较以确定信号是否直接来自父级。

#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/wait.h>

static pid_t child_id;

void sigparent(int sig) {
    const char msg[] = "The parent will kill the child.\n";

    switch (sig) {
    case SIGINT:
    case SIGQUIT:
        write(STDOUT_FILENO, msg, (sizeof msg) - 1);
        kill(child_id, SIGQUIT);
        break;
    default:
        break;
    }
}

void sigchild(int sig, siginfo_t *info, void *ctx) {
    const char msg[] = "The child will now die.\n";

    if (getppid() == info->si_pid)
        switch (sig) {
        case SIGINT:
        case SIGQUIT:
            write(STDOUT_FILENO, msg, (sizeof msg) - 1);
            _exit(EXIT_SUCCESS);
            break;
        default:
            break;
        }
}

void parent(void) {
    signal(SIGINT, sigparent);
    signal(SIGQUIT, sigparent);

    puts("Parent will wait...");
    waitpid(child_id, NULL, WUNTRACED);
    puts("Parent is done waiting.");
}

void child(void) {
    struct sigaction action = { 0 };

    sigemptyset(&action.sa_mask);
    action.sa_flags = (SA_SIGINFO);
    action.sa_sigaction = sigchild;

    sigaction(SIGINT, &action, NULL);
    sigaction(SIGQUIT, &action, NULL);

    while (1) {
        puts("Child is sleeping...");
        sleep(2);
    }
}

int main(void) {
    if ((child_id = fork()))
        parent();
    else
        child();
}

Answer 2

该过程不会杀死，为什么？

我认为令人困惑的部分是子进程也将使用相同的signal_handler function 作为其父进程——即使在signal()之后调用了fork() ) 。 如果您希望子进程在从父进程接收到该信号时死亡，则处理程序应测试这是否是子进程（子进程的cpid设置为 1）并告诉它显式退出。

这是一个例子：

void signal_handler(int sig) {
    // char parent_str[] = "this is ctrl + c in the parent prosess\n";
    char child_str[] = "this is ctrl + c in the child prosess\n";
    // signal(sig, signal_handler);
    if (sig == SIGINT) {
        write(STDOUT_FILENO, child_str, sizeof(child_str) - 1); 
        if(cpid != 1) {
            kill(cpid, SIGINT);
        } else {
            exit(1);
        }   
    }   
    else if (sig == SIGQUIT)
    {   
        write(STDOUT_FILENO, "this is ctrl + \\ in the child prosess\n", sizeof("this is ctrl + \\ in the child prosess\n") - 1); 
        if(cpid != 1) {
            kill(cpid, SIGQUIT);
        } else {
            exit(1);
        }   
    }   
}