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