三十五、minishell（3）

35.1 内容

　　在当前的 minishell 中，如果执行 date clear 命令等，minishell 会停止：

　　

　　这是因为引入进程组的时候，mshell 放置在前台进程组，同时之后在子进程中又创建了一个进程组，在代码中，第二个进程组在没有将其设置为前台进程组之前，一直是后台进程组。那么后台进程组读写 minishell 的时候，会产生 SIGTTIN 和 SIGTTOU 这两个信号。

　　SIGTTIN：后台进程组的成员读控制终端

　　SIGTTOU：后台进程组的成员读控制终端

　　产生这两个信号默认的操作就是停止进程。

　　minishell 被停止的原因就是对这两个信号未作处理。我们处理的有些命令是通过 FORK 执行的，必须处理这两个信号。

　　所以我们必须对作业控制信号进行处理。

35.2 修改部分

　　其他部分参考第 29 节：https://www.cnblogs.com/kele-dad/p/9201411.html

35.2.1 signal 部分

　　mshell_signal.h

#ifndef INCLUDE_MSHELL_SIGNAL_H_
#define INCLUDE_MSHELL_SIGNAL_H_

#include "mshell_common.h"
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

extern void mshell_signal_Ign(void);
extern void mshell_signal_Catch(void);
extern void mshell_signal_Default(void);
#endif /* INCLUDE_MSHELL_SIGNAL_H_ */

　　mshell_signal.c

#include "mshell_signal.h"

/** ================ parent handler handler ==================== */
/** 忽略某些信号 */
void mshell_signal_Ign(void)
{
    signal(SIGTTIN, SIG_IGN);
    signal(SIGTTOU, SIG_IGN);
    signal(SIGINT, SIG_IGN);
    signal(SIGTSTP, SIG_IGN);
}

/** mshell 的信号处理函数 */
static void mshell_signal_Handler(int signo)
{
    /** 子进程终止信号捕获 */
    if(signo == SIGCHLD){
        /** 回收进程组中的子进程, 非阻塞模式 */
        waitpid(-1, NULL, WNOHANG);
        /** 将 minishell 所在的组调度为前台进程组 */
        tcsetpgrp(0, getpgid(getpid()));
    }
}

/** 捕获信号 */
void mshell_signal_Catch(void)
{
    signal(SIGCHLD, mshell_signal_Handler);
}

/** =============== child process handler =================== */
void mshell_signal_Default(void)
{
    signal(SIGTTIN, SIG_DFL);
    signal(SIGTTOU, SIG_DFL);
    signal(SIGINT, SIG_DFL);
    signal(SIGTSTP, SIG_DFL);
    signal(SIGCHLD, SIG_DFL);
}

35.2.1 mshell_handler 修改

　　mshell_handler.h

#ifndef __MSHELL_HANDLER_H__
#define __MSHELL_HANDLER_H__


#include "mshell_common.h"
#include "mshell_signal.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

　　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[0] = (char *)calloc(strlen(cmd + 1), sizeof(char));
    if(NULL == args_tmp[0]) {
        return MSHELL_ERROR_MALLOC;
    }
    strcpy(args_tmp[0], cmd);

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

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

        /** 对命令行进行解析，判断是否为后台进程 */
        int process_ret;
        *process_flag = mshell_process_BackParse(cmd_param, &process_ret);
        if(0 == 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
");
            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 + 1), 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 = 0; 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;
    }

    return 0;
}

static void mshell_cmd_ExcuProcess(mshell_job_t job, int order, mshell_process_Flag_t process_flag)
{
    pid_t pid;
    if((pid = fork()) < 0) {
        perror("fork error");
    }
    else if(pid == 0) {
        /** child process */

        /** 信号处理 */
        mshell_signal_Default();

        if(order == 0) {
            /** 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(1);
    }
    else {
        /** parent process */
        if(order == 0) {
            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);
    }

}

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 = 0; 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);
    }

    return 0;
}

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

    /** 信号处理 */
    mshell_signal_Ign();
    mshell_signal_Catch();

    char buffer[MSHELL_COMMAND_LEN];
    memset(buffer, 0, 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(1) {

        len = read(STDIN_FILENO, buffer, MSHELL_COMMAND_LEN); ///< 从命令行读取内容到 buffer
        buffer[len - 1] = 0;
        if(strlen(buffer) > 0){
            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, 0, MSHELL_COMMAND_LEN);
    }
}