![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / sh.420|
Return to main.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / sh.420 |
1.1 root 1: /*
2: * sh/main.c
3: * The Bourne shell.
4: * Main program, initialization and miscellaneous routines.
5: */
6:
7: #include <assert.h>
8: #include <stdarg.h>
9: #include "sh.h"
10: #include <fcntl.h>
11:
12: void fakearg ();
13: void reset ();
14: void ecantopen ();
15: void panic ();
16: void printe ();
17: void syntax ();
18:
19:
20: int
21: main(argc, argv, envp)
22: char *argv[];
23: char *envp[];
24: {
25:
26: sarg0 = argc > 0 ? argv [0] : "";
27: fakearg (0, argc, argv, envp);
28:
29: if (argc > 0 && argv [0][0] == '-') {
30: lgnflag = 1;
31: umask (ufmask = 022);
32: } else if (argc > 0 && argv [0][0] == '+') {
33: lgnflag = 2;
34: umask (ufmask = 022);
35: } else
36: umask (ufmask = umask (ufmask));
37:
38: /*
39: * NIGEL: we must *force* stdin to be unbuffered to defeat some
40: * excessive cleverness in the stdio library. Note that line-buffering
41: * is a mode that only applies to output.
42: */
43:
44: if (setvbuf (stdin, NULL, _IONBF, BUFSIZ) != 0)
45: printe ("Cannot set stdin buffering\n");
46:
47: if (setjmp (restart) != 0) {
48: /* reentry for shell command file execution */
49: fakearg (1, nargc, nargv, nenvp);
50: argc = nargc;
51: argv = nargv;
52: envp = nenvp;
53: cmdflag ++;
54: nllflag = 0;
55: }
56:
57: shpid = getpid ();
58: initvar (envp);
59:
60: if (set (argc, argv, 1))
61: return 1;
62:
63: if (cflag) {
64: if (sargp [0] == NULL) {
65: printe ("No string for -c?");
66: return 1;
67: }
68: -- sargc;
69: session (SARGS, * sargp ++);
70: } else if (! sflag && ! iflag && sargc != 0) {
71: sarg0 = * sargp ++;
72: --sargc;
73: if (scmdp == NULL)
74: scmdp = sarg0;
75: session (SFILE, scmdp);
76: } else
77: session (SSTR, stdin);
78:
79: cleanup_shell_fns ();
80: unlink_temp (capture_temp ());
81: return slret;
82: }
83:
84:
85: /*
86: * Make the arg listing of ps come out right.
87: * f == 0, first entry, determine buffer limits.
88: * f != 0, later entry, fill buffer with lies.
89: */
90:
91: void
92: fakearg(f, argc, argv, envp)
93: int f, argc;
94: char **argv, **envp;
95: {
96: static char *fbuf;
97: static int nbuf;
98: register int n;
99:
100: if (f == 0) {
101: fbuf = argv [0];
102: nbuf = 0;
103: if (envp != NULL && envp [0] != NULL) {
104: while (envp [1] != NULL)
105: envp += 1;
106: nbuf = envp [0] - fbuf + strlen (envp [0]) - 1;
107: } else if (argc > 0)
108: nbuf = argv [argc - 1] - fbuf +
109: strlen (argv [argc - 1]) - 1;
110: } else {
111: if (fbuf == NULL || nbuf == 0)
112: return;
113: n = 0;
114: fbuf [0] = 0;
115: while (-- argc > 0) {
116: argv += 1;
117: n += strlen (argv [0]) + 1;
118: if (n >= nbuf)
119: break;
120: strcat (fbuf, argv [0]);
121: strcat (fbuf, " ");
122: }
123: strcat (fbuf, "\1"); /* non-ascii terminator */
124: }
125: }
126:
127:
128: /*
129: * Push a session of the indicated type. A non-zero return value is the
130: * appropriate return value for the session, but offset by one.
131: */
132:
133: int
134: push_session (type, info, session)
135: int type;
136: __VOID__ * info;
137: SES * session;
138: {
139: session->s_next = sesp;
140: sesp = session;
141: session->s_bpp = savebuf ();
142:
143: switch (session->s_type = type) {
144: case SARGS:
145: session->s_strp = (char *) info;
146: session->s_flag = 0;
147: break;
148:
149: case SARGV:
150: session->s_argv = (char **) info;
151: if ((session->s_strp = session->s_argv [0]) == NULL)
152: return 1;
153: session->s_flag = 0;
154: break;
155:
156: case SFILE:
157: session->s_strp = (char *) info;
158:
159: /*
160: * NIGEL: We should take steps to ensure that the file
161: * descriptors created for these input files lie above the
162: * range that can be redirected in scripts!
163: */
164:
165: if ((type = open (session->s_strp, O_RDONLY)) < 0) {
166: ecantopen (session->s_strp);
167: return 2;
168: }
169: if (type > 9) {
170: int scan;
171: for (scan = 10 ; scan < FOPEN_MAX ; scan ++) {
172: if (fcntl (scan, F_GETFD) == -1) {
173: /*
174: * Move the new FD to the new place.
175: */
176:
177: dup2 (type, scan);
178: close (type);
179: type = scan;
180:
181: break;
182: }
183: }
184: }
185: if ((session->s_ifp = fdopen (type, "r")) == NULL) {
186: ecantopen (session->s_strp);
187: return 2;
188: }
189: session->s_flag = isatty (fileno (session->s_ifp)) &&
190: isatty (2);
191: break;
192:
193: case SSTR:
194: session->s_strp = NULL;
195: session->s_ifp = (FILE *) info;
196: session->s_flag = isatty (fileno (session->s_ifp)) &&
197: isatty (2);
198: break;
199: }
200:
201: return 0;
202: }
203:
204:
205: /*
206: * Pop the passed-in session, which must be the current session.
207: */
208:
209: void
210: pop_session (session)
211: SES * session;
212: {
213: assert (sesp == session);
214:
215: freebuf (session->s_bpp);
216:
217: if (session->s_type == SFILE)
218: fclose (session->s_ifp);
219:
220: if (session->s_next == NULL) {
221: sigintr (0);
222: recover (IRDY);
223: }
224:
225: sesp = session->s_next;
226: }
227:
228:
229: /*
230: * Loop on input.
231: */
232:
233: int
234: session(t, p)
235: register char *p;
236: {
237: SES s;
238: register int rcode;
239:
240: if ((rcode = push_session (t, p, & s)) > 0)
241: return rcode - 1;
242:
243: if (s.s_next == NULL) { /* Initial entry */
244: if (iflag)
245: s.s_flag = iflag;
246: else
247: iflag = s.s_flag;
248: dflttrp (IRDY);
249: }
250:
251: /* Loop on input */
252: for (;;) {
253: unlink_temp (capture_temp ());
254:
255: rcode = setjmp (s.s_envl);
256: switch (rcode) {
257: case RSET: /* initial setjmp call */
258: switch (lgnflag) {
259: case 1: /* - sign invocation */
260: lgnflag = 0;
261: if (ffind ("/etc", "profile", 4))
262: session (SFILE, duplstr (strt, 0));
263: recover (IPROF);
264: if (* vhome && ffind (vhome, ".profile", 4))
265: session (SFILE, duplstr (strt, 0));
266: break;
267:
268: case 2: /* + sign invocation */
269: lgnflag = 0;
270: if (ffind ("/etc", "profile", 4))
271: session (SFILE, duplstr (strt, 0));
272: recover (IPROF);
273: return exshell (findvar ("SHELL"));
274: }
275: checkmail ();
276: comflag = 1;
277: errflag = 0;
278: recover (IRDY);
279: freebuf (s.s_bpp);
280: s.s_bpp = savebuf ();
281: if (yyparse () != 0)
282: syntax ();
283:
284: case REOF:
285: recover (IRDY);
286: break;
287:
288: case RCMD:
289: recover (IRDY);
290: s.s_con = NULL;
291: command (s.s_node);
292: if (tflag && tflag ++ >= 2)
293: break;
294: continue;
295:
296: case RERR:
297: recover (IRDY);
298: if (! errflag)
299: syntax ();
300: if (! iflag || (tflag && tflag ++ >= 2))
301: break;
302: continue;
303:
304: case RINT:
305: if (s.s_next != NULL) {
306: sesp = s.s_next;
307: reset (RINT);
308: NOTREACHED;
309: }
310: prpflag = 2;
311: if (! iflag || (tflag && tflag ++ >= 2))
312: break;
313: continue;
314:
315: case RUEXITS:
316: case RUABORT:
317: if (s.s_next != NULL) {
318: sesp = s.s_next;
319: reset (rcode);
320: NOTREACHED;
321: }
322: if (rcode == RUEXITS || ! iflag ||
323: (tflag && tflag ++ >= 2))
324: break;
325: continue;
326:
327: case RNOSBRK:
328: case RSYSER:
329: case RBRKCON:
330: case RNOWAY:
331: default:
332: if (s.s_next != NULL)
333: break;
334: if (! iflag || (tflag && tflag ++ >= 2))
335: break;
336: continue;
337: }
338: break;
339: }
340:
341: pop_session (& s);
342: return (slret);
343: }
344:
345:
346: void
347: reset (f)
348: {
349: longjmp (sesp->s_envl, f);
350: NOTREACHED;
351: }
352:
353:
354: /*
355: * Global head of list of temporary files.
356: */
357:
358: static TEMP_FILE * temp_list;
359:
360: ALLOC_COUNT (temp)
361:
362: /*
363: * Remember the name of a temporary file.
364: */
365:
366: void
367: remember_temp (filename)
368: char * filename;
369: {
370: TEMP_FILE * temp = (TEMP_FILE *) salloc (sizeof (* temp));
371:
372: temp->tf_name = duplstr (filename, 1);
373: temp->tf_next = temp_list;
374: temp_list = temp;
375:
376: ALLOC_ALLOC (temp)
377: }
378:
379:
380: /*
381: * Return a pointer to the current global list of temporary files and clear
382: * the global pointer to that list.
383: */
384:
385: TEMP_FILE *
386: capture_temp ()
387: {
388: TEMP_FILE * temp = temp_list;
389:
390: temp_list = NULL;
391: return temp;
392: }
393:
394:
395: /*
396: * Deallocate a list of temporary files.
397: */
398:
399: void
400: forget_temp (templist)
401: TEMP_FILE * templist;
402: {
403: TEMP_FILE * temp;
404:
405: while ((temp = templist) != NULL) {
406:
407: templist = temp->tf_next;
408:
409: ALLOC_FREE (temp);
410: sfree (temp->tf_name);
411: sfree (temp);
412: }
413: }
414:
415:
416: /*
417: * Walk over a list of temporary files, unlinking the files and deallocating
418: * the list nodes.
419: */
420:
421: void
422: unlink_temp (templist)
423: TEMP_FILE * templist;
424: {
425: TEMP_FILE * temp;
426:
427: while ((temp = templist) != NULL) {
428:
429: templist = temp->tf_next;
430: unlink (temp->tf_name);
431:
432: ALLOC_FREE (temp)
433: sfree (temp->tf_name);
434: sfree (temp);
435: }
436: }
437:
438:
439: /*
440: * Make a temp file name.
441: */
442:
443: char *
444: shtmp ()
445: {
446: static char tmpfile [] = "/tmp/shXXXXXXX";
447: static int tmpflag = 0;
448:
449: tmpflag ++;
450: sprintf (tmpfile + 6, "%05d%c%c", shpid, tmpflag % 26 + 'a',
451: (tmpflag / 26) % 26 + 'a');
452: return tmpfile;
453: }
454:
455:
456: /*
457: * Print formatted.
458: */
459:
460: void
461: prints (format /* , ... */)
462: char * format;
463: {
464: va_list args;
465:
466: va_start (args, format);
467: vfprintf (stderr, format, args);
468: va_end (args);
469: }
470:
471:
472: /*
473: * Make a core dump in /tmp and longjmp back to session -
474: * there's a possibility we'll die horribly.
475: */
476:
477: void
478: panic (i)
479: int i;
480: {
481: #ifdef PARANOID
482: register int f;
483:
484: if ((f = fork ()) == 0) {
485: abort ();
486: NOTREACHED;
487: }
488: waitc (f);
489: #endif
490: printe ("Internal shell assertion %d failed", i);
491: reset (RNOWAY);
492: NOTREACHED;
493: }
494:
495:
496: /*
497: * Print out an error message.
498: */
499:
500: void
501: printe (format /* , ... */)
502: char * format;
503: {
504: errflag += 1;
505: if (! noeflag) {
506: va_list args;
507:
508: va_start (args, format);
509: vfprintf (stderr, format, args);
510: va_end (args);
511: fprintf (stderr, "\n");
512: }
513: }
514:
515: /*
516: * Some familiar errors.
517: */
518:
519: void ecantopen(s) char *s; { printe ("Cannot open %s", s); }
520: void ecantfind(s) char *s; { printe ("Cannot find %s", s); }
521: void e2big(s) char *s; { printe ("File to big to execute: %s", s); }
522: void ecantmake(s) char *s; { printe ("Cannot create %s", s); }
523: void emisschar(c) { printe ("Missing `%c'", c); }
524: void ecantfdop() { printe ("Fdopen failed"); }
525: void enotdef(s) char *s; { printe ("Cannot find variable %s", s); }
526: void eillvar(s) char *s; { printe ("Illegal variable name: %s", s); }
527: void eredir() { printe ("Illegal redirection"); }
528: void etoolong(s) char *s; {
529: printe ("Argument too long %s: %.*s", s, STRSIZE, strt);
530: }
531: void eredirundo() {
532: printe ("Unable to preserve redirection state when redirecting builtin");
533: }
534:
535:
536: /*
537: * Don't print out an error message.
538: */
539:
540: void
541: yyerror()
542: {
543: }
544:
545:
546: /*
547: * print out the prompt given the prompt to write
548: */
549:
550: void
551: prompt(vps)
552: char *vps;
553: {
554: prints ("%s", vps);
555: #if RSX
556: fflush (stdout);
557: #endif
558: }
559:
560:
561: /*
562: * Syntax error message - print line number and file if
563: * not interactive.
564: */
565:
566: void
567: syntax()
568: {
569: if (sesp->s_type == SFILE) {
570: if (feof (sesp->s_ifp))
571: printe ("%s: Syntax error at EOF", sesp->s_strp);
572: else
573: printe ("%s: Syntax error in line %d", sesp->s_strp,
574: yyline);
575: } else
576: printe ("Syntax error");
577: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.