Shell实现1.0

　　今天的任务是实现Linux 下shell 界面的实现。

　　我们知道，Linux 下的外部命令是bash进程通过生成出子进程去调用bin/bash 下的相关命令来执行的。

　　我们根据这一特性，对stdin 端输入的字符获取并剖析。

 

　　每次获取字符串，先剖析字符串，将其中用于分割的空格都变成 '\0' 并且将字符串的内容拆分成多个字符串装入到一个包含多个字符串的数组中（我们设定数组最大成员个数为8）

　　

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <ctype.h>
#include <myerr.h>

int main()
{
    char buf[1024];

    while(1){
        memset(buf,0,sizeof(buf));
        printf("[ root@localhost file ]#");
        scanf("%[^\n]",buf);
        getchar();
        if(strncmp(buf,"exit",4) == 0)
            err_quit(NULL);
        //read buf
        else
            do_parse(buf);

    }
    return 0;
}

 

　　第二步，定义字符串剖析函数。

　　将函数装入argv[8] 数组中，然后调用execvp 函数。

　　让我看一下execvp 函数的相关信息：

　　

　　exec 的作用就是让当前进程直接跳转至其他函数，用一个新的进程（映像）替代现有的进程（映像）。

　　Linux下的字母都可以很好的做出引申并理解——

　　首先可以看到两个函数名中带 p 的函数，其意思为：函数会在PATH所指的目录下直接寻找相关命令。所以，如果函数名中不带有 p ，意为要输入的是绝对地址（相对地址）。

　　其次可以看到两个函数名中带有 e ，e 可以直译为 envp ----环境变量，也就是说，在跳转时要加上环境变量相关的参数。

　　最后可以看到一般函数是 v 一般函数是 l ，v 即 vector 可以理解成数组（浅），即传参以数组形式传，l 即 list 可以理解成链表（浅），即传参以多个独立的字符串传递。

 

void do_parse(char* buf)
{
    int argc = 0;
    char* argv[8];
    int IsNeedMoveFile = 0;//表示发现'>'的个数
    int TheTransferFile = 0;//内容转移的位置。
    
    //修改命令行。
    //暂时只考虑一个>的情况，不考虑 >>
    //这里需要改变argc IsNeedMoveFile TheTransferFile的值，所以要传地址
    AlterBuf(buf,argv,&argc,&IsNeedMoveFile,&TheTransferFile);

    //判断'>'的特殊情况
    if(1 == Judge_Rediect(argv,argc,IsNeedMoveFile,TheTransferFile) )
        return;
    
    //开始跑程序
    Run_ThisProgress(argv ,argc ,IsNeedMoveFile ,TheTransferFile);
    
    int i = 0;
    for(i=0;i<argc;i++){
        printf("%s ",argv[i]);
    }
    printf("\n");
}

 

 　　在Myshell 实现1.0版本下，我加入了文件重定向符的判断和异常分析。

　　以下是字符串转换函数的源码：

void AlterBuf(char *buf,char *argv[],int* argc,int* IsNeedMF,int* TheFile)//需要改变，所以传指针
{
    int i = 0;
    int status = 0;//0--空格 1--字符 
    while(buf[i]!='\0')
    {
        // is '>'
        if(buf[i] == '>' && isspace(buf[i+1]) && status == 0)
        {
            if (0 == i)
                err_quit("write in error!\n");
            else{
                argv[(*argc)] = NULL;
                (*argc)++;
                *TheFile = *argc;
                (*IsNeedMF) += 1;
            }
        }
        //space->char
        else if(!isspace(buf[i])&&status == 0){
            argv[(*argc)] = &buf[i];
            status = 1;
            (*argc)++;
        }
        //is space
        else if(isspace(buf[i]))
        {
            status = 0;
            buf[i] ='\0';
        }

        i++;
    }
}

 

 　　以下是文件重定向符 ‘>’ 的异常判断：

 

int Judge_Rediect(char *argv[],int argc,int IsNeedMF,int TheFile)
{
    //没有标识符'>'
    //no '>'
    if(TheFile == 0 || IsNeedMF == 0)
        argv[argc] = NULL;

    //有多个'>'标识符
    //have more than one '>'
    else if(IsNeedMF > 1){
        err_msg("write in error!\n");
        return 1;
    }
    //有'>'却无文件
    else if(IsNeedMF == 1 && TheFile == argc)
    {    
        err_msg("The file can not be nameless!\n");
        return 1;
    }
    //不止一个文件
    else if(IsNeedMF == 1 && (TheFile + 1) != argc)
    {
        int j = 0;
        for(j = TheFile + 1;j <= argc;j++){
            err_msg("The file %s is needless!\n",argv[j]);    
        }
        err_msg("Leave The Procedure!\n");
        return 1;
    }

    return 0;
}

 

　　处理完异常，最后是运行程序的代码：

 

//文件重定向实现

void Run_ThisProgress(char *argv[],int argc,int IsNeedMF,int TheFile)
{
    if(argc != 0)
    {
        //让子进程去执行shell指令
        if(fork() == 0){
            //有 '>' 文件重定向
            if(IsNeedMF == 1)
            {
                close(1);
                open(argv[TheFile],O_RDWR | O_CREAT,0644);
            }
            if(-1 == execvp(argv[0],argv))
                err_msg("Pid Exec failed!\n");
        }

        wait(NULL);
    }    
}