二十九、Linux 进程与信号——minishell（2）

编程内容：

　　1.完成  echo env export 命令

　　2.完成前后台进程

　　3.完成重定向

完整代码如下：

29.1 主函数、通用头文件和Makefile

29.1.1 主函数

　　mshell_main.c

 #include <stdio.h>
 #include <stdlib.h>
 #include "mshell_handler.h"

 int main(int argc, char *argv[])
 {
     mshell_Handler();
 }

29.1.2 通用文件

　　mshell_common.h

 #ifndef __MSHELL_COMMON_H__
 #define __MSHELL_COMMON_H__

 #include <stdio.h>
 #include <stdlib.h>

 typedef enum {
     MSHELL_ERROR_NONE        = ,
     MSHELL_ERROR_PARAM            ,
     MSHELL_ERROR_MALLOC            ,
     MSHELL_ERROR_CALLOC            ,
     MSHELL_ERROR_PROG_CREATE,
     MSHELL_ERROR_PROG_DESTROY,
     MSHELL_ERROR_JOB_CREATE,
     MSHELL_ERROR_JOB_DESTROY,
     MSHELL_ERROR_JOB_PROGADD,
     MSHELL_ERROR_CMD_NONECMD,
     MSHELL_ERROR_REDIRECION_PARAM,
     MSHELL_ERROR_REDIRECTION_CREATE,
     MSHELL_ERROR_REDIRECTION_PARSE
 }mshell_error_t;

 extern int mshell_args_Total(char **args);
 extern void mshell_args_Free(char **args);
 #endif

　　mshell_common.c

 #include "mshell_common.h"

 /** 统计命令行参数的个数 */
 int mshell_args_Total(char **args)
 {
     int i = ;
     char *start = args[];

     while(NULL != start) {
         i++;
         start = args[i];
     }

     return i;
 }

 void mshell_args_Free(char **args)
 {
     if(NULL == args){
         return ;
     }

     int i;
     int len = sizeof(args);
     for(i = ; i < len; i++) {
         free(args[i]);
     }
 #if 0
     while(NULL != args[i]){
         free(args[i]);
         i++;
     }
 #endif
     free(args);
 }

