![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / upas / send|
Return to main.c CVS log | Up to [Research Unix] / researchv10no / cmd / upas / send |
1.1 root 1: #include <stdio.h>
2: #include <regexp.h>
3: #include <signal.h>
4: #include "mail.h"
5: #include "string.h"
6: #include "message.h"
7: #include "dest.h"
8: #include "aux.h"
9: #include "process.h"
10:
11: /* globals to all files */
12: int rmail = 0;
13: int onatty = 0;
14: char *thissys;
15: int nflg = 0;
16: int debug = 0;
17:
18: #define PIPETIMELIMIT (2*60)
19:
20: /* global to this file */
21: static string *errstr;
22: static message *mp;
23: static int interrupt;
24: static char stderrbuf[BUFSIZ];
25: static int savemail;
26:
27: /* imports (other than in .h's) */
28: extern int nsysfile;
29: extern void exit();
30: extern FILE* lockopen();
31:
32: /* interrupt handling */
33: SIGRETURN
34: catch_int(s)
35: int s;
36: {
37: signal(SIGINT, catch_int);
38: interrupt = 1;
39: }
40:
41: /* save the mail and go away */
42: SIGRETURN
43: save_on_int(s)
44: int s;
45: {
46: cleanlocks();
47: save_mail(mp);
48: exit(1);
49: }
50:
51: /* save the mail and go away */
52: SIGRETURN
53: die_on_quit(s)
54: int s;
55: {
56: cleanlocks();
57: exit(1);
58: }
59:
60: main(ac, av)
61: int ac;
62: char *av[];
63: {
64: int i,j;
65: dest *dp=NULL;
66: int checkforward;
67: SIG_TYP fint, fquit, fhup;
68: char *base;
69: int rv;
70:
71: /* process args */
72: setbuf(stderr, stderrbuf);
73: for (i = 1; i < ac; i++) {
74: if (av[i][0] == '-') {
75: for(j=1; av[i][j]; j++)
76: /* option */
77: switch (av[i][1]) {
78: case '#':
79: nflg = 1;
80: break;
81: case 'd':
82: debug = 1;
83: break;
84: default:
85: fprintf(stderr, "usage: mail [-#] list-of-addresses\n");
86: exit(1);
87: }
88: } else
89: /* destination */
90: d_insert(&dp, d_new(s_copy(av[i])));
91: }
92: if (dp == NULL) {
93: fprintf(stderr, "usage: mail [-#] address-list\n");
94: exit(1);
95: }
96:
97: /*
98: * get context:
99: * - whether we're rmail or mail
100: * - whether on a tty
101: */
102: base = basename(av[0]);
103: checkforward = rmail = strcmp(base, "rmail")==0;
104: onatty = (!rmail) && isatty(0);
105: thissys = sysname_read();
106: if (!nflg) {
107: if ((fint=signal(SIGINT, SIG_IGN))!=SIG_DFL)
108: signal(SIGINT, fint);
109: else
110: signal(SIGINT, fint = (SIG_TYP)catch_int);
111: if ((fquit=signal(SIGQUIT, SIG_IGN))!=SIG_DFL)
112: signal(SIGQUIT, fquit);
113: else
114: signal(SIGQUIT, die_on_quit);
115: if ((fhup=signal(SIGHUP, SIG_IGN))!=SIG_DFL)
116: signal(SIGHUP, fhup);
117: else
118: signal(SIGHUP, fhup = (SIG_TYP)catch_int);
119:
120: mp = m_read(stdin, rmail, onatty);
121: if (mp == NULL)
122: exit(0);
123: if (interrupt != 0) {
124: save_mail(mp);
125: exit(1);
126: }
127:
128: if (fint==(SIG_TYP)catch_int)
129: signal(SIGINT, save_on_int);
130: if (fhup==(SIG_TYP)catch_int)
131: signal(SIGHUP, save_on_int);
132: } else {
133: mp = m_new();
134: default_from(mp);
135: }
136: errstr = s_new();
137: (void)getrules();
138:
139: /*
140: * If this is a gateway, translate the sender address into a local
141: * address. This only happens if mail to the local address is
142: * forwarded to the sender.
143: */
144: gateway(mp);
145:
146: /*
147: * Protect against shell characters in the sender name for
148: * security reasons.
149: */
150: s_restart(mp->sender);
151: if (shellchars(s_to_c(mp->sender)))
152: mp->replyaddr = s_copy("postmaster");
153: else
154: mp->replyaddr = s_clone(mp->sender);
155: s_restart(mp->replyaddr);
156:
157: /*
158: * reject messages that are too long. We don't do it earlier
159: * in m_read since we haven't set up enough things yet.
160: */
161: if(mp->size < 0)
162: return refuse(dp, mp, "message too long", 0);
163:
164: rv = send(dp, mp, checkforward);
165: if(savemail)
166: save_mail(mp);
167: return rv;
168: }
169:
170:
171: /* send a message to a list of sites */
172: int
173: send(destp, mp, checkforward)
174: dest *destp;
175: message *mp;
176: {
177: dest *dp; /* destination being acted upon */
178: dest *bound; /* bound destinations */
179: int errors=0;
180: static int forked;
181: extern dest *up_bind();
182:
183: /* bind the destinations to actions */
184: bound = up_bind(destp, mp, checkforward);
185:
186: /* loop through and execute commands */
187: for (dp = d_rm(&bound); dp != NULL; dp = d_rm(&bound)) {
188: switch (dp->status) {
189: case d_cat:
190: errors += cat_mail(dp, mp);
191: break;
192: case d_pipeto:
193: case d_pipe:
194: if (!rmail && !nflg && !forked) {
195: forked = 1;
196: lesstedious();
197: }
198: errors += pipe_mail(dp, mp, dp->status==d_pipeto);
199: break;
200: default:
201: errors += complain_mail(dp, mp);
202: break;
203: }
204: }
205:
206: return errors;
207: }
208:
209: /* avoid user tedium (as Mike Lesk said in a previous version) */
210: lesstedious()
211: {
212: int i;
213:
214: switch(fork()){
215: case -1:
216: onatty = 0;
217: break;
218: case 0:
219: signal(SIGHUP, SIG_IGN);
220: signal(SIGINT, SIG_IGN);
221: signal(SIGQUIT, SIG_IGN);
222: signal(SIGTERM, SIG_IGN);
223: setpgrp(getpid());
224: for(i=0; i<nsysfile; i++)
225: close(i);
226: onatty = 0;
227: savemail=0;
228: break;
229: default:
230: exit(0);
231: }
232: }
233:
234:
235: /* save the mail */
236: save_mail(mp)
237: message *mp;
238: {
239: FILE *fp;
240: string *file=s_new();
241: char *home;
242: static saved = 0;
243: int uid, gid;
244: extern char *getenv();
245:
246: setuid(uid=getuid());
247: setgid(gid=getgid());
248: if ((home = getenv("HOME")) == NULL)
249: return;
250: s_append(file, home);
251: s_append(file, "/dead.letter");
252: if ((fp = lockopen(s_to_c(file), "w", MBOXMODE, uid, gid)) == NULL)
253: return;
254: m_bprint(mp, fp);
255: lockclose(fp);
256: fprintf(stderr, "saved in %s\n", s_to_c(file));
257: }
258:
259: /* remember the interrupt happened */
260: /* dispose of incorrect addresses */
261: complain_mail(dp, mp)
262: dest *dp;
263: message *mp;
264: {
265: char *msg;
266:
267: switch (dp->status) {
268: case d_undefined:
269: msg = "Invalid address"; /* a little different, for debugging */
270: break;
271: case d_syntax:
272: msg = "invalid address";
273: break;
274: case d_unknown:
275: msg = "unknown user";
276: break;
277: case d_eloop:
278: case d_loop:
279: msg = "forwarding loop";
280: break;
281: case d_noforward:
282: if(dp->pstat && *s_to_c(dp->repl2))
283: return refuse(dp, mp, s_to_c(dp->repl2), dp->pstat);
284: else
285: msg = "destination unknown or forwarding disallowed";
286: break;
287: case d_pipe:
288: msg = "broken pipe";
289: break;
290: case d_cat:
291: msg = "broken cat";
292: break;
293: case d_translate:
294: if(dp->pstat && *s_to_c(dp->repl2))
295: return refuse(dp, mp, s_to_c(dp->repl2), dp->pstat);
296: else
297: msg = "name translation failed";
298: break;
299: case d_alias:
300: msg = "broken alias";
301: break;
302: case d_badmbox:
303: msg = "corrupted mailbox";
304: break;
305: case d_resource:
306: msg = "out of some resource. Try again later.";
307: break;
308: }
309: if (nflg) {
310: printf("%s: %s\n", msg, s_to_c(dp->addr));
311: return 1;
312: }
313: return refuse(dp, mp, msg, 0);
314: }
315:
316: static process *pp;
317: static int timedout;
318:
319: SIGRETURN
320: times_up() {
321: kill(pp->pid, SIGKILL);
322: timedout = 1;
323: }
324:
325: /* dispose of remote addresses */
326: pipe_mail(dp, mp, pipeto)
327: dest *dp;
328: message *mp;
329: int pipeto;
330: {
331: string *file;
332: FILE *fp;
333: dest *next, *list=NULL;
334: string *cmd;
335: int status;
336: string *errstr=s_new();
337: char *mbox;
338:
339: /*
340: * collect the arguments
341: */
342: file = s_new();
343: mbox = s_to_c(dp->addr);
344: if (strncmp (mbox, "local!", 6) == 0)
345: mbox += 6;
346: abspath(mbox, MAILROOT, file);
347: next = d_rm_same(&dp);
348: cmd = s_clone(s_restart(next->repl1));
349: for(; next != NULL; next = d_rm_same(&dp)) {
350: if ((next->uid!=-1 || next->gid !=-1)
351: && shellchars(s_to_c(next->addr))){
352: /* this could be a serious security violation */
353: next->status=d_syntax;
354: complain_mail(next, mp);
355: continue;
356: }
357: if (next->repl2 != NULL) {
358: s_append(cmd, " ");
359: s_append(cmd, s_to_c(next->repl2));
360: }
361: d_insert(&list, next);
362: }
363:
364: if (nflg) {
365: puts(s_to_c(cmd));
366: s_free(cmd);
367: s_free(file);
368: return 0;
369: }
370:
371: /*
372: * lock the mailbox (so that `Pipe to's run sequentially)
373: */
374: if(pipeto)
375: fp = lockopen(s_to_c(file), "r", 0, 0, 0);
376: else
377: fp = NULL;
378: s_free(file);
379:
380: /*
381: * run the process
382: */
383: pp = proc_start(s_to_c(cmd), instream(), (stream *)NULL,
384: outstream(), list->uid);
385: if(pp==NULL || pp->std[0]==NULL || pp->std[2]==NULL)
386: return refuse(list, mp, "out of processes, pipes, or memory", 0);
387: m_print(mp, pp->std[0]->fp, thissys, 0);
388: stream_free(pp->std[0]); pp->std[0] = NULL;
389: timedout = 0;
390: if (pipeto) {
391: signal(SIGALRM, times_up);
392: alarm(PIPETIMELIMIT); /* don't let a user hold us up. */
393: }
394: while(s_read_line(pp->std[2]->fp, errstr) != NULL)
395: ;
396: status = proc_wait(pp);
397: if (pipeto) {
398: alarm(0);
399: signal(SIGALRM, SIG_IGN);
400: }
401: proc_free(pp);
402: s_free(cmd);
403:
404: /*
405: * unlock the mailbox (if it was locked)
406: */
407: if(fp!=NULL)
408: lockclose(fp);
409:
410: /*
411: * return status
412: */
413: if (status != 0) {
414: if (timedout)
415: s_append(errstr, "'Pipe to' command took too long");
416: return refuse(list, mp, s_to_c(errstr), status);
417: }
418: loglist(list, mp, "remote");
419: return 0;
420: }
421:
422: /* dispose of local addresses */
423: cat_mail(dp, mp)
424: dest *dp;
425: message *mp;
426: {
427: FILE *fp;
428: char *rcvr;
429:
430: if (nflg) {
431: printf("cat >> %s\n", s_to_c(dp->repl1));
432: return 0;
433: }
434: fp=lockopen(s_to_c(dp->repl1), "a", MBOXMODE, dp->uid, dp->gid);
435: if (fp == NULL)
436: return refuse(dp, mp, "mail file cannot be opened", 0);
437: m_print(mp, fp, (char *)NULL, 1);
438: fputs("\n", fp);
439: fflush(fp);
440: if (ferror(fp)) {
441: lockclose(fp);
442: return refuse(dp, mp, "error writing mail file", 0);
443: }
444: lockclose(fp);
445: rcvr = basename(s_to_c(dp->repl1));
446: logdelivery(dp, rcvr, mp);
447: notify(rcvr, mp);
448: return 0;
449: }
450:
451: static void
452: appaddr(sp, dp)
453: string *sp;
454: dest *dp;
455: {
456: dest *parent;
457:
458: if (dp->parent != NULL) {
459: for(parent=dp->parent; parent->parent!=NULL; parent=parent->parent)
460: ;
461: s_append(sp, s_to_c(parent->addr));
462: s_append(sp, "' alias `");
463: }
464: s_append(sp, s_to_c(dp->addr));
465: }
466:
467: /* reject delivery */
468: refuse(list, mp, cp, status)
469: dest *list;
470: message *mp;
471: char *cp;
472: int status;
473: {
474: string *errstr=s_new();
475: dest *dp;
476: int rv=0;
477:
478: dp = d_rm(&list);
479: mkerrstr(errstr, mp, dp, list, cp, status);
480: /*
481: * if on a tty just report the error. Otherwise send mail
482: * reporting the error. N.B. To avoid mail loops, don't
483: * send mail reporting a failure of mail to reach the postmaster.
484: */
485: if (onatty) {
486: fputs(s_to_c(errstr), stderr);
487: savemail = 1;
488: rv = 1;
489: } else
490: rv = replymsg(errstr, mp, dp);
491: logrefusal(dp, mp, s_to_c(errstr));
492: s_free(errstr);
493: return rv;
494: }
495:
496: /* make the error message */
497: mkerrstr(errstr, mp, dp, list, cp, status)
498: string *errstr;
499: message *mp;
500: dest *dp;
501: dest *list;
502: char *cp;
503: {
504: dest *next;
505: char smsg[64];
506:
507: /* list all aliases */
508: s_append(errstr, "Mail to `");
509: appaddr(errstr, dp);
510: for(next = d_rm(&list); next != NULL; next = d_rm(&list)) {
511: s_append(errstr, "', '");
512: appaddr(errstr, next);
513: d_insert(&dp, next);
514: }
515: s_append(errstr, "' from '");
516: s_append(errstr, s_to_c(mp->sender));
517: s_append(errstr, "' (");
518: s_append(errstr, s_to_c(mp->replyaddr));
519: s_append(errstr, ")");
520: s_append(errstr, " failed.\n");
521:
522: /* >> and | deserve different flavored messages */
523: switch(dp->status) {
524: case d_pipe:
525: s_append(errstr, "The mailer `");
526: s_append(errstr, s_to_c(dp->repl1));
527: sprintf(smsg, "' returned error status %x.\n", status);
528: s_append(errstr, smsg);
529: s_append(errstr, "The error message was:\n");
530: s_append(errstr, cp);
531: break;
532: default:
533: s_append(errstr, "The error message was:\n");
534: s_append(errstr, cp);
535: break;
536: }
537: }
538:
539: /*
540: * reply with up to 1024 characters of the
541: * original message
542: */
543: replymsg(errstr, mp, dp)
544: string *errstr;
545: message *mp;
546: dest *dp;
547: {
548: message *refp = m_new();
549: dest *ndp;
550: char *rcvr;
551: int rv;
552:
553: rcvr = dp->status==d_eloop ? "postmaster" : s_to_c(mp->replyaddr);
554: ndp = d_new(s_copy(rcvr));
555: s_append(refp->sender, "postmaster");
556: s_append(refp->replyaddr, "postmaster");
557: s_append(refp->date, thedate());
558: s_append(refp->body, s_to_c(errstr));
559: s_append(refp->body, "\nThe message began:\n");
560: s_nappend(refp->body, s_to_c(mp->body), 8*1024);
561: refp->size = strlen(s_to_c(refp->body));
562: rv = send(ndp, refp, 0);
563: m_free(refp);
564: d_free(ndp);
565: return rv;
566: }
567:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.