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