29.1.3 Makefile

 #PROJECT_ROOT = $(dir $(abspath $(lastword $(MAKEFILE_LIST))))
 PROJECT_ROOT = $(shell pwd)
 SRC_DIR = $(PROJECT_ROOT)/src
 INCLUDE_DIR = $(PROJECT_ROOT)/include
 OBJ_DIR = $(PROJECT_ROOT)/obj
 BIN_DIR = $(PROJECT_ROOT)/bin

 # 找出 src 目录下的所有 .c 文件
 C_SRCS = $(wildcard $(SRC_DIR)/*.c)
 # 将所有的 src 下的 .c 文件替换为 .o 文件
 C_OBJS = $(patsubst %c, %o, $(C_SRCS))
 TARGET = mshell
 SHARE_LIB = libmshell.a

 C_SRC_MAIN = mshell_main.c

 CC = gcc
 CCFLAGS += fPIC
 LDFLAGS += -shared -fPIC
 ASFLAGS +=
 ARFLAGS = -crs
 LIBS_FLAGS = -L$(BIN_DIR)

 RM = rm -rf

 CFLAGS += -Wall -g -I$(INCLUDE_DIR)
 INCDIR += -I$(INCLUDE_DIR)

 .PHONY: all clean test

 all: $(TARGET)
     cp $(SHARE_LIB) $(BIN_DIR)
     cp $(SRC_DIR)/*.o $(OBJ_DIR)/
     $(RM) $(SHARE_LIB) $(SRC_DIR)/*.o

 $(TARGET): $(SHARE_LIB)
     $(CC) $(C_SRC_MAIN) -o $(TARGET) $(CFLAGS) $(INCDIR) $(LIBS_FLAGS) -lmshell

 $(SHARE_LIB): $(C_OBJS)
     $(AR) $(ARFLAGS) $(SHARE_LIB) $(C_OBJS)
     cp $(SHARE_LIB) $(BIN_DIR)

 $(C_OBJS) : %.o:%.c
     $(CC) -c $(CFLAGS) $(INCDIR) -o $@ $<

 clean:
     $(RM) mshell
     $(RM) $(SHARE_LIB)
     $(RM) $(OBJ_DIR)/$(OBJS)/*.o
     $(RM) $(SRC_DIR)/*.o

29.2 handler

　　mshell_handler.c

 #include "mshell_handler.h"

 static mshell_error_t mshell_cmd_Parsed(mshell_job_t *job, char *line, mshell_process_Flag_t *process_flag)
 {
     /** Create args secondary pointer stored in program */
     char **args_tmp = (char **)malloc(MSHELL_ARGS_SIZE * sizeof(char *));
     if(NULL == args_tmp) {
         return MSHELL_ERROR_MALLOC;
     }

     /** Split the command line */
     char *cmd = strtok(line, " ");

     /** The first parameter is the command itself */
     args_tmp[] = (char *)calloc(strlen(cmd + ), sizeof(char));
     if(NULL == args_tmp[]) {
         return MSHELL_ERROR_MALLOC;
     }
     strcpy(args_tmp[], cmd);

     /** Start with the second parameter */
     int i = ;
     char *cmd_param;
     mshell_redirection_t *redirections[MSHELL_REDIRECTION_NUMBER];
     int redirection_num = ;

     while(NULL != (cmd_param = strtok(NULL, " "))) {

         /** 对命令行进行解析，判断是否为后台进程 */
         int process_ret;
         *process_flag = mshell_process_BackParse(cmd_param, &process_ret);
         if( == process_ret) {
             continue;
         }

         /** 分析重定向 */
         mshell_error_t redirection_ret;
         redirections[redirection_num] =
                 mshell_redirection_Parse(redirections, redirection_num, cmd_param, &redirection_ret);
         if(NULL != redirections[redirection_num] && MSHELL_ERROR_NONE == redirection_ret){
             redirection_num++;
             continue;
         }
         else if (NULL == redirections[redirection_num] && MSHELL_ERROR_REDIRECION_PARAM == redirection_ret) {
             printf("need param\n");
             continue;
         }
         else if(NULL == redirections[redirection_num] && MSHELL_ERROR_REDIRECTION_CREATE == redirection_ret)
         {
             perror("error create redirection");
             return MSHELL_ERROR_REDIRECTION_CREATE;
         }

         /** 分析命令 */
         args_tmp[i] = (char *)calloc(strlen(cmd_param + ), sizeof(char));
         if(NULL == args_tmp[i]) {
             return MSHELL_ERROR_MALLOC;
         }
         strcpy(args_tmp[i], cmd_param);
         i++;
     }
     args_tmp[i] = NULL;

     /** Store all command line parameters in program and free args_tmp*/
     mshell_prog_t *prog = mshell_prog_Create(args_tmp);
     if(NULL == prog) {
         return MSHELL_ERROR_PROG_CREATE;
     }
     mshell_args_Free(args_tmp);

     /** Add redirection to job and free redirections*/
     for(i = ; i < redirection_num; i++){
         mshell_prog_RedirectionAdd(prog, redirections[i]);
     }
     mshell_redirections_Free(redirections, redirection_num);

     /** Add program to the job*/
     if(MSHELL_ERROR_NONE != mshell_job_AddProg(job, prog)) {
         return MSHELL_ERROR_JOB_PROGADD;
     }

 #if 0
     /** free args_tmp */
     mshell_args_Free(args_tmp);
 #endif
     return ;
 }

 static void mshell_cmd_ExcuProcess(mshell_job_t job, int order, mshell_process_Flag_t process_flag)
 {
     pid_t pid;
     if((pid = fork()) < ) {
         perror("fork error");
     }
     else if(pid == ) {
         /** child process */
         if(order == ) {
             /** order = 0, 则为 minishell 当中启动的第一个子进程，设置其为组长进程 */
             job.pgid = mshell_process_GroupGet(getpid(), getpid());
         }
         else {
             /** order > 0, 则为启动的第二个进程，将其设置进程组的成员进程 */
             job.pgid = mshell_process_GroupGet(getpid(), job.pgid);
         }
         mshell_process_GroupSet(process_flag, getpid());
         /** 对便准输入、标准输出和追加进行重定向 */
         mshell_prog_RedirectionExcu(job.progs[order]);

         /** 调用 exec 函数执行系统中的其他命令 */
         if(MSHELL_ERROR_CMD_NONECMD == mshell_Cmd_ExcuOther(job.progs[order].args))
             exit();
     }
     else {
         /** parent process */
         if(order == ) {
             job.pgid = mshell_process_GroupGet(pid, pid);
         }
         else {
             job.pgid = mshell_process_GroupGet(pid, job.pgid);
         }
         mshell_process_GroupSet(process_flag, job.pgid);

         mshell_process_Wait(process_flag, job.pgid);

 #if 0
         /** 等待指定的子进程结束, 阻塞版本，支持作业控制 */
         if(waitpid(pid, NULL, WUNTRACED) < ) {
             perror("waitpid error");
         }
 #endif
     }

 }

 static mshell_error_t mshell_cmd_Excu(mshell_job_t *job, mshell_process_Flag_t process_flag)
 {
     int ret = MSHELL_ERROR_NONE;
     int i;
     for(i = ; i < job->progs_num; i++)
     {
         ret = mshell_Cmd_ExcuFun(job->progs[i].args);
         if(MSHELL_ERROR_NONE == ret || MSHELL_ERROR_PARAM == ret) {
             return MSHELL_ERROR_NONE;
         }

         /** 执行其他命令 */
         mshell_cmd_ExcuProcess(*job, i, process_flag);
 #if 0
         pid_t pid;
         if((pid = fork()) < ) {
             perror("fork error");
         }
         else if(pid == ) {
             /** child process */
             /** 调用 exec 函数执行系统中的其他命令 */
             if(MSHELL_ERROR_CMD_NONECMD == mshell_Cmd_ExcuOther(job->progs[i].args))
                 exit();
         }
         else {
             /** parent process */
             /** 等待指定的子进程结束, 阻塞版本，支持作业控制 */
             if(waitpid(pid, NULL, WUNTRACED) < ) {
                 perror("waitpid error");
             }
         }
 #endif
     }

     return ;
 }

 mshell_error_t mshell_Handler()
 {
     /**创建一个进程组，将 minishell 进程设置为进程组的组长 */
     setpgid(getpid(), getpid());

     char buffer[MSHELL_COMMAND_LEN];
     memset(buffer, , MSHELL_COMMAND_LEN);

     ssize_t size = strlen(MSHELL_PROMPT) * sizeof(char);
     write(STDOUT_FILENO, MSHELL_PROMPT, size);

     mshell_process_Flag_t process_flag;    ///< 设置前台和后台进程的标志
     ssize_t len;
     while() {

         len = read(STDIN_FILENO, buffer, MSHELL_COMMAND_LEN); ///< 从命令行读取内容到 buffer
         buffer[len - 1] = 0;
         if(strlen(buffer) > ){
             mshell_job_t *job = mshell_job_Create(buffer);
             if(NULL == job) {
                 return MSHELL_ERROR_JOB_CREATE;
             }

             mshell_cmd_Parsed(job, buffer, &process_flag);
             mshell_cmd_Excu(job, process_flag);
             //mshell_job_Destroy(job);
         }

         write(STDOUT_FILENO, MSHELL_PROMPT, size);
         memset(buffer, , MSHELL_COMMAND_LEN);
     }
 }

