- 在Linux系统中，shell是我们每天经常使用的东西，而如何实现一个自己的shell？首先我们需要了解一些基础知识
一.进程基础知识
进程概述: CPU执行的程序，是一个动态的实体，进程是操作系统资源分配的基本单位。
进程和程序的区别在于进程是动态的，程序是静态的，进程是运行中的程序
linux 下可通过ps命令来实现查看
Linux中一个进程由三部分组成，代码段，数据段和栈堆端。代码段存放程序的全局变量，常量，静态变量。堆栈段中的堆用于存放动态分配的全局变量,堆栈中栈用于函数调用，它存放着函数的参数，函数内部定义的局部变量
Linux中的进程控制，系统提供了一些函数可以使用:
- fork用于创建一个新进程
- exit用于终结进程
- wait将父进程挂起，等待子进程的终结
- getpid 获取当前进程的PID
- nice改变进程的优先级
进程分为几种不同的状态，运行状态，可中断状态，不可中断状态，僵尸进程，停止进程
2.还有几种特殊的进程
孤儿进程: 如果一个子进程的父进程先与子进程结束，子进程就成为一个孤儿进程
守护进程:在后台运行的，没有控制终端与之相连的进程，它独立于控制终端，周期性的执行某些任务
二.进程的内存映像
我们在linux平时见到的程序，他们是如何转化为进程的？
通常需要如下几个步骤
- 内核将程序读入内存，为程序分配内存空间
- 内核为该进程分配了进程标识符（PID）和其他所需资源
- 内核为该进程保存了PID及其相应的状态信息，把程序放进队列种等待执行，这样就可以被操作系统的调度程序执行了
2.进程的内存映像
进程的内存映像是指的内核在内存中如何存放可执行程序文件，在将程序转化为进程的过程中，把硬盘复制给内存之中
，而在实现自己的shell中就使用到这一概念,可执行程序位于磁盘中，而内存映像在内存之中，内存映像随着程序的执行在动态变化中
三.实现myshell所涉及到的部分函数的用法
1.fork函数
fork函数是创建子进程的方式.
include< stdio.h>
include < unistd.h>
pid _t fork (void);
使用fork函数可以将当前进程分裂为两个进程，但是不同的是fork函数有两个返回值,一个是父进程调用fork的返回值,一个是子进程中fork函数的返回值
2.vfork函数
vfork函数与fork函数的不同是什么?
他们的基本用法是相同的，也有一些地方有一些不同，
- vfork和fork一样都是调用一次，返回两次
- 使用fork创建一个子进程之后，子进程会继承父进程的资源，具有良好的并发性，而vfork创建的子进程会共享父进程的地址空间,子进程对该地址空间中任何数据的修改都会被父进程所看到
- vfork函数，一般是子进程先执行，之后父进程才进行执行
3.进程退出
LInux中进程退出分为两种,正常退出和异常退出
(1) 正常退出
在main函数中执行return
调用exit函数
调用_exit函数
而exit和_exit函数有什么区别尼，exit函数在结束时会清除缓冲区中的内容，而_exit会交给内核处理，直接关闭
(2) 异常退出
调用abort函数
进程收到某种信号，而信号会让程序停止
注:尽量减少僵尸进程的产生,应该合理的使用wait/waitpid函数，来让父进程等待子进程的结束
4.执行程序
很多小伙伴看到这里应该就很好奇，如何执行进程?
在这里给大家介绍一个函数族 exec族身为地字一号的重要人物，其作用是十分广阔的
原理:使用exec族执行一个可执行的文件来代替当前进程的内存映像
exec的族的使用并没有产生新的进程哦，而是把程序的代码换入，重新分贝数据段和栈堆段.
exec族的成员如下
#include <unistd.h>
extern char **environ;
int execl(const char *path, const char *arg, ...
/* (char *) NULL */);
int execlp(const char *file, const char *arg, ...
/* (char *) NULL */);
int execle(const char *path, const char *arg, ...
/*, (char *) NULL, char * const envp[] */);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[],
char *const envp[]);
我在这里使用到了execvp，在这里介绍以下它的用法吧,
它的参数中的filename，如果其中包含了"/“的话，相当于路径，不包含的话”/",函数就到环境变量中PATH来寻找
4.等待进程结束
这点是必要的，不然会造成僵尸进程的产生
#include<sys/types.h>
#include<sys/wait.h>
pid_t wait（int *statloc)
pid_t waitpid (pid_t pid, int * statloc , int options)
wait函数让父进程暂停执行，直到它的一个子进程结束为停止
状态信息将会被写入到statloc
waitpid 函数也用来等待子进程的结束，但是它有特定的要求pid需指定要等待的子进程的pid
5.strtok函数(我用来解析命令行参数)
该函数包含在"string.h"头文件中
函数原型：
char* strtok (char* str,constchar* delimiters );
函数功能：
切割字符串，将str切分成一个个子串
函数参数：
str：在第一次被调用的时间str是传入需要被切割字符串的首地址；在后面调用的时间传入NULL。
delimiters：表示切割字符串（字符串中每个字符都会 当作分割符）。
函数返回值：
当s中的字符查找到末尾时，返回NULL;
如果查不到delimiter所标示的字符，则返回当前strtok的字符串的指针。
注：strtok函数遇到NULL就会结束
如何实现重定向?
标准输入stdin——-需要处理的数据流
标注输出stdout——–结果数据流
标准错误输出stderr—–错误消息流
默认的三个数据流的文件描述符分别为0，1，2，默认的标准输入为终端键盘IO，标准输出和错误输出都是为终端屏幕。而IO重定向就是将三个数据流定向到别的文件描述符。
最低可用文件描述符
什么是文件描述符？ 简单来说就是打开文件的一个索引号。Unix系统中，把打开文件保持在一个数组中，文件描述符即为某文件在此数组中的索引。而最低可用文件描述符的意思就是，每当系统打开一个新文件，则分配一个目前可用的最小的文件描述符用于该文件。每个Unix程序默认打开0，1，2三个文件描述符，其实它们对应的文件就是键盘设备和终端屏幕设备的设备文件。
系统调用dup函数
int dup(int oldfd);
dup函数的作用是复制oldfd文件描述符给一个最低可用文件描述符。如果我们想将标准输入重定向到新的文件描述符fd，那么我们可以先close(0)关闭标准输入文件描述符，然后调用函数dup(fd)，系统则会默认使用最低可用文件描述符指向fd文件描述符对应的文件。最后再关闭fd文件描述符就完成了IO重定向，如下图所示
那具体是如何实现的? 关键就在于fork和exec函数之间，exec函数的功能只是利用了磁盘的新程序代替了当前进程的正文段，数据段，堆段和栈段，文件描述符是继承的，除非通过fcntl函数设置了执行时关闭标志.
我们可以在fork函数之后，exec函数之前进行IO重定向.
管道
管道是Unix系统进程通信的一种形式。管道有两个特点:
一般管道的数据只能在一个方向上流动
管道只能在具有公共祖先的两个进程之间使用。通常管道由一个父进程创建，调用fork函数后，这个管道就能在父进程和子进程之间使用了
管道是通过调用pipe函数创建，参数是一个大小为2的int数组，由该参数返回两个文件描述符:fd[0]为读打开，fd[1]为写打开。即fd[1]的输出是fd[0]的输入
#include< unistd.h>
#int pipe(int fd[2]);
使用fork函数创建新进程时，也会将父进程的管道复制，就像这样:
四.代码
//添加颜色使用命令别名，alias查看
//对于指针数组不能使用strcpy来进行添加 直接衡等就可
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <dirent.h>
#include <signal.h>
#include <ctype.h>
#include <string.h>
#include <pwd.h>
#include <wait.h>
#include <readline/history.h>
#include <readline/readline.h>
#define MAXARGS 20
#define ARGLEN 60
int i;
struct parameter
{
int normal; //一般命令
int out_redirect; //输出重定向 >
int in_redirect; //输入重定向 <
int have_pipe; //命令中由管道符号
int backgroud; //标识命令有没有重定向
int out_redirects; // >>
};
char oldpwd[300][300];
int o;
struct parameter param;
//cd内置命令
void shell_cd(char *path[]);
void find_command(char *path[]);
void get_ifnput(char *buf)
{
struct passwd *name; ///头文件在pwd.h之中，需要添加
name = getpwuid(getuid());
char pwd[100] = {0};
getcwd(pwd, sizeof(pwd) - 1); //保存绝对路径
int len = strlen(pwd);
char *p = pwd + len;
char temp[MAXARGS * ARGLEN];
int pathlen;
char *isstarm;
while (*p != '/' && len--) //把当前目录从后往前遍历
{
p--;
}
p++;
sprintf(temp, "[%s @myshell %s] :", name->pw_name, p);
isstarm = readline(temp);
add_history(isstarm);
write_history(NULL);
pathlen = strlen(temp);
if (pathlen == MAXARGS * ARGLEN)
{
perror("too long");
exit(-1);
}
strcpy(buf, isstarm);
//buf[pathlen]='\n';
buf[pathlen++] = '\0';
if(strcmp(buf,"")==0)
strcpy(buf,"\n");
free(isstarm);
}
//解析命令行参数
void explain(char *buf, char *list[256])
{
i = 0;
char *p = buf;
while (1)
{
if (strcmp(buf, "cd") == 0)
{
strcat(buf, " ~");
}
if((strcmp(buf,"ll"))==0)
{
strcpy(buf,"ls -l --color=auto");
}
if (p[0] == '\n')
break;
if (p[0] == ' ')
p++;
else
{
list[i] = strtok(buf, " "); //将他们的空格分开i
if(strcmp(list[i],"ls")==0)
{
list[i+1]="--color=auto";
i++;
}
i++;
while ((list[i] = strtok(NULL, " ")) != NULL && strcmp(list[i], "\n") != 0)
{ //在这里需要注意strtok的返回值为NULL
if(strcmp(list[i],"grep")==0)
{
list[i+1]="--color=auto";
i++;
}
i++;
}
}
if (list[i] == NULL)
{
break;
}
}
}
void recover_stdio() //dev/tty是终端控制台
{
int ttyfd;
ttyfd = open("/dev/tty", O_RDONLY);
//付给他标准输出和输出和报错
dup2(ttyfd, 0);
dup2(ttyfd, 1);
dup2(ttyfd, 2);
}
//标准的输入输出流分为三种
//>>函数可使用O_APPEND标识符来进行追加操作
void output_redirce(char *filename, int mode)
{
if (filename == NULL)
return;
int fd;
if (mode == 1)
fd = open(filename, O_RDWR | O_APPEND | O_CREAT, 0644);
else
fd = open(filename, O_WRONLY | O_CREAT, 0644);
if (fd < 0)
perror("open error");
dup2(fd, 1);
close(fd);
return ;
}
static void intput_redirce(char *filename)
{
int fd;
fd = open(filename, O_RDWR);
if (fd < 0)
perror("< error");
dup2(fd, 0);
close(fd);
return;
}
//因为将命令传递给execv函数需要去掉
//执行命令
void do_cmd(char *list[])
{
param.backgroud = 0;
//如果命令中有&,表示后台运行,父进程直接返回,不等子进程，
int status;
int mode = 0;
pid_t pid;
int j = 0;
int flag = 0; //标记有没有特殊字符，比如重定向或者&
int pid_flag=0;
//查看有没有后台运行程序
for (j = 0; j < i; j++)
{
if (strncmp(list[j], "&", 1) == 0)
{
if (j <= i - 1)
{
param.backgroud = 1;
break;
}
if (j > i - 1)
{
perror("Wrong command\n");
return;
}
}
if (strcmp(list[j], "|") == 0)
{
flag = 1;
pid_flag = 1;
int pipe_fd[2]; //使用pipe函数构建管道
int pipstatuts;
pid_t child, child2;
pipe(pipe_fd);
char *file[256];
*file = (char *)malloc(256);//指针数组跟二维数组不同
memset(file,0,sizeof(file));
int k=0,n=0,file_flag=0,l;
for(k=j+1;k<i;k++)
{
file[n] = list[k];
if(strcmp(file[n],">")==0)
{
file_flag = 1;
file[n] = NULL;
l=n;
n++;
continue;
}
if(strcmp(file[n],">>")==0)
{
file_flag = 2;
file[n]=NULL;
l=n;
n++;
continue;
}
if(strcmp(file[n],"<")==0)
{
file_flag = 3;
file[n]=NULL;
l=n;
n++;
continue;
}
n++;
}
if ((child = fork()) != 0) //函数的父进程
{
if ((child2 = fork()) == 0) //子进程
{
close(pipe_fd[1]); //关闭写端，管道第一个命令需要读入
close(fileno(stdin)); //关闭输入
dup2(pipe_fd[0], fileno(stdin));
close(pipe_fd[0]); //读端结束关闭，防止影响别的*/
list[j]=NULL;
file[n] = NULL;
if(file_flag == 1)
output_redirce(file[l+1], mode);
if(file_flag ==2)
output_redirce(file[l+1], 1);
if(file_flag == 3)
intput_redirce(file[l+1]);
execvp(file[0],file);
exit(0);
}
else //在这里child2的父进程迟缓
{
close(pipe_fd[0]);
close(pipe_fd[1]);
waitpid(child2, &pipstatuts, 0);
}
waitpid(child, &pipstatuts, 0);
}
else
{
close(pipe_fd[0]); //写数据
close(fileno(stdout)); //关闭读端
dup2(pipe_fd[1], fileno(stdout));
close(pipe_fd[1]);
list[j] = NULL;
execvp(list[0], list);
exit(0);
}
param.have_pipe = 3;
break;
}
if (strcmp(list[j], ">") == 0)
{
flag = 1;
pid = fork();
if (pid == 0)
{
param.out_redirect = 1;
list[j] = NULL;
output_redirce(list[j + 1], mode);
find_command(list);
exit(0);
}
break;
}
if (strcmp(list[j], "<") == 0)
{
flag = 1;
pid = fork();
if (pid == 0)
{
param.in_redirect = 1;
list[j] = NULL;
intput_redirce(list[j + 1]);
find_command(list);
exit(0);
}
break;
}
if (strcmp(list[j], ">>") == 0)
{
flag = 1;
pid = fork();
if (pid == 0)
{
param.out_redirects = 1;
list[j] = NULL;
output_redirce(list[j + 1], 1);
find_command(list);
exit(0);
}
break;
}
if (strcmp(list[j], "&") == 0)
{
param.backgroud = 1;
}
}
if (flag == 0 && param.backgroud == 0)
{
pid = fork();
if (pid == 0)
{
find_command(list);
exit(0);
}
}
if (param.backgroud == 1) //如果命令中有后台执行的程序
{
pid = fork();
printf("process id %d\n",pid);
return;
}
if(pid_flag == 0)
{
if (waitpid(pid, &status, 0) == -1)
{
printf("wait for child process error\n");
}
}
}
void showhistroy()
{
read_history(NULL);
HIST_ENTRY **history;
history = history_list();
int k = 0;
while (history[k] != NULL)
{
printf("%s\n", history[k]->line);
k++;
}
}
//查找命令中的可执行命令，在这里应该fork一个子进程让它在后台，不断工作到终止
//不然的话执行一个进程就会死掉
void find_command(char *path[])
{
int pid;
int child_info = -1;
if (*path == NULL)
return;
if (strcmp(*path, "exit") == 0 || strcmp(*path, "logout") == 0)
exit(0);
if ((pid = fork()) == -1)
perror("fork");
else if (pid == 0)
{
execvp(path[0], path);
}
else
{
if (wait(&child_info) == -1)
perror("wait");
}
return;
}
//cd内置命令
void shell_cd(char *path[])
{
struct passwd *usrname; ///头文件在pwd.h之中，需要添加
usrname = getpwuid(getuid());
if (strcmp(path[1], "~") == 0)
{
if (strcmp(usrname->pw_name, "kiosk") == 0)
{
strcpy(path[1], "/home/kiosk/");
}
if (strcmp(usrname->pw_name, "root") == 0)
{
strcpy(path[1], "/root/");
}
}
if (strcmp(path[1], "-") == 0)
{
strcpy(path[1], oldpwd[o]);
}
getcwd(oldpwd[o], sizeof(oldpwd[o]) - 1); //保存绝对路径
//printf("%s\n",oldpwd[o]);
o++;
if (chdir(path[1]) < 0) //chdir可以改变当前的工作目录，fchdir用来将当前目录改为由文件描述符所指定的目录
{
printf("%s\n",path[1]);
perror("cd");
}
}
int main(int argc, char **argv)
{
char *buf = NULL;
buf = (char *)malloc(MAXARGS * ARGLEN);
char *list[256];
*list = (char *)malloc(256);
if (buf == NULL)
{
perror("malloc failed");
exit(-1);
}
signal(SIGINT, SIG_IGN);//屏蔽掉信号,ctrl+c
signal(SIGQUIT, SIG_IGN);
signal(SIGSTOP, SIG_IGN);//ctrl+z发出信号
signal(SIGTSTP, SIG_IGN);
while (1)
{
memset(buf, 0, 1200);
memset(list, 0, sizeof(list));
get_ifnput(buf);
if (strcmp(buf, "exit") == 0 || strcmp(buf, "logout") == 0)
break;
if (strcmp(buf,"\n") == 0 )
continue; //多个回车
explain(buf, list);
if (strcmp(list[0], "cd") == 0)
{
shell_cd(list);
continue;
}
if (strcmp(list[0], "history") == 0)
{
showhistroy();
continue;
}
do_cmd(list);
}
free(buf);
for (i = 0; i < 256; i++) //将二位数组进行释放
free(list[i]);
exit(0);
}