Question

我现在的代码现在向stdout发送一个提示符，然后从stdin读取一行。在任何时候接收SIGINT都会中断执行并退出程序。我不确定我应该捕获SIGINT的哪个位置，并且我知道在使用当前代码接收到信号时我无法启动新提示。有没有一种正确的方法来实现它（最终目标是它像大多数shell一样（SIGINT取消当前提示并启动一个新的））？

此代码将在Linux上运行，但平台越少越好。

get_line从stdin读取一行到缓冲区并生成一个char []，它被分配给行。
split_args占用一行并将其转换为char []数组，在空格上分割 is_command_valid确定用户是否键入了已知的内部命令。外部程序无法执行。

static int run_interactive(char *user)
{
    int done = 0;

    do
    {
        char *line, **args;
        int (*fn)(char *, char **);

        fprintf(stderr, "gitorium (%s)> ", user);
        get_line(&line);

        if (line[0] == '\0')
        {
            free(line);
            break;
        }

        split_args(&args, line);

        if (!strcmp(args[0], "quit") || !strcmp(args[0], "exit") ||
            !strcmp(args[0], "logout") || !strcmp(args[0], "bye"))
            done = 1;
        else if (NULL == args[0] ||
            (!strcmp("help", args[0]) && NULL == args[1]))
            interactive_help();
        else if ((fn = is_command_valid(args)) != NULL)
            (*fn)(user, args);
        else
            error("The command does not exist.");

        free(line);
        free(args);
    }
    while (!done);

    return 0;
}

以下是两个最重要的辅助函数

static int split_args(char ***args, char *str)
{
    char **res = NULL, *p = strtok(str, " ");
    int n_spaces = 0, i = 0;

    while (p)
    {
        res = realloc(res, sizeof (char*) * ++n_spaces);

        if (res == NULL)
            return GITORIUM_MEM_ALLOC;

        res[n_spaces-1] = p;
        i++;
        p = strtok(NULL, " ");
    }

    res = realloc(res, sizeof(char*) * (n_spaces+1));
    if (res == NULL)
        return GITORIUM_MEM_ALLOC;

    res[n_spaces] = 0;
    *args = res;

    return i;
}

static int get_line(char **linep)
{
    char *line = malloc(LINE_BUFFER_SIZE);
    int len = LINE_BUFFER_SIZE, c;
    *linep = line;

    if(line == NULL)
        return GITORIUM_MEM_ALLOC;

    for(;;)
    {
        c = fgetc(stdin);
        if(c == EOF || c == '\n')
            break;

        if(--len == 0)
        {
            char *linen = realloc(*linep, sizeof *linep + LINE_BUFFER_SIZE);
            if(linen == NULL)
                return GITORIUM_MEM_ALLOC;

            len = LINE_BUFFER_SIZE;
            line = linen + (line - *linep);
            *linep = linen;
        }

        *line++ = c;
    }

    *line = 0;
    return 0;
}

Answer 1

如果我理解正确，你想知道如何处理信号以及一旦你得到信号该怎么做。

建立信号处理程序的方式是使用sigaction()。您没有说明您所使用的平台，所以我假设Linux，尽管sigaction()由POSIX标准定义，并且应该可以在大多数其他平台上使用。

有多种方法可以做到这一点。一种方法是建立一个信号处理程序，它只是将一个全局变量设置为1，表示信号被捕获。然后在getline()函数中建立检查以查看是否已捕获SIGINT，如果是，则返回NULL并允许run_interactive()再次运行。

以下是捕捉信号的方法：

#include <signal.h>

static int sigint_caught = 0;

static void sigint_handler(int sig) {
  sigint_caught = 1;
}

struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0; // or SA_RESTART if you want to automatically restart system calls interrupted by the signal
sa.sa_handler = sigint_handler;

if (sigaction(SIGINT, &sa, NULL) == -1) {
  printf("could not establish handler\n");
  exit(-1); // or something
}

然后可能在getline()中，在无限循环中，您将建立检查以查看是否已捕获SIGINT：

for (;;) {
  if (sigint_caught) {
    return NULL;
  }

  // ...

然后在run_interactive()来电中，您可以使用检查返回值以查看是否发现了SIGINT：

// ... get_line(&line); if (line == NULL && sigint_caught) { sigint_caught = 0; // allow it to be caught again free(line); continue; // or something; basically go to the next iteration of this loop } else if (line[0] == '\0') { free(line); break; } else { // rest of code

没有测试它所以我不能保证它会工作，因为你的问题相当广泛（不得不查看更多的代码等），但希望它能给你足够的想法你可以在你的情况下做你。这可能是一个非常天真的解决方案，但它可能会满足您的需求。对于更强大的东西，可能会查看bash或zsh等流行shell的源代码。

例如，可能发生的一件事是fgetc()可能会阻塞，因为stdin中没有新数据，并且可能是在发送信号时。 fgetc()将被中断，errno将EINTR，因此您可以在getline()中添加对此的检查：

c = fgetc(stdin); // make sure to #include <errno.h> if (errno == EINTR && sigint_caught) return NULL;

只有在不将sa_flags设置为SA_RESTART时才会发生这种情况。如果这样做，那么fgetc应该会自动重启并继续阻止，直到收到新的输入，这可能是您想要的，也可能不是。

如何设计信号安全的shell解释器

1 个答案: