Tinyshell: 一个简易的shell命令解释器

这是自己最近学习Linux系统编程之后写的一个练手的小程序，能很好地复习系统编程中的进程管理、信号、管道、文件等内容。

通过回顾写的过程中遇到的问题的形式记录程序的关键点，最后给出完整程序代码。

0. Tinyshell的功能

这个简易的shell解释器可以解析磁盘命令，支持管道和输入输出重定向，内置命令只实现了exit，可以判定后台执行命令（&），但未实现bg功能（后台命令直接返回）。

 

1. shell是如何运行程序的

基本的模式就是主进程从键盘获取命令、解析命令，并fork出子进程执行相应的命令，最后主进程在子进程结束后回收（避免僵尸进程）。

这里执行命令可以采用exec家族中的execvp

int execvp(const char *file, char *constargv[]); 

两个参数分别传递程序名（如ls）和命令行参数（如 -l）即可。

 

2. 怎么解析命令？

由于命令行解析要实现管道功能和I/O重定向功能，所以解析命令也稍微有些复杂。

首先用cmdline读取完整的一行命令；

avline解析命令，去除空格，不同字符串之间以\0间隔。

定义一个COMMAND数据结构，包含一个字符串指针数组和infd，outfd两个文件描述符变量。

typedef struct command
{
char *args[MAXARG+1];    /* 解析出的命令参数列表 */
int infd;
int outfd;
} COMMAND;

每个COMMAND存储一个指令，其中args中的每个指针指向解析好的命令行参数字符串，infd，outfd存这个命令的输入输出对应的文件描述符。

COMMAND之间以< > |符号间隔，每个COMMAND中空格间隔出命令和不同的参数。大致结构如下图所示：（注：命令行处理方法和图片均学习自[2]）

                                                                      

3. 输入输出重定向怎么处理？

理解I/O重定向首先要理解最低可用文件描述符的概念。即每个进程都有其打开的一组文件，这些打开的文件被保持在一个数组中，文件描述符即为某文件在此数组中的索引。

所以当打开文件时，为文件安排的总是此数组中最低可用位置的索引。

同时stdin, stdout, stderr分别对应文件描述符0,1,2被打开。

文件描述符集通过exec调用传递，不会被改变。

所以shell可以通过fork产生子进程与子进程调用exec之间的时间间隔来重定向标准输入输出到文件。

利用的函数是dup / dup2

#include <unistd.h>
int dup(int oldfd);
int dup2(int oldfd, int newfd)

以输入重定向为例。 open(file)  -> close(0) -> dup(fd) -> close(fd)

open(file)打开将要重定向的文件，close(0)使得文件描述符0空闲，dup(fd)对fd进行复制，利用最低文件描述符0，此时该文件与文件描述符0连接在一起。

close(fd)来关闭文件的原始连接，只留下文件描述符0的连接。 或直接利用dp2将文件描述符pld复制到文件描述符new（open -> dup2 -> close）

同时利用append变量记录输出重定向是否是追加模式（“>>”）来决定打开文件的方式。

 

4. 管道怎么处理？

管道就是利用linux的管道创建函数并将管道的读写端分别绑定即可。

#include <unistd.h>
int pipe(int pipefd[2]);

pipefd[0]为管道读端，pipefd[1]为管道写端。

前后进程利用管道，采用如下逻辑：(以ls | wc为例)

前一个进程（ls） : close(p[0]) -> dup2(p[1], 1) -> close(p[1]) -> exec（ls）

后一个进程 （wc）：close(p[1]) -> dup(p[0], 0) -> close(p[0])  -> exec（wc）

注意，有N个COMMAND意味着要建立N-1个管道，所以可以用变量cmd_count记录命令个数。

    int fds[2];
for (i=0; i<cmd_count; ++i)
    {
/* 如果不是最后一条命令，则需要创建管道 */
if (i<cmd_count-1)
        {
            pipe(fds);
            cmd[i].outfd = fds[1];
            cmd[i+1].infd = fds[0];
        }

        forkexec(i);

if ((fd = cmd[i].infd) != 0)
            close(fd);

if ((fd = cmd[i].outfd) != 1)
            close(fd);
    }  

//forkexec中相关代码
if (cmd[i].infd != 0)
        {
            close(0);
            dup(cmd[i].infd);
        }
if (cmd[i].outfd != 1)
        {
            close(1);
            dup(cmd[i].outfd);
        }

int j;
for (j=3; j<1024; ++j)
            close(j);                

 

5.信号处理

分析整个流程中不同阶段的信号处理问题。

5.1 首先是shell主循环运行阶段，显然shell是不会被Ctrl + C停止的，所以初始化要忽略SIG_INT，SIGQUIT

5.2 当前台运行其他程序时，是可以用Ctrl + C来终止程序运行的，所以这时要恢复SIG_INT, SIGQUIT。

但注意Ctrl + C会导致内核向当前进程组的所有进程发送SIGINT信号。所以当fork出子进程处理前台命令时，应该让第一个简单命令作为进程组的组长。

这样接收到信号时，不会对shell进程产生影响。

设置进程组采用setpgid函数。setpgid(0,0)表示用当前进程的PID作为进程组ID。

#include <unistd.h>
int setpgid(pid_t pid, pid_t pgid);

5.3 后台运行程序，不会调用wait等待子进程退出，所以采用linux下特有的处理方式，忽略SIGCHLD，避免僵尸进程（在linux下交给init处理）

但在前台运行时需要再把SIGCHLD回复，显示等待子进程退出。

if (backgnd == 1)
    signal(SIGCHLD, SIG_IGN);
else
    signal(SIGCHLD, SIG_DFL);

5.4 前台任务如何回收子进程？ 在看到的参考中有的方案提到while循环只到回收到最后一个子进程为止。

即

while (wait(NULL) != lastpid)
    ;

但此方法应该有bug，fork出的子进程的顺序与子进程结束的顺序不一定相同，所以还是采用计数的方式，等待所以子进程被回收。

int cnt = 0;
while (wait(NULL) != -1 && cnt != cmd_count) {
    cnt++;
}

 

6.其他开始没注意到的小bug和补充

6.1 cmd_count == 0时，不执行任何操作，直接返回。不加这一句判断会出错。

6.2 因为没有实现bg功能，所以后台作业将第一条简单命令的infd重定向至/dev/null， 当第一条命令试图从标准输入获取数据的时候立即返回EOF。

6.3 内置命令只实现了exit退出。

 

7. 还有什么可以优化？

7.1 这里主进程中采用的是阻塞等待回收子进程的策略，一个更好的方案应该是利用SIGCHLD信号来处理。但这里便存在很多容易出错的地方。

比如子进程可能结束了，父进程还没有获得执行的机会，父进程再执行后再也收不到SIGCHLD信号。

所以需要通过显示的阻塞SIGCHLD信号来对其进行同步（利用sigprocmask函数）

其次，信号的接收是不排队的，所以对于同时到来的子进程结束信号，一些信号可能被丢弃。所以一个未处理的信号表明至少一个信号到达了。要小心处理。

关于这部分内容，可以参考CSAPP【3】。

7.2 可以考虑加入更多的内置命令，同时实现shell的流程控制和变量设置。

 

8. 完整代码

为了好在博客中上传，没有采取头文件形式，所有内容在一个.c文件中

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <linux/limits.h>
#include <fcntl.h>
#include <signal.h>
#include <string.h>


#define MAXLINE 1024    /* 输入行的最大长度 */
#define MAXARG 20        /* 每个简单命令的参数最多个数 */
#define PIPELINE 5        /* 一个管道行中简单命令的最多个数 */
#define MAXNAME 100        /* IO重定向文件名的最大长度 */


typedef struct command
{
    char *args[MAXARG+1];    /* 解析出的命令参数列表 */
    int infd;
    int outfd;
} COMMAND;

typedef void (*CMD_HANDLER)(void);  /*内置命令函数指针*/

typedef struct builtin_cmd
{
    char *name;
    CMD_HANDLER handler;

} BUILTIN_CMD;

void do_exit(void);
void do_cd(void);
void do_type(void);
BUILTIN_CMD builtins[] = 
{
    {"exit", do_exit},
    {"cd", do_cd},
    {"type", do_type},
    {NULL, NULL}
};

char cmdline[MAXLINE+1];        /*读到的一行命令*/
char avline[MAXLINE+1];            /*解析过添加好\0的命令*/
char *lineptr;
char *avptr;
char infile[MAXNAME+1];         /*输入重定向文件*/
char outfile[MAXNAME+1];        /*输出重定向文件*/
COMMAND cmd[PIPELINE];            /*解析好的命令数组*/

int cmd_count;            /*有多少个命令*/
int backgnd;           /*是否后台作业*/
int append;                /*输出重定向是否是append模式*/
int lastpid;            /*回收最后一个子进程的pid*/

#define ERR_EXIT(m) \
  do \
  { \
    perror(m); \
    exit(EXIT_FAILURE); \
  } \
  while (0)


void setup(void);
void init(void);
void shell_loop(void);
int read_command(void);
int parse_command(void);
int execute_command(void);
void forkexec(int i);
int check(const char *str);
int execute_disk_command(void);
int builtin(void);
void get_command(int i);
void getname(char *name);


int main()
{
    /* 安装信号 */
    setup();
    /* 进入shell循环 */
    shell_loop();
    return 0;
}


void sigint_handler(int sig)
{
    printf("\n[minishell]$ ");
    fflush(stdout);
}


void setup(void)
{
    signal(SIGINT, sigint_handler);
    signal(SIGQUIT, SIG_IGN);
}

void init(void)
{
    memset(cmd, 0, sizeof(cmd));
    int i;
    for (i=0; i<PIPELINE; ++i)
    {
        cmd[i].infd = 0;
        cmd[i].outfd = 1;
    }
    memset(cmdline, 0, sizeof(cmdline));
    memset(avline, 0, sizeof(avline));
    lineptr = cmdline;
    avptr = avline;
    memset(infile, 0, sizeof(infile));
    memset(outfile, 0, sizeof(outfile));
    cmd_count = 0;
    backgnd = 0;
    append = 0;
    lastpid = 0;

    printf("[minishell]$ ");
        fflush(stdout);
}


/**主循环**/
void shell_loop(void)
{
    while (1)
    {
        /* 初始化环境 */
        init();
        /* 获取命令 */
        if (read_command() == -1)
            break;
        /* 解析命令 */
        parse_command();
        /*print_command();*/
        /* 执行命令 */
        execute_command();
    }
    
    printf("\nexit\n");
}


/*
 * 读取命令
 * 成功返回0，失败或者读取到文件结束符(EOF)返回-1
 */
int read_command(void)
{
    /* 按行读取命令，cmdline中包含\n字符 */
    if (fgets(cmdline, MAXLINE, stdin) == NULL)
        return -1;
    return 0;
}

/*
 * 解析命令
 * 成功返回解析到的命令个数，失败返回-1
 */
int parse_command(void)
{
    /* cat < test.txt | grep -n public > test2.txt & */
    if (check("\n"))
        return 0;

    /* 判断是否内部命令并执行它 */
    if (builtin())
        return 0;


    /* 1、解析第一条简单命令 */
    get_command(0);
    /* 2、判定是否有输入重定向符 */
    if (check("<"))
        getname(infile);
    /* 3、判定是否有管道 */
    int i;
    for (i=1; i<PIPELINE; ++i)
    {
        if (check("|"))
            get_command(i);
        else
            break;
    }
    /* 4、判定是否有输出重定向符 */
    if (check(">"))
    {
        if (check(">"))
            append = 1;
        getname(outfile);
    }
    /* 5、判定是否后台作业 */
    if (check("&"))
        backgnd = 1;
    /* 6、判定命令结束‘\n’*/
    if (check("\n"))
    {
        cmd_count = i;
        return cmd_count;
    }
    else
    {
        fprintf(stderr, "Command line syntax error\n");
        return -1;
    }
}


/*
 * 解析简单命令至cmd[i]
 * 提取cmdline中的命令参数到avline数组中，
 * 并且将COMMAND结构中的args[]中的每个指针指向这些字符串
 */
void get_command(int i)
{
    /*   cat < test.txt | grep -n public > test2.txt & */

    int j = 0;
    int inword;
    while (*lineptr != '\0')
    {
        /* 去除空格 */
        while (*lineptr == ' ' || *lineptr == '\t')
            *lineptr++;

        /* 将第i条命令第j个参数指向avptr */
        cmd[i].args[j] = avptr;
        /* 提取参数 */
        while (*lineptr != '\0'
            && *lineptr != ' '
            && *lineptr != '\t'
            && *lineptr != '>'
            && *lineptr != '<'
            && *lineptr != '|'
            && *lineptr != '&'
            && *lineptr != '\n')
        {
                /* 参数提取至avptr指针所向的数组avline */
                *avptr++ = *lineptr++;
                inword = 1;
        }
        *avptr++ = '\0';
        switch (*lineptr)
        {
        case ' ':
        case '\t':
            inword = 0;
            j++;
            break;
        case '<':
        case '>':
        case '|':
        case '&':
        case '\n':
            if (inword == 0)
                cmd[i].args[j] = NULL;
            return;
        default: /* for '\0' */
            return;
        }
    }
}

/*
 * 将lineptr中的字符串与str进行匹配
 * 成功返回1，lineptr移过所匹配的字符串
 * 失败返回0，lineptr保持不变
 */
int check(const char *str)
{
    char *p;
    while (*lineptr == ' ' || *lineptr == '\t')
        lineptr++;

    p = lineptr;
    while (*str != '\0' && *str == *p)
    {
        str++;
        p++;
    }

    if (*str == '\0')
    {
        lineptr = p;    /* lineptr移过所匹配的字符串 */
        return 1;
    }

    /* lineptr保持不变 */
    return 0;
}

void getname(char *name)
{
    while (*lineptr == ' ' || *lineptr == '\t')
        lineptr++;

    while (*lineptr != '\0'
            && *lineptr != ' '
            && *lineptr != '\t'
            && *lineptr != '>'
            && *lineptr != '<'
            && *lineptr != '|'
            && *lineptr != '&'
            && *lineptr != '\n')
    {
            *name++ = *lineptr++;
    }
    *name = '\0';
}

/*
 * 执行命令
 * 成功返回0，失败返回-1
 */
int execute_command(void)
{
    execute_disk_command();
    return 0;
}

/*执行命令 fork + exec */
void forkexec(int i)
{
    pid_t pid;
    pid = fork();
    if (pid == -1)
        ERR_EXIT("fork");

    if (pid > 0)
    {
        /* 父进程 */
        if (backgnd == 1)
            printf("%d\n", pid);
        lastpid = pid;
    }
    else if (pid == 0)
    {
        /* backgnd=1时，将第一条简单命令的infd重定向至/dev/null */
        /* 当第一条命令试图从标准输入获取数据的时候立即返回EOF */

        if (cmd[i].infd == 0 && backgnd == 1)
            cmd[i].infd = open("/dev/null", O_RDONLY);

        /* 将第一个简单命令进程作为进程组组长 */
        if (i == 0)
            setpgid(0, 0);
        /* 子进程 */
        if (cmd[i].infd != 0)
        {
            close(0);
            dup(cmd[i].infd);
        }
        if (cmd[i].outfd != 1)
        {
            close(1);
            dup(cmd[i].outfd);
        }

        int j;
        for (j=3; j<1024; ++j)
            close(j);

        /* 前台作业能够接收SIGINT、SIGQUIT信号 */
        /* 这两个信号要恢复为默认操作 */
        if (backgnd == 0)
        {
            signal(SIGINT, SIG_DFL);
            signal(SIGQUIT, SIG_DFL);
        }
        execvp(cmd[i].args[0], cmd[i].args);
        exit(EXIT_FAILURE);
    }
}

/*执行非内置的命令*/
int execute_disk_command(void)
{
    if (cmd_count == 0)
        return 0;

    if (infile[0] != '\0')
        cmd[0].infd = open(infile, O_RDONLY);

    if (outfile[0] != '\0')
    {
        if (append)
            cmd[cmd_count-1].outfd = open(outfile, O_WRONLY | O_CREAT
                | O_APPEND, 0666);
        else
            cmd[cmd_count-1].outfd = open(outfile, O_WRONLY | O_CREAT
                | O_TRUNC, 0666);
    }

    /* 因为后台作不会调用wait等待子进程退出 */
    /* 为避免僵死进程，可以忽略SIGCHLD信号 */
    if (backgnd == 1)
        signal(SIGCHLD, SIG_IGN);
    else
        signal(SIGCHLD, SIG_DFL);

    int i;
    int fd;
    int fds[2];
    for (i=0; i<cmd_count; ++i)
    {
        /* 如果不是最后一条命令，则需要创建管道 */
        if (i<cmd_count-1)
        {
            pipe(fds);
            cmd[i].outfd = fds[1];
            cmd[i+1].infd = fds[0];
        }

        forkexec(i);

        if ((fd = cmd[i].infd) != 0)
            close(fd);

        if ((fd = cmd[i].outfd) != 1)
            close(fd);
    }

    if (backgnd == 0)
    {
        /* 前台作业，需要等待管道中最后一个命令退出 */
        int cnt = 0;
        while (wait(NULL) != -1 && cnt != cmd_count) {
            cnt++;
        }
    //    while (wait(NULL) != lastpid)
    //        ;
    }

    return 0;
}


/*
 * 内部命令解析
 * 返回1表示为内部命令，0表示不是内部命令
 */
int builtin(void)
{
    /*
    if (check("exit"))
        do_exit();
    else if (check("cd"))
        do_cd();
    else
        return 0;

    return 1;
    */

    int i = 0;
    int found = 0;
    while (builtins[i].name != NULL)
    {
        if (check(builtins[i].name))
        {
            builtins[i].handler();
            found = 1;
            break;
        }
        i++;
    }

    return found;
}

void do_exit(void)
{
    printf("exit\n");
    exit(EXIT_SUCCESS);
}

void do_cd(void)
{
    printf("do_cd ... \n");
}

void do_type(void)
{
    printf("do_type ... \n");
}

 

参考资料：

1. BruceMolay, 莫莱, Molay,等. Unix/Linux编程实践教程[M]. 清华大学出版社, 2004.

2. c++教程网， linux_miniShell实践

3. RandalE.Bryant, DavidR.O'Hallaron, 布莱恩特,等. 深入理解计算机系统[M]. 机械工业出版社, 2011.