![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmd3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ucb / Mail|
Return to cmd3.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ucb / Mail |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)cmd3.c 2.14 (Berkeley) 8/11/83";
3: #endif
4:
5: #include "rcv.h"
6: #include <sys/stat.h>
7:
8: /*
9: * Mail -- a mail program
10: *
11: * Still more user commands.
12: */
13:
14: /*
15: * Process a shell escape by saving signals, ignoring signals,
16: * and forking a sh -c
17: */
18:
19: shell(str)
20: char *str;
21: {
22: int (*sig[2])(), stat[1];
23: register int t;
24: char *Shell;
25: char cmd[BUFSIZ];
26:
27: strcpy(cmd, str);
28: if (bangexp(cmd) < 0)
29: return(-1);
30: if ((Shell = value("SHELL")) == NOSTR)
31: Shell = SHELL;
32: for (t = 2; t < 4; t++)
33: sig[t-2] = sigset(t, SIG_IGN);
34: t = vfork();
35: if (t == 0) {
36: sigchild();
37: for (t = 2; t < 4; t++)
38: if (sig[t-2] != SIG_IGN)
39: sigsys(t, SIG_DFL);
40: execl(Shell, Shell, "-c", cmd, 0);
41: perror(Shell);
42: _exit(1);
43: }
44: while (wait(stat) != t)
45: ;
46: if (t == -1)
47: perror("fork");
48: for (t = 2; t < 4; t++)
49: sigset(t, sig[t-2]);
50: printf("!\n");
51: return(0);
52: }
53:
54: /*
55: * Fork an interactive shell.
56: */
57:
58: dosh(str)
59: char *str;
60: {
61: int (*sig[2])(), stat[1];
62: register int t;
63: char *Shell;
64: if ((Shell = value("SHELL")) == NOSTR)
65: Shell = SHELL;
66: for (t = 2; t < 4; t++)
67: sig[t-2] = sigset(t, SIG_IGN);
68: t = vfork();
69: if (t == 0) {
70: sigchild();
71: for (t = 2; t < 4; t++)
72: if (sig[t-2] != SIG_IGN)
73: sigsys(t, SIG_DFL);
74: execl(Shell, Shell, 0);
75: perror(Shell);
76: _exit(1);
77: }
78: while (wait(stat) != t)
79: ;
80: if (t == -1)
81: perror("fork");
82: for (t = 2; t < 4; t++)
83: sigsys(t, sig[t-2]);
84: putchar('\n');
85: return(0);
86: }
87:
88: /*
89: * Expand the shell escape by expanding unescaped !'s into the
90: * last issued command where possible.
91: */
92:
93: char lastbang[128];
94:
95: bangexp(str)
96: char *str;
97: {
98: char bangbuf[BUFSIZ];
99: register char *cp, *cp2;
100: register int n;
101: int changed = 0;
102:
103: cp = str;
104: cp2 = bangbuf;
105: n = BUFSIZ;
106: while (*cp) {
107: if (*cp == '!') {
108: if (n < strlen(lastbang)) {
109: overf:
110: printf("Command buffer overflow\n");
111: return(-1);
112: }
113: changed++;
114: strcpy(cp2, lastbang);
115: cp2 += strlen(lastbang);
116: n -= strlen(lastbang);
117: cp++;
118: continue;
119: }
120: if (*cp == '\\' && cp[1] == '!') {
121: if (--n <= 1)
122: goto overf;
123: *cp2++ = '!';
124: cp += 2;
125: changed++;
126: }
127: if (--n <= 1)
128: goto overf;
129: *cp2++ = *cp++;
130: }
131: *cp2 = 0;
132: if (changed) {
133: printf("!%s\n", bangbuf);
134: fflush(stdout);
135: }
136: strcpy(str, bangbuf);
137: strncpy(lastbang, bangbuf, 128);
138: lastbang[127] = 0;
139: return(0);
140: }
141:
142: /*
143: * Print out a nice help message from some file or another.
144: */
145:
146: help()
147: {
148: register c;
149: register FILE *f;
150:
151: if ((f = fopen(HELPFILE, "r")) == NULL) {
152: perror(HELPFILE);
153: return(1);
154: }
155: while ((c = getc(f)) != EOF)
156: putchar(c);
157: fclose(f);
158: return(0);
159: }
160:
161: /*
162: * Change user's working directory.
163: */
164:
165: schdir(str)
166: char *str;
167: {
168: register char *cp;
169:
170: for (cp = str; *cp == ' '; cp++)
171: ;
172: if (*cp == '\0')
173: cp = homedir;
174: else
175: if ((cp = expand(cp)) == NOSTR)
176: return(1);
177: if (chdir(cp) < 0) {
178: perror(cp);
179: return(1);
180: }
181: return(0);
182: }
183:
184: /*
185: * Reply to a list of messages. Extract each name from the
186: * message header and send them off to mail1()
187: */
188:
189: respond(msgvec)
190: int *msgvec;
191: {
192: struct message *mp;
193: char *cp, *cp2, *cp3, *rcv, *replyto;
194: char buf[2 * LINESIZE], **ap;
195: struct name *np;
196: struct header head;
197:
198: if (msgvec[1] != 0) {
199: printf("Sorry, can't reply to multiple messages at once\n");
200: return(1);
201: }
202: mp = &message[msgvec[0] - 1];
203: dot = mp;
204: rcv = NOSTR;
205: cp = skin(nameof(mp, 1));
206: if (cp != NOSTR)
207: rcv = cp;
208: cp = skin(hfield("from", mp));
209: if (cp != NOSTR)
210: rcv = cp;
211: replyto = skin(hfield("reply-to", mp));
212: strcpy(buf, "");
213: if (replyto != NOSTR)
214: strcpy(buf, replyto);
215: else {
216: cp = skin(hfield("to", mp));
217: if (cp != NOSTR)
218: strcpy(buf, cp);
219: }
220: np = elide(extract(buf, GTO));
221: /* rcv = rename(rcv); */
222: mapf(np, rcv);
223: /*
224: * Delete my name from the reply list,
225: * and with it, all my alternate names.
226: */
227: np = delname(np, myname, icequal);
228: if (altnames)
229: for (ap = altnames; *ap; ap++)
230: np = delname(np, *ap, icequal);
231: head.h_seq = 1;
232: cp = detract(np, 0);
233: if (cp != NOSTR && replyto == NOSTR) {
234: strcpy(buf, cp);
235: strcat(buf, " ");
236: strcat(buf, rcv);
237: }
238: else {
239: if (cp == NOSTR && replyto != NOSTR)
240: printf("Empty reply-to field -- replying to author\n");
241: if (cp == NOSTR)
242: strcpy(buf, rcv);
243: else
244: strcpy(buf, cp);
245: }
246: head.h_to = buf;
247: head.h_subject = hfield("subject", mp);
248: if (head.h_subject == NOSTR)
249: head.h_subject = hfield("subj", mp);
250: head.h_subject = reedit(head.h_subject);
251: head.h_cc = NOSTR;
252: if (replyto == NOSTR) {
253: cp = hfield("cc", mp);
254: if (cp != NOSTR) {
255: np = elide(extract(cp, GCC));
256: mapf(np, rcv);
257: np = delname(np, myname, icequal);
258: if (altnames != 0)
259: for (ap = altnames; *ap; ap++)
260: np = delname(np, *ap, icequal);
261: head.h_cc = detract(np, 0);
262: }
263: }
264: head.h_bcc = NOSTR;
265: mail1(&head);
266: return(0);
267: }
268:
269: /*
270: * Modify the subject we are replying to to begin with Re: if
271: * it does not already.
272: */
273:
274: char *
275: reedit(subj)
276: char *subj;
277: {
278: char sbuf[10];
279: register char *newsubj;
280:
281: if (subj == NOSTR)
282: return(NOSTR);
283: strncpy(sbuf, subj, 3);
284: sbuf[3] = 0;
285: if (icequal(sbuf, "re:"))
286: return(subj);
287: newsubj = salloc(strlen(subj) + 6);
288: sprintf(newsubj, "Re: %s", subj);
289: return(newsubj);
290: }
291:
292: /*
293: * Preserve the named messages, so that they will be sent
294: * back to the system mailbox.
295: */
296:
297: preserve(msgvec)
298: int *msgvec;
299: {
300: register struct message *mp;
301: register int *ip, mesg;
302:
303: if (edit) {
304: printf("Cannot \"preserve\" in edit mode\n");
305: return(1);
306: }
307: for (ip = msgvec; *ip != NULL; ip++) {
308: mesg = *ip;
309: mp = &message[mesg-1];
310: mp->m_flag |= MPRESERVE;
311: mp->m_flag &= ~MBOX;
312: dot = mp;
313: }
314: return(0);
315: }
316:
317: /*
318: * Print the size of each message.
319: */
320:
321: messize(msgvec)
322: int *msgvec;
323: {
324: register struct message *mp;
325: register int *ip, mesg;
326:
327: for (ip = msgvec; *ip != NULL; ip++) {
328: mesg = *ip;
329: mp = &message[mesg-1];
330: printf("%d: %ld\n", mesg, mp->m_size);
331: }
332: return(0);
333: }
334:
335: /*
336: * Quit quickly. If we are sourcing, just pop the input level
337: * by returning an error.
338: */
339:
340: rexit(e)
341: {
342: if (sourcing)
343: return(1);
344: if (Tflag != NOSTR)
345: close(creat(Tflag, 0600));
346: exit(e);
347: }
348:
349: /*
350: * Set or display a variable value. Syntax is similar to that
351: * of csh.
352: */
353:
354: set(arglist)
355: char **arglist;
356: {
357: register struct var *vp;
358: register char *cp, *cp2;
359: char varbuf[BUFSIZ], **ap, **p;
360: int errs, h, s;
361:
362: if (argcount(arglist) == 0) {
363: for (h = 0, s = 1; h < HSHSIZE; h++)
364: for (vp = variables[h]; vp != NOVAR; vp = vp->v_link)
365: s++;
366: ap = (char **) salloc(s * sizeof *ap);
367: for (h = 0, p = ap; h < HSHSIZE; h++)
368: for (vp = variables[h]; vp != NOVAR; vp = vp->v_link)
369: *p++ = vp->v_name;
370: *p = NOSTR;
371: sort(ap);
372: for (p = ap; *p != NOSTR; p++)
373: printf("%s\t%s\n", *p, value(*p));
374: return(0);
375: }
376: errs = 0;
377: for (ap = arglist; *ap != NOSTR; ap++) {
378: cp = *ap;
379: cp2 = varbuf;
380: while (*cp != '=' && *cp != '\0')
381: *cp2++ = *cp++;
382: *cp2 = '\0';
383: if (*cp == '\0')
384: cp = "";
385: else
386: cp++;
387: if (equal(varbuf, "")) {
388: printf("Non-null variable name required\n");
389: errs++;
390: continue;
391: }
392: assign(varbuf, cp);
393: }
394: return(errs);
395: }
396:
397: /*
398: * Unset a bunch of variable values.
399: */
400:
401: unset(arglist)
402: char **arglist;
403: {
404: register struct var *vp, *vp2;
405: register char *cp;
406: int errs, h;
407: char **ap;
408:
409: errs = 0;
410: for (ap = arglist; *ap != NOSTR; ap++) {
411: if ((vp2 = lookup(*ap)) == NOVAR) {
412: if (!sourcing) {
413: printf("\"%s\": undefined variable\n", *ap);
414: errs++;
415: }
416: continue;
417: }
418: h = hash(*ap);
419: if (vp2 == variables[h]) {
420: variables[h] = variables[h]->v_link;
421: vfree(vp2->v_name);
422: vfree(vp2->v_value);
423: cfree(vp2);
424: continue;
425: }
426: for (vp = variables[h]; vp->v_link != vp2; vp = vp->v_link)
427: ;
428: vp->v_link = vp2->v_link;
429: vfree(vp2->v_name);
430: vfree(vp2->v_value);
431: cfree(vp2);
432: }
433: return(errs);
434: }
435:
436: /*
437: * Put add users to a group.
438: */
439:
440: group(argv)
441: char **argv;
442: {
443: register struct grouphead *gh;
444: register struct group *gp;
445: register int h;
446: int s;
447: char **ap, *gname, **p;
448:
449: if (argcount(argv) == 0) {
450: for (h = 0, s = 1; h < HSHSIZE; h++)
451: for (gh = groups[h]; gh != NOGRP; gh = gh->g_link)
452: s++;
453: ap = (char **) salloc(s * sizeof *ap);
454: for (h = 0, p = ap; h < HSHSIZE; h++)
455: for (gh = groups[h]; gh != NOGRP; gh = gh->g_link)
456: *p++ = gh->g_name;
457: *p = NOSTR;
458: sort(ap);
459: for (p = ap; *p != NOSTR; p++)
460: printgroup(*p);
461: return(0);
462: }
463: if (argcount(argv) == 1) {
464: printgroup(*argv);
465: return(0);
466: }
467: gname = *argv;
468: h = hash(gname);
469: if ((gh = findgroup(gname)) == NOGRP) {
470: gh = (struct grouphead *) calloc(sizeof *gh, 1);
471: gh->g_name = vcopy(gname);
472: gh->g_list = NOGE;
473: gh->g_link = groups[h];
474: groups[h] = gh;
475: }
476:
477: /*
478: * Insert names from the command list into the group.
479: * Who cares if there are duplicates? They get tossed
480: * later anyway.
481: */
482:
483: for (ap = argv+1; *ap != NOSTR; ap++) {
484: gp = (struct group *) calloc(sizeof *gp, 1);
485: gp->ge_name = vcopy(*ap);
486: gp->ge_link = gh->g_list;
487: gh->g_list = gp;
488: }
489: return(0);
490: }
491:
492: /*
493: * Sort the passed string vecotor into ascending dictionary
494: * order.
495: */
496:
497: sort(list)
498: char **list;
499: {
500: register char **ap;
501: int diction();
502:
503: for (ap = list; *ap != NOSTR; ap++)
504: ;
505: if (ap-list < 2)
506: return;
507: qsort(list, ap-list, sizeof *list, diction);
508: }
509:
510: /*
511: * Do a dictionary order comparison of the arguments from
512: * qsort.
513: */
514:
515: diction(a, b)
516: register char **a, **b;
517: {
518: return(strcmp(*a, *b));
519: }
520:
521: /*
522: * The do nothing command for comments.
523: */
524:
525: null(e)
526: {
527: return(0);
528: }
529:
530: /*
531: * Print out the current edit file, if we are editing.
532: * Otherwise, print the name of the person who's mail
533: * we are reading.
534: */
535:
536: file(argv)
537: char **argv;
538: {
539: register char *cp;
540: char fname[BUFSIZ];
541: int edit;
542:
543: if (argv[0] == NOSTR) {
544: newfileinfo();
545: return(0);
546: }
547:
548: /*
549: * Acker's! Must switch to the new file.
550: * We use a funny interpretation --
551: * # -- gets the previous file
552: * % -- gets the invoker's post office box
553: * %user -- gets someone else's post office box
554: * & -- gets invoker's mbox file
555: * string -- reads the given file
556: */
557:
558: cp = getfilename(argv[0], &edit);
559: if (cp == NOSTR)
560: return(-1);
561: if (setfile(cp, edit)) {
562: perror(cp);
563: return(-1);
564: }
565: newfileinfo();
566: }
567:
568: /*
569: * Evaluate the string given as a new mailbox name.
570: * Ultimately, we want this to support a number of meta characters.
571: * Possibly:
572: * % -- for my system mail box
573: * %user -- for user's system mail box
574: * # -- for previous file
575: * & -- get's invoker's mbox file
576: * file name -- for any other file
577: */
578:
579: char prevfile[PATHSIZE];
580:
581: char *
582: getfilename(name, aedit)
583: char *name;
584: int *aedit;
585: {
586: register char *cp;
587: char savename[BUFSIZ];
588: char oldmailname[BUFSIZ];
589:
590: /*
591: * Assume we will be in "edit file" mode, until
592: * proven wrong.
593: */
594: *aedit = 1;
595: switch (*name) {
596: case '%':
597: *aedit = 0;
598: strcpy(prevfile, mailname);
599: if (name[1] != 0) {
600: strcpy(savename, myname);
601: strcpy(oldmailname, mailname);
602: strncpy(myname, name+1, PATHSIZE-1);
603: myname[PATHSIZE-1] = 0;
604: findmail();
605: cp = savestr(mailname);
606: strcpy(myname, savename);
607: strcpy(mailname, oldmailname);
608: return(cp);
609: }
610: strcpy(oldmailname, mailname);
611: findmail();
612: cp = savestr(mailname);
613: strcpy(mailname, oldmailname);
614: return(cp);
615:
616: case '#':
617: if (name[1] != 0)
618: goto regular;
619: if (prevfile[0] == 0) {
620: printf("No previous file\n");
621: return(NOSTR);
622: }
623: cp = savestr(prevfile);
624: strcpy(prevfile, mailname);
625: return(cp);
626:
627: case '&':
628: strcpy(prevfile, mailname);
629: if (name[1] == 0)
630: return(mbox);
631: /* Fall into . . . */
632:
633: default:
634: regular:
635: strcpy(prevfile, mailname);
636: cp = expand(name);
637: return(cp);
638: }
639: }
640:
641: /*
642: * Expand file names like echo
643: */
644:
645: echo(argv)
646: char **argv;
647: {
648: register char **ap;
649: register char *cp;
650:
651: for (ap = argv; *ap != NOSTR; ap++) {
652: cp = *ap;
653: if ((cp = expand(cp)) != NOSTR)
654: printf("%s ", cp);
655: }
656: return(0);
657: }
658:
659: /*
660: * Reply to a series of messages by simply mailing to the senders
661: * and not messing around with the To: and Cc: lists as in normal
662: * reply.
663: */
664:
665: Respond(msgvec)
666: int msgvec[];
667: {
668: struct header head;
669: struct message *mp;
670: register int i, s, *ap;
671: register char *cp, *cp2, *subject;
672:
673: for (s = 0, ap = msgvec; *ap != 0; ap++) {
674: mp = &message[*ap - 1];
675: dot = mp;
676: if ((cp = skin(hfield("from", mp))) != NOSTR)
677: s+= strlen(cp) + 1;
678: else
679: s += strlen(skin(nameof(mp, 2))) + 1;
680: }
681: if (s == 0)
682: return(0);
683: cp = salloc(s + 2);
684: head.h_to = cp;
685: for (ap = msgvec; *ap != 0; ap++) {
686: mp = &message[*ap - 1];
687: if ((cp2 = skin(hfield("from", mp))) == NOSTR)
688: cp2 = skin(nameof(mp, 2));
689: cp = copy(cp2, cp);
690: *cp++ = ' ';
691: }
692: *--cp = 0;
693: mp = &message[msgvec[0] - 1];
694: subject = hfield("subject", mp);
695: head.h_seq = 0;
696: if (subject == NOSTR)
697: subject = hfield("subj", mp);
698: head.h_subject = reedit(subject);
699: if (subject != NOSTR)
700: head.h_seq++;
701: head.h_cc = NOSTR;
702: head.h_bcc = NOSTR;
703: mail1(&head);
704: return(0);
705: }
706:
707: /*
708: * Conditional commands. These allow one to parameterize one's
709: * .mailrc and do some things if sending, others if receiving.
710: */
711:
712: ifcmd(argv)
713: char **argv;
714: {
715: register char *cp;
716:
717: if (cond != CANY) {
718: printf("Illegal nested \"if\"\n");
719: return(1);
720: }
721: cond = CANY;
722: cp = argv[0];
723: switch (*cp) {
724: case 'r': case 'R':
725: cond = CRCV;
726: break;
727:
728: case 's': case 'S':
729: cond = CSEND;
730: break;
731:
732: default:
733: printf("Unrecognized if-keyword: \"%s\"\n", cp);
734: return(1);
735: }
736: return(0);
737: }
738:
739: /*
740: * Implement 'else'. This is pretty simple -- we just
741: * flip over the conditional flag.
742: */
743:
744: elsecmd()
745: {
746:
747: switch (cond) {
748: case CANY:
749: printf("\"Else\" without matching \"if\"\n");
750: return(1);
751:
752: case CSEND:
753: cond = CRCV;
754: break;
755:
756: case CRCV:
757: cond = CSEND;
758: break;
759:
760: default:
761: printf("Mail's idea of conditions is screwed up\n");
762: cond = CANY;
763: break;
764: }
765: return(0);
766: }
767:
768: /*
769: * End of if statement. Just set cond back to anything.
770: */
771:
772: endifcmd()
773: {
774:
775: if (cond == CANY) {
776: printf("\"Endif\" without matching \"if\"\n");
777: return(1);
778: }
779: cond = CANY;
780: return(0);
781: }
782:
783: /*
784: * Set the list of alternate names.
785: */
786: alternates(namelist)
787: char **namelist;
788: {
789: register int c;
790: register char **ap, **ap2, *cp;
791:
792: c = argcount(namelist) + 1;
793: if (c == 1) {
794: if (altnames == 0)
795: return(0);
796: for (ap = altnames; *ap; ap++)
797: printf("%s ", *ap);
798: printf("\n");
799: return(0);
800: }
801: if (altnames != 0)
802: cfree((char *) altnames);
803: altnames = (char **) calloc(c, sizeof (char *));
804: for (ap = namelist, ap2 = altnames; *ap; ap++, ap2++) {
805: cp = (char *) calloc(strlen(*ap) + 1, sizeof (char));
806: strcpy(cp, *ap);
807: *ap2 = cp;
808: }
809: *ap2 = 0;
810: return(0);
811: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.