【Linux】自定义shell（讲解原理）

  
一、打印命令提示符和获取命令行命令字符串

1.1 设计

我们首先使用操作体系的bash看到了命令行提示符的组成为[用户名@主机名 当前工作目次]$，获取用户名、主机名和当前工作目次的函数在体系调用中都有，这里我们自己设计一个，这三个数据都是环境变量，我们可以通过getenv来获取到他们，获取后将他们按照操作体系bash的格式输出出来即可，通过下图我们可以发现，我们的当前工作目次与操作体系的有所区别，我们的当前工作目次是一条路径，可以通过裁剪得到与操作体系一样的效果，我这里为了区分与操作体系的区别，这里就不做裁剪了。

输出完命令行提示符后，就必要向bash中输入命令了，这里我们就必要一个输入函数来读取命令字符串，必要注意的是这里不能使用scanf函数，因为scanf函数不能读取空格之后的内容，可以选择gets/fgets函数来读取，当我们输入完命令字符串后必要按回车，那么获取到的字符串中也会获取到这个’\n’，所以我们还必要将这个’\n’处理掉。

1. #include <stdio.h>
2. #include <string.h>
3. #include <stdlib.h>
5. #define NUM 1024
7. const char* getUsername()
8. {
9.     char* username = getenv("USER");
10.     if(username)
11.         return username;
12.     else
13.         return "none";
14. }
16. const char* getHostname()
17. {
18.     char* hostname = getenv("HOSTNAME");
19.     if(hostname)
20.         return hostname;
21.     else
22.         return "none";
23. }
26. const char* getCwd()
27. {
28.     char* cwd = getenv("PWD");                                                                                                               
29.     if(cwd)                                                                                                                                 
30.         return cwd;                                                                                                                                      
31.     else                                                                                                                                    
32.         return "none";     
33. }
35. int main()  
36. {
37.     char usercommand[NUM];
38.     printf("[%s@%s %s]# ",getUsername(),getHostname(),getCwd());
39.    
40.     // scanf("%s",usercommand); scanf读到空格就会自动停止，所以这里不使用scanf
41.     fgets(usercommand,sizeof(usercommand),stdin);
42.     // 读取字符串时，会自动获取到'\n'，我们需要将这个'\n'去掉
43.     usercommand[strlen(usercommand)-1] = '\0';
45.         // 用于测试输入的字符串是否符合我们的预期
46.     printf("%s",usercommand);
48.     return 0;
49. }

复制代码

---

1.2 封装

这里将打印命令行提示符与获取命令行字符串的工作统一封装到getUserCommand这个函数中。

1. int getUserCommand(char* command , int num)   
2. {   
3.     printf("[%s@%s %s]# ",getUsername(),getHostname(),getCwd());   
4.         
5.     // scanf("%s",usercommand); scanf读到空格就会自动停止，所以这里不使用scanf   
6.     char* r = fgets(command,num,stdin);   
7.     if(r == NULL) return -1;  // 读取失败返回-1   
8.    
9.     // 读取字符串时，会自动获取到'\n'，我们需要将这个'\n'去掉   
10.     command[strlen(command)-1] = '\0';   
11.     // 由于读入字符串时，必定会有一个\n所以这么不可能会越界                                                                                            
12.                               
13.     // 用于测试输入的字符串是否符合我们的预期
14.     printf("%s",command);
15.    
16.     return 1;                 
17. }
19. int main()
20. {
21.     char usercommand[NUM];
22.    
23.     getUserCommand(usercommand,NUM);
25.     return 0;
26. }

复制代码

---

二、分割字符串

2.1 设计

当我们获取到了命令字符串后，必要将字符串以空格为分隔符将字符串分割为子字符串，并将每一个子字符串的地址存入到一个指针数组中，这里给出一个字符串被分割的例子："ls -l -a" -> "ls" "-l" "-a"。我们可以使用strtok函数来将字符串分割，使用strtok函数处理同一个字符串时，第一次必要传入字符串的地址，后面再次调用则只必要传入NULL即可。

