/usr/bin/wc shell.c

[process A] | [process B] | [process C]

// shell_cmd.h
#pragma once
#include "tokenizer.h"

typedef int cmd_fun_t(struct tokens *tokens);

typedef struct fun_desc
{
    cmd_fun_t *fun;
    char *cmd;
    char *doc;
} fun_desc_t;

extern fun_desc_t cmd_table[];

int cmd_get_size();

int cmd_exit(struct tokens *tokens);
int cmd_help(struct tokens *tokens);

// shell_cmp.c
#include "shell_cmd.h"
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define unused __attribute__((unused))
#define ARRAY_SIZE(ARR) (sizeof(ARR) / sizeof((ARR)[0]))

fun_desc_t cmd_table[] = {
    {cmd_help, "?", "show this help menu"},
    {cmd_pwd, "pwd", "show current working path"},
    {cmd_cd, "cd", "change current working path"},
    {cmd_exit, "exit", "exit the command shell"},
};

int cmd_get_size()
{
    return ARRAY_SIZE(cmd_table);
}

int cmd_help(struct tokens *tokens)
{
    for (unsigned int i = 0; i < ARRAY_SIZE(cmd_table); i++)
    {
        printf("%s - %s\n", cmd_table[i].cmd, cmd_table[i].doc);
    }
    return 1;
}

int cmd_exit(struct tokens *tokens)
{
    exit(0);
}

//shell_cmd.h
// ...
int cmd_pwd(struct tokens *tokens);
int cmd_cd(struct tokens *tokens);
// ...

//shell_cmd.c
// ...
// 记得添加到内置命令表中
fun_desc_t cmd_table[] = {
    {cmd_help, "?", "show this help menu"},
    {cmd_pwd, "pwd", "show current working path"},
    {cmd_cd, "cd", "change current working path"},
    {cmd_exit, "exit", "exit the command shell"},
};
// ...
int cmd_pwd(struct tokens *tokens)
{
    char cwd[PATH_MAX];
    // 通过系统调用getcwd来获取当前目录
    if (getcwd(cwd, sizeof(cwd)) != NULL)
    {
        printf("%s\n", cwd);
    }
    else
    {
        fprintf(stderr, "show work path failed");
        return 1;
    }
    return 0;
}

int cmd_cd(struct tokens *tokens)
{
	// 通过系统调用chdir来改变工作目录
    if (chdir(tokens_get_token(tokens, 1)) == 0)
    {
        return 0;
    }
    else
    {
        fprintf(stderr, "change work path failed");
        return -1;
    }
}
// ...

/usr/bin/example 111 222 333

const char* path = "/usr/bin/example"
char argv[5][4096];
argv[0] = "/usr/bin/example";
argv[1] = "111";
argv[2] = "222";
argv[3] = "333";
argv[4] = NULL;
execv(path, argv);

// shell.c
// ...
while (fgets(line, 4096, stdin))
{
    struct tokens *tokens = tokenize(line);
    int fundex = cmd_lookup(tokens_get_token(tokens, 0));
    if (fundex >= 0)
    {
        cmd_table[fundex].fun(tokens);
    }
    else
    {
	    // 假设最多64个参数，肯定是够大了
        char *argv[64];
	    argv[0] = tokens_get_token(tokens, 0);
	    // 因为第一个参数肯定是自己的路径，已经算一个了
	    int argv_count = 1;
	    // 循环遍历tokens
	    for (int i = 1; i < tokens_get_length(tokens); i++)
	    {
			// 把获取到的token通过strdup复制一份，避免重复销毁
	        argv[i] = strdup(tokens_get_token(tokens, i));
	        argv_count++;
	    }
	    // 最后一个填NULL
	    argv[argv_count] = NULL;
	    // 传参运行
	    execv(argv[0], argv);
    }
    if (shell_is_interactive)
    {
        fprintf(stdout, "%d: ", ++line_num);
    }
    tokens_destroy(tokens);
}
// ...

// shell_program.c
// ...
// 传入的可以是相对路径也可以是完整路径
char *program_get_full_path(const char *path)
{
    char cwd[PATH_MAX];
    getcwd(cwd, sizeof(cwd));
    strcat(cwd, "/");
    // 判断完整路径
    if (access(path, F_OK) == 0)
    {
        return strdup(path);
    }
    // 判断path
    else
    {
        char *env_path = getenv("PATH");
        char full_path[PATH_MAX];
        if (env_path == NULL)
        {
            fprintf(stderr, "there is no PATH\n");
            return NULL;
        }
        char *path_copy = strdup(env_path);
        char *token = strtok(path_copy, ":");
        while (token != NULL)
        {
            full_path[0] = '\0';
            strcat(full_path, token);
            strcat(full_path, "/");
            if (access(strcat(full_path, path), F_OK) == 0)
            {
                return strdup(full_path);
            }
            token = strtok(NULL, ":");
        }
    }
    return NULL;
}
// ...