　　mshell_handler.h

 #ifndef __MSHELL_HANDLER_H__
 #define __MSHELL_HANDLER_H__

 #include "mshell_common.h"
 #include "mshell_process.h"
 #include "mshell_cmd_fun.h"
 #include "mshell_program.h"
 #include "mshell_job.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <malloc.h>
 #include <unistd.h>
 #include <string.h>
 #include <memory.h>
 #include <sys/wait.h>

 #define MSHELL_PROMPT    "mshell =>"
 #define MSHELL_COMMAND_LEN     256
 #define MSHELL_ARGS_SIZE    100

 mshell_error_t mshell_Handler();

 #endif

29.3 作业

　　mshell_job.h

 #ifndef __MSHELL_JOB_H__
 #define __MSHELL_JOB_H__

 #include "mshell_common.h"
 #include "mshell_program.h"
 #include <malloc.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <memory.h>

 /** job struct, A job contains several programs to execute */
 typedef struct {
     char             *cmd;        ///< String commands to be executed
     pid_t            pgid;        ///< 进程组的 ID
     int             progs_num;    ///< Number of programs to execute
     mshell_prog_t    *progs;        ///< Point to several programs to be executed
 }mshell_job_t;

 extern mshell_job_t* mshell_job_Create(char *cmd);
 extern void mshell_job_Destroy(mshell_job_t *job);
 extern mshell_error_t mshell_job_AddProg(mshell_job_t *job, mshell_prog_t *prog);
 #endif

