开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > Shell编程 > 查看源码
shell.c
资源名称：shiyan2.rar　[点击查看]
上传用户：hmmeiri
上传日期：2021-11-11
资源大小：2k
文件大小：10k
源码类别：

Shell编程

开发平台：

C/C++

shell.c：源码内容
  1. #include<stdio.h>
  2. #include<ctype.h>
  3. #include<string.h>
  4. #include<unistd.h>
  5. #include<sys/types.h>
  6. #include<sys/stat.h>
  7. #include<fcntl.h>
  8. #include<sys/wait.h>
  9. #include<math.h>
  10. #include<signal.h>
  11. #include<stdlib.h>
  13. struct command_struct{  //表示命令的结构
  14. char *argv[20];
  15. int mark;   //表示输入指令类型的标记
  16. int numargv;//参数及指令数
  17. }*command;
  18. char *paths;
  19. struct path_struct{    //表路径的结构
  20. char *enpath[20]； //路径的数组
  21. int numpath;  //路径数目
  22. }*path;
  23. char *command_line;  //存放输入命令的字符串
  24. void get_command();  //解析命令函数
  25. void get_path();     //获得环境路径
  26. void common_shell(); //普通SHELL的实现
  27. void pipe_shell();   //实现管道
  28. void redirectIn_shell(); //实现输入重定向
  29. void redirectOut_shell();//实现输出重定向
  30. void back_shell(int);//实现后台
  31. main()
  32. {
  33. char *nowpath;
  34. int i;
  35. /*-----------------*/
  36. while(1){
  37. /*打印提示符*/
  38. nowpath = get_current_dir_name();
  39. printf("<ymf  %s>", nowpath);
  40. command_line = (char*)malloc(100);
  41. gets(command_line);
  42. get_command();
  43. get_path();
  44. /*普通SHELL的实现*/
  45. if(command->mark == 0)
  46. {
  47. common_shell();
  48. }
  49. /*管道的处理*/
  50. if(command->mark == 1)
  51. {
  52. pipe_shell();
  53. }
  54. /*输出重定向*/
  55. if(command->mark == 2)
  56. {
  57. redirectOut_shell();
  58. }
  59. /*输入重定向*/
  60. if(command->mark == 3)
  61. {
  62. redirectIn_shell();
  63. }
  64. /*后台*/
  65. if(command->mark == 4)
  66. {
  67. //printf("%dn", command->mark);
  68. back_shell(command->mark);
  69. }
  70. }
  73. }
  74. /*实现后台的函数*/
  75. void back_shell(int back)
  76. {
  77. int status;
  78. int i, pid;
  79. char *p;
  80. /*吃掉指中'&'*/
  81. for(i = 0;i<command->numargv;i++)
  82. {
  83. if(strstr(command->argv[i], "&")!=NULL)
  84. break;
  85. }
  87. p = (char *)malloc(100);
  88. p = strrchr(command->argv[i], '&');
  89. (*p) = '';
  90. /*处理./a.out指令
  91. *若为./a.out则无需与环境路径相接，直接处理即可
  92. */
  93. if((strstr(command->argv[0], ".out"))!=NULL){
  94. pid = fork();
  95. if(pid == 0){
  96. printf("%sn", command->argv[0]);
  97. execvp("./a.out", command->argv);
  98. }
  99. else{
  100. if(back == 0)
  101. waitpid(pid, 0, 0);
  102. else
  103. printf("%dn", pid);
  104. }
  105. return;
  106. }
  107. //指令与环境路径相接成绝对路径
  108. for(i = 0;i<path->numpath;i++)
  109. {
  110. strcat(path->enpath[i], "/");
  111. strcat(path->enpath[i], command->argv[0]);
  112. //printf("%snn", path[i]);
  113. }
  114. for(i = 0;i<path->numpath;i++)
  115. {
  116. //判断该路径是否存在
  117. if(access(path->enpath[i], F_OK)==0){
  118. //创建进程
  119. pid = fork();
  120. if(pid == 0){
  121. //printf("child programenn");
  122. execvp(path->enpath[i], command->argv);
  123. }
  124. else{
  125. //实现后台
  126. if(back == 0)
  127. waitpid(pid, 0, 0);
  128. }
  129. }
  130. }
  131. }
  132. void redirectIn_shell()
  133. {
  134. int fid;
  135. int status;
  136. int i, num1;
  137. char *nowpath;
  138. char *file;
  139. int path_i;
  140. struct command_struct *command1;
  141. command1 = (struct command_struct *)malloc(sizeof(struct command_struct));
  142. for(i = 0;i<path->numpath;i++)
  143. {
  144. strcat(path->enpath[i], "/");
  145. strcat(path->enpath[i], command->argv[0]);
  146. }
  148. for(i = 0;i<path->numpath;i++)
  149. {
  150. if(access(path->enpath[i], F_OK)==0)
  151. break;
  152. }
  153. path_i = i;
  154. if(i==path->numpath)
  155. printf("error!");
  156. nowpath = get_current_dir_name();;
  158. for(i = 0;i<command->numargv;i++)
  159. {
  160. if(strstr(command->argv[i], "<")!=NULL)
  161. break;
  162. }
  163. num1 = i;
  164. file = command->argv[num1] + 1;
  165. strcat(nowpath, "/");
  166. strcat(nowpath, file);
  167. for(i = 0;i<num1;i++)
  168. {
  169. command1->argv[i] = command->argv[i];
  170. }
  171. if(fork() == 0)
  172. {
  174. fid = open(nowpath, O_RDONLY);
  175. close(0);
  176. dup(fid);
  177. close(fid);
  178. execvp(path->enpath[path_i], command1->argv);
  179. }
  180. else
  181. {
  182. wait(&status);
  183. }
  185. }
  186. void redirectOut_shell()
  187. {
  188. int fid;
  189. int status;
  190. int i, num1;
  191. char *nowpath;
  192. char *file;
  193. int path_i;
  194. struct command_struct *command1;
  195. command1 = (struct command_struct *)malloc(sizeof(struct command_struct));
  196. for(i = 0;i<path->numpath;i++)
  197. {
  198. strcat(path->enpath[i], "/");
  199. strcat(path->enpath[i], command->argv[0]);
  200. }
  202. for(i = 0;i<path->numpath;i++)
  203. {
  204. if(access(path->enpath[i], F_OK)==0)
  205. break;
  206. }
  207. path_i = i;
  208. if(i==path->numpath)
  209. printf("error!");
  210. nowpath = get_current_dir_name();
  211. for(i = 0;i<command->numargv;i++)
  212. {
  213. if(strstr(command->argv[i], ">")!=NULL)
  214. break;
  215. }
  216. num1 = i;
  217. file = command->argv[num1] + 1;
  218. strcat(nowpath, "/");
  219. strcat(nowpath, file);
  220. for(i = 0;i<num1;i++)
  221. {
  222. command1->argv[i] = command->argv[i];
  223. }
  224. if(fork() == 0)
  225. {
  227. fid = open(nowpath, O_WRONLY|O_CREAT);
  228. close(1);
  229. dup(fid);
  230. close(fid);
  231. execvp(path->enpath[path_i], command1->argv);
  232. }
  233. else
  234. {
  235. wait(&status);
  236. }
  239. }
  240. void pipe_shell()
  241. {
  242. int i, num1, j;
  243. int status;
  244. int pid[2];
  245. int pipe_fd[2];
  246. char *p;
  247. struct command_struct *command1,*command2;
  248. struct path_struct *path1, *path2;
  249. command1 = (struct command_struct *)malloc(sizeof(struct command_struct));
  250. command2 = (struct command_struct *)malloc(sizeof(struct command_struct));
  251. path1 = (struct path_struct*)malloc(sizeof(struct path_struct));
  252. path2 = (struct path_struct*)malloc(sizeof(struct path_struct));
  253. //printf("tmdnnn");
  254. for(i = 0;i<command->numargv;i++)
  255. {
  256. if(strstr(command->argv[i], "|")!=NULL)
  257. break;
  258. }
  259. num1 = i;
  260. command->argv[num1] = command->argv[num1] + 1;
  261. /*----------command1------------*/
  262. for(i = 0;i<num1;i++)
  263. {
  264. command1->argv[i] = command->argv[i];
  265. }
  266. /*-------------command2----------*/
  267. for(j = 0, i = num1;i<command->numargv;i++, j++)
  268. {
  269. command2->argv[j] = command->argv[i];
  270. //printf("%sn", command2->argv[j]);
  271. }
  272. //printf("%dnnn", j);
  273. //command2->argv[j + 1] = NULL;
  275. for(i = 0;i<path->numpath;i++)
  276. {
  277. path1->enpath[i] = (char *)malloc(50);
  278. strcpy(path1->enpath[i],path->enpath[i]);
  279. strcat(path1->enpath[i], "/");
  280. strcat(path1->enpath[i], command1->argv[0]);
  281. //printf(":::%snnn", path1->enpath[i]);
  283. path2->enpath[i] = (char *)malloc(50);
  284. strcpy(path2->enpath[i], path->enpath[i]);
  285. strcat(path2->enpath[i], "/");
  286. strcat(path2->enpath[i], command2->argv[0]);
  287. //printf("%snnn", path2->enpath[i]);
  288. }
  289. //查找路径
  290. for(i = 0;i<path->numpath;i++)
  291. if(access(path1->enpath[i], F_OK)==0)
  292. break;
  293. for(j = 0;j<path->numpath;j++)
  294. if(access(path2->enpath[j], F_OK)==0)
  295. break;
  296. //创建管道
  297. if(pipe(pipe_fd)<0)
  298. {
  299. printf("pipe failedn");
  300. exit(0);
  301. }
  302. //创建进程
  303. if((pid[0]=fork())<0)
  304. {
  305. printf("fork failedn");
  306. exit(0);
  307. }
  308. //进程1
  309. if(pid[0]==0)
  310. {
  311. close(pipe_fd[0]);   //关闭管道输出
  312. dup2(pipe_fd[1], 1); //进程1输出接到管道输入端
  313. close(pipe_fd[1]);  //关闭管道输入
  314. execvp(path1->enpath[i], command1->argv);//执行
  315. }
  316. if(pid[0])
  317. {
  318. if((pid[1]=fork())<0)
  319. {
  320. printf("fork failesn");
  321. exit(0);
  322. }
  323. if(!pid[1])
  324. {
  325. close(pipe_fd[1]);//关闭管道输入
  326. dup2(pipe_fd[0], 0);//进程2输入端接到管道输出端
  327. close(pipe_fd[0]);//关闭管道输出
  329. execvp(path2->enpath[j], command2->argv);
  330. }
  331. close(pipe_fd[0]);
  332. close(pipe_fd[1]);
  333. waitpid(pid[1], &status, 0);
  334. }
  337. }
  338. void common_shell()
  339. {
  340. int status;
  341. int i;
  342. char *p, *nowpath;
  345. if((strstr(command->argv[0], ".out"))!=NULL){
  346. if(fork()==0){
  347. execvp("./a.out", command->argv);
  348. }
  349. else{
  350. wait(&status);
  351. }
  352. return;
  353. }
  356. //printf("%sn", path->enpath[0]);
  357. //printf("%sn", command->argv[0]);
  358. for(i = 0;i<path->numpath;i++)
  359. {
  360. strcat(path->enpath[i], "/");
  361. strcat(path->enpath[i], command->argv[0]);
  362. //printf("%snn", path[i]);
  363. }
  364. //printf("%sn", path->enpath[0]);
  365. //printf("%sn", command->argv[0]);
  366. //for(i = 0;i<path->numpath;i++)
  367. //printf("%sn", path->enpath[i]);
  368. for(i = 0;i<path->numpath;i++)
  369. {
  370. if(access(path->enpath[i], F_OK)==0)
  371. break;
  372. }
  373. //printf("%sn", path->enpath[i]);
  374. if(i == path-> numpath)
  375. printf("ERROR !!");
  377. else{
  378. if(fork() == 0){
  379. execvp(path->enpath[i], command->argv);
  380. }
  381. else{
  382. wait(&status);
  383. }
  384. }
  387. }
  388. void get_path()
  389. {
  390. int num, i;
  391. char*word;
  392. char *stay_pointer, *move_pointer;
  393. paths = (char *)getenv("PATH");
  394. //printf("%sn", paths);
  395. stay_pointer = paths;
  396. move_pointer = paths;
  397. path = (struct path_struct*)malloc(sizeof(struct path_struct));
  398. num = 0;
  399. i = 0;
  400. while((*move_pointer)!='')
  401. {
  402. stay_pointer = move_pointer;
  403. while((*move_pointer)!=':'&&(*move_pointer)!=''){
  404. num++;
  405. move_pointer ++;
  406. }
  407. word = (char*)malloc(num + 1);
  408. strncpy(word, stay_pointer, num);
  409. strcat(word, "");
  410. path->enpath[i] = word;
  411. i++;
  412. num = 0;
  413. if((*move_pointer)=='')
  414. break;
  415. move_pointer++; 
  416. if((*move_pointer)=='')
  417. break;
  418. }
  419. path->numpath = i;
  421. }
  422. void get_command()
  423. {
  425. char *word;
  426. char *move_pointer, *stay_pointer;
  427. int num, i;
  428. //printf("adfsadfann");
  429. /*----------------*/
  430. command = (struct command_struct *)malloc(sizeof(struct command_struct));
  431. /*结构体中变量赋初值*/
  433. command->mark = 0;
  434. command->numargv = 0;
  435. num = 0;
  436. i = 0;
  437. //该指针移动，读过整个指令字符串
  438. move_pointer = command_line;
  439. //指向每个以空格分隔开来的字符的头指针
  440. stay_pointer = command_line;
  443. while((*move_pointer)!=''){
  445. if((*move_pointer) == '')
  446. break;
  447. while((*move_pointer)==' ')
  448. move_pointer++;
  449. if((*move_pointer) == '')
  450. break;
  451. stay_pointer = move_pointer;
  452. //printf("%snn", stay_pointer);
  453. while(((*move_pointer)!=' ')&&((*move_pointer)!='')){
  454. /*标记赋值*/
  455. if((*move_pointer)=='|')
  456. command->mark = 1;
  457. if((*move_pointer)=='>')
  458. command->mark = 2;
  459. if((*move_pointer)=='<')
  460. command->mark = 3;
  461. if((*move_pointer)=='&')
  462. command->mark = 4;
  463. move_pointer++;
  464. num++;
  465. }
  466. //获得以空格分隔开的一个字符串
  467. word = (char*)malloc(num + 1);
  468. strncpy(word, stay_pointer, num);
  469. strcat(word, "");
  470. command->argv[i] = word;
  471. num = 0;
  472. i++;
  473. if((*move_pointer) == '')
  474. break;
  476. }
  477. command->numargv=i;
  479. }