// ...
// 尝试获取文件的完整路径
argv[0] = program_get_full_path(tokens_get_token(tokens, 0));
// ...

// 通过解析token知道是否要重定向和重定向的文件路径
// 这里就不写这步的过程了
bool is_input_redirect;
bool is_output_redirect;
char input_file_path[PATH_MAX];
char output_file_path[PATH_MAX];
if (is_input_redirect)
{
	// 获取文件的fd
    int fd = open(input_file_path, O_RDONLY);
    if (fd < 0)
    {
        fprintf(stderr, "open input failed\n");
        return EXIT_FAILURE;
    }
    // 重定向，本质是复制一份fd作为标准输入
    dup2(fd, STDIN_FILENO);
    // 因为上面复制了一份，所以把这里创建的fd关闭即可
    close(fd);
}
// 下面的原理一样
if (is_output_redirect)
{
    int fd = open(output_file_path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd < 0)
    {
        fprintf(stderr, "open output failed\n");
        return EXIT_FAILURE;
    }
    dup2(fd, STDOUT_FILENO);
    close(fd);
}

pid_t pid = fork();
if(pid == 0)
{
	printf("child\n");
}
else
{
	printf("parent\n");
}

// 就是有几个 | 符号
int pipe_count;
// 管道们
int pipes[pipe_count][2];
// 初始化管道
for(int i=0; i<pipe_count; i++)
{
	pipe(pipes[i]);
}
pid_t child_pid;
// 表示执行到第几个pipe
int pipe_index;
// 子进程创建循环
for(...)
{
	child_pid = fork();
	if(child_pid == 0)
	{
		// ...
		if (pipe_index > 0)
        {
	        // 将自己的标准输入替换为上一个的输出
            dup2(pipes[pipe_index - 1][0], STDIN_FILENO);
	    }
        if (pipe_index < pipe_count)
        {
	        // 将自己的标准输出替换为下一个的输入
	        dup2(pipes[pipe_index][1], STDOUT_FILENO);
        }
        // 然后关闭所有的pipe，确保pipe里面干净
        program_close_all_pipe(pipes, pipe_count);
        // 下面会执行程序，然后子进程会退出
		// ...
	}
	//... 
	pipe_index++;
}
// 最后再关闭一次
program_close_all_pipe(pipes, pipe_count);
// 最后等待所有子进程完毕
waitpid(-child_pid, NULL, 0);

// 主进程信号初始化
void signal_main_init(void)
{
    signal(SIGINT, SIG_IGN);
    signal(SIGTSTP, SIG_IGN);
    signal(SIGTTOU, SIG_IGN);
}

// 子进程信号初始化
void signal_child_init(void)
{
    signal(SIGINT, SIG_DFL);
    signal(SIGTSTP, SIG_DFL);
    signal(SIGTTOU, SIG_DFL);
}

// 子进程创建循环
for(...)
{
	child_pid = fork();
	if(child_pid == 0)
	{
		// ...
        // 下面会执行程序，然后子进程会退出
		// ...
	}
	// 父进程设置子进程的进程组
	if (pipe_index == 0)
    {
        setpgid(child_pid, child_pid);
        pgid = child_pid;
    }
    else
    {
        setpgid(child_pid, pgid);
    }
    // ...
}

bool is_background;
for(...)
{
	child_pid = fork();
	if(child_pid == 0)
	{
		// ...
		// 这里的部分不重要
        // 下面会执行程序，然后子进程会退出
		// ...
	}
	// 父进程获取子进程组
	if (!is_background)
    {
        // 前台给到子进程组
        tcsetpgrp(STDIN_FILENO, pgid);
    }
    // ...
}

// 添加job类型
typedef struct
{
	// 记录pid
    pid_t pid;
    // 记录是否是后台任务
    bool is_background;
    // 保存当前终端设置
    struct termios termios;
} job;

// fg的核心函数
bool job_to_forground(job *job)
{
	// 实现无PID输入拉起最近的任务
    job = job == NULL ? recent_job : job;
    if (job->is_background == false)
    {
        return false;
    }
    // 转让前台
    tcsetpgrp(STDIN_FILENO, job->pid);
    // 恢复termios
    tcsetattr(STDIN_FILENO, TCSADRAIN, &job->termios);
    // 传递信号
    kill(job->pid, SIGCONT);
    job->is_background = false;
    // 等待这个子进程结束
    waitpid(job->pid, NULL, WUNTRACED);
    // 前台回到shell
    tcsetpgrp(STDIN_FILENO, getpgrp());
    return true;
}

// bg的核心函数
bool job_resume(job *job)
{
    job = job == NULL ? recent_job : job;
    // 传递信号
    kill(job->pid, SIGCONT);
    job->is_background = true;
    return true;
}
// 本身就是后台任务，也就没必要等待了