　　mshell_job.c

 #include "mshell_common.h"
 #include "mshell_program.h"
 #include "mshell_job.h"

 mshell_job_t* mshell_job_Create(char *cmd)
 {
     mshell_job_t *job = (mshell_job_t *)malloc(sizeof(mshell_job_t));
     if(NULL == job)
     {
         return NULL;
     }

     job->cmd = (char *)malloc(sizeof(char) * strlen(cmd));
     if(NULL == job->cmd)
     {
         return NULL;
     }

     strcpy(job->cmd, cmd);
     job->progs_num = ;
     job->progs = NULL;

     return job;
 }
 void mshell_job_Destroy(mshell_job_t *job)
 {
     if(NULL == job)
     {
         return ;
     }
     free(job->progs);
     free(job->cmd);
     free(job);
 }

 mshell_error_t mshell_job_AddProg(mshell_job_t *job, mshell_prog_t *prog)
 {
     mshell_prog_t *prog_tmp = (mshell_prog_t *)malloc(sizeof(mshell_prog_t) * (job->progs_num + ));//1 为NULL的初始化
     if(NULL == prog_tmp) {
         return MSHELL_ERROR_MALLOC;
     }

     memcpy(prog_tmp, job->progs, job->progs_num * sizeof(mshell_prog_t));
     prog_tmp[job->progs_num++] = *prog;
     free(job->progs);
     job->progs = prog_tmp;

     return MSHELL_ERROR_NONE;
 }

29.4 程序

　　mshell_program.h

 #ifndef __MSHELL_PROGRAM_H__
 #define __MSHELL_PROGRAM_H__

 #include "mshell_common.h"
 #include "mshell_redirection.h"
 #include <malloc.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <memory.h>

 /** program struct */
 typedef struct {
     /**
      * Command-line parameters obtained from the terminal
      * Char*argv[] parameter corresponding to the main function
      */
     char                     **args;
     pid_t                     pid;                ///< 进程 ID
     int                     redirection_num;    ///< 重定向的数量
     mshell_redirection_t     *redirecitons;        ///< 重定向结构体数组
 }mshell_prog_t;

 extern mshell_prog_t* mshell_prog_Create(char **args);
 extern void mshell_prog_Destroy(mshell_prog_t *prog);
 extern void mshell_prog_RedirectionAdd(mshell_prog_t *prog, mshell_redirection_t *redirection);
 extern void mshell_prog_RedirectionExcu(mshell_prog_t prog);
 #endif

　　mshell_program.c

 #include "mshell_program.h"

 /**
  * Init program's pointer array
  */
 static mshell_prog_t * mshell_prog_ArgsInit(mshell_prog_t *prog, char **args, int counter)
 {
     int i;

     for(i = ; i < counter; i++) {
         int len = strlen(args[i]);
         prog->args[i] = (char *)malloc(len);
         if(NULL == prog->args[i]){
             return NULL;
         }

         strcpy(prog->args[i], args[i]);
     }
     return prog;
 }

 mshell_prog_t * mshell_prog_Create(char **args)
 {
     mshell_prog_t *prog = (mshell_prog_t *)malloc(sizeof(mshell_prog_t));
     if(NULL == prog){
         return NULL;
     }

     /** Init program's redirection */
     prog->redirection_num = ;
     prog->redirecitons = NULL;

     /** Init program's pointer array  */
     int args_num = mshell_args_Total(args);
     prog->args = (char **)calloc(args_num + , sizeof(char *));
     prog = mshell_prog_ArgsInit(prog, args, args_num);
     return prog;
 }

 void mshell_prog_Destroy(mshell_prog_t *prog)
 {
     if(NULL == prog) {
         return ;
     }

     mshell_args_Free(prog->args);
     free(prog->redirecitons);
     free(prog);
 }

 void mshell_prog_RedirectionAdd(mshell_prog_t *prog, mshell_redirection_t *redirection)
 {
     mshell_redirection_t *redirections = (mshell_redirection_t *)calloc(prog->redirection_num + , sizeof(mshell_redirection_t));
     if(NULL == redirections){
         return;
     }

     if(NULL != prog->redirecitons) {
         memcpy(redirections, prog->redirecitons, prog->redirection_num * sizeof(redirections));
         free(redirections);
     }

     prog->redirecitons = redirections;
     memcpy(&prog->redirecitons[prog->redirection_num], redirection, sizeof(mshell_redirection_t));
     prog->redirection_num += ;
 }

 void mshell_prog_RedirectionExcu(mshell_prog_t prog)
 {
     int i;
     for(i = ; i < prog.redirection_num; i++) {
         mshell_redirection_Excu(prog.redirecitons[i]);
     }
 }

