Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Annotate
Revision Log

daemon.c @ 19204

Visit:

Revision 19204, 94.6 KB checked in by zacheiss, 21 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r19203, which included commits to RCS files with non-trunk default branches.

Line
1	/*
2	* Copyright (c) 1998-2003 Sendmail, Inc. and its suppliers.
3	* All rights reserved.
4	* Copyright (c) 1983, 1995-1997 Eric P. Allman. All rights reserved.
5	* Copyright (c) 1988, 1993
6	* The Regents of the University of California. All rights reserved.
7	*
8	* By using this file, you agree to the terms and conditions set
9	* forth in the LICENSE file which can be found at the top level of
10	* the sendmail distribution.
11	*
12	*/
13
14	#include <sendmail.h>
15
16	SM_RCSID("@(#)$Id: daemon.c,v 1.1.1.1 2003-04-08 15:08:53 zacheiss Exp $")
17
18	#if defined(SOCK_STREAM) \|\| defined(__GNU_LIBRARY__)
19	# define USE_SOCK_STREAM 1
20	#endif /* defined(SOCK_STREAM) \|\| defined(__GNU_LIBRARY__) */
21
22	#if defined(USE_SOCK_STREAM)
23	# if NETINET \|\| NETINET6
24	# include <arpa/inet.h>
25	# endif /* NETINET \|\| NETINET6 */
26	# if NAMED_BIND
27	# ifndef NO_DATA
28	# define NO_DATA NO_ADDRESS
29	# endif /* ! NO_DATA */
30	# endif /* NAMED_BIND */
31	#endif /* defined(USE_SOCK_STREAM) */
32
33	#if STARTTLS
34	# include <openssl/rand.h>
35	#endif /* STARTTLS */
36
37	#include <sys/time.h>
38
39	#if IP_SRCROUTE && NETINET
40	# include <netinet/in_systm.h>
41	# include <netinet/ip.h>
42	# if HAS_IN_H
43	# include <netinet/in.h>
44	# ifndef IPOPTION
45	# define IPOPTION ip_opts
46	# define IP_LIST ip_opts
47	# define IP_DST ip_dst
48	# endif /* ! IPOPTION */
49	# else /* HAS_IN_H */
50	# include <netinet/ip_var.h>
51	# ifndef IPOPTION
52	# define IPOPTION ipoption
53	# define IP_LIST ipopt_list
54	# define IP_DST ipopt_dst
55	# endif /* ! IPOPTION */
56	# endif /* HAS_IN_H */
57	#endif /* IP_SRCROUTE && NETINET */
58
59	#include <sm/fdset.h>
60
61	/* structure to describe a daemon or a client */
62	struct daemon
63	{
64	int d_socket; /* fd for socket */
65	SOCKADDR d_addr; /* socket for incoming */
66	unsigned short d_port; /* port number */
67	int d_listenqueue; /* size of listen queue */
68	int d_tcprcvbufsize; /* size of TCP receive buffer */
69	int d_tcpsndbufsize; /* size of TCP send buffer */
70	time_t d_refuse_connections_until;
71	bool d_firsttime;
72	int d_socksize;
73	BITMAP256 d_flags; /* flags; see sendmail.h */
74	char d_mflags; / flags for use in macro */
75	char d_name; / user-supplied name */
76	#if MILTER
77	# if _FFR_MILTER_PERDAEMON
78	char *d_inputfilterlist;
79	struct milter *d_inputfilters[MAXFILTERS];
80	# endif /* _FFR_MILTER_PERDAEMON */
81	#endif /* MILTER */
82	};
83
84	typedef struct daemon DAEMON_T;
85
86	static void connecttimeout __P((void));
87	static int opendaemonsocket __P((DAEMON_T *, bool));
88	static unsigned short setupdaemon __P((SOCKADDR *));
89	static void getrequests_checkdiskspace __P((ENVELOPE *e));
90
91	/*
92	** DAEMON.C -- routines to use when running as a daemon.
93	**
94	** This entire file is highly dependent on the 4.2 BSD
95	** interprocess communication primitives. No attempt has
96	** been made to make this file portable to Version 7,
97	** Version 6, MPX files, etc. If you should try such a
98	** thing yourself, I recommend chucking the entire file
99	** and starting from scratch. Basic semantics are:
100	**
101	** getrequests(e)
102	** Opens a port and initiates a connection.
103	** Returns in a child. Must set InChannel and
104	** OutChannel appropriately.
105	** clrdaemon()
106	** Close any open files associated with getting
107	** the connection; this is used when running the queue,
108	** etc., to avoid having extra file descriptors during
109	** the queue run and to avoid confusing the network
110	** code (if it cares).
111	** makeconnection(host, port, mci, e, enough)
112	** Make a connection to the named host on the given
113	** port. Returns zero on success, else an exit status
114	** describing the error.
115	** host_map_lookup(map, hbuf, avp, pstat)
116	** Convert the entry in hbuf into a canonical form.
117	*/
118
119	static DAEMON_T Daemons[MAXDAEMONS];
120	static int NDaemons = 0; /* actual number of daemons */
121
122	static time_t NextDiskSpaceCheck = 0;
123
124	/*
125	** GETREQUESTS -- open mail IPC port and get requests.
126	**
127	** Parameters:
128	** e -- the current envelope.
129	**
130	** Returns:
131	** pointer to flags.
132	**
133	** Side Effects:
134	** Waits until some interesting activity occurs. When
135	** it does, a child is created to process it, and the
136	** parent waits for completion. Return from this
137	** routine is always in the child. The file pointers
138	** "InChannel" and "OutChannel" should be set to point
139	** to the communication channel.
140	** May restart persistent queue runners if they have ended
141	** for some reason.
142	*/
143
144	BITMAP256 *
145	getrequests(e)
146	ENVELOPE *e;
147	{
148	int t;
149	int idx, curdaemon = -1;
150	int i, olddaemon = 0;
151	#if XDEBUG
152	bool j_has_dot;
153	#endif /* XDEBUG */
154	char status[MAXLINE];
155	SOCKADDR sa;
156	SOCKADDR_LEN_T len = sizeof sa;
157	#if _FFR_QUEUE_RUN_PARANOIA
158	time_t lastrun;
159	#endif /* _FFR_QUEUE_RUN_PARANOIA */
160	# if NETUNIX
161	extern int ControlSocket;
162	# endif /* NETUNIX */
163	extern ENVELOPE BlankEnvelope;
164	extern bool refuseconnections __P((char , ENVELOPE , int, bool));
165
166
167	for (idx = 0; idx < NDaemons; idx++)
168	{
169	Daemons[idx].d_port = setupdaemon(&(Daemons[idx].d_addr));
170	Daemons[idx].d_firsttime = true;
171	Daemons[idx].d_refuse_connections_until = (time_t) 0;
172	}
173
174	/*
175	** Try to actually open the connection.
176	*/
177
178	if (tTd(15, 1))
179	{
180	for (idx = 0; idx < NDaemons; idx++)
181	{
182	sm_dprintf("getrequests: daemon %s: port %d\n",
183	Daemons[idx].d_name,
184	ntohs(Daemons[idx].d_port));
185	}
186	}
187
188	/* get a socket for the SMTP connection */
189	for (idx = 0; idx < NDaemons; idx++)
190	Daemons[idx].d_socksize = opendaemonsocket(&Daemons[idx], true);
191
192	if (opencontrolsocket() < 0)
193	sm_syslog(LOG_WARNING, NOQID,
194	"daemon could not open control socket %s: %s",
195	ControlSocketName, sm_errstring(errno));
196
197	/* If there are any queue runners released reapchild() co-ord's */
198	(void) sm_signal(SIGCHLD, reapchild);
199
200	/* write the pid to file, command line args to syslog */
201	log_sendmail_pid(e);
202
203	#if XDEBUG
204	{
205	char jbuf[MAXHOSTNAMELEN];
206
207	expand("\201j", jbuf, sizeof jbuf, e);
208	j_has_dot = strchr(jbuf, '.') != NULL;
209	}
210	#endif /* XDEBUG */
211
212	/* Add parent process as first item */
213	proc_list_add(CurrentPid, "Sendmail daemon", PROC_DAEMON, 0, -1);
214
215	if (tTd(15, 1))
216	{
217	for (idx = 0; idx < NDaemons; idx++)
218	sm_dprintf("getrequests: daemon %s: %d\n",
219	Daemons[idx].d_name,
220	Daemons[idx].d_socket);
221	}
222
223	for (;;)
224	{
225	register pid_t pid;
226	auto SOCKADDR_LEN_T lotherend;
227	bool timedout = false;
228	bool control = false;
229	int save_errno;
230	int pipefd[2];
231	time_t now;
232	#if STARTTLS
233	long seed;
234	#endif /* STARTTLS */
235
236	/* see if we are rejecting connections */
237	(void) sm_blocksignal(SIGALRM);
238
239	if (ShutdownRequest != NULL)
240	shutdown_daemon();
241	else if (RestartRequest != NULL)
242	restart_daemon();
243	else if (RestartWorkGroup)
244	restart_marked_work_groups();
245
246	for (idx = 0; idx < NDaemons; idx++)
247	{
248	/*
249	** XXX do this call outside the loop?
250	** no: refuse_connections may sleep().
251	*/
252
253	now = curtime();
254	if (now < Daemons[idx].d_refuse_connections_until)
255	continue;
256	if (bitnset(D_DISABLE, Daemons[idx].d_flags))
257	continue;
258	if (refuseconnections(Daemons[idx].d_name, e, idx,
259	curdaemon == idx))
260	{
261	if (Daemons[idx].d_socket >= 0)
262	{
263	/* close socket so peer fails quickly */
264	(void) close(Daemons[idx].d_socket);
265	Daemons[idx].d_socket = -1;
266	}
267
268	/* refuse connections for next 15 seconds */
269	Daemons[idx].d_refuse_connections_until = now + 15;
270	}
271	else if (Daemons[idx].d_socket < 0 \|\|
272	Daemons[idx].d_firsttime)
273	{
274	if (!Daemons[idx].d_firsttime && LogLevel > 8)
275	sm_syslog(LOG_INFO, NOQID,
276	"accepting connections again for daemon %s",
277	Daemons[idx].d_name);
278
279	/* arrange to (re)open the socket if needed */
280	(void) opendaemonsocket(&Daemons[idx], false);
281	Daemons[idx].d_firsttime = false;
282	}
283	}
284
285	/* May have been sleeping above, check again */
286	if (ShutdownRequest != NULL)
287	shutdown_daemon();
288	else if (RestartRequest != NULL)
289	restart_daemon();
290	else if (RestartWorkGroup)
291	restart_marked_work_groups();
292
293	getrequests_checkdiskspace(e);
294
295	#if XDEBUG
296	/* check for disaster */
297	{
298	char jbuf[MAXHOSTNAMELEN];
299
300	expand("\201j", jbuf, sizeof jbuf, e);
301	if (!wordinclass(jbuf, 'w'))
302	{
303	dumpstate("daemon lost $j");
304	sm_syslog(LOG_ALERT, NOQID,
305	"daemon process doesn't have $j in $=w; see syslog");
306	abort();
307	}
308	else if (j_has_dot && strchr(jbuf, '.') == NULL)
309	{
310	dumpstate("daemon $j lost dot");
311	sm_syslog(LOG_ALERT, NOQID,
312	"daemon process $j lost dot; see syslog");
313	abort();
314	}
315	}
316	#endif /* XDEBUG */
317
318	#if 0
319	/*
320	** Andrew Sun <asun@ieps-sun.ml.com> claims that this will
321	** fix the SVr4 problem. But it seems to have gone away,
322	** so is it worth doing this?
323	*/
324
325	if (DaemonSocket >= 0 &&
326	SetNonBlocking(DaemonSocket, false) < 0)
327	log an error here;
328	#endif /* 0 */
329	(void) sm_releasesignal(SIGALRM);
330
331	for (;;)
332	{
333	bool setproc = false;
334	int highest = -1;
335	fd_set readfds;
336	struct timeval timeout;
337
338	if (ShutdownRequest != NULL)
339	shutdown_daemon();
340	else if (RestartRequest != NULL)
341	restart_daemon();
342	else if (RestartWorkGroup)
343	restart_marked_work_groups();
344
345	FD_ZERO(&readfds);
346
347	for (idx = 0; idx < NDaemons; idx++)
348	{
349	/* wait for a connection */
350	if (Daemons[idx].d_socket >= 0)
351	{
352	if (!setproc &&
353	!bitnset(D_ETRNONLY,
354	Daemons[idx].d_flags))
355	{
356	sm_setproctitle(true, e,
357	"accepting connections");
358	setproc = true;
359	}
360	if (Daemons[idx].d_socket > highest)
361	highest = Daemons[idx].d_socket;
362	SM_FD_SET(Daemons[idx].d_socket,
363	&readfds);
364	}
365	}
366
367	#if NETUNIX
368	if (ControlSocket >= 0)
369	{
370	if (ControlSocket > highest)
371	highest = ControlSocket;
372	SM_FD_SET(ControlSocket, &readfds);
373	}
374	#endif /* NETUNIX */
375
376	timeout.tv_sec = 5;
377	timeout.tv_usec = 0;
378
379	t = select(highest + 1, FDSET_CAST &readfds,
380	NULL, NULL, &timeout);
381
382	/* Did someone signal while waiting? */
383	if (ShutdownRequest != NULL)
384	shutdown_daemon();
385	else if (RestartRequest != NULL)
386	restart_daemon();
387	else if (RestartWorkGroup)
388	restart_marked_work_groups();
389
390
391
392	curdaemon = -1;
393	if (doqueuerun())
394	{
395	(void) runqueue(true, false, false, false);
396	#if _FFR_QUEUE_RUN_PARANOIA
397	lastrun = now;
398	#endif /* _FFR_QUEUE_RUN_PARANOIA */
399	}
400	#if _FFR_QUEUE_RUN_PARANOIA
401	else if (QueueIntvl > 0 &&
402	lastrun + QueueIntvl + 60 < now)
403	{
404
405	/*
406	** set lastrun unconditionally to avoid
407	** calling checkqueuerunner() all the time.
408	** That's also why we currently ignore the
409	** result of the function call.
410	*/
411
412	(void) checkqueuerunner();
413	lastrun = now;
414	}
415	#endif /* _FFR_QUEUE_RUN_PARANOIA */
416
417	if (t <= 0)
418	{
419	timedout = true;
420	break;
421	}
422
423	control = false;
424	errno = 0;
425
426	/* look "round-robin" for an active socket */
427	if ((idx = olddaemon + 1) >= NDaemons)
428	idx = 0;
429	for (i = 0; i < NDaemons; i++)
430	{
431	if (Daemons[idx].d_socket >= 0 &&
432	SM_FD_ISSET(Daemons[idx].d_socket,
433	&readfds))
434	{
435	lotherend = Daemons[idx].d_socksize;
436	memset(&RealHostAddr, '\0',
437	sizeof RealHostAddr);
438	t = accept(Daemons[idx].d_socket,
439	(struct sockaddr *)&RealHostAddr,
440	&lotherend);
441
442	/*
443	** If remote side closes before
444	** accept() finishes, sockaddr
445	** might not be fully filled in.
446	*/
447
448	if (t >= 0 &&
449	(lotherend == 0 \|\|
450	# ifdef BSD4_4_SOCKADDR
451	RealHostAddr.sa.sa_len == 0 \|\|
452	# endif /* BSD4_4_SOCKADDR */
453	RealHostAddr.sa.sa_family != Daemons[idx].d_addr.sa.sa_family))
454	{
455	(void) close(t);
456	t = -1;
457	errno = EINVAL;
458	}
459	olddaemon = curdaemon = idx;
460	break;
461	}
462	if (++idx >= NDaemons)
463	idx = 0;
464	}
465	#if NETUNIX
466	if (curdaemon == -1 && ControlSocket >= 0 &&
467	SM_FD_ISSET(ControlSocket, &readfds))
468	{
469	struct sockaddr_un sa_un;
470
471	lotherend = sizeof sa_un;
472	memset(&sa_un, '\0', sizeof sa_un);
473	t = accept(ControlSocket,
474	(struct sockaddr *)&sa_un,
475	&lotherend);
476
477	/*
478	** If remote side closes before
479	** accept() finishes, sockaddr
480	** might not be fully filled in.
481	*/
482
483	if (t >= 0 &&
484	(lotherend == 0 \|\|
485	# ifdef BSD4_4_SOCKADDR
486	sa_un.sun_len == 0 \|\|
487	# endif /* BSD4_4_SOCKADDR */
488	sa_un.sun_family != AF_UNIX))
489	{
490	(void) close(t);
491	t = -1;
492	errno = EINVAL;
493	}
494	if (t >= 0)
495	control = true;
496	}
497	#else /* NETUNIX */
498	if (curdaemon == -1)
499	{
500	/* No daemon to service */
501	continue;
502	}
503	#endif /* NETUNIX */
504	if (t >= 0 \|\| errno != EINTR)
505	break;
506	}
507	if (timedout)
508	{
509	timedout = false;
510	continue;
511	}
512	save_errno = errno;
513	(void) sm_blocksignal(SIGALRM);
514	if (t < 0)
515	{
516	errno = save_errno;
517	syserr("getrequests: accept");
518
519	/* arrange to re-open the socket next time around */
520	(void) close(Daemons[curdaemon].d_socket);
521	Daemons[curdaemon].d_socket = -1;
522	#if SO_REUSEADDR_IS_BROKEN
523	/*
524	** Give time for bound socket to be released.
525	** This creates a denial-of-service if you can
526	** force accept() to fail on affected systems.
527	*/
528
529	Daemons[curdaemon].d_refuse_connections_until = curtime() + 15;
530	#endif /* SO_REUSEADDR_IS_BROKEN */
531	continue;
532	}
533
534	if (!control)
535	{
536	/* set some daemon related macros */
537	switch (Daemons[curdaemon].d_addr.sa.sa_family)
538	{
539	case AF_UNSPEC:
540	macdefine(&BlankEnvelope.e_macro, A_PERM,
541	macid("{daemon_family}"), "unspec");
542	break;
543	#if _FFR_DAEMON_NETUNIX
544	# if NETUNIX
545	case AF_UNIX:
546	macdefine(&BlankEnvelope.e_macro, A_PERM,
547	macid("{daemon_family}"), "local");
548	break;
549	# endif /* NETUNIX */
550	#endif /* _FFR_DAEMON_NETUNIX */
551	#if NETINET
552	case AF_INET:
553	macdefine(&BlankEnvelope.e_macro, A_PERM,
554	macid("{daemon_family}"), "inet");
555	break;
556	#endif /* NETINET */
557	#if NETINET6
558	case AF_INET6:
559	macdefine(&BlankEnvelope.e_macro, A_PERM,
560	macid("{daemon_family}"), "inet6");
561	break;
562	#endif /* NETINET6 */
563	#if NETISO
564	case AF_ISO:
565	macdefine(&BlankEnvelope.e_macro, A_PERM,
566	macid("{daemon_family}"), "iso");
567	break;
568	#endif /* NETISO */
569	#if NETNS
570	case AF_NS:
571	macdefine(&BlankEnvelope.e_macro, A_PERM,
572	macid("{daemon_family}"), "ns");
573	break;
574	#endif /* NETNS */
575	#if NETX25
576	case AF_CCITT:
577	macdefine(&BlankEnvelope.e_macro, A_PERM,
578	macid("{daemon_family}"), "x.25");
579	break;
580	#endif /* NETX25 */
581	}
582	macdefine(&BlankEnvelope.e_macro, A_PERM,
583	macid("{daemon_name}"),
584	Daemons[curdaemon].d_name);
585	if (Daemons[curdaemon].d_mflags != NULL)
586	macdefine(&BlankEnvelope.e_macro, A_PERM,
587	macid("{daemon_flags}"),
588	Daemons[curdaemon].d_mflags);
589	else
590	macdefine(&BlankEnvelope.e_macro, A_PERM,
591	macid("{daemon_flags}"), "");
592	}
593
594	/*
595	** Create a subprocess to process the mail.
596	*/
597
598	if (tTd(15, 2))
599	sm_dprintf("getrequests: forking (fd = %d)\n", t);
600
601	/*
602	** Advance state of PRNG.
603	** This is necessary because otherwise all child processes
604	** will produce the same PRN sequence and hence the selection
605	** of a queue directory (and other things, e.g., MX selection)
606	** are not "really" random.
607	*/
608	#if STARTTLS
609	/* XXX get some better "random" data? */
610	seed = get_random();
611	RAND_seed((void *) &NextDiskSpaceCheck,
612	sizeof NextDiskSpaceCheck);
613	RAND_seed((void *) &now, sizeof now);
614	RAND_seed((void *) &seed, sizeof seed);
615	#else /* STARTTLS */
616	(void) get_random();
617	#endif /* STARTTLS */
618
619	#if NAMED_BIND
620	/*
621	** Update MX records for FallBackMX.
622	** Let's hope this is fast otherwise we screw up the
623	** response time.
624	*/
625
626	if (FallBackMX != NULL)
627	(void) getfallbackmxrr(FallBackMX);
628	#endif /* NAMED_BIND */
629
630	if (tTd(93, 100))
631	{
632	/* don't fork, handle connection in this process */
633	pid = 0;
634	pipefd[0] = pipefd[1] = -1;
635	}
636	else
637	{
638	/*
639	** Create a pipe to keep the child from writing to
640	** the socket until after the parent has closed
641	** it. Otherwise the parent may hang if the child
642	** has closed it first.
643	*/
644
645	if (pipe(pipefd) < 0)
646	pipefd[0] = pipefd[1] = -1;
647
648	(void) sm_blocksignal(SIGCHLD);
649	pid = fork();
650	if (pid < 0)
651	{
652	syserr("daemon: cannot fork");
653	if (pipefd[0] != -1)
654	{
655	(void) close(pipefd[0]);
656	(void) close(pipefd[1]);
657	}
658	(void) sm_releasesignal(SIGCHLD);
659	(void) sleep(10);
660	(void) close(t);
661	continue;
662	}
663	}
664
665	if (pid == 0)
666	{
667	char *p;
668	SM_FILE_T inchannel, outchannel = NULL;
669
670	/*
671	** CHILD -- return to caller.
672	** Collect verified idea of sending host.
673	** Verify calling user id if possible here.
674	*/
675
676	/* Reset global flags */
677	RestartRequest = NULL;
678	RestartWorkGroup = false;
679	ShutdownRequest = NULL;
680	PendingSignal = 0;
681	CurrentPid = getpid();
682
683	(void) sm_releasesignal(SIGALRM);
684	(void) sm_releasesignal(SIGCHLD);
685	(void) sm_signal(SIGCHLD, SIG_DFL);
686	(void) sm_signal(SIGHUP, SIG_DFL);
687	(void) sm_signal(SIGTERM, intsig);
688
689	/* turn on profiling */
690	/* SM_PROF(0); */
691
692	/*
693	** Initialize exception stack and default exception
694	** handler for child process.
695	*/
696
697	sm_exc_newthread(fatal_error);
698
699	if (!control)
700	{
701	macdefine(&BlankEnvelope.e_macro, A_TEMP,
702	macid("{daemon_addr}"),
703	anynet_ntoa(&Daemons[curdaemon].d_addr));
704	(void) sm_snprintf(status, sizeof status, "%d",
705	ntohs(Daemons[curdaemon].d_port));
706	macdefine(&BlankEnvelope.e_macro, A_TEMP,
707	macid("{daemon_port}"), status);
708	}
709
710	for (idx = 0; idx < NDaemons; idx++)
711	{
712	if (Daemons[idx].d_socket >= 0)
713	(void) close(Daemons[idx].d_socket);
714	Daemons[idx].d_socket = -1;
715	}
716	clrcontrol();
717
718	/* Avoid SMTP daemon actions if control command */
719	if (control)
720	{
721	/* Add control socket process */
722	proc_list_add(CurrentPid,
723	"console socket child",
724	PROC_CONTROL_CHILD, 0, -1);
725	}
726	else
727	{
728	proc_list_clear();
729
730	/* clean up background delivery children */
731	(void) sm_signal(SIGCHLD, reapchild);
732
733	/* Add parent process as first child item */
734	proc_list_add(CurrentPid, "daemon child",
735	PROC_DAEMON_CHILD, 0, -1);
736
737	/* don't schedule queue runs if ETRN */
738	QueueIntvl = 0;
739
740	sm_setproctitle(true, e, "startup with %s",
741	anynet_ntoa(&RealHostAddr));
742	}
743
744	if (pipefd[0] != -1)
745	{
746	auto char c;
747
748	/*
749	** Wait for the parent to close the write end
750	** of the pipe, which we will see as an EOF.
751	** This guarantees that we won't write to the
752	** socket until after the parent has closed
753	** the pipe.
754	*/
755
756	/* close the write end of the pipe */
757	(void) close(pipefd[1]);
758
759	/* we shouldn't be interrupted, but ... */
760	while (read(pipefd[0], &c, 1) < 0 &&
761	errno == EINTR)
762	continue;
763	(void) close(pipefd[0]);
764	}
765
766	/* control socket processing */
767	if (control)
768	{
769	control_command(t, e);
770	/* NOTREACHED */
771	exit(EX_SOFTWARE);
772	}
773
774	/* determine host name */
775	p = hostnamebyanyaddr(&RealHostAddr);
776	if (strlen(p) > MAXNAME) /* XXX - 1 ? */
777	p[MAXNAME] = '\0';
778	RealHostName = newstr(p);
779	if (RealHostName[0] == '[')
780	{
781	macdefine(&BlankEnvelope.e_macro, A_PERM,
782	macid("{client_resolve}"),
783	h_errno == TRY_AGAIN ? "TEMP" : "FAIL");
784	}
785	else
786	macdefine(&BlankEnvelope.e_macro, A_PERM,
787	macid("{client_resolve}"), "OK");
788	sm_setproctitle(true, e, "startup with %s", p);
789	markstats(e, NULL, STATS_CONNECT);
790
791	if ((inchannel = sm_io_open(SmFtStdiofd,
792	SM_TIME_DEFAULT,
793	(void *) &t,
794	SM_IO_RDONLY,
795	NULL)) == NULL \|\|
796	(t = dup(t)) < 0 \|\|
797	(outchannel = sm_io_open(SmFtStdiofd,
798	SM_TIME_DEFAULT,
799	(void *) &t,
800	SM_IO_WRONLY,
801	NULL)) == NULL)
802	{
803	syserr("cannot open SMTP server channel, fd=%d",
804	t);
805	finis(false, true, EX_OK);
806	}
807	sm_io_automode(inchannel, outchannel);
808
809	InChannel = inchannel;
810	OutChannel = outchannel;
811	DisConnected = false;
812
813	#if XLA
814	if (!xla_host_ok(RealHostName))
815	{
816	message("421 4.4.5 Too many SMTP sessions for this host");
817	finis(false, true, EX_OK);
818	}
819	#endif /* XLA */
820	/* find out name for interface of connection */
821	if (getsockname(sm_io_getinfo(InChannel, SM_IO_WHAT_FD,
822	NULL), &sa.sa, &len) == 0)
823	{
824	p = hostnamebyanyaddr(&sa);
825	if (tTd(15, 9))
826	sm_dprintf("getreq: got name %s\n", p);
827	macdefine(&BlankEnvelope.e_macro, A_TEMP,
828	macid("{if_name}"), p);
829
830	/*
831	** Do this only if it is not the loopback
832	** interface.
833	*/
834
835	if (!isloopback(sa))
836	{
837	char *addr;
838	char family[5];
839
840	addr = anynet_ntoa(&sa);
841	(void) sm_snprintf(family,
842	sizeof(family),
843	"%d", sa.sa.sa_family);
844	macdefine(&BlankEnvelope.e_macro,
845	A_TEMP,
846	macid("{if_addr}"), addr);
847	macdefine(&BlankEnvelope.e_macro,
848	A_TEMP,
849	macid("{if_family}"), family);
850	if (tTd(15, 7))
851	sm_dprintf("getreq: got addr %s and family %s\n",
852	addr, family);
853	}
854	else
855	{
856	macdefine(&BlankEnvelope.e_macro,
857	A_PERM,
858	macid("{if_addr}"), NULL);
859	macdefine(&BlankEnvelope.e_macro,
860	A_PERM,
861	macid("{if_family}"), NULL);
862	}
863	}
864	else
865	{
866	if (tTd(15, 7))
867	sm_dprintf("getreq: getsockname failed\n");
868	macdefine(&BlankEnvelope.e_macro, A_PERM,
869	macid("{if_name}"), NULL);
870	macdefine(&BlankEnvelope.e_macro, A_PERM,
871	macid("{if_addr}"), NULL);
872	macdefine(&BlankEnvelope.e_macro, A_PERM,
873	macid("{if_family}"), NULL);
874	}
875	break;
876	}
877
878	/* parent -- keep track of children */
879	if (control)
880	{
881	(void) sm_snprintf(status, sizeof status,
882	"control socket server child");
883	proc_list_add(pid, status, PROC_CONTROL, 0, -1);
884	}
885	else
886	{
887	(void) sm_snprintf(status, sizeof status,
888	"SMTP server child for %s",
889	anynet_ntoa(&RealHostAddr));
890	proc_list_add(pid, status, PROC_DAEMON, 0, -1);
891	}
892	(void) sm_releasesignal(SIGCHLD);
893
894	/* close the read end of the synchronization pipe */
895	if (pipefd[0] != -1)
896	{
897	(void) close(pipefd[0]);
898	pipefd[0] = -1;
899	}
900
901	/* close the port so that others will hang (for a while) */
902	(void) close(t);
903
904	/* release the child by closing the read end of the sync pipe */
905	if (pipefd[1] != -1)
906	{
907	(void) close(pipefd[1]);
908	pipefd[1] = -1;
909	}
910	}
911	if (tTd(15, 2))
912	sm_dprintf("getreq: returning\n");
913
914	#if MILTER
915	# if _FFR_MILTER_PERDAEMON
916	/* set the filters for this daemon */
917	if (Daemons[curdaemon].d_inputfilterlist != NULL)
918	{
919	for (i = 0;
920	(i < MAXFILTERS &&
921	Daemons[curdaemon].d_inputfilters[i] != NULL);
922	i++)
923	{
924	InputFilters[i] = Daemons[curdaemon].d_inputfilters[i];
925	}
926	if (i < MAXFILTERS)
927	InputFilters[i] = NULL;
928	}
929	# endif /* _FFR_MILTER_PERDAEMON */
930	#endif /* MILTER */
931	return &Daemons[curdaemon].d_flags;
932	}
933
934	/*
935	** GETREQUESTS_CHECKDISKSPACE -- check available diskspace.
936	**
937	** Parameters:
938	** e -- envelope.
939	**
940	** Returns:
941	** none.
942	**
943	** Side Effects:
944	** Modifies Daemon flags (D_ETRNONLY) if not enough disk space.
945	*/
946
947	static void
948	getrequests_checkdiskspace(e)
949	ENVELOPE *e;
950	{
951	bool logged = false;
952	int idx;
953	time_t now;
954
955	now = curtime();
956	if (now < NextDiskSpaceCheck)
957	return;
958
959	/* Check if there is available disk space in all queue groups. */
960	if (!enoughdiskspace(0, NULL))
961	{
962	for (idx = 0; idx < NDaemons; ++idx)
963	{
964	if (bitnset(D_ETRNONLY, Daemons[idx].d_flags))
965	continue;
966
967	/* log only if not logged before */
968	if (!logged)
969	{
970	if (LogLevel > 8)
971	sm_syslog(LOG_INFO, NOQID,
972	"rejecting new messages: min free: %ld",
973	MinBlocksFree);
974	sm_setproctitle(true, e,
975	"rejecting new messages: min free: %ld",
976	MinBlocksFree);
977	logged = true;
978	}
979	setbitn(D_ETRNONLY, Daemons[idx].d_flags);
980	}
981	}
982	else
983	{
984	for (idx = 0; idx < NDaemons; ++idx)
985	{
986	if (!bitnset(D_ETRNONLY, Daemons[idx].d_flags))
987	continue;
988
989	/* log only if not logged before */
990	if (!logged)
991	{
992	if (LogLevel > 8)
993	sm_syslog(LOG_INFO, NOQID,
994	"accepting new messages (again)");
995	logged = true;
996	}
997
998	/* title will be set later */
999	clrbitn(D_ETRNONLY, Daemons[idx].d_flags);
1000	}
1001	}
1002
1003	/* only check disk space once a minute */
1004	NextDiskSpaceCheck = now + 60;
1005	}
1006
1007	/*
1008	** OPENDAEMONSOCKET -- open SMTP socket
1009	**
1010	** Deals with setting all appropriate options.
1011	**
1012	** Parameters:
1013	** d -- the structure for the daemon to open.
1014	** firsttime -- set if this is the initial open.
1015	**
1016	** Returns:
1017	** Size in bytes of the daemon socket addr.
1018	**
1019	** Side Effects:
1020	** Leaves DaemonSocket set to the open socket.
1021	** Exits if the socket cannot be created.
1022	*/
1023
1024	#define MAXOPENTRIES 10 /* maximum number of tries to open connection */
1025
1026	static int
1027	opendaemonsocket(d, firsttime)
1028	DAEMON_T *d;
1029	bool firsttime;
1030	{
1031	int on = 1;
1032	int fdflags;
1033	SOCKADDR_LEN_T socksize = 0;
1034	int ntries = 0;
1035	int save_errno;
1036
1037	if (tTd(15, 2))
1038	sm_dprintf("opendaemonsocket(%s)\n", d->d_name);
1039
1040	do
1041	{
1042	if (ntries > 0)
1043	(void) sleep(5);
1044	if (firsttime \|\| d->d_socket < 0)
1045	{
1046	#if _FFR_DAEMON_NETUNIX
1047	# if NETUNIX
1048	if (d->d_addr.sa.sa_family == AF_UNIX)
1049	{
1050	int rval;
1051	long sff = SFF_SAFEDIRPATH\|SFF_OPENASROOT\|SFF_NOLINK\|SFF_ROOTOK\|SFF_EXECOK\|SFF_CREAT;
1052
1053	/* if not safe, don't use it */
1054	rval = safefile(d->d_addr.sunix.sun_path,
1055	RunAsUid, RunAsGid,
1056	RunAsUserName, sff,
1057	S_IRUSR\|S_IWUSR, NULL);
1058	if (rval != 0)
1059	{
1060	save_errno = errno;
1061	syserr("opendaemonsocket: daemon %s: unsafe domain socket %s",
1062	d->d_name,
1063	d->d_addr.sunix.sun_path);
1064	goto fail;
1065	}
1066
1067	/* Don't try to overtake an existing socket */
1068	(void) unlink(d->d_addr.sunix.sun_path);
1069	}
1070	# endif /* NETUNIX */
1071	#endif /* _FFR_DOMAIN_NETUNIX */
1072	d->d_socket = socket(d->d_addr.sa.sa_family,
1073	SOCK_STREAM, 0);
1074	if (d->d_socket < 0)
1075	{
1076	save_errno = errno;
1077	syserr("opendaemonsocket: daemon %s: can't create server SMTP socket",
1078	d->d_name);
1079	fail:
1080	if (bitnset(D_OPTIONAL, d->d_flags) &&
1081	(!transienterror(save_errno) \|\|
1082	ntries >= MAXOPENTRIES - 1))
1083	{
1084	syserr("opendaemonsocket: daemon %s: optional socket disabled",
1085	d->d_name);
1086	setbitn(D_DISABLE, d->d_flags);
1087	d->d_socket = -1;
1088	return -1;
1089	}
1090	severe:
1091	if (LogLevel > 0)
1092	sm_syslog(LOG_ALERT, NOQID,
1093	"daemon %s: problem creating SMTP socket",
1094	d->d_name);
1095	d->d_socket = -1;
1096	continue;
1097	}
1098
1099	if (SM_FD_SETSIZE > 0 && d->d_socket >= SM_FD_SETSIZE)
1100	{
1101	save_errno = EINVAL;
1102	syserr("opendaemonsocket: daemon %s: server SMTP socket (%d) too large",
1103	d->d_name, d->d_socket);
1104	goto fail;
1105	}
1106
1107	/* turn on network debugging? */
1108	if (tTd(15, 101))
1109	(void) setsockopt(d->d_socket, SOL_SOCKET,
1110	SO_DEBUG, (char *)&on,
1111	sizeof on);
1112
1113	(void) setsockopt(d->d_socket, SOL_SOCKET,
1114	SO_REUSEADDR, (char *)&on, sizeof on);
1115	(void) setsockopt(d->d_socket, SOL_SOCKET,
1116	SO_KEEPALIVE, (char *)&on, sizeof on);
1117
1118	#ifdef SO_RCVBUF
1119	if (d->d_tcprcvbufsize > 0)
1120	{
1121	if (setsockopt(d->d_socket, SOL_SOCKET,
1122	SO_RCVBUF,
1123	(char *) &d->d_tcprcvbufsize,
1124	sizeof(d->d_tcprcvbufsize)) < 0)
1125	syserr("opendaemonsocket: daemon %s: setsockopt(SO_RCVBUF)", d->d_name);
1126	}
1127	#endif /* SO_RCVBUF */
1128	#ifdef SO_SNDBUF
1129	if (d->d_tcpsndbufsize > 0)
1130	{
1131	if (setsockopt(d->d_socket, SOL_SOCKET,
1132	SO_SNDBUF,
1133	(char *) &d->d_tcpsndbufsize,
1134	sizeof(d->d_tcpsndbufsize)) < 0)
1135	syserr("opendaemonsocket: daemon %s: setsockopt(SO_SNDBUF)", d->d_name);
1136	}
1137	#endif /* SO_SNDBUF */
1138
1139	if ((fdflags = fcntl(d->d_socket, F_GETFD, 0)) == -1 \|\|
1140	fcntl(d->d_socket, F_SETFD,
1141	fdflags \| FD_CLOEXEC) == -1)
1142	{
1143	save_errno = errno;
1144	syserr("opendaemonsocket: daemon %s: failed to %s close-on-exec flag: %s",
1145	d->d_name,
1146	fdflags == -1 ? "get" : "set",
1147	sm_errstring(save_errno));
1148	(void) close(d->d_socket);
1149	goto severe;
1150	}
1151
1152	switch (d->d_addr.sa.sa_family)
1153	{
1154	#if _FFR_DAEMON_NETUNIX
1155	# ifdef NETUNIX
1156	case AF_UNIX:
1157	socksize = sizeof d->d_addr.sunix;
1158	break;
1159	# endif /* NETUNIX */
1160	#endif /* _FFR_DAEMON_NETUNIX */
1161	#if NETINET
1162	case AF_INET:
1163	socksize = sizeof d->d_addr.sin;
1164	break;
1165	#endif /* NETINET */
1166
1167	#if NETINET6
1168	case AF_INET6:
1169	socksize = sizeof d->d_addr.sin6;
1170	break;
1171	#endif /* NETINET6 */
1172
1173	#if NETISO
1174	case AF_ISO:
1175	socksize = sizeof d->d_addr.siso;
1176	break;
1177	#endif /* NETISO */
1178
1179	default:
1180	socksize = sizeof d->d_addr;
1181	break;
1182	}
1183
1184	if (bind(d->d_socket, &d->d_addr.sa, socksize) < 0)
1185	{
1186	/* probably another daemon already */
1187	save_errno = errno;
1188	syserr("opendaemonsocket: daemon %s: cannot bind",
1189	d->d_name);
1190	(void) close(d->d_socket);
1191	goto fail;
1192	}
1193	}
1194	if (!firsttime &&
1195	listen(d->d_socket, d->d_listenqueue) < 0)
1196	{
1197	save_errno = errno;
1198	syserr("opendaemonsocket: daemon %s: cannot listen",
1199	d->d_name);
1200	(void) close(d->d_socket);
1201	goto severe;
1202	}
1203	return socksize;
1204	} while (ntries++ < MAXOPENTRIES && transienterror(save_errno));
1205	syserr("!opendaemonsocket: daemon %s: server SMTP socket wedged: exiting",
1206	d->d_name);
1207	/* NOTREACHED */
1208	return -1; /* avoid compiler warning on IRIX */
1209	}
1210	/*
1211	** SETUPDAEMON -- setup socket for daemon
1212	**
1213	** Parameters:
1214	** daemonaddr -- socket for daemon
1215	**
1216	** Returns:
1217	** port number on which daemon should run
1218	**
1219	*/
1220
1221	static unsigned short
1222	setupdaemon(daemonaddr)
1223	SOCKADDR *daemonaddr;
1224	{
1225	unsigned short port;
1226
1227	/*
1228	** Set up the address for the mailer.
1229	*/
1230
1231	if (daemonaddr->sa.sa_family == AF_UNSPEC)
1232	{
1233	memset(daemonaddr, '\0', sizeof *daemonaddr);
1234	#if NETINET
1235	daemonaddr->sa.sa_family = AF_INET;
1236	#endif /* NETINET */
1237	}
1238
1239	switch (daemonaddr->sa.sa_family)
1240	{
1241	#if NETINET
1242	case AF_INET:
1243	if (daemonaddr->sin.sin_addr.s_addr == 0)
1244	daemonaddr->sin.sin_addr.s_addr = INADDR_ANY;
1245	port = daemonaddr->sin.sin_port;
1246	break;
1247	#endif /* NETINET */
1248
1249	#if NETINET6
1250	case AF_INET6:
1251	if (IN6_IS_ADDR_UNSPECIFIED(&daemonaddr->sin6.sin6_addr))
1252	daemonaddr->sin6.sin6_addr = in6addr_any;
1253	port = daemonaddr->sin6.sin6_port;
1254	break;
1255	#endif /* NETINET6 */
1256
1257	default:
1258	/* unknown protocol */
1259	port = 0;
1260	break;
1261	}
1262	if (port == 0)
1263	{
1264	#ifdef NO_GETSERVBYNAME
1265	port = htons(25);
1266	#else /* NO_GETSERVBYNAME */
1267	{
1268	register struct servent *sp;
1269
1270	sp = getservbyname("smtp", "tcp");
1271	if (sp == NULL)
1272	{
1273	syserr("554 5.3.5 service \"smtp\" unknown");
1274	port = htons(25);
1275	}
1276	else
1277	port = sp->s_port;
1278	}
1279	#endif /* NO_GETSERVBYNAME */
1280	}
1281
1282	switch (daemonaddr->sa.sa_family)
1283	{
1284	#if NETINET
1285	case AF_INET:
1286	daemonaddr->sin.sin_port = port;
1287	break;
1288	#endif /* NETINET */
1289
1290	#if NETINET6
1291	case AF_INET6:
1292	daemonaddr->sin6.sin6_port = port;
1293	break;
1294	#endif /* NETINET6 */
1295
1296	default:
1297	/* unknown protocol */
1298	break;
1299	}
1300	return port;
1301	}
1302	/*
1303	** CLRDAEMON -- reset the daemon connection
1304	**
1305	** Parameters:
1306	** none.
1307	**
1308	** Returns:
1309	** none.
1310	**
1311	** Side Effects:
1312	** releases any resources used by the passive daemon.
1313	*/
1314
1315	void
1316	clrdaemon()
1317	{
1318	int i;
1319
1320	for (i = 0; i < NDaemons; i++)
1321	{
1322	if (Daemons[i].d_socket >= 0)
1323	(void) close(Daemons[i].d_socket);
1324	Daemons[i].d_socket = -1;
1325	}
1326	}
1327
1328	/*
1329	** GETMODIFIERS -- get modifier flags
1330	**
1331	** Parameters:
1332	** v -- the modifiers (input text line).
1333	** modifiers -- pointer to flag field to represent modifiers.
1334	**
1335	** Returns:
1336	** (xallocat()ed) string representation of modifiers.
1337	**
1338	** Side Effects:
1339	** fills in modifiers.
1340	*/
1341
1342	char *
1343	getmodifiers(v, modifiers)
1344	char *v;
1345	BITMAP256 modifiers;
1346	{
1347	int l;
1348	char h, f, *flags;
1349
1350	/* maximum length of flags: upper case Option -> "OO " */
1351	l = 3 * strlen(v) + 3;
1352
1353	/* is someone joking? */
1354	if (l < 0 \|\| l > 256)
1355	{
1356	if (LogLevel > 2)
1357	sm_syslog(LOG_ERR, NOQID,
1358	"getmodifiers too long, ignored");
1359	return NULL;
1360	}
1361	flags = xalloc(l);
1362	f = flags;
1363	clrbitmap(modifiers);
1364	for (h = v; *h != '\0'; h++)
1365	{
1366	if (isascii(h) && !isspace(h) && isprint(*h))
1367	{
1368	setbitn(*h, modifiers);
1369	if (flags != f)
1370	*flags++ = ' ';
1371	flags++ = h;
1372	if (isupper(*h))
1373	flags++ = h;
1374	}
1375	}
1376	*flags++ = '\0';
1377	return f;
1378	}
1379
1380	/*
1381	** CHKDAEMONMODIFIERS -- check whether all daemons have set a flag.
1382	**
1383	** Parameters:
1384	** flag -- the flag to test.
1385	**
1386	** Returns:
1387	** true iff all daemons have set flag.
1388	*/
1389
1390	bool
1391	chkdaemonmodifiers(flag)
1392	int flag;
1393	{
1394	int i;
1395
1396	for (i = 0; i < NDaemons; i++)
1397	if (!bitnset((char) flag, Daemons[i].d_flags))
1398	return false;
1399	return true;
1400	}
1401
1402	/*
1403	** SETSOCKADDROPTIONS -- set options for SOCKADDR (daemon or client)
1404	**
1405	** Parameters:
1406	** p -- the options line.
1407	** d -- the daemon structure to fill in.
1408	**
1409	** Returns:
1410	** none.
1411	*/
1412
1413	static void
1414	setsockaddroptions(p, d)
1415	register char *p;
1416	DAEMON_T *d;
1417	{
1418	#if NETISO
1419	short portno;
1420	#endif /* NETISO */
1421	char *port = NULL;
1422	char *addr = NULL;
1423
1424	#if NETINET
1425	if (d->d_addr.sa.sa_family == AF_UNSPEC)
1426	d->d_addr.sa.sa_family = AF_INET;
1427	#endif /* NETINET */
1428
1429	while (p != NULL)
1430	{
1431	register char *f;
1432	register char *v;
1433
1434	while (isascii(p) && isspace(p))
1435	p++;
1436	if (*p == '\0')
1437	break;
1438	f = p;
1439	p = strchr(p, ',');
1440	if (p != NULL)
1441	*p++ = '\0';
1442	v = strchr(f, '=');
1443	if (v == NULL)
1444	continue;
1445	while (isascii(++v) && isspace(v))
1446	continue;
1447	if (isascii(f) && islower(f))
1448	f = toupper(f);
1449
1450	switch (*f)
1451	{
1452	case 'F': /* address family */
1453	if (isascii(v) && isdigit(v))
1454	d->d_addr.sa.sa_family = atoi(v);
1455	#if _FFR_DAEMON_NETUNIX
1456	# ifdef NETUNIX
1457	else if (sm_strcasecmp(v, "unix") == 0 \|\|
1458	sm_strcasecmp(v, "local") == 0)
1459	d->d_addr.sa.sa_family = AF_UNIX;
1460	# endif /* NETUNIX */
1461	#endif /* _FFR_DAEMON_NETUNIX */
1462	#if NETINET
1463	else if (sm_strcasecmp(v, "inet") == 0)
1464	d->d_addr.sa.sa_family = AF_INET;
1465	#endif /* NETINET */
1466	#if NETINET6
1467	else if (sm_strcasecmp(v, "inet6") == 0)
1468	d->d_addr.sa.sa_family = AF_INET6;
1469	#endif /* NETINET6 */
1470	#if NETISO
1471	else if (sm_strcasecmp(v, "iso") == 0)
1472	d->d_addr.sa.sa_family = AF_ISO;
1473	#endif /* NETISO */
1474	#if NETNS
1475	else if (sm_strcasecmp(v, "ns") == 0)
1476	d->d_addr.sa.sa_family = AF_NS;
1477	#endif /* NETNS */
1478	#if NETX25
1479	else if (sm_strcasecmp(v, "x.25") == 0)
1480	d->d_addr.sa.sa_family = AF_CCITT;
1481	#endif /* NETX25 */
1482	else
1483	syserr("554 5.3.5 Unknown address family %s in Family=option",
1484	v);
1485	break;
1486
1487	case 'A': /* address */
1488	addr = v;
1489	break;
1490
1491	#if MILTER
1492	# if _FFR_MILTER_PERDAEMON
1493	case 'I':
1494	d->d_inputfilterlist = v;
1495	break;
1496	# endif /* _FFR_MILTER_PERDAEMON */
1497	#endif /* MILTER */
1498
1499	case 'P': /* port */
1500	port = v;
1501	break;
1502
1503	case 'L': /* listen queue size */
1504	d->d_listenqueue = atoi(v);
1505	break;
1506
1507	case 'M': /* modifiers (flags) */
1508	d->d_mflags = getmodifiers(v, d->d_flags);
1509	break;
1510
1511	case 'S': /* send buffer size */
1512	d->d_tcpsndbufsize = atoi(v);
1513	break;
1514
1515	case 'R': /* receive buffer size */
1516	d->d_tcprcvbufsize = atoi(v);
1517	break;
1518
1519	case 'N': /* name */
1520	d->d_name = v;
1521	break;
1522
1523	default:
1524	syserr("554 5.3.5 PortOptions parameter \"%s\" unknown",
1525	f);
1526	}
1527	}
1528
1529	/* Check addr and port after finding family */
1530	if (addr != NULL)
1531	{
1532	switch (d->d_addr.sa.sa_family)
1533	{
1534	#if _FFR_DAEMON_NETUNIX
1535	# if NETUNIX
1536	case AF_UNIX:
1537	if (strlen(addr) >= sizeof(d->d_addr.sunix.sun_path))
1538	{
1539	errno = ENAMETOOLONG;
1540	syserr("setsockaddroptions: domain socket name too long: %s > %d",
1541	addr, sizeof(d->d_addr.sunix.sun_path));
1542	break;
1543	}
1544
1545	/* file safety check done in opendaemonsocket() */
1546	(void) memset(&d->d_addr.sunix.sun_path, '\0',
1547	sizeof(d->d_addr.sunix.sun_path));
1548	(void) sm_strlcpy((char *)&d->d_addr.sunix.sun_path,
1549	addr,
1550	sizeof(d->d_addr.sunix.sun_path));
1551	break;
1552	# endif /* NETUNIX */
1553	#endif /* _FFR_DAEMON_NETUNIX */
1554	#if NETINET
1555	case AF_INET:
1556	if (!isascii(addr) \|\| !isdigit(addr) \|\|
1557	((d->d_addr.sin.sin_addr.s_addr = inet_addr(addr))
1558	== INADDR_NONE))
1559	{
1560	register struct hostent *hp;
1561
1562	hp = sm_gethostbyname(addr, AF_INET);
1563	if (hp == NULL)
1564	syserr("554 5.3.0 host \"%s\" unknown",
1565	addr);
1566	else
1567	{
1568	while (*(hp->h_addr_list) != NULL &&
1569	hp->h_addrtype != AF_INET)
1570	hp->h_addr_list++;
1571	if (*(hp->h_addr_list) == NULL)
1572	syserr("554 5.3.0 host \"%s\" unknown",
1573	addr);
1574	else
1575	memmove(&d->d_addr.sin.sin_addr,
1576	*(hp->h_addr_list),
1577	INADDRSZ);
1578	# if NETINET6
1579	freehostent(hp);
1580	hp = NULL;
1581	# endif /* NETINET6 */
1582	}
1583	}
1584	break;
1585	#endif /* NETINET */
1586
1587	#if NETINET6
1588	case AF_INET6:
1589	if (anynet_pton(AF_INET6, addr,
1590	&d->d_addr.sin6.sin6_addr) != 1)
1591	{
1592	register struct hostent *hp;
1593
1594	hp = sm_gethostbyname(addr, AF_INET6);
1595	if (hp == NULL)
1596	syserr("554 5.3.0 host \"%s\" unknown",
1597	addr);
1598	else
1599	{
1600	while (*(hp->h_addr_list) != NULL &&
1601	hp->h_addrtype != AF_INET6)
1602	hp->h_addr_list++;
1603	if (*(hp->h_addr_list) == NULL)
1604	syserr("554 5.3.0 host \"%s\" unknown",
1605	addr);
1606	else
1607	memmove(&d->d_addr.sin6.sin6_addr,
1608	*(hp->h_addr_list),
1609	IN6ADDRSZ);
1610	freehostent(hp);
1611	hp = NULL;
1612	}
1613	}
1614	break;
1615	#endif /* NETINET6 */
1616
1617	default:
1618	syserr("554 5.3.5 address= option unsupported for family %d",
1619	d->d_addr.sa.sa_family);
1620	break;
1621	}
1622	}
1623
1624	if (port != NULL)
1625	{
1626	switch (d->d_addr.sa.sa_family)
1627	{
1628	#if NETINET
1629	case AF_INET:
1630	if (isascii(port) && isdigit(port))
1631	d->d_addr.sin.sin_port = htons((unsigned short)
1632	atoi((const char *) port));
1633	else
1634	{
1635	# ifdef NO_GETSERVBYNAME
1636	syserr("554 5.3.5 invalid port number: %s",
1637	port);
1638	# else /* NO_GETSERVBYNAME */
1639	register struct servent *sp;
1640
1641	sp = getservbyname(port, "tcp");
1642	if (sp == NULL)
1643	syserr("554 5.3.5 service \"%s\" unknown",
1644	port);
1645	else
1646	d->d_addr.sin.sin_port = sp->s_port;
1647	# endif /* NO_GETSERVBYNAME */
1648	}
1649	break;
1650	#endif /* NETINET */
1651
1652	#if NETINET6
1653	case AF_INET6:
1654	if (isascii(port) && isdigit(port))
1655	d->d_addr.sin6.sin6_port = htons((unsigned short)
1656	atoi(port));
1657	else
1658	{
1659	# ifdef NO_GETSERVBYNAME
1660	syserr("554 5.3.5 invalid port number: %s",
1661	port);
1662	# else /* NO_GETSERVBYNAME */
1663	register struct servent *sp;
1664
1665	sp = getservbyname(port, "tcp");
1666	if (sp == NULL)
1667	syserr("554 5.3.5 service \"%s\" unknown",
1668	port);
1669	else
1670	d->d_addr.sin6.sin6_port = sp->s_port;
1671	# endif /* NO_GETSERVBYNAME */
1672	}
1673	break;
1674	#endif /* NETINET6 */
1675
1676	#if NETISO
1677	case AF_ISO:
1678	/* assume two byte transport selector */
1679	if (isascii(port) && isdigit(port))
1680	portno = htons((unsigned short) atoi(port));
1681	else
1682	{
1683	# ifdef NO_GETSERVBYNAME
1684	syserr("554 5.3.5 invalid port number: %s",
1685	port);
1686	# else /* NO_GETSERVBYNAME */
1687	register struct servent *sp;
1688
1689	sp = getservbyname(port, "tcp");
1690	if (sp == NULL)
1691	syserr("554 5.3.5 service \"%s\" unknown",
1692	port);
1693	else
1694	portno = sp->s_port;
1695	# endif /* NO_GETSERVBYNAME */
1696	}
1697	memmove(TSEL(&d->d_addr.siso),
1698	(char *) &portno, 2);
1699	break;
1700	#endif /* NETISO */
1701
1702	default:
1703	syserr("554 5.3.5 Port= option unsupported for family %d",
1704	d->d_addr.sa.sa_family);
1705	break;
1706	}
1707	}
1708	}
1709	/*
1710	** SETDAEMONOPTIONS -- set options for running the MTA daemon
1711	**
1712	** Parameters:
1713	** p -- the options line.
1714	**
1715	** Returns:
1716	** true if successful, false otherwise.
1717	**
1718	** Side Effects:
1719	** increments number of daemons.
1720	*/
1721
1722	#define DEF_LISTENQUEUE 10
1723
1724	struct dflags
1725	{
1726	char *d_name;
1727	int d_flag;
1728	};
1729
1730	static struct dflags DaemonFlags[] =
1731	{
1732	{ "AUTHREQ", D_AUTHREQ },
1733	{ "BINDIF", D_BINDIF },
1734	{ "CANONREQ", D_CANONREQ },
1735	{ "IFNHELO", D_IFNHELO },
1736	{ "FQMAIL", D_FQMAIL },
1737	{ "FQRCPT", D_FQRCPT },
1738	#if _FFR_SMTP_SSL
1739	{ "SMTPS", D_SMTPS },
1740	#endif /* _FFR_SMTP_SSL */
1741	{ "UNQUALOK", D_UNQUALOK },
1742	{ "NOAUTH", D_NOAUTH },
1743	{ "NOCANON", D_NOCANON },
1744	{ "NOETRN", D_NOETRN },
1745	{ "NOTLS", D_NOTLS },
1746	{ "ETRNONLY", D_ETRNONLY },
1747	{ "OPTIONAL", D_OPTIONAL },
1748	{ "DISABLE", D_DISABLE },
1749	{ "ISSET", D_ISSET },
1750	{ NULL, 0 }
1751	};
1752
1753	static void
1754	printdaemonflags(d)
1755	DAEMON_T *d;
1756	{
1757	register struct dflags *df;
1758	bool first = true;
1759
1760	for (df = DaemonFlags; df->d_name != NULL; df++)
1761	{
1762	if (!bitnset(df->d_flag, d->d_flags))
1763	continue;
1764	if (first)
1765	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "<%s",
1766	df->d_name);
1767	else
1768	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, ",%s",
1769	df->d_name);
1770	first = false;
1771	}
1772	if (!first)
1773	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, ">");
1774	}
1775
1776	bool
1777	setdaemonoptions(p)
1778	register char *p;
1779	{
1780	if (NDaemons >= MAXDAEMONS)
1781	return false;
1782	Daemons[NDaemons].d_socket = -1;
1783	Daemons[NDaemons].d_listenqueue = DEF_LISTENQUEUE;
1784	clrbitmap(Daemons[NDaemons].d_flags);
1785	setsockaddroptions(p, &Daemons[NDaemons]);
1786
1787	#if MILTER
1788	# if _FFR_MILTER_PERDAEMON
1789	if (Daemons[NDaemons].d_inputfilterlist != NULL)
1790	Daemons[NDaemons].d_inputfilterlist = newstr(Daemons[NDaemons].d_inputfilterlist);
1791	# endif /* _FFR_MILTER_PERDAEMON */
1792	#endif /* MILTER */
1793
1794	if (Daemons[NDaemons].d_name != NULL)
1795	Daemons[NDaemons].d_name = newstr(Daemons[NDaemons].d_name);
1796	else
1797	{
1798	char num[30];
1799
1800	(void) sm_snprintf(num, sizeof num, "Daemon%d", NDaemons);
1801	Daemons[NDaemons].d_name = newstr(num);
1802	}
1803
1804	if (tTd(37, 1))
1805	{
1806	sm_dprintf("Daemon %s flags: ", Daemons[NDaemons].d_name);
1807	printdaemonflags(&Daemons[NDaemons]);
1808	sm_dprintf("\n");
1809	}
1810	++NDaemons;
1811	return true;
1812	}
1813	/*
1814	** INITDAEMON -- initialize daemon if not yet done.
1815	**
1816	** Parameters:
1817	** none
1818	**
1819	** Returns:
1820	** none
1821	**
1822	** Side Effects:
1823	** initializes structure for one daemon.
1824	*/
1825
1826	void
1827	initdaemon()
1828	{
1829	if (NDaemons == 0)
1830	{
1831	Daemons[NDaemons].d_socket = -1;
1832	Daemons[NDaemons].d_listenqueue = DEF_LISTENQUEUE;
1833	Daemons[NDaemons].d_name = "Daemon0";
1834	NDaemons = 1;
1835	}
1836	}
1837	/*
1838	** SETCLIENTOPTIONS -- set options for running the client
1839	**
1840	** Parameters:
1841	** p -- the options line.
1842	**
1843	** Returns:
1844	** none.
1845	*/
1846
1847	static DAEMON_T ClientSettings[AF_MAX + 1];
1848
1849	void
1850	setclientoptions(p)
1851	register char *p;
1852	{
1853	int family;
1854	DAEMON_T d;
1855
1856	memset(&d, '\0', sizeof d);
1857	setsockaddroptions(p, &d);
1858
1859	/* grab what we need */
1860	family = d.d_addr.sa.sa_family;
1861	STRUCTCOPY(d, ClientSettings[family]);
1862	setbitn(D_ISSET, ClientSettings[family].d_flags); /* mark as set */
1863	if (d.d_name != NULL)
1864	ClientSettings[family].d_name = newstr(d.d_name);
1865	else
1866	{
1867	char num[30];
1868
1869	(void) sm_snprintf(num, sizeof num, "Client%d", family);
1870	ClientSettings[family].d_name = newstr(num);
1871	}
1872	}
1873	/*
1874	** ADDR_FAMILY -- determine address family from address
1875	**
1876	** Parameters:
1877	** addr -- the string representation of the address
1878	**
1879	** Returns:
1880	** AF_INET, AF_INET6 or AF_UNSPEC
1881	**
1882	** Side Effects:
1883	** none.
1884	*/
1885
1886	static int
1887	addr_family(addr)
1888	char *addr;
1889	{
1890	#if NETINET6
1891	SOCKADDR clt_addr;
1892	#endif /* NETINET6 */
1893
1894	#if NETINET
1895	if (inet_addr(addr) != INADDR_NONE)
1896	{
1897	if (tTd(16, 9))
1898	sm_dprintf("addr_family(%s): INET\n", addr);
1899	return AF_INET;
1900	}
1901	#endif /* NETINET */
1902	#if NETINET6
1903	if (anynet_pton(AF_INET6, addr, &clt_addr.sin6.sin6_addr) == 1)
1904	{
1905	if (tTd(16, 9))
1906	sm_dprintf("addr_family(%s): INET6\n", addr);
1907	return AF_INET6;
1908	}
1909	#endif /* NETINET6 */
1910	#if _FFR_DAEMON_NETUNIX
1911	# if NETUNIX
1912	if (*addr == '/')
1913	{
1914	if (tTd(16, 9))
1915	sm_dprintf("addr_family(%s): LOCAL\n", addr);
1916	return AF_UNIX;
1917	}
1918	# endif /* NETUNIX */
1919	#endif /* _FFR_DAEMON_NETUNIX */
1920	if (tTd(16, 9))
1921	sm_dprintf("addr_family(%s): UNSPEC\n", addr);
1922	return AF_UNSPEC;
1923	}
1924
1925	/*
1926	** CHKCLIENTMODIFIERS -- check whether all clients have set a flag.
1927	**
1928	** Parameters:
1929	** flag -- the flag to test.
1930	**
1931	** Returns:
1932	** true iff all configured clients have set the flag.
1933	*/
1934
1935	bool
1936	chkclientmodifiers(flag)
1937	int flag;
1938	{
1939	int i;
1940	bool flagisset;
1941
1942	flagisset = false;
1943	for (i = 0; i < AF_MAX; i++)
1944	{
1945	if (bitnset(D_ISSET, ClientSettings[i].d_flags))
1946	{
1947	if (!bitnset((char) flag, ClientSettings[i].d_flags))
1948	return false;
1949	flagisset = true;
1950	}
1951	}
1952	return flagisset;
1953	}
1954
1955	#if MILTER
1956	# if _FFR_MILTER_PERDAEMON
1957	/*
1958	** SETUP_DAEMON_FILTERS -- Parse per-socket filters
1959	**
1960	** Parameters:
1961	** none
1962	**
1963	** Returns:
1964	** none
1965	*/
1966
1967	void
1968	setup_daemon_milters()
1969	{
1970	int idx;
1971
1972	if (OpMode == MD_SMTP)
1973	{
1974	/* no need to configure the daemons */
1975	return;
1976	}
1977
1978	for (idx = 0; idx < NDaemons; idx++)
1979	{
1980	if (Daemons[idx].d_inputfilterlist != NULL)
1981	{
1982	milter_config(Daemons[idx].d_inputfilterlist,
1983	Daemons[idx].d_inputfilters,
1984	MAXFILTERS);
1985	}
1986	}
1987	}
1988	# endif /* _FFR_MILTER_PERDAEMON */
1989	#endif /* MILTER */
1990	/*
1991	** MAKECONNECTION -- make a connection to an SMTP socket on a machine.
1992	**
1993	** Parameters:
1994	** host -- the name of the host.
1995	** port -- the port number to connect to.
1996	** mci -- a pointer to the mail connection information
1997	** structure to be filled in.
1998	** e -- the current envelope.
1999	** enough -- time at which to stop further connection attempts.
2000	** (0 means no limit)
2001	**
2002	** Returns:
2003	** An exit code telling whether the connection could be
2004	** made and if not why not.
2005	**
2006	** Side Effects:
2007	** none.
2008	*/
2009
2010	static jmp_buf CtxConnectTimeout;
2011
2012	SOCKADDR CurHostAddr; /* address of current host */
2013
2014	int
2015	makeconnection(host, port, mci, e, enough)
2016	char *host;
2017	volatile unsigned int port;
2018	register MCI *mci;
2019	ENVELOPE *e;
2020	time_t enough;
2021	{
2022	register volatile int addrno = 0;
2023	volatile int s;
2024	register struct hostent volatile hp = (struct hostent ) NULL;
2025	SOCKADDR addr;
2026	SOCKADDR clt_addr;
2027	int save_errno = 0;
2028	volatile SOCKADDR_LEN_T addrlen;
2029	volatile bool firstconnect;
2030	SM_EVENT *volatile ev = NULL;
2031	#if NETINET6
2032	volatile bool v6found = false;
2033	#endif /* NETINET6 */
2034	volatile int family = InetMode;
2035	SOCKADDR_LEN_T len;
2036	volatile SOCKADDR_LEN_T socksize = 0;
2037	volatile bool clt_bind;
2038	BITMAP256 d_flags;
2039	char *p;
2040	extern ENVELOPE BlankEnvelope;
2041
2042	/* retranslate {daemon_flags} into bitmap */
2043	clrbitmap(d_flags);
2044	if ((p = macvalue(macid("{daemon_flags}"), e)) != NULL)
2045	{
2046	for (; *p != '\0'; p++)
2047	{
2048	if (!(isascii(p) && isspace(p)))
2049	setbitn(bitidx(*p), d_flags);
2050	}
2051	}
2052
2053	#if NETINET6
2054	v4retry:
2055	#endif /* NETINET6 */
2056	clt_bind = false;
2057
2058	/* Set up the address for outgoing connection. */
2059	if (bitnset(D_BINDIF, d_flags) &&
2060	(p = macvalue(macid("{if_addr}"), e)) != NULL &&
2061	*p != '\0')
2062	{
2063	#if NETINET6
2064	char p6[INET6_ADDRSTRLEN];
2065	#endif /* NETINET6 */
2066
2067	memset(&clt_addr, '\0', sizeof clt_addr);
2068
2069	/* infer the address family from the address itself */
2070	clt_addr.sa.sa_family = addr_family(p);
2071	switch (clt_addr.sa.sa_family)
2072	{
2073	#if NETINET
2074	case AF_INET:
2075	clt_addr.sin.sin_addr.s_addr = inet_addr(p);
2076	if (clt_addr.sin.sin_addr.s_addr != INADDR_NONE &&
2077	clt_addr.sin.sin_addr.s_addr != INADDR_LOOPBACK)
2078	{
2079	clt_bind = true;
2080	socksize = sizeof (struct sockaddr_in);
2081	}
2082	break;
2083	#endif /* NETINET */
2084
2085	#if NETINET6
2086	case AF_INET6:
2087	if (inet_addr(p) != INADDR_NONE)
2088	(void) sm_snprintf(p6, sizeof p6,
2089	"IPv6:::ffff:%s", p);
2090	else
2091	(void) sm_strlcpy(p6, p, sizeof p6);
2092	if (anynet_pton(AF_INET6, p6,
2093	&clt_addr.sin6.sin6_addr) == 1 &&
2094	!IN6_IS_ADDR_LOOPBACK(&clt_addr.sin6.sin6_addr))
2095	{
2096	clt_bind = true;
2097	socksize = sizeof (struct sockaddr_in6);
2098	}
2099	break;
2100	#endif /* NETINET6 */
2101
2102	#if 0
2103	default:
2104	syserr("554 5.3.5 Address= option unsupported for family %d",
2105	clt_addr.sa.sa_family);
2106	break;
2107	#endif /* 0 */
2108	}
2109	if (clt_bind)
2110	family = clt_addr.sa.sa_family;
2111	}
2112
2113	/* D_BINDIF not set or not available, fallback to ClientPortOptions */
2114	if (!clt_bind)
2115	{
2116	STRUCTCOPY(ClientSettings[family].d_addr, clt_addr);
2117	switch (clt_addr.sa.sa_family)
2118	{
2119	#if NETINET
2120	case AF_INET:
2121	if (clt_addr.sin.sin_addr.s_addr == 0)
2122	clt_addr.sin.sin_addr.s_addr = INADDR_ANY;
2123	else
2124	clt_bind = true;
2125	if (clt_addr.sin.sin_port != 0)
2126	clt_bind = true;
2127	socksize = sizeof (struct sockaddr_in);
2128	break;
2129	#endif /* NETINET */
2130	#if NETINET6
2131	case AF_INET6:
2132	if (IN6_IS_ADDR_UNSPECIFIED(&clt_addr.sin6.sin6_addr))
2133	clt_addr.sin6.sin6_addr = in6addr_any;
2134	else
2135	clt_bind = true;
2136	socksize = sizeof (struct sockaddr_in6);
2137	if (clt_addr.sin6.sin6_port != 0)
2138	clt_bind = true;
2139	break;
2140	#endif /* NETINET6 */
2141	#if NETISO
2142	case AF_ISO:
2143	socksize = sizeof clt_addr.siso;
2144	clt_bind = true;
2145	break;
2146	#endif /* NETISO */
2147	default:
2148	break;
2149	}
2150	}
2151
2152	/*
2153	** Set up the address for the mailer.
2154	** Accept "[a.b.c.d]" syntax for host name.
2155	*/
2156
2157	SM_SET_H_ERRNO(0);
2158	errno = 0;
2159	memset(&CurHostAddr, '\0', sizeof CurHostAddr);
2160	memset(&addr, '\0', sizeof addr);
2161	SmtpPhase = mci->mci_phase = "initial connection";
2162	CurHostName = host;
2163
2164	if (host[0] == '[')
2165	{
2166	p = strchr(host, ']');
2167	if (p != NULL)
2168	{
2169	#if NETINET
2170	unsigned long hid = INADDR_NONE;
2171	#endif /* NETINET */
2172	#if NETINET6
2173	struct sockaddr_in6 hid6;
2174	#endif /* NETINET6 */
2175
2176	*p = '\0';
2177	#if NETINET6
2178	memset(&hid6, '\0', sizeof hid6);
2179	#endif /* NETINET6 */
2180	#if NETINET
2181	if (family == AF_INET &&
2182	(hid = inet_addr(&host[1])) != INADDR_NONE)
2183	{
2184	addr.sin.sin_family = AF_INET;
2185	addr.sin.sin_addr.s_addr = hid;
2186	}
2187	else
2188	#endif /* NETINET */
2189	#if NETINET6
2190	if (family == AF_INET6 &&
2191	anynet_pton(AF_INET6, &host[1],
2192	&hid6.sin6_addr) == 1)
2193	{
2194	addr.sin6.sin6_family = AF_INET6;
2195	addr.sin6.sin6_addr = hid6.sin6_addr;
2196	}
2197	else
2198	#endif /* NETINET6 */
2199	{
2200	/* try it as a host name (avoid MX lookup) */
2201	hp = sm_gethostbyname(&host[1], family);
2202	if (hp == NULL && p[-1] == '.')
2203	{
2204	#if NAMED_BIND
2205	int oldopts = _res.options;
2206
2207	_res.options &= ~(RES_DEFNAMES\|RES_DNSRCH);
2208	#endif /* NAMED_BIND */
2209	p[-1] = '\0';
2210	hp = sm_gethostbyname(&host[1],
2211	family);
2212	p[-1] = '.';
2213	#if NAMED_BIND
2214	_res.options = oldopts;
2215	#endif /* NAMED_BIND */
2216	}
2217	*p = ']';
2218	goto gothostent;
2219	}
2220	*p = ']';
2221	}
2222	if (p == NULL)
2223	{
2224	extern char MsgBuf[];
2225
2226	usrerrenh("5.1.2",
2227	"553 Invalid numeric domain spec \"%s\"",
2228	host);
2229	mci_setstat(mci, EX_NOHOST, "5.1.2", MsgBuf);
2230	errno = EINVAL;
2231	return EX_NOHOST;
2232	}
2233	}
2234	else
2235	{
2236	/* contortion to get around SGI cc complaints */
2237	{
2238	p = &host[strlen(host) - 1];
2239	hp = sm_gethostbyname(host, family);
2240	if (hp == NULL && *p == '.')
2241	{
2242	#if NAMED_BIND
2243	int oldopts = _res.options;
2244
2245	_res.options &= ~(RES_DEFNAMES\|RES_DNSRCH);
2246	#endif /* NAMED_BIND */
2247	*p = '\0';
2248	hp = sm_gethostbyname(host, family);
2249	*p = '.';
2250	#if NAMED_BIND
2251	_res.options = oldopts;
2252	#endif /* NAMED_BIND */
2253	}
2254	}
2255	gothostent:
2256	if (hp == NULL)
2257	{
2258	#if NAMED_BIND
2259	/* check for name server timeouts */
2260	# if NETINET6
2261	if (WorkAroundBrokenAAAA && family == AF_INET6 &&
2262	errno == ETIMEDOUT)
2263	{
2264	/*
2265	** An attempt with family AF_INET may
2266	** succeed By skipping the next section
2267	** of code, we will try AF_INET before
2268	** failing.
2269	*/
2270
2271	if (tTd(16, 10))
2272	sm_dprintf("makeconnection: WorkAroundBrokenAAAA: Trying AF_INET lookup (AF_INET6 failed)\n");
2273	}
2274	else
2275	# endif /* NETINET6 */
2276	{
2277	if (errno == ETIMEDOUT \|\|
2278	h_errno == TRY_AGAIN \|\|
2279	(errno == ECONNREFUSED && UseNameServer))
2280	{
2281	save_errno = errno;
2282	mci_setstat(mci, EX_TEMPFAIL,
2283	"4.4.3", NULL);
2284	errno = save_errno;
2285	return EX_TEMPFAIL;
2286	}
2287	}
2288	#endif /* NAMED_BIND */
2289	#if NETINET6
2290	/*
2291	** Try v6 first, then fall back to v4.
2292	** If we found a v6 address, but no v4
2293	** addresses, then TEMPFAIL.
2294	*/
2295
2296	if (family == AF_INET6)
2297	{
2298	family = AF_INET;
2299	goto v4retry;
2300	}
2301	if (v6found)
2302	goto v6tempfail;
2303	#endif /* NETINET6 */
2304	save_errno = errno;
2305	mci_setstat(mci, EX_NOHOST, "5.1.2", NULL);
2306	errno = save_errno;
2307	return EX_NOHOST;
2308	}
2309	addr.sa.sa_family = hp->h_addrtype;
2310	switch (hp->h_addrtype)
2311	{
2312	#if NETINET
2313	case AF_INET:
2314	memmove(&addr.sin.sin_addr,
2315	hp->h_addr,
2316	INADDRSZ);
2317	break;
2318	#endif /* NETINET */
2319
2320	#if NETINET6
2321	case AF_INET6:
2322	memmove(&addr.sin6.sin6_addr,
2323	hp->h_addr,
2324	IN6ADDRSZ);
2325	break;
2326	#endif /* NETINET6 */
2327
2328	default:
2329	if (hp->h_length > sizeof addr.sa.sa_data)
2330	{
2331	syserr("makeconnection: long sa_data: family %d len %d",
2332	hp->h_addrtype, hp->h_length);
2333	mci_setstat(mci, EX_NOHOST, "5.1.2", NULL);
2334	errno = EINVAL;
2335	return EX_NOHOST;
2336	}
2337	memmove(addr.sa.sa_data, hp->h_addr, hp->h_length);
2338	break;
2339	}
2340	addrno = 1;
2341	}
2342
2343	/*
2344	** Determine the port number.
2345	*/
2346
2347	if (port == 0)
2348	{
2349	#ifdef NO_GETSERVBYNAME
2350	port = htons(25);
2351	#else /* NO_GETSERVBYNAME */
2352	register struct servent *sp = getservbyname("smtp", "tcp");
2353
2354	if (sp == NULL)
2355	{
2356	if (LogLevel > 2)
2357	sm_syslog(LOG_ERR, NOQID,
2358	"makeconnection: service \"smtp\" unknown");
2359	port = htons(25);
2360	}
2361	else
2362	port = sp->s_port;
2363	#endif /* NO_GETSERVBYNAME */
2364	}
2365
2366	#if NETINET6
2367	if (addr.sa.sa_family == AF_INET6 &&
2368	IN6_IS_ADDR_V4MAPPED(&addr.sin6.sin6_addr) &&
2369	ClientSettings[AF_INET].d_addr.sa.sa_family != 0)
2370	{
2371	/*
2372	** Ignore mapped IPv4 address since
2373	** there is a ClientPortOptions setting
2374	** for IPv4.
2375	*/
2376
2377	goto nextaddr;
2378	}
2379	#endif /* NETINET6 */
2380
2381	switch (addr.sa.sa_family)
2382	{
2383	#if NETINET
2384	case AF_INET:
2385	addr.sin.sin_port = port;
2386	addrlen = sizeof (struct sockaddr_in);
2387	break;
2388	#endif /* NETINET */
2389
2390	#if NETINET6
2391	case AF_INET6:
2392	addr.sin6.sin6_port = port;
2393	addrlen = sizeof (struct sockaddr_in6);
2394	break;
2395	#endif /* NETINET6 */
2396
2397	#if NETISO
2398	case AF_ISO:
2399	/* assume two byte transport selector */
2400	memmove(TSEL((struct sockaddr_iso ) &addr), (char ) &port, 2);
2401	addrlen = sizeof (struct sockaddr_iso);
2402	break;
2403	#endif /* NETISO */
2404
2405	default:
2406	syserr("Can't connect to address family %d", addr.sa.sa_family);
2407	mci_setstat(mci, EX_NOHOST, "5.1.2", NULL);
2408	errno = EINVAL;
2409	#if NETINET6
2410	if (hp != NULL)
2411	freehostent(hp);
2412	#endif /* NETINET6 */
2413	return EX_NOHOST;
2414	}
2415
2416	/*
2417	** Try to actually open the connection.
2418	*/
2419
2420	#if XLA
2421	/* if too many connections, don't bother trying */
2422	if (!xla_noqueue_ok(host))
2423	{
2424	# if NETINET6
2425	if (hp != NULL)
2426	freehostent(hp);
2427	# endif /* NETINET6 */
2428	return EX_TEMPFAIL;
2429	}
2430	#endif /* XLA */
2431
2432	firstconnect = true;
2433	for (;;)
2434	{
2435	if (tTd(16, 1))
2436	sm_dprintf("makeconnection (%s [%s].%d (%d))\n",
2437	host, anynet_ntoa(&addr), ntohs(port),
2438	(int) addr.sa.sa_family);
2439
2440	/* save for logging */
2441	CurHostAddr = addr;
2442
2443	#if HASRRESVPORT
2444	if (bitnset(M_SECURE_PORT, mci->mci_mailer->m_flags))
2445	{
2446	int rport = IPPORT_RESERVED - 1;
2447
2448	s = rresvport(&rport);
2449	}
2450	else
2451	#endif /* HASRRESVPORT */
2452	{
2453	s = socket(addr.sa.sa_family, SOCK_STREAM, 0);
2454	}
2455	if (s < 0)
2456	{
2457	save_errno = errno;
2458	syserr("makeconnection: cannot create socket");
2459	#if XLA
2460	xla_host_end(host);
2461	#endif /* XLA */
2462	mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
2463	#if NETINET6
2464	if (hp != NULL)
2465	freehostent(hp);
2466	#endif /* NETINET6 */
2467	errno = save_errno;
2468	return EX_TEMPFAIL;
2469	}
2470
2471	#ifdef SO_SNDBUF
2472	if (ClientSettings[family].d_tcpsndbufsize > 0)
2473	{
2474	if (setsockopt(s, SOL_SOCKET, SO_SNDBUF,
2475	(char *) &ClientSettings[family].d_tcpsndbufsize,
2476	sizeof(ClientSettings[family].d_tcpsndbufsize)) < 0)
2477	syserr("makeconnection: setsockopt(SO_SNDBUF)");
2478	}
2479	#endif /* SO_SNDBUF */
2480	#ifdef SO_RCVBUF
2481	if (ClientSettings[family].d_tcprcvbufsize > 0)
2482	{
2483	if (setsockopt(s, SOL_SOCKET, SO_RCVBUF,
2484	(char *) &ClientSettings[family].d_tcprcvbufsize,
2485	sizeof(ClientSettings[family].d_tcprcvbufsize)) < 0)
2486	syserr("makeconnection: setsockopt(SO_RCVBUF)");
2487	}
2488	#endif /* SO_RCVBUF */
2489
2490	if (tTd(16, 1))
2491	sm_dprintf("makeconnection: fd=%d\n", s);
2492
2493	/* turn on network debugging? */
2494	if (tTd(16, 101))
2495	{
2496	int on = 1;
2497
2498	(void) setsockopt(s, SOL_SOCKET, SO_DEBUG,
2499	(char *)&on, sizeof on);
2500	}
2501	if (e->e_xfp != NULL) /* for debugging */
2502	(void) sm_io_flush(e->e_xfp, SM_TIME_DEFAULT);
2503	errno = 0; /* for debugging */
2504
2505	if (clt_bind)
2506	{
2507	int on = 1;
2508
2509	switch (clt_addr.sa.sa_family)
2510	{
2511	#if NETINET
2512	case AF_INET:
2513	if (clt_addr.sin.sin_port != 0)
2514	(void) setsockopt(s, SOL_SOCKET,
2515	SO_REUSEADDR,
2516	(char *) &on,
2517	sizeof on);
2518	break;
2519	#endif /* NETINET */
2520
2521	#if NETINET6
2522	case AF_INET6:
2523	if (clt_addr.sin6.sin6_port != 0)
2524	(void) setsockopt(s, SOL_SOCKET,
2525	SO_REUSEADDR,
2526	(char *) &on,
2527	sizeof on);
2528	break;
2529	#endif /* NETINET6 */
2530	}
2531
2532	if (bind(s, &clt_addr.sa, socksize) < 0)
2533	{
2534	save_errno = errno;
2535	(void) close(s);
2536	errno = save_errno;
2537	syserr("makeconnection: cannot bind socket [%s]",
2538	anynet_ntoa(&clt_addr));
2539	#if NETINET6
2540	if (hp != NULL)
2541	freehostent(hp);
2542	#endif /* NETINET6 */
2543	errno = save_errno;
2544	return EX_TEMPFAIL;
2545	}
2546	}
2547
2548	/*
2549	** Linux seems to hang in connect for 90 minutes (!!!).
2550	** Time out the connect to avoid this problem.
2551	*/
2552
2553	if (setjmp(CtxConnectTimeout) == 0)
2554	{
2555	int i;
2556
2557	if (e->e_ntries <= 0 && TimeOuts.to_iconnect != 0)
2558	ev = sm_setevent(TimeOuts.to_iconnect,
2559	connecttimeout, 0);
2560	else if (TimeOuts.to_connect != 0)
2561	ev = sm_setevent(TimeOuts.to_connect,
2562	connecttimeout, 0);
2563	else
2564	ev = NULL;
2565
2566	switch (ConnectOnlyTo.sa.sa_family)
2567	{
2568	#if NETINET
2569	case AF_INET:
2570	addr.sin.sin_addr.s_addr = ConnectOnlyTo.sin.sin_addr.s_addr;
2571	break;
2572	#endif /* NETINET */
2573
2574	#if NETINET6
2575	case AF_INET6:
2576	memmove(&addr.sin6.sin6_addr,
2577	&ConnectOnlyTo.sin6.sin6_addr,
2578	IN6ADDRSZ);
2579	break;
2580	#endif /* NETINET6 */
2581	}
2582	i = connect(s, (struct sockaddr *) &addr, addrlen);
2583	save_errno = errno;
2584	if (ev != NULL)
2585	sm_clrevent(ev);
2586	if (i >= 0)
2587	break;
2588	}
2589	else
2590	save_errno = errno;
2591
2592	/* couldn't connect.... figure out why */
2593	(void) close(s);
2594
2595	/* if running demand-dialed connection, try again */
2596	if (DialDelay > 0 && firstconnect &&
2597	bitnset(M_DIALDELAY, mci->mci_mailer->m_flags))
2598	{
2599	if (tTd(16, 1))
2600	sm_dprintf("Connect failed (%s); trying again...\n",
2601	sm_errstring(save_errno));
2602	firstconnect = false;
2603	(void) sleep(DialDelay);
2604	continue;
2605	}
2606
2607	if (LogLevel > 13)
2608	sm_syslog(LOG_INFO, e->e_id,
2609	"makeconnection (%s [%s]) failed: %s",
2610	host, anynet_ntoa(&addr),
2611	sm_errstring(save_errno));
2612
2613	#if NETINET6
2614	nextaddr:
2615	#endif /* NETINET6 */
2616	if (hp != NULL && hp->h_addr_list[addrno] != NULL &&
2617	(enough == 0 \|\| curtime() < enough))
2618	{
2619	if (tTd(16, 1))
2620	sm_dprintf("Connect failed (%s); trying new address....\n",
2621	sm_errstring(save_errno));
2622	switch (addr.sa.sa_family)
2623	{
2624	#if NETINET
2625	case AF_INET:
2626	memmove(&addr.sin.sin_addr,
2627	hp->h_addr_list[addrno++],
2628	INADDRSZ);
2629	break;
2630	#endif /* NETINET */
2631
2632	#if NETINET6
2633	case AF_INET6:
2634	memmove(&addr.sin6.sin6_addr,
2635	hp->h_addr_list[addrno++],
2636	IN6ADDRSZ);
2637	break;
2638	#endif /* NETINET6 */
2639
2640	default:
2641	memmove(addr.sa.sa_data,
2642	hp->h_addr_list[addrno++],
2643	hp->h_length);
2644	break;
2645	}
2646	continue;
2647	}
2648	errno = save_errno;
2649
2650	#if NETINET6
2651	if (family == AF_INET6)
2652	{
2653	if (tTd(16, 1))
2654	sm_dprintf("Connect failed (%s); retrying with AF_INET....\n",
2655	sm_errstring(save_errno));
2656	v6found = true;
2657	family = AF_INET;
2658	if (hp != NULL)
2659	{
2660	freehostent(hp);
2661	hp = NULL;
2662	}
2663	goto v4retry;
2664	}
2665	v6tempfail:
2666	#endif /* NETINET6 */
2667	/* couldn't open connection */
2668	#if NETINET6
2669	/* Don't clobber an already saved errno from v4retry */
2670	if (errno > 0)
2671	#endif /* NETINET6 */
2672	save_errno = errno;
2673	if (tTd(16, 1))
2674	sm_dprintf("Connect failed (%s)\n",
2675	sm_errstring(save_errno));
2676	#if XLA
2677	xla_host_end(host);
2678	#endif /* XLA */
2679	mci_setstat(mci, EX_TEMPFAIL, "4.4.1", NULL);
2680	#if NETINET6
2681	if (hp != NULL)
2682	freehostent(hp);
2683	#endif /* NETINET6 */
2684	errno = save_errno;
2685	return EX_TEMPFAIL;
2686	}
2687
2688	#if NETINET6
2689	if (hp != NULL)
2690	{
2691	freehostent(hp);
2692	hp = NULL;
2693	}
2694	#endif /* NETINET6 */
2695
2696	/* connection ok, put it into canonical form */
2697	mci->mci_out = NULL;
2698	if ((mci->mci_out = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
2699	(void *) &s,
2700	SM_IO_WRONLY, NULL)) == NULL \|\|
2701	(s = dup(s)) < 0 \|\|
2702	(mci->mci_in = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
2703	(void *) &s,
2704	SM_IO_RDONLY, NULL)) == NULL)
2705	{
2706	save_errno = errno;
2707	syserr("cannot open SMTP client channel, fd=%d", s);
2708	mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
2709	if (mci->mci_out != NULL)
2710	(void) sm_io_close(mci->mci_out, SM_TIME_DEFAULT);
2711	(void) close(s);
2712	errno = save_errno;
2713	return EX_TEMPFAIL;
2714	}
2715	sm_io_automode(mci->mci_out, mci->mci_in);
2716
2717	/* set {client_flags} */
2718	if (ClientSettings[addr.sa.sa_family].d_mflags != NULL)
2719	{
2720	macdefine(&mci->mci_macro, A_PERM,
2721	macid("{client_flags}"),
2722	ClientSettings[addr.sa.sa_family].d_mflags);
2723	}
2724	else
2725	macdefine(&mci->mci_macro, A_PERM,
2726	macid("{client_flags}"), "");
2727
2728	/* "add" {client_flags} to bitmap */
2729	if (bitnset(D_IFNHELO, ClientSettings[addr.sa.sa_family].d_flags))
2730	{
2731	/* look for just this one flag */
2732	setbitn(D_IFNHELO, d_flags);
2733	}
2734
2735	/* find out name for Interface through which we connect */
2736	len = sizeof addr;
2737	if (getsockname(s, &addr.sa, &len) == 0)
2738	{
2739	char *name;
2740	char family[5];
2741
2742	macdefine(&BlankEnvelope.e_macro, A_TEMP,
2743	macid("{if_addr_out}"), anynet_ntoa(&addr));
2744	(void) sm_snprintf(family, sizeof(family), "%d",
2745	addr.sa.sa_family);
2746	macdefine(&BlankEnvelope.e_macro, A_TEMP,
2747	macid("{if_family_out}"), family);
2748
2749	name = hostnamebyanyaddr(&addr);
2750	macdefine(&BlankEnvelope.e_macro, A_TEMP,
2751	macid("{if_name_out}"), name);
2752	if (LogLevel > 11)
2753	{
2754	/* log connection information */
2755	sm_syslog(LOG_INFO, e->e_id,
2756	"SMTP outgoing connect on %.40s", name);
2757	}
2758	if (bitnset(D_IFNHELO, d_flags))
2759	{
2760	if (name[0] != '[' && strchr(name, '.') != NULL)
2761	mci->mci_heloname = newstr(name);
2762	}
2763	}
2764	else
2765	{
2766	macdefine(&BlankEnvelope.e_macro, A_PERM,
2767	macid("{if_name_out}"), NULL);
2768	macdefine(&BlankEnvelope.e_macro, A_PERM,
2769	macid("{if_addr_out}"), NULL);
2770	macdefine(&BlankEnvelope.e_macro, A_PERM,
2771	macid("{if_family_out}"), NULL);
2772	}
2773	mci_setstat(mci, EX_OK, NULL, NULL);
2774	return EX_OK;
2775	}
2776
2777	static void
2778	connecttimeout()
2779	{
2780	/*
2781	** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
2782	** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
2783	** DOING.
2784	*/
2785
2786	errno = ETIMEDOUT;
2787	longjmp(CtxConnectTimeout, 1);
2788	}
2789	/*
2790	** MAKECONNECTION_DS -- make a connection to a domain socket.
2791	**
2792	** Parameters:
2793	** mux_path -- the path of the socket to connect to.
2794	** mci -- a pointer to the mail connection information
2795	** structure to be filled in.
2796	**
2797	** Returns:
2798	** An exit code telling whether the connection could be
2799	** made and if not why not.
2800	**
2801	** Side Effects:
2802	** none.
2803	*/
2804
2805	#if NETUNIX
2806	int
2807	makeconnection_ds(mux_path, mci)
2808	char *mux_path;
2809	register MCI *mci;
2810	{
2811	int sock;
2812	int rval, save_errno;
2813	long sff = SFF_SAFEDIRPATH\|SFF_OPENASROOT\|SFF_NOLINK\|SFF_ROOTOK\|SFF_EXECOK;
2814	struct sockaddr_un unix_addr;
2815
2816	/* if not safe, don't connect */
2817	rval = safefile(mux_path, RunAsUid, RunAsGid, RunAsUserName,
2818	sff, S_IRUSR\|S_IWUSR, NULL);
2819
2820	if (rval != 0)
2821	{
2822	syserr("makeconnection_ds: unsafe domain socket");
2823	mci_setstat(mci, EX_TEMPFAIL, "4.3.5", NULL);
2824	errno = rval;
2825	return EX_TEMPFAIL;
2826	}
2827
2828	/* prepare address structure */
2829	memset(&unix_addr, '\0', sizeof unix_addr);
2830	unix_addr.sun_family = AF_UNIX;
2831
2832	if (strlen(mux_path) >= sizeof unix_addr.sun_path)
2833	{
2834	syserr("makeconnection_ds: domain socket name too long");
2835
2836	/* XXX why TEMPFAIL but 5.x.y ? */
2837	mci_setstat(mci, EX_TEMPFAIL, "5.3.5", NULL);
2838	errno = ENAMETOOLONG;
2839	return EX_UNAVAILABLE;
2840	}
2841	(void) sm_strlcpy(unix_addr.sun_path, mux_path,
2842	sizeof unix_addr.sun_path);
2843
2844	/* initialize domain socket */
2845	sock = socket(AF_UNIX, SOCK_STREAM, 0);
2846	if (sock == -1)
2847	{
2848	save_errno = errno;
2849	syserr("makeconnection_ds: could not create domain socket");
2850	mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
2851	errno = save_errno;
2852	return EX_TEMPFAIL;
2853	}
2854
2855	/* connect to server */
2856	if (connect(sock, (struct sockaddr *) &unix_addr,
2857	sizeof(unix_addr)) == -1)
2858	{
2859	save_errno = errno;
2860	syserr("Could not connect to socket %s", mux_path);
2861	mci_setstat(mci, EX_TEMPFAIL, "4.4.1", NULL);
2862	(void) close(sock);
2863	errno = save_errno;
2864	return EX_TEMPFAIL;
2865	}
2866
2867	/* connection ok, put it into canonical form */
2868	mci->mci_out = NULL;
2869	if ((mci->mci_out = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
2870	(void *) &sock, SM_IO_WRONLY, NULL))
2871	== NULL
2872	\|\| (sock = dup(sock)) < 0 \|\|
2873	(mci->mci_in = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
2874	(void *) &sock, SM_IO_RDONLY, NULL))
2875	== NULL)
2876	{
2877	save_errno = errno;
2878	syserr("cannot open SMTP client channel, fd=%d", sock);
2879	mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
2880	if (mci->mci_out != NULL)
2881	(void) sm_io_close(mci->mci_out, SM_TIME_DEFAULT);
2882	(void) close(sock);
2883	errno = save_errno;
2884	return EX_TEMPFAIL;
2885	}
2886	sm_io_automode(mci->mci_out, mci->mci_in);
2887
2888	mci_setstat(mci, EX_OK, NULL, NULL);
2889	errno = 0;
2890	return EX_OK;
2891	}
2892	#endif /* NETUNIX */
2893	/*
2894	** SHUTDOWN_DAEMON -- Performs a clean shutdown of the daemon
2895	**
2896	** Parameters:
2897	** none.
2898	**
2899	** Returns:
2900	** none.
2901	**
2902	** Side Effects:
2903	** closes control socket, exits.
2904	*/
2905
2906	void
2907	shutdown_daemon()
2908	{
2909	int i;
2910	char *reason;
2911
2912	sm_allsignals(true);
2913
2914	reason = ShutdownRequest;
2915	ShutdownRequest = NULL;
2916	PendingSignal = 0;
2917
2918	if (LogLevel > 79)
2919	sm_syslog(LOG_DEBUG, CurEnv->e_id, "interrupt (%s)",
2920	reason == NULL ? "implicit call" : reason);
2921
2922	FileName = NULL;
2923	closecontrolsocket(true);
2924	#if XLA
2925	xla_all_end();
2926	#endif /* XLA */
2927
2928	for (i = 0; i < NDaemons; i++)
2929	{
2930	if (Daemons[i].d_socket >= 0)
2931	{
2932	(void) close(Daemons[i].d_socket);
2933	Daemons[i].d_socket = -1;
2934
2935	#if _FFR_DAEMON_NETUNIX
2936	# if NETUNIX
2937	/* Remove named sockets */
2938	if (Daemons[i].d_addr.sa.sa_family == AF_UNIX)
2939	{
2940	int rval;
2941	long sff = SFF_SAFEDIRPATH\|SFF_OPENASROOT\|SFF_NOLINK\|SFF_MUSTOWN\|SFF_EXECOK\|SFF_CREAT;
2942
2943	/* if not safe, don't use it */
2944	rval = safefile(Daemons[i].d_addr.sunix.sun_path,
2945	RunAsUid, RunAsGid,
2946	RunAsUserName, sff,
2947	S_IRUSR\|S_IWUSR, NULL);
2948	if (rval == 0 &&
2949	unlink(Daemons[i].d_addr.sunix.sun_path) < 0)
2950	{
2951	sm_syslog(LOG_WARNING, NOQID,
2952	"Could not remove daemon %s socket: %s: %s",
2953	Daemons[i].d_name,
2954	Daemons[i].d_addr.sunix.sun_path,
2955	sm_errstring(errno));
2956	}
2957	}
2958	# endif /* NETUNIX */
2959	#endif /* _FFR_DAEMON_NETUNIX */
2960	}
2961	}
2962
2963	finis(false, true, EX_OK);
2964	}
2965	/*
2966	** RESTART_DAEMON -- Performs a clean restart of the daemon
2967	**
2968	** Parameters:
2969	** none.
2970	**
2971	** Returns:
2972	** none.
2973	**
2974	** Side Effects:
2975	** restarts the daemon or exits if restart fails.
2976	*/
2977
2978	/* Make a non-DFL/IGN signal a noop */
2979	#define SM_NOOP_SIGNAL(sig, old) \
2980	do \
2981	{ \
2982	(old) = sm_signal((sig), sm_signal_noop); \
2983	if ((old) == SIG_IGN \|\| (old) == SIG_DFL) \
2984	(void) sm_signal((sig), (old)); \
2985	} while (0)
2986
2987	void
2988	restart_daemon()
2989	{
2990	bool drop;
2991	int i;
2992	int save_errno;
2993	char *reason;
2994	sigfunc_t ignore, oalrm, ousr1;
2995	extern int DtableSize;
2996
2997	/* clear the events to turn off SIGALRMs */
2998	sm_clear_events();
2999	sm_allsignals(true);
3000
3001	reason = RestartRequest;
3002	RestartRequest = NULL;
3003	PendingSignal = 0;
3004
3005	if (SaveArgv[0][0] != '/')
3006	{
3007	if (LogLevel > 3)
3008	sm_syslog(LOG_INFO, NOQID,
3009	"could not restart: need full path");
3010	finis(false, true, EX_OSFILE);
3011	/* NOTREACHED */
3012	}
3013	if (LogLevel > 3)
3014	sm_syslog(LOG_INFO, NOQID, "restarting %s due to %s",
3015	SaveArgv[0],
3016	reason == NULL ? "implicit call" : reason);
3017
3018	closecontrolsocket(true);
3019	#if SM_CONF_SHM
3020	cleanup_shm(DaemonPid == getpid());
3021	#endif /* SM_CONF_SHM */
3022
3023	/*
3024	** Want to drop to the user who started the process in all cases
3025	** but when running as "smmsp" for the clientmqueue queue run
3026	** daemon. In that case, UseMSP will be true, RunAsUid should not
3027	** be root, and RealUid should be either 0 or RunAsUid.
3028	*/
3029
3030	drop = !(UseMSP && RunAsUid != 0 &&
3031	(RealUid == 0 \|\| RealUid == RunAsUid));
3032
3033	if (drop_privileges(drop) != EX_OK)
3034	{
3035	if (LogLevel > 0)
3036	sm_syslog(LOG_ALERT, NOQID,
3037	"could not drop privileges: %s",
3038	sm_errstring(errno));
3039	finis(false, true, EX_OSERR);
3040	/* NOTREACHED */
3041	}
3042
3043	/* arrange for all the files to be closed */
3044	for (i = 3; i < DtableSize; i++)
3045	{
3046	register int j;
3047
3048	if ((j = fcntl(i, F_GETFD, 0)) != -1)
3049	(void) fcntl(i, F_SETFD, j \| FD_CLOEXEC);
3050	}
3051
3052	/*
3053	** Need to allow signals before execve() to make them "harmless".
3054	** However, the default action can be "terminate", so it isn't
3055	** really harmless. Setting signals to IGN will cause them to be
3056	** ignored in the new process to, so that isn't a good alternative.
3057	*/
3058
3059	SM_NOOP_SIGNAL(SIGALRM, oalrm);
3060	SM_NOOP_SIGNAL(SIGCHLD, ignore);
3061	SM_NOOP_SIGNAL(SIGHUP, ignore);
3062	SM_NOOP_SIGNAL(SIGINT, ignore);
3063	SM_NOOP_SIGNAL(SIGPIPE, ignore);
3064	SM_NOOP_SIGNAL(SIGTERM, ignore);
3065	#ifdef SIGUSR1
3066	SM_NOOP_SIGNAL(SIGUSR1, ousr1);
3067	#endif /* SIGUSR1 */
3068
3069	/* Turn back on signals */
3070	sm_allsignals(false);
3071
3072	(void) execve(SaveArgv[0], (ARGV_T) SaveArgv, (ARGV_T) ExternalEnviron);
3073	save_errno = errno;
3074
3075	/* block signals again and restore needed signals */
3076	sm_allsignals(true);
3077
3078	/* For finis() events */
3079	(void) sm_signal(SIGALRM, oalrm);
3080
3081	#ifdef SIGUSR1
3082	/* For debugging finis() */
3083	(void) sm_signal(SIGUSR1, ousr1);
3084	#endif /* SIGUSR1 */
3085
3086	errno = save_errno;
3087	if (LogLevel > 0)
3088	sm_syslog(LOG_ALERT, NOQID, "could not exec %s: %s",
3089	SaveArgv[0], sm_errstring(errno));
3090	finis(false, true, EX_OSFILE);
3091	/* NOTREACHED */
3092	}
3093	/*
3094	** MYHOSTNAME -- return the name of this host.
3095	**
3096	** Parameters:
3097	** hostbuf -- a place to return the name of this host.
3098	** size -- the size of hostbuf.
3099	**
3100	** Returns:
3101	** A list of aliases for this host.
3102	**
3103	** Side Effects:
3104	** Adds numeric codes to $=w.
3105	*/
3106
3107	struct hostent *
3108	myhostname(hostbuf, size)
3109	char hostbuf[];
3110	int size;
3111	{
3112	register struct hostent *hp;
3113
3114	if (gethostname(hostbuf, size) < 0 \|\| hostbuf[0] == '\0')
3115	(void) sm_strlcpy(hostbuf, "localhost", size);
3116	hp = sm_gethostbyname(hostbuf, InetMode);
3117	#if NETINET && NETINET6
3118	if (hp == NULL && InetMode == AF_INET6)
3119	{
3120	/*
3121	** It's possible that this IPv6 enabled machine doesn't
3122	** actually have any IPv6 interfaces and, therefore, no
3123	** IPv6 addresses. Fall back to AF_INET.
3124	*/
3125
3126	hp = sm_gethostbyname(hostbuf, AF_INET);
3127	}
3128	#endif /* NETINET && NETINET6 */
3129	if (hp == NULL)
3130	return NULL;
3131	if (strchr(hp->h_name, '.') != NULL \|\| strchr(hostbuf, '.') == NULL)
3132	(void) cleanstrcpy(hostbuf, hp->h_name, size);
3133
3134	#if NETINFO
3135	if (strchr(hostbuf, '.') == NULL)
3136	{
3137	char *domainname;
3138
3139	domainname = ni_propval("/locations", NULL, "resolver",
3140	"domain", '\0');
3141	if (domainname != NULL &&
3142	strlen(domainname) + strlen(hostbuf) + 1 < size)
3143	(void) sm_strlcat2(hostbuf, ".", domainname, size);
3144	}
3145	#endif /* NETINFO */
3146
3147	/*
3148	** If there is still no dot in the name, try looking for a
3149	** dotted alias.
3150	*/
3151
3152	if (strchr(hostbuf, '.') == NULL)
3153	{
3154	char **ha;
3155
3156	for (ha = hp->h_aliases; ha != NULL && *ha != NULL; ha++)
3157	{
3158	if (strchr(*ha, '.') != NULL)
3159	{
3160	(void) cleanstrcpy(hostbuf, *ha, size - 1);
3161	hostbuf[size - 1] = '\0';
3162	break;
3163	}
3164	}
3165	}
3166
3167	/*
3168	** If _still_ no dot, wait for a while and try again -- it is
3169	** possible that some service is starting up. This can result
3170	** in excessive delays if the system is badly configured, but
3171	** there really isn't a way around that, particularly given that
3172	** the config file hasn't been read at this point.
3173	** All in all, a bit of a mess.
3174	*/
3175
3176	if (strchr(hostbuf, '.') == NULL &&
3177	!getcanonname(hostbuf, size, true, NULL))
3178	{
3179	sm_syslog(LOG_CRIT, NOQID,
3180	"My unqualified host name (%s) unknown; sleeping for retry",
3181	hostbuf);
3182	message("My unqualified host name (%s) unknown; sleeping for retry",
3183	hostbuf);
3184	(void) sleep(60);
3185	if (!getcanonname(hostbuf, size, true, NULL))
3186	{
3187	sm_syslog(LOG_ALERT, NOQID,
3188	"unable to qualify my own domain name (%s) -- using short name",
3189	hostbuf);
3190	message("WARNING: unable to qualify my own domain name (%s) -- using short name",
3191	hostbuf);
3192	}
3193	}
3194	return hp;
3195	}
3196	/*
3197	** ADDRCMP -- compare two host addresses
3198	**
3199	** Parameters:
3200	** hp -- hostent structure for the first address
3201	** ha -- actual first address
3202	** sa -- second address
3203	**
3204	** Returns:
3205	** 0 -- if ha and sa match
3206	** else -- they don't match
3207	*/
3208
3209	static int
3210	addrcmp(hp, ha, sa)
3211	struct hostent *hp;
3212	char *ha;
3213	SOCKADDR *sa;
3214	{
3215	#if NETINET6
3216	unsigned char *a;
3217	#endif /* NETINET6 */
3218
3219	switch (sa->sa.sa_family)
3220	{
3221	#if NETINET
3222	case AF_INET:
3223	if (hp->h_addrtype == AF_INET)
3224	return memcmp(ha, (char *) &sa->sin.sin_addr, INADDRSZ);
3225	break;
3226	#endif /* NETINET */
3227
3228	#if NETINET6
3229	case AF_INET6:
3230	a = (unsigned char *) &sa->sin6.sin6_addr;
3231
3232	/* Straight binary comparison */
3233	if (hp->h_addrtype == AF_INET6)
3234	return memcmp(ha, a, IN6ADDRSZ);
3235
3236	/* If IPv4-mapped IPv6 address, compare the IPv4 section */
3237	if (hp->h_addrtype == AF_INET &&
3238	IN6_IS_ADDR_V4MAPPED(&sa->sin6.sin6_addr))
3239	return memcmp(a + IN6ADDRSZ - INADDRSZ, ha, INADDRSZ);
3240	break;
3241	#endif /* NETINET6 */
3242	}
3243	return -1;
3244	}
3245	/*
3246	** GETAUTHINFO -- get the real host name associated with a file descriptor
3247	**
3248	** Uses RFC1413 protocol to try to get info from the other end.
3249	**
3250	** Parameters:
3251	** fd -- the descriptor
3252	** may_be_forged -- an outage that is set to true if the
3253	** forward lookup of RealHostName does not match
3254	** RealHostAddr; set to false if they do match.
3255	**
3256	** Returns:
3257	** The user@host information associated with this descriptor.
3258	*/
3259
3260	static jmp_buf CtxAuthTimeout;
3261
3262	static void
3263	authtimeout()
3264	{
3265	/*
3266	** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
3267	** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
3268	** DOING.
3269	*/
3270
3271	errno = ETIMEDOUT;
3272	longjmp(CtxAuthTimeout, 1);
3273	}
3274
3275	char *
3276	getauthinfo(fd, may_be_forged)
3277	int fd;
3278	bool *may_be_forged;
3279	{
3280	unsigned short SM_NONVOLATILE port = 0;
3281	SOCKADDR_LEN_T falen;
3282	register char *volatile p = NULL;
3283	SOCKADDR la;
3284	SOCKADDR_LEN_T lalen;
3285	#ifndef NO_GETSERVBYNAME
3286	register struct servent *sp;
3287	# if NETINET
3288	static unsigned short port4 = 0;
3289	# endif /* NETINET */
3290	# if NETINET6
3291	static unsigned short port6 = 0;
3292	# endif /* NETINET6 */
3293	#endif /* ! NO_GETSERVBYNAME */
3294	volatile int s;
3295	int i = 0;
3296	size_t len;
3297	SM_EVENT *ev;
3298	int nleft;
3299	struct hostent *hp;
3300	char *ostype = NULL;
3301	char **ha;
3302	char ibuf[MAXNAME + 1];
3303	static char hbuf[MAXNAME + MAXAUTHINFO + 11];
3304
3305	*may_be_forged = false;
3306	falen = sizeof RealHostAddr;
3307	if (isatty(fd) \|\| (i = getpeername(fd, &RealHostAddr.sa, &falen)) < 0 \|\|
3308	falen <= 0 \|\| RealHostAddr.sa.sa_family == 0)
3309	{
3310	if (i < 0)
3311	{
3312	/*
3313	** ENOTSOCK is OK: bail on anything else, but reset
3314	** errno in this case, so a mis-report doesn't
3315	** happen later.
3316	*/
3317
3318	if (errno != ENOTSOCK)
3319	return NULL;
3320	errno = 0;
3321	}
3322	(void) sm_strlcpyn(hbuf, sizeof hbuf, 2, RealUserName,
3323	"@localhost");
3324	if (tTd(9, 1))
3325	sm_dprintf("getauthinfo: %s\n", hbuf);
3326	return hbuf;
3327	}
3328
3329	if (RealHostName == NULL)
3330	{
3331	/* translate that to a host name */
3332	RealHostName = newstr(hostnamebyanyaddr(&RealHostAddr));
3333	if (strlen(RealHostName) > MAXNAME)
3334	RealHostName[MAXNAME] = '\0'; /* XXX - 1 ? */
3335	}
3336
3337	/* cross check RealHostName with forward DNS lookup */
3338	if (anynet_ntoa(&RealHostAddr)[0] != '[' &&
3339	RealHostName[0] != '[')
3340	{
3341	int family;
3342
3343	family = RealHostAddr.sa.sa_family;
3344	#if NETINET6 && NEEDSGETIPNODE
3345	/*
3346	** If RealHostAddr is an IPv6 connection with an
3347	** IPv4-mapped address, we need RealHostName's IPv4
3348	** address(es) for addrcmp() to compare against
3349	** RealHostAddr.
3350	**
3351	** Actually, we only need to do this for systems
3352	** which NEEDSGETIPNODE since the real getipnodebyname()
3353	** already does V4MAPPED address via the AI_V4MAPPEDCFG
3354	** flag. A better fix to this problem is to add this
3355	** functionality to our stub getipnodebyname().
3356	*/
3357
3358	if (family == AF_INET6 &&
3359	IN6_IS_ADDR_V4MAPPED(&RealHostAddr.sin6.sin6_addr))
3360	family = AF_INET;
3361	#endif /* NETINET6 && NEEDSGETIPNODE */
3362
3363	/* try to match the reverse against the forward lookup */
3364	hp = sm_gethostbyname(RealHostName, family);
3365	if (hp == NULL)
3366	*may_be_forged = true;
3367	else
3368	{
3369	for (ha = hp->h_addr_list; *ha != NULL; ha++)
3370	{
3371	if (addrcmp(hp, *ha, &RealHostAddr) == 0)
3372	break;
3373	}
3374	may_be_forged = ha == NULL;
3375	#if NETINET6
3376	freehostent(hp);
3377	hp = NULL;
3378	#endif /* NETINET6 */
3379	}
3380	}
3381
3382	if (TimeOuts.to_ident == 0)
3383	goto noident;
3384
3385	lalen = sizeof la;
3386	switch (RealHostAddr.sa.sa_family)
3387	{
3388	#if NETINET
3389	case AF_INET:
3390	if (getsockname(fd, &la.sa, &lalen) < 0 \|\|
3391	lalen <= 0 \|\|
3392	la.sa.sa_family != AF_INET)
3393	{
3394	/* no ident info */
3395	goto noident;
3396	}
3397	port = RealHostAddr.sin.sin_port;
3398
3399	/* create ident query */
3400	(void) sm_snprintf(ibuf, sizeof ibuf, "%d,%d\r\n",
3401	ntohs(RealHostAddr.sin.sin_port),
3402	ntohs(la.sin.sin_port));
3403
3404	/* create local address */
3405	la.sin.sin_port = 0;
3406
3407	/* create foreign address */
3408	# ifdef NO_GETSERVBYNAME
3409	RealHostAddr.sin.sin_port = htons(113);
3410	# else /* NO_GETSERVBYNAME */
3411
3412	/*
3413	** getservbyname() consumes about 5% of the time
3414	** when receiving a small message (almost all of the time
3415	** spent in this routine).
3416	** Hence we store the port in a static variable
3417	** to save this time.
3418	** The portnumber shouldn't change very often...
3419	** This code makes the assumption that the port number
3420	** is not 0.
3421	*/
3422
3423	if (port4 == 0)
3424	{
3425	sp = getservbyname("auth", "tcp");
3426	if (sp != NULL)
3427	port4 = sp->s_port;
3428	else
3429	port4 = htons(113);
3430	}
3431	RealHostAddr.sin.sin_port = port4;
3432	break;
3433	# endif /* NO_GETSERVBYNAME */
3434	#endif /* NETINET */
3435
3436	#if NETINET6
3437	case AF_INET6:
3438	if (getsockname(fd, &la.sa, &lalen) < 0 \|\|
3439	lalen <= 0 \|\|
3440	la.sa.sa_family != AF_INET6)
3441	{
3442	/* no ident info */
3443	goto noident;
3444	}
3445	port = RealHostAddr.sin6.sin6_port;
3446
3447	/* create ident query */
3448	(void) sm_snprintf(ibuf, sizeof ibuf, "%d,%d\r\n",
3449	ntohs(RealHostAddr.sin6.sin6_port),
3450	ntohs(la.sin6.sin6_port));
3451
3452	/* create local address */
3453	la.sin6.sin6_port = 0;
3454
3455	/* create foreign address */
3456	# ifdef NO_GETSERVBYNAME
3457	RealHostAddr.sin6.sin6_port = htons(113);
3458	# else /* NO_GETSERVBYNAME */
3459	if (port6 == 0)
3460	{
3461	sp = getservbyname("auth", "tcp");
3462	if (sp != NULL)
3463	port6 = sp->s_port;
3464	else
3465	port6 = htons(113);
3466	}
3467	RealHostAddr.sin6.sin6_port = port6;
3468	break;
3469	# endif /* NO_GETSERVBYNAME */
3470	#endif /* NETINET6 */
3471	default:
3472	/* no ident info */
3473	goto noident;
3474	}
3475
3476	s = -1;
3477	if (setjmp(CtxAuthTimeout) != 0)
3478	{
3479	if (s >= 0)
3480	(void) close(s);
3481	goto noident;
3482	}
3483
3484	/* put a timeout around the whole thing */
3485	ev = sm_setevent(TimeOuts.to_ident, authtimeout, 0);
3486
3487	/* connect to foreign IDENT server using same address as SMTP socket */
3488	s = socket(la.sa.sa_family, SOCK_STREAM, 0);
3489	if (s < 0)
3490	{
3491	sm_clrevent(ev);
3492	goto noident;
3493	}
3494	if (bind(s, &la.sa, lalen) < 0 \|\|
3495	connect(s, &RealHostAddr.sa, lalen) < 0)
3496	goto closeident;
3497
3498	if (tTd(9, 10))
3499	sm_dprintf("getauthinfo: sent %s", ibuf);
3500
3501	/* send query */
3502	if (write(s, ibuf, strlen(ibuf)) < 0)
3503	goto closeident;
3504
3505	/* get result */
3506	p = &ibuf[0];
3507	nleft = sizeof ibuf - 1;
3508	while ((i = read(s, p, nleft)) > 0)
3509	{
3510	p += i;
3511	nleft -= i;
3512	*p = '\0';
3513	if (strchr(ibuf, '\n') != NULL \|\| nleft <= 0)
3514	break;
3515	}
3516	(void) close(s);
3517	sm_clrevent(ev);
3518	if (i < 0 \|\| p == &ibuf[0])
3519	goto noident;
3520
3521	if (p >= &ibuf[2] && --p == '\n' && --p == '\r')
3522	p--;
3523	*++p = '\0';
3524
3525	if (tTd(9, 3))
3526	sm_dprintf("getauthinfo: got %s\n", ibuf);
3527
3528	/* parse result */
3529	p = strchr(ibuf, ':');
3530	if (p == NULL)
3531	{
3532	/* malformed response */
3533	goto noident;
3534	}
3535	while (isascii(++p) && isspace(p))
3536	continue;
3537	if (sm_strncasecmp(p, "userid", 6) != 0)
3538	{
3539	/* presumably an error string */
3540	goto noident;
3541	}
3542	p += 6;
3543	while (isascii(p) && isspace(p))
3544	p++;
3545	if (*p++ != ':')
3546	{
3547	/* either useridxx or malformed response */
3548	goto noident;
3549	}
3550
3551	/* p now points to the OSTYPE field */
3552	while (isascii(p) && isspace(p))
3553	p++;
3554	ostype = p;
3555	p = strchr(p, ':');
3556	if (p == NULL)
3557	{
3558	/* malformed response */
3559	goto noident;
3560	}
3561	else
3562	{
3563	char *charset;
3564
3565	*p = '\0';
3566	charset = strchr(ostype, ',');
3567	if (charset != NULL)
3568	*charset = '\0';
3569	}
3570
3571	/* 1413 says don't do this -- but it's broken otherwise */
3572	while (isascii(++p) && isspace(p))
3573	continue;
3574
3575	/* p now points to the authenticated name -- copy carefully */
3576	if (sm_strncasecmp(ostype, "other", 5) == 0 &&
3577	(ostype[5] == ' ' \|\| ostype[5] == '\0'))
3578	{
3579	(void) sm_strlcpy(hbuf, "IDENT:", sizeof hbuf);
3580	cleanstrcpy(&hbuf[6], p, MAXAUTHINFO);
3581	}
3582	else
3583	cleanstrcpy(hbuf, p, MAXAUTHINFO);
3584	len = strlen(hbuf);
3585	(void) sm_strlcpyn(&hbuf[len], sizeof hbuf - len, 2, "@",
3586	RealHostName == NULL ? "localhost" : RealHostName);
3587	goto postident;
3588
3589	closeident:
3590	(void) close(s);
3591	sm_clrevent(ev);
3592
3593	noident:
3594	/* put back the original incoming port */
3595	switch (RealHostAddr.sa.sa_family)
3596	{
3597	#if NETINET
3598	case AF_INET:
3599	if (port > 0)
3600	RealHostAddr.sin.sin_port = port;
3601	break;
3602	#endif /* NETINET */
3603
3604	#if NETINET6
3605	case AF_INET6:
3606	if (port > 0)
3607	RealHostAddr.sin6.sin6_port = port;
3608	break;
3609	#endif /* NETINET6 */
3610	}
3611
3612	if (RealHostName == NULL)
3613	{
3614	if (tTd(9, 1))
3615	sm_dprintf("getauthinfo: NULL\n");
3616	return NULL;
3617	}
3618	(void) sm_strlcpy(hbuf, RealHostName, sizeof hbuf);
3619
3620	postident:
3621	#if IP_SRCROUTE
3622	# ifndef GET_IPOPT_DST
3623	# define GET_IPOPT_DST(dst) (dst)
3624	# endif /* ! GET_IPOPT_DST */
3625	/*
3626	** Extract IP source routing information.
3627	**
3628	** Format of output for a connection from site a through b
3629	** through c to d:
3630	** loose: @site-c@site-b:site-a
3631	** strict: !@site-c@site-b:site-a
3632	**
3633	** o - pointer within ipopt_list structure.
3634	** q - pointer within ls/ss rr route data
3635	** p - pointer to hbuf
3636	*/
3637
3638	if (RealHostAddr.sa.sa_family == AF_INET)
3639	{
3640	SOCKOPT_LEN_T ipoptlen;
3641	int j;
3642	unsigned char *q;
3643	unsigned char *o;
3644	int l;
3645	struct IPOPTION ipopt;
3646
3647	ipoptlen = sizeof ipopt;
3648	if (getsockopt(fd, IPPROTO_IP, IP_OPTIONS,
3649	(char *) &ipopt, &ipoptlen) < 0)
3650	goto noipsr;
3651	if (ipoptlen == 0)
3652	goto noipsr;
3653	o = (unsigned char *) ipopt.IP_LIST;
3654	while (o != NULL && o < (unsigned char *) &ipopt + ipoptlen)
3655	{
3656	switch (*o)
3657	{
3658	case IPOPT_EOL:
3659	o = NULL;
3660	break;
3661
3662	case IPOPT_NOP:
3663	o++;
3664	break;
3665
3666	case IPOPT_SSRR:
3667	case IPOPT_LSRR:
3668	/*
3669	** Source routing.
3670	** o[0] is the option type (loose/strict).
3671	** o[1] is the length of this option,
3672	** including option type and
3673	** length.
3674	** o[2] is the pointer into the route
3675	** data.
3676	** o[3] begins the route data.
3677	*/
3678
3679	p = &hbuf[strlen(hbuf)];
3680	l = sizeof hbuf - (hbuf - p) - 6;
3681	(void) sm_snprintf(p, SPACELEFT(hbuf, p),
3682	" [%s@%.*s",
3683	*o == IPOPT_SSRR ? "!" : "",
3684	l > 240 ? 120 : l / 2,
3685	inet_ntoa(GET_IPOPT_DST(ipopt.IP_DST)));
3686	i = strlen(p);
3687	p += i;
3688	l -= strlen(p);
3689
3690	j = o[1] / sizeof(struct in_addr) - 1;
3691
3692	/* q skips length and router pointer to data */
3693	q = &o[3];
3694	for ( ; j >= 0; j--)
3695	{
3696	struct in_addr addr;
3697
3698	memcpy(&addr, q, sizeof(addr));
3699	(void) sm_snprintf(p,
3700	SPACELEFT(hbuf, p),
3701	"%c%.*s",
3702	j != 0 ? '@' : ':',
3703	l > 240 ? 120 :
3704	j == 0 ? l : l / 2,
3705	inet_ntoa(addr));
3706	i = strlen(p);
3707	p += i;
3708	l -= i + 1;
3709	q += sizeof(struct in_addr);
3710	}
3711	o += o[1];
3712	break;
3713
3714	default:
3715	/* Skip over option */
3716	o += o[1];
3717	break;
3718	}
3719	}
3720	(void) sm_snprintf(p, SPACELEFT(hbuf, p), "]");
3721	goto postipsr;
3722	}
3723
3724	noipsr:
3725	#endif /* IP_SRCROUTE */
3726	if (RealHostName != NULL && RealHostName[0] != '[')
3727	{
3728	p = &hbuf[strlen(hbuf)];
3729	(void) sm_snprintf(p, SPACELEFT(hbuf, p), " [%.100s]",
3730	anynet_ntoa(&RealHostAddr));
3731	}
3732	if (*may_be_forged)
3733	{
3734	p = &hbuf[strlen(hbuf)];
3735	(void) sm_strlcpy(p, " (may be forged)", SPACELEFT(hbuf, p));
3736	macdefine(&BlankEnvelope.e_macro, A_PERM,
3737	macid("{client_resolve}"), "FORGED");
3738	}
3739
3740	#if IP_SRCROUTE
3741	postipsr:
3742	#endif /* IP_SRCROUTE */
3743
3744	/* put back the original incoming port */
3745	switch (RealHostAddr.sa.sa_family)
3746	{
3747	#if NETINET
3748	case AF_INET:
3749	if (port > 0)
3750	RealHostAddr.sin.sin_port = port;
3751	break;
3752	#endif /* NETINET */
3753
3754	#if NETINET6
3755	case AF_INET6:
3756	if (port > 0)
3757	RealHostAddr.sin6.sin6_port = port;
3758	break;
3759	#endif /* NETINET6 */
3760	}
3761
3762	if (tTd(9, 1))
3763	sm_dprintf("getauthinfo: %s\n", hbuf);
3764	return hbuf;
3765	}
3766	/*
3767	** HOST_MAP_LOOKUP -- turn a hostname into canonical form
3768	**
3769	** Parameters:
3770	** map -- a pointer to this map.
3771	** name -- the (presumably unqualified) hostname.
3772	** av -- unused -- for compatibility with other mapping
3773	** functions.
3774	** statp -- an exit status (out parameter) -- set to
3775	** EX_TEMPFAIL if the name server is unavailable.
3776	**
3777	** Returns:
3778	** The mapping, if found.
3779	** NULL if no mapping found.
3780	**
3781	** Side Effects:
3782	** Looks up the host specified in hbuf. If it is not
3783	** the canonical name for that host, return the canonical
3784	** name (unless MF_MATCHONLY is set, which will cause the
3785	** status only to be returned).
3786	*/
3787
3788	char *
3789	host_map_lookup(map, name, av, statp)
3790	MAP *map;
3791	char *name;
3792	char **av;
3793	int *statp;
3794	{
3795	register struct hostent *hp;
3796	#if NETINET
3797	struct in_addr in_addr;
3798	#endif /* NETINET */
3799	#if NETINET6
3800	struct in6_addr in6_addr;
3801	#endif /* NETINET6 */
3802	char cp, ans = NULL;
3803	register STAB *s;
3804	time_t now;
3805	#if NAMED_BIND
3806	time_t SM_NONVOLATILE retrans = 0;
3807	int SM_NONVOLATILE retry = 0;
3808	#endif /* NAMED_BIND */
3809	char hbuf[MAXNAME + 1];
3810
3811	/*
3812	** See if we have already looked up this name. If so, just
3813	** return it (unless expired).
3814	*/
3815
3816	now = curtime();
3817	s = stab(name, ST_NAMECANON, ST_ENTER);
3818	if (bitset(NCF_VALID, s->s_namecanon.nc_flags) &&
3819	s->s_namecanon.nc_exp >= now)
3820	{
3821	if (tTd(9, 1))
3822	sm_dprintf("host_map_lookup(%s) => CACHE %s\n",
3823	name,
3824	s->s_namecanon.nc_cname == NULL
3825	? "NULL"
3826	: s->s_namecanon.nc_cname);
3827	errno = s->s_namecanon.nc_errno;
3828	SM_SET_H_ERRNO(s->s_namecanon.nc_herrno);
3829	*statp = s->s_namecanon.nc_stat;
3830	if (*statp == EX_TEMPFAIL)
3831	{
3832	CurEnv->e_status = "4.4.3";
3833	message("851 %s: Name server timeout",
3834	shortenstring(name, 33));
3835	}
3836	if (*statp != EX_OK)
3837	return NULL;
3838	if (s->s_namecanon.nc_cname == NULL)
3839	{
3840	syserr("host_map_lookup(%s): bogus NULL cache entry, errno = %d, h_errno = %d",
3841	name,
3842	s->s_namecanon.nc_errno,
3843	s->s_namecanon.nc_herrno);
3844	return NULL;
3845	}
3846	if (bitset(MF_MATCHONLY, map->map_mflags))
3847	cp = map_rewrite(map, name, strlen(name), NULL);
3848	else
3849	cp = map_rewrite(map,
3850	s->s_namecanon.nc_cname,
3851	strlen(s->s_namecanon.nc_cname),
3852	av);
3853	return cp;
3854	}
3855
3856	/*
3857	** If we are running without a regular network connection (usually
3858	** dial-on-demand) and we are just queueing, we want to avoid DNS
3859	** lookups because those could try to connect to a server.
3860	*/
3861
3862	if (CurEnv->e_sendmode == SM_DEFER &&
3863	bitset(MF_DEFER, map->map_mflags))
3864	{
3865	if (tTd(9, 1))
3866	sm_dprintf("host_map_lookup(%s) => DEFERRED\n", name);
3867	*statp = EX_TEMPFAIL;
3868	return NULL;
3869	}
3870
3871	/*
3872	** If first character is a bracket, then it is an address
3873	** lookup. Address is copied into a temporary buffer to
3874	** strip the brackets and to preserve name if address is
3875	** unknown.
3876	*/
3877
3878	if (tTd(9, 1))
3879	sm_dprintf("host_map_lookup(%s) => ", name);
3880	#if NAMED_BIND
3881	if (map->map_timeout > 0)
3882	{
3883	retrans = _res.retrans;
3884	_res.retrans = map->map_timeout;
3885	}
3886	if (map->map_retry > 0)
3887	{
3888	retry = _res.retry;
3889	_res.retry = map->map_retry;
3890	}
3891	#endif /* NAMED_BIND */
3892
3893	/* set default TTL */
3894	s->s_namecanon.nc_exp = now + SM_DEFAULT_TTL;
3895	if (*name != '[')
3896	{
3897	int ttl;
3898
3899	(void) sm_strlcpy(hbuf, name, sizeof hbuf);
3900	if (getcanonname(hbuf, sizeof hbuf - 1, !HasWildcardMX, &ttl))
3901	{
3902	ans = hbuf;
3903	if (ttl > 0)
3904	s->s_namecanon.nc_exp = now + SM_MIN(ttl,
3905	SM_DEFAULT_TTL);
3906	}
3907	}
3908	else
3909	{
3910	if ((cp = strchr(name, ']')) == NULL)
3911	{
3912	if (tTd(9, 1))
3913	sm_dprintf("FAILED\n");
3914	return NULL;
3915	}
3916	*cp = '\0';
3917
3918	hp = NULL;
3919	#if NETINET
3920	if ((in_addr.s_addr = inet_addr(&name[1])) != INADDR_NONE)
3921	hp = sm_gethostbyaddr((char *)&in_addr,
3922	INADDRSZ, AF_INET);
3923	#endif /* NETINET */
3924	#if NETINET6
3925	if (hp == NULL &&
3926	anynet_pton(AF_INET6, &name[1], &in6_addr) == 1)
3927	hp = sm_gethostbyaddr((char *)&in6_addr,
3928	IN6ADDRSZ, AF_INET6);
3929	#endif /* NETINET6 */
3930	*cp = ']';
3931
3932	if (hp != NULL)
3933	{
3934	/* found a match -- copy out */
3935	ans = denlstring((char *) hp->h_name, true, true);
3936	#if NETINET6
3937	if (ans == hp->h_name)
3938	{
3939	static char n[MAXNAME + 1];
3940
3941	/* hp->h_name is about to disappear */
3942	(void) sm_strlcpy(n, ans, sizeof n);
3943	ans = n;
3944	}
3945	freehostent(hp);
3946	hp = NULL;
3947	#endif /* NETINET6 */
3948	}
3949	}
3950	#if NAMED_BIND
3951	if (map->map_timeout > 0)
3952	_res.retrans = retrans;
3953	if (map->map_retry > 0)
3954	_res.retry = retry;
3955	#endif /* NAMED_BIND */
3956
3957	s->s_namecanon.nc_flags \|= NCF_VALID; /* will be soon */
3958
3959	/* Found an answer */
3960	if (ans != NULL)
3961	{
3962	s->s_namecanon.nc_stat = *statp = EX_OK;
3963	if (s->s_namecanon.nc_cname != NULL)
3964	sm_free(s->s_namecanon.nc_cname);
3965	s->s_namecanon.nc_cname = sm_strdup_x(ans);
3966	if (bitset(MF_MATCHONLY, map->map_mflags))
3967	cp = map_rewrite(map, name, strlen(name), NULL);
3968	else
3969	cp = map_rewrite(map, ans, strlen(ans), av);
3970	if (tTd(9, 1))
3971	sm_dprintf("FOUND %s\n", ans);
3972	return cp;
3973	}
3974
3975
3976	/* No match found */
3977	s->s_namecanon.nc_errno = errno;
3978	#if NAMED_BIND
3979	s->s_namecanon.nc_herrno = h_errno;
3980	if (tTd(9, 1))
3981	sm_dprintf("FAIL (%d)\n", h_errno);
3982	switch (h_errno)
3983	{
3984	case TRY_AGAIN:
3985	if (UseNameServer)
3986	{
3987	CurEnv->e_status = "4.4.3";
3988	message("851 %s: Name server timeout",
3989	shortenstring(name, 33));
3990	}
3991	*statp = EX_TEMPFAIL;
3992	break;
3993
3994	case HOST_NOT_FOUND:
3995	case NO_DATA:
3996	*statp = EX_NOHOST;
3997	break;
3998
3999	case NO_RECOVERY:
4000	*statp = EX_SOFTWARE;
4001	break;
4002
4003	default:
4004	*statp = EX_UNAVAILABLE;
4005	break;
4006	}
4007	#else /* NAMED_BIND */
4008	if (tTd(9, 1))
4009	sm_dprintf("FAIL\n");
4010	*statp = EX_NOHOST;
4011	#endif /* NAMED_BIND */
4012	s->s_namecanon.nc_stat = *statp;
4013	return NULL;
4014	}
4015	/*
4016	** HOST_MAP_INIT -- initialize host class structures
4017	**
4018	** Parameters:
4019	** map -- a pointer to this map.
4020	** args -- argument string.
4021	**
4022	** Returns:
4023	** true.
4024	*/
4025
4026	bool
4027	host_map_init(map, args)
4028	MAP *map;
4029	char *args;
4030	{
4031	register char *p = args;
4032
4033	for (;;)
4034	{
4035	while (isascii(p) && isspace(p))
4036	p++;
4037	if (*p != '-')
4038	break;
4039	switch (*++p)
4040	{
4041	case 'a':
4042	map->map_app = ++p;
4043	break;
4044
4045	case 'T':
4046	map->map_tapp = ++p;
4047	break;
4048
4049	case 'm':
4050	map->map_mflags \|= MF_MATCHONLY;
4051	break;
4052
4053	case 't':
4054	map->map_mflags \|= MF_NODEFER;
4055	break;
4056
4057	case 'S': /* only for consistency */
4058	map->map_spacesub = *++p;
4059	break;
4060
4061	case 'D':
4062	map->map_mflags \|= MF_DEFER;
4063	break;
4064
4065	case 'd':
4066	{
4067	char *h;
4068
4069	while (isascii(++p) && isspace(p))
4070	continue;
4071	h = strchr(p, ' ');
4072	if (h != NULL)
4073	*h = '\0';
4074	map->map_timeout = convtime(p, 's');
4075	if (h != NULL)
4076	*h = ' ';
4077	}
4078	break;
4079
4080	case 'r':
4081	while (isascii(++p) && isspace(p))
4082	continue;
4083	map->map_retry = atoi(p);
4084	break;
4085	}
4086	while (p != '\0' && !(isascii(p) && isspace(*p)))
4087	p++;
4088	if (*p != '\0')
4089	*p++ = '\0';
4090	}
4091	if (map->map_app != NULL)
4092	map->map_app = newstr(map->map_app);
4093	if (map->map_tapp != NULL)
4094	map->map_tapp = newstr(map->map_tapp);
4095	return true;
4096	}
4097
4098	#if NETINET6
4099	/*
4100	** ANYNET_NTOP -- convert an IPv6 network address to printable form.
4101	**
4102	** Parameters:
4103	** s6a -- a pointer to an in6_addr structure.
4104	** dst -- buffer to store result in
4105	** dst_len -- size of dst buffer
4106	**
4107	** Returns:
4108	** A printable version of that structure.
4109	*/
4110
4111	char *
4112	anynet_ntop(s6a, dst, dst_len)
4113	struct in6_addr *s6a;
4114	char *dst;
4115	size_t dst_len;
4116	{
4117	register char *ap;
4118
4119	if (IN6_IS_ADDR_V4MAPPED(s6a))
4120	ap = (char *) inet_ntop(AF_INET,
4121	&s6a->s6_addr[IN6ADDRSZ - INADDRSZ],
4122	dst, dst_len);
4123	else
4124	{
4125	char *d;
4126	size_t sz;
4127
4128	/* Save pointer to beginning of string */
4129	d = dst;
4130
4131	/* Add IPv6: protocol tag */
4132	sz = sm_strlcpy(dst, "IPv6:", dst_len);
4133	if (sz >= dst_len)
4134	return NULL;
4135	dst += sz;
4136	dst_len -= sz;
4137	ap = (char *) inet_ntop(AF_INET6, s6a, dst, dst_len);
4138
4139	/* Restore pointer to beginning of string */
4140	if (ap != NULL)
4141	ap = d;
4142	}
4143	return ap;
4144	}
4145
4146	/*
4147	** ANYNET_PTON -- convert printed form to network address.
4148	**
4149	** Wrapper for inet_pton() which handles IPv6: labels.
4150	**
4151	** Parameters:
4152	** family -- address family
4153	** src -- string
4154	** dst -- destination address structure
4155	**
4156	** Returns:
4157	** 1 if the address was valid
4158	** 0 if the address wasn't parseable
4159	** -1 if error
4160	*/
4161
4162	int
4163	anynet_pton(family, src, dst)
4164	int family;
4165	const char *src;
4166	void *dst;
4167	{
4168	if (family == AF_INET6 && sm_strncasecmp(src, "IPv6:", 5) == 0)
4169	src += 5;
4170	return inet_pton(family, src, dst);
4171	}
4172	#endif /* NETINET6 */
4173	/*
4174	** ANYNET_NTOA -- convert a network address to printable form.
4175	**
4176	** Parameters:
4177	** sap -- a pointer to a sockaddr structure.
4178	**
4179	** Returns:
4180	** A printable version of that sockaddr.
4181	*/
4182
4183	#ifdef USE_SOCK_STREAM
4184
4185	# if NETLINK
4186	# include <net/if_dl.h>
4187	# endif /* NETLINK */
4188
4189	char *
4190	anynet_ntoa(sap)
4191	register SOCKADDR *sap;
4192	{
4193	register char *bp;
4194	register char *ap;
4195	int l;
4196	static char buf[100];
4197
4198	/* check for null/zero family */
4199	if (sap == NULL)
4200	return "NULLADDR";
4201	if (sap->sa.sa_family == 0)
4202	return "0";
4203
4204	switch (sap->sa.sa_family)
4205	{
4206	# if NETUNIX
4207	case AF_UNIX:
4208	if (sap->sunix.sun_path[0] != '\0')
4209	(void) sm_snprintf(buf, sizeof buf, "[UNIX: %.64s]",
4210	sap->sunix.sun_path);
4211	else
4212	(void) sm_strlcpy(buf, "[UNIX: localhost]", sizeof buf);
4213	return buf;
4214	# endif /* NETUNIX */
4215
4216	# if NETINET
4217	case AF_INET:
4218	return (char *) inet_ntoa(sap->sin.sin_addr);
4219	# endif /* NETINET */
4220
4221	# if NETINET6
4222	case AF_INET6:
4223	ap = anynet_ntop(&sap->sin6.sin6_addr, buf, sizeof buf);
4224	if (ap != NULL)
4225	return ap;
4226	break;
4227	# endif /* NETINET6 */
4228
4229	# if NETLINK
4230	case AF_LINK:
4231	(void) sm_snprintf(buf, sizeof buf, "[LINK: %s]",
4232	link_ntoa((struct sockaddr_dl *) &sap->sa));
4233	return buf;
4234	# endif /* NETLINK */
4235	default:
4236	/* this case is needed when nothing is #defined */
4237	/* in order to keep the switch syntactically correct */
4238	break;
4239	}
4240
4241	/* unknown family -- just dump bytes */
4242	(void) sm_snprintf(buf, sizeof buf, "Family %d: ", sap->sa.sa_family);
4243	bp = &buf[strlen(buf)];
4244	ap = sap->sa.sa_data;
4245	for (l = sizeof sap->sa.sa_data; --l >= 0; )
4246	{
4247	(void) sm_snprintf(bp, SPACELEFT(buf, bp), "%02x:",
4248	*ap++ & 0377);
4249	bp += 3;
4250	}
4251	*--bp = '\0';
4252	return buf;
4253	}
4254	/*
4255	** HOSTNAMEBYANYADDR -- return name of host based on address
4256	**
4257	** Parameters:
4258	** sap -- SOCKADDR pointer
4259	**
4260	** Returns:
4261	** text representation of host name.
4262	**
4263	** Side Effects:
4264	** none.
4265	*/
4266
4267	char *
4268	hostnamebyanyaddr(sap)
4269	register SOCKADDR *sap;
4270	{
4271	register struct hostent *hp;
4272	# if NAMED_BIND
4273	int saveretry;
4274	# endif /* NAMED_BIND */
4275	# if NETINET6
4276	struct in6_addr in6_addr;
4277	# endif /* NETINET6 */
4278
4279	# if NAMED_BIND
4280	/* shorten name server timeout to avoid higher level timeouts */
4281	saveretry = _res.retry;
4282	if (_res.retry * _res.retrans > 20)
4283	_res.retry = 20 / _res.retrans;
4284	# endif /* NAMED_BIND */
4285
4286	switch (sap->sa.sa_family)
4287	{
4288	# if NETINET
4289	case AF_INET:
4290	hp = sm_gethostbyaddr((char *) &sap->sin.sin_addr,
4291	INADDRSZ, AF_INET);
4292	break;
4293	# endif /* NETINET */
4294
4295	# if NETINET6
4296	case AF_INET6:
4297	hp = sm_gethostbyaddr((char *) &sap->sin6.sin6_addr,
4298	IN6ADDRSZ, AF_INET6);
4299	break;
4300	# endif /* NETINET6 */
4301
4302	# if NETISO
4303	case AF_ISO:
4304	hp = sm_gethostbyaddr((char *) &sap->siso.siso_addr,
4305	sizeof sap->siso.siso_addr, AF_ISO);
4306	break;
4307	# endif /* NETISO */
4308
4309	# if NETUNIX
4310	case AF_UNIX:
4311	hp = NULL;
4312	break;
4313	# endif /* NETUNIX */
4314
4315	default:
4316	hp = sm_gethostbyaddr(sap->sa.sa_data, sizeof sap->sa.sa_data,
4317	sap->sa.sa_family);
4318	break;
4319	}
4320
4321	# if NAMED_BIND
4322	_res.retry = saveretry;
4323	# endif /* NAMED_BIND */
4324
4325	# if NETINET \|\| NETINET6
4326	if (hp != NULL && hp->h_name[0] != '['
4327	# if NETINET6
4328	&& inet_pton(AF_INET6, hp->h_name, &in6_addr) != 1
4329	# endif /* NETINET6 */
4330	# if NETINET
4331	&& inet_addr(hp->h_name) == INADDR_NONE
4332	# endif /* NETINET */
4333	)
4334	{
4335	char *name;
4336
4337	name = denlstring((char *) hp->h_name, true, true);
4338	# if NETINET6
4339	if (name == hp->h_name)
4340	{
4341	static char n[MAXNAME + 1];
4342
4343	/* Copy the string, hp->h_name is about to disappear */
4344	(void) sm_strlcpy(n, name, sizeof n);
4345	name = n;
4346	}
4347	freehostent(hp);
4348	# endif /* NETINET6 */
4349	return name;
4350	}
4351	# endif /* NETINET \|\| NETINET6 */
4352
4353	# if NETINET6
4354	if (hp != NULL)
4355	{
4356	freehostent(hp);
4357	hp = NULL;
4358	}
4359	# endif /* NETINET6 */
4360
4361	# if NETUNIX
4362	if (sap->sa.sa_family == AF_UNIX && sap->sunix.sun_path[0] == '\0')
4363	return "localhost";
4364	# endif /* NETUNIX */
4365	{
4366	static char buf[203];
4367
4368	(void) sm_snprintf(buf, sizeof buf, "[%.200s]",
4369	anynet_ntoa(sap));
4370	return buf;
4371	}
4372	}
4373	#endif /* USE_SOCK_STREAM */

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/third/sendmail/sendmail/daemon.c @ 19204

Download in other formats: