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

#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+]; /* 解析出的命令参数列表 */
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+]; /*读到的一行命令*/
char avline[MAXLINE+]; /*解析过添加好\0的命令*/
char *lineptr;
char *avptr;
char infile[MAXNAME+]; /*输入重定向文件*/
char outfile[MAXNAME+]; /*输出重定向文件*/
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 () 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 ;
} 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, , sizeof(cmd));
int i;
for (i=; i<PIPELINE; ++i)
{
cmd[i].infd = ;
cmd[i].outfd = ;
}
memset(cmdline, , sizeof(cmdline));
memset(avline, , sizeof(avline));
lineptr = cmdline;
avptr = avline;
memset(infile, , sizeof(infile));
memset(outfile, , sizeof(outfile));
cmd_count = ;
backgnd = ;
append = ;
lastpid = ; printf("[minishell]$ ");
fflush(stdout);
} /**主循环**/
void shell_loop(void)
{
while ()
{
/* 初始化环境 */
init();
/* 获取命令 */
if (read_command() == -)
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 -;
return ;
} /*
* 解析命令
* 成功返回解析到的命令个数，失败返回-1
*/
int parse_command(void)
{
/* cat < test.txt | grep -n public > test2.txt & */
if (check("\n"))
return ; /* 判断是否内部命令并执行它 */
if (builtin())
return ; /* 1、解析第一条简单命令 */
get_command();
/* 2、判定是否有输入重定向符 */
if (check("<"))
getname(infile);
/* 3、判定是否有管道 */
int i;
for (i=; i<PIPELINE; ++i)
{
if (check("|"))
get_command(i);
else
break;
}
/* 4、判定是否有输出重定向符 */
if (check(">"))
{
if (check(">"))
append = ;
getname(outfile);
}
/* 5、判定是否后台作业 */
if (check("&"))
backgnd = ;
/* 6、判定命令结束‘\n’*/
if (check("\n"))
{
cmd_count = i;
return cmd_count;
}
else
{
fprintf(stderr, "Command line syntax error\n");
return -;
}
} /*
* 解析简单命令至cmd[i]
* 提取cmdline中的命令参数到avline数组中，
* 并且将COMMAND结构中的args[]中的每个指针指向这些字符串
*/
void get_command(int i)
{
/* cat < test.txt | grep -n public > test2.txt & */ int j = ;
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 = ;
}
*avptr++ = '\0';
switch (*lineptr)
{
case ' ':
case '\t':
inword = ;
j++;
break;
case '<':
case '>':
case '|':
case '&':
case '\n':
if (inword == )
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 ;
} /* lineptr保持不变 */
return ;
} 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 ;
} /*执行命令 fork + exec */
void forkexec(int i)
{
pid_t pid;
pid = fork();
if (pid == -)
ERR_EXIT("fork"); if (pid > )
{
/* 父进程 */
if (backgnd == )
printf("%d\n", pid);
lastpid = pid;
}
else if (pid == )
{
/* backgnd=1时，将第一条简单命令的infd重定向至/dev/null */
/* 当第一条命令试图从标准输入获取数据的时候立即返回EOF */ if (cmd[i].infd == && backgnd == )
cmd[i].infd = open("/dev/null", O_RDONLY); /* 将第一个简单命令进程作为进程组组长 */
if (i == )
setpgid(, );
/* 子进程 */
if (cmd[i].infd != )
{
close();
dup(cmd[i].infd);
}
if (cmd[i].outfd != )
{
close();
dup(cmd[i].outfd);
} int j;
for (j=; j<; ++j)
close(j); /* 前台作业能够接收SIGINT、SIGQUIT信号 */
/* 这两个信号要恢复为默认操作 */
if (backgnd == )
{
signal(SIGINT, SIG_DFL);
signal(SIGQUIT, SIG_DFL);
}
execvp(cmd[i].args[], cmd[i].args);
exit(EXIT_FAILURE);
}
} /*执行非内置的命令*/
int execute_disk_command(void)
{
if (cmd_count == )
return ; if (infile[] != '\0')
cmd[].infd = open(infile, O_RDONLY); if (outfile[] != '\0')
{
if (append)
cmd[cmd_count-].outfd = open(outfile, O_WRONLY | O_CREAT
| O_APPEND, );
else
cmd[cmd_count-].outfd = open(outfile, O_WRONLY | O_CREAT
| O_TRUNC, );
} /* 因为后台作不会调用wait等待子进程退出 */
/* 为避免僵死进程，可以忽略SIGCHLD信号 */
if (backgnd == )
signal(SIGCHLD, SIG_IGN);
else
signal(SIGCHLD, SIG_DFL); int i;
int fd;
int fds[];
for (i=; i<cmd_count; ++i)
{
/* 如果不是最后一条命令，则需要创建管道 */
if (i<cmd_count-)
{
pipe(fds);
cmd[i].outfd = fds[];
cmd[i+].infd = fds[];
} forkexec(i); if ((fd = cmd[i].infd) != )
close(fd); if ((fd = cmd[i].outfd) != )
close(fd);
} if (backgnd == )
{
/* 前台作业，需要等待管道中最后一个命令退出 */
int cnt = ;
while (wait(NULL) != - && cnt != cmd_count) {
cnt++;
}
// while (wait(NULL) != lastpid)
// ;
} return ;
} /*
* 内部命令解析
* 返回1表示为内部命令，0表示不是内部命令
*/
int builtin(void)
{
/*
if (check("exit"))
do_exit();
else if (check("cd"))
do_cd();
else
return 0; return 1;
*/ int i = ;
int found = ;
while (builtins[i].name != NULL)
{
if (check(builtins[i].name))
{
builtins[i].handler();
found = ;
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");
}