在 c 中捕获 ctrl-c 并继续执行答案

【问题标题】：Catching ctrl-c in c and continuing execution在 c 中捕获 ctrl-c 并继续执行
【发布时间】：2019-03-12 14:54:37
【问题描述】：

我正在用c写一个简单的shell程序，需要处理ctrl-c。

如果前台进程正在运行，我需要终止它并继续主 shell 循环。如果没有，我只需要打印信号已被捕获。

以下是我的代码，基于此线程：Catch Ctrl-C in C

void inthandler(int dummy){
    signal(dummy, SIG_IGN);
    printf("ctrl-c caught\n");
}

我在进入主循环之前调用了 signal()

int main(int argc, char*argv[]){
    signal(SIGINT, inthandler)
    while(true){
        //main loop
    }
}

到目前为止，我可以拦截 ctrl-c 并打印我想要的消息，但任何进一步的输入都会导致段错误。

进入 inthandler 后如何返回执行我的主循环？

【问题讨论】：

永远不要在信号处理程序中调用任何 IO 例程。您可以设置一个标志，然后在主循环中检查该标志。
您在问题中链接到的线程是实现处理程序的正确方法（Dirk 的答案在顶部）。这就是 jwdonahue 所说的。不要做stdio 的东西（例如printf inside 信号处理程序（或malloc 等人））
回答你最后一个问题，你没有因为它发生在你身上。在您的程序处理完一个信号后，它会在它停止的地方恢复执行。
阅读所有您链接到的问题中的答案和cmets，那里描述了很多警告和陷阱。

标签： c shell signals

【解决方案1】：

使用sigaction()，而不是signal()，除非将处置设置为SIG_DFL 或SIG_IGN。虽然 signal() 是在 C 中指定的，而 sigaction() POSIX.1 中指定了，但无论如何您都需要 POSIX 来对信号做任何有意义的事情。
仅在信号处理程序中使用 async-signal safe 函数。您可以使用 POSIX 低级 I/O（read()、write()）而不是标准 I/O（如 <stdio.h> 中声明的）到底层文件描述符。但是，您确实需要避免对使用相同底层描述符的流使用标准 I/O，否则输出可能会由于标准 I/O 中的缓冲而出现乱码。
如果您将信号处理程序中的信号处置更改为忽略，则只会捕获（每种捕获类型的）第一个信号。

考虑以下示例程序：

#define _POSIX_C_SOURCE 200809L
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>

/* Helper function: Write a string to a descriptor, keeping errno unchanged. 
   Returns 0 if success, errno error code if an error occurs. */
static inline int  wrs(const int fd, const char *s)
{
    /* Invalid descriptor? */
    if (fd == -1)
        return EBADF;

    /* Anything to actually write? */
    if (s && *s) {
        const int   saved_errno = errno;
        const char *z = s;
        ssize_t     n;
        int         err = 0;

        /* Use a loop to find end of s, since strlen() is not async-signal safe. */
        while (*z)
            z++;

        /* Write the string, ignoring EINTR, and allowing short writes. */
        while (s < z) {
            n = write(fd, s, (size_t)(z - s));
            if (n > 0)
                s += n;
            else
            if (n != -1) {
                /* This should never occur, so it's an I/O error. */
                err = EIO;
                break;
            } else
            if (errno != EINTR) {
                /* An actual error occurred. */
                err = errno;
                break;
            }
        }

        errno = saved_errno;
        return err;

    } else {
        /* Nothing to write. NULL s is silently ignored without error. */
        return 0;
    }
}

/* Signal handler. Just outputs a line to standard error. */
void catcher(int signum)
{
    switch (signum) {
    case SIGINT:
        wrs(STDERR_FILENO, "Caught INT signal.\n");
        return;
    default:
        wrs(STDERR_FILENO, "Caught a signal.\n");
        return;
    }
}

/* Helper function to install the signal handler. */
int install_catcher(const int signum)
{
    struct sigaction  act;

    memset(&act, 0, sizeof act);
    sigemptyset(&act.sa_mask);

    act.sa_handler = catcher;
    act.sa_flags = SA_RESTART;  /* Do not interrupt "slow" functions */
    if (sigaction(signum, &act, NULL) == -1)
        return -1;  /* Failed */

    return 0;
}

