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