29.5 命令

　　mshell_cmd_fun.h

 #ifndef __MSHELL_CMD_FUN_H__
 #define __MSHELL_CMD_FUN_H__

 #include "mshell_common.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <string.h>

 #define MSHELL_CMD_CD            "cd"
 #define MSHELL_CMD_PWD            "pwd"
 #define MSHELL_CMD_EXIT            "exit"
 #define MSHELL_CMD_ENV            "env"
 #define MSHELL_CMD_ECHO            "echo"
 #define MSHELL_CMD_EXPORT        "export"

 typedef void (* mshell_cmd_Fun)(char *args);
 typedef struct {
     char *cmd;
     mshell_cmd_Fun    callback;
 }mshell_funs_t;

 mshell_error_t mshell_Cmd_ExcuFun(char **args);
 mshell_error_t mshell_Cmd_ExcuOther(char **args);
 #endif

　　mshell_cmd_fun.c

 #include "mshell_cmd_fun.h"

 extern char** environ;

 static void mshell_cmd_Cd(char *args)
 {
     if(chdir(args) < ) {
         perror("cd error");
     }
 }

 static void mshell_cmd_Pwd(char *args)
 {
     char buffer[];
     memset(buffer, , sizeof(buffer));
     if(getcwd(buffer, sizeof(buffer)) == NULL){
         perror("pwd error");
     }

     printf("%s\n", buffer);
 }

 static void mshell_cmd_Exit(char *args)
 {
     exit();
 }

 static void mshell_mcd_Env(char *args)
 {
     int i = ;
     char *env = NULL;

     while(NULL != (env = environ[i])) {
         printf("%s\n", env);
         i++;
     }
 }

 static void mshell_mcd_Echo(char *args)
 {
     char *arg_tmp = args;
     if(NULL == arg_tmp) {
         fprintf(stderr, "echo: invalid argument\n");
         return;
     }

     if('$' == arg_tmp[]) {
         char *env_tmp = getenv(arg_tmp + );
         printf("%s\n", env_tmp);
     }
     else {
         printf("%s\n", arg_tmp);
     }
 }

 static void mshell_mcd_Export(char *args)
 {
     if(NULL == args) {
         fprintf(stderr, "export: invalid argument\n");
         return;
     }

     putenv(args);
 }

 static mshell_funs_t mshell_table_fun[] = {
     /** cmd                    func */
     {MSHELL_CMD_CD    ,        mshell_cmd_Cd},
     {MSHELL_CMD_PWD ,        mshell_cmd_Pwd},
     {MSHELL_CMD_EXIT,        mshell_cmd_Exit},
     {MSHELL_CMD_ENV ,        mshell_mcd_Env},
     {MSHELL_CMD_ECHO,        mshell_mcd_Echo},
     {MSHELL_CMD_EXPORT,        mshell_mcd_Export},
 };

 mshell_error_t mshell_Cmd_ExcuFun(char **args)
 {
     if(NULL == args) {
         return MSHELL_ERROR_PARAM;
     }
     int len = sizeof(mshell_table_fun) / sizeof(mshell_funs_t);
     int i;
     for(i = ; i < len; i++) {
         if(!strcmp(args[], mshell_table_fun[i].cmd)){
             mshell_table_fun[i].callback(args[]);
             return MSHELL_ERROR_NONE;
         }
     }

     return MSHELL_ERROR_CMD_NONECMD;
 }

 mshell_error_t mshell_Cmd_ExcuOther(char **args)
 {
     /** excu 函数成功执行不返回，出错会返回 -1 */
     if(execvp(args[], args) < ) {
         perror("execvp error");
         /** 这里退出后，让后面的程序继续执行 */
         return MSHELL_ERROR_CMD_NONECMD;
     }

     return MSHELL_ERROR_NONE;
 }

29.6 重定向