1. #include <stdio.h>
2. #include <string.h>
3. #include <stdlib.h>
5. #define NUM 1024                    
6. #define SIZE 64     
7. #define SEP " "
9. const char* getUsername()
10. {
11.     char* username = getenv("USER");
12.     if(username)
13.         return username;
14.     else
15.         return "none";
16. }
18. const char* getHostname()
19. {
20.     char* hostname = getenv("HOSTNAME");
21.     if(hostname)
22.         return hostname;
23.     else
24.         return "none";
25. }
28. const char* getCwd()
29. {
30.     char* cwd = getenv("PWD");                                                                                                               
31.     if(cwd)                                                                                                                                 
32.         return cwd;                                                                                                                                      
33.     else                                                                                                                                    
34.         return "none";     
35. }
38. int main()  
39. {                                                                                                                                                        
40.     while(1)  
41.     {         
42.         char usercommand[NUM];  
43.         char* argv[SIZE];      
44.                                 
45.         int x = getUserCommand(usercommand,NUM);  
46.                                                   
47.         if(x == -1) continue;                                
48.                                     
49.         int argc = 0;               
50.         argv[argc++] = strtok(usercommand,SEP);  
53.         while(argv[argc++] = strtok(NULL,SEP));         
54.         // strtok函数分割失败时会返回NULL，正好是我们字符串数组结尾所需要的   
55.             // 所以分割的方式可以使用赋值作为循环判断条件进行循序   
56.             // 若是大家不习惯可以使用下面这一种分割方式   
57.            
58.         // while(argv[argc++] = strtok(NULL,SEP));  
59.         // while(1)                                    
60.         // {                                          
61.         //     argv[argc] = strtok(NULL,SEP);         
62.         //     if(argv[argc] == NULL)                  
63.         //         break;                     
64.         //     argc++;                        
65.         // }                                   
66.                                     
67.         for(int i = 0 ; argv[i] ; i++)  
68.         {                              
69.             printf("%d : %s \n",i,argv[i]);  
70.         }                                    
71.     }
72.     return 0;
73. }

复制代码

---

2.2 封装

1. void SplitCommand(char* in , char* out[])      
2. {      
3.     int argc = 0;      
4.    
5.     out[argc++] = strtok(in,SEP);      
6.    
7.     while(out[argc++] = strtok(NULL,SEP));        
8.     // strtok函数分割失败时会返回NULL，正好是我们字符串数组结尾所需要的   
9.     // 所以分割的方式可以使用赋值作为循环判断条件进行循序   
10.     // 若是大家不习惯可以使用下面这一种分割方式   
11.                                                                                                                                                       
12.     // while(1)   
13.     // {   
14.     //     out[argc] = strtok(NULL,SEP);   
15.     //     if(out[argc] == NULL)                                                                                                              
16.     //         break;   
17.     //     argc++;                                                                                                                           
18.     }                                                                                                                                                  
19.                                                                                                                                            
20. // 用于测试字符串是否被分割                                                                                                                                             
21. #ifdef debug
22.      for(int i = 0 ; out[i] ; i++)                                                                                                         
23.      {                                                                                                                                      
24.          printf("%d : %s \n",i,out[i]);                                                                                                     
25.      }        
26. #endif                                                                                                                                    
27. }                                                                                                                                          
28.                                                                                                                                           
29. int main()                                                                                                                                 
30. {                                                                                                                                          
31.     while(1)                                                                                                                              
32.     {                                                                                                                                      
33.         char usercommand[NUM];                                                                                                            
34.         char* argv[SIZE];   
35.             
36.         int x = getUserCommand(usercommand,NUM);   
37.    
38.         SplitCommand(usercommand,argv);
39.     }
40.     return 0;
41. }

复制代码

---

三、执行指令

3.1 设计

将命令字符串分割后，就必要执行命令了，我们知道bash必要一直运行，这里添加一个循环让他一直运行，我们可以使用前面学习过的进程替换来执行命令，但是不能使用当前进程来进程替换，当前进程还必要继承运行，所以我们可以创建一个子进程来执行命令，由于我们将字符串分割为子字符串存储在了指针数组中，这里可以使用execvp函数来进行进场替换。

