用C编写命令行shell；第一次尝试使用 ncurses/C

Question

我正在开发一个类项目，其中我必须编写一个具有以下要求的命令行 shell：

• shell 必须能够读取缓冲的输入
• 缓冲区应为 64 个字符
• 应处理错误条件
  • 超出缓冲区大小
  • 中断（当信号到达时） - 请参阅 read() 的手册页
  • 无效输入（无法解析的字符、空行等）
  • 可能遇到的任何其他错误。
• Shell 必须具有至少 20 项的历史记录，并且历史记录的大小不能是静态的。当历史缓冲区已满时，将删除最旧的项目并添加最新的项目。
• 程序应该能够在前台或后台运行。 （使用 &）
• Ctrl-D 将退出 shell
• Ctrl-C 将打印完整的历史记录
• 命令“history”也将打印完整的历史记录。最新的项目将位于列表的底部。
• 所有其他信号将被捕获并在 shell 中显示给用户
• 程序将使用 read() 命令读取输入，除非支持箭头键

我选择实现历史循环的箭头键，所以我使用 ncurses用于输入，而不是 read()。我认为我使用 strtok() 解析输入，使用 fork() 和 execvp() 运行进程做得很好，但我没有正确实现 ncurses。到目前为止，我所做的就是初始化一个新屏幕，显示提示，然后在按下任何键时出现段错误。不好。

我想问题一定出在我的设计上。我不太了解 ncurses。我应该在这个项目中使用什么类型的数据结构？我应该如何处理 ncurses 设置、拆卸以及其间的所有事情？窗口和屏幕有什么关系？我应该使用一个可全局访问的窗口/屏幕吗？另外，我一直在尝试使用 char* 作为输入缓冲区，使用 char** 作为命令历史记录，但我没有 C 经验，所以尽管阅读了 malloc、calloc 和 realloc，但我还是不确定在缓冲区和历史记录中存储命令的最佳方式。关于管理这些字符数组有什么建议吗？

tl;dr：如何正确使用 ncurses 来制作命令行 shell，以及如何使用 C 处理命令内存管理？