　　mshell_redirection.h

 #ifndef __MSHELL_REDIRECTION_H__
 #define __MSHELL_REDIRECTION_H__

 #include "mshell_common.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <string.h>

 #define MSHELL_REDIRECTION_NUMBER        5

 #define MSHELL_REDIRECTION_READ            "<"
 #define MSHELL_REDIRECTION_WRITE        ">"
 #define MSHELL_REDIRECTION_APPEND        ">>"

 typedef enum {
     mshell_Redirection_Read,
     mshell_Redirection_Write,
     mshell_Redirection_Append
 }mshell_redirection_type_t;

 typedef struct {
     mshell_redirection_type_t    type;
     int                            fd;
 }mshell_redirection_t;

 typedef mshell_redirection_t* (* mshell_redirection_fun)(char *file);
 typedef struct {
     char                     *type;
     mshell_redirection_fun     callback;
 }mshell_table_redirection_t;

 typedef void (* mshell_redirection_ExcuFun)(int fd);
 typedef struct {
     mshell_redirection_type_t    type;
     mshell_redirection_ExcuFun    callback;
 }mshell_Table_redirectionExcu_t;

 extern mshell_redirection_t *mshell_redirection_Create(int fd, mshell_redirection_type_t type);
 extern void mshell_redirection_Destroy(mshell_redirection_t *redirection);
 extern mshell_redirection_t *mshell_redirection_Parse(
         mshell_redirection_t **redirection,
         int num,
         char *args,
         mshell_error_t *error);
 extern void mshell_redirections_Free(mshell_redirection_t **redirections, int num);
 extern void mshell_redirection_Excu(mshell_redirection_t redirection);
 #endif

　　mshell_redirection.c

 #include "mshell_redirection.h"

 mshell_redirection_t *mshell_redirection_Create(int fd, mshell_redirection_type_t type)
 {
     mshell_redirection_t *redirection = (mshell_redirection_t *)calloc(, sizeof(mshell_redirection_t));
     if(NULL == redirection){
         return NULL;
     }

     redirection->fd = fd;
     redirection->type = type;
     return redirection;
 }

 void mshell_redirection_Destroy(mshell_redirection_t *redirection)
 {
     if(NULL == redirection) {
         return;
     }
     free(redirection);
 }

 static mshell_redirection_t *mshell_redirection_Read(char *file)
 {
     int fd = open(file, O_RDONLY);
     mshell_redirection_t *redirection = mshell_redirection_Create(fd, mshell_Redirection_Read);
     return redirection;
 }

 static mshell_redirection_t *mshell_redirection_Write(char *file)
 {
     int fd = open(file, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
     mshell_redirection_t *redirection = mshell_redirection_Create(fd, mshell_Redirection_Write);
     return redirection;
 }

 static mshell_redirection_t *mshell_redirection_Append(char *file)
 {
     int fd = open(file, O_WRONLY | O_CREAT | O_APPEND, S_IRWXU | S_IRWXG | S_IRWXO);
     mshell_redirection_t *redirection = mshell_redirection_Create(fd, mshell_Redirection_Append);
     return redirection;
 }

 static mshell_table_redirection_t mshell_redirection_table[] = {
     /** args                    func */
     {MSHELL_REDIRECTION_READ,    mshell_redirection_Read},
     {MSHELL_REDIRECTION_WRITE,    mshell_redirection_Write},
     {MSHELL_REDIRECTION_APPEND,    mshell_redirection_Append},
 };

 mshell_redirection_t *mshell_redirection_Parse(
         mshell_redirection_t **redirection,
         int num,
         char *args,
         mshell_error_t *error)
 {
     int len = sizeof(mshell_redirection_table) / sizeof(mshell_table_redirection_t);
     int i;

     for(i = ; i < len; i++) {
         if(!strcmp(args, mshell_redirection_table[i].type)) {
             char *file = strtok(NULL, " ");
             if(NULL == file) {
                 *error = MSHELL_ERROR_REDIRECION_PARAM;
                 return NULL;
             }
             else
             {
                 redirection[num] = mshell_redirection_table[i].callback(file);
                 if(NULL == redirection[num]){
                     *error = MSHELL_ERROR_REDIRECTION_CREATE;
                     return NULL;
                 }
                 else {
                     *error = MSHELL_ERROR_NONE;
                     return redirection[num];
                 }
             }
         }
     }

     return NULL;
 }

 void mshell_redirections_Free(mshell_redirection_t **redirections, int num)
 {
     if(NULL == redirections){
         return;
     }
     int i;
     for(i = ; i < num; i++) {
         mshell_redirection_Destroy(redirections[i]);
     }

 }

 static void mshell_redirection_ExcuRead(int fd)
 {
     if(dup2(fd, STDIN_FILENO) != STDIN_FILENO) {
         perror("dup2");
     }
 }

 static void mshell_redirection_ExcuWrite(int fd)
 {
     if(dup2(fd, STDOUT_FILENO) != STDOUT_FILENO) {
         perror("dup2");
     }
 }

 static void mshell_redirection_ExcuAppend(int fd)
 {
     if(dup2(fd, STDOUT_FILENO) != STDOUT_FILENO) {
         perror("dup2");
     }
 }

 static mshell_Table_redirectionExcu_t mshell_redirection_ExcuTable[] = {
     /** type                            func */
     {mshell_Redirection_Read,            mshell_redirection_ExcuRead},
     {mshell_Redirection_Write,            mshell_redirection_ExcuWrite},
     {mshell_Redirection_Append,            mshell_redirection_ExcuAppend},
 };

 /** 对标准输入、标准输出和追加进行重定向 */
 void mshell_redirection_Excu(mshell_redirection_t redirection)
 {
     int i;
     int len = sizeof(mshell_redirection_ExcuTable) / sizeof(mshell_Table_redirectionExcu_t);
     for(i = ; i < len; i++) {
         if(redirection.type == mshell_redirection_ExcuTable[i].type) {
             mshell_redirection_ExcuTable[i].callback(redirection.fd);
         }
     }
 }

29.7 进程

　　mshell_process.h

 #ifndef __MSHELL_PROCESS_H__
 #define __MSHELL_PROCESS_H__

 #include "mshell_common.h"
 #include <unistd.h>
 #include <sys/wait.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 typedef enum {
     MSHELL_PROCESS_FORE = ,
     MSHELL_PROCESS_BACK =
 }mshell_process_Flag_t;

 /** 解析 & 符号，设置进程组标志为前台或后台进程标指 */
 extern mshell_process_Flag_t mshell_process_BackParse(char *args, int *error);
 extern pid_t mshell_process_GroupGet(pid_t pid, pid_t group_pid);
 extern void mshell_process_GroupSet(mshell_process_Flag_t process_flag, pid_t pid);
 extern void mshell_process_Wait(mshell_process_Flag_t process_flag, pid_t pgid);

 #endif /* INCLUDE_MSHELL_PROCESS_H_ */