1. #include <stdio.h>
2. #include <string.h>
3. #include <stdlib.h>
4. #include <unistd.h>
5. #include <sys/types.h>
6. #include <sys/wait.h>
8. #define NUM 1024
9. #define SIZE 64
10. #define SEP " "
11. #define debug 1
13. const char* getUsername()
14. {
15.     char* username = getenv("USER");
16.     if(username)
17.         return username;
18.     else
19.         return "none";
20. }
22. const char* getHostname()
23. {
24.     char* hostname = getenv("HOSTNAME");
25.     if(hostname)
26.         return hostname;
27.     else
28.         return "none";
29. }
31. const char* getCwd()
32. {
33.     char* cwd = getenv("PWD");                                                                                                               
34.     if(cwd)                                                                                                                                 
35.         return cwd;                                                                                                                                      
36.     else                                                                                                                                    
37.         return "none";     
38. }
40. int getUserCommand(char* command , int num)   
41. {   
42.     printf("[%s@%s %s]# ",getUsername(),getHostname(),getCwd());   
43.         
44.     // scanf("%s",usercommand); scanf读到空格就会自动停止，所以这里不使用scanf   
45.     char* r = fgets(command,num,stdin);   
46.     if(r == NULL) return -1;  // 读取失败返回-1   
47.    
48.     // 读取字符串时，会自动获取到'\n'，我们需要将这个'\n'去掉   
49.     command[strlen(command)-1] = '\0';   
50.     // 由于读入字符串时，必定会有一个\n所以这么不可能会越界   
52.         // 用于测试输入的字符串是否符合我们的预期
53.     // printf("%s",command);                                                                                       
54.                               
55.     return 1;                 
56. }
58. void SplitCommand(char* in , char* out[])      
59. {      
60.     int argc = 0;      
61.    
62.     out[argc++] = strtok(in,SEP);      
63.    
64.     while(out[argc++] = strtok(NULL,SEP));        
65.     // strtok函数分割失败时会返回NULL，正好是我们字符串数组结尾所需要的   
66.     // 所以分割的方式可以使用赋值作为循环判断条件进行循序   
67.     // 若是大家不习惯可以使用下面这一种分割方式   
68.                                                                                                                                                       
69.     // while(1)   
70.     // {   
71.     //     out[argc] = strtok(NULL,SEP);   
72.     //     if(out[argc] == NULL)                                                                                                              
73.     //         break;   
74.     //     argc++;                                                                                                                           
75.     }                                                                                                                                                  
76.                                                                                                                                            
77.                                                                                                                                              
78. #ifdef debug
79.      for(int i = 0 ; out[i] ; i++)                                                                                                         
80.      {                                                                                                                                      
81.          printf("%d : %s \n",i,out[i]);                                                                                                     
82.      }        
83. #endif                                                                                                                                    
84. }  
86. int main()                                                                                                                                 
87. {                                                                                                                                          
88.     while(1)                                                                                                                              
89.     {                                                                                                                                                  
90.         char usercommand[NUM];                                                                                                            
91.         char* argv[SIZE];   
92.         // 打印命令提示符和获取命令行命令字符串   
93.         int x = getUserCommand(usercommand,NUM);   
94.    
95.         if(x <= 0) continue;   
96.             // 分割命令字符串
97.         SplitCommand(usercommand,argv);
99.         pid_t id = fork();
101.         if(id < 0) return -1;
102.         else if(id == 0)
103.         {
104.             execvp(argv[0],argv);
105.             // 若替换失败则子进程退出
106.             exit(-1);
107.         }
108.         else
109.         {
110.             pid_t rid = wait(NULL);
111.             if(rid>0){};      
112.         }
114.     }
115.     return 0;
116. }

复制代码

---

3.2 封装

1. int execute(char* argv[])
2. {
3.     pid_t id = fork();
5.     if(id < 0) return -1;
6.     else if(id == 0)
7.     {   
8.         execvp(argv[0],argv);   
9.         // 若替换失败则子进程退出   
10.         exit(-1);   
11.     }   
12.     else   
13.     {   
14.         pid_t rid = wait(NULL);   
15.         if(rid>0){};     
16.     }   
17.     return 0;   
18. }   
20. int main()   
21. {   
22.     while(1)   
23.     {   
24.         char usercommand[NUM];   
25.         char* argv[SIZE];   
26.         // 打印命令提示符和获取命令行命令字符串        
27.         int x = getUserCommand(usercommand,NUM);   
28.                                                                                                                                                       
29.         if(x <= 0) continue;   
30.             // 分割命令字符串
31.         SplitCommand(usercommand,argv);
32.             // 执行命令
33.         execute(argv);
34.     }
35.     return 0;
36. }

复制代码

---

四、处理內键命令的执行

