Linux.实现一个简单的shell

• fork & execve

---

Shell框架

• shell start and wait for inputing command and paraments
• identify the command
• cannot identify then print ‘bad command’ and go back to wait
• if exit then exit() shell
• else fork(), child execve() the Executable file, father wait() for the child

---

实现简单的命令

my_pwd

• print current working directory

/* 
 * my_pwd.c
 */
#include <unistd.h>
#include <stdio.h>

char curp[255];
void main(int argc,char *argv[])
{
   getcwd(curp,255);
   printf("PWD: %s\n",curp);
   return;
}

my_ls

• list the directory and regular file contained by the given directory
• support absolue path and relative path

/*
 * my_ls.c
 *
 */
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <string.h>
#include <dirent.h>
#include <stdlib.h>
...
char **pths = NULL;    //store the pathes to list
int pth_n = 0;         //the number of paths
...
int res = 0;
struct stat st_f;
DIR* dir = NULL;
struct dirent* dir_ent = NULL;
for(int i = 0; i < pth_n; ++i){
    char pth[255];
    if(pths[i][0] == '/')
        sprintf(pth,"%s",pths[i]);
    else // char cwd[255] & getcwd(cwd,sizeof(cwd))
        sprintf(pth,"%s/%s", cwd, pths[i]);

    res = stat(pth, &st_f);
    if(res < 0){
        printf("cannot stat path %s\n", pth);
        continue;
    }

    if(!S_ISDIR(st_f.st_mode)){
        printf("%s is not a directory\n", pth);
        continue;
    }else{
        dir = opendir( pth );
        if(dir == NULL)
            printf("cannot open ab_path %s\n", pth);

        dir_ent = readdir( dir );
        while( dir_ent != NULL ){
            //ignore ".." "." and ".*" which are hidden files
            if(dir_ent->d_name[0] == '.'){
                dir_ent = readdir( dir );
                continue;
            }

            if(dir_ent->d_type == DT_DIR)
                printf("d %s\n",dir_ent->d_name);
            else if(dir_ent->d_type == DT_REG)
                printf("r %s\n",dir_ent->d_name);

            dir_ent = readdir( dir );
        }
    }
 }

my_cd

• fork & execve cannnot change father process’s current working directory
• then chdir() should called by shell itself

/*
 * test_cwd.c
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

void main(int argc,char**argv)
{
    char cwd[255];
    int cwd_size = sizeof(cwd);
    printf("cwd_size = %d\n", cwd_size);
    getcwd(cwd, cwd_size);
    printf("riginal father cwd = %s\n", cwd );

    pid_t pid = fork();
    if(pid == 0){
        chdir("/home");
        getcwd(cwd, 255);
        printf("child cwd = %s\n", cwd );
    }
    else if(pid > 0){
        wait(pid);
        getcwd(cwd, 255);
        printf("father cwd = %s\n", cwd );
    }
}

---

MyShell Process

• void my_exec(char *filename) to fork & execve with the given filename, and father process should wait()
• int dispatch(char *input) to identify command and paraments, then store them(include cmd and paras) in char* cmd_paras[]
• void get_input(char *cmd) to read up to 255 charactors from user input

/*
 * my_shell.c
 */
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <pwd.h>
#include <sys/types.h>

char* cmd_set[] = {"exit","my_cd","my_ls","my_pwd"};
char* cmd_paras[MY_CMD_NUM];
int cmd_paras_n = 0;

char cwd[ MY_CWD_SIZE ];

void my_exec(char *path)
{
    int pid = fork();
    if(pid == 0)        execve(path, cmd_paras, env);
    else if(pid > 0){
        int status = 0;
        pid_t pidd = 0;
        pidd = wait(&status);
    }
    else if(pid < 0)    printf("fail to fork process.\n");
}

int dispatch(char *input)
{
    int ret = -1, res = 0;
...
    //cmd_paras[0] is the command
    //cmd_paras[1..n] are the paramenst
    //cmd_paras_n = n+1
    if(!strcmp(cmd_paras[0], cmd_set[0])) ret = 0;   //exit
    if(!strcmp(cmd_paras[0], cmd_set[1])){           //cd
        ret = 1;
        char dir[MY_CWD_SIZE];
        if(cmd_paras_n == 1){
            uid_t usrid = getuid();
            struct passwd* pwd = getpwuid(usrid);
            sprintf(dir, "/home/%s", pwd->pw_name);
        }
        else{
            char* new_cwd = cmd_paras[1];
            if(new_cwd[0] == '/') sprintf(dir, "%s", new_cwd);
            else sprintf(dir, "%s/%s", cwd, new_cwd);
        }
        res = chdir(dir);
        if(res < 0)printf("failed to change cwd to %s\n",dir);
        }
    if(!strcmp(cmd_paras[0], cmd_set[2])) ret = 2;  //ls
    if(!strcmp(cmd_paras[0], cmd_set[3])) ret = 3;  //pwd

    return ret;
}

void get_input(char *cmd)
{
    int i = 0;
    char c = getchar();
    while( c != '\n' && i < 255 ){
        cmd[ i++ ] = c;
        c = getchar();
    }
    cmd[ i ] = '\0';
}

void main(int argc,char **argv)
{
    char cmd[ MY_CMD_SIZE ];
    const char * cmd_path = "/home/niugen/LINUX_CLASS";

    int cmd_n = 0, loop = 1;

    char cmd_file[ MY_CMD_SIZE ];
    while(loop){
        getcwd(cwd, MY_CWD_SIZE);
        printf("MyShell@%s > ", cwd);
        get_input( cmd );

        cmd_n = dispatch( cmd );

        if(cmd_n < 0)printf("Bad Command.\n");    //bad command
        else if(cmd_n == 0) loop = 0;             //exit
        else if(cmd_n != 1){                      //not 'cd'
            sprintf(cmd_file,"%s/%s", cmd_path, cmd_paras[0]);
            my_exec(cmd_file);
        }
    }
}