![[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 [CSRG BSD Unix] / 42BSD / usr.lib / sendmail / src|
Return to main.c CVS log | Up to [CSRG BSD Unix] / 42BSD / usr.lib / sendmail / src |
1.1 root 1: # define _DEFINE
2: # include <signal.h>
3: # include <sys/ioctl.h>
4: # include "sendmail.h"
5: # include <sys/file.h>
6:
7: SCCSID(@(#)main.c 4.3 9/5/83);
8:
9: /*
10: ** SENDMAIL -- Post mail to a set of destinations.
11: **
12: ** This is the basic mail router. All user mail programs should
13: ** call this routine to actually deliver mail. Sendmail in
14: ** turn calls a bunch of mail servers that do the real work of
15: ** delivering the mail.
16: **
17: ** Sendmail is driven by tables read in from /usr/lib/sendmail.cf
18: ** (read by readcf.c). Some more static configuration info,
19: ** including some code that you may want to tailor for your
20: ** installation, is in conf.c. You may also want to touch
21: ** daemon.c (if you have some other IPC mechanism), acct.c
22: ** (to change your accounting), names.c (to adjust the name
23: ** server mechanism).
24: **
25: ** Usage:
26: ** /usr/lib/sendmail [flags] addr ...
27: **
28: ** See the associated documentation for details.
29: **
30: ** Author:
31: ** Eric Allman, UCB/INGRES (until 10/81)
32: ** Britton-Lee, Inc., purveyors of fine
33: ** database computers (from 11/81)
34: ** The support of the INGRES Project and Britton-Lee is
35: ** gratefully acknowledged. Britton-Lee in
36: ** particular had absolutely nothing to gain from
37: ** my involvement in this project.
38: */
39:
40:
41:
42:
43:
44: int NextMailer = 0; /* "free" index into Mailer struct */
45: char *FullName; /* sender's full name */
46: ENVELOPE BlankEnvelope; /* a "blank" envelope */
47: ENVELOPE MainEnvelope; /* the envelope around the basic letter */
48:
49: #ifdef DAEMON
50: #ifndef SMTP
51: ERROR %%%% Cannot have daemon mode without SMTP %%%% ERROR
52: #endif SMTP
53: #endif DAEMON
54:
55:
56:
57:
58:
59:
60: main(argc, argv)
61: int argc;
62: char **argv;
63: {
64: register char *p;
65: char **av;
66: extern int finis();
67: extern char Version[];
68: char *from;
69: typedef int (*fnptr)();
70: STAB *st;
71: register int i;
72: bool readconfig = FALSE;
73: bool safecf = TRUE; /* this conf file is sys default */
74: bool queuemode = FALSE; /* process queue requests */
75: static bool reenter = FALSE;
76: char jbuf[30]; /* holds HostName */
77: extern bool safefile();
78: extern time_t convtime();
79: extern putheader(), putbody();
80: extern ENVELOPE *newenvelope();
81: extern intsig();
82: extern char **myhostname();
83: extern char *arpadate();
84:
85: /*
86: ** Check to see if we reentered.
87: ** This would normally happen if e_putheader or e_putbody
88: ** were NULL when invoked.
89: */
90:
91: if (reenter)
92: {
93: syserr("main: reentered!");
94: abort();
95: }
96: reenter = TRUE;
97:
98: /*
99: ** Be sure we have enough file descriptors.
100: */
101:
102: for (i = 3; i < 20; i++)
103: (void) close(i);
104: errno = 0;
105:
106: /*
107: ** Do a quick prescan of the argument list.
108: ** We do this to find out if we can potentially thaw the
109: ** configuration file. If not, we do the thaw now so that
110: ** the argument processing applies to this run rather than
111: ** to the run that froze the configuration.
112: */
113:
114: argv[argc] = NULL;
115: av = argv;
116: while (*++av != NULL)
117: {
118: if (strncmp(*av, "-C", 2) == 0 || strncmp(*av, "-bz", 3) == 0)
119: break;
120: }
121: if (*av == NULL)
122: readconfig = !thaw(FreezeFile);
123:
124: /*
125: ** Now do basic initialization
126: */
127:
128: InChannel = stdin;
129: OutChannel = stdout;
130: if (signal(SIGINT, SIG_IGN) != SIG_IGN)
131: (void) signal(SIGINT, intsig);
132: if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
133: (void) signal(SIGHUP, intsig);
134: (void) signal(SIGTERM, intsig);
135: (void) signal(SIGPIPE, SIG_IGN);
136: OldUmask = umask(0);
137: OpMode = MD_DELIVER;
138: MotherPid = getpid();
139: # ifndef V6
140: FullName = getenv("NAME");
141: # endif V6
142:
143: /* set up the blank envelope */
144: BlankEnvelope.e_puthdr = putheader;
145: BlankEnvelope.e_putbody = putbody;
146: BlankEnvelope.e_xfp = NULL;
147: CurEnv = &BlankEnvelope;
148:
149: /* make sure we have a clean slate */
150: closeall();
151:
152: # ifdef LOG
153: openlog("sendmail", LOG_PID);
154: # endif LOG
155: errno = 0;
156: from = NULL;
157:
158: /* initialize some macros, etc. */
159: initmacros();
160:
161: /* hostname */
162: av = myhostname(jbuf, sizeof jbuf);
163: if (jbuf[0] != '\0')
164: {
165: p = newstr(jbuf);
166: define('w', p, CurEnv);
167: setclass('w', p);
168: }
169: while (av != NULL && *av != NULL)
170: setclass('w', *av++);
171:
172: /* version */
173: define('v', Version, CurEnv);
174:
175: /* current time */
176: define('b', arpadate((char *) NULL), CurEnv);
177:
178: /*
179: ** Crack argv.
180: */
181:
182: av = argv;
183: p = rindex(*av, '/');
184: if (p++ == NULL)
185: p = *av;
186: if (strcmp(p, "newaliases") == 0)
187: OpMode = MD_INITALIAS;
188: else if (strcmp(p, "mailq") == 0)
189: OpMode = MD_PRINT;
190: while ((p = *++av) != NULL && p[0] == '-')
191: {
192: switch (p[1])
193: {
194: case 'b': /* operations mode */
195: switch (p[2])
196: {
197: case MD_DAEMON:
198: # ifndef DAEMON
199: syserr("Daemon mode not implemented");
200: break;
201: # endif DAEMON
202: case MD_SMTP:
203: # ifndef SMTP
204: syserr("I don't speak SMTP");
205: break;
206: # endif SMTP
207: case MD_ARPAFTP:
208: case MD_DELIVER:
209: case MD_VERIFY:
210: case MD_TEST:
211: case MD_INITALIAS:
212: case MD_PRINT:
213: case MD_FREEZE:
214: OpMode = p[2];
215: break;
216:
217: default:
218: syserr("Invalid operation mode %c", p[2]);
219: break;
220: }
221: break;
222:
223: case 'C': /* select configuration file */
224: ConfFile = &p[2];
225: if (ConfFile[0] == '\0')
226: ConfFile = "sendmail.cf";
227: safecf = FALSE;
228: break;
229:
230: # ifdef DEBUG
231: case 'd': /* debug */
232: tTsetup(tTdvect, sizeof tTdvect, "0-99.1");
233: tTflag(&p[2]);
234: setbuf(stdout, (char *) NULL);
235: printf("Version %s\n", Version);
236: break;
237: # endif DEBUG
238:
239: case 'f': /* from address */
240: case 'r': /* obsolete -f flag */
241: p += 2;
242: if (*p == '\0' && ((p = *++av) == NULL || *p == '-'))
243: {
244: p = *++av;
245: if (p == NULL || *p == '-')
246: {
247: syserr("No \"from\" person");
248: av--;
249: break;
250: }
251: }
252: if (from != NULL)
253: {
254: syserr("More than one \"from\" person");
255: break;
256: }
257: from = p;
258: break;
259:
260: case 'F': /* set full name */
261: p += 2;
262: if (*p == '\0' && ((p = *++av) == NULL || *p == '-'))
263: {
264: syserr("Bad -F flag");
265: av--;
266: break;
267: }
268: FullName = p;
269: break;
270:
271: case 'h': /* hop count */
272: p += 2;
273: if (*p == '\0' && ((p = *++av) == NULL || !isdigit(*p)))
274: {
275: syserr("Bad hop count (%s)", p);
276: av--;
277: break;
278: }
279: CurEnv->e_hopcount = atoi(p);
280: break;
281:
282: case 'n': /* don't alias */
283: NoAlias = TRUE;
284: break;
285:
286: case 'o': /* set option */
287: setoption(p[2], &p[3], FALSE, TRUE);
288: break;
289:
290: case 'q': /* run queue files at intervals */
291: # ifdef QUEUE
292: queuemode = TRUE;
293: QueueIntvl = convtime(&p[2]);
294: # else QUEUE
295: syserr("I don't know about queues");
296: # endif QUEUE
297: break;
298:
299: case 't': /* read recipients from message */
300: GrabTo = TRUE;
301: break;
302:
303: /* compatibility flags */
304: case 'c': /* connect to non-local mailers */
305: case 'e': /* error message disposition */
306: case 'i': /* don't let dot stop me */
307: case 'm': /* send to me too */
308: case 'T': /* set timeout interval */
309: case 'v': /* give blow-by-blow description */
310: setoption(p[1], &p[2], FALSE, TRUE);
311: break;
312:
313: case 's': /* save From lines in headers */
314: setoption('f', &p[2], FALSE, TRUE);
315: break;
316:
317: # ifdef DBM
318: case 'I': /* initialize alias DBM file */
319: OpMode = MD_INITALIAS;
320: break;
321: # endif DBM
322: }
323: }
324:
325: /*
326: ** Do basic initialization.
327: ** Read system control file.
328: ** Extract special fields for local use.
329: */
330:
331: if (!safecf || OpMode == MD_FREEZE || readconfig)
332: readcf(ConfFile, safecf);
333:
334: switch (OpMode)
335: {
336: case MD_FREEZE:
337: /* this is critical to avoid forgeries of the frozen config */
338: setuid(getuid());
339: setgid(getgid());
340:
341: /* freeze the configuration */
342: freeze(FreezeFile);
343: exit(EX_OK);
344:
345: case MD_INITALIAS:
346: Verbose = TRUE;
347: break;
348: }
349:
350: /* do heuristic mode adjustment */
351: if (Verbose)
352: {
353: /* turn off noconnect option */
354: setoption('c', "F", TRUE, FALSE);
355:
356: /* turn on interactive delivery */
357: setoption('d', "", TRUE, FALSE);
358: }
359:
360: /* our name for SMTP codes */
361: expand("$j", jbuf, &jbuf[sizeof jbuf - 1], CurEnv);
362: HostName = jbuf;
363:
364: /* the indices of local and program mailers */
365: st = stab("local", ST_MAILER, ST_FIND);
366: if (st == NULL)
367: syserr("No local mailer defined");
368: else
369: LocalMailer = st->s_mailer;
370: st = stab("prog", ST_MAILER, ST_FIND);
371: if (st == NULL)
372: syserr("No prog mailer defined");
373: else
374: ProgMailer = st->s_mailer;
375:
376: /* operate in queue directory */
377: if (chdir(QueueDir) < 0)
378: {
379: syserr("cannot chdir(%s)", QueueDir);
380: exit(EX_SOFTWARE);
381: }
382:
383: /*
384: ** If printing the queue, go off and do that.
385: */
386:
387: if (OpMode == MD_PRINT)
388: {
389: #ifdef QUEUE
390: dropenvelope(CurEnv);
391: printqueue();
392: exit(EX_OK);
393: #else QUEUE
394: usrerr("No queue to print");
395: finis();
396: #endif QUEUE
397: }
398:
399: /*
400: ** Initialize aliases.
401: */
402:
403: initaliases(AliasFile, OpMode == MD_INITALIAS);
404: if (OpMode == MD_INITALIAS)
405: exit(EX_OK);
406:
407: # ifdef DEBUG
408: if (tTd(0, 15))
409: {
410: /* print configuration table (or at least part of it) */
411: printrules();
412: for (i = 0; i < MAXMAILERS; i++)
413: {
414: register struct mailer *m = Mailer[i];
415: int j;
416:
417: if (m == NULL)
418: continue;
419: printf("mailer %d (%s): P=%s S=%d R=%d M=%ld F=", i, m->m_name,
420: m->m_mailer, m->m_s_rwset, m->m_r_rwset,
421: m->m_maxsize);
422: for (j = '\0'; j <= '\177'; j++)
423: if (bitnset(j, m->m_flags))
424: putchar(j);
425: printf(" E=");
426: xputs(m->m_eol);
427: printf("\n");
428: }
429: }
430: # endif DEBUG
431:
432: /*
433: ** Switch to the main envelope.
434: */
435:
436: CurEnv = newenvelope(&MainEnvelope);
437: MainEnvelope.e_flags = BlankEnvelope.e_flags;
438:
439: /*
440: ** If test mode, read addresses from stdin and process.
441: */
442:
443: if (OpMode == MD_TEST)
444: {
445: char buf[MAXLINE];
446:
447: printf("ADDRESS TEST MODE\nEnter <ruleset> <address>\n");
448: for (;;)
449: {
450: register char **pvp;
451: char *q;
452: extern char **prescan();
453: extern char *DelimChar;
454:
455: printf("> ");
456: fflush(stdout);
457: if (fgets(buf, sizeof buf, stdin) == NULL)
458: finis();
459: for (p = buf; isspace(*p); *p++)
460: continue;
461: q = p;
462: while (*p != '\0' && !isspace(*p))
463: p++;
464: if (*p == '\0')
465: continue;
466: *p = '\0';
467: do
468: {
469: pvp = prescan(++p, ',');
470: if (pvp == NULL)
471: continue;
472: rewrite(pvp, 3);
473: p = q;
474: while (*p != '\0')
475: {
476: rewrite(pvp, atoi(p));
477: while (*p != '\0' && *p++ != ',')
478: continue;
479: }
480: } while (*(p = DelimChar) != '\0');
481: }
482: }
483:
484: # ifdef QUEUE
485: /*
486: ** If collecting stuff from the queue, go start doing that.
487: */
488:
489: if (queuemode && OpMode != MD_DAEMON && QueueIntvl == 0)
490: {
491: runqueue(FALSE);
492: finis();
493: }
494: # endif QUEUE
495:
496: /*
497: ** If a daemon, wait for a request.
498: ** getrequests will always return in a child.
499: ** If we should also be processing the queue, start
500: ** doing it in background.
501: ** We check for any errors that might have happened
502: ** during startup.
503: */
504:
505: if (OpMode == MD_DAEMON || QueueIntvl != 0)
506: {
507: if (!tTd(0, 1))
508: {
509: /* put us in background */
510: i = fork();
511: if (i < 0)
512: syserr("daemon: cannot fork");
513: if (i != 0)
514: exit(0);
515:
516: /* get our pid right */
517: MotherPid = getpid();
518:
519: /* disconnect from our controlling tty */
520: disconnect(TRUE);
521: }
522:
523: # ifdef QUEUE
524: if (queuemode)
525: {
526: runqueue(TRUE);
527: if (OpMode != MD_DAEMON)
528: for (;;)
529: pause();
530: }
531: # endif QUEUE
532: dropenvelope(CurEnv);
533:
534: #ifdef DAEMON
535: getrequests();
536:
537: /* at this point we are in a child: reset state */
538: OpMode = MD_SMTP;
539: (void) newenvelope(CurEnv);
540: openxscript(CurEnv);
541: #endif DAEMON
542: }
543:
544: # ifdef SMTP
545: /*
546: ** If running SMTP protocol, start collecting and executing
547: ** commands. This will never return.
548: */
549:
550: if (OpMode == MD_SMTP)
551: smtp();
552: # endif SMTP
553:
554: /*
555: ** Do basic system initialization and set the sender
556: */
557:
558: initsys();
559: setsender(from);
560:
561: if (OpMode != MD_ARPAFTP && *av == NULL && !GrabTo)
562: {
563: usrerr("Usage: /etc/sendmail [flags] addr...");
564: finis();
565: }
566: if (OpMode == MD_VERIFY)
567: SendMode = SM_VERIFY;
568:
569: /*
570: ** Scan argv and deliver the message to everyone.
571: */
572:
573: sendtoargv(av);
574:
575: /* if we have had errors sofar, arrange a meaningful exit stat */
576: if (Errors > 0 && ExitStat == EX_OK)
577: ExitStat = EX_USAGE;
578:
579: /*
580: ** Read the input mail.
581: */
582:
583: CurEnv->e_to = NULL;
584: if (OpMode != MD_VERIFY || GrabTo)
585: collect(FALSE);
586: errno = 0;
587:
588: /* collect statistics */
589: if (OpMode != MD_VERIFY)
590: markstats(CurEnv, (ADDRESS *) NULL);
591:
592: # ifdef DEBUG
593: if (tTd(1, 1))
594: printf("From person = \"%s\"\n", CurEnv->e_from.q_paddr);
595: # endif DEBUG
596:
597: /*
598: ** Actually send everything.
599: ** If verifying, just ack.
600: */
601:
602: CurEnv->e_from.q_flags |= QDONTSEND;
603: CurEnv->e_to = NULL;
604: sendall(CurEnv, SM_DEFAULT);
605:
606: /*
607: ** All done.
608: */
609:
610: finis();
611: }
612: /*
613: ** FINIS -- Clean up and exit.
614: **
615: ** Parameters:
616: ** none
617: **
618: ** Returns:
619: ** never
620: **
621: ** Side Effects:
622: ** exits sendmail
623: */
624:
625: finis()
626: {
627: # ifdef DEBUG
628: if (tTd(2, 1))
629: printf("\n====finis: stat %d e_flags %o\n", ExitStat, CurEnv->e_flags);
630: # endif DEBUG
631:
632: /* clean up temp files */
633: CurEnv->e_to = NULL;
634: dropenvelope(CurEnv);
635:
636: /* post statistics */
637: poststats(StatFile);
638:
639: /* and exit */
640: # ifdef LOG
641: if (LogLevel > 11)
642: syslog(LOG_DEBUG, "finis, pid=%d", getpid());
643: # endif LOG
644: if (ExitStat == EX_TEMPFAIL)
645: ExitStat = EX_OK;
646: exit(ExitStat);
647: }
648: /*
649: ** INTSIG -- clean up on interrupt
650: **
651: ** This just arranges to exit. It pessimises in that it
652: ** may resend a message.
653: **
654: ** Parameters:
655: ** none.
656: **
657: ** Returns:
658: ** none.
659: **
660: ** Side Effects:
661: ** Unlocks the current job.
662: */
663:
664: intsig()
665: {
666: FileName = NULL;
667: unlockqueue(CurEnv);
668: exit(EX_OK);
669: }
670: /*
671: ** INITMACROS -- initialize the macro system
672: **
673: ** This just involves defining some macros that are actually
674: ** used internally as metasymbols to be themselves.
675: **
676: ** Parameters:
677: ** none.
678: **
679: ** Returns:
680: ** none.
681: **
682: ** Side Effects:
683: ** initializes several macros to be themselves.
684: */
685:
686: struct metamac
687: {
688: char metaname;
689: char metaval;
690: };
691:
692: struct metamac MetaMacros[] =
693: {
694: /* these are important on the LHS */
695: '*', MATCHZANY, '+', MATCHANY, '-', MATCHONE, '=', MATCHCLASS,
696: '~', MATCHNCLASS,
697:
698: /* these are RHS metasymbols */
699: '#', CANONNET, '@', CANONHOST, ':', CANONUSER, '>', CALLSUBR,
700:
701: /* and finally the conditional operations */
702: '?', CONDIF, '|', CONDELSE, '.', CONDFI,
703:
704: '\0'
705: };
706:
707: initmacros()
708: {
709: register struct metamac *m;
710: char buf[5];
711: register int c;
712:
713: for (m = MetaMacros; m->metaname != '\0'; m++)
714: {
715: buf[0] = m->metaval;
716: buf[1] = '\0';
717: define(m->metaname, newstr(buf), CurEnv);
718: }
719: buf[0] = MATCHREPL;
720: buf[2] = '\0';
721: for (c = '0'; c <= '9'; c++)
722: {
723: buf[1] = c;
724: define(c, newstr(buf), CurEnv);
725: }
726: }
727: /*
728: ** FREEZE -- freeze BSS & allocated memory
729: **
730: ** This will be used to efficiently load the configuration file.
731: **
732: ** Parameters:
733: ** freezefile -- the name of the file to freeze to.
734: **
735: ** Returns:
736: ** none.
737: **
738: ** Side Effects:
739: ** Writes BSS and malloc'ed memory to freezefile
740: */
741:
742: union frz
743: {
744: char frzpad[BUFSIZ]; /* insure we are on a BUFSIZ boundary */
745: struct
746: {
747: time_t frzstamp; /* timestamp on this freeze */
748: char *frzbrk; /* the current break */
749: char frzver[252]; /* sendmail version */
750: } frzinfo;
751: };
752:
753: freeze(freezefile)
754: char *freezefile;
755: {
756: int f;
757: union frz fhdr;
758: extern char edata;
759: extern char *sbrk();
760: extern char Version[];
761:
762: if (freezefile == NULL)
763: return;
764:
765: /* try to open the freeze file */
766: f = creat(freezefile, FileMode);
767: if (f < 0)
768: {
769: syserr("Cannot freeze");
770: errno = 0;
771: return;
772: }
773:
774: /* build the freeze header */
775: fhdr.frzinfo.frzstamp = curtime();
776: fhdr.frzinfo.frzbrk = sbrk(0);
777: strcpy(fhdr.frzinfo.frzver, Version);
778:
779: /* write out the freeze header */
780: if (write(f, (char *) &fhdr, sizeof fhdr) != sizeof fhdr ||
781: write(f, (char *) &edata, fhdr.frzinfo.frzbrk - &edata) !=
782: (fhdr.frzinfo.frzbrk - &edata))
783: {
784: syserr("Cannot freeze");
785: }
786:
787: /* fine, clean up */
788: (void) close(f);
789: }
790: /*
791: ** THAW -- read in the frozen configuration file.
792: **
793: ** Parameters:
794: ** freezefile -- the name of the file to thaw from.
795: **
796: ** Returns:
797: ** TRUE if it successfully read the freeze file.
798: ** FALSE otherwise.
799: **
800: ** Side Effects:
801: ** reads freezefile in to BSS area.
802: */
803:
804: thaw(freezefile)
805: char *freezefile;
806: {
807: int f;
808: union frz fhdr;
809: extern char edata;
810: extern char Version[];
811:
812: if (freezefile == NULL)
813: return (FALSE);
814:
815: /* open the freeze file */
816: f = open(freezefile, 0);
817: if (f < 0)
818: {
819: errno = 0;
820: return (FALSE);
821: }
822:
823: /* read in the header */
824: if (read(f, (char *) &fhdr, sizeof fhdr) < sizeof fhdr ||
825: strcmp(fhdr.frzinfo.frzver, Version) != 0)
826: {
827: (void) close(f);
828: return (FALSE);
829: }
830:
831: /* arrange to have enough space */
832: if (brk(fhdr.frzinfo.frzbrk) < 0)
833: {
834: syserr("Cannot break to %x", fhdr.frzinfo.frzbrk);
835: (void) close(f);
836: return (FALSE);
837: }
838:
839: /* now read in the freeze file */
840: if (read(f, (char *) &edata, fhdr.frzinfo.frzbrk - &edata) !=
841: (fhdr.frzinfo.frzbrk - &edata))
842: {
843: /* oops! we have trashed memory..... */
844: write(2, "Cannot read freeze file\n", 24);
845: _exit(EX_SOFTWARE);
846: }
847:
848: (void) close(f);
849: return (TRUE);
850: }
851: /*
852: ** DISCONNECT -- remove our connection with any foreground process
853: **
854: ** Parameters:
855: ** fulldrop -- if set, we should also drop the controlling
856: ** TTY if possible -- this should only be done when
857: ** setting up the daemon since otherwise UUCP can
858: ** leave us trying to open a dialin, and we will
859: ** wait for the carrier.
860: **
861: ** Returns:
862: ** none
863: **
864: ** Side Effects:
865: ** Trys to insure that we are immune to vagaries of
866: ** the controlling tty.
867: */
868:
869: disconnect(fulldrop)
870: bool fulldrop;
871: {
872: int fd;
873:
874: #ifdef DEBUG
875: if (tTd(52, 1))
876: printf("disconnect: In %d Out %d\n", fileno(InChannel),
877: fileno(OutChannel));
878: if (tTd(52, 5))
879: {
880: printf("don't\n");
881: return;
882: }
883: #endif DEBUG
884:
885: /* be sure we don't get nasty signals */
886: signal(SIGHUP, SIG_IGN);
887: signal(SIGINT, SIG_IGN);
888: signal(SIGQUIT, SIG_IGN);
889:
890: /* we can't communicate with our caller, so.... */
891: HoldErrs = TRUE;
892: ErrorMode = EM_MAIL;
893: Verbose = FALSE;
894:
895: /* all input from /dev/null */
896: if (InChannel != stdin)
897: {
898: (void) fclose(InChannel);
899: InChannel = stdin;
900: }
901: (void) freopen("/dev/null", "r", stdin);
902:
903: /* output to the transcript */
904: if (OutChannel != stdout)
905: {
906: (void) fclose(OutChannel);
907: OutChannel = stdout;
908: }
909: if (CurEnv->e_xfp == NULL)
910: CurEnv->e_xfp = fopen("/dev/null", "w");
911: (void) fflush(stdout);
912: (void) close(1);
913: (void) close(2);
914: while ((fd = dup(fileno(CurEnv->e_xfp))) < 2 && fd > 0)
915: continue;
916:
917: #ifdef TIOCNOTTY
918: /* drop our controlling TTY completely if possible */
919: if (fulldrop)
920: {
921: fd = open("/dev/tty", 2);
922: if (fd >= 0)
923: {
924: (void) ioctl(fd, TIOCNOTTY, 0);
925: (void) close(fd);
926: }
927: errno = 0;
928: }
929: #endif TIOCNOTTY
930:
931: # ifdef LOG
932: if (LogLevel > 11)
933: syslog(LOG_DEBUG, "in background, pid=%d", getpid());
934: # endif LOG
935:
936: errno = 0;
937: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.