　　mshell_process.c

 /*
  * mshell_process.c
  *
  *  Created on: 2018年12月26日
  *      Author: homework
  *  brief:
  *      启动的 minishell 本身就是一个进程，在一个进程组当中，
  *      在 minishell 中启动的若干个进程中，其中就有一个父进程，也可能还有其他子进程
  *      在此基础上，再做一个进程组
  *      把 minishell 启动起来后，做为一个进程组，minishell 为组长进程
  *      在 minishell 上启动多个进程，将这些进程作为一个进程组
  *  1. 把 minishell 单独设置为一个进程组
  *  2. 把在 minishell 中启动的进程设置为一个进程组
  *      2.1 把在 minishell 中启动的第一个进程作为进程组的组长
  *      2.2 后面创建的进程放置进此进程组当中
  */

 #include "mshell_process.h"

 /** 解析 & 符号，设置进程组标志为前台或后台进程标指 */
 mshell_process_Flag_t mshell_process_BackParse(char *args, int *error)
 {
     mshell_process_Flag_t process_flag = MSHELL_PROCESS_FORE;
     if(!strcmp(args, "&")){
         process_flag = MSHELL_PROCESS_BACK;
         *error = ;
         return process_flag;
     }

     *error = -;
     return process_flag;
 }

 /** 创建进程组并获取进程组 ID */
 pid_t mshell_process_GroupGet(pid_t pid, pid_t group_pid)
 {
     if(setpgid(pid, group_pid) < ) {
         perror("setpgid error");
     }

     return group_pid;
 }

 /** 设置前台进程组 */
 void mshell_process_GroupSet(mshell_process_Flag_t process_flag, pid_t pid)
 {
     if(process_flag == MSHELL_PROCESS_FORE) {
         tcsetpgrp(, getpgid(pid));
     }
 }

 void mshell_process_Wait(mshell_process_Flag_t process_flag, pid_t pgid)
 {
     if(process_flag == MSHELL_PROCESS_FORE) {
         waitpid(-pgid, NULL, WUNTRACED);
     }

     if(process_flag == MSHELL_PROCESS_BACK) {
         waitpid(-pgid, NULL, WNOHANG);
     }
 }