![[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 / mailx|
Return to collect.c CVS log | Up to [Research Unix] / researchv10no / lbin / mailx |
1.1 root 1: #ident "@(#)collect.c 1.7 'attmail mail(1) command'"
2: #ident "@(#)mailx:collect.c 1.18.1.1"
3: /* Copyright (c) 1984 AT&T */
4: /* All Rights Reserved */
5:
6: /* THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T */
7: /* The copyright notice above does not evidence any */
8: /* actual or intended publication of such source code. */
9:
10: #ident "@(#)mailx:collect.c 1.16.1.1"
11:
12: /*
13: * mailx -- a modified version of a University of California at Berkeley
14: * mail program
15: *
16: * Collect input from standard input, handling
17: * ~ escapes.
18: */
19:
20: #include "rcv.h"
21:
22: #ifdef SIGCONT
23: static void collcont();
24: #endif
25: static void collrub();
26: static void cpout();
27: static int exwrite();
28: static int forward();
29: static void intack();
30: static FILE *mesedit();
31: static FILE *mespipe();
32: static void resetsigs();
33: static int stripnulls();
34: static long transmit();
35: static void xhalt();
36: static char **Xaddone();
37:
38: /*
39: * Read a message from standard output and return a read file to it
40: * or NULL on error.
41: */
42:
43: /*
44: * The following hokiness with global variables is so that on
45: * receipt of an interrupt signal, the partial message can be salted
46: * away on dead.letter. The output file must be available to flush,
47: * and the input to read. Several open files could be saved all through
48: * mailx if stdio allowed simultaneous read/write access.
49: */
50:
51: static void (*savesig)(); /* Previous SIGINT value */
52: static void (*savehup)(); /* Previous SIGHUP value */
53: #ifdef SIGCONT
54: static void (*savecont)(); /* Previous SIGCONT value */
55: #endif
56: static FILE *newi; /* File for saving away */
57: static FILE *newo; /* Output side of same */
58: static int hf; /* Ignore interrups */
59: static int hadintr; /* Have seen one SIGINT so far */
60: static struct header *savehp;
61: static jmp_buf coljmp; /* To get back to work */
62:
63: FILE *
64: collect(hp)
65: struct header *hp;
66: {
67: FILE *ibuf, *fbuf, *obuf;
68: int escape, eof;
69: long lc, cc;
70: register int c, t;
71: char linebuf[LINESIZE+1], *cp;
72: char *iprompt;
73: void (*sigpipe)(), (*sigint)();
74:
75: noreset++;
76: ibuf = obuf = NULL;
77: newi = newo = NULL;
78: if ((obuf = fopen(tempMail, "w")) == NULL) {
79: perror(tempMail);
80: goto err;
81: }
82: newo = obuf;
83: if ((ibuf = fopen(tempMail, "r")) == NULL) {
84: perror(tempMail);
85: newo = NULL;
86: fclose(obuf);
87: goto err;
88: }
89: newi = ibuf;
90: removefile(tempMail);
91:
92: hf = !!value("ignore");
93: hadintr = 1;
94: savehp = hp;
95: if ((savesig = sigset(SIGINT, SIG_IGN)) != (void (*)())SIG_IGN)
96: sigset(SIGINT, hf ? (void (*)())intack : (void (*)())collrub);
97: if ((savehup = sigset(SIGHUP, SIG_IGN)) != (void (*)())SIG_IGN)
98: sigset(SIGHUP, collrub);
99: #ifdef SIGCONT
100: # ifdef preSVr4
101: savecont = sigset(SIGCONT, collcont);
102: # else
103: {
104: struct sigaction nsig, osig;
105: nsig.sa_handler = collcont;
106: sigemptyset(&nsig.sa_mask);
107: nsig.sa_flags = SA_RESTART;
108: (void) sigaction(SIGCONT, &nsig, &osig);
109: savecont = osig.sa_handler;
110: }
111: # endif
112: #endif
113: /*
114: * If we are going to prompt for subject/cc/bcc,
115: * refrain from printing a newline after
116: * the headers (since some people mind).
117: */
118:
119: if (hp->h_subject == NOSTR) {
120: hp->h_subject = sflag;
121: sflag = NOSTR;
122: }
123: t = GMASK;
124: c = 0;
125: if (intty) {
126: if (hp->h_subject == NOSTR && value("asksub"))
127: c |= GSUBJECT;
128: /* adb: due to popular demand, these were moved to the end of the letter
129: * adb: if (hp->h_cc == NOSTR && value("askcc"))
130: * adb: c |= GCC;
131: * adb: if (hp->h_bcc == NOSTR && value("askbcc"))
132: * adb: c |= GBCC;
133: * adb */
134: if (c)
135: t &= ~GNL;
136: }
137: if (hp->h_seq != 0) {
138: puthead(hp, stdout, t);
139: fflush(stdout);
140: }
141: if (setjmp(coljmp))
142: goto err;
143: if (c)
144: grabh(hp, c, 1);
145: escape = SENDESC;
146: if ((cp = value("escape")) != NOSTR)
147: escape = *cp;
148: eof = 0;
149: if ((cp = value("MAILX_HEAD")) != NOSTR) {
150: cpout( cp, obuf);
151: if (isatty(fileno(stdin)))
152: cpout( cp, stdout);
153: }
154: iprompt = value("iprompt");
155: fflush(obuf);
156: hadintr = 0;
157: for (;;) {
158: int nread, hasnulls;
159: setjmp(coljmp);
160: sigrelse(SIGINT);
161: sigrelse(SIGHUP);
162: if (intty && outtty && iprompt)
163: fputs(iprompt, stdout);
164: flush();
165: if ((nread = getline(linebuf,LINESIZE,stdin,&hasnulls)) == NULL) {
166: if (intty && value("ignoreeof") != NOSTR) {
167: if (++eof > 35)
168: break;
169: printf("Use \".\" to terminate letter\n");
170: continue;
171: }
172: break;
173: }
174: eof = 0;
175: hadintr = 0;
176: if (intty && equal(".\n", linebuf) &&
177: (value("dot") != NOSTR || value("ignoreeof") != NOSTR))
178: break;
179: if ((linebuf[0] != escape) || (rflag != NOSTR) || !intty) {
180: if (write(fileno(obuf),linebuf,nread) != nread)
181: goto err;
182: continue;
183: }
184: /*
185: * On double escape, just send the single one.
186: */
187: if ((nread > 1) && (linebuf[1] == escape)) {
188: if (write(fileno(obuf),linebuf+1,nread-1) != (nread-1))
189: goto err;
190: continue;
191: }
192: if (hasnulls)
193: nread = stripnulls(linebuf, nread);
194: c = linebuf[1];
195: linebuf[nread - 1] = '\0';
196: switch (c) {
197: default:
198: /*
199: * Otherwise, it's an error.
200: */
201: printf("Unknown tilde escape.\n");
202: break;
203:
204: case 'a':
205: case 'A':
206: /*
207: * autograph; sign the letter.
208: */
209:
210: if (cp = value(c=='a' ? "sign":"Sign")) {
211: cpout( cp, obuf);
212: if (isatty(fileno(stdin)))
213: cpout( cp, stdout);
214: }
215:
216: break;
217:
218: case 'i':
219: /*
220: * insert string
221: */
222: for (cp = &linebuf[2]; any(*cp, " \t"); cp++)
223: ;
224: if (*cp)
225: cp = value(cp);
226: if (cp != NOSTR) {
227: cpout(cp, obuf);
228: if (isatty(fileno(stdout)))
229: cpout(cp, stdout);
230: }
231: break;
232:
233: case '!':
234: /*
235: * Shell escape, send the balance of the
236: * line to sh -c.
237: */
238:
239: shell(&linebuf[2]);
240: break;
241:
242: case ':':
243: case '_':
244: /*
245: * Escape to command mode, but be nice!
246: */
247:
248: execute(&linebuf[2], 1);
249: iprompt = value("iprompt");
250: if (cp = value("escape"))
251: escape = *cp;
252: printf("(continue)\n");
253: break;
254:
255: case '.':
256: /*
257: * Simulate end of file on input.
258: */
259: goto eofl;
260:
261: case 'q':
262: case 'Q':
263: /*
264: * Force a quit of sending mail.
265: * Act like an interrupt happened.
266: */
267:
268: hadintr++;
269: collrub(SIGINT);
270: exit(1);
271: /* NOTREACHED */
272:
273: case 'x':
274: xhalt();
275: break; /* not reached */
276:
277: case 'h':
278: /*
279: * Grab a bunch of headers.
280: */
281: if (!intty || !outtty) {
282: printf("~h: no can do!?\n");
283: break;
284: }
285: grabh(hp, GMASK, 0);
286: printf("(continue)\n");
287: break;
288:
289: case 't':
290: /*
291: * Add to the To list.
292: */
293:
294: hp->h_to = addto(hp->h_to, &linebuf[2]);
295: hp->h_seq++;
296: break;
297:
298: case 's':
299: /*
300: * Set the Subject list.
301: */
302:
303: cp = &linebuf[2];
304: while (any(*cp, " \t"))
305: cp++;
306: hp->h_subject = savestr(cp);
307: hp->h_seq++;
308: break;
309:
310: case 'c':
311: /*
312: * Add to the CC list.
313: */
314:
315: hp->h_cc = addto(hp->h_cc, &linebuf[2]);
316: hp->h_seq++;
317: break;
318:
319: case 'b':
320: /*
321: * Add stuff to blind carbon copies list.
322: */
323: hp->h_bcc = addto(hp->h_bcc, &linebuf[2]);
324: hp->h_seq++;
325: break;
326:
327: case 'R':
328: hp->h_defopt = addone(hp->h_defopt, "/receipt");
329: hp->h_seq++;
330: fprintf(stderr, "Return receipt marked.\n");
331: break;
332:
333: case 'd':
334: copy(Getf("DEAD"), &linebuf[2]);
335: /* FALLTHROUGH */
336:
337: case '<':
338: case 'r': {
339: int ispip;
340: /*
341: * Invoke a file:
342: * Search for the file name,
343: * then open it and copy the contents to obuf.
344: *
345: * if name begins with '!', read from a command
346: */
347:
348: cp = &linebuf[2];
349: while (any(*cp, " \t"))
350: cp++;
351: if (*cp == '\0') {
352: printf("Interpolate what file?\n");
353: break;
354: }
355: if (*cp=='!') {
356: /* take input from a command */
357: ispip = 1;
358: if ((fbuf = npopen(++cp, "r"))==NULL) {
359: perror("");
360: break;
361: }
362: sigint = sigset(SIGINT, SIG_IGN);
363: } else {
364: ispip = 0;
365: cp = expand(cp);
366: if (cp == NOSTR)
367: break;
368: if (isdir(cp)) {
369: printf("%s: directory\n",cp);
370: break;
371: }
372: if ((fbuf = fopen(cp, "r")) == NULL) {
373: perror(cp);
374: break;
375: }
376: }
377: printf("\"%s\" ", cp);
378: flush();
379: lc = cc = 0;
380: while ((t = getc(fbuf)) != EOF) {
381: if (t == '\n')
382: lc++;
383: if (putc(t, obuf) == EOF) {
384: if (ispip) {
385: npclose(fbuf);
386: sigset(SIGINT, sigint);
387: } else
388: fclose(fbuf);
389: goto err;
390: }
391: cc++;
392: }
393: if (ispip) {
394: npclose(fbuf);
395: sigset(SIGINT, sigint);
396: } else
397: fclose(fbuf);
398: printf("%ld/%ld\n", lc, cc);
399: fflush(obuf);
400: break;
401: }
402:
403: case 'w':
404: /*
405: * Write the message on a file.
406: */
407:
408: cp = &linebuf[2];
409: while (any(*cp, " \t"))
410: cp++;
411: if (*cp == '\0') {
412: fprintf(stderr, "Write what file!?\n");
413: break;
414: }
415: if ((cp = expand(cp)) == NOSTR)
416: break;
417: fflush(obuf);
418: rewind(ibuf);
419: exwrite(cp, ibuf);
420: break;
421:
422: case 'm':
423: case 'f':
424: /*
425: * Interpolate the named messages, if we
426: * are in receiving mail mode. Does the
427: * standard list processing garbage.
428: * If ~f is given, we don't shift over.
429: */
430:
431: if (!rcvmode) {
432: printf("No messages to send from!?!\n");
433: break;
434: }
435: cp = &linebuf[2];
436: while (any(*cp, " \t"))
437: cp++;
438: if (forward(cp, obuf, c) < 0)
439: goto err;
440: fflush(obuf);
441: printf("(continue)\n");
442: break;
443:
444: case '?':
445: if ((fbuf = fopen(THELPFILE, "r")) == NULL) {
446: printf("No help just now.\n");
447: break;
448: }
449: t = getc(fbuf);
450: while (t != -1) {
451: putchar(t);
452: t = getc(fbuf);
453: }
454: fclose(fbuf);
455: break;
456:
457: case 'p':
458: /*
459: * Print out the current state of the
460: * message without altering anything.
461: */
462:
463: fflush(obuf);
464: rewind(ibuf);
465: if (value("crt")) {
466: char *pg = PG;
467: if (!*pg)
468: pg = "cat";
469: if (fbuf = npopen(pg, "w")) { /* adb */
470: sigint = sigset(SIGINT, SIG_IGN);
471: sigpipe = sigset(SIGPIPE, SIG_IGN);
472: } else
473: fbuf = stdout;
474: } else
475: fbuf = stdout;
476: fprintf(fbuf, "-------\nMessage contains:\n");
477: puthead(hp, fbuf, GMASK);
478: while ((t = getc(ibuf))!=EOF)
479: putc(t, fbuf);
480: if (fbuf != stdout) {
481: npclose(fbuf);
482: sigset(SIGPIPE, sigpipe);
483: sigset(SIGINT, sigint);
484: }
485: printf("(continue)\n");
486: break;
487:
488: case '^':
489: case '|':
490: /*
491: * Pipe message through command.
492: * Collect output as new message.
493: */
494:
495: obuf = mespipe(ibuf, obuf, &linebuf[2]);
496: newo = obuf;
497: ibuf = newi;
498: newi = ibuf;
499: printf("(continue)\n");
500: break;
501:
502: case 'v':
503: case 'e':
504: /*
505: * Edit the current message.
506: * 'e' means to use EDITOR
507: * 'v' means to use VISUAL
508: */
509:
510: if ((obuf = mesedit(ibuf, obuf, c, hp)) == NULL)
511: goto err;
512: newo = obuf;
513: ibuf = newi;
514: printf("(continue)\n");
515: break;
516: }
517: fflush(obuf);
518: }
519: eofl:
520: c = 0; /* adb */
521: if (intty) { /* adb */
522: if (hp->h_cc == NOSTR && value("askcc")) /* adb */
523: c |= GCC; /* adb */
524: if (hp->h_bcc == NOSTR && value("askbcc")) /* adb */
525: c |= GBCC; /* adb */
526: } /* adb */
527: if (c) /* adb */
528: grabh(hp, c, 1); /* adb */
529: fflush(obuf);
530: if ((cp = value("MAILX_TAIL")) != NOSTR) {
531: cpout( cp, obuf);
532: if (isatty(fileno(stdin)))
533: cpout( cp, stdout);
534: }
535: fclose(obuf);
536: rewind(ibuf);
537: resetsigs(0);
538: noreset = 0;
539: return(ibuf);
540:
541: err:
542: if (ibuf != NULL)
543: fclose(ibuf);
544: if (obuf != NULL)
545: fclose(obuf);
546: resetsigs(0);
547: noreset = 0;
548: return(NULL);
549: }
550:
551: static void resetsigs(resethup)
552: int resethup;
553: {
554: (void) sigset(SIGINT, savesig);
555: if (resethup)
556: (void) sigset(SIGHUP, savehup);
557: #ifdef SIGCONT
558: # ifdef preSVr4
559: (void) sigset(SIGCONT, savecont);
560: # else
561: {
562: struct sigaction nsig;
563: nsig.sa_handler = savecont;
564: sigemptyset(&nsig.sa_mask);
565: nsig.sa_flags = SA_RESTART;
566: (void) sigaction(SIGCONT, &nsig, (struct sigaction*)0);
567: }
568: # endif
569: #endif
570: }
571:
572: /*
573: * Write a file ex-like.
574: */
575:
576: static int
577: exwrite(name, ibuf)
578: char name[];
579: FILE *ibuf;
580: {
581: register FILE *of;
582: struct stat junk;
583: void (*sigint)(), (*sigpipe)();
584: int pi = (*name == '!');
585:
586: if (!pi && stat(name, &junk) >= 0
587: && (junk.st_mode & S_IFMT) == S_IFREG) {
588: fprintf(stderr, "%s: File exists\n", name);
589: return(-1);
590: }
591: if ((of = pi ? npopen(++name, "w") : fopen(name, "w")) == NULL) {
592: perror(name);
593: return(-1);
594: }
595: if (pi) {
596: sigint = sigset(SIGINT, SIG_IGN);
597: sigpipe = sigset(SIGPIPE, SIG_IGN);
598: }
599: lcwrite(name, ibuf, of);
600: pi ? npclose(of) : fclose(of);
601: if (pi) {
602: sigset(SIGPIPE, sigpipe);
603: sigset(SIGINT, sigint);
604: }
605: return(0);
606: }
607:
608: void
609: lcwrite(fn, fi, fo)
610: char *fn;
611: FILE *fi, *fo;
612: {
613: register int c;
614: long lc, cc;
615:
616: printf("\"%s\" ", fn);
617: fflush(stdout);
618: lc = cc = 0;
619: while ((c = getc(fi)) != EOF) {
620: cc++;
621: if (putc(c, fo) == '\n')
622: lc++;
623: if (ferror(fo)) {
624: perror("");
625: return;
626: }
627: }
628: printf("%ld/%ld\n", lc, cc);
629: fflush(stdout);
630: }
631:
632: /*
633: * Edit the message being collected on ibuf and obuf.
634: * Write the message out onto some poorly-named temp file
635: * and point an editor at it.
636: *
637: * On return, make the edit file the new temp file.
638: */
639:
640: static FILE *
641: mesedit(ibuf, obuf, c, hp)
642: FILE *ibuf, *obuf;
643: struct header *hp;
644: {
645: pid_t pid;
646: FILE *fbuf;
647: register int t;
648: void (*sigint)();
649: struct stat sbuf;
650: register char *edit;
651: char hdr[LINESIZE];
652:
653: if (stat(tempEdit, &sbuf) >= 0) {
654: printf("%s: file exists\n", tempEdit);
655: goto out;
656: }
657: close(creat(tempEdit, TEMPPERM));
658: if ((fbuf = fopen(tempEdit, "w")) == NULL) {
659: perror(tempEdit);
660: goto out;
661: }
662: fflush(obuf);
663: rewind(ibuf);
664: puthead(hp, fbuf, GMASK);
665: while ((t = getc(ibuf)) != EOF)
666: putc(t, fbuf);
667: fflush(fbuf);
668: if (ferror(fbuf)) {
669: perror(tempEdit);
670: removefile(tempEdit);
671: goto out;
672: }
673: fclose(fbuf);
674: if ((edit = value(c == 'e' ? "EDITOR" : "VISUAL")) == NOSTR)
675: edit = c == 'e' ? EDITOR : VISUAL;
676: edit = expand(edit);
677:
678: /*
679: * Fork/execlp the editor on the edit file
680: */
681:
682: pid = fork();
683: if ( pid == (pid_t)-1 ) {
684: perror("fork");
685: removefile(tempEdit);
686: goto out;
687: }
688: if ( pid == 0 ) {
689: sigchild();
690: execlp(edit, edit, tempEdit, (char *)0);
691: perror(edit);
692: _exit(1);
693: }
694: sigint = sigset(SIGINT, SIG_IGN);
695: while (wait((int *)0) != pid)
696: ;
697: sigset(SIGINT, sigint);
698: /*
699: * Now switch to new file.
700: */
701:
702: if ((fbuf = fopen(tempEdit, "r")) == NULL) {
703: perror(tempEdit);
704: removefile(tempEdit);
705: goto out;
706: }
707: removefile(tempEdit);
708: hp->h_to = hp->h_subject = hp->h_cc = hp->h_bcc = hp->h_defopt = NOSTR;
709: hp->h_others = NOSTRPTR;
710: hp->h_seq = 0;
711: while (gethfield(fbuf, hdr, 9999L) > 0) {
712: if (ishfield(hdr, "to"))
713: hp->h_to = addto(hp->h_to, hcontents(hdr));
714: else if (ishfield(hdr, "subject"))
715: hp->h_subject = addone(hp->h_subject, hcontents(hdr));
716: else if (ishfield(hdr, "cc"))
717: hp->h_cc = addto(hp->h_cc, hcontents(hdr));
718: else if (ishfield(hdr, "bcc"))
719: hp->h_bcc = addto(hp->h_bcc, hcontents(hdr));
720: else if (ishfield(hdr, "default-options"))
721: hp->h_defopt = addone(hp->h_defopt, hcontents(hdr));
722: else
723: hp->h_others = Xaddone(hp->h_others, hdr);
724: hp->h_seq++;
725: }
726: if ((obuf = fopen(tempMail, "w")) == NULL) {
727: perror(tempMail);
728: fclose(fbuf);
729: goto out;
730: }
731: if ((ibuf = fopen(tempMail, "r")) == NULL) {
732: perror(tempMail);
733: removefile(tempMail);
734: fclose(fbuf);
735: fclose(obuf);
736: goto out;
737: }
738: removefile(tempMail);
739: if (strlen(hdr) > 0) {
740: fputs(hdr, obuf);
741: putc('\n', obuf);
742: }
743: while ((t = getc(fbuf)) != EOF)
744: putc(t, obuf);
745: fclose(fbuf);
746: fclose(newo);
747: fclose(newi);
748: newo = obuf;
749: newi = ibuf;
750: out:
751: return(newo);
752: }
753:
754: /*
755: * Pipe the message through the command.
756: * Old message is on stdin of command;
757: * New message collected from stdout.
758: * Sh -c must return 0 to accept the new message.
759: */
760:
761: static FILE *
762: mespipe(ibuf, obuf, cmd)
763: FILE *ibuf, *obuf;
764: char cmd[];
765: {
766: register FILE *ni, *no;
767: pid_t pid;
768: int s;
769: void (*sigint)();
770: char *Shell;
771:
772: newi = ibuf;
773: if ((no = fopen(tempEdit, "w")) == NULL) {
774: perror(tempEdit);
775: return(obuf);
776: }
777: if ((ni = fopen(tempEdit, "r")) == NULL) {
778: perror(tempEdit);
779: fclose(no);
780: removefile(tempEdit);
781: return(obuf);
782: }
783: removefile(tempEdit);
784: fflush(obuf);
785: rewind(ibuf);
786: if ((Shell = value("SHELL")) == NULL || *Shell=='\0')
787: Shell = SHELL;
788: if ((pid = fork()) == (pid_t)-1) {
789: perror("fork");
790: goto err;
791: }
792: if (pid == 0) {
793: /*
794: * stdin = current message.
795: * stdout = new message.
796: */
797:
798: sigchild();
799: close(0);
800: dup(fileno(ibuf));
801: close(1);
802: dup(fileno(no));
803: for (s = 4; s < 15; s++)
804: close(s);
805: execlp(Shell, Shell, "-c", cmd, (char *)0);
806: perror(Shell);
807: _exit(1);
808: }
809: sigint = sigset(SIGINT, SIG_IGN);
810: while (wait(&s) != pid)
811: ;
812: sigset(SIGINT, sigint);
813: if (s != 0 || pid == (pid_t)-1) {
814: fprintf(stderr, "\"%s\" failed!?\n", cmd);
815: goto err;
816: }
817: if (fsize(ni) == 0) {
818: fprintf(stderr, "No bytes from \"%s\" !?\n", cmd);
819: goto err;
820: }
821:
822: /*
823: * Take new files.
824: */
825:
826: newi = ni;
827: fclose(ibuf);
828: fclose(obuf);
829: return(no);
830:
831: err:
832: fclose(no);
833: fclose(ni);
834: return(obuf);
835: }
836:
837: /*
838: * Interpolate the named messages into the current
839: * message, preceding each line with a tab.
840: * Return a count of the number of characters now in
841: * the message, or -1 if an error is encountered writing
842: * the message temporary. The flag argument is 'm' if we
843: * should shift over and 'f' if not.
844: */
845: static int
846: forward(ms, obuf, f)
847: char ms[];
848: FILE *obuf;
849: {
850: register int *msgvec, *ip;
851:
852: msgvec = (int *) salloc((msgCount+1) * sizeof *msgvec);
853: if (msgvec == NOINTPTR)
854: return(0);
855: if (getmsglist(ms, msgvec, 0) < 0)
856: return(0);
857: if (*msgvec == NULL) {
858: *msgvec = first(0, MMNORM);
859: if (*msgvec == NULL) {
860: printf("No appropriate messages\n");
861: return(0);
862: }
863: msgvec[1] = NULL;
864: }
865: printf("Interpolating:");
866: for (ip = msgvec; *ip != NULL; ip++) {
867: touch(*ip);
868: printf(" %d", *ip);
869: if (f == 'm') {
870: if (transmit(&message[*ip-1], obuf) < 0L) {
871: perror(tempMail);
872: return(-1);
873: }
874: } else
875: if (send(&message[*ip-1], obuf, 0) < 0) {
876: perror(tempMail);
877: return(-1);
878: }
879: }
880: printf("\n");
881: return(0);
882: }
883:
884: /*
885: * Send message described by the passed pointer to the
886: * passed output buffer. Insert a tab in front of each
887: * line. Return a count of the characters sent, or -1
888: * on error.
889: */
890:
891: static long
892: transmit(mailp, obuf)
893: struct message *mailp;
894: FILE *obuf;
895: {
896: register struct message *mp;
897: register int ch;
898: register long c, n;
899: int bol;
900: FILE *ibuf;
901: char *mprefix = value("mprefix");
902:
903: if (!mprefix)
904: mprefix = "\t";
905: mp = mailp;
906: ibuf = setinput(mp);
907: c = mp->m_size;
908: n = c;
909: bol = 1;
910: while (c-- > 0L) {
911: if (bol) {
912: bol = 0;
913: fputs(mprefix, obuf);
914: n++;
915: if (ferror(obuf)) {
916: perror("/tmp");
917: return(-1L);
918: }
919: }
920: ch = getc(ibuf);
921: if (ch == '\n')
922: bol++;
923: putc(ch, obuf);
924: if (ferror(obuf)) {
925: perror("/tmp");
926: return(-1L);
927: }
928: }
929: return(n);
930: }
931:
932: /*
933: * Print (continue) when continued after ^Z.
934: */
935: #ifdef SIGCONT
936: /*ARGSUSED*/
937: static void
938: collcont(s)
939: {
940: printf("(continue)\n",s); /* reference s to suppress warning -- adb */
941: fflush(stdout);
942: }
943: #endif /* SIGCONT */
944:
945: /*
946: * On interrupt, go here to save the partial
947: * message on ~/dead.letter.
948: * Then restore signals and execute the normal
949: * signal routine. We only come here if signals
950: * were previously set anyway.
951: */
952: static void
953: collrub(s)
954: {
955: register FILE *dbuf;
956: register int c;
957: register char *deadletter = Getf("DEAD");
958: long cc, lc;
959:
960: if (s == SIGHUP)
961: sigignore(SIGHUP);
962: if (s == SIGINT && hadintr == 0) {
963: hadintr++;
964: clrbuf(stdout);
965: printf("\n(Interrupt -- one more to kill letter)\n");
966: sigrelse(s);
967: longjmp(coljmp, 1);
968: }
969: fclose(newo);
970: rewind(newi);
971: if (s == SIGINT && value("save")==NOSTR || fsize(newi) == 0)
972: goto done;
973: if ((dbuf = fopen(deadletter, "w")) == NULL) { /* old behavior -- adb */
974: perror(deadletter);
975: goto done;
976: }
977: chmod(deadletter, DEADPERM);
978: printf("\"%s\" ", deadletter);
979: fflush(stdout);
980: puthead(savehp, dbuf, GMASK);
981: for (cc = lc = 0; (c = getc(newi)) != EOF; cc++)
982: if (putc(c, dbuf) == '\n')
983: lc++;
984: fclose(dbuf);
985: printf("%ld/%ld\n", lc, cc);
986: done:
987: fclose(newi);
988: resetsigs(1);
989: if (rcvmode) {
990: if (s == SIGHUP)
991: hangup();
992: else
993: stop(s);
994: }
995: else
996: exit(1);
997: }
998:
999: /*
1000: * Acknowledge an interrupt signal from the tty by typing an @
1001: */
1002: static void
1003: intack(s)
1004: {
1005: (void) s;
1006: puts("@");
1007: fflush(stdout);
1008: clearerr(stdin);
1009: longjmp(coljmp,1);
1010: }
1011:
1012: /* Read line from stdin, noting any NULL characters.
1013: Return the number of characters read. Note that the buffer
1014: passed must be 1 larger than "size" for the trailing NUL byte.
1015: */
1016: int
1017: getline(line,size,f,hasnulls)
1018: char *line;
1019: int size;
1020: FILE *f;
1021: int *hasnulls;
1022: {
1023: register int i, ch;
1024: for (i = 0; (i < size) && ((ch=getc(f)) != EOF); ) {
1025: if ( ch == '\0' )
1026: *hasnulls = 1;
1027: if ((line[i++] = ch) == '\n') break;
1028: }
1029: line[i] = '\0';
1030: return(i);
1031: }
1032:
1033: void
1034: savedead(s)
1035: {
1036: (void) s;
1037: collrub(SIGINT);
1038: exit(1);
1039: /* NOTREACHED */
1040: }
1041:
1042: /*
1043: * Add a list of addresses to the end of a header entry field.
1044: */
1045: char *
1046: addto(hf, news)
1047: char hf[], news[];
1048: {
1049: char name[LINESIZE];
1050: int comma = docomma(news);
1051:
1052: while (news = yankword(news, name, comma)) {
1053: strcat(name, ", ");
1054: hf = addone(hf, name);
1055: }
1056: return hf;
1057: }
1058:
1059: /*
1060: * Add a string to the end of a header entry field.
1061: */
1062: char *
1063: addone(hf, news)
1064: char hf[], news[];
1065: {
1066: register char *cp, *cp2, *linebuf;
1067:
1068: if (hf == NOSTR)
1069: hf = "";
1070: if (*news == '\0')
1071: return(hf);
1072: linebuf = salloc((unsigned)(strlen(hf) + strlen(news) + 2));
1073: for (cp = hf; any(*cp, " \t"); cp++)
1074: ;
1075: for (cp2 = linebuf; *cp;)
1076: *cp2++ = *cp++;
1077: if (cp2 > linebuf && cp2[-1] != ' ')
1078: *cp2++ = ' ';
1079: for (cp = news; any(*cp, " \t"); cp++)
1080: ;
1081: while (*cp != '\0')
1082: *cp2++ = *cp++;
1083: *cp2 = '\0';
1084: return(linebuf);
1085: }
1086:
1087: static int nptrs(hf)
1088: char **hf;
1089: {
1090: register int i;
1091: if (!hf)
1092: return 0;
1093: for (i = 0; *hf; hf++)
1094: i++;
1095: return i;
1096: }
1097:
1098: /*
1099: * Add a non-standard header to the end of the non-standard headers.
1100: */
1101: static char **
1102: Xaddone(hf, news)
1103: char **hf, news[];
1104: {
1105: register char *linebuf;
1106: char **ohf = hf;
1107: int nhf = nptrs(hf);
1108:
1109: if (hf == NOSTRPTR)
1110: hf = (char**)salloc(sizeof(char*) * 2);
1111: else
1112: hf = (char**)srealloc(hf, sizeof(char*) * (nhf + 2));
1113: if (hf == NOSTRPTR) {
1114: fprintf(stderr, "No room, header lost: %s\n", news);
1115: return(ohf);
1116: }
1117: linebuf = salloc((unsigned)(strlen(news) + 1));
1118: strcpy(linebuf, news);
1119: hf[nhf++] = linebuf;
1120: hf[nhf] = NOSTR;
1121: return(hf);
1122: }
1123:
1124: static void
1125: cpout( str, ofd )
1126: char *str;
1127: FILE *ofd;
1128: {
1129: register char *cp = str;
1130:
1131: while ( *cp ) {
1132: if ( *cp == '\\' ) {
1133: switch ( *(cp+1) ) {
1134: case 'n':
1135: putc('\n',ofd);
1136: cp++;
1137: break;
1138: case 't':
1139: putc('\t',ofd);
1140: cp++;
1141: break;
1142: default:
1143: putc('\\',ofd);
1144: }
1145: }
1146: else {
1147: putc(*cp,ofd);
1148: }
1149: cp++;
1150: }
1151: putc('\n',ofd);
1152: fflush(ofd);
1153: }
1154:
1155: static void
1156: xhalt()
1157: {
1158: fclose(newo);
1159: fclose(newi);
1160: sigset(SIGINT, savesig);
1161: sigset(SIGHUP, savehup);
1162: if (rcvmode)
1163: stop(0);
1164: exit(1);
1165: /* NOTREACHED */
1166: }
1167:
1168: /*
1169: Strip the nulls from a buffer of length n
1170: */
1171: static int
1172: stripnulls(linebuf, nread)
1173: register char *linebuf;
1174: register int nread;
1175: {
1176: register int i, j;
1177: for (i = 0; i < nread; i++)
1178: if (linebuf[i] == '\0')
1179: break;
1180: for (j = i; j < nread; j++)
1181: if (linebuf[j] != '\0')
1182: linebuf[i++] = linebuf[j];
1183: linebuf[i] = '\0';
1184: return i;
1185: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.