![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to daemon.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / usr.lib / sendmail / src|
Return to daemon.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.lib / sendmail / src |
1.1 root 1: /*
2: ** Sendmail
3: ** Copyright (c) 1983 Eric P. Allman
4: ** Berkeley, California
5: **
6: ** Copyright (c) 1983 Regents of the University of California.
7: ** All rights reserved. The Berkeley software License Agreement
8: ** specifies the terms and conditions for redistribution.
9: */
10:
11:
12: # include <errno.h>
13: # include "sendmail.h"
14:
15: # ifndef DAEMON
16: # ifndef lint
17: static char SccsId[] = "@(#)daemon.c 5.19 (Berkeley) 5/6/86 (w/o daemon mode)";
18: # endif not lint
19: # else
20:
21: # include <netdb.h>
22: # include <sys/signal.h>
23: # include <sys/wait.h>
24: # include <sys/time.h>
25: # include <sys/resource.h>
26:
27: # ifndef lint
28: static char SccsId[] = "@(#)daemon.c 5.19 (Berkeley) 5/6/86 (with daemon mode)";
29: # endif not lint
30:
31: /*
32: ** DAEMON.C -- routines to use when running as a daemon.
33: **
34: ** This entire file is highly dependent on the 4.2 BSD
35: ** interprocess communication primitives. No attempt has
36: ** been made to make this file portable to Version 7,
37: ** Version 6, MPX files, etc. If you should try such a
38: ** thing yourself, I recommend chucking the entire file
39: ** and starting from scratch. Basic semantics are:
40: **
41: ** getrequests()
42: ** Opens a port and initiates a connection.
43: ** Returns in a child. Must set InChannel and
44: ** OutChannel appropriately.
45: ** clrdaemon()
46: ** Close any open files associated with getting
47: ** the connection; this is used when running the queue,
48: ** etc., to avoid having extra file descriptors during
49: ** the queue run and to avoid confusing the network
50: ** code (if it cares).
51: ** makeconnection(host, port, outfile, infile)
52: ** Make a connection to the named host on the given
53: ** port. Set *outfile and *infile to the files
54: ** appropriate for communication. Returns zero on
55: ** success, else an exit status describing the
56: ** error.
57: ** maphostname(hbuf, hbufsize)
58: ** Convert the entry in hbuf into a canonical form. It
59: ** may not be larger than hbufsize.
60: */
61: /*
62: ** GETREQUESTS -- open mail IPC port and get requests.
63: **
64: ** Parameters:
65: ** none.
66: **
67: ** Returns:
68: ** none.
69: **
70: ** Side Effects:
71: ** Waits until some interesting activity occurs. When
72: ** it does, a child is created to process it, and the
73: ** parent waits for completion. Return from this
74: ** routine is always in the child. The file pointers
75: ** "InChannel" and "OutChannel" should be set to point
76: ** to the communication channel.
77: */
78:
79: struct sockaddr_in SendmailAddress;/* internet address of sendmail */
80:
81: int DaemonSocket = -1; /* fd describing socket */
82: char *NetName; /* name of home (local?) network */
83:
84: getrequests()
85: {
86: int t;
87: register struct servent *sp;
88: int on = 1;
89: extern reapchild();
90:
91: /*
92: ** Set up the address for the mailer.
93: */
94:
95: sp = getservbyname("smtp", "tcp");
96: if (sp == NULL)
97: {
98: syserr("server \"smtp\" unknown");
99: goto severe;
100: }
101: SendmailAddress.sin_family = AF_INET;
102: SendmailAddress.sin_addr.s_addr = INADDR_ANY;
103: SendmailAddress.sin_port = sp->s_port;
104:
105: /*
106: ** Try to actually open the connection.
107: */
108:
109: # ifdef DEBUG
110: if (tTd(15, 1))
111: printf("getrequests: port 0x%x\n", SendmailAddress.sin_port);
112: # endif DEBUG
113:
114: /* get a socket for the SMTP connection */
115: DaemonSocket = socket(AF_INET, SOCK_STREAM, 0);
116: if (DaemonSocket < 0)
117: {
118: /* probably another daemon already */
119: syserr("getrequests: can't create socket");
120: severe:
121: # ifdef LOG
122: if (LogLevel > 0)
123: syslog(LOG_ALERT, "cannot get connection");
124: # endif LOG
125: finis();
126: }
127:
128: #ifdef DEBUG
129: /* turn on network debugging? */
130: if (tTd(15, 15))
131: (void) setsockopt(DaemonSocket, SOL_SOCKET, SO_DEBUG, (char *)&on, sizeof on);
132: #endif DEBUG
133:
134: (void) setsockopt(DaemonSocket, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof on);
135: (void) setsockopt(DaemonSocket, SOL_SOCKET, SO_KEEPALIVE, (char *)&on, sizeof on);
136:
137: if (bind(DaemonSocket, &SendmailAddress, sizeof SendmailAddress) < 0)
138: {
139: syserr("getrequests: cannot bind");
140: (void) close(DaemonSocket);
141: goto severe;
142: }
143: if (listen(DaemonSocket, 10) < 0)
144: {
145: syserr("getrequests: cannot listen");
146: (void) close(DaemonSocket);
147: goto severe;
148: }
149:
150: (void) signal(SIGCHLD, reapchild);
151:
152: # ifdef DEBUG
153: if (tTd(15, 1))
154: printf("getrequests: %d\n", DaemonSocket);
155: # endif DEBUG
156:
157: for (;;)
158: {
159: register int pid;
160: auto int lotherend;
161: struct sockaddr_in otherend;
162: extern int RefuseLA;
163:
164: /* see if we are rejecting connections */
165: while (getla() > RefuseLA)
166: sleep(5);
167:
168: /* wait for a connection */
169: do
170: {
171: errno = 0;
172: lotherend = sizeof otherend;
173: t = accept(DaemonSocket, &otherend, &lotherend);
174: } while (t < 0 && errno == EINTR);
175: if (t < 0)
176: {
177: syserr("getrequests: accept");
178: sleep(5);
179: continue;
180: }
181:
182: /*
183: ** Create a subprocess to process the mail.
184: */
185:
186: # ifdef DEBUG
187: if (tTd(15, 2))
188: printf("getrequests: forking (fd = %d)\n", t);
189: # endif DEBUG
190:
191: pid = fork();
192: if (pid < 0)
193: {
194: syserr("daemon: cannot fork");
195: sleep(10);
196: (void) close(t);
197: continue;
198: }
199:
200: if (pid == 0)
201: {
202: extern struct hostent *gethostbyaddr();
203: register struct hostent *hp;
204: char buf[MAXNAME];
205:
206: /*
207: ** CHILD -- return to caller.
208: ** Collect verified idea of sending host.
209: ** Verify calling user id if possible here.
210: */
211:
212: (void) signal(SIGCHLD, SIG_DFL);
213:
214: /* determine host name */
215: hp = gethostbyaddr((char *) &otherend.sin_addr, sizeof otherend.sin_addr, AF_INET);
216: if (hp != NULL)
217: {
218: (void) strcpy(buf, hp->h_name);
219: if (NetName != NULL && NetName[0] != '\0' &&
220: index(hp->h_name, '.') == NULL)
221: {
222: (void) strcat(buf, ".");
223: (void) strcat(buf, NetName);
224: }
225: }
226: else
227: {
228: extern char *inet_ntoa();
229:
230: /* produce a dotted quad */
231: (void) sprintf(buf, "[%s]",
232: inet_ntoa(otherend.sin_addr));
233: }
234:
235: /* should we check for illegal connection here? XXX */
236:
237: RealHostName = newstr(buf);
238:
239: (void) close(DaemonSocket);
240: InChannel = fdopen(t, "r");
241: OutChannel = fdopen(dup(t), "w");
242: # ifdef DEBUG
243: if (tTd(15, 2))
244: printf("getreq: returning\n");
245: # endif DEBUG
246: # ifdef LOG
247: if (LogLevel > 11)
248: syslog(LOG_DEBUG, "connected, pid=%d", getpid());
249: # endif LOG
250: return;
251: }
252:
253: /* close the port so that others will hang (for a while) */
254: (void) close(t);
255: }
256: /*NOTREACHED*/
257: }
258: /*
259: ** CLRDAEMON -- reset the daemon connection
260: **
261: ** Parameters:
262: ** none.
263: **
264: ** Returns:
265: ** none.
266: **
267: ** Side Effects:
268: ** releases any resources used by the passive daemon.
269: */
270:
271: clrdaemon()
272: {
273: if (DaemonSocket >= 0)
274: (void) close(DaemonSocket);
275: DaemonSocket = -1;
276: }
277: /*
278: ** MAKECONNECTION -- make a connection to an SMTP socket on another machine.
279: **
280: ** Parameters:
281: ** host -- the name of the host.
282: ** port -- the port number to connect to.
283: ** outfile -- a pointer to a place to put the outfile
284: ** descriptor.
285: ** infile -- ditto for infile.
286: **
287: ** Returns:
288: ** An exit code telling whether the connection could be
289: ** made and if not why not.
290: **
291: ** Side Effects:
292: ** none.
293: */
294:
295: int h_errno; /*this will go away when code implemented*/
296:
297: makeconnection(host, port, outfile, infile)
298: char *host;
299: u_short port;
300: FILE **outfile;
301: FILE **infile;
302: {
303: register int s;
304: int sav_errno;
305:
306: /*
307: ** Set up the address for the mailer.
308: ** Accept "[a.b.c.d]" syntax for host name.
309: */
310:
311: h_errno = 0;
312: errno = 0;
313:
314: if (host[0] == '[')
315: {
316: long hid;
317: register char *p = index(host, ']');
318:
319: if (p != NULL)
320: {
321: *p = '\0';
322: hid = inet_addr(&host[1]);
323: *p = ']';
324: }
325: if (p == NULL || hid == -1)
326: {
327: usrerr("Invalid numeric domain spec \"%s\"", host);
328: return (EX_NOHOST);
329: }
330: SendmailAddress.sin_addr.s_addr = hid;
331: }
332: else
333: {
334: register struct hostent *hp = gethostbyname(host);
335:
336: if (hp == NULL)
337: {
338: if (errno == ETIMEDOUT || h_errno == TRY_AGAIN)
339: return (EX_TEMPFAIL);
340:
341: /*
342: ** XXX Should look for mail forwarder record here
343: ** XXX if (h_errno == NO_ADDRESS).
344: */
345:
346: return (EX_NOHOST);
347: }
348: bcopy(hp->h_addr, (char *) &SendmailAddress.sin_addr, hp->h_length);
349: }
350:
351: /*
352: ** Determine the port number.
353: */
354:
355: if (port != 0)
356: SendmailAddress.sin_port = htons(port);
357: else
358: {
359: register struct servent *sp = getservbyname("smtp", "tcp");
360:
361: if (sp == NULL)
362: {
363: syserr("makeconnection: server \"smtp\" unknown");
364: return (EX_OSFILE);
365: }
366: SendmailAddress.sin_port = sp->s_port;
367: }
368:
369: /*
370: ** Try to actually open the connection.
371: */
372:
373: # ifdef DEBUG
374: if (tTd(16, 1))
375: printf("makeconnection (%s)\n", host);
376: # endif DEBUG
377:
378: s = socket(AF_INET, SOCK_STREAM, 0);
379: if (s < 0)
380: {
381: syserr("makeconnection: no socket");
382: sav_errno = errno;
383: goto failure;
384: }
385:
386: # ifdef DEBUG
387: if (tTd(16, 1))
388: printf("makeconnection: %d\n", s);
389:
390: /* turn on network debugging? */
391: if (tTd(16, 14))
392: {
393: int on = 1;
394: (void) setsockopt(DaemonSocket, SOL_SOCKET, SO_DEBUG, (char *)&on, sizeof on);
395: }
396: # endif DEBUG
397: (void) fflush(CurEnv->e_xfp); /* for debugging */
398: errno = 0; /* for debugging */
399: SendmailAddress.sin_family = AF_INET;
400: if (connect(s, &SendmailAddress, sizeof SendmailAddress) < 0)
401: {
402: sav_errno = errno;
403: (void) close(s);
404: /* failure, decide if temporary or not */
405: failure:
406: switch (sav_errno)
407: {
408: case EISCONN:
409: case ETIMEDOUT:
410: case EINPROGRESS:
411: case EALREADY:
412: case EADDRINUSE:
413: case EHOSTDOWN:
414: case ENETDOWN:
415: case ENETRESET:
416: case ENOBUFS:
417: case ECONNREFUSED:
418: case ECONNRESET:
419: case EHOSTUNREACH:
420: case ENETUNREACH:
421: /* there are others, I'm sure..... */
422: return (EX_TEMPFAIL);
423:
424: case EPERM:
425: /* why is this happening? */
426: syserr("makeconnection: funny failure, addr=%lx, port=%x",
427: SendmailAddress.sin_addr.s_addr, SendmailAddress.sin_port);
428: return (EX_TEMPFAIL);
429:
430: default:
431: return (EX_UNAVAILABLE);
432: }
433: }
434:
435: /* connection ok, put it into canonical form */
436: *outfile = fdopen(s, "w");
437: *infile = fdopen(s, "r");
438:
439: return (EX_OK);
440: }
441: /*
442: ** MYHOSTNAME -- return the name of this host.
443: **
444: ** Parameters:
445: ** hostbuf -- a place to return the name of this host.
446: ** size -- the size of hostbuf.
447: **
448: ** Returns:
449: ** A list of aliases for this host.
450: **
451: ** Side Effects:
452: ** none.
453: */
454:
455: char **
456: myhostname(hostbuf, size)
457: char hostbuf[];
458: int size;
459: {
460: extern struct hostent *gethostbyname();
461: struct hostent *hp;
462:
463: if (gethostname(hostbuf, size) < 0)
464: {
465: (void) strcpy(hostbuf, "localhost");
466: }
467: hp = gethostbyname(hostbuf);
468: if (hp != NULL)
469: {
470: (void) strcpy(hostbuf, hp->h_name);
471: return (hp->h_aliases);
472: }
473: else
474: return (NULL);
475: }
476: /*
477: ** MAPHOSTNAME -- turn a hostname into canonical form
478: **
479: ** Parameters:
480: ** hbuf -- a buffer containing a hostname.
481: ** hbsize -- the size of hbuf.
482: **
483: ** Returns:
484: ** none.
485: **
486: ** Side Effects:
487: ** Looks up the host specified in hbuf. If it is not
488: ** the canonical name for that host, replace it with
489: ** the canonical name. If the name is unknown, or it
490: ** is already the canonical name, leave it unchanged.
491: */
492:
493: maphostname(hbuf, hbsize)
494: char *hbuf;
495: int hbsize;
496: {
497: register struct hostent *hp;
498: extern struct hostent *gethostbyname();
499:
500: /*
501: ** If first character is a bracket, then it is an address
502: ** lookup. Address is copied into a temporary buffer to
503: ** strip the brackets and to preserve hbuf if address is
504: ** unknown.
505: */
506:
507: if (*hbuf == '[')
508: {
509: extern struct hostent *gethostbyaddr();
510: u_long in_addr;
511: char ptr[256];
512: char *bptr;
513:
514: (void) strcpy(ptr, hbuf);
515: bptr = index(ptr,']');
516: *bptr = '\0';
517: in_addr = inet_addr(&ptr[1]);
518: hp = gethostbyaddr((char *) &in_addr, sizeof(struct in_addr), AF_INET);
519: if (hp == NULL)
520: return;
521: }
522: else
523: {
524: makelower(hbuf);
525: hp = gethostbyname(hbuf);
526: }
527: if (hp != NULL)
528: {
529: int i = strlen(hp->h_name);
530:
531: if (i >= hbsize)
532: hp->h_name[--i] = '\0';
533: (void) strcpy(hbuf, hp->h_name);
534: }
535: }
536:
537: # else DAEMON
538: /* code for systems without sophisticated networking */
539:
540: /*
541: ** MYHOSTNAME -- stub version for case of no daemon code.
542: **
543: ** Can't convert to upper case here because might be a UUCP name.
544: **
545: ** Mark, you can change this to be anything you want......
546: */
547:
548: char **
549: myhostname(hostbuf, size)
550: char hostbuf[];
551: int size;
552: {
553: register FILE *f;
554:
555: hostbuf[0] = '\0';
556: f = fopen("/usr/include/whoami", "r");
557: if (f != NULL)
558: {
559: (void) fgets(hostbuf, size, f);
560: fixcrlf(hostbuf, TRUE);
561: (void) fclose(f);
562: }
563: return (NULL);
564: }
565: /*
566: ** MAPHOSTNAME -- turn a hostname into canonical form
567: **
568: ** Parameters:
569: ** hbuf -- a buffer containing a hostname.
570: ** hbsize -- the size of hbuf.
571: **
572: ** Returns:
573: ** none.
574: **
575: ** Side Effects:
576: ** Looks up the host specified in hbuf. If it is not
577: ** the canonical name for that host, replace it with
578: ** the canonical name. If the name is unknown, or it
579: ** is already the canonical name, leave it unchanged.
580: */
581:
582: /*ARGSUSED*/
583: maphostname(hbuf, hbsize)
584: char *hbuf;
585: int hbsize;
586: {
587: return;
588: }
589:
590: #endif DAEMON
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.