当我们使用上面的代码执行命令时，发现大部分命令都可以被执行，但是比方cd、export、echo这样的内建命令却不能被执行，原因是内建命令是作用与bash的也就是这里的父进程，并且内建命令是bash的一部分，与常见命令不同，执行内建命令时不必要创建新的子进程，所以这些内建命令必要被特殊处理一下。将命令字符串分割后就判断当前命令是否为内建命令，是则直接执行内建命令，否则认定为常见命令向下继承执行。内建命令如那里理，这里就不多讲解，具体处理方法在下面的代码中有具体的注释，有爱好的可以看一下。

1. #include <stdio.h>   
2. #include <string.h>   
3. #include <stdlib.h>   
4. #include <unistd.h>   
5. #include <sys/types.h>   
6. #include <sys/wait.h>   
7.    
8. #define NUM 1024   
9. #define SIZE 64     
10. #define SEP " "     
11. // #define debug 1   
12.    
13. // 由于环境变量PWD需要一直存在，这里定义一个全局变量来存储
14. char cwd[1024];   
15. // 定义一个全局二维数组中，用于存储添加的环境变量
16. char myenv[128][1024];   
17. // 记录二维数组中有多少个环境变量
18. int cnt = 0;   
19. int lastcode = 0; // 记录退出码   
20.                                                                                                                                                       
21. char* getHomename()   
22. {                                       
23.     char* homename = getenv("HOME");   
24.     if(homename)            
25.         return homename;   
26.     else                          
27.         return (char*)"none";   
28. }                                
30. const char* getUsername()   
31. {                                       
32.     char* username = getenv("USER");
33.     if(username)            
34.         return username;   
35.     else                                                                                                                                               
36.         return "none";   
37. }   
39. const char* getHostname()
40. {
41.     char* hostname = getenv("HOSTNAME");
42.     if(hostname)
43.         return hostname;
44.     else
45.         return "none";
46. }
48. const char* getCwd()
49. {
50.     char* cwd = getenv("PWD");
51.     if(cwd)
52.         return cwd;
53.     else
54.         return "none";
55. }
57. int getUserCommand(char* command , int num)
58. {
59.     printf("[%s@%s %s]# ",getUsername(),getHostname(),getCwd());
60.    
61.     // scanf("%s",usercommand); scanf读到空格就会自动停止，所以这里不使用scanf                                                                        
62.     char* r = fgets(command,num,stdin);
63.     if(r == NULL) return -1;  // 读取失败返回-1
64.     // 读取字符串时，会自动获取到'\n'，我们需要将这个'\n'去掉
65.     command[strlen(command)-1] = '\0';
66.     // 由于读入字符串时，必定会有一个\n所以这么不可能会越界
68.     // 用于测试输入的字符串是否符合我们的预期   
69.     // printf("%s\n",command);   
71.     // 当命令行只输入回车时，则没有必要创建子进程来执行任务
72.     if(strlen(command) == 0)
73.         return 0;
75.     return 1;
76. }
78. void SplitCommand(char* in , char* out[])   
79. {   
80.     int argc = 0;   
81.     out[argc++] = strtok(in,SEP);   
82.           while(out[argc++] = strtok(NULL,SEP));                                                                                                            
83.     // strtok函数分割失败时会返回NULL，正好是我们字符串数组结尾所需要的
84.     // 所以分割的方式可以使用赋值作为循环判断条件进行循序
85.     // 若是大家不习惯可以使用下面这一种分割方式
86.    
88.     //while(1)   
89.     //{   
90.     //    out[argc] = strtok(NULL,SEP);   
91.     //    if(out[argc] == NULL)                                                                                                              
92.     //        break;   
93.     //    argc++;                                                                                                                           
94.     //}                                                                                                                                      
95. #ifdef debug
96.     for(int i = 0 ; out[i] ; i++)                                                                                                         
97.     {                                                                                                                                      
98.         printf("%d : %s \n",i,out[i]);                                                                                                     
99.     }        
100. #endif
101. }
103. int execute(char* argv[])
104. {
105.     pid_t id = fork();
106.                                                                                                                                                       
107.     if(id < 0) return -1;
108.     else if(id == 0)
109.     {
110.         execvp(argv[0],argv);
111.         // 若替换失败则子进程退出
112.         exit(-1);
113.     }
114.     else
115.     {
116.         // sleep(1);
117.         int status = 0;
118.         pid_t rid = wait(&status);
119.         if(rid>0)
120.         {
121.             lastcode = WEXITSTATUS(status);
122.         }
123.         
124.     }
125.     return 0;
126. }
128. void cd(char* path)
129. {
130.         // 将当前的工作目录改为path
131.     chdir(path);
132.     // tmp作为一个临时空间
133.     char tmp[1024];
134.     // 将当前工作目录写入到tmp中
135.     getcwd(tmp,sizeof(tmp));
136.     // 将PWD=与tmp进行组合，形成环境变量的格式存储到全局变量cwd                                                                                                                     
137.     sprintf(cwd,"PWD=%s",tmp);
138.     // 将cwd添加到环境变量中，覆盖掉原来的环境变量PWD
139.     putenv(cwd);
140. }
142. // 内键命令并执行1，非内键命令0
143. int dobuildin(char* argv[])
144. {
145.     if(strcmp(argv[0],"cd") == 0)
146.     {
147.         char* path = NULL;
148.         // cd命令后面没有添加路径，默认更改当前工作目录为家目录
149.         if(argv[1] == NULL)
150.             path = getHomename();
151.         else
152.             path = argv[1];
154.         cd(path);
155.         return 1;
156.     }
157.     else if(strcmp(argv[0],"export") == 0)
158.     {
159.             // 如果export后面没有内容则不做任何处理
160.         if(argv[1] == NULL)
161.             return 1;
162.         else
163.         {
164.                 // 将需要添加的环境变量保存到全局的二维数组中
165.             strcpy(myenv[cnt],argv[1]);
166.             // 将这个环境变量添加到进程的环境变量表中
167.             putenv(myenv[cnt++]);
168.             return 1;
169.         }
170.     }
171.         else if(strcmp(argv[0],"echo") == 0)
172.     {
173.             // 当echo后面没有内容时，默认输出回车
174.         if(argv[1] == NULL)
175.         {
176.             printf("\n");
177.             return 1;
178.         }
179.         // 当echo后面的字符串的第一个字符为$时
180.         // 就是查看进程的退出码或是环境变量的                                                                                                                                             
181.         else if(*(argv[1]) == '$' && strlen(argv[1]) >= 2)
182.         {
183.             // 输出退出码
184.             if(*(argv[1]+1) == '?')
185.             {
186.                 printf("%d\n",lastcode);            
187.                 lastcode = 0;
188.             }
189.             else  // 输出环境变量  
190.             {
191.                 const char* enval = getenv(argv[1]+1);
192.                 if(enval)
193.                 {
194.                     printf("%s",enval);
195.                 }
196.                 else
197.                 {
198.                     printf("\n");
199.                 }
200.             }
201.         }
202.         // 不符合上面情况，通常就是将echo后面的字符串直接输出
203.         else
204.         {
205.             printf("%s",argv[1]);
206.         }
207.         return 1;
208.         }                                                                                                                                                  
209.     else if(0){}
210.     return 0;
211. }
213. int main()                                                                                                                                 
214. {                                                                                                                                          
215.     while(1)                                                                                                                              
216.     {                                                                                                                                      
217.         char usercommand[NUM];                                                                                                            
218.         char* argv[SIZE];   
219.         // 打印命令提示符和获取命令行命令字符串   
220.         int x = getUserCommand(usercommand,NUM);   
221.    
222.         if(x <= 0) continue;   
223.    
224.         SplitCommand(usercommand,argv);
226.         x = dobuildin(argv);
227.         if(x == 1)
228.             continue;
230.         execute(argv);
231.     }
232.     return 0;
233. }

