1: /* ladsh4.c */
2:
3: #define _GNU_SOURCE
4:
5: #include <ctype.h>
6: #include <errno.h>
7: #include <fcntl.h>
8: #include <glob.h>
9: #include <signal.h>
10: #include <stdio.h>
11: #include <stdlib.h>
12: #include <string.h>
13: #include <sys/ioctl.h>
14: #include <sys/wait.h>
15: #include <unistd.h>
16:
17: #define MAX_COMMAND_LEN 250 /* max length of a single command
18: string */
19: #define JOB_STATUS_FORMAT "[%d] %-22s %.40s
"
20:
21: struct jobSet {
22: struct job * head; /* head of list of running jobs */
23: struct job * fg; /* current foreground job */
24: };
25:
26: enum redirectionType { REDIRECT_INPUT, REDIRECT_OVERWRITE,
27: REDIRECT_APPEND };
28:
29: struct redirectionSpecifier {
30: enum redirectionType type; /* type of redirection */
31: int fd; /* fd being redirected */
32: char * filename; /* file to redirect fd to */
33: };
34:
35: struct childProgram {
36: pid_t pid; /* 0 if exited */
37: char ** argv; /* program name and arguments */
38: int numRedirections; /* elements in redirection array */
39: struct redirectionSpecifier * redirections; /* I/O redirs */
40: glob_t globResult; /* result of parameter globbing */
41: int freeGlob; /* should we free globResult? */
42: int isStopped; /* is the program currently running? */
43: };
44:
45: struct job {
46: int jobId; /* job number */
47: int numProgs; /* number of programs in job */
48: int runningProgs; /* number of programs running */
49: char * text; /* name of job */
50: char * cmdBuf; /* buffer various argv's point to */
51: pid_t pgrp; /* process group ID for the job */
52: struct childProgram * progs; /* array of programs in job */
53: struct job * next; /* to track background commands */
54: int stoppedProgs; /* num of programs alive, but stopped */
55: };
56:
57: void freeJob(struct job * cmd) {
58: int i;
59:
60: for (i = 0; i < cmd->numProgs; i++) {
61: free(cmd->progs[i].argv);
62: if (cmd->progs[i].redirections)
63: free(cmd->progs[i].redirections);
64: if (cmd->progs[i].freeGlob)
65: globfree(&cmd->progs[i].globResult);
66: }
67: free(cmd->progs);
68: if (cmd->text) free(cmd->text);
69: free(cmd->cmdBuf);
70: }
71:
72: int getCommand(FILE * source, char * command) {
73: if (source == stdin) {
74: printf("# ");
75: fflush(stdout);
76: }
77:
78: if (!fgets(command, MAX_COMMAND_LEN, source)) {
79: if (source == stdin) printf("
");
80: return 1;
81: }
82:
83: /* remove trailing newline */
84: command[strlen(command) - 1] = ' ';
85:
86: return 0;
87: }
88:
89: void globLastArgument(struct childProgram * prog, int * argcPtr,
90: int * argcAllocedPtr) {
91: int argc = *argcPtr;
92: int argcAlloced = *argcAllocedPtr;
93: int rc;
94: int flags;
95: int i;
96: char * src, * dst;
97:
98: if (argc > 1) { /* cmd->globResult already initialized */
99: flags = GLOB_APPEND;
100: i = prog->globResult.gl_pathc;
101: } else {
102: prog->freeGlob = 1;
103: flags = 0;
104: i = 0;
105: }
106:
107: rc = glob(prog->argv[argc - 1], flags, NULL, &prog->globResult);
108: if (rc == GLOB_NOSPACE) {
109: fprintf(stderr, "out of space during glob operation
");
110: return;
111: } else if (rc == GLOB_NOMATCH ||
112: (!rc && (prog->globResult.gl_pathc - i) == 1 &&
113: !strcmp(prog->argv[argc - 1],
114: prog->globResult.gl_pathv[i]))) {
115: /* we need to remove whatever quoting is still present */
116: src = dst = prog->argv[argc - 1];
117: while (*src) {
118: if (*src != '') *dst++ = *src;
119: src++;
120: }
121: *dst = ' ';
122: } else if (!rc) {
123: argcAlloced += (prog->globResult.gl_pathc - i);
124: prog->argv = realloc(prog->argv,
125: argcAlloced * sizeof(*prog->argv));
126: memcpy(prog->argv + (argc - 1),
127: prog->globResult.gl_pathv + i,
128: sizeof(*(prog->argv)) *
129: (prog->globResult.gl_pathc - i));
130: argc += (prog->globResult.gl_pathc - i - 1);
131: }
132:
133: *argcAllocedPtr = argcAlloced;
134: *argcPtr = argc;
135: }
136:
137: /* Return cmd->numProgs as 0 if no command is present (e.g. an empty
138: line). If a valid command is found, commandPtr is set to point to
139: the beginning of the next command (if the original command had
140: more than one job associated with it) or NULL if no more
141: commands are present. */
142: int parseCommand(char ** commandPtr, struct job * job, int * isBg) {
143: char * command;
144: char * returnCommand = NULL;
145: char * src, * buf, * chptr;
146: int argc = 0;
147: int done = 0;
148: int argvAlloced;
149: int i;
150: char quote = ' ';
151: int count;
152: struct childProgram * prog;
153:
154: /* skip leading white space */
155: while (**commandPtr && isspace(**commandPtr)) (*commandPtr)++;
156:
157: /* this handles empty lines and leading '#' characters */
158: if (!**commandPtr || (**commandPtr=='#')) {
159: job->numProgs = 0;
160: *commandPtr = NULL;
161: return 0;
162: }
163:
164: *isBg = 0;
165: job->numProgs = 1;
166: job->progs = malloc(sizeof(*job->progs));
167:
168: /* We set the argv elements to point inside of this string. The
169: memory is freed by freeJob().
170:
171: Getting clean memory relieves us of the task of NULL
172: terminating things and makes the rest of this look a bit
173: cleaner (though it is, admittedly, a tad less efficient) */
174: job->cmdBuf = command = calloc(1, strlen(*commandPtr) + 1);
175: job->text = NULL;
176:
177: prog = job->progs;
178: prog->numRedirections = 0;
179: prog->redirections = NULL;
180: prog->freeGlob = 0;
181: prog->isStopped = 0;
182:
183: argvAlloced = 5;
184: prog->argv = malloc(sizeof(*prog->argv) * argvAlloced);
185: prog->argv[0] = job->cmdBuf;
186:
187: buf = command;
188: src = *commandPtr;
189: while (*src && !done) {
190: if (quote == *src) {
191: quote = ' ';
192: } else if (quote) {
193: if (*src == '') {
194: src++;
195: if (!*src) {
196: fprintf(stderr,
197: "character expected after \
");
198: freeJob(job);
199: return 1;
200: }
201:
202: /* in shell, "'" should yield ' */
203: if (*src != quote) *buf++ = '';
204: } else if (*src == '*' || *src == '?' || *src == '[' ||
205: *src == ']')
206: *buf++ = '';
207: *buf++ = *src;
208: } else if (isspace(*src)) {
209: if (*prog->argv[argc]) {
210: buf++, argc++;
211: /* +1 here leaves room for the NULL which
212: ends argv */
213: if ((argc + 1) == argvAlloced) {
214: argvAlloced += 5;
215: prog->argv = realloc(prog->argv,
216: sizeof(*prog->argv) * argvAlloced);
217: }
218: prog->argv[argc] = buf;
219:
220: globLastArgument(prog, &argc, &argvAlloced);
221: }
222: } else switch (*src) {
223: case '"':
224: case ''':
225: quote = *src;
226: break;
227:
228: case '#': /* comment */
229: done = 1;
230: break;
231:
232: case '>': /* redirections */
233: case '<':
234: i = prog->numRedirections++;
235: prog->redirections = realloc(prog->redirections,
236: sizeof(*prog->redirections) * (i + 1));
237:
238: prog->redirections[i].fd = -1;
239: if (buf != prog->argv[argc]) {
240: /* the stuff before this character may be
241: the file number being redirected */
242: prog->redirections[i].fd =
243: strtol(prog->argv[argc], &chptr, 10);
244:
245: if (*chptr && *prog->argv[argc]) {
246: buf++, argc++;
247: globLastArgument(prog, &argc, &argvAlloced);
248: }
249: }
250:
251: if (prog->redirections[i].fd == -1) {
252: if (*src == '>')
253: prog->redirections[i].fd = 1;
254: else
255: prog->redirections[i].fd = 0;
256: }
257:
258: if (*src++ == '>') {
259: if (*src == '>') {
260: prog->redirections[i].type = REDIRECT_APPEND;
261: src++;
262: } else {
263: prog->redirections[i].type = REDIRECT_OVERWRITE;
264: }
265: } else {
266: prog->redirections[i].type = REDIRECT_INPUT;
267: }
268:
269: /* This isn't POSIX sh compliant. Oh well. */
270: chptr = src;
271: while (isspace(*chptr)) chptr++;
272:
273: if (!*chptr) {
274: fprintf(stderr, "file name expected after %c
",
275: *src);
276: freeJob(job);
277: return 1;
278: }
279:
280: prog->redirections[i].filename = buf;
281: while (*chptr && !isspace(*chptr))
282: *buf++ = *chptr++;
283:
284: src = chptr - 1; /* we src++ later */
285: prog->argv[argc] = ++buf;
286: break;
287:
288: case '|': /* pipe */
289: /* finish this command */
290: if (*prog->argv[argc]) argc++;
291: if (!argc) {
292: fprintf(stderr, "empty command in pipe
");
293: freeJob(job);
294: return 1;
295: }
296: prog->argv[argc] = NULL;
297:
298: /* and start the next */
299: job->numProgs++;
300: job->progs = realloc(job->progs,
301: sizeof(*job->progs) *
302: job->numProgs);
303: prog = job->progs + (job->numProgs - 1);
304: prog->numRedirections = 0;
305: prog->redirections = NULL;
306: prog->freeGlob = 0;
307: argc = 0;
308:
309: argvAlloced = 5;
310: prog->argv = malloc(sizeof(*prog->argv) *
311: argvAlloced);
312: prog->argv[0] = ++buf;
313:
314: src++;
315: while (*src && isspace(*src)) src++;
316:
317: if (!*src) {
318: fprintf(stderr, "empty command in pipe
");
319: return 1;
320: }
321: src--; /* we'll ++ it at the end of the loop */
322:
323: break;
324:
325: case '&': /* background */
326: *isBg = 1;
327: case ';': /* multiple commands */
328: done = 1;
329: returnCommand = *commandPtr + (src - *commandPtr) + 1;
330: break;
331:
332: case '':
333: src++;
334: if (!*src) {
335: freeJob(job);
336: fprintf(stderr, "character expected after \
");
337: return 1;
338: }
339: if (*src == '*' || *src == '[' || *src == ']'
340: || *src == '?')
341: *buf++ = '';
342: /* fallthrough */
343: default:
344: *buf++ = *src;
345: }
346:
347: src++;
348: }
349:
350: if (*prog->argv[argc]) {
351: argc++;
352: globLastArgument(prog, &argc, &argvAlloced);
353: }
354: if (!argc) {
355: freeJob(job);
356: return 0;
357: }
358: prog->argv[argc] = NULL;
359:
360: if (!returnCommand) {
361: job->text = malloc(strlen(*commandPtr) + 1);
362: strcpy(job->text, *commandPtr);
363: } else {
364: /* This leaves any trailing spaces, which is a bit sloppy */
365:
366: count = returnCommand - *commandPtr;
367: job->text = malloc(count + 1);
368: strncpy(job->text, *commandPtr, count);
369: job->text[count] = ' ';
370: }
371:
372: *commandPtr = returnCommand;
373:
374: return 0;
375: }
376:
377: int setupRedirections(struct childProgram * prog) {
378: int i;
379: int openfd;
380: int mode;
381: struct redirectionSpecifier * redir = prog->redirections;
382:
383: for (i = 0; i < prog->numRedirections; i++, redir++) {
384: switch (redir->type) {
385: case REDIRECT_INPUT:
386: mode = O_RDONLY;
387: break;
388: case REDIRECT_OVERWRITE:
389: mode = O_RDWR | O_CREAT | O_TRUNC;
390: break;
391: case REDIRECT_APPEND:
392: mode = O_RDWR | O_CREAT | O_APPEND;
393: break;
394: }
395:
396: openfd = open(redir->filename, mode, 0666);
397: if (openfd < 0) {
398: /* this could get lost if stderr has been redirected,
399: but bash and ash both lose it as well (though zsh
400: doesn't!) */
401: fprintf(stderr, "error opening %s: %s
",
402: redir->filename, strerror(errno));
403: return 1;
404: }
405:
406: if (openfd != redir->fd) {
407: dup2(openfd, redir->fd);
408: close(openfd);
409: }
410: }
411:
412: return 0;
413: }
414:
415: int runCommand(struct job newJob, struct jobSet * jobList,
416: int inBg) {
417: struct job * job;
418: char * newdir, * buf;
419: int i, len;
420: int nextin, nextout;
421: int pipefds[2]; /* pipefd[0] is for reading */
422: char * statusString;
423: int jobNum;
424: int controlfds[2]; /* a pipe to make the child pause */
425:
426: /* handle built-ins here -- we don't fork() so we
427: can't background these very easily */
428: if (!strcmp(newJob.progs[0].argv[0], "exit")) {
429: /* this should return a real exit code */
430: exit(0);
431: } else if (!strcmp(newJob.progs[0].argv[0], "pwd")) {
432: len = 50;
433: buf = malloc(len);
434: while (!getcwd(buf, len) && errno == ERANGE) {
435: len += 50;
436: buf = realloc(buf, len);
437: }
438: printf("%s
", buf);
439: free(buf);
440: return 0;
441: } else if (!strcmp(newJob.progs[0].argv[0], "cd")) {
442: if (!newJob.progs[0].argv[1] == 1)
443: newdir = getenv("HOME");
444: else
445: newdir = newJob.progs[0].argv[1];
446: if (chdir(newdir))
447: printf("failed to change current directory: %s
",
448: strerror(errno));
449: return 0;
450: } else if (!strcmp(newJob.progs[0].argv[0], "jobs")) {
451: for (job = jobList->head; job; job = job->next) {
452: if (job->runningProgs == job->stoppedProgs)
453: statusString = "Stopped";
454: else
455: statusString = "Running";
456:
457: printf(JOB_STATUS_FORMAT, job->jobId, statusString,
458: job->text);
459: }
460: return 0;
461: } else if (!strcmp(newJob.progs[0].argv[0], "fg") ||
462: !strcmp(newJob.progs[0].argv[0], "bg")) {
463: if (!newJob.progs[0].argv[1] || newJob.progs[0].argv[2]) {
464: fprintf(stderr,
465: "%s: exactly one argument is expected
",
466: newJob.progs[0].argv[0]);
467: return 1;
468: }
469:
470: if (sscanf(newJob.progs[0].argv[1], "%%%d", &jobNum) != 1) {
471: fprintf(stderr, "%s: bad argument '%s'
",
472: newJob.progs[0].argv[0],
473: newJob.progs[0].argv[1]);
474: return 1;
475: }
476:
477: for (job = jobList->head; job; job = job->next)
478: if (job->jobId == jobNum) break;
479:
480: if (!job) {
481: fprintf(stderr, "%s: unknown job %d
",
482: newJob.progs[0].argv[0], jobNum);
483: return 1;
484: }
485:
486: if (*newJob.progs[0].argv[0] == 'f') {
487: /* Make this job the foreground job */
488:
489: if (tcsetpgrp(0, job->pgrp))
490: perror("tcsetpgrp");
491: jobList->fg = job;
492: }
493:
494: /* Restart the processes in the job */
495: for (i = 0; i < job->numProgs; i++)
496: job->progs[i].isStopped = 0;
497:
498: kill(-job->pgrp, SIGCONT);
499:
500: job->stoppedProgs = 0;
501:
502: return 0;
503: }
504:
505: nextin = 0, nextout = 1;
506: for (i = 0; i < newJob.numProgs; i++) {
507: if ((i + 1) < newJob.numProgs) {
508: pipe(pipefds);
509: nextout = pipefds[1];
510: } else {
511: nextout = 1;
512: }
513:
514: pipe(controlfds);
515:
516: if (!(newJob.progs[i].pid = fork())) {
517: signal(SIGTTOU, SIG_DFL);
518:
519: close(controlfds[1]);
520: /* this read will return 0 when the write side closes */
521: read(controlfds[0], &len, 1);
522: close(controlfds[0]);
523:
524: if (nextin != 0) {
525: dup2(nextin, 0);
526: close(nextin);
527: }
528:
529: if (nextout != 1) {
530: dup2(nextout, 1);
531: close(nextout);
532: }
533:
534: /* explicit redirections override pipes */
535: setupRedirections(newJob.progs + i);
536:
537: execvp(newJob.progs[i].argv[0], newJob.progs[i].argv);
538: fprintf(stderr, "exec() of %s failed: %s
",
539: newJob.progs[i].argv[0],
540: strerror(errno));
541: exit(1);
542: }
543:
544: /* put our child in the process group whose leader is the
545: first process in this pipe */
546: setpgid(newJob.progs[i].pid, newJob.progs[0].pid);
547:
548: /* close the control pipe so the child can continue */
549: close(controlfds[0]);
550: close(controlfds[1]);
551:
552: if (nextin != 0) close(nextin);
553: if (nextout != 1) close(nextout);
554:
555: /* If there isn't another process, nextin is garbage
556: but it doesn't matter */
557: nextin = pipefds[0];
558: }
559:
560: newJob.pgrp = newJob.progs[0].pid;
561:
562: /* find the ID for the job to use */
563: newJob.jobId = 1;
564: for (job = jobList->head; job; job = job->next)
565: if (job->jobId >= newJob.jobId)
566: newJob.jobId = job->jobId + 1;
567:
568: /* add the job to the list of running jobs */
569: if (!jobList->head) {
570: job = jobList->head = malloc(sizeof(*job));
571: } else {
572: for (job = jobList->head; job->next; job = job->next);
573: job->next = malloc(sizeof(*job));
574: job = job->next;
575: }
576:
577: *job = newJob;
578: job->next = NULL;
579: job->runningProgs = job->numProgs;
580: job->stoppedProgs = 0;
581:
582: if (inBg) {
583: /* we don't wait for background jobs to return -- append it
584: to the list of backgrounded jobs and leave it alone */
585:
586: printf("[%d] %d
", job->jobId,
587: newJob.progs[newJob.numProgs - 1].pid);
588: } else {
589: jobList->fg = job;
590:
591: /* move the new process group into the foreground */
592:
593: if (tcsetpgrp(0, newJob.pgrp))
594: perror("tcsetpgrp");
595: }
596:
597: return 0;
598: }
599:
600: void removeJob(struct jobSet * jobList, struct job * job) {
601: struct job * prevJob;
602:
603: freeJob(job);
604: if (job == jobList->head) {
605: jobList->head = job->next;
606: } else {
607: prevJob = jobList->head;
608: while (prevJob->next != job) prevJob = prevJob->next;
609: prevJob->next = job->next;
610: }
611:
612: free(job);
613: }
614:
615: /* Checks to see if any background processes have exited -- if they
616: have, figure out why and see if a job has completed */
617: void checkJobs(struct jobSet * jobList) {
618: struct job * job;
619: pid_t childpid;
620: int status;
621: int progNum;
622: char * msg;
623:
624: while ((childpid = waitpid(-1, &status,
625: WNOHANG | WUNTRACED)) > 0) {
626: for (job = jobList->head; job; job = job->next) {
627: progNum = 0;
628: while (progNum < job->numProgs &&
629: job->progs[progNum].pid != childpid)
630: progNum++;
631: if (progNum < job->numProgs) break;
632: }
633:
634: if (WIFEXITED(status) || WIFSIGNALED(status)) {
635: /* child exited */
636: job->runningProgs--;
637: job->progs[progNum].pid = 0;
638:
639: if (!WIFSIGNALED(status))
640: msg = "Done";
641: else
642: msg = strsignal(WTERMSIG(status));
643:
644: if (!job->runningProgs) {
645: printf(JOB_STATUS_FORMAT, job->jobId,
646: msg, job->text);
647: removeJob(jobList, job);
648: }
649: } else {
650: /* child stopped */
651: job->stoppedProgs++;
652: job->progs[progNum].isStopped = 1;
653:
654: if (job->stoppedProgs == job->numProgs) {
655: printf(JOB_STATUS_FORMAT, job->jobId, "Stopped",
656: job->text);
657: }
658: }
659: }
660:
661: if (childpid == -1 && errno != ECHILD)
662: perror("waitpid");
663: }
664:
665: int main(int argc, const char ** argv) {
666: char command[MAX_COMMAND_LEN + 1];
667: char * nextCommand = NULL;
668: struct jobSet jobList = { NULL, NULL };
669: struct job newJob;
670: FILE * input = stdin;
671: int i;
672: int status;
673: int inBg;
674:
675: if (argc > 2) {
676: fprintf(stderr, "unexpected arguments; usage: ladsh1 "
677: "<commands>
");
678: exit(1);
679: } else if (argc == 2) {
680: input = fopen(argv[1], "r");
681: if (!input) {
682: perror("fopen");
683: exit(1);
684: }
685: }
686:
687: /* don't pay any attention to this signal; it just confuses
688: things and isn't really meant for shells anyway */
689: signal(SIGTTOU, SIG_IGN);
690:
691: while (1) {
692: if (!jobList.fg) {
693: /* no job is in the foreground */
694:
695: /* see if any background processes have exited */
696: checkJobs(&jobList);
697:
698: if (!nextCommand) {
699: if (getCommand(input, command)) break;
700: nextCommand = command;
701: }
702:
703: if (!parseCommand(&nextCommand, &newJob, &inBg) &&
704: newJob.numProgs) {
705: runCommand(newJob, &jobList, inBg);
706: }
707: } else {
708: /* a job is running in the foreground; wait for it */
709: i = 0;
710: while (!jobList.fg->progs[i].pid ||
711: jobList.fg->progs[i].isStopped) i++;
712:
713: waitpid(jobList.fg->progs[i].pid, &status, WUNTRACED);
714:
715: if (WIFSIGNALED(status) &&
716: (WTERMSIG(status) != SIGINT)) {
717: printf("%s
", strsignal(status));
718: }
719:
720: if (WIFEXITED(status) || WIFSIGNALED(status)) {
721: /* the child exited */
722: jobList.fg->runningProgs--;
723: jobList.fg->progs[i].pid = 0;
724:
725: if (!jobList.fg->runningProgs) {
726: /* child exited */
727:
728: removeJob(&jobList, jobList.fg);
729: jobList.fg = NULL;
730:
731: /* move the shell to the foreground */
732: if (tcsetpgrp(0, getpid()))
733: perror("tcsetpgrp");
734: }
735: } else {
736: /* the child was stopped */
737: jobList.fg->stoppedProgs++;
738: jobList.fg->progs[i].isStopped = 1;
739:
740: if (jobList.fg->stoppedProgs ==
741: jobList.fg->runningProgs) {
742: printf("
" JOB_STATUS_FORMAT,
743: jobList.fg->jobId,
744: "Stopped", jobList.fg->text);
745: jobList.fg = NULL;
746: }
747: }
748:
749: if (!jobList.fg) {
750: /* move the shell to the foreground */
751: if (tcsetpgrp(0, getpid()))
752: perror("tcsetpgrp");
753: }
754: }
755: }
756:
757: return 0;
758: }
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.