![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to collect.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / ucbmail|
Return to collect.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / ucbmail |
1.1 root 1: #
2:
3: /*
4: * Mail -- a mail program
5: *
6: * Collect input from standard input, handling
7: * ~ escapes.
8: */
9:
10: #include "rcv.h"
11: #include <sys/stat.h>
12:
13: /*
14: * Read a message from standard output and return a read file to it
15: * or NULL on error.
16: */
17:
18: /*
19: * The following hokiness with global variables is so that on
20: * receipt of an interrupt signal, the partial message can be salted
21: * away on dead.letter. The output file must be available to flush,
22: * and the input to read. Several open files could be saved all through
23: * Mail if stdio allowed simultaneous read/write access.
24: */
25:
26: static int (*savesig)(); /* Previous SIGINT value */
27: static FILE *newi; /* File for saving away */
28: static FILE *newo; /* Output side of same */
29: static int hf; /* Ignore interrups */
30: static int nofault; /* Soft signal if set */
31: static int hadintr; /* Have seen one SIGINT so far */
32:
33: static jmp_buf coljmp; /* To get back to work */
34:
35: FILE *
36: collect(hp)
37: struct header *hp;
38: {
39: FILE *ibuf, *fbuf, *obuf;
40: int lc, cc, escape, collrub(), intack(), stopdot;
41: register int c, t;
42: char linebuf[LINESIZE], *cp;
43: extern char tempMail[];
44:
45: stopdot = (value("dot") != NOSTR) && intty;
46: ibuf = obuf = NULL;
47: if (value("ignore") != NOSTR)
48: hf = 1;
49: else
50: hf = 0;
51: nofault = 1;
52: hadintr = 0;
53: if ((savesig = signal(SIGINT, SIG_IGN)) != SIG_IGN)
54: signal(SIGINT, hf ? intack : collrub);
55: newi = NULL;
56: newo = NULL;
57: if ((obuf = fopen(tempMail, "w")) == NULL) {
58: perror(tempMail);
59: goto err;
60: }
61: newo = obuf;
62: if ((ibuf = fopen(tempMail, "r")) == NULL) {
63: perror(tempMail);
64: newo = NULL;
65: fclose(obuf);
66: goto err;
67: }
68: newi = ibuf;
69: remove(tempMail);
70: if (hp->h_seq != 0) {
71: puthead(hp, stdout, GTO|GSUBJECT|GCC);
72: fflush(stdout);
73: }
74: if (intty && hp->h_subject == NOSTR && value("ask"))
75: grabh(hp, GSUBJECT);
76: escape = ESCAPE;
77: if ((cp = value("escape")) != NOSTR)
78: escape = *cp;
79: for (;;) {
80: setjmp(coljmp);
81: nofault = 0;
82: flush();
83: if (readline(stdin, linebuf) <= 0)
84: break;
85: hadintr = 0;
86: if (stopdot && equal(".", linebuf))
87: break;
88: if (linebuf[0] != escape ||
89: (!intty && value("henry") == NOSTR)) {
90: if ((t = putline(obuf, linebuf)) < 0)
91: goto err;
92: continue;
93: }
94: c = linebuf[1];
95: nofault= 0;
96: switch (c) {
97: default:
98: /*
99: * On double escape, just send the single one.
100: * Otherwise, it's an error.
101: */
102:
103: if (c == escape) {
104: if (putline(obuf, &linebuf[1]) < 0)
105: goto err;
106: else
107: break;
108: }
109: printf("Unknown tilde escape.\n");
110: break;
111:
112: case 'C':
113: /*
114: * Dump core.
115: */
116:
117: core();
118: break;
119:
120: case '!':
121: /*
122: * Shell escape, send the balance of the
123: * line to sh -c.
124: */
125:
126: shell(&linebuf[2]);
127: break;
128:
129: case ':':
130: case '_':
131: /*
132: * Escape to command mode, but be nice!
133: */
134:
135: nofault = 0;
136: execute(&linebuf[2]);
137: break;
138:
139: case '.':
140: /*
141: * Simulate end of file on input.
142: */
143: goto eof;
144:
145: case 'q':
146: case 'Q':
147: /*
148: * Force a quit of sending mail.
149: * Act like an interrupt happened.
150: */
151:
152: nofault = 0;
153: hadintr++;
154: collrub(SIGINT);
155: exit(1);
156:
157: case 'h':
158: /*
159: * Grab a bunch of headers.
160: */
161: if (!intty || !outtty) {
162: printf("~h: no can do!?\n");
163: break;
164: }
165: grabh(hp, GTO|GSUBJECT|GCC);
166: printf("(continue)\n");
167: break;
168:
169: case 't':
170: /*
171: * Add to the To list.
172: */
173:
174: hp->h_to = addto(hp->h_to, &linebuf[2]);
175: hp->h_seq++;
176: break;
177:
178: case 's':
179: /*
180: * Set the Subject list.
181: */
182:
183: cp = &linebuf[2];
184: while (any(*cp, " \t"))
185: cp++;
186: hp->h_subject = savestr(cp);
187: hp->h_seq++;
188: break;
189:
190: case 'c':
191: /*
192: * Add to the CC list.
193: */
194:
195: hp->h_cc = addto(hp->h_cc, &linebuf[2]);
196: hp->h_seq++;
197: break;
198:
199: case 'b':
200: /*
201: * Add stuff to blind carbon copies list.
202: */
203: hp->h_bcc = addto(hp->h_bcc, &linebuf[2]);
204: hp->h_seq++;
205: break;
206:
207: case 'd':
208: copy(deadletter, &linebuf[2]);
209: /* fall into . . . */
210:
211: case 'r':
212: /*
213: * Invoke a file:
214: * Search for the file name,
215: * then open it and copy the contents to obuf.
216: */
217:
218: cp = &linebuf[2];
219: while (any(*cp, " \t"))
220: cp++;
221: if (*cp == '\0') {
222: printf("Interpolate what file?\n");
223: break;
224: }
225: cp = expand(cp);
226: if (cp == NOSTR)
227: break;
228: if (isdir(cp)) {
229: printf("%s: directory\n");
230: break;
231: }
232: if ((fbuf = fopen(cp, "r")) == NULL) {
233: perror(cp);
234: break;
235: }
236: printf("\"%s\" ", cp);
237: flush();
238: lc = 0;
239: cc = 0;
240: while (readline(fbuf, linebuf) > 0) {
241: lc++;
242: if ((t = putline(obuf, linebuf)) < 0) {
243: fclose(fbuf);
244: goto err;
245: }
246: cc += t;
247: }
248: fclose(fbuf);
249: printf("%d/%d\n", lc, cc);
250: break;
251:
252: case 'w':
253: /*
254: * Write the message on a file.
255: */
256:
257: cp = &linebuf[2];
258: while (any(*cp, " \t"))
259: cp++;
260: if (*cp == '\0') {
261: fprintf(stderr, "Write what file!?\n");
262: break;
263: }
264: if ((cp = expand(cp)) == NOSTR)
265: break;
266: fflush(obuf);
267: rewind(ibuf);
268: exwrite(cp, ibuf, 1);
269: break;
270:
271: case 'm':
272: case 'f':
273: /*
274: * Interpolate the named messages, if we
275: * are in receiving mail mode. Does the
276: * standard list processing garbage.
277: * If ~f is given, we don't shift over.
278: */
279:
280: if (!rcvmode) {
281: printf("No messages to send from!?!\n");
282: break;
283: }
284: cp = &linebuf[2];
285: while (any(*cp, " \t"))
286: cp++;
287: if (forward(cp, obuf, c) < 0)
288: goto err;
289: printf("(continue)\n");
290: break;
291:
292: case '?':
293: nofault = 0;
294: if ((fbuf = fopen(THELPFILE, "r")) == NULL) {
295: printf("No help just now.\n");
296: break;
297: }
298: t = getc(fbuf);
299: while (t != -1) {
300: putchar(t);
301: t = getc(fbuf);
302: }
303: fclose(fbuf);
304: break;
305:
306: case 'p':
307: /*
308: * Print out the current state of the
309: * message without altering anything.
310: */
311:
312: fflush(obuf);
313: rewind(ibuf);
314: nofault = 0;
315: printf("-------\nMessage contains:\n");
316: puthead(hp, stdout, GTO|GSUBJECT|GCC|GBCC);
317: t = getc(ibuf);
318: while (t != EOF) {
319: putchar(t);
320: t = getc(ibuf);
321: }
322: printf("(continue)\n");
323: break;
324:
325: case '^':
326: case '|':
327: /*
328: * Pipe message through command.
329: * Collect output as new message.
330: */
331:
332: obuf = mespipe(ibuf, obuf, &linebuf[2]);
333: newo = obuf;
334: ibuf = newi;
335: newi = ibuf;
336: printf("(continue)\n");
337: break;
338:
339: case 'v':
340: case 'e':
341: /*
342: * Edit the current message.
343: * 'e' means to use EDITOR
344: * 'v' means to use VISUAL
345: */
346:
347: if ((obuf = mesedit(ibuf, obuf, c)) == NULL)
348: goto err;
349: newo = obuf;
350: ibuf = newi;
351: printf("(continue)\n");
352: break;
353: break;
354: }
355: }
356: eof:
357: fclose(obuf);
358: rewind(ibuf);
359: signal(SIGINT, savesig);
360: return(ibuf);
361:
362: err:
363: if (ibuf != NULL)
364: fclose(ibuf);
365: if (obuf != NULL)
366: fclose(obuf);
367: signal(SIGINT, savesig);
368: return(NULL);
369: }
370:
371: /*
372: * Non destructively interrogate the value of the given signal.
373: */
374:
375: psig(n)
376: {
377: register (*wassig)();
378:
379: wassig = signal(n, SIG_IGN);
380: signal(n, wassig);
381: return((int) wassig);
382: }
383:
384: /*
385: * Write a file, ex-like if f set.
386: */
387:
388: exwrite(name, ibuf, f)
389: char name[];
390: FILE *ibuf;
391: {
392: register FILE *of;
393: register int c;
394: long cc;
395: int lc;
396: struct stat junk;
397:
398: if (f) {
399: printf("\"%s\" ", name);
400: fflush(stdout);
401: }
402: if (stat(name, &junk) >= 0) {
403: if (!f)
404: fprintf(stderr, "%s: ", name);
405: fprintf(stderr, "File exists\n", name);
406: return(-1);
407: }
408: if ((of = fopen(name, "w")) == NULL) {
409: perror(NOSTR);
410: return(-1);
411: }
412: lc = 0;
413: cc = 0;
414: while ((c = getc(ibuf)) != EOF) {
415: cc++;
416: if (c == '\n')
417: lc++;
418: putc(c, of);
419: if (ferror(of)) {
420: perror(name);
421: fclose(of);
422: return(-1);
423: }
424: }
425: fclose(of);
426: printf("%d/%ld\n", lc, cc);
427: fflush(stdout);
428: return(0);
429: }
430:
431: /*
432: * Edit the message being collected on ibuf and obuf.
433: * Write the message out onto some poorly-named temp file
434: * and point an editor at it.
435: *
436: * On return, make the edit file the new temp file.
437: */
438:
439: FILE *
440: mesedit(ibuf, obuf, c)
441: FILE *ibuf, *obuf;
442: {
443: int pid, s;
444: FILE *fbuf;
445: register int t;
446: int (*sig)();
447: struct stat sbuf;
448: extern char tempMail[], tempEdit[];
449: register char *edit;
450:
451: sig = signal(SIGINT, SIG_IGN);
452: if (stat(tempEdit, &sbuf) >= 0) {
453: printf("%s: file exists\n", tempEdit);
454: goto out;
455: }
456: close(creat(tempEdit, 0600));
457: if ((fbuf = fopen(tempEdit, "w")) == NULL) {
458: perror(tempEdit);
459: goto out;
460: }
461: fflush(obuf);
462: rewind(ibuf);
463: t = getc(ibuf);
464: while (t != EOF) {
465: putc(t, fbuf);
466: t = getc(ibuf);
467: }
468: fflush(fbuf);
469: if (ferror(fbuf)) {
470: perror(tempEdit);
471: remove(tempEdit);
472: goto fix;
473: }
474: fclose(fbuf);
475: if ((edit = value(c == 'e' ? "EDITOR" : "VISUAL")) == NOSTR)
476: edit = c == 'e' ? EDITOR : VISUAL;
477: pid = vfork();
478: if (pid == 0) {
479: if (sig != SIG_IGN)
480: signal(SIGINT, SIG_DFL);
481: execl(edit, edit, tempEdit, 0);
482: perror(edit);
483: _exit(1);
484: }
485: if (pid == -1) {
486: perror("fork");
487: remove(tempEdit);
488: goto out;
489: }
490: while (wait(&s) != pid)
491: ;
492: if (s != 0) {
493: printf("Fatal error in \"%s\"\n", edit);
494: remove(tempEdit);
495: goto out;
496: }
497:
498: /*
499: * Now switch to new file.
500: */
501:
502: if ((fbuf = fopen(tempEdit, "a")) == NULL) {
503: perror(tempEdit);
504: remove(tempEdit);
505: goto out;
506: }
507: if ((ibuf = fopen(tempEdit, "r")) == NULL) {
508: perror(tempEdit);
509: fclose(fbuf);
510: remove(tempEdit);
511: goto out;
512: }
513: remove(tempEdit);
514: fclose(obuf);
515: fclose(newi);
516: obuf = fbuf;
517: goto out;
518: fix:
519: perror(tempEdit);
520: out:
521: signal(SIGINT, sig);
522: newi = ibuf;
523: return(obuf);
524: }
525:
526: /*
527: * Pipe the message through the command.
528: * Old message is on stdin of command;
529: * New message collected from stdout.
530: * Sh -c must return 0 to accept the new message.
531: */
532:
533: FILE *
534: mespipe(ibuf, obuf, cmd)
535: FILE *ibuf, *obuf;
536: char cmd[];
537: {
538: register FILE *ni, *no;
539: int pid, s;
540: int (*savesig)();
541: char *Shell;
542:
543: newi = ibuf;
544: if ((no = fopen(tempEdit, "w")) == NULL) {
545: perror(tempEdit);
546: return(obuf);
547: }
548: if ((ni = fopen(tempEdit, "r")) == NULL) {
549: perror(tempEdit);
550: fclose(no);
551: remove(tempEdit);
552: return(obuf);
553: }
554: remove(tempEdit);
555: savesig = signal(SIGINT, SIG_IGN);
556: fflush(obuf);
557: rewind(ibuf);
558: if ((Shell = value("SHELL")) == NULL)
559: Shell = "/bin/sh";
560: if ((pid = vfork()) == -1) {
561: perror("fork");
562: goto err;
563: }
564: if (pid == 0) {
565: /*
566: * stdin = current message.
567: * stdout = new message.
568: */
569:
570: close(0);
571: dup(fileno(ibuf));
572: close(1);
573: dup(fileno(no));
574: for (s = 4; s < 15; s++)
575: close(s);
576: execl(Shell, Shell, "-c", cmd, 0);
577: perror(Shell);
578: _exit(1);
579: }
580: while (wait(&s) != pid)
581: ;
582: if (s != 0 || pid == -1) {
583: fprintf(stderr, "\"%s\" failed!?\n", cmd);
584: goto err;
585: }
586: if (fsize(ni) == 0) {
587: fprintf(stderr, "No bytes from \"%s\" !?\n", cmd);
588: goto err;
589: }
590:
591: /*
592: * Take new files.
593: */
594:
595: newi = ni;
596: fclose(ibuf);
597: fclose(obuf);
598: signal(SIGINT, savesig);
599: return(no);
600:
601: err:
602: fclose(no);
603: fclose(ni);
604: signal(SIGINT, savesig);
605: return(obuf);
606: }
607:
608: /*
609: * Interpolate the named messages into the current
610: * message, preceding each line with a tab.
611: * Return a count of the number of characters now in
612: * the message, or -1 if an error is encountered writing
613: * the message temporary. The flag argument is 'm' if we
614: * should shift over and 'f' if not.
615: */
616:
617: forward(ms, obuf, f)
618: char ms[];
619: FILE *obuf;
620: {
621: register int *msgvec, *ip;
622: extern char tempMail[];
623:
624: msgvec = (int *) salloc((msgCount+1) * sizeof *msgvec);
625: if (msgvec == (int *) NOSTR)
626: return(0);
627: if (getmsglist(ms, msgvec, 0) < 0)
628: return(0);
629: if (*msgvec == NULL) {
630: *msgvec = first(0, MMNORM);
631: if (*msgvec == NULL) {
632: printf("No appropriate messages\n");
633: return(0);
634: }
635: msgvec[1] = NULL;
636: }
637: printf("Interpolating:");
638: for (ip = msgvec; *ip != NULL; ip++) {
639: touch(*ip);
640: printf(" %d", *ip);
641: if (f == 'm') {
642: if (transmit(&message[*ip-1], obuf) < 0) {
643: perror(tempMail);
644: return(-1);
645: }
646: } else
647: if (send(&message[*ip-1], obuf) < 0) {
648: perror(tempMail);
649: return(-1);
650: }
651: }
652: printf("\n");
653: return(0);
654: }
655:
656: /*
657: * Send message described by the passed pointer to the
658: * passed output buffer. Insert a tab in front of each
659: * line. Return a count of the characters sent, or -1
660: * on error.
661: */
662:
663: transmit(mailp, obuf)
664: struct message *mailp;
665: FILE *obuf;
666: {
667: register struct message *mp;
668: register int c, ch;
669: int n, bol;
670: FILE *ibuf;
671:
672: mp = mailp;
673: ibuf = setinput(mp);
674: c = msize(mp);
675: n = c;
676: bol = 1;
677: while (c-- > 0) {
678: if (bol) {
679: bol = 0;
680: putc('\t', obuf);
681: n++;
682: if (ferror(obuf)) {
683: perror("/tmp");
684: return(-1);
685: }
686: }
687: ch = getc(ibuf);
688: if (ch == '\n')
689: bol++;
690: putc(ch, obuf);
691: if (ferror(obuf)) {
692: perror("/tmp");
693: return(-1);
694: }
695: }
696: return(n);
697: }
698:
699: /*
700: * On interrupt, go here to save the partial
701: * message on #/dead.letter.
702: * Then restore signals and execute the normal
703: * signal routine. We only come here if signals
704: * were previously set anyway.
705: */
706:
707: collrub(s)
708: {
709: register FILE *dbuf;
710: register int c;
711:
712: #ifdef V7
713: signal(s, SIG_IGN);
714: #else
715: signal(SIGINT, SIG_IGN);
716: #endif
717: if (nofault) {
718: #ifdef V7
719: signal(s, collrub);
720: #else
721: signal(SIGINT, collrub);
722: #endif
723: return;
724: }
725: if (hadintr == 0) {
726: hadintr++;
727: clrbuf(stdout);
728: printf("\n(Interrupt -- one more to kill letter)\n");
729: #ifdef V7
730: signal(s, collrub);
731: #else
732: signal(SIGINT, collrub);
733: #endif
734: longjmp(coljmp, 1);
735: }
736: fclose(newo);
737: rewind(newi);
738: if (value("nosave") != NOSTR)
739: goto done;
740: if ((dbuf = fopen(deadletter, "w")) == NULL)
741: goto done;
742: chmod(deadletter, 0600);
743: while ((c = getc(newi)) != EOF)
744: putc(c, dbuf);
745: fclose(dbuf);
746:
747: done:
748: fclose(newi);
749: signal(SIGINT, savesig);
750: if (rcvmode)
751: stop();
752: else
753: exit(1);
754: }
755:
756: /*
757: * Acknowledge an interrupt signal from the tty by typing an @
758: */
759:
760: intack(s)
761: {
762:
763: signal(SIGINT, SIG_IGN);
764: putchar('@');
765: fflush(stdout);
766: clearerr(stdin);
767: signal(SIGINT, intack);
768: }
769:
770: /*
771: * Add a string to the end of a header entry field.
772: */
773:
774: char *
775: addto(hf, news)
776: char hf[], news[];
777: {
778: register char *cp, *cp2, *linebuf;
779:
780: if (hf == NOSTR)
781: hf = "";
782: linebuf = salloc(strlen(hf) + strlen(news) + 1);
783: for (cp = hf; any(*cp, " \t"); cp++)
784: ;
785: for (cp2 = linebuf; *cp;)
786: *cp2++ = *cp++;
787: *cp2++ = ' ';
788: for (cp = news; any(*cp, " \t"); cp++)
789: ;
790: while (*cp != '\0')
791: *cp2++ = *cp++;
792: *cp2 = '\0';
793: return(linebuf);
794: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.