复制代码

---

五、重定向（本文章所有代码）

写完前面的代码后，发现这个代码并不能解决重定向的问题，没了解重定向的最悦目一下后面一篇文章了解一下重定向是什么，在分割命令字符串之前，我们必要判断这个命令字符串是否必要进行重定向，必要重定向则必要对字符串进行处理，比方"ls -l -a > fortest.txt" -> "ls -l -a" 重定向范例 "fortest.txt"，我们会得到三个部分，命令字符串、重定向范例、和文件名，在代码定义四种重定向范例，无重定向、输入重定向、输出重定向和追加重定向，默认情况下是无重定向，定义一个全局变量存储重定向范例，定义一个全局指针来指向文件名，然后我们针对不同的重定向范例使用dup2函数进行不同的处理，具体不同重定向的处理过程请查察代码中重定向的一部分。

1. #include <stdio.h>                                                                                                                                    
2. #include <string.h>                  
3. #include <stdlib.h>   
4. #include <unistd.h>   
5. #include <sys/types.h>                        
6. #include <sys/wait.h>   
7. #include <sys/stat.h>   
8. #include <fcntl.h>   
9. #include <ctype.h>   
10.      
11. #define NUM 1024   
12. #define SIZE 64        
13. #define SEP " "     
14. // #define debug 1   
15.                                                             
16. #define NoneRedir   0           
17. #define InputRedir  1            
18. #define OutputRedir 2   
19. #define AppendRedir 3   
20.    
21. int redir = NoneRedir;            
22. char* filename = NULL;         
23.      
24. // 由于环境变量PWD需要一直存在，这里定义一个全局变量来存储
25. char cwd[1024];   
26. // 定义一个全局二维数组中，用于存储添加的环境变量
27. char myenv[128][1024];   
28. // 记录二维数组中有多少个环境变量
29. int cnt = 0;   
30. int lastcode = 0; // 记录退出码   
32. char* getHomename()
33. {                              
34.     char* homename = getenv("HOME");   
35.     if(homename)
36.         return homename;   
37.     else   
38.         return (char*)"none";                                                                                                                          
39. }
41. const char* getUsername()
42. {
43.     char* username = getenv("USER");
44.     if(username)
45.         return username;
46.     else
47.         return "none";
48. }
50. const char* getHostname()
51. {
52.     char* hostname = getenv("HOSTNAME");
53.     if(hostname)
54.         return hostname;
55.     else
56.         return "none";
57. }
58. const char* getCwd()
59. {
60.     char* cwd = getenv("PWD");                                                                                                                        
61.     if(cwd)
62.         return cwd;
63.     else
64.         return "none";
65. }
67. int getUserCommand(char* command , int num)
68. {
69.     printf("[%s@%s %s]# ",getUsername(),getHostname(),getCwd());
70.    
71.     // scanf("%s",usercommand); scanf读到空格就会自动停止，所以这里不使用scanf
72.     char* r = fgets(command,num,stdin);
73.     if(r == NULL) return -1;  // 读取失败返回-1
74.     // 读取字符串时，会自动获取到'\n'，我们需要将这个'\n'去掉
75.     command[strlen(command)-1] = '\0';
76.     // 由于读入字符串时，必定会有一个\n所以这么不可能会越界
78.     // 用于测试输入的字符串是否符合我们的预期   
79.     // printf("%s\n",command);   
81.     // 当命令行只输入回车时，则没有必要创建子进程来执行任务
82.     if(strlen(command) == 0)
83.         return 0;
85.     return 1;
86. }
88. void SplitCommand(char* in , char* out[])   
89. {   
90.     int argc = 0;   
91.     out[argc++] = strtok(in,SEP);   
92.         while(out[argc++] = strtok(NULL,SEP));   
93.                                                                                                                                  
94. #ifdef debug
95.     for(int i = 0 ; out[i] ; i++)                                                                                                         
96.     {                                                                                                                                      
97.         printf("%d : %s \n",i,out[i]);                                                                                                     
98.     }        
99. #endif
100. }  
101. int execute(char* argv[])
102. {
103.     pid_t id = fork();
105.     if(id < 0) return -1;                                                                                                                              
106.     else if(id == 0)
107.     {
108.         int fd = 0;
109.         if(redir == InputRedir)
110.         {
111.             fd = open(filename,O_RDONLY);
112.             dup2(fd,0);
113.         }
114.         else if(redir == OutputRedir)
115.         {
116.             fd = open(filename,O_WRONLY|O_CREAT|O_TRUNC,0666);
117.             dup2(fd,1);
118.         }
119.         else if(redir == AppendRedir)
120.         {
121.             fd = open(filename,O_WRONLY|O_CREAT|O_APPEND,0666);
122.             dup2(fd,1);
123.         }
124.         else
125.         {
126.             // do nothing
127.         }
129.         execvp(argv[0],argv);
130.         // 若替换失败则子进程退出
131.         exit(-1);
132.     }
133.         else
134.     {
135.         // sleep(1);
136.         int status = 0;
137.         pid_t rid = wait(&status);
138.         if(rid>0)
139.         {
140.             lastcode = WEXITSTATUS(status);
141.         }
142.         
143.     }
144.     return 0;
145. }
147. void cd(char* path)
148. {
149.     chdir(path);
150.     char tmp[1024];
151.     // char* tmp = getenv("PWD");
152.     getcwd(tmp,sizeof(tmp));
153.     sprintf(cwd,"PWD=%s",tmp);
154.     putenv(cwd);
155. }
157. // 内键命令并执行1，非内键命令0
158. int dobuildin(char* argv[])
159. {
160.     if(strcmp(argv[0],"cd") == 0)
161.     {
162.         char* path = NULL;
163.         if(argv[1] == NULL)
164.             path = getHomename();
165.         else
166.             path = argv[1];
168.         cd(path);                                                                                                                                      
169.         return 1;
170.     }
171.     else if(strcmp(argv[0],"export") == 0)
172.     {
173.         if(argv[1] == NULL)
174.             return 1;
175.         else
176.         {
177.             strcpy(myenv[cnt],argv[1]);
178.             putenv(myenv[cnt++]);
179.             return 1;
180.         }
181.     }
182.         else if(strcmp(argv[0],"echo") == 0)
183.     {                                                                                                                                                  
184.         if(argv[1] == NULL)
185.         {
186.             printf("\n");
187.             return 1;
188.         }
189.         else if(*(argv[1]) == '$' && strlen(argv[1]) >= 2)
190.         {
191.             // 输出退出码
192.             if(*(argv[1]+1) == '?')
193.             {
194.                 printf("%d\n",lastcode);
195.                 lastcode = 0;
196.             }
197.             else  // 输出环境变量  
198.             {
199.                 const char* enval = getenv(argv[1]+1);
200.                 if(enval)
201.                 {
202.                     printf("%s",enval);
203.                 }
204.                 else
205.                 {
206.                     printf("\n");
207.                 }
208.             }
209.         }
210.         else
211.         {
212.             printf("%s",argv[1]);
213.         }
214.         return 1;
215.     }
216.     else if(0){}
217.     return 0;
218. }
220. // 用于跳过空格
221. #define SkipSpace(pos) do{while(isspace(*pos)) pos++;}while(0)
223. // 判断是否为重定向
224. void CheckRedir(char command[])
225. {
226.     char* start = command;                                                                                                                             
227.     char* end = command +  strlen(command);
229.     while(start < end)
230.     {
231.         // 输入重定向
232.         if(*end == '<')
233.         {
234.             *end = '\0';
235.             filename = end + 1;
236.             SkipSpace(filename);
237.             redir = InputRedir;
238.         }
239.         else if(*end == '>')
240.         {
241.             // 追加重定向
242.             if(*(end-1) == '>')
243.             {
244.                 *(end-1) = '\0';
245.                 filename = end + 1;
246.                 SkipSpace(filename);
247.                 redir = AppendRedir;
248.             }
249.             // 输出重定向
250.             else
251.             {
252.                 *end = '\0';
253.                 filename = end + 1;                                                                                                                    
254.                 SkipSpace(filename);
255.                 redir = OutputRedir;
256.             }
257.         }
258.         end--;
259.     }
260. }
262. int main()                                                                                                                                 
263. {                                                                                                                                          
264.     while(1)                                                                                                                              
265.     {                                                                                                                                                  
266.         // 初始默认为非重定向
267.         redir = NoneRedir;
268.         filename = NULL;
270.         char usercommand[NUM];                                                                                                            
271.         char* argv[SIZE];   
272.         // 打印命令提示符和获取命令行命令字符串   
273.         int x = getUserCommand(usercommand,NUM);   
274.    
275.         if(x <= 0) continue;   
276.    
277.         // 判断是否为重定向
278.         CheckRedir(usercommand);
280.         // 分割命令行  "ls -a -l" -> "ls" "-a" "-l"
281.         SplitCommand(usercommand,argv);
283.         // 判断是否为內键命令
284.         x = dobuildin(argv);
285.         if(x == 1)
286.             continue;
288.         // 执行指令
289.         execute(argv);
290.     }
291.     return 0;
292. }

复制代码

---

末了

如果有什么建议和疑问，或是有什么错误，各人可以在批评区中提出。
希望各人以后也能和我一起进步！！