![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to send.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / Mail|
Return to send.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / Mail |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char *sccsid = "@(#)send.c 5.2 (Berkeley) 6/21/85";
9: #endif not lint
10:
11: #include "rcv.h"
12: #ifdef VMUNIX
13: #include <sys/wait.h>
14: #endif
15: #include <ctype.h>
16: #include <sys/stat.h>
17:
18: /*
19: * Mail -- a mail program
20: *
21: * Mail to others.
22: */
23:
24: /*
25: * Send message described by the passed pointer to the
26: * passed output buffer. Return -1 on error, but normally
27: * the number of lines written. Adjust the status: field
28: * if need be. If doign is set, suppress ignored header fields.
29: */
30: send(mailp, obuf, doign)
31: struct message *mailp;
32: FILE *obuf;
33: {
34: register struct message *mp;
35: register int t;
36: long c;
37: FILE *ibuf;
38: char line[LINESIZE], field[BUFSIZ];
39: int lc, ishead, infld, fline, dostat;
40: char *cp, *cp2;
41:
42: mp = mailp;
43: ibuf = setinput(mp);
44: c = mp->m_size;
45: ishead = 1;
46: dostat = 1;
47: infld = 0;
48: fline = 1;
49: lc = 0;
50: while (c > 0L) {
51: fgets(line, LINESIZE, ibuf);
52: c -= (long) strlen(line);
53: lc++;
54: if (ishead) {
55: /*
56: * First line is the From line, so no headers
57: * there to worry about
58: */
59: if (fline) {
60: fline = 0;
61: goto writeit;
62: }
63: /*
64: * If line is blank, we've reached end of
65: * headers, so force out status: field
66: * and note that we are no longer in header
67: * fields
68: */
69: if (line[0] == '\n') {
70: if (dostat) {
71: statusput(mailp, obuf, doign);
72: dostat = 0;
73: }
74: ishead = 0;
75: goto writeit;
76: }
77: /*
78: * If this line is a continuation (via space or tab)
79: * of a previous header field, just echo it
80: * (unless the field should be ignored).
81: */
82: if (infld && (isspace(line[0]) || line[0] == '\t')) {
83: if (doign && isign(field)) continue;
84: goto writeit;
85: }
86: infld = 0;
87: /*
88: * If we are no longer looking at real
89: * header lines, force out status:
90: * This happens in uucp style mail where
91: * there are no headers at all.
92: */
93: if (!headerp(line)) {
94: if (dostat) {
95: statusput(mailp, obuf, doign);
96: dostat = 0;
97: }
98: putc('\n', obuf);
99: ishead = 0;
100: goto writeit;
101: }
102: infld++;
103: /*
104: * Pick up the header field.
105: * If it is an ignored field and
106: * we care about such things, skip it.
107: */
108: cp = line;
109: cp2 = field;
110: while (*cp && *cp != ':' && !isspace(*cp))
111: *cp2++ = *cp++;
112: *cp2 = 0;
113: if (doign && isign(field))
114: continue;
115: /*
116: * If the field is "status," go compute and print the
117: * real Status: field
118: */
119: if (icequal(field, "status")) {
120: if (dostat) {
121: statusput(mailp, obuf, doign);
122: dostat = 0;
123: }
124: continue;
125: }
126: }
127: writeit:
128: fputs(line, obuf);
129: if (ferror(obuf))
130: return(-1);
131: }
132: if (ferror(obuf))
133: return(-1);
134: if (ishead && (mailp->m_flag & MSTATUS))
135: printf("failed to fix up status field\n");
136: return(lc);
137: }
138:
139: /*
140: * Test if the passed line is a header line, RFC 733 style.
141: */
142: headerp(line)
143: register char *line;
144: {
145: register char *cp = line;
146:
147: while (*cp && !isspace(*cp) && *cp != ':')
148: cp++;
149: while (*cp && isspace(*cp))
150: cp++;
151: return(*cp == ':');
152: }
153:
154: /*
155: * Output a reasonable looking status field.
156: * But if "status" is ignored and doign, forget it.
157: */
158: statusput(mp, obuf, doign)
159: register struct message *mp;
160: register FILE *obuf;
161: {
162: char statout[3];
163:
164: if (doign && isign("status"))
165: return;
166: if ((mp->m_flag & (MNEW|MREAD)) == MNEW)
167: return;
168: if (mp->m_flag & MREAD)
169: strcpy(statout, "R");
170: else
171: strcpy(statout, "");
172: if ((mp->m_flag & MNEW) == 0)
173: strcat(statout, "O");
174: fprintf(obuf, "Status: %s\n", statout);
175: }
176:
177:
178: /*
179: * Interface between the argument list and the mail1 routine
180: * which does all the dirty work.
181: */
182:
183: mail(people)
184: char **people;
185: {
186: register char *cp2;
187: register int s;
188: char *buf, **ap;
189: struct header head;
190:
191: for (s = 0, ap = people; *ap != (char *) -1; ap++)
192: s += strlen(*ap) + 1;
193: buf = salloc(s+1);
194: cp2 = buf;
195: for (ap = people; *ap != (char *) -1; ap++) {
196: cp2 = copy(*ap, cp2);
197: *cp2++ = ' ';
198: }
199: if (cp2 != buf)
200: cp2--;
201: *cp2 = '\0';
202: head.h_to = buf;
203: head.h_subject = NOSTR;
204: head.h_cc = NOSTR;
205: head.h_bcc = NOSTR;
206: head.h_seq = 0;
207: mail1(&head);
208: return(0);
209: }
210:
211:
212: /*
213: * Send mail to a bunch of user names. The interface is through
214: * the mail routine below.
215: */
216:
217: sendmail(str)
218: char *str;
219: {
220: register char **ap;
221: char *bufp;
222: register int t;
223: struct header head;
224:
225: if (blankline(str))
226: head.h_to = NOSTR;
227: else
228: head.h_to = str;
229: head.h_subject = NOSTR;
230: head.h_cc = NOSTR;
231: head.h_bcc = NOSTR;
232: head.h_seq = 0;
233: mail1(&head);
234: return(0);
235: }
236:
237: /*
238: * Mail a message on standard input to the people indicated
239: * in the passed header. (Internal interface).
240: */
241:
242: mail1(hp)
243: struct header *hp;
244: {
245: register char *cp;
246: int pid, i, s, p, gotcha;
247: char **namelist, *deliver;
248: struct name *to, *np;
249: struct stat sbuf;
250: FILE *mtf, *postage;
251: int remote = rflag != NOSTR || rmail;
252: char **t;
253:
254: /*
255: * Collect user's mail from standard input.
256: * Get the result as mtf.
257: */
258:
259: pid = -1;
260: if ((mtf = collect(hp)) == NULL)
261: return(-1);
262: hp->h_seq = 1;
263: if (hp->h_subject == NOSTR)
264: hp->h_subject = sflag;
265: if (intty && value("askcc") != NOSTR)
266: grabh(hp, GCC);
267: else if (intty) {
268: printf("EOT\n");
269: fflush(stdout);
270: }
271:
272: /*
273: * Now, take the user names from the combined
274: * to and cc lists and do all the alias
275: * processing.
276: */
277:
278: senderr = 0;
279: to = usermap(cat(extract(hp->h_bcc, GBCC),
280: cat(extract(hp->h_to, GTO), extract(hp->h_cc, GCC))));
281: if (to == NIL) {
282: printf("No recipients specified\n");
283: goto topdog;
284: }
285:
286: /*
287: * Look through the recipient list for names with /'s
288: * in them which we write to as files directly.
289: */
290:
291: to = outof(to, mtf, hp);
292: rewind(mtf);
293: to = verify(to);
294: if (senderr && !remote) {
295: topdog:
296:
297: if (fsize(mtf) != 0) {
298: remove(deadletter);
299: exwrite(deadletter, mtf, 1);
300: rewind(mtf);
301: }
302: }
303: for (gotcha = 0, np = to; np != NIL; np = np->n_flink)
304: if ((np->n_type & GDEL) == 0) {
305: gotcha++;
306: break;
307: }
308: if (!gotcha)
309: goto out;
310: to = elide(to);
311: mechk(to);
312: if (count(to) > 1)
313: hp->h_seq++;
314: if (hp->h_seq > 0 && !remote) {
315: fixhead(hp, to);
316: if (fsize(mtf) == 0)
317: if (hp->h_subject == NOSTR)
318: printf("No message, no subject; hope that's ok\n");
319: else
320: printf("Null message body; hope that's ok\n");
321: if ((mtf = infix(hp, mtf)) == NULL) {
322: fprintf(stderr, ". . . message lost, sorry.\n");
323: return(-1);
324: }
325: }
326: namelist = unpack(to);
327: if (debug) {
328: printf("Recipients of message:\n");
329: for (t = namelist; *t != NOSTR; t++)
330: printf(" \"%s\"", *t);
331: printf("\n");
332: fflush(stdout);
333: return;
334: }
335: if ((cp = value("record")) != NOSTR)
336: savemail(expand(cp), hp, mtf);
337:
338: /*
339: * Wait, to absorb a potential zombie, then
340: * fork, set up the temporary mail file as standard
341: * input for "mail" and exec with the user list we generated
342: * far above. Return the process id to caller in case he
343: * wants to await the completion of mail.
344: */
345:
346: #ifdef VMUNIX
347: #ifdef pdp11
348: while (wait2(&s, WNOHANG) > 0)
349: #endif
350: #if defined(vax) || defined(sun)
351: while (wait3(&s, WNOHANG, 0) > 0)
352: #endif
353: ;
354: #else
355: wait(&s);
356: #endif
357: rewind(mtf);
358: pid = fork();
359: if (pid == -1) {
360: perror("fork");
361: remove(deadletter);
362: exwrite(deadletter, mtf, 1);
363: goto out;
364: }
365: if (pid == 0) {
366: sigchild();
367: #ifdef SIGTSTP
368: if (remote == 0) {
369: sigset(SIGTSTP, SIG_IGN);
370: sigset(SIGTTIN, SIG_IGN);
371: sigset(SIGTTOU, SIG_IGN);
372: }
373: #endif
374: for (i = SIGHUP; i <= SIGQUIT; i++)
375: sigset(i, SIG_IGN);
376: if (!stat(POSTAGE, &sbuf))
377: if ((postage = fopen(POSTAGE, "a")) != NULL) {
378: fprintf(postage, "%s %d %d\n", myname,
379: count(to), fsize(mtf));
380: fclose(postage);
381: }
382: s = fileno(mtf);
383: for (i = 3; i < 15; i++)
384: if (i != s)
385: close(i);
386: close(0);
387: dup(s);
388: close(s);
389: #ifdef CC
390: submit(getpid());
391: #endif CC
392: #ifdef SENDMAIL
393: if ((deliver = value("sendmail")) == NOSTR)
394: deliver = SENDMAIL;
395: execv(deliver, namelist);
396: #endif SENDMAIL
397: execv(MAIL, namelist);
398: perror(MAIL);
399: exit(1);
400: }
401:
402: out:
403: if (remote || (value("verbose") != NOSTR)) {
404: while ((p = wait(&s)) != pid && p != -1)
405: ;
406: if (s != 0)
407: senderr++;
408: pid = 0;
409: }
410: fclose(mtf);
411: return(pid);
412: }
413:
414: /*
415: * Fix the header by glopping all of the expanded names from
416: * the distribution list into the appropriate fields.
417: * If there are any ARPA net recipients in the message,
418: * we must insert commas, alas.
419: */
420:
421: fixhead(hp, tolist)
422: struct header *hp;
423: struct name *tolist;
424: {
425: register struct name *nlist;
426: register int f;
427: register struct name *np;
428:
429: for (f = 0, np = tolist; np != NIL; np = np->n_flink)
430: if (any('@', np->n_name)) {
431: f |= GCOMMA;
432: break;
433: }
434:
435: if (debug && f & GCOMMA)
436: fprintf(stderr, "Should be inserting commas in recip lists\n");
437: hp->h_to = detract(tolist, GTO|f);
438: hp->h_cc = detract(tolist, GCC|f);
439: }
440:
441: /*
442: * Prepend a header in front of the collected stuff
443: * and return the new file.
444: */
445:
446: FILE *
447: infix(hp, fi)
448: struct header *hp;
449: FILE *fi;
450: {
451: extern char tempMail[];
452: register FILE *nfo, *nfi;
453: register int c;
454:
455: rewind(fi);
456: if ((nfo = fopen(tempMail, "w")) == NULL) {
457: perror(tempMail);
458: return(fi);
459: }
460: if ((nfi = fopen(tempMail, "r")) == NULL) {
461: perror(tempMail);
462: fclose(nfo);
463: return(fi);
464: }
465: remove(tempMail);
466: puthead(hp, nfo, GTO|GSUBJECT|GCC|GNL);
467: c = getc(fi);
468: while (c != EOF) {
469: putc(c, nfo);
470: c = getc(fi);
471: }
472: if (ferror(fi)) {
473: perror("read");
474: return(fi);
475: }
476: fflush(nfo);
477: if (ferror(nfo)) {
478: perror(tempMail);
479: fclose(nfo);
480: fclose(nfi);
481: return(fi);
482: }
483: fclose(nfo);
484: fclose(fi);
485: rewind(nfi);
486: return(nfi);
487: }
488:
489: /*
490: * Dump the to, subject, cc header on the
491: * passed file buffer.
492: */
493:
494: puthead(hp, fo, w)
495: struct header *hp;
496: FILE *fo;
497: {
498: register int gotcha;
499:
500: gotcha = 0;
501: if (hp->h_to != NOSTR && w & GTO)
502: fmt("To: ", hp->h_to, fo), gotcha++;
503: if (hp->h_subject != NOSTR && w & GSUBJECT)
504: fprintf(fo, "Subject: %s\n", hp->h_subject), gotcha++;
505: if (hp->h_cc != NOSTR && w & GCC)
506: fmt("Cc: ", hp->h_cc, fo), gotcha++;
507: if (hp->h_bcc != NOSTR && w & GBCC)
508: fmt("Bcc: ", hp->h_bcc, fo), gotcha++;
509: if (gotcha && w & GNL)
510: putc('\n', fo);
511: return(0);
512: }
513:
514: /*
515: * Format the given text to not exceed 72 characters.
516: */
517:
518: fmt(str, txt, fo)
519: register char *str, *txt;
520: register FILE *fo;
521: {
522: register int col;
523: register char *bg, *bl, *pt, ch;
524:
525: col = strlen(str);
526: if (col)
527: fprintf(fo, "%s", str);
528: pt = bg = txt;
529: bl = 0;
530: while (*bg) {
531: pt++;
532: if (++col >72) {
533: if (!bl) {
534: bl = bg;
535: while (*bl && !isspace(*bl))
536: bl++;
537: }
538: if (!*bl)
539: goto finish;
540: ch = *bl;
541: *bl = '\0';
542: fprintf(fo, "%s\n ", bg);
543: col = 4;
544: *bl = ch;
545: pt = bg = ++bl;
546: bl = 0;
547: }
548: if (!*pt) {
549: finish:
550: fprintf(fo, "%s\n", bg);
551: return;
552: }
553: if (isspace(*pt))
554: bl = pt;
555: }
556: }
557:
558: /*
559: * Save the outgoing mail on the passed file.
560: */
561:
562: savemail(name, hp, fi)
563: char name[];
564: struct header *hp;
565: FILE *fi;
566: {
567: register FILE *fo;
568: register int c;
569: long now;
570: char *n;
571:
572: if ((fo = fopen(name, "a")) == NULL) {
573: perror(name);
574: return(-1);
575: }
576: time(&now);
577: n = rflag;
578: if (n == NOSTR)
579: n = myname;
580: fprintf(fo, "From %s %s", n, ctime(&now));
581: rewind(fi);
582: for (c = getc(fi); c != EOF; c = getc(fi))
583: putc(c, fo);
584: fprintf(fo, "\n");
585: fflush(fo);
586: if (ferror(fo))
587: perror(name);
588: fclose(fo);
589: return(0);
590: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.