十七、文件和目录——minishell（1）

　　

　　主函数运行要去读取从标准输入或终端上输入的整个命令行，然后再去解析命令行参数，解析出来之后，要将其封装成一个 program，然后再将 program 放入 job 中，然后再去执行 job 中的命令行的内容。

17.1 job.o

　　job.h 文件

#ifndef __JOB_H__
#define __JOB_H__

typedef struct
{
    char **args; //shell 当中输入的命令参数;对应主函数中的 char *argv[] 参数
}Program;

//作业结构体，表示若干个要执行的参数
typedef struct
{
    char         *cmd;
    int         progs_num;
    Program     *progs;//Program 的结构体指针
}Job;

extern Job * create_job(char *cmd);
extern void destroy_job(Job *job);
extern Program* create_program(char **arg);//创建一个程序
extern void destroy_program(Program *prog);
extern int add_program(Job *job, Program *prog);//将程序加入到 job 中

#endif

　　job.c 文件

#include "job.h"
#include <malloc.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <memory.h>


/* 根据 commond 命令创建 job */
Job * create_job(char *cmd)
{
    Job *job = (Job *)malloc(sizeof(Job));
    assert(job != NULL);

    job->cmd = (char *)malloc(sizeof(char) * strlen(cmd));
    assert(job->cmd != NULL);

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

    return job;
}

void destroy_job(Job *job)
{
    assert(job != NULL);
    free(job->progs);
    free(job->cmd);
    free(job);
}

/* 统计命令行参数的个数 */
static int arg_num(char **arg)
{
    int i = 0;
    char *start = arg[0];

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

    return i;
}


/*
 *     函数功能：    构建一个 program
 *     函数参数：
 *         @arg：命令行传入的参数
 *     返回值：
 */
Program* create_program(char **arg)//创建一个程序
{
    //在堆当中创建 program 内存块
    Program *prog = (Program *)malloc(sizeof(Program));
    assert(prog != NULL);

    int counter = arg_num(arg);

    //多 new 一个空间存放 NULL ，所以 counter 要 +1
    prog->args = (char **)calloc(counter + 1, sizeof(char *));

    int i;
    for(i = 0; i < counter; i++) {
        int len = strlen(arg[i]);
        prog->args[i] = (char *)malloc(len);
        assert(prog->args[i] != NULL);
        strcpy(prog->args[i], arg[i]);
    }
    prog->args[i] = NULL;
    return prog;
}

void destroy_program(Program *prog)
{
    assert(prog != NULL);
    int i = 0;

    /* 命令行释放 */
    while(prog->args[i] != NULL) {
        free(prog->args[i]);
        i++;
    }
    free(prog->args);//数组释放
    free(prog);
}

/*    1.通过动态分配创建一个结构体数组
 *    2.将 job 中原先的 progs 复制给 ps 结构体数组
 *    3.在向 ps 结构体数组中加上新的 prog
 *    4.把  job 中原先的 progs 释放掉
 *    5.将 job 中的 progs 指向 ps
 */
int add_program(Job *job, Program *prog)//将程序加入到 job 中
{
    Program *ps = (Program *)malloc(sizeof(Program) * (job->progs_num + 1));//1 为NULL的初始化

    memcpy(ps, job->progs, job->progs_num * sizeof(Program));
    ps[job->progs_num++] = *prog;
    free(job->progs);
    job->progs = ps;
}

　　编译成 .o 文件

　　gcc -o obj/job.o -Iinclude -c src/job.c

17.2 命令行参数的解析

17.2.1 主函数

　　mshell.c

#include "job.h"
#include "cmd_func.h"
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <assert.h>
#include <malloc.h>

/* shell 中的提示符 */
char *prompt = "mshell > ";

/* 指定命令行中传递的最大命令行的长度 */
#define MAX_COMMAND_LEN 256


/* 对命令行进行解析 */
void parse_cmd(Job *job, char *line)
{
    char **args = (char **)malloc(100 * sizeof(char *));//创建的 program 里面的args
    assert(args != NULL);

    /* 分割命令行 */
    char *cmd = strtok(line, " ");
    args[0] = (char *)malloc(strlen(cmd) * sizeof(char)); //第一个参数为命令本身
    strcpy(args[0], cmd);

    int i = 1;
    char *s;
    while((s = strtok(NULL, " ")) != NULL) {
        args[i] = (char *)malloc(strlen(s) * sizeof(char));
        strcpy(args[i], s);
        i++;
    }

    //根据  args 创建 program
    Program * prog = create_program(args);
    add_program(job, prog);

    int j;
    for(j = 0; j < i; j++) {
        free(args[j]);
    }

    free(args);
}

/* 执行命令 */
void excute_cmd(Job *job)
{
    int i;
    for(i = 0; i < job->progs_num; i++) {
        if(!strcmp(job->progs[i].args[0], "cd")) {
            cd_func(&job->progs[i]);
            return;
        }

        if(!strcmp(job->progs[i].args[0], "pwd")) {
            pwd_func(&job->progs[i]);
            return;
        }

        if(!strcmp(job->progs[i].args[0], "exit")) {
            exit_func(&job->progs[i]);
            return;
        }
    }
}


int main(int argc, char *argv[])
{
    char buff[MAX_COMMAND_LEN];//存放从命令行中输入的整个命令行
    memset(buff, 0, MAX_COMMAND_LEN);
    ssize_t size = strlen(prompt) * sizeof(char);//提示符占用的总的大小

    write(STDOUT_FILENO, prompt, size);//输出 shell 的提示符

    ssize_t len;
    while(1) {
        /* 从标准输入读取命令行的内容 */
        len = read(STDIN_FILENO, buff, MAX_COMMAND_LEN);
        buff[len - 1] = 0; //结束符

        if(strlen(buff) > 0) {//命令行要大于0
            Job *job = create_job(buff);//创建 job

            parse_cmd(job, buff); //对命令行进行解析

            excute_cmd(job); // 执行命令
            destroy_job(job); // 销毁

        }

        write(STDOUT_FILENO, prompt, size);
        memset(buff, 0, MAX_COMMAND_LEN);
    }

    return 0;
}

17.2.2 命令功能函数

　　cmd_func.h

#ifndef __CMD_FUNC_H__
#define __CMD_FUNC_H__

#include "job.h"

#define BUFF_SIZE_256         256


extern void cd_func(Program *prog);
extern void pwd_func(Program *prog);
extern void exit_func(Program *prog);

#endif

　　cmd_func.c

#include "cmd_func.h"
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include "job.h"
#include <fcntl.h>
#include <string.h>
#include <unistd.h>

/* 切换目录 */
void cd_func(Program *prog)
{
    if(chdir(prog->args[1]) < 0) {
        perror("cd error");
    }
}

/* 显示当前工作目录路径 */
void pwd_func(Program *prog)
{
    char buff[256];
    memset(buff, 0, sizeof(buff));

    /* 获取当前工作目录的绝对路径 */
    if(getcwd(buff, sizeof(buff)) == NULL) {
        perror("pwd error");
    }

    printf("%s
", buff);
}

/* 退出 */
void exit_func(Program *prog)
{
    exit(0);
}

　　编译成.o 文件

　　gcc -o obj/cmd_func.o -Iinclude -c src/cmd_func.c

17.3 编译调试　　

　　gcc -o bin/mshell -Iinclude obj/*.o src/mshell.c