/* Helper function to remove embedded NUL characters and CRs and LFs,
   as well as leading and trailing whitespace.  Assumes data[size] is writable. */
size_t clean(char *data, size_t size)
{
    char *const  end = data + size;
    char        *src = data;
    char        *dst = data;

    /* Skip leading ASCII whitespace. */
    while (src < end && (*src == '\t' || *src == '\n' || *src == '\v' ||
                         *src == '\f' || *src == '\r' || *src == ' '))
        src++;

    /* Copy all but NUL, CR, and LF chars. */
    while (src < end)
        if (*src != '\0' && *src != '\n' && *src != '\r')
            *(dst++) = *(src++);
        else
            src++;

    /* Backtrack trailing ASCII whitespace. */
    while (dst > data && (dst[-1] == '\t' || dst[-1] == '\n' || dst[-1] == '\v' ||
                          dst[-1] == '\n' || dst[-1] == '\r' || dst[-1] == ' '))
        dst--;

    /* Mark end of string. */
    *dst = '\0';

    /* Return new length. */
    return (size_t)(dst - data);
}


int main(void)
{
    char   *line = NULL;
    size_t  size = 0;
    ssize_t len;

    if (install_catcher(SIGINT)) {
        fprintf(stderr, "Cannot install signal handler: %s.\n", strerror(errno));
        return EXIT_FAILURE;
    }

    printf("Type Ctrl+D, 'exit', or 'quit' on an empty line to exit.\n");

    while (1) {
        len = getline(&line, &size, stdin);
        if (len < 0)
            break;

        clean(line, len);
        printf("Read %zd chars: %s\n", len, line);

        if (!strcmp(line, "exit") || !strcmp(line, "quit"))
            break;
    }

    return EXIT_SUCCESS;
}

在大多数 POSIXy 系统上，伪终端中的 Ctrl+C 也会清除当前行缓冲区，因此在交互式提供行的中间按下它会丢弃该行（未发送到进程的数据）。

请注意，当您按下 Ctrl+C 时，您通常在伪终端中看到的 ^C 是终端功能，由 ECHO termios 设置控制。该设置还控制一般按键是否在终端上回显。

如果将signal(SIGINT, SIG_IGN) 添加到 catcher() 中，就在 wrs() 行之后，只有第一个 Ctrl+C 会打印“Caught INT signal”；后面的任何 Ctrl+C 都会丢弃不完整的行。

所以，如果你输入，比如说，FooCtrl+CBarEnter，你会看到 p>

Foo^CCaught INT signal.
Bar
Read 4 chars: Bar

或

Foo^CBar
Read 4 chars: Bar

取决于由 Ctrl+C 生成的 INT 信号是被处理程序捕获还是被忽略。

要退出，请在行首输入exit 或quit，或紧跟在Ctrl+C之后。

这里没有分段错误，所以如果你的代码确实产生了一个，那一定是由于你的程序中的错误。

进入 inthandler 后如何返回执行我的主循环？

信号传递中断在信号处理程序执行期间的执行；然后，被中断的代码继续执行。因此，该问题的严格正确答案是从信号处理程序返回。

如果安装信号处理程序时设置了SA_RESTART 标志，那么被中断的代码应该继续执行，就好像什么都没发生一样。如果安装的信号处理程序没有该标志，则中断“慢”系统调用可能会返回 EINTR 错误。

errno 在信号处理程序中必须保持不变的原因——这是一个很多很多程序员忽略的错误——是如果信号处理程序中的操作更改 errno，并且信号处理程序在之后立即被调用系统或 C 库调用失败并出现错误代码，代码看到的 errno 将是错误的！诚然，这是一种罕见的情况（对于每个系统或 C 库调用，这种情况发生的时间窗口很小），但这是一个可能发生的真正错误。当它真的发生时，就是那种让开发人员扯掉头发、赤身裸体地跑来跑去的黑森虫，而且通常比现在更疯狂。

另请注意，stderr 仅用于安装信号处理程序失败的代码路径中，因为我想确保不要将 I/O 和 POSIX 低级 I/O 混合为标准错误。

【讨论】：