我意识到这是一个相当沉重的问题。 :(

编辑：我已经看到 http: //www.gnu.org/software/libc/manual/html_node/Implementing-a-Shell.html 和 http://www.linuxinfor.com/english/NCURSES-Programming/ 但 ncurses 文档实际上有太多开销，我只是想使用它识别箭头键的功能。

Answer 1

下面是一些示例代码：

1. 执行动态内存分配。

2. 以非阻塞模式从控制台读取。

3. 使用 VT100 代码将帧缓冲区打印到控制台。

它使用 GCC 在 Linux 上编译，没有警告或错误。它远非没有错误，但它应该给您一些关于可能性的想法。编译并运行它，按[向上]和[向下]将打印消息，输入字符并按[输入]将“执行”命令。

#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <termios.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

/** VT100 command to clear the screen. Use puts(VT100_CLEAR_SCREEN) to clear
 *  the screen. */
#define VT100_CLEAR_SCREEN "\033[2J"

/** VT100 command to reset the cursor to the top left hand corner of the
 *  screen. */
#define VT100_CURSOR_TO_ORIGIN "\033[H"

struct frame_s
{
    int x;
    int y;
    char *data;
};

static int draw_frame(struct frame_s *frame)
{
    int row;
    char *data;
    int attrib;

    puts(VT100_CLEAR_SCREEN);
    puts(VT100_CURSOR_TO_ORIGIN);

    for (row = 0, data = frame->data; row  < frame->y; row++, data += frame->x)
    {
        /*  0 for normal, 1 for bold, 7 for reverse. */
        attrib = 0;

        /*  The VT100 commands to move the cursor, set the attribute, and the
         *  actual frame line. */
        fprintf(stdout, "\033[%d;%dH\033[0m\033[%dm%.*s", row + 1, 0, attrib, frame->x, data);
        fflush(stdout);
    }

    return (0);
}

int main(void)
{
    const struct timespec timeout = { .tv_sec = 1, .tv_nsec = 0 };
    struct frame_s frame;
    struct termios tty_old;
    struct termios tty_new;
    unsigned char line[128];
    unsigned int count = 0;
    int ret;
    struct pollfd fds[1];
    sigset_t sigmask;
    struct tm *tp;
    time_t current_time;

    /*  Set up a little frame. */
    frame.x = 80;
    frame.y = 5;
    frame.data = malloc(frame.x * frame.y);

    if (frame.data == NULL)
    {
        fprintf(stderr, "No memory\n");
        exit (1);
    }

    memset(frame.data, ' ', frame.x * frame.y);

    /*  Get the terminal state. */
    tcgetattr(STDIN_FILENO, &tty_old);
    tty_new = tty_old;

    /*  Turn off "cooked" mode (line buffering) and set minimum characters
     *  to zero (i.e. non-blocking). */
    tty_new.c_lflag &= ~ICANON;
    tty_new.c_cc[VMIN] = 0;

    /*  Set the terminal attributes. */
    tcsetattr(STDIN_FILENO, TCSANOW, &tty_new);

    /*  Un-mask all signals while in ppoll() so any signal will cause
     *  ppoll() to return prematurely. */
    sigemptyset(&sigmask);

    fds[0].events = POLLIN;
    fds[0].fd = STDIN_FILENO;

    /*  Loop forever waiting for key presses. Update the output on every key
     *  press and every 1.0s (when ppoll() times out). */
    do
    {
        fds[0].revents = 0;
        ret = ppoll(fds, sizeof(fds) / sizeof(struct pollfd), &timeout, &sigmask);

        if (fds[0].revents & POLLIN)
        {
            ret = read(STDIN_FILENO, &line[count], sizeof(line) - count);

            if (ret > 0)
            {
                line[count + ret] = '\0';

                if (strcmp(&line[count], "\033[A") == 0)
                {
                    snprintf(frame.data, frame.x, "up");
                    count = 0;
                }
                else if (strcmp(&line[count], "\033[B") == 0)
                {
                    snprintf(frame.data, frame.x, "down");
                    count = 0;
                }
                else if (line[count] == 127) // backspace
                {
                    if (count != 0) { count -= ret;}
                }
                else if (line[count] == '\n')
                {
                    snprintf(frame.data, frame.x, "entered: %s", line);
                    count = 0;
                }
                else
                {
                    count += ret;
                }
            }
        }

        /*  Print the current time to the output buffer. */
        current_time = time(NULL);
        tp = localtime(¤t_time);
        strftime(&frame.data[1 * frame.x], frame.x, "%Y/%m/%d %H:%M:%S", tp);

        /*  Print the command line. */
        line[count] = '\0';
        snprintf(&frame.data[(frame.y - 1) * frame.x], frame.x, "$ %s", line);

        draw_frame(&frame);
    }
    while (1);

    /*  Restore terminal and free resources. */
    tcsetattr(STDIN_FILENO, TCSANOW, &tty_old);
    free(frame.data);

    return (0);
}

Answer 2

如果您的输入缓冲区定义为 64 个字符，那么我建议使用 char 数组而不是 char*。像 char input_buffer[65]; 这样的东西应该可以满足您的目的（为尾随的 '\0' 添加一个额外的字符）。

就命令历史记录而言，您可以使用二维数组。像 char command_history[20][65]; 这样的东西应该可以让您存储 20 个旧命令，每个命令有 64 个字符。

静态分配这些缓冲区应该会让事情变得更容易，因为您不必担心 malloc 和朋友。

如果没有看到你的代码，很难给你太多具体的建议。我有一种感觉，您正在犯与初次学习 C 的人所犯的常见错误相同类型的错误。您能否发布给您带来问题的代码部分，以便我们可以更多地了解您在做什么？

发布提供的代码后进行更新：

我看到的一个问题是函数 takeInput 没有 return 语句。当您在主函数中使用 input = takeInput(); 时，input 的值并未设置为您认为的值。它可能不是一个有效的指针，这会导致您的 input[j] 行出现段错误。

您对 cmdHistory 的使用也需要重新审视。您可以使用 cmdHistory = (char**)calloc(21,sizeof(int)); 来分配它，这样您就有足够的空间来存储 21 个整数。在函数 printHistory 中，您将 cmdHistory 的元素传递给 printw，就好像它们是字符串一样（它们只是整数）。这绝对不是在做你想做的事。相反，cmdHistory 的分配逻辑需要看起来更像您的解除分配逻辑（向后除外）。分配一个 char** 数组，然后迭代该数组，将每个指针分配给新分配的缓冲区。就像数组中的每个元素都有一个 free 语句，加上整个数组有一个 free 语句一样，您也应该有一个 malloc每个元素加上一个 malloc 作为整个数组。

即使您无法使用静态分配的堆栈，也请尝试使用静态分配的堆栈来编写程序。这将使您解决关键检测逻辑等问题，而不必担心程序的动态内存部分。一旦其余部分正常工作，返回并交换静态内存以进行动态内存分配。这样，您一次只需调试一点点。

Answer 3

你看过 Readline 图书馆吗？它非常适合在您的项目中使用。

http://cnswww.cns.cwru.edu/php/chet/readline /rltop.html