2 * Copyright (c) 1998-2007, 2009, 2010 Sendmail, Inc. and its suppliers.
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.
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.
17 SM_RCSID("@(#)$Id: daemon.c,v 8.691 2011/01/25 18:31:30 ca Exp $")
19 #if defined(SOCK_STREAM) || defined(__GNU_LIBRARY__)
20 # define USE_SOCK_STREAM 1
21 #endif /* defined(SOCK_STREAM) || defined(__GNU_LIBRARY__) */
23 #if defined(USE_SOCK_STREAM)
24 # if NETINET || NETINET6
25 # include <arpa/inet.h>
26 # endif /* NETINET || NETINET6 */
29 # define NO_DATA NO_ADDRESS
30 # endif /* ! NO_DATA */
31 # endif /* NAMED_BIND */
32 #endif /* defined(USE_SOCK_STREAM) */
35 # include <openssl/rand.h>
40 #if IP_SRCROUTE && NETINET
41 # include <netinet/in_systm.h>
42 # include <netinet/ip.h>
44 # include <netinet/in.h>
46 # define IPOPTION ip_opts
47 # define IP_LIST ip_opts
48 # define IP_DST ip_dst
49 # endif /* ! IPOPTION */
51 # include <netinet/ip_var.h>
53 # define IPOPTION ipoption
54 # define IP_LIST ipopt_list
55 # define IP_DST ipopt_dst
56 # endif /* ! IPOPTION */
57 # endif /* HAS_IN_H */
58 #endif /* IP_SRCROUTE && NETINET */
65 static void connecttimeout __P((int));
66 static int opendaemonsocket __P((DAEMON_T *, bool));
67 static unsigned short setupdaemon __P((SOCKADDR *));
68 static void getrequests_checkdiskspace __P((ENVELOPE *e));
69 static void setsockaddroptions __P((char *, DAEMON_T *));
70 static void printdaemonflags __P((DAEMON_T *));
71 static int addr_family __P((char *));
72 static int addrcmp __P((struct hostent *, char *, SOCKADDR *));
73 static void authtimeout __P((int));
76 ** DAEMON.C -- routines to use when running as a daemon.
78 ** This entire file is highly dependent on the 4.2 BSD
79 ** interprocess communication primitives. No attempt has
80 ** been made to make this file portable to Version 7,
81 ** Version 6, MPX files, etc. If you should try such a
82 ** thing yourself, I recommend chucking the entire file
83 ** and starting from scratch. Basic semantics are:
86 ** Opens a port and initiates a connection.
87 ** Returns in a child. Must set InChannel and
88 ** OutChannel appropriately.
90 ** Close any open files associated with getting
91 ** the connection; this is used when running the queue,
92 ** etc., to avoid having extra file descriptors during
93 ** the queue run and to avoid confusing the network
94 ** code (if it cares).
95 ** makeconnection(host, port, mci, e, enough)
96 ** Make a connection to the named host on the given
97 ** port. Returns zero on success, else an exit status
98 ** describing the error.
99 ** host_map_lookup(map, hbuf, avp, pstat)
100 ** Convert the entry in hbuf into a canonical form.
103 static int NDaemons = 0; /* actual number of daemons */
105 static time_t NextDiskSpaceCheck = 0;
108 ** GETREQUESTS -- open mail IPC port and get requests.
111 ** e -- the current envelope.
117 ** Waits until some interesting activity occurs. When
118 ** it does, a child is created to process it, and the
119 ** parent waits for completion. Return from this
120 ** routine is always in the child. The file pointers
121 ** "InChannel" and "OutChannel" should be set to point
122 ** to the communication channel.
123 ** May restart persistent queue runners if they have ended
132 int idx, curdaemon = -1;
133 int i, olddaemon = 0;
137 char status[MAXLINE];
139 SOCKADDR_LEN_T len = sizeof(sa);
140 #if _FFR_QUEUE_RUN_PARANOIA
142 #endif /* _FFR_QUEUE_RUN_PARANOIA */
144 extern int ControlSocket;
145 # endif /* NETUNIX */
146 extern ENVELOPE BlankEnvelope;
149 /* initialize data for function that generates queue ids */
151 for (idx = 0; idx < NDaemons; idx++)
153 Daemons[idx].d_port = setupdaemon(&(Daemons[idx].d_addr));
154 Daemons[idx].d_firsttime = true;
155 Daemons[idx].d_refuse_connections_until = (time_t) 0;
159 ** Try to actually open the connection.
164 for (idx = 0; idx < NDaemons; idx++)
166 sm_dprintf("getrequests: daemon %s: port %d\n",
168 ntohs(Daemons[idx].d_port));
172 /* get a socket for the SMTP connection */
173 for (idx = 0; idx < NDaemons; idx++)
174 Daemons[idx].d_socksize = opendaemonsocket(&Daemons[idx], true);
176 if (opencontrolsocket() < 0)
177 sm_syslog(LOG_WARNING, NOQID,
178 "daemon could not open control socket %s: %s",
179 ControlSocketName, sm_errstring(errno));
181 /* If there are any queue runners released reapchild() co-ord's */
182 (void) sm_signal(SIGCHLD, reapchild);
184 /* write the pid to file, command line args to syslog */
189 char jbuf[MAXHOSTNAMELEN];
191 expand("\201j", jbuf, sizeof(jbuf), e);
192 j_has_dot = strchr(jbuf, '.') != NULL;
196 /* Add parent process as first item */
197 proc_list_add(CurrentPid, "Sendmail daemon", PROC_DAEMON, 0, -1, NULL);
201 for (idx = 0; idx < NDaemons; idx++)
202 sm_dprintf("getrequests: daemon %s: socket %d\n",
204 Daemons[idx].d_socket);
210 auto SOCKADDR_LEN_T lotherend;
211 bool timedout = false;
212 bool control = false;
218 #endif /* STARTTLS */
220 /* see if we are rejecting connections */
221 (void) sm_blocksignal(SIGALRM);
224 for (idx = 0; idx < NDaemons; idx++)
227 ** XXX do this call outside the loop?
228 ** no: refuse_connections may sleep().
232 if (now < Daemons[idx].d_refuse_connections_until)
234 if (bitnset(D_DISABLE, Daemons[idx].d_flags))
236 if (refuseconnections(e, idx, curdaemon == idx))
238 if (Daemons[idx].d_socket >= 0)
240 /* close socket so peer fails quickly */
241 (void) close(Daemons[idx].d_socket);
242 Daemons[idx].d_socket = -1;
245 /* refuse connections for next 15 seconds */
246 Daemons[idx].d_refuse_connections_until = now + 15;
248 else if (Daemons[idx].d_socket < 0 ||
249 Daemons[idx].d_firsttime)
251 if (!Daemons[idx].d_firsttime && LogLevel > 8)
252 sm_syslog(LOG_INFO, NOQID,
253 "accepting connections again for daemon %s",
254 Daemons[idx].d_name);
256 /* arrange to (re)open the socket if needed */
257 (void) opendaemonsocket(&Daemons[idx], false);
258 Daemons[idx].d_firsttime = false;
262 /* May have been sleeping above, check again */
265 getrequests_checkdiskspace(e);
268 /* check for disaster */
270 char jbuf[MAXHOSTNAMELEN];
272 expand("\201j", jbuf, sizeof(jbuf), e);
273 if (!wordinclass(jbuf, 'w'))
275 dumpstate("daemon lost $j");
276 sm_syslog(LOG_ALERT, NOQID,
277 "daemon process doesn't have $j in $=w; see syslog");
280 else if (j_has_dot && strchr(jbuf, '.') == NULL)
282 dumpstate("daemon $j lost dot");
283 sm_syslog(LOG_ALERT, NOQID,
284 "daemon process $j lost dot; see syslog");
292 ** Andrew Sun <asun@ieps-sun.ml.com> claims that this will
293 ** fix the SVr4 problem. But it seems to have gone away,
294 ** so is it worth doing this?
297 if (DaemonSocket >= 0 &&
298 SetNonBlocking(DaemonSocket, false) < 0)
301 (void) sm_releasesignal(SIGALRM);
305 bool setproc = false;
308 struct timeval timeout;
312 for (idx = 0; idx < NDaemons; idx++)
314 /* wait for a connection */
315 if (Daemons[idx].d_socket >= 0)
319 Daemons[idx].d_flags))
321 sm_setproctitle(true, e,
322 "accepting connections");
325 if (Daemons[idx].d_socket > highest)
326 highest = Daemons[idx].d_socket;
327 SM_FD_SET(Daemons[idx].d_socket,
333 if (ControlSocket >= 0)
335 if (ControlSocket > highest)
336 highest = ControlSocket;
337 SM_FD_SET(ControlSocket, &readfds);
344 t = select(highest + 1, FDSET_CAST &readfds,
345 NULL, NULL, &timeout);
347 /* Did someone signal while waiting? */
353 (void) runqueue(true, false, false, false);
354 #if _FFR_QUEUE_RUN_PARANOIA
356 #endif /* _FFR_QUEUE_RUN_PARANOIA */
358 #if _FFR_QUEUE_RUN_PARANOIA
359 else if (CheckQueueRunners > 0 && QueueIntvl > 0 &&
360 lastrun + QueueIntvl + CheckQueueRunners < now)
364 ** set lastrun unconditionally to avoid
365 ** calling checkqueuerunner() all the time.
366 ** That's also why we currently ignore the
367 ** result of the function call.
370 (void) checkqueuerunner();
373 #endif /* _FFR_QUEUE_RUN_PARANOIA */
384 /* look "round-robin" for an active socket */
385 if ((idx = olddaemon + 1) >= NDaemons)
387 for (i = 0; i < NDaemons; i++)
389 if (Daemons[idx].d_socket >= 0 &&
390 SM_FD_ISSET(Daemons[idx].d_socket,
393 lotherend = Daemons[idx].d_socksize;
394 memset(&RealHostAddr, '\0',
395 sizeof(RealHostAddr));
396 t = accept(Daemons[idx].d_socket,
397 (struct sockaddr *)&RealHostAddr,
401 ** If remote side closes before
402 ** accept() finishes, sockaddr
403 ** might not be fully filled in.
408 # ifdef BSD4_4_SOCKADDR
409 RealHostAddr.sa.sa_len == 0 ||
410 # endif /* BSD4_4_SOCKADDR */
411 RealHostAddr.sa.sa_family != Daemons[idx].d_addr.sa.sa_family))
417 olddaemon = curdaemon = idx;
420 if (++idx >= NDaemons)
424 if (curdaemon == -1 && ControlSocket >= 0 &&
425 SM_FD_ISSET(ControlSocket, &readfds))
427 struct sockaddr_un sa_un;
429 lotherend = sizeof(sa_un);
430 memset(&sa_un, '\0', sizeof(sa_un));
431 t = accept(ControlSocket,
432 (struct sockaddr *)&sa_un,
436 ** If remote side closes before
437 ** accept() finishes, sockaddr
438 ** might not be fully filled in.
443 # ifdef BSD4_4_SOCKADDR
444 sa_un.sun_len == 0 ||
445 # endif /* BSD4_4_SOCKADDR */
446 sa_un.sun_family != AF_UNIX))
458 /* No daemon to service */
462 if (t >= 0 || errno != EINTR)
471 (void) sm_blocksignal(SIGALRM);
476 /* let's ignore these temporary errors */
477 if (save_errno == EINTR
479 || save_errno == EAGAIN
482 || save_errno == ECONNABORTED
483 #endif /* ECONNABORTED */
485 || save_errno == EWOULDBLOCK
486 #endif /* EWOULDBLOCK */
490 syserr("getrequests: accept");
494 /* arrange to re-open socket next time around */
495 (void) close(Daemons[curdaemon].d_socket);
496 Daemons[curdaemon].d_socket = -1;
497 #if SO_REUSEADDR_IS_BROKEN
499 ** Give time for bound socket to be released.
500 ** This creates a denial-of-service if you can
501 ** force accept() to fail on affected systems.
504 Daemons[curdaemon].d_refuse_connections_until =
506 #endif /* SO_REUSEADDR_IS_BROKEN */
513 /* set some daemon related macros */
514 switch (Daemons[curdaemon].d_addr.sa.sa_family)
517 macdefine(&BlankEnvelope.e_macro, A_PERM,
518 macid("{daemon_family}"), "unspec");
520 #if _FFR_DAEMON_NETUNIX
523 macdefine(&BlankEnvelope.e_macro, A_PERM,
524 macid("{daemon_family}"), "local");
526 # endif /* NETUNIX */
527 #endif /* _FFR_DAEMON_NETUNIX */
530 macdefine(&BlankEnvelope.e_macro, A_PERM,
531 macid("{daemon_family}"), "inet");
536 macdefine(&BlankEnvelope.e_macro, A_PERM,
537 macid("{daemon_family}"), "inet6");
539 #endif /* NETINET6 */
542 macdefine(&BlankEnvelope.e_macro, A_PERM,
543 macid("{daemon_family}"), "iso");
548 macdefine(&BlankEnvelope.e_macro, A_PERM,
549 macid("{daemon_family}"), "ns");
554 macdefine(&BlankEnvelope.e_macro, A_PERM,
555 macid("{daemon_family}"), "x.25");
559 macdefine(&BlankEnvelope.e_macro, A_PERM,
560 macid("{daemon_name}"),
561 Daemons[curdaemon].d_name);
562 if (Daemons[curdaemon].d_mflags != NULL)
563 macdefine(&BlankEnvelope.e_macro, A_PERM,
564 macid("{daemon_flags}"),
565 Daemons[curdaemon].d_mflags);
567 macdefine(&BlankEnvelope.e_macro, A_PERM,
568 macid("{daemon_flags}"), "");
572 ** If connection rate is exceeded here, connection shall be
573 ** refused later by a new call after fork() by the
574 ** validate_connection() function. Closing the connection
575 ** at this point violates RFC 2821.
576 ** Do NOT remove this call, its side effects are needed.
579 connection_rate_check(&RealHostAddr, NULL);
582 ** Create a subprocess to process the mail.
586 sm_dprintf("getrequests: forking (fd = %d)\n", t);
589 ** Advance state of PRNG.
590 ** This is necessary because otherwise all child processes
591 ** will produce the same PRN sequence and hence the selection
592 ** of a queue directory (and other things, e.g., MX selection)
593 ** are not "really" random.
596 /* XXX get some better "random" data? */
598 RAND_seed((void *) &NextDiskSpaceCheck,
599 sizeof(NextDiskSpaceCheck));
600 RAND_seed((void *) &now, sizeof(now));
601 RAND_seed((void *) &seed, sizeof(seed));
604 #endif /* STARTTLS */
608 ** Update MX records for FallbackMX.
609 ** Let's hope this is fast otherwise we screw up the
613 if (FallbackMX != NULL)
614 (void) getfallbackmxrr(FallbackMX);
615 #endif /* NAMED_BIND */
619 /* don't fork, handle connection in this process */
621 pipefd[0] = pipefd[1] = -1;
626 ** Create a pipe to keep the child from writing to
627 ** the socket until after the parent has closed
628 ** it. Otherwise the parent may hang if the child
629 ** has closed it first.
632 if (pipe(pipefd) < 0)
633 pipefd[0] = pipefd[1] = -1;
635 (void) sm_blocksignal(SIGCHLD);
639 syserr("daemon: cannot fork");
642 (void) close(pipefd[0]);
643 (void) close(pipefd[1]);
645 (void) sm_releasesignal(SIGCHLD);
655 SM_FILE_T *inchannel, *outchannel = NULL;
658 ** CHILD -- return to caller.
659 ** Collect verified idea of sending host.
660 ** Verify calling user id if possible here.
663 /* Reset global flags */
664 RestartRequest = NULL;
665 RestartWorkGroup = false;
666 ShutdownRequest = NULL;
668 CurrentPid = getpid();
669 close_sendmail_pid();
671 (void) sm_releasesignal(SIGALRM);
672 (void) sm_releasesignal(SIGCHLD);
673 (void) sm_signal(SIGCHLD, SIG_DFL);
674 (void) sm_signal(SIGHUP, SIG_DFL);
675 (void) sm_signal(SIGTERM, intsig);
677 /* turn on profiling */
681 ** Initialize exception stack and default exception
682 ** handler for child process.
685 sm_exc_newthread(fatal_error);
689 macdefine(&BlankEnvelope.e_macro, A_TEMP,
690 macid("{daemon_addr}"),
691 anynet_ntoa(&Daemons[curdaemon].d_addr));
692 (void) sm_snprintf(status, sizeof(status), "%d",
693 ntohs(Daemons[curdaemon].d_port));
694 macdefine(&BlankEnvelope.e_macro, A_TEMP,
695 macid("{daemon_port}"), status);
698 for (idx = 0; idx < NDaemons; idx++)
700 if (Daemons[idx].d_socket >= 0)
701 (void) close(Daemons[idx].d_socket);
702 Daemons[idx].d_socket = -1;
706 /* Avoid SMTP daemon actions if control command */
709 /* Add control socket process */
710 proc_list_add(CurrentPid,
711 "console socket child",
712 PROC_CONTROL_CHILD, 0, -1, NULL);
718 /* clean up background delivery children */
719 (void) sm_signal(SIGCHLD, reapchild);
721 /* Add parent process as first child item */
722 proc_list_add(CurrentPid, "daemon child",
723 PROC_DAEMON_CHILD, 0, -1, NULL);
724 /* don't schedule queue runs if ETRN */
728 ** Hack: override global variables if
729 ** the corresponding DaemonPortOption
732 #if _FFR_SS_PER_DAEMON
733 if (Daemons[curdaemon].d_supersafe !=
735 SuperSafe = Daemons[curdaemon].
737 #endif /* _FFR_SS_PER_DAEMON */
738 if (Daemons[curdaemon].d_dm != DM_NOTSET)
740 Daemons[curdaemon].d_dm, e);
742 if (Daemons[curdaemon].d_refuseLA !=
744 RefuseLA = Daemons[curdaemon].
746 if (Daemons[curdaemon].d_queueLA != DPO_NOTSET)
747 QueueLA = Daemons[curdaemon].d_queueLA;
748 if (Daemons[curdaemon].d_delayLA != DPO_NOTSET)
749 DelayLA = Daemons[curdaemon].d_delayLA;
750 if (Daemons[curdaemon].d_maxchildren !=
752 MaxChildren = Daemons[curdaemon].
755 sm_setproctitle(true, e, "startup with %s",
756 anynet_ntoa(&RealHostAddr));
764 ** Wait for the parent to close the write end
765 ** of the pipe, which we will see as an EOF.
766 ** This guarantees that we won't write to the
767 ** socket until after the parent has closed
771 /* close the write end of the pipe */
772 (void) close(pipefd[1]);
774 /* we shouldn't be interrupted, but ... */
775 while (read(pipefd[0], &c, 1) < 0 &&
778 (void) close(pipefd[0]);
781 /* control socket processing */
784 control_command(t, e);
789 /* determine host name */
790 p = hostnamebyanyaddr(&RealHostAddr);
791 if (strlen(p) > MAXNAME) /* XXX - 1 ? */
793 RealHostName = newstr(p);
794 if (RealHostName[0] == '[')
796 macdefine(&BlankEnvelope.e_macro, A_PERM,
797 macid("{client_resolve}"),
798 h_errno == TRY_AGAIN ? "TEMP" : "FAIL");
802 macdefine(&BlankEnvelope.e_macro, A_PERM,
803 macid("{client_resolve}"), "OK");
805 sm_setproctitle(true, e, "startup with %s", p);
806 markstats(e, NULL, STATS_CONNECT);
808 if ((inchannel = sm_io_open(SmFtStdiofd,
814 (outchannel = sm_io_open(SmFtStdiofd,
820 syserr("cannot open SMTP server channel, fd=%d",
822 finis(false, true, EX_OK);
824 sm_io_automode(inchannel, outchannel);
826 InChannel = inchannel;
827 OutChannel = outchannel;
828 DisConnected = false;
831 if (!xla_host_ok(RealHostName))
833 message("421 4.4.5 Too many SMTP sessions for this host");
834 finis(false, true, EX_OK);
837 /* find out name for interface of connection */
838 if (getsockname(sm_io_getinfo(InChannel, SM_IO_WHAT_FD,
839 NULL), &sa.sa, &len) == 0)
841 p = hostnamebyanyaddr(&sa);
843 sm_dprintf("getreq: got name %s\n", p);
844 macdefine(&BlankEnvelope.e_macro, A_TEMP,
845 macid("{if_name}"), p);
848 ** Do this only if it is not the loopback
857 addr = anynet_ntoa(&sa);
858 (void) sm_snprintf(family,
860 "%d", sa.sa.sa_family);
861 macdefine(&BlankEnvelope.e_macro,
863 macid("{if_addr}"), addr);
864 macdefine(&BlankEnvelope.e_macro,
866 macid("{if_family}"), family);
868 sm_dprintf("getreq: got addr %s and family %s\n",
873 macdefine(&BlankEnvelope.e_macro,
875 macid("{if_addr}"), NULL);
876 macdefine(&BlankEnvelope.e_macro,
878 macid("{if_family}"), NULL);
884 sm_dprintf("getreq: getsockname failed\n");
885 macdefine(&BlankEnvelope.e_macro, A_PERM,
886 macid("{if_name}"), NULL);
887 macdefine(&BlankEnvelope.e_macro, A_PERM,
888 macid("{if_addr}"), NULL);
889 macdefine(&BlankEnvelope.e_macro, A_PERM,
890 macid("{if_family}"), NULL);
895 /* parent -- keep track of children */
898 (void) sm_snprintf(status, sizeof(status),
899 "control socket server child");
900 proc_list_add(pid, status, PROC_CONTROL, 0, -1, NULL);
904 (void) sm_snprintf(status, sizeof(status),
905 "SMTP server child for %s",
906 anynet_ntoa(&RealHostAddr));
907 proc_list_add(pid, status, PROC_DAEMON, 0, -1,
910 (void) sm_releasesignal(SIGCHLD);
912 /* close the read end of the synchronization pipe */
915 (void) close(pipefd[0]);
919 /* close the port so that others will hang (for a while) */
922 /* release the child by closing the read end of the sync pipe */
925 (void) close(pipefd[1]);
930 sm_dprintf("getreq: returning\n");
933 /* set the filters for this daemon */
934 if (Daemons[curdaemon].d_inputfilterlist != NULL)
938 Daemons[curdaemon].d_inputfilters[i] != NULL);
941 InputFilters[i] = Daemons[curdaemon].d_inputfilters[i];
944 InputFilters[i] = NULL;
947 return &Daemons[curdaemon].d_flags;
951 ** GETREQUESTS_CHECKDISKSPACE -- check available diskspace.
960 ** Modifies Daemon flags (D_ETRNONLY) if not enough disk space.
964 getrequests_checkdiskspace(e)
972 if (now < NextDiskSpaceCheck)
975 /* Check if there is available disk space in all queue groups. */
976 if (!enoughdiskspace(0, NULL))
978 for (idx = 0; idx < NDaemons; ++idx)
980 if (bitnset(D_ETRNONLY, Daemons[idx].d_flags))
983 /* log only if not logged before */
987 sm_syslog(LOG_INFO, NOQID,
988 "rejecting new messages: min free: %ld",
990 sm_setproctitle(true, e,
991 "rejecting new messages: min free: %ld",
995 setbitn(D_ETRNONLY, Daemons[idx].d_flags);
1000 for (idx = 0; idx < NDaemons; ++idx)
1002 if (!bitnset(D_ETRNONLY, Daemons[idx].d_flags))
1005 /* log only if not logged before */
1009 sm_syslog(LOG_INFO, NOQID,
1010 "accepting new messages (again)");
1014 /* title will be set later */
1015 clrbitn(D_ETRNONLY, Daemons[idx].d_flags);
1019 /* only check disk space once a minute */
1020 NextDiskSpaceCheck = now + 60;
1024 ** OPENDAEMONSOCKET -- open SMTP socket
1026 ** Deals with setting all appropriate options.
1029 ** d -- the structure for the daemon to open.
1030 ** firsttime -- set if this is the initial open.
1033 ** Size in bytes of the daemon socket addr.
1036 ** Leaves DaemonSocket set to the open socket.
1037 ** Exits if the socket cannot be created.
1040 #define MAXOPENTRIES 10 /* maximum number of tries to open connection */
1043 opendaemonsocket(d, firsttime)
1049 SOCKADDR_LEN_T socksize = 0;
1054 sm_dprintf("opendaemonsocket(%s)\n", d->d_name);
1060 if (firsttime || d->d_socket < 0)
1062 #if _FFR_DAEMON_NETUNIX
1064 if (d->d_addr.sa.sa_family == AF_UNIX)
1067 long sff = SFF_SAFEDIRPATH|SFF_OPENASROOT|SFF_NOLINK|SFF_ROOTOK|SFF_EXECOK|SFF_CREAT;
1069 /* if not safe, don't use it */
1070 rval = safefile(d->d_addr.sunix.sun_path,
1073 S_IRUSR|S_IWUSR, NULL);
1077 syserr("opendaemonsocket: daemon %s: unsafe domain socket %s",
1079 d->d_addr.sunix.sun_path);
1083 /* Don't try to overtake an existing socket */
1084 (void) unlink(d->d_addr.sunix.sun_path);
1086 # endif /* NETUNIX */
1087 #endif /* _FFR_DOMAIN_NETUNIX */
1088 d->d_socket = socket(d->d_addr.sa.sa_family,
1090 if (d->d_socket < 0)
1093 syserr("opendaemonsocket: daemon %s: can't create server SMTP socket",
1096 if (bitnset(D_OPTIONAL, d->d_flags) &&
1097 (!transienterror(save_errno) ||
1098 ntries >= MAXOPENTRIES - 1))
1100 syserr("opendaemonsocket: daemon %s: optional socket disabled",
1102 setbitn(D_DISABLE, d->d_flags);
1108 sm_syslog(LOG_ALERT, NOQID,
1109 "daemon %s: problem creating SMTP socket",
1115 if (SM_FD_SETSIZE > 0 && d->d_socket >= SM_FD_SETSIZE)
1117 save_errno = EINVAL;
1118 syserr("opendaemonsocket: daemon %s: server SMTP socket (%d) too large",
1119 d->d_name, d->d_socket);
1123 /* turn on network debugging? */
1125 (void) setsockopt(d->d_socket, SOL_SOCKET,
1126 SO_DEBUG, (char *)&on,
1129 (void) setsockopt(d->d_socket, SOL_SOCKET,
1130 SO_REUSEADDR, (char *)&on, sizeof(on));
1131 (void) setsockopt(d->d_socket, SOL_SOCKET,
1132 SO_KEEPALIVE, (char *)&on, sizeof(on));
1135 if (d->d_tcprcvbufsize > 0)
1137 if (setsockopt(d->d_socket, SOL_SOCKET,
1139 (char *) &d->d_tcprcvbufsize,
1140 sizeof(d->d_tcprcvbufsize)) < 0)
1141 syserr("opendaemonsocket: daemon %s: setsockopt(SO_RCVBUF)", d->d_name);
1143 #endif /* SO_RCVBUF */
1145 if (d->d_tcpsndbufsize > 0)
1147 if (setsockopt(d->d_socket, SOL_SOCKET,
1149 (char *) &d->d_tcpsndbufsize,
1150 sizeof(d->d_tcpsndbufsize)) < 0)
1151 syserr("opendaemonsocket: daemon %s: setsockopt(SO_SNDBUF)", d->d_name);
1153 #endif /* SO_SNDBUF */
1155 if ((fdflags = fcntl(d->d_socket, F_GETFD, 0)) == -1 ||
1156 fcntl(d->d_socket, F_SETFD,
1157 fdflags | FD_CLOEXEC) == -1)
1160 syserr("opendaemonsocket: daemon %s: failed to %s close-on-exec flag: %s",
1162 fdflags == -1 ? "get" : "set",
1163 sm_errstring(save_errno));
1164 (void) close(d->d_socket);
1168 switch (d->d_addr.sa.sa_family)
1170 #if _FFR_DAEMON_NETUNIX
1173 socksize = sizeof(d->d_addr.sunix);
1175 # endif /* NETUNIX */
1176 #endif /* _FFR_DAEMON_NETUNIX */
1179 socksize = sizeof(d->d_addr.sin);
1181 #endif /* NETINET */
1185 socksize = sizeof(d->d_addr.sin6);
1187 #endif /* NETINET6 */
1191 socksize = sizeof(d->d_addr.siso);
1196 socksize = sizeof(d->d_addr);
1200 if (bind(d->d_socket, &d->d_addr.sa, socksize) < 0)
1202 /* probably another daemon already */
1204 syserr("opendaemonsocket: daemon %s: cannot bind",
1206 (void) close(d->d_socket);
1211 listen(d->d_socket, d->d_listenqueue) < 0)
1214 syserr("opendaemonsocket: daemon %s: cannot listen",
1216 (void) close(d->d_socket);
1220 } while (ntries++ < MAXOPENTRIES && transienterror(save_errno));
1221 syserr("!opendaemonsocket: daemon %s: server SMTP socket wedged: exiting",
1224 return -1; /* avoid compiler warning on IRIX */
1227 ** SETUPDAEMON -- setup socket for daemon
1230 ** daemonaddr -- socket for daemon
1233 ** port number on which daemon should run
1237 static unsigned short
1238 setupdaemon(daemonaddr)
1239 SOCKADDR *daemonaddr;
1241 unsigned short port;
1244 ** Set up the address for the mailer.
1247 if (daemonaddr->sa.sa_family == AF_UNSPEC)
1249 memset(daemonaddr, '\0', sizeof(*daemonaddr));
1251 daemonaddr->sa.sa_family = AF_INET;
1252 #endif /* NETINET */
1255 switch (daemonaddr->sa.sa_family)
1259 if (daemonaddr->sin.sin_addr.s_addr == 0)
1260 daemonaddr->sin.sin_addr.s_addr =
1261 LocalDaemon ? htonl(INADDR_LOOPBACK) : INADDR_ANY;
1262 port = daemonaddr->sin.sin_port;
1264 #endif /* NETINET */
1268 if (IN6_IS_ADDR_UNSPECIFIED(&daemonaddr->sin6.sin6_addr))
1269 daemonaddr->sin6.sin6_addr =
1270 (LocalDaemon && V6LoopbackAddrFound) ?
1271 in6addr_loopback : in6addr_any;
1272 port = daemonaddr->sin6.sin6_port;
1274 #endif /* NETINET6 */
1277 /* unknown protocol */
1283 #ifdef NO_GETSERVBYNAME
1285 #else /* NO_GETSERVBYNAME */
1287 register struct servent *sp;
1289 sp = getservbyname("smtp", "tcp");
1292 syserr("554 5.3.5 service \"smtp\" unknown");
1298 #endif /* NO_GETSERVBYNAME */
1301 switch (daemonaddr->sa.sa_family)
1305 daemonaddr->sin.sin_port = port;
1307 #endif /* NETINET */
1311 daemonaddr->sin6.sin6_port = port;
1313 #endif /* NETINET6 */
1316 /* unknown protocol */
1322 ** CLRDAEMON -- reset the daemon connection
1331 ** releases any resources used by the passive daemon.
1339 for (i = 0; i < NDaemons; i++)
1341 if (Daemons[i].d_socket >= 0)
1342 (void) close(Daemons[i].d_socket);
1343 Daemons[i].d_socket = -1;
1348 ** GETMODIFIERS -- get modifier flags
1351 ** v -- the modifiers (input text line).
1352 ** modifiers -- pointer to flag field to represent modifiers.
1355 ** (xallocat()ed) string representation of modifiers.
1358 ** fills in modifiers.
1362 getmodifiers(v, modifiers)
1364 BITMAP256 modifiers;
1367 char *h, *f, *flags;
1369 /* maximum length of flags: upper case Option -> "OO " */
1370 l = 3 * strlen(v) + 3;
1372 /* is someone joking? */
1373 if (l < 0 || l > 256)
1376 sm_syslog(LOG_ERR, NOQID,
1377 "getmodifiers too long, ignored");
1382 clrbitmap(modifiers);
1383 for (h = v; *h != '\0'; h++)
1385 if (isascii(*h) && !isspace(*h) && isprint(*h))
1387 setbitn(*h, modifiers);
1400 ** CHKDAEMONMODIFIERS -- check whether all daemons have set a flag.
1403 ** flag -- the flag to test.
1406 ** true iff all daemons have set flag.
1410 chkdaemonmodifiers(flag)
1415 for (i = 0; i < NDaemons; i++)
1416 if (!bitnset((char) flag, Daemons[i].d_flags))
1422 ** SETSOCKADDROPTIONS -- set options for SOCKADDR (daemon or client)
1425 ** p -- the options line.
1426 ** d -- the daemon structure to fill in.
1433 setsockaddroptions(p, d)
1444 if (d->d_addr.sa.sa_family == AF_UNSPEC)
1445 d->d_addr.sa.sa_family = AF_INET;
1446 #endif /* NETINET */
1447 #if _FFR_SS_PER_DAEMON
1448 d->d_supersafe = DPO_NOTSET;
1449 #endif /* _FFR_SS_PER_DAEMON */
1450 d->d_dm = DM_NOTSET;
1451 d->d_refuseLA = DPO_NOTSET;
1452 d->d_queueLA = DPO_NOTSET;
1453 d->d_delayLA = DPO_NOTSET;
1454 d->d_maxchildren = DPO_NOTSET;
1461 while (isascii(*p) && isspace(*p))
1472 while (isascii(*++v) && isspace(*v))
1477 case 'A': /* address */
1480 #endif /* !_FFR_DPO_CS */
1485 d->d_maxchildren = atoi(v);
1488 case 'D': /* DeliveryMode */
1498 syserr("554 5.3.5 Unknown delivery mode %c",
1504 case 'd': /* delayLA */
1505 d->d_delayLA = atoi(v);
1508 case 'F': /* address family */
1511 #endif /* !_FFR_DPO_CS */
1512 if (isascii(*v) && isdigit(*v))
1513 d->d_addr.sa.sa_family = atoi(v);
1514 #if _FFR_DAEMON_NETUNIX
1516 else if (sm_strcasecmp(v, "unix") == 0 ||
1517 sm_strcasecmp(v, "local") == 0)
1518 d->d_addr.sa.sa_family = AF_UNIX;
1519 # endif /* NETUNIX */
1520 #endif /* _FFR_DAEMON_NETUNIX */
1522 else if (sm_strcasecmp(v, "inet") == 0)
1523 d->d_addr.sa.sa_family = AF_INET;
1524 #endif /* NETINET */
1526 else if (sm_strcasecmp(v, "inet6") == 0)
1527 d->d_addr.sa.sa_family = AF_INET6;
1528 #endif /* NETINET6 */
1530 else if (sm_strcasecmp(v, "iso") == 0)
1531 d->d_addr.sa.sa_family = AF_ISO;
1534 else if (sm_strcasecmp(v, "ns") == 0)
1535 d->d_addr.sa.sa_family = AF_NS;
1538 else if (sm_strcasecmp(v, "x.25") == 0)
1539 d->d_addr.sa.sa_family = AF_CCITT;
1542 syserr("554 5.3.5 Unknown address family %s in Family=option",
1550 # endif /* !_FFR_DPO_CS */
1551 d->d_inputfilterlist = v;
1555 case 'L': /* listen queue size */
1558 #endif /* !_FFR_DPO_CS */
1559 d->d_listenqueue = atoi(v);
1562 case 'M': /* modifiers (flags) */
1565 #endif /* !_FFR_DPO_CS */
1566 d->d_mflags = getmodifiers(v, d->d_flags);
1569 case 'N': /* name */
1572 #endif /* !_FFR_DPO_CS */
1576 case 'P': /* port */
1579 #endif /* !_FFR_DPO_CS */
1584 d->d_queueLA = atoi(v);
1587 case 'R': /* receive buffer size */
1588 d->d_tcprcvbufsize = atoi(v);
1592 d->d_refuseLA = atoi(v);
1595 case 'S': /* send buffer size */
1598 #endif /* !_FFR_DPO_CS */
1599 d->d_tcpsndbufsize = atoi(v);
1602 #if _FFR_SS_PER_DAEMON
1603 case 'T': /* SuperSafe */
1604 if (tolower(*v) == 'i')
1605 d->d_supersafe = SAFE_INTERACTIVE;
1606 else if (tolower(*v) == 'p')
1608 d->d_supersafe = SAFE_REALLY_POSTMILTER;
1610 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
1611 "Warning: SuperSafe=PostMilter requires Milter support (-DMILTER)\n");
1612 # endif /* MILTER */
1614 d->d_supersafe = atobool(v) ? SAFE_REALLY
1617 #endif /* _FFR_SS_PER_DAEMON */
1620 syserr("554 5.3.5 PortOptions parameter \"%s\" unknown",
1625 /* Check addr and port after finding family */
1628 switch (d->d_addr.sa.sa_family)
1630 #if _FFR_DAEMON_NETUNIX
1633 if (strlen(addr) >= sizeof(d->d_addr.sunix.sun_path))
1635 errno = ENAMETOOLONG;
1636 syserr("setsockaddroptions: domain socket name too long: %s > %d",
1637 addr, sizeof(d->d_addr.sunix.sun_path));
1641 /* file safety check done in opendaemonsocket() */
1642 (void) memset(&d->d_addr.sunix.sun_path, '\0',
1643 sizeof(d->d_addr.sunix.sun_path));
1644 (void) sm_strlcpy((char *)&d->d_addr.sunix.sun_path,
1646 sizeof(d->d_addr.sunix.sun_path));
1648 # endif /* NETUNIX */
1649 #endif /* _FFR_DAEMON_NETUNIX */
1652 if (!isascii(*addr) || !isdigit(*addr) ||
1653 ((d->d_addr.sin.sin_addr.s_addr = inet_addr(addr))
1656 register struct hostent *hp;
1658 hp = sm_gethostbyname(addr, AF_INET);
1660 syserr("554 5.3.0 host \"%s\" unknown",
1664 while (*(hp->h_addr_list) != NULL &&
1665 hp->h_addrtype != AF_INET)
1667 if (*(hp->h_addr_list) == NULL)
1668 syserr("554 5.3.0 host \"%s\" unknown",
1671 memmove(&d->d_addr.sin.sin_addr,
1677 # endif /* NETINET6 */
1681 #endif /* NETINET */
1685 if (anynet_pton(AF_INET6, addr,
1686 &d->d_addr.sin6.sin6_addr) != 1)
1688 register struct hostent *hp;
1690 hp = sm_gethostbyname(addr, AF_INET6);
1692 syserr("554 5.3.0 host \"%s\" unknown",
1696 while (*(hp->h_addr_list) != NULL &&
1697 hp->h_addrtype != AF_INET6)
1699 if (*(hp->h_addr_list) == NULL)
1700 syserr("554 5.3.0 host \"%s\" unknown",
1703 memmove(&d->d_addr.sin6.sin6_addr,
1711 #endif /* NETINET6 */
1714 syserr("554 5.3.5 address= option unsupported for family %d",
1715 d->d_addr.sa.sa_family);
1722 switch (d->d_addr.sa.sa_family)
1726 if (isascii(*port) && isdigit(*port))
1727 d->d_addr.sin.sin_port = htons((unsigned short)
1728 atoi((const char *) port));
1731 # ifdef NO_GETSERVBYNAME
1732 syserr("554 5.3.5 invalid port number: %s",
1734 # else /* NO_GETSERVBYNAME */
1735 register struct servent *sp;
1737 sp = getservbyname(port, "tcp");
1739 syserr("554 5.3.5 service \"%s\" unknown",
1742 d->d_addr.sin.sin_port = sp->s_port;
1743 # endif /* NO_GETSERVBYNAME */
1746 #endif /* NETINET */
1750 if (isascii(*port) && isdigit(*port))
1751 d->d_addr.sin6.sin6_port = htons((unsigned short)
1755 # ifdef NO_GETSERVBYNAME
1756 syserr("554 5.3.5 invalid port number: %s",
1758 # else /* NO_GETSERVBYNAME */
1759 register struct servent *sp;
1761 sp = getservbyname(port, "tcp");
1763 syserr("554 5.3.5 service \"%s\" unknown",
1766 d->d_addr.sin6.sin6_port = sp->s_port;
1767 # endif /* NO_GETSERVBYNAME */
1770 #endif /* NETINET6 */
1774 /* assume two byte transport selector */
1775 if (isascii(*port) && isdigit(*port))
1776 portno = htons((unsigned short) atoi(port));
1779 # ifdef NO_GETSERVBYNAME
1780 syserr("554 5.3.5 invalid port number: %s",
1782 # else /* NO_GETSERVBYNAME */
1783 register struct servent *sp;
1785 sp = getservbyname(port, "tcp");
1787 syserr("554 5.3.5 service \"%s\" unknown",
1790 portno = sp->s_port;
1791 # endif /* NO_GETSERVBYNAME */
1793 memmove(TSEL(&d->d_addr.siso),
1794 (char *) &portno, 2);
1799 syserr("554 5.3.5 Port= option unsupported for family %d",
1800 d->d_addr.sa.sa_family);
1806 ** SETDAEMONOPTIONS -- set options for running the MTA daemon
1809 ** p -- the options line.
1812 ** true if successful, false otherwise.
1815 ** increments number of daemons.
1818 #define DEF_LISTENQUEUE 10
1826 static struct dflags DaemonFlags[] =
1828 { "AUTHREQ", D_AUTHREQ },
1829 { "BINDIF", D_BINDIF },
1830 { "CANONREQ", D_CANONREQ },
1831 { "IFNHELO", D_IFNHELO },
1832 { "FQMAIL", D_FQMAIL },
1833 { "FQRCPT", D_FQRCPT },
1834 { "SMTPS", D_SMTPS },
1835 { "UNQUALOK", D_UNQUALOK },
1836 { "NOAUTH", D_NOAUTH },
1837 { "NOCANON", D_NOCANON },
1838 { "NOETRN", D_NOETRN },
1839 { "NOTLS", D_NOTLS },
1840 { "ETRNONLY", D_ETRNONLY },
1841 { "OPTIONAL", D_OPTIONAL },
1842 { "DISABLE", D_DISABLE },
1843 { "ISSET", D_ISSET },
1851 register struct dflags *df;
1854 for (df = DaemonFlags; df->d_name != NULL; df++)
1856 if (!bitnset(df->d_flag, d->d_flags))
1859 sm_dprintf("<%s", df->d_name);
1861 sm_dprintf(",%s", df->d_name);
1872 if (NDaemons >= MAXDAEMONS)
1874 Daemons[NDaemons].d_socket = -1;
1875 Daemons[NDaemons].d_listenqueue = DEF_LISTENQUEUE;
1876 clrbitmap(Daemons[NDaemons].d_flags);
1877 setsockaddroptions(p, &Daemons[NDaemons]);
1880 if (Daemons[NDaemons].d_inputfilterlist != NULL)
1881 Daemons[NDaemons].d_inputfilterlist = newstr(Daemons[NDaemons].d_inputfilterlist);
1884 if (Daemons[NDaemons].d_name != NULL)
1885 Daemons[NDaemons].d_name = newstr(Daemons[NDaemons].d_name);
1890 (void) sm_snprintf(num, sizeof(num), "Daemon%d", NDaemons);
1891 Daemons[NDaemons].d_name = newstr(num);
1896 sm_dprintf("Daemon %s flags: ", Daemons[NDaemons].d_name);
1897 printdaemonflags(&Daemons[NDaemons]);
1904 ** INITDAEMON -- initialize daemon if not yet done.
1913 ** initializes structure for one daemon.
1921 Daemons[NDaemons].d_socket = -1;
1922 Daemons[NDaemons].d_listenqueue = DEF_LISTENQUEUE;
1923 Daemons[NDaemons].d_name = "Daemon0";
1928 ** SETCLIENTOPTIONS -- set options for running the client
1931 ** p -- the options line.
1937 static DAEMON_T ClientSettings[AF_MAX + 1];
1946 memset(&d, '\0', sizeof(d));
1947 setsockaddroptions(p, &d);
1949 /* grab what we need */
1950 family = d.d_addr.sa.sa_family;
1951 STRUCTCOPY(d, ClientSettings[family]);
1952 setbitn(D_ISSET, ClientSettings[family].d_flags); /* mark as set */
1953 if (d.d_name != NULL)
1954 ClientSettings[family].d_name = newstr(d.d_name);
1959 (void) sm_snprintf(num, sizeof(num), "Client%d", family);
1960 ClientSettings[family].d_name = newstr(num);
1964 ** ADDR_FAMILY -- determine address family from address
1967 ** addr -- the string representation of the address
1970 ** AF_INET, AF_INET6 or AF_UNSPEC
1982 #endif /* NETINET6 */
1985 if (inet_addr(addr) != INADDR_NONE)
1988 sm_dprintf("addr_family(%s): INET\n", addr);
1991 #endif /* NETINET */
1993 if (anynet_pton(AF_INET6, addr, &clt_addr.sin6.sin6_addr) == 1)
1996 sm_dprintf("addr_family(%s): INET6\n", addr);
1999 #endif /* NETINET6 */
2000 #if _FFR_DAEMON_NETUNIX
2005 sm_dprintf("addr_family(%s): LOCAL\n", addr);
2008 # endif /* NETUNIX */
2009 #endif /* _FFR_DAEMON_NETUNIX */
2011 sm_dprintf("addr_family(%s): UNSPEC\n", addr);
2016 ** CHKCLIENTMODIFIERS -- check whether all clients have set a flag.
2019 ** flag -- the flag to test.
2022 ** true iff all configured clients have set the flag.
2026 chkclientmodifiers(flag)
2033 for (i = 0; i < AF_MAX; i++)
2035 if (bitnset(D_ISSET, ClientSettings[i].d_flags))
2037 if (!bitnset((char) flag, ClientSettings[i].d_flags))
2047 ** SETUP_DAEMON_FILTERS -- Parse per-socket filters
2057 setup_daemon_milters()
2061 if (OpMode == MD_SMTP)
2063 /* no need to configure the daemons */
2067 for (idx = 0; idx < NDaemons; idx++)
2069 if (Daemons[idx].d_inputfilterlist != NULL)
2071 milter_config(Daemons[idx].d_inputfilterlist,
2072 Daemons[idx].d_inputfilters,
2079 ** MAKECONNECTION -- make a connection to an SMTP socket on a machine.
2082 ** host -- the name of the host.
2083 ** port -- the port number to connect to.
2084 ** mci -- a pointer to the mail connection information
2085 ** structure to be filled in.
2086 ** e -- the current envelope.
2087 ** enough -- time at which to stop further connection attempts.
2088 ** (0 means no limit)
2091 ** An exit code telling whether the connection could be
2092 ** made and if not why not.
2098 static jmp_buf CtxConnectTimeout;
2100 SOCKADDR CurHostAddr; /* address of current host */
2103 makeconnection(host, port, mci, e, enough)
2105 volatile unsigned int port;
2110 register volatile int addrno = 0;
2112 register struct hostent *volatile hp = (struct hostent *) NULL;
2116 volatile SOCKADDR_LEN_T addrlen;
2117 volatile bool firstconnect = true;
2118 SM_EVENT *volatile ev = NULL;
2120 volatile bool v6found = false;
2121 #endif /* NETINET6 */
2122 volatile int family = InetMode;
2124 volatile SOCKADDR_LEN_T socksize = 0;
2125 volatile bool clt_bind;
2128 extern ENVELOPE BlankEnvelope;
2130 /* retranslate {daemon_flags} into bitmap */
2132 if ((p = macvalue(macid("{daemon_flags}"), e)) != NULL)
2134 for (; *p != '\0'; p++)
2136 if (!(isascii(*p) && isspace(*p)))
2137 setbitn(bitidx(*p), d_flags);
2143 #endif /* NETINET6 */
2146 /* Set up the address for outgoing connection. */
2147 if (bitnset(D_BINDIF, d_flags) &&
2148 (p = macvalue(macid("{if_addr}"), e)) != NULL &&
2152 char p6[INET6_ADDRSTRLEN];
2153 #endif /* NETINET6 */
2155 memset(&clt_addr, '\0', sizeof(clt_addr));
2157 /* infer the address family from the address itself */
2158 clt_addr.sa.sa_family = addr_family(p);
2159 switch (clt_addr.sa.sa_family)
2163 clt_addr.sin.sin_addr.s_addr = inet_addr(p);
2164 if (clt_addr.sin.sin_addr.s_addr != INADDR_NONE &&
2165 clt_addr.sin.sin_addr.s_addr !=
2166 htonl(INADDR_LOOPBACK))
2169 socksize = sizeof(struct sockaddr_in);
2172 #endif /* NETINET */
2176 if (inet_addr(p) != INADDR_NONE)
2177 (void) sm_snprintf(p6, sizeof(p6),
2178 "IPv6:::ffff:%s", p);
2180 (void) sm_strlcpy(p6, p, sizeof(p6));
2181 if (anynet_pton(AF_INET6, p6,
2182 &clt_addr.sin6.sin6_addr) == 1 &&
2183 !IN6_IS_ADDR_LOOPBACK(&clt_addr.sin6.sin6_addr))
2186 socksize = sizeof(struct sockaddr_in6);
2189 #endif /* NETINET6 */
2193 syserr("554 5.3.5 Address= option unsupported for family %d",
2194 clt_addr.sa.sa_family);
2199 family = clt_addr.sa.sa_family;
2202 /* D_BINDIF not set or not available, fallback to ClientPortOptions */
2205 STRUCTCOPY(ClientSettings[family].d_addr, clt_addr);
2206 switch (clt_addr.sa.sa_family)
2210 if (clt_addr.sin.sin_addr.s_addr == 0)
2211 clt_addr.sin.sin_addr.s_addr = LocalDaemon ?
2212 htonl(INADDR_LOOPBACK) : INADDR_ANY;
2215 if (clt_addr.sin.sin_port != 0)
2217 socksize = sizeof(struct sockaddr_in);
2219 #endif /* NETINET */
2222 if (IN6_IS_ADDR_UNSPECIFIED(&clt_addr.sin6.sin6_addr))
2223 clt_addr.sin6.sin6_addr =
2224 (LocalDaemon && V6LoopbackAddrFound) ?
2225 in6addr_loopback : in6addr_any;
2228 socksize = sizeof(struct sockaddr_in6);
2229 if (clt_addr.sin6.sin6_port != 0)
2232 #endif /* NETINET6 */
2235 socksize = sizeof(clt_addr.siso);
2245 ** Set up the address for the mailer.
2246 ** Accept "[a.b.c.d]" syntax for host name.
2251 memset(&CurHostAddr, '\0', sizeof(CurHostAddr));
2252 memset(&addr, '\0', sizeof(addr));
2253 SmtpPhase = mci->mci_phase = "initial connection";
2258 p = strchr(host, ']');
2262 unsigned long hid = INADDR_NONE;
2263 #endif /* NETINET */
2265 struct sockaddr_in6 hid6;
2266 #endif /* NETINET6 */
2270 memset(&hid6, '\0', sizeof(hid6));
2271 #endif /* NETINET6 */
2273 if (family == AF_INET &&
2274 (hid = inet_addr(&host[1])) != INADDR_NONE)
2276 addr.sin.sin_family = AF_INET;
2277 addr.sin.sin_addr.s_addr = hid;
2280 #endif /* NETINET */
2282 if (family == AF_INET6 &&
2283 anynet_pton(AF_INET6, &host[1],
2284 &hid6.sin6_addr) == 1)
2286 addr.sin6.sin6_family = AF_INET6;
2287 addr.sin6.sin6_addr = hid6.sin6_addr;
2290 #endif /* NETINET6 */
2292 /* try it as a host name (avoid MX lookup) */
2293 hp = sm_gethostbyname(&host[1], family);
2294 if (hp == NULL && p[-1] == '.')
2297 int oldopts = _res.options;
2299 _res.options &= ~(RES_DEFNAMES|RES_DNSRCH);
2300 #endif /* NAMED_BIND */
2302 hp = sm_gethostbyname(&host[1],
2306 _res.options = oldopts;
2307 #endif /* NAMED_BIND */
2316 extern char MsgBuf[];
2319 "553 Invalid numeric domain spec \"%s\"",
2321 mci_setstat(mci, EX_NOHOST, "5.1.2", MsgBuf);
2328 /* contortion to get around SGI cc complaints */
2330 p = &host[strlen(host) - 1];
2331 hp = sm_gethostbyname(host, family);
2332 if (hp == NULL && *p == '.')
2335 int oldopts = _res.options;
2337 _res.options &= ~(RES_DEFNAMES|RES_DNSRCH);
2338 #endif /* NAMED_BIND */
2340 hp = sm_gethostbyname(host, family);
2343 _res.options = oldopts;
2344 #endif /* NAMED_BIND */
2348 if (hp == NULL || hp->h_addr == NULL)
2351 /* check for name server timeouts */
2353 if (WorkAroundBrokenAAAA && family == AF_INET6 &&
2357 ** An attempt with family AF_INET may
2358 ** succeed By skipping the next section
2359 ** of code, we will try AF_INET before
2364 sm_dprintf("makeconnection: WorkAroundBrokenAAAA: Trying AF_INET lookup (AF_INET6 failed)\n");
2367 # endif /* NETINET6 */
2369 if (errno == ETIMEDOUT ||
2370 # if _FFR_GETHBN_ExFILE
2373 # endif /* EMFILE */
2376 # endif /* ENFILE */
2377 # endif /* _FFR_GETHBN_ExFILE */
2378 h_errno == TRY_AGAIN ||
2379 (errno == ECONNREFUSED && UseNameServer))
2382 mci_setstat(mci, EX_TEMPFAIL,
2388 #endif /* NAMED_BIND */
2391 ** Try v6 first, then fall back to v4.
2392 ** If we found a v6 address, but no v4
2393 ** addresses, then TEMPFAIL.
2396 if (family == AF_INET6)
2403 #endif /* NETINET6 */
2405 mci_setstat(mci, EX_NOHOST, "5.1.2", NULL);
2409 addr.sa.sa_family = hp->h_addrtype;
2410 switch (hp->h_addrtype)
2414 memmove(&addr.sin.sin_addr,
2418 #endif /* NETINET */
2422 memmove(&addr.sin6.sin6_addr,
2426 #endif /* NETINET6 */
2429 if (hp->h_length > sizeof(addr.sa.sa_data))
2431 syserr("makeconnection: long sa_data: family %d len %d",
2432 hp->h_addrtype, hp->h_length);
2433 mci_setstat(mci, EX_NOHOST, "5.1.2", NULL);
2437 memmove(addr.sa.sa_data, hp->h_addr, hp->h_length);
2444 ** Determine the port number.
2449 #ifdef NO_GETSERVBYNAME
2451 #else /* NO_GETSERVBYNAME */
2452 register struct servent *sp = getservbyname("smtp", "tcp");
2457 sm_syslog(LOG_ERR, NOQID,
2458 "makeconnection: service \"smtp\" unknown");
2463 #endif /* NO_GETSERVBYNAME */
2467 if (addr.sa.sa_family == AF_INET6 &&
2468 IN6_IS_ADDR_V4MAPPED(&addr.sin6.sin6_addr) &&
2469 ClientSettings[AF_INET].d_addr.sa.sa_family != 0)
2472 ** Ignore mapped IPv4 address since
2473 ** there is a ClientPortOptions setting
2479 #endif /* NETINET6 */
2481 switch (addr.sa.sa_family)
2485 addr.sin.sin_port = port;
2486 addrlen = sizeof(struct sockaddr_in);
2488 #endif /* NETINET */
2492 addr.sin6.sin6_port = port;
2493 addrlen = sizeof(struct sockaddr_in6);
2495 #endif /* NETINET6 */
2499 /* assume two byte transport selector */
2500 memmove(TSEL((struct sockaddr_iso *) &addr), (char *) &port, 2);
2501 addrlen = sizeof(struct sockaddr_iso);
2506 syserr("Can't connect to address family %d", addr.sa.sa_family);
2507 mci_setstat(mci, EX_NOHOST, "5.1.2", NULL);
2512 #endif /* NETINET6 */
2517 ** Try to actually open the connection.
2521 /* if too many connections, don't bother trying */
2522 if (!xla_noqueue_ok(host))
2527 # endif /* NETINET6 */
2535 sm_dprintf("makeconnection (%s [%s].%d (%d))\n",
2536 host, anynet_ntoa(&addr), ntohs(port),
2537 (int) addr.sa.sa_family);
2539 /* save for logging */
2543 if (bitnset(M_SECURE_PORT, mci->mci_mailer->m_flags))
2545 int rport = IPPORT_RESERVED - 1;
2547 s = rresvport(&rport);
2550 #endif /* HASRRESVPORT */
2552 s = socket(addr.sa.sa_family, SOCK_STREAM, 0);
2557 syserr("makeconnection: cannot create socket");
2561 mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
2565 #endif /* NETINET6 */
2571 if (ClientSettings[family].d_tcpsndbufsize > 0)
2573 if (setsockopt(s, SOL_SOCKET, SO_SNDBUF,
2574 (char *) &ClientSettings[family].d_tcpsndbufsize,
2575 sizeof(ClientSettings[family].d_tcpsndbufsize)) < 0)
2576 syserr("makeconnection: setsockopt(SO_SNDBUF)");
2578 #endif /* SO_SNDBUF */
2580 if (ClientSettings[family].d_tcprcvbufsize > 0)
2582 if (setsockopt(s, SOL_SOCKET, SO_RCVBUF,
2583 (char *) &ClientSettings[family].d_tcprcvbufsize,
2584 sizeof(ClientSettings[family].d_tcprcvbufsize)) < 0)
2585 syserr("makeconnection: setsockopt(SO_RCVBUF)");
2587 #endif /* SO_RCVBUF */
2590 sm_dprintf("makeconnection: fd=%d\n", s);
2592 /* turn on network debugging? */
2597 (void) setsockopt(s, SOL_SOCKET, SO_DEBUG,
2598 (char *)&on, sizeof(on));
2600 if (e->e_xfp != NULL) /* for debugging */
2601 (void) sm_io_flush(e->e_xfp, SM_TIME_DEFAULT);
2602 errno = 0; /* for debugging */
2608 switch (clt_addr.sa.sa_family)
2612 if (clt_addr.sin.sin_port != 0)
2613 (void) setsockopt(s, SOL_SOCKET,
2618 #endif /* NETINET */
2622 if (clt_addr.sin6.sin6_port != 0)
2623 (void) setsockopt(s, SOL_SOCKET,
2628 #endif /* NETINET6 */
2631 if (bind(s, &clt_addr.sa, socksize) < 0)
2636 syserr("makeconnection: cannot bind socket [%s]",
2637 anynet_ntoa(&clt_addr));
2641 #endif /* NETINET6 */
2648 ** Linux seems to hang in connect for 90 minutes (!!!).
2649 ** Time out the connect to avoid this problem.
2652 if (setjmp(CtxConnectTimeout) == 0)
2656 if (e->e_ntries <= 0 && TimeOuts.to_iconnect != 0)
2657 ev = sm_setevent(TimeOuts.to_iconnect,
2659 else if (TimeOuts.to_connect != 0)
2660 ev = sm_setevent(TimeOuts.to_connect,
2665 switch (ConnectOnlyTo.sa.sa_family)
2669 addr.sin.sin_addr.s_addr = ConnectOnlyTo.sin.sin_addr.s_addr;
2670 addr.sa.sa_family = ConnectOnlyTo.sa.sa_family;
2672 #endif /* NETINET */
2676 memmove(&addr.sin6.sin6_addr,
2677 &ConnectOnlyTo.sin6.sin6_addr,
2680 #endif /* NETINET6 */
2683 sm_dprintf("Connecting to [%s]...\n", anynet_ntoa(&addr));
2684 i = connect(s, (struct sockaddr *) &addr, addrlen);
2694 /* couldn't connect.... figure out why */
2697 /* if running demand-dialed connection, try again */
2698 if (DialDelay > 0 && firstconnect &&
2699 bitnset(M_DIALDELAY, mci->mci_mailer->m_flags))
2702 sm_dprintf("Connect failed (%s); trying again...\n",
2703 sm_errstring(save_errno));
2704 firstconnect = false;
2705 (void) sleep(DialDelay);
2710 sm_syslog(LOG_INFO, e->e_id,
2711 "makeconnection (%s [%s]) failed: %s",
2712 host, anynet_ntoa(&addr),
2713 sm_errstring(save_errno));
2717 #endif /* NETINET6 */
2718 if (hp != NULL && hp->h_addr_list[addrno] != NULL &&
2719 (enough == 0 || curtime() < enough))
2722 sm_dprintf("Connect failed (%s); trying new address....\n",
2723 sm_errstring(save_errno));
2724 switch (addr.sa.sa_family)
2728 memmove(&addr.sin.sin_addr,
2729 hp->h_addr_list[addrno++],
2732 #endif /* NETINET */
2736 memmove(&addr.sin6.sin6_addr,
2737 hp->h_addr_list[addrno++],
2740 #endif /* NETINET6 */
2743 memmove(addr.sa.sa_data,
2744 hp->h_addr_list[addrno++],
2753 if (family == AF_INET6)
2756 sm_dprintf("Connect failed (%s); retrying with AF_INET....\n",
2757 sm_errstring(save_errno));
2768 #endif /* NETINET6 */
2769 /* couldn't open connection */
2771 /* Don't clobber an already saved errno from v4retry */
2773 #endif /* NETINET6 */
2776 sm_dprintf("Connect failed (%s)\n",
2777 sm_errstring(save_errno));
2781 mci_setstat(mci, EX_TEMPFAIL, "4.4.1", NULL);
2785 #endif /* NETINET6 */
2796 #endif /* NETINET6 */
2798 /* connection ok, put it into canonical form */
2799 mci->mci_out = NULL;
2800 if ((mci->mci_out = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
2802 SM_IO_WRONLY_B, NULL)) == NULL ||
2804 (mci->mci_in = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
2806 SM_IO_RDONLY_B, NULL)) == NULL)
2809 syserr("cannot open SMTP client channel, fd=%d", s);
2810 mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
2811 if (mci->mci_out != NULL)
2812 (void) sm_io_close(mci->mci_out, SM_TIME_DEFAULT);
2817 sm_io_automode(mci->mci_out, mci->mci_in);
2819 /* set {client_flags} */
2820 if (ClientSettings[addr.sa.sa_family].d_mflags != NULL)
2822 macdefine(&mci->mci_macro, A_PERM,
2823 macid("{client_flags}"),
2824 ClientSettings[addr.sa.sa_family].d_mflags);
2827 macdefine(&mci->mci_macro, A_PERM,
2828 macid("{client_flags}"), "");
2830 /* "add" {client_flags} to bitmap */
2831 if (bitnset(D_IFNHELO, ClientSettings[addr.sa.sa_family].d_flags))
2833 /* look for just this one flag */
2834 setbitn(D_IFNHELO, d_flags);
2837 /* find out name for Interface through which we connect */
2839 if (getsockname(s, &addr.sa, &len) == 0)
2844 macdefine(&BlankEnvelope.e_macro, A_TEMP,
2845 macid("{if_addr_out}"), anynet_ntoa(&addr));
2846 (void) sm_snprintf(family, sizeof(family), "%d",
2848 macdefine(&BlankEnvelope.e_macro, A_TEMP,
2849 macid("{if_family_out}"), family);
2851 name = hostnamebyanyaddr(&addr);
2852 macdefine(&BlankEnvelope.e_macro, A_TEMP,
2853 macid("{if_name_out}"), name);
2856 /* log connection information */
2857 sm_syslog(LOG_INFO, e->e_id,
2858 "SMTP outgoing connect on %.40s", name);
2860 if (bitnset(D_IFNHELO, d_flags))
2862 if (name[0] != '[' && strchr(name, '.') != NULL)
2863 mci->mci_heloname = newstr(name);
2868 macdefine(&BlankEnvelope.e_macro, A_PERM,
2869 macid("{if_name_out}"), NULL);
2870 macdefine(&BlankEnvelope.e_macro, A_PERM,
2871 macid("{if_addr_out}"), NULL);
2872 macdefine(&BlankEnvelope.e_macro, A_PERM,
2873 macid("{if_family_out}"), NULL);
2876 /* Use the configured HeloName as appropriate */
2877 if (HeloName != NULL && HeloName[0] != '\0')
2879 SM_FREE_CLR(mci->mci_heloname);
2880 mci->mci_heloname = newstr(HeloName);
2883 mci_setstat(mci, EX_OK, NULL, NULL);
2888 connecttimeout(ignore)
2892 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
2893 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
2898 longjmp(CtxConnectTimeout, 1);
2901 ** MAKECONNECTION_DS -- make a connection to a domain socket.
2904 ** mux_path -- the path of the socket to connect to.
2905 ** mci -- a pointer to the mail connection information
2906 ** structure to be filled in.
2909 ** An exit code telling whether the connection could be
2910 ** made and if not why not.
2918 makeconnection_ds(mux_path, mci)
2923 int rval, save_errno;
2924 long sff = SFF_SAFEDIRPATH|SFF_OPENASROOT|SFF_NOLINK|SFF_ROOTOK|SFF_EXECOK;
2925 struct sockaddr_un unix_addr;
2927 /* if not safe, don't connect */
2928 rval = safefile(mux_path, RunAsUid, RunAsGid, RunAsUserName,
2929 sff, S_IRUSR|S_IWUSR, NULL);
2933 syserr("makeconnection_ds: unsafe domain socket %s",
2935 mci_setstat(mci, EX_TEMPFAIL, "4.3.5", NULL);
2940 /* prepare address structure */
2941 memset(&unix_addr, '\0', sizeof(unix_addr));
2942 unix_addr.sun_family = AF_UNIX;
2944 if (strlen(mux_path) >= sizeof(unix_addr.sun_path))
2946 syserr("makeconnection_ds: domain socket name %s too long",
2949 /* XXX why TEMPFAIL but 5.x.y ? */
2950 mci_setstat(mci, EX_TEMPFAIL, "5.3.5", NULL);
2951 errno = ENAMETOOLONG;
2952 return EX_UNAVAILABLE;
2954 (void) sm_strlcpy(unix_addr.sun_path, mux_path,
2955 sizeof(unix_addr.sun_path));
2957 /* initialize domain socket */
2958 sock = socket(AF_UNIX, SOCK_STREAM, 0);
2962 syserr("makeconnection_ds: could not create domain socket %s",
2964 mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
2969 /* connect to server */
2970 if (connect(sock, (struct sockaddr *) &unix_addr,
2971 sizeof(unix_addr)) == -1)
2974 syserr("Could not connect to socket %s", mux_path);
2975 mci_setstat(mci, EX_TEMPFAIL, "4.4.1", NULL);
2981 /* connection ok, put it into canonical form */
2982 mci->mci_out = NULL;
2983 if ((mci->mci_out = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
2984 (void *) &sock, SM_IO_WRONLY_B, NULL))
2986 || (sock = dup(sock)) < 0 ||
2987 (mci->mci_in = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
2988 (void *) &sock, SM_IO_RDONLY_B, NULL))
2992 syserr("cannot open SMTP client channel, fd=%d", sock);
2993 mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
2994 if (mci->mci_out != NULL)
2995 (void) sm_io_close(mci->mci_out, SM_TIME_DEFAULT);
3000 sm_io_automode(mci->mci_out, mci->mci_in);
3002 mci_setstat(mci, EX_OK, NULL, NULL);
3006 #endif /* NETUNIX */
3008 ** SHUTDOWN_DAEMON -- Performs a clean shutdown of the daemon
3017 ** closes control socket, exits.
3026 sm_allsignals(true);
3028 reason = ShutdownRequest;
3029 ShutdownRequest = NULL;
3033 sm_syslog(LOG_INFO, CurEnv->e_id, "stopping daemon, reason=%s",
3034 reason == NULL ? "implicit call" : reason);
3037 closecontrolsocket(true);
3042 for (i = 0; i < NDaemons; i++)
3044 if (Daemons[i].d_socket >= 0)
3046 (void) close(Daemons[i].d_socket);
3047 Daemons[i].d_socket = -1;
3049 #if _FFR_DAEMON_NETUNIX
3051 /* Remove named sockets */
3052 if (Daemons[i].d_addr.sa.sa_family == AF_UNIX)
3055 long sff = SFF_SAFEDIRPATH|SFF_OPENASROOT|SFF_NOLINK|SFF_MUSTOWN|SFF_EXECOK|SFF_CREAT;
3057 /* if not safe, don't use it */
3058 rval = safefile(Daemons[i].d_addr.sunix.sun_path,
3061 S_IRUSR|S_IWUSR, NULL);
3063 unlink(Daemons[i].d_addr.sunix.sun_path) < 0)
3065 sm_syslog(LOG_WARNING, NOQID,
3066 "Could not remove daemon %s socket: %s: %s",
3068 Daemons[i].d_addr.sunix.sun_path,
3069 sm_errstring(errno));
3072 # endif /* NETUNIX */
3073 #endif /* _FFR_DAEMON_NETUNIX */
3077 finis(false, true, EX_OK);
3080 ** RESTART_DAEMON -- Performs a clean restart of the daemon
3089 ** restarts the daemon or exits if restart fails.
3092 /* Make a non-DFL/IGN signal a noop */
3093 #define SM_NOOP_SIGNAL(sig, old) \
3096 (old) = sm_signal((sig), sm_signal_noop); \
3097 if ((old) == SIG_IGN || (old) == SIG_DFL) \
3098 (void) sm_signal((sig), (old)); \
3107 sigfunc_t ignore, oalrm, ousr1;
3108 extern int DtableSize;
3110 /* clear the events to turn off SIGALRMs */
3112 sm_allsignals(true);
3114 reason = RestartRequest;
3115 RestartRequest = NULL;
3118 if (SaveArgv[0][0] != '/')
3121 sm_syslog(LOG_INFO, NOQID,
3122 "could not restart: need full path");
3123 finis(false, true, EX_OSFILE);
3127 sm_syslog(LOG_INFO, NOQID, "restarting %s due to %s",
3129 reason == NULL ? "implicit call" : reason);
3131 closecontrolsocket(true);
3133 cleanup_shm(DaemonPid == getpid());
3134 #endif /* SM_CONF_SHM */
3136 /* close locked pid file */
3137 close_sendmail_pid();
3140 ** Want to drop to the user who started the process in all cases
3141 ** *but* when running as "smmsp" for the clientmqueue queue run
3142 ** daemon. In that case, UseMSP will be true, RunAsUid should not
3143 ** be root, and RealUid should be either 0 or RunAsUid.
3146 drop = !(UseMSP && RunAsUid != 0 &&
3147 (RealUid == 0 || RealUid == RunAsUid));
3149 if (drop_privileges(drop) != EX_OK)
3152 sm_syslog(LOG_ALERT, NOQID,
3153 "could not drop privileges: %s",
3154 sm_errstring(errno));
3155 finis(false, true, EX_OSERR);
3159 sm_close_on_exec(STDERR_FILENO + 1, DtableSize);
3162 ** Need to allow signals before execve() to make them "harmless".
3163 ** However, the default action can be "terminate", so it isn't
3164 ** really harmless. Setting signals to IGN will cause them to be
3165 ** ignored in the new process to, so that isn't a good alternative.
3168 SM_NOOP_SIGNAL(SIGALRM, oalrm);
3169 SM_NOOP_SIGNAL(SIGCHLD, ignore);
3170 SM_NOOP_SIGNAL(SIGHUP, ignore);
3171 SM_NOOP_SIGNAL(SIGINT, ignore);
3172 SM_NOOP_SIGNAL(SIGPIPE, ignore);
3173 SM_NOOP_SIGNAL(SIGTERM, ignore);
3175 SM_NOOP_SIGNAL(SIGUSR1, ousr1);
3176 #endif /* SIGUSR1 */
3178 /* Turn back on signals */
3179 sm_allsignals(false);
3181 (void) execve(SaveArgv[0], (ARGV_T) SaveArgv, (ARGV_T) ExternalEnviron);
3184 /* block signals again and restore needed signals */
3185 sm_allsignals(true);
3187 /* For finis() events */
3188 (void) sm_signal(SIGALRM, oalrm);
3191 /* For debugging finis() */
3192 (void) sm_signal(SIGUSR1, ousr1);
3193 #endif /* SIGUSR1 */
3197 sm_syslog(LOG_ALERT, NOQID, "could not exec %s: %s",
3198 SaveArgv[0], sm_errstring(errno));
3199 finis(false, true, EX_OSFILE);
3203 ** MYHOSTNAME -- return the name of this host.
3206 ** hostbuf -- a place to return the name of this host.
3207 ** size -- the size of hostbuf.
3210 ** A list of aliases for this host.
3213 ** Adds numeric codes to $=w.
3217 myhostname(hostbuf, size)
3221 register struct hostent *hp;
3223 if (gethostname(hostbuf, size) < 0 || hostbuf[0] == '\0')
3224 (void) sm_strlcpy(hostbuf, "localhost", size);
3225 hp = sm_gethostbyname(hostbuf, InetMode);
3226 #if NETINET && NETINET6
3227 if (hp == NULL && InetMode == AF_INET6)
3230 ** It's possible that this IPv6 enabled machine doesn't
3231 ** actually have any IPv6 interfaces and, therefore, no
3232 ** IPv6 addresses. Fall back to AF_INET.
3235 hp = sm_gethostbyname(hostbuf, AF_INET);
3237 #endif /* NETINET && NETINET6 */
3240 if (strchr(hp->h_name, '.') != NULL || strchr(hostbuf, '.') == NULL)
3241 (void) cleanstrcpy(hostbuf, hp->h_name, size);
3244 if (strchr(hostbuf, '.') == NULL)
3248 domainname = ni_propval("/locations", NULL, "resolver",
3250 if (domainname != NULL &&
3251 strlen(domainname) + strlen(hostbuf) + 1 < size)
3252 (void) sm_strlcat2(hostbuf, ".", domainname, size);
3254 #endif /* NETINFO */
3257 ** If there is still no dot in the name, try looking for a
3261 if (strchr(hostbuf, '.') == NULL)
3265 for (ha = hp->h_aliases; ha != NULL && *ha != NULL; ha++)
3267 if (strchr(*ha, '.') != NULL)
3269 (void) cleanstrcpy(hostbuf, *ha, size - 1);
3270 hostbuf[size - 1] = '\0';
3277 ** If _still_ no dot, wait for a while and try again -- it is
3278 ** possible that some service is starting up. This can result
3279 ** in excessive delays if the system is badly configured, but
3280 ** there really isn't a way around that, particularly given that
3281 ** the config file hasn't been read at this point.
3282 ** All in all, a bit of a mess.
3285 if (strchr(hostbuf, '.') == NULL &&
3286 !getcanonname(hostbuf, size, true, NULL))
3288 sm_syslog(LocalDaemon ? LOG_WARNING : LOG_CRIT, NOQID,
3289 "My unqualified host name (%s) unknown; sleeping for retry",
3291 message("My unqualified host name (%s) unknown; sleeping for retry",
3294 if (!getcanonname(hostbuf, size, true, NULL))
3296 sm_syslog(LocalDaemon ? LOG_WARNING : LOG_ALERT, NOQID,
3297 "unable to qualify my own domain name (%s) -- using short name",
3299 message("WARNING: unable to qualify my own domain name (%s) -- using short name",
3306 ** ADDRCMP -- compare two host addresses
3309 ** hp -- hostent structure for the first address
3310 ** ha -- actual first address
3311 ** sa -- second address
3314 ** 0 -- if ha and sa match
3315 ** else -- they don't match
3326 #endif /* NETINET6 */
3328 switch (sa->sa.sa_family)
3332 if (hp->h_addrtype == AF_INET)
3333 return memcmp(ha, (char *) &sa->sin.sin_addr, INADDRSZ);
3335 #endif /* NETINET */
3339 a = (unsigned char *) &sa->sin6.sin6_addr;
3341 /* Straight binary comparison */
3342 if (hp->h_addrtype == AF_INET6)
3343 return memcmp(ha, a, IN6ADDRSZ);
3345 /* If IPv4-mapped IPv6 address, compare the IPv4 section */
3346 if (hp->h_addrtype == AF_INET &&
3347 IN6_IS_ADDR_V4MAPPED(&sa->sin6.sin6_addr))
3348 return memcmp(a + IN6ADDRSZ - INADDRSZ, ha, INADDRSZ);
3350 #endif /* NETINET6 */
3355 ** GETAUTHINFO -- get the real host name associated with a file descriptor
3357 ** Uses RFC1413 protocol to try to get info from the other end.
3360 ** fd -- the descriptor
3361 ** may_be_forged -- an outage that is set to true if the
3362 ** forward lookup of RealHostName does not match
3363 ** RealHostAddr; set to false if they do match.
3366 ** The user@host information associated with this descriptor.
3369 static jmp_buf CtxAuthTimeout;
3376 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
3377 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
3382 longjmp(CtxAuthTimeout, 1);
3386 getauthinfo(fd, may_be_forged)
3388 bool *may_be_forged;
3390 unsigned short SM_NONVOLATILE port = 0;
3391 SOCKADDR_LEN_T falen;
3392 register char *volatile p = NULL;
3394 SOCKADDR_LEN_T lalen;
3395 #ifndef NO_GETSERVBYNAME
3396 register struct servent *sp;
3398 static unsigned short port4 = 0;
3399 # endif /* NETINET */
3401 static unsigned short port6 = 0;
3402 # endif /* NETINET6 */
3403 #endif /* ! NO_GETSERVBYNAME */
3410 char *ostype = NULL;
3412 char ibuf[MAXNAME + 1];
3413 static char hbuf[MAXNAME + MAXAUTHINFO + 11];
3415 *may_be_forged = false;
3416 falen = sizeof(RealHostAddr);
3417 if (isatty(fd) || (i = getpeername(fd, &RealHostAddr.sa, &falen)) < 0 ||
3418 falen <= 0 || RealHostAddr.sa.sa_family == 0)
3423 ** ENOTSOCK is OK: bail on anything else, but reset
3424 ** errno in this case, so a mis-report doesn't
3428 if (errno != ENOTSOCK)
3432 (void) sm_strlcpyn(hbuf, sizeof(hbuf), 2, RealUserName,
3435 sm_dprintf("getauthinfo: %s\n", hbuf);
3439 if (RealHostName == NULL)
3441 /* translate that to a host name */
3442 RealHostName = newstr(hostnamebyanyaddr(&RealHostAddr));
3443 if (strlen(RealHostName) > MAXNAME)
3444 RealHostName[MAXNAME] = '\0'; /* XXX - 1 ? */
3447 /* cross check RealHostName with forward DNS lookup */
3448 if (anynet_ntoa(&RealHostAddr)[0] != '[' &&
3449 RealHostName[0] != '[')
3453 family = RealHostAddr.sa.sa_family;
3454 #if NETINET6 && NEEDSGETIPNODE
3456 ** If RealHostAddr is an IPv6 connection with an
3457 ** IPv4-mapped address, we need RealHostName's IPv4
3458 ** address(es) for addrcmp() to compare against
3461 ** Actually, we only need to do this for systems
3462 ** which NEEDSGETIPNODE since the real getipnodebyname()
3463 ** already does V4MAPPED address via the AI_V4MAPPEDCFG
3464 ** flag. A better fix to this problem is to add this
3465 ** functionality to our stub getipnodebyname().
3468 if (family == AF_INET6 &&
3469 IN6_IS_ADDR_V4MAPPED(&RealHostAddr.sin6.sin6_addr))
3471 #endif /* NETINET6 && NEEDSGETIPNODE */
3473 /* try to match the reverse against the forward lookup */
3474 hp = sm_gethostbyname(RealHostName, family);
3477 /* XXX: Could be a temporary error on forward lookup */
3478 *may_be_forged = true;
3482 for (ha = hp->h_addr_list; *ha != NULL; ha++)
3484 if (addrcmp(hp, *ha, &RealHostAddr) == 0)
3487 *may_be_forged = *ha == NULL;
3491 #endif /* NETINET6 */
3495 if (TimeOuts.to_ident == 0)
3499 switch (RealHostAddr.sa.sa_family)
3503 if (getsockname(fd, &la.sa, &lalen) < 0 ||
3505 la.sa.sa_family != AF_INET)
3510 port = RealHostAddr.sin.sin_port;
3512 /* create ident query */
3513 (void) sm_snprintf(ibuf, sizeof(ibuf), "%d,%d\r\n",
3514 ntohs(RealHostAddr.sin.sin_port),
3515 ntohs(la.sin.sin_port));
3517 /* create local address */
3518 la.sin.sin_port = 0;
3520 /* create foreign address */
3521 # ifdef NO_GETSERVBYNAME
3522 RealHostAddr.sin.sin_port = htons(113);
3523 # else /* NO_GETSERVBYNAME */
3526 ** getservbyname() consumes about 5% of the time
3527 ** when receiving a small message (almost all of the time
3528 ** spent in this routine).
3529 ** Hence we store the port in a static variable
3530 ** to save this time.
3531 ** The portnumber shouldn't change very often...
3532 ** This code makes the assumption that the port number
3538 sp = getservbyname("auth", "tcp");
3544 RealHostAddr.sin.sin_port = port4;
3546 # endif /* NO_GETSERVBYNAME */
3547 #endif /* NETINET */
3551 if (getsockname(fd, &la.sa, &lalen) < 0 ||
3553 la.sa.sa_family != AF_INET6)
3558 port = RealHostAddr.sin6.sin6_port;
3560 /* create ident query */
3561 (void) sm_snprintf(ibuf, sizeof(ibuf), "%d,%d\r\n",
3562 ntohs(RealHostAddr.sin6.sin6_port),
3563 ntohs(la.sin6.sin6_port));
3565 /* create local address */
3566 la.sin6.sin6_port = 0;
3568 /* create foreign address */
3569 # ifdef NO_GETSERVBYNAME
3570 RealHostAddr.sin6.sin6_port = htons(113);
3571 # else /* NO_GETSERVBYNAME */
3574 sp = getservbyname("auth", "tcp");
3580 RealHostAddr.sin6.sin6_port = port6;
3582 # endif /* NO_GETSERVBYNAME */
3583 #endif /* NETINET6 */
3590 if (setjmp(CtxAuthTimeout) != 0)
3597 /* put a timeout around the whole thing */
3598 ev = sm_setevent(TimeOuts.to_ident, authtimeout, 0);
3600 /* connect to foreign IDENT server using same address as SMTP socket */
3601 s = socket(la.sa.sa_family, SOCK_STREAM, 0);
3607 if (bind(s, &la.sa, lalen) < 0 ||
3608 connect(s, &RealHostAddr.sa, lalen) < 0)
3612 sm_dprintf("getauthinfo: sent %s", ibuf);
3615 if (write(s, ibuf, strlen(ibuf)) < 0)
3620 nleft = sizeof(ibuf) - 1;
3621 while ((i = read(s, p, nleft)) > 0)
3628 if ((s = strchr(ibuf, '\n')) != NULL)
3642 if (i < 0 || p == &ibuf[0])
3645 if (p >= &ibuf[2] && *--p == '\n' && *--p == '\r')
3650 sm_dprintf("getauthinfo: got %s\n", ibuf);
3653 p = strchr(ibuf, ':');
3656 /* malformed response */
3659 while (isascii(*++p) && isspace(*p))
3661 if (sm_strncasecmp(p, "userid", 6) != 0)
3663 /* presumably an error string */
3667 while (isascii(*p) && isspace(*p))
3671 /* either useridxx or malformed response */
3675 /* p now points to the OSTYPE field */
3676 while (isascii(*p) && isspace(*p))
3682 /* malformed response */
3690 charset = strchr(ostype, ',');
3691 if (charset != NULL)
3695 /* 1413 says don't do this -- but it's broken otherwise */
3696 while (isascii(*++p) && isspace(*p))
3699 /* p now points to the authenticated name -- copy carefully */
3700 if (sm_strncasecmp(ostype, "other", 5) == 0 &&
3701 (ostype[5] == ' ' || ostype[5] == '\0'))
3703 (void) sm_strlcpy(hbuf, "IDENT:", sizeof(hbuf));
3704 cleanstrcpy(&hbuf[6], p, MAXAUTHINFO);
3707 cleanstrcpy(hbuf, p, MAXAUTHINFO);
3709 (void) sm_strlcpyn(&hbuf[len], sizeof(hbuf) - len, 2, "@",
3710 RealHostName == NULL ? "localhost" : RealHostName);
3718 /* put back the original incoming port */
3719 switch (RealHostAddr.sa.sa_family)
3724 RealHostAddr.sin.sin_port = port;
3726 #endif /* NETINET */
3731 RealHostAddr.sin6.sin6_port = port;
3733 #endif /* NETINET6 */
3736 if (RealHostName == NULL)
3739 sm_dprintf("getauthinfo: NULL\n");
3742 (void) sm_strlcpy(hbuf, RealHostName, sizeof(hbuf));
3746 # ifndef GET_IPOPT_DST
3747 # define GET_IPOPT_DST(dst) (dst)
3748 # endif /* ! GET_IPOPT_DST */
3750 ** Extract IP source routing information.
3752 ** Format of output for a connection from site a through b
3754 ** loose: @site-c@site-b:site-a
3755 ** strict: !@site-c@site-b:site-a
3757 ** o - pointer within ipopt_list structure.
3758 ** q - pointer within ls/ss rr route data
3759 ** p - pointer to hbuf
3762 if (RealHostAddr.sa.sa_family == AF_INET)
3764 SOCKOPT_LEN_T ipoptlen;
3769 struct IPOPTION ipopt;
3771 ipoptlen = sizeof(ipopt);
3772 if (getsockopt(fd, IPPROTO_IP, IP_OPTIONS,
3773 (char *) &ipopt, &ipoptlen) < 0)
3777 o = (unsigned char *) ipopt.IP_LIST;
3778 while (o != NULL && o < (unsigned char *) &ipopt + ipoptlen)
3794 ** o[0] is the option type (loose/strict).
3795 ** o[1] is the length of this option,
3796 ** including option type and
3798 ** o[2] is the pointer into the route
3800 ** o[3] begins the route data.
3803 p = &hbuf[strlen(hbuf)];
3804 l = sizeof(hbuf) - (hbuf - p) - 6;
3805 (void) sm_snprintf(p, SPACELEFT(hbuf, p),
3807 *o == IPOPT_SSRR ? "!" : "",
3808 l > 240 ? 120 : l / 2,
3809 inet_ntoa(GET_IPOPT_DST(ipopt.IP_DST)));
3814 j = o[1] / sizeof(struct in_addr) - 1;
3816 /* q skips length and router pointer to data */
3818 for ( ; j >= 0; j--)
3820 struct in_addr addr;
3822 memcpy(&addr, q, sizeof(addr));
3823 (void) sm_snprintf(p,
3833 q += sizeof(struct in_addr);
3839 /* Skip over option */
3844 (void) sm_snprintf(p, SPACELEFT(hbuf, p), "]");
3849 #endif /* IP_SRCROUTE */
3850 if (RealHostName != NULL && RealHostName[0] != '[')
3852 p = &hbuf[strlen(hbuf)];
3853 (void) sm_snprintf(p, SPACELEFT(hbuf, p), " [%.100s]",
3854 anynet_ntoa(&RealHostAddr));
3858 p = &hbuf[strlen(hbuf)];
3859 (void) sm_strlcpy(p, " (may be forged)", SPACELEFT(hbuf, p));
3860 macdefine(&BlankEnvelope.e_macro, A_PERM,
3861 macid("{client_resolve}"), "FORGED");
3866 #endif /* IP_SRCROUTE */
3868 /* put back the original incoming port */
3869 switch (RealHostAddr.sa.sa_family)
3874 RealHostAddr.sin.sin_port = port;
3876 #endif /* NETINET */
3881 RealHostAddr.sin6.sin6_port = port;
3883 #endif /* NETINET6 */
3887 sm_dprintf("getauthinfo: %s\n", hbuf);
3891 ** HOST_MAP_LOOKUP -- turn a hostname into canonical form
3894 ** map -- a pointer to this map.
3895 ** name -- the (presumably unqualified) hostname.
3896 ** av -- unused -- for compatibility with other mapping
3898 ** statp -- an exit status (out parameter) -- set to
3899 ** EX_TEMPFAIL if the name server is unavailable.
3902 ** The mapping, if found.
3903 ** NULL if no mapping found.
3906 ** Looks up the host specified in hbuf. If it is not
3907 ** the canonical name for that host, return the canonical
3908 ** name (unless MF_MATCHONLY is set, which will cause the
3909 ** status only to be returned).
3913 host_map_lookup(map, name, av, statp)
3919 register struct hostent *hp;
3921 struct in_addr in_addr;
3922 #endif /* NETINET */
3924 struct in6_addr in6_addr;
3925 #endif /* NETINET6 */
3926 char *cp, *ans = NULL;
3930 time_t SM_NONVOLATILE retrans = 0;
3931 int SM_NONVOLATILE retry = 0;
3932 #endif /* NAMED_BIND */
3933 char hbuf[MAXNAME + 1];
3936 ** See if we have already looked up this name. If so, just
3937 ** return it (unless expired).
3941 s = stab(name, ST_NAMECANON, ST_ENTER);
3942 if (bitset(NCF_VALID, s->s_namecanon.nc_flags) &&
3943 s->s_namecanon.nc_exp >= now)
3946 sm_dprintf("host_map_lookup(%s) => CACHE %s\n",
3948 s->s_namecanon.nc_cname == NULL
3950 : s->s_namecanon.nc_cname);
3951 errno = s->s_namecanon.nc_errno;
3952 SM_SET_H_ERRNO(s->s_namecanon.nc_herrno);
3953 *statp = s->s_namecanon.nc_stat;
3954 if (*statp == EX_TEMPFAIL)
3956 CurEnv->e_status = "4.4.3";
3957 message("851 %s: Name server timeout",
3958 shortenstring(name, 33));
3960 if (*statp != EX_OK)
3962 if (s->s_namecanon.nc_cname == NULL)
3964 syserr("host_map_lookup(%s): bogus NULL cache entry, errno=%d, h_errno=%d",
3966 s->s_namecanon.nc_errno,
3967 s->s_namecanon.nc_herrno);
3970 if (bitset(MF_MATCHONLY, map->map_mflags))
3971 cp = map_rewrite(map, name, strlen(name), NULL);
3973 cp = map_rewrite(map,
3974 s->s_namecanon.nc_cname,
3975 strlen(s->s_namecanon.nc_cname),
3981 ** If we are running without a regular network connection (usually
3982 ** dial-on-demand) and we are just queueing, we want to avoid DNS
3983 ** lookups because those could try to connect to a server.
3986 if (CurEnv->e_sendmode == SM_DEFER &&
3987 bitset(MF_DEFER, map->map_mflags))
3990 sm_dprintf("host_map_lookup(%s) => DEFERRED\n", name);
3991 *statp = EX_TEMPFAIL;
3996 ** If first character is a bracket, then it is an address
3997 ** lookup. Address is copied into a temporary buffer to
3998 ** strip the brackets and to preserve name if address is
4003 sm_dprintf("host_map_lookup(%s) => ", name);
4005 if (map->map_timeout > 0)
4007 retrans = _res.retrans;
4008 _res.retrans = map->map_timeout;
4010 if (map->map_retry > 0)
4013 _res.retry = map->map_retry;
4015 #endif /* NAMED_BIND */
4017 /* set default TTL */
4018 s->s_namecanon.nc_exp = now + SM_DEFAULT_TTL;
4023 (void) sm_strlcpy(hbuf, name, sizeof(hbuf));
4024 if (getcanonname(hbuf, sizeof(hbuf) - 1, !HasWildcardMX, &ttl))
4028 s->s_namecanon.nc_exp = now + SM_MIN(ttl,
4034 if ((cp = strchr(name, ']')) == NULL)
4037 sm_dprintf("FAILED\n");
4044 if ((in_addr.s_addr = inet_addr(&name[1])) != INADDR_NONE)
4045 hp = sm_gethostbyaddr((char *)&in_addr,
4047 #endif /* NETINET */
4050 anynet_pton(AF_INET6, &name[1], &in6_addr) == 1)
4051 hp = sm_gethostbyaddr((char *)&in6_addr,
4052 IN6ADDRSZ, AF_INET6);
4053 #endif /* NETINET6 */
4058 /* found a match -- copy out */
4059 ans = denlstring((char *) hp->h_name, true, true);
4061 if (ans == hp->h_name)
4063 static char n[MAXNAME + 1];
4065 /* hp->h_name is about to disappear */
4066 (void) sm_strlcpy(n, ans, sizeof(n));
4071 #endif /* NETINET6 */
4075 if (map->map_timeout > 0)
4076 _res.retrans = retrans;
4077 if (map->map_retry > 0)
4079 #endif /* NAMED_BIND */
4081 s->s_namecanon.nc_flags |= NCF_VALID; /* will be soon */
4083 /* Found an answer */
4086 s->s_namecanon.nc_stat = *statp = EX_OK;
4087 if (s->s_namecanon.nc_cname != NULL)
4088 sm_free(s->s_namecanon.nc_cname);
4089 s->s_namecanon.nc_cname = sm_strdup_x(ans);
4090 if (bitset(MF_MATCHONLY, map->map_mflags))
4091 cp = map_rewrite(map, name, strlen(name), NULL);
4093 cp = map_rewrite(map, ans, strlen(ans), av);
4095 sm_dprintf("FOUND %s\n", ans);
4100 /* No match found */
4101 s->s_namecanon.nc_errno = errno;
4103 s->s_namecanon.nc_herrno = h_errno;
4105 sm_dprintf("FAIL (%d)\n", h_errno);
4111 CurEnv->e_status = "4.4.3";
4112 message("851 %s: Name server timeout",
4113 shortenstring(name, 33));
4115 *statp = EX_TEMPFAIL;
4118 case HOST_NOT_FOUND:
4124 *statp = EX_SOFTWARE;
4128 *statp = EX_UNAVAILABLE;
4131 #else /* NAMED_BIND */
4133 sm_dprintf("FAIL\n");
4135 #endif /* NAMED_BIND */
4136 s->s_namecanon.nc_stat = *statp;
4140 ** HOST_MAP_INIT -- initialize host class structures
4143 ** map -- a pointer to this map.
4144 ** args -- argument string.
4151 host_map_init(map, args)
4155 register char *p = args;
4159 while (isascii(*p) && isspace(*p))
4170 map->map_tapp = ++p;
4174 map->map_mflags |= MF_MATCHONLY;
4178 map->map_mflags |= MF_NODEFER;
4181 case 'S': /* only for consistency */
4182 map->map_spacesub = *++p;
4186 map->map_mflags |= MF_DEFER;
4193 while (isascii(*++p) && isspace(*p))
4198 map->map_timeout = convtime(p, 's');
4205 while (isascii(*++p) && isspace(*p))
4207 map->map_retry = atoi(p);
4210 while (*p != '\0' && !(isascii(*p) && isspace(*p)))
4215 if (map->map_app != NULL)
4216 map->map_app = newstr(map->map_app);
4217 if (map->map_tapp != NULL)
4218 map->map_tapp = newstr(map->map_tapp);
4224 ** ANYNET_NTOP -- convert an IPv6 network address to printable form.
4227 ** s6a -- a pointer to an in6_addr structure.
4228 ** dst -- buffer to store result in
4229 ** dst_len -- size of dst buffer
4232 ** A printable version of that structure.
4236 anynet_ntop(s6a, dst, dst_len)
4237 struct in6_addr *s6a;
4243 if (IN6_IS_ADDR_V4MAPPED(s6a))
4244 ap = (char *) inet_ntop(AF_INET,
4245 &s6a->s6_addr[IN6ADDRSZ - INADDRSZ],
4252 /* Save pointer to beginning of string */
4255 /* Add IPv6: protocol tag */
4256 sz = sm_strlcpy(dst, "IPv6:", dst_len);
4261 ap = (char *) inet_ntop(AF_INET6, s6a, dst, dst_len);
4263 /* Restore pointer to beginning of string */
4271 ** ANYNET_PTON -- convert printed form to network address.
4273 ** Wrapper for inet_pton() which handles IPv6: labels.
4276 ** family -- address family
4278 ** dst -- destination address structure
4281 ** 1 if the address was valid
4282 ** 0 if the address wasn't parseable
4287 anynet_pton(family, src, dst)
4292 if (family == AF_INET6 && sm_strncasecmp(src, "IPv6:", 5) == 0)
4294 return inet_pton(family, src, dst);
4296 #endif /* NETINET6 */
4298 ** ANYNET_NTOA -- convert a network address to printable form.
4301 ** sap -- a pointer to a sockaddr structure.
4304 ** A printable version of that sockaddr.
4307 #ifdef USE_SOCK_STREAM
4310 # include <net/if_dl.h>
4311 # endif /* NETLINK */
4315 register SOCKADDR *sap;
4320 static char buf[100];
4322 /* check for null/zero family */
4325 if (sap->sa.sa_family == 0)
4328 switch (sap->sa.sa_family)
4332 if (sap->sunix.sun_path[0] != '\0')
4333 (void) sm_snprintf(buf, sizeof(buf), "[UNIX: %.64s]",
4334 sap->sunix.sun_path);
4336 (void) sm_strlcpy(buf, "[UNIX: localhost]", sizeof(buf));
4338 # endif /* NETUNIX */
4342 return (char *) inet_ntoa(sap->sin.sin_addr);
4343 # endif /* NETINET */
4347 ap = anynet_ntop(&sap->sin6.sin6_addr, buf, sizeof(buf));
4351 # endif /* NETINET6 */
4355 (void) sm_snprintf(buf, sizeof(buf), "[LINK: %s]",
4356 link_ntoa((struct sockaddr_dl *) &sap->sa));
4358 # endif /* NETLINK */
4360 /* this case is needed when nothing is #defined */
4361 /* in order to keep the switch syntactically correct */
4365 /* unknown family -- just dump bytes */
4366 (void) sm_snprintf(buf, sizeof(buf), "Family %d: ", sap->sa.sa_family);
4367 bp = &buf[strlen(buf)];
4368 ap = sap->sa.sa_data;
4369 for (l = sizeof(sap->sa.sa_data); --l >= 0; )
4371 (void) sm_snprintf(bp, SPACELEFT(buf, bp), "%02x:",
4379 ** HOSTNAMEBYANYADDR -- return name of host based on address
4382 ** sap -- SOCKADDR pointer
4385 ** text representation of host name.
4392 hostnamebyanyaddr(sap)
4393 register SOCKADDR *sap;
4395 register struct hostent *hp;
4398 # endif /* NAMED_BIND */
4400 struct in6_addr in6_addr;
4401 # endif /* NETINET6 */
4404 /* shorten name server timeout to avoid higher level timeouts */
4405 saveretry = _res.retry;
4406 if (_res.retry * _res.retrans > 20)
4407 _res.retry = 20 / _res.retrans;
4408 # endif /* NAMED_BIND */
4410 switch (sap->sa.sa_family)
4414 hp = sm_gethostbyaddr((char *) &sap->sin.sin_addr,
4417 # endif /* NETINET */
4421 hp = sm_gethostbyaddr((char *) &sap->sin6.sin6_addr,
4422 IN6ADDRSZ, AF_INET6);
4424 # endif /* NETINET6 */
4428 hp = sm_gethostbyaddr((char *) &sap->siso.siso_addr,
4429 sizeof(sap->siso.siso_addr), AF_ISO);
4431 # endif /* NETISO */
4437 # endif /* NETUNIX */
4440 hp = sm_gethostbyaddr(sap->sa.sa_data, sizeof(sap->sa.sa_data),
4446 _res.retry = saveretry;
4447 # endif /* NAMED_BIND */
4449 # if NETINET || NETINET6
4450 if (hp != NULL && hp->h_name[0] != '['
4452 && inet_pton(AF_INET6, hp->h_name, &in6_addr) != 1
4453 # endif /* NETINET6 */
4455 && inet_addr(hp->h_name) == INADDR_NONE
4456 # endif /* NETINET */
4461 name = denlstring((char *) hp->h_name, true, true);
4463 if (name == hp->h_name)
4465 static char n[MAXNAME + 1];
4467 /* Copy the string, hp->h_name is about to disappear */
4468 (void) sm_strlcpy(n, name, sizeof(n));
4472 # endif /* NETINET6 */
4475 # endif /* NETINET || NETINET6 */
4483 # endif /* NETINET6 */
4486 if (sap->sa.sa_family == AF_UNIX && sap->sunix.sun_path[0] == '\0')
4488 # endif /* NETUNIX */
4490 static char buf[203];
4492 (void) sm_snprintf(buf, sizeof(buf), "[%.200s]",
4497 #endif /* USE_SOCK_STREAM */