![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to deliver.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / a / tmp / smail|
Return to deliver.c CVS log | Up to [MW Coherent from dump] / coherent / a / tmp / smail |
1.1 root 1: /*
2: ** Deliver.c
3: **
4: ** Routines to effect delivery of mail for rmail/smail.
5: **
6: */
7:
8: #ifndef lint
9: static char *sccsid="@(#)deliver.c 2.5 (smail) 9/15/87";
10: #endif
11:
12: # include <stdio.h>
13: # include <sys/types.h>
14: # include <sys/stat.h>
15: /* # include <sys/utsname.h> */
16: # include <ctype.h>
17: # include <signal.h>
18: # include "defs.h"
19:
20: extern int errno; /* Error number set by certain system routines. */
21: extern int exitstat; /* set if a forked mailer fails */
22: extern enum edebug debug; /* how verbose we are */
23: extern char hostname[]; /* our uucp hostname */
24: extern char hostdomain[]; /* our host's domain */
25: extern enum ehandle handle; /* what we handle */
26: extern enum erouting routing; /* how we're routing addresses */
27: extern char *uuxargs; /* arguments given to uux */
28: extern int queuecost; /* threshold for queueing mail */
29: extern int maxnoqueue; /* max number of uucico's */
30: extern char *spoolfile; /* file name of spooled message */
31: extern FILE *spoolfp; /* file ptr to spooled message */
32: extern int spoolmaster; /* set if creator of spoolfile */
33: extern char nows[]; /* local time in ctime(3) format*/
34: extern char arpanows[]; /* local time in arpadate format*/
35: extern char _version[]; /* Version string from copyright.c */
36: char stderrfile[20]; /* error file for stderr traping*/
37: char err_msg[2*MAXCLEN]; /* handy place to build error messages */
38:
39: char userlist[2*MAXCLEN]; /* used to build a list of users mail will
40: * sent to.
41: */
42: /*
43: **
44: ** deliver(): hand the letter to the proper mail programs.
45: **
46: ** Issues one command for each different host of <hostv>,
47: ** constructing the proper command for LOCAL or UUCP mail.
48: ** Note that LOCAL mail has blank host names.
49: **
50: ** The <userv> names for each host are arguments to the command.
51: **
52: ** Prepends a "From" line to the letter just before going
53: ** out, with a "remote from <hostname>" if it is a UUCP letter.
54: **
55: */
56:
57: deliver(argc, hostv, userv, formv, costv)
58: int argc; /* number of addresses */
59: char *hostv[]; /* host names */
60: char *userv[]; /* user names */
61: enum eform formv[]; /* form for each address */
62: int costv[]; /* cost vector */
63: {
64: FILE *out; /* pipe to mailer */
65: FILE *popen(); /* to fork a mailer */
66: #ifdef RECORD
67: void record(); /* record all transactions */
68: #endif
69: #ifdef LOG
70: void log();
71: #endif
72: char *mktemp();
73: char *sform();
74: char from[SMLBUF]; /* accumulated from argument */
75: char lcommand[SMLBUF]; /* local command issued */
76: char rcommand[SMLBUF]; /* remote command issued */
77: char scommand[SMLBUF]; /* retry command issued */
78: char *command; /* actual command */
79: char buf[SMLBUF]; /* copying rest of the letter */
80: enum eform form; /* holds form[i] for speed */
81: long size; /* number of bytes of message */
82: char *flags; /* flags for uux */
83: char *sflag; /* flag for smail */
84: int i, j, status, retrying;
85: char *c, *postmaster();
86: int failcount = 0;
87: int noqcnt = 0; /* number of uucico's started */
88: char *uux_noqueue = UUX_NOQUEUE;/* uucico starts immediately */
89: char *uux_queue = UUX_QUEUE; /* uucico job gets queued */
90: off_t message;
91: struct stat st;
92:
93: /*
94: ** rewind the spool file and read the collapsed From_ line
95: */
96: (void) fseek(spoolfp, 0L, 0);
97: (void) fgets(from, sizeof(from), spoolfp);
98: if((c = index(from, '\n')) != 0) *c = '\0';
99: message = ftell(spoolfp);
100:
101: /*
102: ** We pass through the list of addresses.
103: */
104: userlist[0] = '\0'; /* initialize userlist */
105: stderrfile[0] = '\0';
106: for(i = 0; i < argc; i++) {
107: char *lend = lcommand;
108: char *rend = rcommand;
109: char *send = scommand;
110:
111: /*
112: ** Prevent errors from previous passes.
113: */
114: exitstat = 0;
115:
116:
117: /*
118: ** If we don't have sendmail, arrange to trap standard error
119: ** for inclusion in the message that is returned with failed mail.
120: */
121: (void) unlink(stderrfile);
122: (void) strcpy(stderrfile, "/tmp/stderrXXXXXX");
123: (void) mktemp(stderrfile);
124: (void) freopen(stderrfile, "w", stderr);
125: if(debug != YES) {
126: (void) freopen(stderrfile, "w", stdout);
127: }
128:
129: *lend = *rend = *send = '\0';
130:
131: /*
132: ** If form == ERROR, the address was bad
133: ** If form == SENT, it has been sent on a previous pass.
134: */
135: form = formv[i];
136: if (form == SENT) {
137: continue;
138: }
139: /*
140: ** Build the command based on whether this is local mail or uucp mail.
141: ** By default, don't allow more than 'maxnoqueue' uucico commands to
142: ** be started by a single invocation of 'smail'.
143: */
144: if(uuxargs == NULL) { /* flags not set on command line */
145: if(noqcnt < maxnoqueue && costv[i] <= queuecost) {
146: flags = uux_noqueue;
147: } else {
148: flags = uux_queue;
149: }
150: } else {
151: flags = uuxargs;
152: }
153:
154: retrying = 0;
155: if(routing == JUSTDOMAIN) {
156: sflag = "-r";
157: } else if(routing == ALWAYS) {
158: sflag = "-R";
159: } else {
160: sflag = "";
161: }
162:
163: (void) sprintf(lcommand, LMAIL(from, hostv[i]));
164: (void) sprintf(rcommand, RMAIL(flags, from, hostv[i]));
165:
166: /*
167: ** For each address with the same host name and form, append the user
168: ** name to the command line, and set form = ERROR so we skip this address
169: ** on later passes.
170: */
171: /* we initialized lend (rend) to point at the
172: * beginning of its buffer, so that at
173: * least one address will be used regardless
174: * of the length of lcommand (rcommand).
175: */
176: for (j = i; j < argc; j++) {
177: if ((formv[j] != form)
178: || (strcmpic(hostv[i], hostv[j]) != 0)
179: || ((lend - lcommand) > MAXCLEN)
180: || ((rend - rcommand) > MAXCLEN)) {
181: continue;
182: }
183:
184: /*
185: ** seek to the end of scommand
186: ** and add on a 'smail' command
187: ** multiple commands are separated by ';'
188: */
189:
190: send += strlen(send);
191: if(send != scommand) {
192: *send++ = ';' ;
193: }
194:
195: (void) sprintf(send, RETRY(sflag));
196: send += strlen(send);
197:
198: lend += strlen(lend);
199: rend += strlen(rend);
200:
201: if (form == LOCAL) {
202: (void) sprintf(lend, LARG(userv[j]));
203: (void) sprintf(send, LARG(userv[j]));
204: strcat(userlist,userv[j]);
205: } else {
206: (void) sprintf(lend, RLARG(hostv[i], userv[j]));
207: (void) sprintf(send, RLARG(hostv[i], userv[j]));
208: }
209:
210: (void) sprintf(rend, RARG(userv[j]));
211: formv[j] = SENT;
212: }
213: retry:
214: /*
215: ** rewind the spool file and read the collapsed From_ line
216: */
217: (void) fseek(spoolfp, message, 0);
218:
219: /* if the address was in a bogus form (usually DOMAIN),
220: ** then don't bother trying the uux.
221: **
222: ** Rather, go straight to the next smail routing level.
223: */
224: if(form == ERROR) {
225: static char errbuf[SMLBUF];
226: (void) sprintf(errbuf,
227: "address resolution ('%s' @ '%s') failed",
228: userv[i], hostv[i]);
229: command = errbuf;
230: size = 0;
231: goto form_error;
232: }
233:
234: if (retrying) {
235: command = scommand;
236: } else if (form == LOCAL) {
237: command = lcommand;
238: } else {
239: command = rcommand;
240: if(flags == uux_noqueue) {
241: noqcnt++;
242: }
243: }
244: ADVISE("COMMAND: %s\n", command);
245:
246: /*
247: ** Fork the mailer and set it up for writing so we can send the mail to it,
248: ** or for debugging divert the output to stdout.
249: */
250:
251: /*
252: ** We may try to write on a broken pipe, if the uux'd host
253: ** is unknown to us. Ignore this signal, since we can use the
254: ** return value of the pclose() as our indication of failure.
255: */
256: (void) signal(SIGPIPE, SIG_IGN);
257:
258: if (debug == YES) {
259: out = stdout;
260: } else {
261: failcount = 0;
262: do {
263: out = popen(command, "w");
264: if (out) break;
265: /*
266: * Fork failed. System probably overloaded.
267: * Wait awhile and try again 10 times.
268: * If it keeps failing, probably some
269: * other problem, like no uux or smail.
270: */
271: (void) sleep(60);
272: if (failcount == 1) {
273: sprintf(err_msg,
274: "Deliver can not popen %s. errno = %d",
275: command, errno);
276: error_log(err_msg);
277: } /* if failed exactly once */
278: } while (++failcount < 10);
279: if (failcount == 10) {
280: sprintf(err_msg,
281: "Deliver failed 10 times. errno = %d",
282: command, errno);
283: error_log(err_msg);
284: } /* if failed exactly once */
285: }
286: if(out == NULL) {
287: exitstat = EX_UNAVAILABLE;
288: (void) printf("couldn't execute %s.\n", command);
289: continue;
290: }
291:
292: size = 0;
293: if(fstat(fileno(spoolfp), &st) >= 0) {
294: size = st.st_size - message;
295: }
296: /*
297: ** Output our From_ line.
298: */
299: if (form == LOCAL) {
300: #ifdef SENDMAIL
301: (void) sprintf(buf, LFROM(from, nows, hostname));
302: size += strlen(buf);
303: (void) fputs(buf, out);
304: #else
305: char *p;
306: if((p=index(from, '!')) != NULL) {
307: *p = NULL;
308: (void) sprintf(buf, RFROM(p+1, nows, from));
309: size += strlen(buf);
310: (void) fputs(buf, out);
311: *p = '!';
312: }
313: #endif
314: } else {
315: (void) sprintf(buf, RFROM(from, nows, hostname));
316: size += strlen(buf);
317: (void) fputs(buf, out);
318: }
319:
320: /* END OF THIS LOOKS LIKE THE PLACE */
321: #ifdef SENDMAIL
322: /*
323: ** If using sendmail, insert a Received: line only for mail
324: ** that is being passed to uux. If not using sendmail, always
325: ** insert the received line, since sendmail isn't there to do it.
326: */
327: if(command == rcommand && handle != ALL)
328: #endif
329: {
330: #ifdef GATEWAY_NAME
331: (void) sprintf(buf,
332: "Received: by %s (%s - %s) id AA%05d; %s\n",
333: hostdomain, VERSION,GATEWAY_NAME,
334: getpid(), arpanows);
335: #else
336: (void) sprintf(buf,
337: "Received: by %s (%s) id AA%05d; %s\n",
338: hostdomain, VERSION,
339: getpid(), arpanows);
340: #endif
341: size += strlen(buf);
342: (void) fputs(buf, out);
343: }
344:
345: /*
346: ** Copy input.
347: */
348: while(fgets(buf, sizeof(buf), spoolfp) != NULL) {
349: (void) fputs(buf, out);
350: }
351: /*
352: ** Get exit status and if non-zero, set global exitstat so when we exit
353: ** we can indicate an error.
354: */
355: form_error:
356: if (debug != YES) {
357: if(form == ERROR) {
358: exitstat = EX_NOHOST;
359: } else {
360: status = pclose(out);
361: exitstat = status >> 8;
362: }
363: /*
364: * The 'retrying' check prevents a smail loop.
365: */
366: if(exitstat != 0) {
367: /*
368: ** the mail failed, probably because the host
369: ** being uux'ed isn't in L.sys or local user
370: ** is unknown.
371: */
372:
373: if((retrying == 0) /* first pass */
374: && (routing != REROUTE) /* have higher level */
375: && (form != LOCAL)) { /* can't route local */
376: /*
377: ** Try again using a higher
378: ** level of routing.
379: */
380: ADVISE("%s failed (%d)\ntrying %s\n",
381: command, exitstat, scommand);
382: exitstat = 0;
383: retrying = 1;
384: form = SENT;
385: goto retry;
386: }
387:
388: /*
389: ** if we have no other routing possibilities
390: ** see that the mail is returned to sender.
391: */
392:
393: /* Important NOTE: A very nasty race condition exists here. If
394: * multiple child processes are trying to send mail to the same
395: * user simultaneously, then 1 process will get the mailbox and
396: * lock it, causing the other processes to fail. If a user invokes
397: * several processes to send mail to himself locally, then each
398: * process that fails once a mailbox is locked will force smail to
399: * return the message back to the original sender, which will fail,
400: * because the mailbox is already locked. This will force another
401: * smail process to fire up to return the returned message, and we
402: * will enter a recursive spawning of smail processes that will
403: * eventually choke the kernel.
404: *
405: * I have added code to check the following:
406: * if a local mail send fails, we check to see if the person
407: * who sent the message exists in the local send-to-user
408: * list (userlist). If this is true, we do NOT return the
409: * the mail, but write a message to the log file to indicate
410: * that this occured.
411: *
412: * Bob H. 10/20/92
413: */
414: if((routing == REROUTE)
415: || ((form == LOCAL) && (!strstr(userlist,from)))) {
416:
417: /*
418: ** if this was our last chance,
419: ** return the mail to the sender.
420: */
421:
422: ADVISE("%s failed (%d)\n",
423: command, exitstat);
424:
425: (void) fseek(spoolfp, message, 0);
426: #ifdef SENDMAIL
427: /* if we have sendmail, then it
428: ** was handed the mail, which failed.
429: ** sendmail returns the failed mail
430: ** for us, so we need not do it again.
431: */
432: if(form != LOCAL)
433: #endif
434: {
435: return_mail(from, command, form);
436: }
437: exitstat = 0;
438: }
439: if((form == LOCAL) && (strstr(userlist,from))){
440: sprintf(err_msg,"Local mail to user %s failed. Because", from);
441: error_log(err_msg);
442: sprintf(err_msg,"this was the same person to send the message,");
443: error_log(err_msg);
444: sprintf(err_msg,"it will NOT be returned to avoid a race condition.");
445: error_log(err_msg);
446: }
447: }
448: # ifdef LOG
449: else {
450: if(retrying == 0) log(command, from, size);
451: }
452: # endif
453: }
454: }
455: /*
456: ** Update logs and records.
457: */
458: # ifdef RECORD
459: (void) fseek(spoolfp, message, 0);
460: record(command, from, size);
461: # endif
462:
463: /*
464: ** close spool file pointer.
465: ** if we created it, then unlink file.
466: */
467: (void) fclose(spoolfp);
468: if(spoolmaster) {
469: (void) unlink(spoolfile);
470: }
471: (void) unlink(stderrfile);
472: }
473:
474: /*
475: ** return mail to sender, as determined by From_ line.
476: */
477: return_mail(from, fcommand, form)
478: char *from, *fcommand;
479: enum eform form;
480: {
481: char buf[SMLBUF];
482: char domain[SMLBUF], user[SMLBUF];
483: char *r;
484: FILE *fp, *out, *popen();
485: int i = 0;
486:
487: r = buf;
488:
489: (void) sprintf(r, "%s %s", SMAIL, VFLAG);
490: r += strlen(r);
491:
492: if(islocal(from, domain, user)) {
493: (void) sprintf(r, LARG(user));
494: } else {
495: (void) sprintf(r, RLARG(domain, user));
496: }
497:
498: i = 0;
499:
500: do {
501: out = popen(buf, "w");
502: if (out) break;
503: /*
504: * Fork failed. System probably overloaded.
505: * Wait awhile and try again 10 times.
506: * If it keeps failing, probably some
507: * other problem, like no uux or smail.
508: */
509: (void) sleep(60);
510: } while (++i < 10);
511:
512: if(out == NULL) {
513: (void) printf("couldn't execute %s.\n", buf);
514: return;
515: }
516:
517: (void) fprintf(out, "Date: %s\n", arpanows);
518: (void) fprintf(out, "From: MAILER-DAEMON@%s\n", hostdomain);
519: (void) fprintf(out, "Subject: failed mail\n");
520: (void) fprintf(out, "To: %s\n", from);
521: (void) fprintf(out, "\n");
522: (void) fprintf(out, "Form: %s\n", sform(form));
523: (void) fprintf(out, "Exit status: %d\n", exitstat);
524: (void) fprintf(out, "======= command failed =======\n\n");
525: (void) fprintf(out, " COMMAND: %s\n\n", fcommand);
526:
527: (void) fprintf(out, "======= standard error follows =======\n");
528: (void) fflush(stderr);
529: if((fp = fopen(stderrfile, "r")) != NULL) {
530: while(fgets(buf, sizeof(buf), fp) != NULL) {
531: (void) fputs(buf, out);
532: }
533: }
534: (void) fclose(fp);
535: (void) fprintf(out, "======= text of message follows =======\n");
536: /*
537: ** Copy input.
538: */
539: (void) fprintf(out, "From %s\n", from);
540: while(fgets(buf, sizeof(buf), spoolfp) != NULL) {
541: (void) fputs(buf, out);
542: }
543: (void) pclose(out);
544: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.