2 * ntp_io.c - input/output routines for ntpd. The socket-opening code
3 * was shamelessly stolen from ntpd.
14 # if !defined(FNM_CASEFOLD) && defined(FNM_IGNORECASE)
15 # define FNM_CASEFOLD FNM_IGNORECASE
18 #ifdef HAVE_SYS_PARAM_H
19 # include <sys/param.h>
21 #ifdef HAVE_SYS_IOCTL_H
22 # include <sys/ioctl.h>
24 #ifdef HAVE_SYS_SOCKIO_H /* UXPV: SIOC* #defines (Frank Vance <fvance@waii.com>) */
25 # include <sys/sockio.h>
31 #include "ntp_machine.h"
35 #include "ntp_lists.h"
36 #include "ntp_refclock.h"
37 #include "ntp_stdlib.h"
38 #include "ntp_worker.h"
39 #include "ntp_request.h"
40 #include "ntp_assert.h"
41 #include "timevalops.h"
42 #include "timespecops.h"
43 #include "ntpd-opts.h"
46 /* Don't include ISC's version of IPv6 variables and structures */
49 #include <isc/interfaceiter.h>
50 #include <isc/netaddr.h>
51 #include <isc/result.h>
52 #include <isc/sockaddr.h>
58 #ifdef HAS_ROUTING_SOCKET
59 # include <net/route.h>
60 # ifdef HAVE_RTNETLINK
61 # include <linux/rtnetlink.h>
66 * setsockopt does not always have the same arg declaration
67 * across all platforms. If it's not defined we make it empty
70 #ifndef SETSOCKOPT_ARG_CAST
71 #define SETSOCKOPT_ARG_CAST
74 extern int listen_to_virtual_ips;
77 #define IPTOS_DSCP_EF 0xb8
79 int qos = IPTOS_DSCP_EF; /* QoS RFC3246 */
82 /* TODO burnicki: This should be moved to ntp_timer.c, but if we do so
83 * we get a linker error. Since we're running out of time before the leap
84 * second occurs, we let it here where it just works.
92 typedef struct nic_rule_tag nic_rule;
96 nic_rule_action action;
97 nic_rule_match match_type;
104 * NIC rule listhead. Entries are added at the head so that the first
105 * match in the list is the last matching rule specified.
107 nic_rule *nic_rule_list;
110 #if defined(SO_BINTIME) && defined(SCM_BINTIME) && defined(CMSG_FIRSTHDR)
111 # define HAVE_PACKET_TIMESTAMP
112 # define HAVE_BINTIME
113 # ifdef BINTIME_CTLMSGBUF_SIZE
114 # define CMSG_BUFSIZE BINTIME_CTLMSGBUF_SIZE
116 # define CMSG_BUFSIZE 1536 /* moderate default */
118 #elif defined(SO_TIMESTAMPNS) && defined(SCM_TIMESTAMPNS) && defined(CMSG_FIRSTHDR)
119 # define HAVE_PACKET_TIMESTAMP
120 # define HAVE_TIMESTAMPNS
121 # ifdef TIMESTAMPNS_CTLMSGBUF_SIZE
122 # define CMSG_BUFSIZE TIMESTAMPNS_CTLMSGBUF_SIZE
124 # define CMSG_BUFSIZE 1536 /* moderate default */
126 #elif defined(SO_TIMESTAMP) && defined(SCM_TIMESTAMP) && defined(CMSG_FIRSTHDR)
127 # define HAVE_PACKET_TIMESTAMP
128 # define HAVE_TIMESTAMP
129 # ifdef TIMESTAMP_CTLMSGBUF_SIZE
130 # define CMSG_BUFSIZE TIMESTAMP_CTLMSGBUF_SIZE
132 # define CMSG_BUFSIZE 1536 /* moderate default */
135 /* fill in for old/other timestamp interfaces */
138 #if defined(SYS_WINNT)
139 #include "win32_io.h"
140 #include <isc/win32os.h>
144 * We do asynchronous input using the SIGIO facility. A number of
145 * recvbuf buffers are preallocated for input. In the signal
146 * handler we poll to see which sockets are ready and read the
147 * packets from them into the recvbuf's along with a time stamp and
148 * an indication of the source host and the interface it was received
149 * through. This allows us to get as accurate receive time stamps
150 * as possible independent of other processing going on.
152 * We watch the number of recvbufs available to the signal handler
153 * and allocate more when this number drops below the low water
154 * mark. If the signal handler should run out of buffers in the
155 * interim it will drop incoming frames, the idea being that it is
156 * better to drop a packet than to be inaccurate.
161 * Other statistics of possible interest
163 volatile u_long packets_dropped; /* total number of packets dropped on reception */
164 volatile u_long packets_ignored; /* packets received on wild card interface */
165 volatile u_long packets_received; /* total number of packets received */
166 u_long packets_sent; /* total number of packets sent */
167 u_long packets_notsent; /* total number of packets which couldn't be sent */
169 volatile u_long handler_calls; /* number of calls to interrupt handler */
170 volatile u_long handler_pkts; /* number of pkts received by handler */
171 u_long io_timereset; /* time counters were reset */
176 endpt * any_interface; /* wildcard ipv4 interface */
177 endpt * any6_interface; /* wildcard ipv6 interface */
178 endpt * loopback_interface; /* loopback ipv4 interface */
180 static isc_boolean_t broadcast_client_enabled; /* is broadcast client enabled */
181 u_int sys_ifnum; /* next .ifnum to assign */
182 int ninterfaces; /* Total number of interfaces */
184 int disable_dynamic_updates; /* scan interfaces once only */
188 * Refclock stuff. We keep a chain of structures with data concerning
189 * the guys we are doing I/O for.
191 static struct refclockio *refio;
192 #endif /* REFCLOCK */
195 * File descriptor masks etc. for call to select
196 * Not needed for I/O Completion Ports or anything outside this file
198 static fd_set activefds;
199 static int maxactivefd;
202 * bit alternating value to detect verified interfaces during an update cycle
204 static u_short sys_interphase = 0;
206 static endpt * new_interface(endpt *);
207 static void add_interface(endpt *);
208 static int update_interfaces(u_short, interface_receiver_t,
210 static void remove_interface(endpt *);
211 static endpt * create_interface(u_short, endpt *);
213 static int is_wildcard_addr (const sockaddr_u *);
216 * Multicast functions
218 static isc_boolean_t addr_ismulticast (sockaddr_u *);
219 static isc_boolean_t is_anycast (sockaddr_u *,
223 * Not all platforms support multicast
226 static isc_boolean_t socket_multicast_enable (endpt *, sockaddr_u *);
227 static isc_boolean_t socket_multicast_disable(endpt *, sockaddr_u *);
231 static void interface_dump (const endpt *);
232 static void sockaddr_dump (const sockaddr_u *);
233 static void print_interface (const endpt *, const char *, const char *);
234 #define DPRINT_INTERFACE(level, args) do { if (debug >= (level)) { print_interface args; } } while (0)
236 #define DPRINT_INTERFACE(level, args) do {} while (0)
239 typedef struct vsock vsock_t;
240 enum desc_type { FD_TYPE_SOCKET, FD_TYPE_FILE };
250 #if !defined(HAVE_IO_COMPLETION_PORT) && defined(HAS_ROUTING_SOCKET)
252 * async notification processing (e. g. routing sockets)
255 * support for receiving data on fd that is not a refclock or a socket
256 * like e. g. routing sockets
258 struct asyncio_reader {
259 struct asyncio_reader *link; /* the list this is being kept in */
260 SOCKET fd; /* fd to be read */
261 void *data; /* possibly local data */
262 void (*receiver)(struct asyncio_reader *); /* input handler */
265 struct asyncio_reader *asyncio_reader_list;
267 static void delete_asyncio_reader (struct asyncio_reader *);
268 static struct asyncio_reader *new_asyncio_reader (void);
269 static void add_asyncio_reader (struct asyncio_reader *, enum desc_type);
270 static void remove_asyncio_reader (struct asyncio_reader *);
272 #endif /* !defined(HAVE_IO_COMPLETION_PORT) && defined(HAS_ROUTING_SOCKET) */
274 static void init_async_notifications (void);
276 static int addr_eqprefix (const sockaddr_u *, const sockaddr_u *,
278 static int addr_samesubnet (const sockaddr_u *, const sockaddr_u *,
279 const sockaddr_u *, const sockaddr_u *);
280 static int create_sockets (u_short);
281 static SOCKET open_socket (sockaddr_u *, int, int, endpt *);
282 static void set_reuseaddr (int);
283 static isc_boolean_t socket_broadcast_enable (struct interface *, SOCKET, sockaddr_u *);
285 #if !defined(HAVE_IO_COMPLETION_PORT) && !defined(HAVE_SIGNALED_IO)
286 static char * fdbits (int, const fd_set *);
288 #ifdef OS_MISSES_SPECIFIC_ROUTE_UPDATES
289 static isc_boolean_t socket_broadcast_disable (struct interface *, sockaddr_u *);
292 typedef struct remaddr remaddr_t;
300 remaddr_t * remoteaddr_list;
301 endpt * ep_list; /* complete endpt list */
302 endpt * mc4_list; /* IPv4 mcast-capable unicast endpts */
303 endpt * mc6_list; /* IPv6 mcast-capable unicast endpts */
305 static endpt * wildipv4;
306 static endpt * wildipv6;
309 int accept_wildcard_if_for_winnt;
311 const int accept_wildcard_if_for_winnt = FALSE;
314 static void add_fd_to_list (SOCKET, enum desc_type);
315 static endpt * find_addr_in_list (sockaddr_u *);
316 static endpt * find_flagged_addr_in_list(sockaddr_u *, u_int32);
317 static void delete_addr_from_list (sockaddr_u *);
318 static void delete_interface_from_list(endpt *);
319 static void close_and_delete_fd_from_list(SOCKET);
320 static void add_addr_to_list (sockaddr_u *, endpt *);
321 static void create_wildcards (u_short);
322 static endpt * findlocalinterface (sockaddr_u *, int, int);
323 static endpt * findclosestinterface (sockaddr_u *, int);
325 static const char * action_text (nic_rule_action);
327 static nic_rule_action interface_action(char *, sockaddr_u *, u_int32);
328 static void convert_isc_if (isc_interface_t *,
330 static void calc_addr_distance(sockaddr_u *,
333 static int cmp_addr_distance(const sockaddr_u *,
337 * Routines to read the ntp packets
339 #if !defined(HAVE_IO_COMPLETION_PORT)
340 static inline int read_network_packet (SOCKET, struct interface *, l_fp);
341 static void ntpd_addremove_io_fd (int, int, int);
342 static void input_handler_scan (const l_fp*, const fd_set*);
343 static int/*BOOL*/ sanitize_fdset (int errc);
345 static inline int read_refclock_packet (SOCKET, struct refclockio *, l_fp);
347 #ifdef HAVE_SIGNALED_IO
348 static void input_handler (l_fp*);
353 #ifndef HAVE_IO_COMPLETION_PORT
362 if (fd < 0 || fd >= FD_SETSIZE) {
364 "Too many sockets in use, FD_SETSIZE %d exceeded by fd %d",
370 FD_SET(fd, &activefds);
371 maxactivefd = max(fd, maxactivefd);
373 FD_CLR(fd, &activefds);
374 if (maxactivefd && fd == maxactivefd) {
375 for (i = maxactivefd - 1; i >= 0; i--)
376 if (FD_ISSET(i, &activefds)) {
380 INSIST(fd != maxactivefd);
384 #endif /* !HAVE_IO_COMPLETION_PORT */
389 * collect timing information for various processing
390 * paths. currently we only pass them on to the file
391 * for later processing. this could also do histogram
392 * based analysis in other to reduce the load (and skew)
393 * dur to the file output
396 collect_timing(struct recvbuf *rb, const char *tag, int count, l_fp *dts)
400 snprintf(buf, sizeof(buf), "%s %d %s %s",
402 ? ((rb->dstadr != NULL)
403 ? stoa(&rb->recv_srcadr)
406 count, lfptoa(dts, 9), tag);
407 record_timing_stats(buf);
412 * About dynamic interfaces, sockets, reception and more...
414 * the code solves following tasks:
416 * - keep a current list of active interfaces in order
417 * to bind to to the interface address on NTP_PORT so that
418 * all wild and specific bindings for NTP_PORT are taken by ntpd
419 * to avoid other daemons messing with the time or sockets.
420 * - all interfaces keep a list of peers that are referencing
421 * the interface in order to quickly re-assign the peers to
422 * new interface in case an interface is deleted (=> gone from system or
424 * - have a preconfigured socket ready with the right local address
425 * for transmission and reception
426 * - have an address list for all destination addresses used within ntpd
427 * to find the "right" preconfigured socket.
428 * - facilitate updating the internal interface list with respect to
429 * the current kernel state
433 * - mapping of multicast addresses to the interface affected is not always
434 * one to one - especially on hosts with multiple interfaces
435 * the code here currently allocates a separate interface entry for those
436 * multicast addresses
437 * iff it is able to bind to a *new* socket with the multicast address (flags |= MCASTIF)
438 * in case of failure the multicast address is bound to an existing interface.
439 * - on some systems it is perfectly legal to assign the same address to
440 * multiple interfaces. Therefore this code does not keep a list of interfaces
441 * but a list of interfaces that represent a unique address as determined by the kernel
442 * by the procedure in findlocalinterface. Thus it is perfectly legal to see only
443 * one representative of a group of real interfaces if they share the same address.
445 * Frank Kardel 20050910
449 * init_io - initialize I/O module.
454 /* Init buffer free list and stat counters */
455 init_recvbuff(RECV_INIT);
456 /* update interface every 5 minutes as default */
457 interface_interval = 300;
460 addremove_io_fd = &ntpd_addremove_io_fd;
463 #if defined(SYS_WINNT)
464 init_io_completion_port();
465 #elif defined(HAVE_SIGNALED_IO)
466 (void) set_signal(input_handler);
472 ntpd_addremove_io_fd(
480 #ifdef HAVE_SIGNALED_IO
483 #endif /* not HAVE_SIGNALED_IO */
485 maintain_activefds(fd, remove_it);
490 * io_open_sockets - call socket creation routine
493 io_open_sockets(void)
495 static int already_opened;
497 if (already_opened || HAVE_OPT( SAVECONFIGQUIT ))
506 create_sockets(NTP_PORT);
509 init_async_notifications();
511 DPRINTF(3, ("io_open_sockets: maxactivefd %d\n", maxactivefd));
517 * function to dump the contents of the interface structure
518 * for debugging use only.
519 * We face a dilemma here -- sockets are FDs under POSIX and
520 * actually HANDLES under Windows. So we use '%lld' as format
521 * and cast the value to 'long long'; this should not hurt
522 * with UNIX-like systems and does not truncate values on Win64.
525 interface_dump(const endpt *itf)
527 printf("Dumping interface: %p\n", itf);
528 printf("fd = %lld\n", (long long)itf->fd);
529 printf("bfd = %lld\n", (long long)itf->bfd);
530 printf("sin = %s,\n", stoa(&itf->sin));
531 sockaddr_dump(&itf->sin);
532 printf("bcast = %s,\n", stoa(&itf->bcast));
533 sockaddr_dump(&itf->bcast);
534 printf("mask = %s,\n", stoa(&itf->mask));
535 sockaddr_dump(&itf->mask);
536 printf("name = %s\n", itf->name);
537 printf("flags = 0x%08x\n", itf->flags);
538 printf("last_ttl = %d\n", itf->last_ttl);
539 printf("addr_refid = %08x\n", itf->addr_refid);
540 printf("num_mcast = %d\n", itf->num_mcast);
541 printf("received = %ld\n", itf->received);
542 printf("sent = %ld\n", itf->sent);
543 printf("notsent = %ld\n", itf->notsent);
544 printf("ifindex = %u\n", itf->ifindex);
545 printf("peercnt = %u\n", itf->peercnt);
546 printf("phase = %u\n", itf->phase);
550 * sockaddr_dump - hex dump the start of a sockaddr_u
553 sockaddr_dump(const sockaddr_u *psau)
555 /* Limit the size of the sockaddr_in6 hex dump */
556 const int maxsize = min(32, sizeof(psau->sa6));
560 /* XXX: Should we limit maxsize based on psau->saX.sin_family? */
561 cp = (const void *)&psau->sa6;
563 for(i = 0; i < maxsize; i++) {
564 printf("%02x", *cp++);
572 * print_interface - helper to output debug information
575 print_interface(const endpt *iface, const char *pfx, const char *sfx)
577 printf("%sinterface #%d: fd=%lld, bfd=%lld, name=%s, flags=0x%x, ifindex=%u, sin=%s",
580 (long long)iface->fd,
581 (long long)iface->bfd,
586 if (AF_INET == iface->family) {
587 if (iface->flags & INT_BROADCAST)
588 printf(", bcast=%s", stoa(&iface->bcast));
589 printf(", mask=%s", stoa(&iface->mask));
592 (iface->ignore_packets)
596 if (debug > 4) /* in-depth debugging only */
597 interface_dump(iface);
601 #if !defined(HAVE_IO_COMPLETION_PORT) && defined(HAS_ROUTING_SOCKET)
603 * create an asyncio_reader structure
605 static struct asyncio_reader *
606 new_asyncio_reader(void)
608 struct asyncio_reader *reader;
610 reader = emalloc_zero(sizeof(*reader));
611 reader->fd = INVALID_SOCKET;
620 delete_asyncio_reader(
621 struct asyncio_reader *reader
628 * add asynchio_reader
632 struct asyncio_reader * reader,
635 LINK_SLIST(asyncio_reader_list, reader, link);
636 add_fd_to_list(reader->fd, type);
640 * remove asynchio_reader
643 remove_asyncio_reader(
644 struct asyncio_reader *reader
647 struct asyncio_reader *unlinked;
649 UNLINK_SLIST(unlinked, asyncio_reader_list, reader, link,
650 struct asyncio_reader);
652 if (reader->fd != INVALID_SOCKET)
653 close_and_delete_fd_from_list(reader->fd);
655 reader->fd = INVALID_SOCKET;
657 #endif /* !defined(HAVE_IO_COMPLETION_PORT) && defined(HAS_ROUTING_SOCKET) */
660 /* compare two sockaddr prefixes */
663 const sockaddr_u * a,
664 const sockaddr_u * b,
670 isc_sockaddr_t isc_sa;
673 memcpy(&isc_sa.type, a, min(sizeof(isc_sa.type), sizeof(*a)));
674 isc_netaddr_fromsockaddr(&isc_a, &isc_sa);
677 memcpy(&isc_sa.type, b, min(sizeof(isc_sa.type), sizeof(*b)));
678 isc_netaddr_fromsockaddr(&isc_b, &isc_sa);
680 return (int)isc_netaddr_eqprefix(&isc_a, &isc_b,
687 const sockaddr_u * a,
688 const sockaddr_u * a_mask,
689 const sockaddr_u * b,
690 const sockaddr_u * b_mask
694 const u_int32 * pa_limit;
699 REQUIRE(AF(a) == AF(a_mask));
700 REQUIRE(AF(b) == AF(b_mask));
702 * With address and mask families verified to match, comparing
703 * the masks also validates the address's families match.
705 if (!SOCK_EQ(a_mask, b_mask))
709 loops = sizeof(NSRCADR6(a)) / sizeof(*pa);
710 pa = (const void *)&NSRCADR6(a);
711 pb = (const void *)&NSRCADR6(b);
712 pm = (const void *)&NSRCADR6(a_mask);
714 loops = sizeof(NSRCADR(a)) / sizeof(*pa);
715 pa = (const void *)&NSRCADR(a);
716 pb = (const void *)&NSRCADR(b);
717 pm = (const void *)&NSRCADR(a_mask);
719 for (pa_limit = pa + loops; pa < pa_limit; pa++, pb++, pm++)
720 if ((*pa & *pm) != (*pb & *pm))
728 * interface list enumerator - visitor pattern
732 interface_receiver_t receiver,
736 interface_info_t ifi;
738 ifi.action = IFS_EXISTS;
739 for (ifi.ep = ep_list; ifi.ep != NULL; ifi.ep = ifi.ep->elink)
740 (*receiver)(data, &ifi);
744 * do standard initialization of interface structure
752 ep->fd = INVALID_SOCKET;
753 ep->bfd = INVALID_SOCKET;
754 ep->phase = sys_interphase;
759 * create new interface structure initialize from
760 * template structure or via standard initialization
763 static struct interface *
765 struct interface *interface
768 struct interface * iface;
770 iface = emalloc(sizeof(*iface));
772 if (NULL == interface)
773 init_interface(iface);
774 else /* use the template */
775 memcpy(iface, interface, sizeof(*iface));
777 /* count every new instance of an interface in the system */
778 iface->ifnum = sys_ifnum++;
779 iface->starttime = current_time;
781 # ifdef HAVE_IO_COMPLETION_PORT
782 if (!io_completion_port_add_interface(iface)) {
783 msyslog(LOG_EMERG, "cannot register interface with IO engine -- will exit now");
792 * return interface storage into free memory pool
799 # ifdef HAVE_IO_COMPLETION_PORT
800 io_completion_port_remove_interface(ep);
807 * link interface into list of known interfaces
814 endpt ** pmclisthead;
822 int ep_univ_iid; /* iface ID from MAC address */
823 int scan_univ_iid; /* see RFC 4291 */
824 int ep_privacy; /* random local iface ID */
825 int scan_privacy; /* see RFC 4941 */
828 /* Calculate the refid */
829 ep->addr_refid = addr2refid(&ep->sin);
830 /* link at tail so ntpdc -c ifstats index increases each row */
831 LINK_TAIL_SLIST(ep_list, ep, elink, endpt);
834 /* the rest is for enabled multicast-capable addresses only */
835 if (ep->ignore_packets || !(INT_MULTICAST & ep->flags) ||
836 INT_LOOPBACK & ep->flags)
838 # ifndef INCLUDE_IPV6_MULTICAST_SUPPORT
839 if (AF_INET6 == ep->family)
842 pmclisthead = (AF_INET == ep->family)
846 if (AF_INET6 == ep->family) {
848 IN6_IS_ADDR_LINKLOCAL(PSOCK_ADDR6(&ep->sin)) ||
849 IN6_IS_ADDR_SITELOCAL(PSOCK_ADDR6(&ep->sin));
850 ep_univ_iid = IS_IID_UNIV(&ep->sin);
851 ep_privacy = !!(INT_PRIVACY & ep->flags);
857 DPRINTF(4, ("add_interface mcast-capable %s%s%s%s\n",
859 (ep_local) ? " link/scope-local" : "",
860 (ep_univ_iid) ? " univ-IID" : "",
861 (ep_privacy) ? " privacy" : ""));
863 * If we have multiple local addresses on the same network
864 * interface, and some are link- or site-local, do not multicast
865 * out from the link-/site-local addresses by default, to avoid
866 * duplicate manycastclient associations between v6 peers using
867 * link-local and global addresses. link-local can still be
868 * chosen using "nic ignore myv6globalprefix::/64".
869 * Similarly, if we have multiple global addresses from the same
870 * prefix on the same network interface, multicast from one,
871 * preferring EUI-64, then static, then least RFC 4941 privacy
874 for (scan = *pmclisthead; scan != NULL; scan = scan_next) {
875 scan_next = scan->mclink;
876 if (ep->family != scan->family)
878 if (strcmp(ep->name, scan->name))
880 same_subnet = addr_samesubnet(&ep->sin, &ep->mask,
881 &scan->sin, &scan->mask);
882 if (AF_INET6 == ep->family) {
885 IN6_IS_ADDR_LINKLOCAL(PSOCK_ADDR6(addr)) ||
886 IN6_IS_ADDR_SITELOCAL(PSOCK_ADDR6(addr));
887 scan_univ_iid = IS_IID_UNIV(addr);
888 scan_privacy = !!(INT_PRIVACY & scan->flags);
891 scan_univ_iid = FALSE;
892 scan_privacy = FALSE;
894 DPRINTF(4, ("add_interface mcast-capable scan %s%s%s%s\n",
896 (scan_local) ? " link/scope-local" : "",
897 (scan_univ_iid) ? " univ-IID" : "",
898 (scan_privacy) ? " privacy" : ""));
899 if ((ep_local && !scan_local) || (same_subnet &&
900 ((ep_privacy && !scan_privacy) ||
901 (!ep_univ_iid && scan_univ_iid)))) {
902 DPRINTF(4, ("did not add %s to %s of IPv6 multicast-capable list which already has %s\n",
910 if ((scan_local && !ep_local) || (same_subnet &&
911 ((scan_privacy && !ep_privacy) ||
912 (!scan_univ_iid && ep_univ_iid)))) {
913 UNLINK_SLIST(unlinked, *pmclisthead,
914 scan, mclink, endpt);
915 DPRINTF(4, ("%s %s from IPv6 multicast-capable list to add %s\n",
919 stoa(&scan->sin), stoa(&ep->sin)));
923 * Add link/site local at the tail of the multicast-
924 * capable unicast interfaces list, so that ntpd will
925 * send from global addresses before link-/site-local
929 LINK_TAIL_SLIST(*pmclisthead, ep, mclink, endpt);
931 LINK_SLIST(*pmclisthead, ep, mclink);
932 DPRINTF(4, ("added %s to %s of IPv%s multicast-capable unicast local address list\n",
937 (AF_INET == ep->family)
941 if (INVALID_SOCKET == ep->fd)
945 * select the local address from which to send to multicast.
947 switch (AF(&ep->sin)) {
950 rc = setsockopt(ep->fd, IPPROTO_IP,
952 (void *)&NSRCADR(&ep->sin),
953 sizeof(NSRCADR(&ep->sin)));
956 "setsockopt IP_MULTICAST_IF %s fails: %m",
960 # ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
962 rc = setsockopt(ep->fd, IPPROTO_IPV6,
964 (void *)&ep->ifindex,
965 sizeof(ep->ifindex));
966 /* do not complain if bound addr scope is ifindex */
967 if (rc && ep->ifindex != SCOPE(&ep->sin))
969 "setsockopt IPV6_MULTICAST_IF %u for %s fails: %m",
970 ep->ifindex, stoa(&ep->sin));
979 * remove interface from known interface list and clean up
980 * associated resources
988 endpt ** pmclisthead;
991 UNLINK_SLIST(unlinked, ep_list, ep, elink, endpt);
992 if (!ep->ignore_packets && INT_MULTICAST & ep->flags) {
993 pmclisthead = (AF_INET == ep->family)
996 UNLINK_SLIST(unlinked, *pmclisthead, ep, mclink, endpt);
997 DPRINTF(4, ("%s %s IPv%s multicast-capable unicast local address list\n",
1002 (AF_INET == ep->family)
1006 delete_interface_from_list(ep);
1008 if (ep->fd != INVALID_SOCKET) {
1010 "Deleting interface #%d %s, %s#%d, interface stats: received=%ld, sent=%ld, dropped=%ld, active_time=%ld secs",
1018 current_time - ep->starttime);
1019 # ifdef HAVE_IO_COMPLETION_PORT
1020 io_completion_port_remove_socket(ep->fd, ep);
1022 close_and_delete_fd_from_list(ep->fd);
1023 ep->fd = INVALID_SOCKET;
1026 if (ep->bfd != INVALID_SOCKET) {
1028 "stop listening for broadcasts to %s on interface #%d %s",
1029 stoa(&ep->bcast), ep->ifnum, ep->name);
1030 # ifdef HAVE_IO_COMPLETION_PORT
1031 io_completion_port_remove_socket(ep->bfd, ep);
1033 close_and_delete_fd_from_list(ep->bfd);
1034 ep->bfd = INVALID_SOCKET;
1036 # ifdef HAVE_IO_COMPLETION_PORT
1037 io_completion_port_remove_interface(ep);
1041 mon_clearinterface(ep);
1043 /* remove restrict interface entry */
1044 SET_HOSTMASK(&resmask, AF(&ep->sin));
1045 hack_restrict(RESTRICT_REMOVEIF, &ep->sin, &resmask,
1046 -3, RESM_NTPONLY | RESM_INTERFACE, RES_IGNORE, 0);
1055 msyslog(LOG_INFO, "%s on %d %s %s",
1056 (ep->ignore_packets)
1058 : "Listen normally",
1071 #ifdef INCLUDE_IPV6_SUPPORT
1074 sockaddr_u wildaddr;
1075 nic_rule_action action;
1076 struct interface * wildif;
1079 * silence "potentially uninitialized" warnings from VC9
1080 * failing to follow the logic. Ideally action could remain
1081 * uninitialized, and the memset be the first statement under
1082 * the first if (v4wild).
1084 action = ACTION_LISTEN;
1087 #ifdef INCLUDE_IPV6_SUPPORT
1089 * create pseudo-interface with wildcard IPv6 address
1091 v6wild = ipv6_works;
1093 /* set wildaddr to the v6 wildcard address :: */
1095 AF(&wildaddr) = AF_INET6;
1096 SET_ADDR6N(&wildaddr, in6addr_any);
1097 SET_PORT(&wildaddr, port);
1098 SET_SCOPE(&wildaddr, 0);
1100 /* check for interface/nic rules affecting the wildcard */
1101 action = interface_action(NULL, &wildaddr, 0);
1102 v6wild = (ACTION_IGNORE != action);
1105 wildif = new_interface(NULL);
1107 strlcpy(wildif->name, "v6wildcard", sizeof(wildif->name));
1108 memcpy(&wildif->sin, &wildaddr, sizeof(wildif->sin));
1109 wildif->family = AF_INET6;
1110 AF(&wildif->mask) = AF_INET6;
1111 SET_ONESMASK(&wildif->mask);
1113 wildif->flags = INT_UP | INT_WILDCARD;
1114 wildif->ignore_packets = (ACTION_DROP == action);
1116 wildif->fd = open_socket(&wildif->sin, 0, 1, wildif);
1118 if (wildif->fd != INVALID_SOCKET) {
1120 any6_interface = wildif;
1121 add_addr_to_list(&wildif->sin, wildif);
1122 add_interface(wildif);
1123 log_listen_address(wildif);
1126 "unable to bind to wildcard address %s - another process may be running - EXITING",
1127 stoa(&wildif->sin));
1130 DPRINT_INTERFACE(2, (wildif, "created ", "\n"));
1135 * create pseudo-interface with wildcard IPv4 address
1137 v4wild = ipv4_works;
1139 /* set wildaddr to the v4 wildcard address 0.0.0.0 */
1140 AF(&wildaddr) = AF_INET;
1141 SET_ADDR4N(&wildaddr, INADDR_ANY);
1142 SET_PORT(&wildaddr, port);
1144 /* check for interface/nic rules affecting the wildcard */
1145 action = interface_action(NULL, &wildaddr, 0);
1146 v4wild = (ACTION_IGNORE != action);
1149 wildif = new_interface(NULL);
1151 strlcpy(wildif->name, "v4wildcard", sizeof(wildif->name));
1152 memcpy(&wildif->sin, &wildaddr, sizeof(wildif->sin));
1153 wildif->family = AF_INET;
1154 AF(&wildif->mask) = AF_INET;
1155 SET_ONESMASK(&wildif->mask);
1157 wildif->flags = INT_BROADCAST | INT_UP | INT_WILDCARD;
1158 wildif->ignore_packets = (ACTION_DROP == action);
1161 * enable multicast reception on the broadcast socket
1163 AF(&wildif->bcast) = AF_INET;
1164 SET_ADDR4N(&wildif->bcast, INADDR_ANY);
1165 SET_PORT(&wildif->bcast, port);
1167 wildif->fd = open_socket(&wildif->sin, 0, 1, wildif);
1169 if (wildif->fd != INVALID_SOCKET) {
1171 any_interface = wildif;
1173 add_addr_to_list(&wildif->sin, wildif);
1174 add_interface(wildif);
1175 log_listen_address(wildif);
1178 "unable to bind to wildcard address %s - another process may be running - EXITING",
1179 stoa(&wildif->sin));
1182 DPRINT_INTERFACE(2, (wildif, "created ", "\n"));
1188 * add_nic_rule() -- insert a rule entry at the head of nic_rule_list.
1192 nic_rule_match match_type,
1193 const char * if_name, /* interface name or numeric address */
1195 nic_rule_action action
1199 isc_boolean_t is_ip;
1201 rule = emalloc_zero(sizeof(*rule));
1202 rule->match_type = match_type;
1203 rule->prefixlen = prefixlen;
1204 rule->action = action;
1206 if (MATCH_IFNAME == match_type) {
1207 REQUIRE(NULL != if_name);
1208 rule->if_name = estrdup(if_name);
1209 } else if (MATCH_IFADDR == match_type) {
1210 REQUIRE(NULL != if_name);
1211 /* set rule->addr */
1212 is_ip = is_ip_address(if_name, AF_UNSPEC, &rule->addr);
1215 REQUIRE(NULL == if_name);
1217 LINK_SLIST(nic_rule_list, rule, next);
1224 nic_rule_action action
1232 t = "ERROR"; /* quiet uninit warning */
1233 DPRINTF(1, ("fatal: unknown nic_rule_action %d\n",
1256 static nic_rule_action
1259 sockaddr_u * if_addr,
1267 DPRINTF(4, ("interface_action: interface %s ",
1268 (if_name != NULL) ? if_name : "wildcard"));
1270 iswildcard = is_wildcard_addr(if_addr);
1271 isloopback = !!(INT_LOOPBACK & if_flags);
1274 * Find any matching NIC rule from --interface / -I or ntp.conf
1275 * interface/nic rules.
1277 for (rule = nic_rule_list; rule != NULL; rule = rule->next) {
1279 switch (rule->match_type) {
1282 /* loopback and wildcard excluded from "all" */
1283 if (isloopback || iswildcard)
1285 DPRINTF(4, ("nic all %s\n",
1286 action_text(rule->action)));
1287 return rule->action;
1290 if (IS_IPV4(if_addr)) {
1291 DPRINTF(4, ("nic ipv4 %s\n",
1292 action_text(rule->action)));
1293 return rule->action;
1298 if (IS_IPV6(if_addr)) {
1299 DPRINTF(4, ("nic ipv6 %s\n",
1300 action_text(rule->action)));
1301 return rule->action;
1305 case MATCH_WILDCARD:
1307 DPRINTF(4, ("nic wildcard %s\n",
1308 action_text(rule->action)));
1309 return rule->action;
1314 if (rule->prefixlen != -1) {
1315 if (addr_eqprefix(if_addr, &rule->addr,
1318 DPRINTF(4, ("subnet address match - %s\n",
1319 action_text(rule->action)));
1320 return rule->action;
1323 if (SOCK_EQ(if_addr, &rule->addr)) {
1325 DPRINTF(4, ("address match - %s\n",
1326 action_text(rule->action)));
1327 return rule->action;
1333 #if defined(HAVE_FNMATCH) && defined(FNM_CASEFOLD)
1334 && !fnmatch(rule->if_name, if_name, FNM_CASEFOLD)
1336 && !strcasecmp(if_name, rule->if_name)
1340 DPRINTF(4, ("interface name match - %s\n",
1341 action_text(rule->action)));
1342 return rule->action;
1349 * Unless explicitly disabled such as with "nic ignore ::1"
1350 * listen on loopback addresses. Since ntpq and ntpdc query
1351 * "localhost" by default, which typically resolves to ::1 and
1352 * 127.0.0.1, it's useful to default to listening on both.
1355 DPRINTF(4, ("default loopback listen\n"));
1356 return ACTION_LISTEN;
1360 * Treat wildcard addresses specially. If there is no explicit
1361 * "nic ... wildcard" or "nic ... 0.0.0.0" or "nic ... ::" rule
1365 DPRINTF(4, ("default wildcard drop\n"));
1370 * Check for "virtual IP" (colon in the interface name) after
1371 * the rules so that "ntpd --interface eth0:1 -novirtualips"
1372 * does indeed listen on eth0:1's addresses.
1374 if (!listen_to_virtual_ips && if_name != NULL
1375 && (strchr(if_name, ':') != NULL)) {
1377 DPRINTF(4, ("virtual ip - ignore\n"));
1378 return ACTION_IGNORE;
1382 * If there are no --interface/-I command-line options and no
1383 * interface/nic rules in ntp.conf, the default action is to
1384 * listen. In the presence of rules from either, the default
1385 * is to ignore. This implements ntpd's traditional listen-
1386 * every default with no interface listen configuration, and
1387 * ensures a single -I eth0 or "nic listen eth0" means do not
1388 * listen on any other addresses.
1390 if (NULL == nic_rule_list) {
1391 DPRINTF(4, ("default listen\n"));
1392 return ACTION_LISTEN;
1395 DPRINTF(4, ("implicit ignore\n"));
1396 return ACTION_IGNORE;
1402 isc_interface_t *isc_if,
1407 const u_char v6loop[16] = {0, 0, 0, 0, 0, 0, 0, 0,
1408 0, 0, 0, 0, 0, 0, 0, 1};
1410 strlcpy(itf->name, isc_if->name, sizeof(itf->name));
1411 itf->ifindex = isc_if->ifindex;
1412 itf->family = (u_short)isc_if->af;
1413 AF(&itf->sin) = itf->family;
1414 AF(&itf->mask) = itf->family;
1415 AF(&itf->bcast) = itf->family;
1416 SET_PORT(&itf->sin, port);
1417 SET_PORT(&itf->mask, port);
1418 SET_PORT(&itf->bcast, port);
1420 if (IS_IPV4(&itf->sin)) {
1421 NSRCADR(&itf->sin) = isc_if->address.type.in.s_addr;
1422 NSRCADR(&itf->mask) = isc_if->netmask.type.in.s_addr;
1424 if (isc_if->flags & INTERFACE_F_BROADCAST) {
1425 itf->flags |= INT_BROADCAST;
1426 NSRCADR(&itf->bcast) =
1427 isc_if->broadcast.type.in.s_addr;
1430 #ifdef INCLUDE_IPV6_SUPPORT
1431 else if (IS_IPV6(&itf->sin)) {
1432 SET_ADDR6N(&itf->sin, isc_if->address.type.in6);
1433 SET_ADDR6N(&itf->mask, isc_if->netmask.type.in6);
1435 SET_SCOPE(&itf->sin, isc_if->address.zone);
1437 #endif /* INCLUDE_IPV6_SUPPORT */
1440 /* Process the rest of the flags */
1443 ((INTERFACE_F_UP & isc_if->flags)
1445 | ((INTERFACE_F_LOOPBACK & isc_if->flags)
1447 | ((INTERFACE_F_POINTTOPOINT & isc_if->flags)
1449 | ((INTERFACE_F_MULTICAST & isc_if->flags)
1450 ? INT_MULTICAST : 0)
1451 | ((INTERFACE_F_PRIVACY & isc_if->flags)
1456 * Clear the loopback flag if the address is not localhost.
1457 * http://bugs.ntp.org/1683
1459 if (INT_LOOPBACK & itf->flags) {
1460 if (AF_INET == itf->family) {
1461 if (127 != (SRCADR(&itf->sin) >> 24))
1462 itf->flags &= ~INT_LOOPBACK;
1464 if (memcmp(v6loop, NSRCADR6(&itf->sin),
1465 sizeof(NSRCADR6(&itf->sin))))
1466 itf->flags &= ~INT_LOOPBACK;
1475 * some OSes have been observed to keep
1476 * cached routes even when more specific routes
1478 * this can be mitigated by re-binding
1483 struct interface * interface
1486 #ifdef OS_MISSES_SPECIFIC_ROUTE_UPDATES
1487 if (interface->fd != INVALID_SOCKET) {
1488 int bcast = (interface->flags & INT_BCASTXMIT) != 0;
1489 /* as we forcibly close() the socket remove the
1490 broadcast permission indication */
1492 socket_broadcast_disable(interface, &interface->sin);
1494 close_and_delete_fd_from_list(interface->fd);
1496 /* create new socket picking up a new first hop binding
1497 at connect() time */
1498 interface->fd = open_socket(&interface->sin,
1499 bcast, 0, interface);
1501 * reset TTL indication so TTL is is set again
1504 interface->last_ttl = 0;
1505 return (interface->fd != INVALID_SOCKET);
1507 return 0; /* invalid sockets are not refreshable */
1508 #else /* !OS_MISSES_SPECIFIC_ROUTE_UPDATES */
1509 return (interface->fd != INVALID_SOCKET);
1510 #endif /* !OS_MISSES_SPECIFIC_ROUTE_UPDATES */
1514 * interface_update - externally callable update function
1518 interface_receiver_t receiver,
1521 int new_interface_found;
1523 if (disable_dynamic_updates)
1527 new_interface_found = update_interfaces(NTP_PORT, receiver, data);
1530 if (!new_interface_found)
1534 msyslog(LOG_DEBUG, "new interface(s) found: waking up resolver");
1536 interrupt_worker_sleep();
1541 * sau_from_netaddr() - convert network address on-wire formats.
1542 * Convert from libisc's isc_netaddr_t to NTP's sockaddr_u
1547 const isc_netaddr_t *pna
1551 AF(psau) = (u_short)pna->family;
1552 switch (pna->family) {
1555 memcpy(&psau->sa4.sin_addr, &pna->type.in,
1556 sizeof(psau->sa4.sin_addr));
1560 memcpy(&psau->sa6.sin6_addr, &pna->type.in6,
1561 sizeof(psau->sa6.sin6_addr));
1569 const sockaddr_u *psau
1572 if (IS_IPV4(psau) && !NSRCADR(psau))
1575 #ifdef INCLUDE_IPV6_SUPPORT
1576 if (IS_IPV6(psau) && S_ADDR6_EQ(psau, &in6addr_any))
1584 #ifdef OS_NEEDS_REUSEADDR_FOR_IFADDRBIND
1586 * enable/disable re-use of wildcard address socket
1594 struct interface *any;
1595 SOCKET fd = INVALID_SOCKET;
1597 any = ANY_INTERFACE_BYFAM(family);
1601 if (fd != INVALID_SOCKET) {
1602 if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
1603 (void *)&on, sizeof(on)))
1605 "set_wildcard_reuse: setsockopt(SO_REUSEADDR, %s) failed: %m",
1608 DPRINTF(4, ("set SO_REUSEADDR to %s on %s\n",
1613 #endif /* OS_NEEDS_REUSEADDR_FOR_IFADDRBIND */
1615 static isc_boolean_t
1622 #if defined(SIOCGIFAFLAG_IN)
1626 if (psau->sa.sa_family != AF_INET)
1628 if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
1631 memcpy(&ifr.ifr_addr, &psau->sa, sizeof(ifr.ifr_addr));
1632 strlcpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
1633 if (ioctl(fd, SIOCGIFAFLAG_IN, &ifr) < 0) {
1638 if ((ifr.ifr_addrflags & flags) != 0)
1640 #endif /* SIOCGIFAFLAG_IN */
1644 static isc_boolean_t
1651 #if defined(INCLUDE_IPV6_SUPPORT) && defined(SIOCGIFAFLAG_IN6)
1652 struct in6_ifreq ifr6;
1655 if (psau->sa.sa_family != AF_INET6)
1657 if ((fd = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
1660 memcpy(&ifr6.ifr_addr, &psau->sa6, sizeof(ifr6.ifr_addr));
1661 strlcpy(ifr6.ifr_name, name, sizeof(ifr6.ifr_name));
1662 if (ioctl(fd, SIOCGIFAFLAG_IN6, &ifr6) < 0) {
1667 if ((ifr6.ifr_ifru.ifru_flags6 & flags6) != 0)
1669 #endif /* INCLUDE_IPV6_SUPPORT && SIOCGIFAFLAG_IN6 */
1673 static isc_boolean_t
1679 #ifdef IN6_IFF_ANYCAST
1680 return check_flags6(psau, name, IN6_IFF_ANYCAST);
1686 static isc_boolean_t
1695 switch (psau->sa.sa_family) {
1697 #ifdef IN_IFF_DETACHED
1698 flags |= IN_IFF_DETACHED;
1700 #ifdef IN_IFF_TENTATIVE
1701 flags |= IN_IFF_TENTATIVE;
1703 return check_flags(psau, name, flags) ? ISC_FALSE : ISC_TRUE;
1705 #ifdef IN6_IFF_DEPARTED
1706 flags |= IN6_IFF_DEPARTED;
1708 #ifdef IN6_IFF_DETACHED
1709 flags |= IN6_IFF_DETACHED;
1711 #ifdef IN6_IFF_TENTATIVE
1712 flags |= IN6_IFF_TENTATIVE;
1714 return check_flags6(psau, name, flags) ? ISC_FALSE : ISC_TRUE;
1721 * update_interface strategy
1723 * toggle configuration phase
1726 * forall currently existing interfaces
1727 * if address is known:
1728 * drop socket - rebind again
1730 * if address is NOT known:
1731 * attempt to create a new interface entry
1734 * forall currently known non MCAST and WILDCARD interfaces
1735 * if interface does not match configuration phase (not seen in phase 1):
1736 * remove interface from known interface list
1737 * forall peers associated with this interface
1738 * disconnect peer from this interface
1741 * attempt to re-assign interfaces to peers
1748 interface_receiver_t receiver,
1752 isc_mem_t * mctx = (void *)-1;
1753 interface_info_t ifi;
1754 isc_interfaceiter_t * iter;
1755 isc_result_t result;
1756 isc_interface_t isc_if;
1757 int new_interface_found;
1758 unsigned int family;
1763 DPRINTF(3, ("update_interfaces(%d)\n", port));
1766 * phase one - scan interfaces
1767 * - create those that are not found
1768 * - update those that are found
1771 new_interface_found = FALSE;
1773 result = isc_interfaceiter_create(mctx, &iter);
1775 if (result != ISC_R_SUCCESS)
1779 * Toggle system interface scan phase to find untouched
1780 * interfaces to be deleted.
1782 sys_interphase ^= 0x1;
1784 for (result = isc_interfaceiter_first(iter);
1785 ISC_R_SUCCESS == result;
1786 result = isc_interfaceiter_next(iter)) {
1788 result = isc_interfaceiter_current(iter, &isc_if);
1790 if (result != ISC_R_SUCCESS)
1793 /* See if we have a valid family to use */
1794 family = isc_if.address.family;
1795 if (AF_INET != family && AF_INET6 != family)
1797 if (AF_INET == family && !ipv4_works)
1799 if (AF_INET6 == family && !ipv6_works)
1802 /* create prototype */
1803 init_interface(&enumep);
1805 convert_isc_if(&isc_if, &enumep, port);
1807 DPRINT_INTERFACE(4, (&enumep, "examining ", "\n"));
1810 * Check if and how we are going to use the interface.
1812 switch (interface_action(enumep.name, &enumep.sin,
1816 DPRINTF(4, ("ignoring interface %s (%s) - by nic rules\n",
1817 enumep.name, stoa(&enumep.sin)));
1821 DPRINTF(4, ("listen interface %s (%s) - by nic rules\n",
1822 enumep.name, stoa(&enumep.sin)));
1823 enumep.ignore_packets = ISC_FALSE;
1827 DPRINTF(4, ("drop on interface %s (%s) - by nic rules\n",
1828 enumep.name, stoa(&enumep.sin)));
1829 enumep.ignore_packets = ISC_TRUE;
1833 /* interfaces must be UP to be usable */
1834 if (!(enumep.flags & INT_UP)) {
1835 DPRINTF(4, ("skipping interface %s (%s) - DOWN\n",
1836 enumep.name, stoa(&enumep.sin)));
1841 * skip any interfaces UP and bound to a wildcard
1842 * address - some dhcp clients produce that in the
1845 if (is_wildcard_addr(&enumep.sin))
1848 if (is_anycast(&enumep.sin, isc_if.name))
1852 * skip any address that is an invalid state to be used
1854 if (!is_valid(&enumep.sin, isc_if.name))
1858 * map to local *address* in order to map all duplicate
1859 * interfaces to an endpt structure with the appropriate
1860 * socket. Our name space is (ip-address), NOT
1861 * (interface name, ip-address).
1863 ep = getinterface(&enumep.sin, INT_WILDCARD);
1865 if (ep != NULL && refresh_interface(ep)) {
1867 * found existing and up to date interface -
1870 if (ep->phase != sys_interphase) {
1872 * On a new round we reset the name so
1873 * the interface name shows up again if
1874 * this address is no longer shared.
1875 * We reset ignore_packets from the
1876 * new prototype to respect any runtime
1877 * changes to the nic rules.
1879 strlcpy(ep->name, enumep.name,
1881 ep->ignore_packets =
1882 enumep.ignore_packets;
1884 /* name collision - rename interface */
1885 strlcpy(ep->name, "*multiple*",
1889 DPRINT_INTERFACE(4, (ep, "updating ",
1892 if (ep->ignore_packets !=
1893 enumep.ignore_packets) {
1895 * We have conflicting configurations
1896 * for the interface address. This is
1897 * caused by using -I <interfacename>
1898 * for an interface that shares its
1899 * address with other interfaces. We
1900 * can not disambiguate incoming
1901 * packets delivered to this socket
1902 * without extra syscalls/features.
1903 * These are not (commonly) available.
1904 * Note this is a more unusual
1905 * configuration where several
1906 * interfaces share an address but
1907 * filtering via interface name is
1908 * attempted. We resolve the
1909 * configuration conflict by disabling
1910 * the processing of received packets.
1911 * This leads to no service on the
1912 * interface address where the conflict
1916 "WARNING: conflicting enable configuration for interfaces %s and %s for address %s - unsupported configuration - address DISABLED",
1917 enumep.name, ep->name,
1920 ep->ignore_packets = ISC_TRUE;
1923 ep->phase = sys_interphase;
1925 ifi.action = IFS_EXISTS;
1927 if (receiver != NULL)
1928 (*receiver)(data, &ifi);
1931 * This is new or refreshing failed - add to
1932 * our interface list. If refreshing failed we
1933 * will delete the interface structure in phase
1934 * 2 as the interface was not marked current.
1935 * We can bind to the address as the refresh
1936 * code already closed the offending socket
1938 ep = create_interface(port, &enumep);
1941 ifi.action = IFS_CREATED;
1943 if (receiver != NULL)
1944 (*receiver)(data, &ifi);
1946 new_interface_found = TRUE;
1949 " new - created\n"));
1952 (&enumep, "updating ",
1953 " new - creation FAILED"));
1956 "failed to init interface for address %s",
1963 isc_interfaceiter_destroy(&iter);
1966 * phase 2 - delete gone interfaces - reassigning peers to
1969 for (ep = ep_list; ep != NULL; ep = next_ep) {
1970 next_ep = ep->elink;
1973 * if phase does not match sys_phase this interface was
1974 * not enumerated during the last interface scan - so it
1975 * is gone and will be deleted here unless it did not
1976 * originate from interface enumeration (INT_WILDCARD,
1979 if (((INT_WILDCARD | INT_MCASTIF) & ep->flags) ||
1980 ep->phase == sys_interphase)
1983 DPRINT_INTERFACE(3, (ep, "updating ",
1984 "GONE - deleting\n"));
1985 remove_interface(ep);
1987 ifi.action = IFS_DELETED;
1989 if (receiver != NULL)
1990 (*receiver)(data, &ifi);
1992 /* disconnect peers from deleted endpt. */
1993 while (ep->peers != NULL)
1994 set_peerdstadr(ep->peers, NULL);
1997 * update globals in case we lose
1998 * a loopback interface
2000 if (ep == loopback_interface)
2001 loopback_interface = NULL;
2003 delete_interface(ep);
2007 * phase 3 - re-configure as the world has possibly changed
2009 * never ever make this conditional again - it is needed to track
2010 * routing updates. see bug #2506
2012 refresh_all_peerinterfaces();
2014 if (broadcast_client_enabled || sys_bclient)
2019 * Check multicast interfaces and try to join multicast groups if
2022 for (ep = ep_list; ep != NULL; ep = ep->elink) {
2025 if (!(INT_MCASTIF & ep->flags) || (INT_MCASTOPEN & ep->flags))
2028 /* Find remote address that was linked to this interface */
2029 for (entry = remoteaddr_list;
2031 entry = entry->link) {
2032 if (entry->ep == ep) {
2033 if (socket_multicast_enable(ep, &entry->addr)) {
2035 "Joined %s socket to multicast group %s",
2037 stoa(&entry->addr));
2045 return new_interface_found;
2050 * create_sockets - create a socket for each interface plus a default
2051 * socket for when we don't know where to send
2058 #ifndef HAVE_IO_COMPLETION_PORT
2060 * I/O Completion Ports don't care about the select and FD_SET
2063 FD_ZERO(&activefds);
2066 DPRINTF(2, ("create_sockets(%d)\n", port));
2068 create_wildcards(port);
2070 update_interfaces(port, NULL, NULL);
2073 * Now that we have opened all the sockets, turn off the reuse
2074 * flag for security.
2078 DPRINTF(2, ("create_sockets: Total interfaces = %d\n", ninterfaces));
2084 * create_interface - create a new interface for a given prototype
2085 * binding the socket.
2087 static struct interface *
2090 struct interface * protot
2095 #if defined(MCAST) && defined(MULTICAST_NONEWSOCKET)
2097 remaddr_t * next_entry;
2099 DPRINTF(2, ("create_interface(%s#%d)\n", stoa(&protot->sin),
2102 /* build an interface */
2103 iface = new_interface(protot);
2108 iface->fd = open_socket(&iface->sin, 0, 0, iface);
2110 if (iface->fd != INVALID_SOCKET)
2111 log_listen_address(iface);
2113 if ((INT_BROADCAST & iface->flags)
2114 && iface->bfd != INVALID_SOCKET)
2115 msyslog(LOG_INFO, "Listening on broadcast address %s#%d",
2116 stoa((&iface->bcast)), port);
2118 if (INVALID_SOCKET == iface->fd
2119 && INVALID_SOCKET == iface->bfd) {
2120 msyslog(LOG_ERR, "unable to create socket on %s (%d) for %s#%d",
2123 stoa((&iface->sin)),
2125 delete_interface(iface);
2130 * Blacklist our own addresses, no use talking to ourself
2132 SET_HOSTMASK(&resmask, AF(&iface->sin));
2133 hack_restrict(RESTRICT_FLAGS, &iface->sin, &resmask,
2134 -4, RESM_NTPONLY | RESM_INTERFACE, RES_IGNORE, 0);
2137 * set globals with the first found
2138 * loopback interface of the appropriate class
2140 if (NULL == loopback_interface && AF_INET == iface->family
2141 && (INT_LOOPBACK & iface->flags))
2142 loopback_interface = iface;
2145 * put into our interface list
2147 add_addr_to_list(&iface->sin, iface);
2148 add_interface(iface);
2150 #if defined(MCAST) && defined(MULTICAST_NONEWSOCKET)
2152 * Join any previously-configured compatible multicast groups.
2154 if (INT_MULTICAST & iface->flags &&
2155 !((INT_LOOPBACK | INT_WILDCARD) & iface->flags) &&
2156 !iface->ignore_packets) {
2157 for (entry = remoteaddr_list;
2159 entry = next_entry) {
2160 next_entry = entry->link;
2161 if (AF(&iface->sin) != AF(&entry->addr) ||
2162 !IS_MCAST(&entry->addr))
2164 if (socket_multicast_enable(iface,
2167 "Joined %s socket to multicast group %s",
2169 stoa(&entry->addr));
2172 "Failed to join %s socket to multicast group %s",
2174 stoa(&entry->addr));
2177 #endif /* MCAST && MCAST_NONEWSOCKET */
2179 DPRINT_INTERFACE(2, (iface, "created ", "\n"));
2184 #ifdef SO_EXCLUSIVEADDRUSE
2196 failed = setsockopt(fd, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
2197 (void *)&one, sizeof(one));
2204 * Prior to Windows XP setting SO_EXCLUSIVEADDRUSE can fail with
2205 * error WSAINVAL depending on service pack level and whether
2206 * the user account is in the Administrators group. Do not
2207 * complain if it fails that way on versions prior to XP (5.1).
2209 err = GetLastError();
2211 if (isc_win32os_versioncheck(5, 1, 0, 0) < 0 /* < 5.1/XP */
2212 && WSAEINVAL == err)
2218 "setsockopt(%d, SO_EXCLUSIVEADDRUSE, on): %m",
2221 #endif /* SO_EXCLUSIVEADDRUSE */
2225 * set_reuseaddr() - set/clear REUSEADDR on all sockets
2226 * NB possible hole - should we be doing this on broadcast
2234 #ifndef SO_EXCLUSIVEADDRUSE
2237 for (ep = ep_list; ep != NULL; ep = ep->elink) {
2238 if (ep->flags & INT_WILDCARD)
2242 * if ep->fd is INVALID_SOCKET, we might have a adapter
2243 * configured but not present
2245 DPRINTF(4, ("setting SO_REUSEADDR on %.16s@%s to %s\n",
2246 ep->name, stoa(&ep->sin),
2247 flag ? "on" : "off"));
2249 if (ep->fd != INVALID_SOCKET) {
2250 if (setsockopt(ep->fd, SOL_SOCKET, SO_REUSEADDR,
2251 (void *)&flag, sizeof(flag))) {
2252 msyslog(LOG_ERR, "set_reuseaddr: setsockopt(%s, SO_REUSEADDR, %s) failed: %m",
2253 stoa(&ep->sin), flag ? "on" : "off");
2257 #endif /* ! SO_EXCLUSIVEADDRUSE */
2261 * This is just a wrapper around an internal function so we can
2262 * make other changes as necessary later on
2266 struct interface * iface,
2270 #ifdef OPEN_BCAST_SOCKET
2271 socket_broadcast_enable(iface, iface->fd, baddr);
2275 #ifdef OPEN_BCAST_SOCKET
2277 * Enable a broadcast address to a given socket
2278 * The socket is in the ep_list all we need to do is enable
2279 * broadcasting. It is not this function's job to select the socket
2281 static isc_boolean_t
2282 socket_broadcast_enable(
2283 struct interface * iface,
2291 if (IS_IPV4(baddr)) {
2292 /* if this interface can support broadcast, set SO_BROADCAST */
2293 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST,
2294 (void *)&on, sizeof(on)))
2296 "setsockopt(SO_BROADCAST) enable failure on address %s: %m",
2299 DPRINTF(2, ("Broadcast enabled on socket %d for address %s\n",
2302 iface->flags |= INT_BCASTXMIT;
2306 #endif /* SO_BROADCAST */
2309 #ifdef OS_MISSES_SPECIFIC_ROUTE_UPDATES
2311 * Remove a broadcast address from a given socket
2312 * The socket is in the ep_list all we need to do is disable
2313 * broadcasting. It is not this function's job to select the socket
2315 static isc_boolean_t
2316 socket_broadcast_disable(
2317 struct interface * iface,
2322 int off = 0; /* This seems to be OK as an int */
2324 if (IS_IPV4(baddr) && setsockopt(iface->fd, SOL_SOCKET,
2325 SO_BROADCAST, (void *)&off, sizeof(off)))
2327 "setsockopt(SO_BROADCAST) disable failure on address %s: %m",
2330 iface->flags &= ~INT_BCASTXMIT;
2334 #endif /* SO_BROADCAST */
2336 #endif /* OS_MISSES_SPECIFIC_ROUTE_UPDATES */
2338 #endif /* OPEN_BCAST_SOCKET */
2341 * return the broadcast client flag value
2344 get_broadcastclient_flag(void)
2346 return (broadcast_client_enabled);
2351 * Check to see if the address is a multicast address
2353 static isc_boolean_t
2358 isc_boolean_t result;
2360 #ifndef INCLUDE_IPV6_MULTICAST_SUPPORT
2362 * If we don't have IPV6 support any IPV6 addr is not multicast
2368 result = IS_MCAST(maddr);
2371 DPRINTF(4, ("address %s is not multicast\n",
2378 * Multicast servers need to set the appropriate Multicast interface
2379 * socket option in order for it to know which interface to use for
2380 * send the multicast packet.
2383 enable_multicast_if(
2384 struct interface * iface,
2389 #ifdef IP_MULTICAST_LOOP
2390 TYPEOF_IP_MULTICAST_LOOP off = 0;
2392 #if defined(INCLUDE_IPV6_MULTICAST_SUPPORT) && defined(IPV6_MULTICAST_LOOP)
2396 REQUIRE(AF(maddr) == AF(&iface->sin));
2398 switch (AF(&iface->sin)) {
2401 #ifdef IP_MULTICAST_LOOP
2403 * Don't send back to itself, but allow failure to set
2405 if (setsockopt(iface->fd, IPPROTO_IP,
2411 "setsockopt IP_MULTICAST_LOOP failed: %m on socket %d, addr %s for multicast address %s",
2412 iface->fd, stoa(&iface->sin),
2419 #ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
2420 #ifdef IPV6_MULTICAST_LOOP
2422 * Don't send back to itself, but allow failure to set
2424 if (setsockopt(iface->fd, IPPROTO_IPV6,
2425 IPV6_MULTICAST_LOOP,
2426 (void *) &off6, sizeof(off6))) {
2429 "setsockopt IPV6_MULTICAST_LOOP failed: %m on socket %d, addr %s for multicast address %s",
2430 iface->fd, stoa(&iface->sin),
2437 #endif /* INCLUDE_IPV6_MULTICAST_SUPPORT */
2444 * Add a multicast address to a given socket
2445 * The socket is in the ep_list all we need to do is enable
2446 * multicasting. It is not this function's job to select the socket
2449 static isc_boolean_t
2450 socket_multicast_enable(
2455 struct ip_mreq mreq;
2456 # ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
2457 struct ipv6_mreq mreq6;
2459 switch (AF(maddr)) {
2463 mreq.imr_multiaddr = SOCK_ADDR4(maddr);
2464 mreq.imr_interface.s_addr = htonl(INADDR_ANY);
2465 if (setsockopt(iface->fd,
2471 "setsockopt IP_ADD_MEMBERSHIP failed: %m on socket %d, addr %s for %x / %x (%s)",
2472 iface->fd, stoa(&iface->sin),
2473 mreq.imr_multiaddr.s_addr,
2474 mreq.imr_interface.s_addr,
2478 DPRINTF(4, ("Added IPv4 multicast membership on socket %d, addr %s for %x / %x (%s)\n",
2479 iface->fd, stoa(&iface->sin),
2480 mreq.imr_multiaddr.s_addr,
2481 mreq.imr_interface.s_addr, stoa(maddr)));
2485 # ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
2487 * Enable reception of multicast packets.
2488 * If the address is link-local we can get the
2489 * interface index from the scope id. Don't do this
2490 * for other types of multicast addresses. For now let
2491 * the kernel figure it out.
2494 mreq6.ipv6mr_multiaddr = SOCK_ADDR6(maddr);
2495 mreq6.ipv6mr_interface = iface->ifindex;
2497 if (setsockopt(iface->fd, IPPROTO_IPV6,
2498 IPV6_JOIN_GROUP, (void *)&mreq6,
2501 "setsockopt IPV6_JOIN_GROUP failed: %m on socket %d, addr %s for interface %u (%s)",
2502 iface->fd, stoa(&iface->sin),
2503 mreq6.ipv6mr_interface, stoa(maddr)));
2506 DPRINTF(4, ("Added IPv6 multicast group on socket %d, addr %s for interface %u (%s)\n",
2507 iface->fd, stoa(&iface->sin),
2508 mreq6.ipv6mr_interface, stoa(maddr)));
2511 # endif /* INCLUDE_IPV6_MULTICAST_SUPPORT */
2513 iface->flags |= INT_MCASTOPEN;
2522 * Remove a multicast address from a given socket
2523 * The socket is in the ep_list all we need to do is disable
2524 * multicasting. It is not this function's job to select the socket
2527 static isc_boolean_t
2528 socket_multicast_disable(
2529 struct interface * iface,
2533 # ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
2534 struct ipv6_mreq mreq6;
2536 struct ip_mreq mreq;
2540 if (find_addr_in_list(maddr) == NULL) {
2541 DPRINTF(4, ("socket_multicast_disable(%s): not found\n",
2546 switch (AF(maddr)) {
2549 mreq.imr_multiaddr = SOCK_ADDR4(maddr);
2550 mreq.imr_interface = SOCK_ADDR4(&iface->sin);
2551 if (setsockopt(iface->fd, IPPROTO_IP,
2552 IP_DROP_MEMBERSHIP, (void *)&mreq,
2556 "setsockopt IP_DROP_MEMBERSHIP failed: %m on socket %d, addr %s for %x / %x (%s)",
2557 iface->fd, stoa(&iface->sin),
2558 SRCADR(maddr), SRCADR(&iface->sin),
2564 # ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
2566 * Disable reception of multicast packets
2567 * If the address is link-local we can get the
2568 * interface index from the scope id. Don't do this
2569 * for other types of multicast addresses. For now let
2570 * the kernel figure it out.
2572 mreq6.ipv6mr_multiaddr = SOCK_ADDR6(maddr);
2573 mreq6.ipv6mr_interface = iface->ifindex;
2575 if (setsockopt(iface->fd, IPPROTO_IPV6,
2576 IPV6_LEAVE_GROUP, (void *)&mreq6,
2580 "setsockopt IPV6_LEAVE_GROUP failure: %m on socket %d, addr %s for %d (%s)",
2581 iface->fd, stoa(&iface->sin),
2582 iface->ifindex, stoa(maddr));
2588 # endif /* INCLUDE_IPV6_MULTICAST_SUPPORT */
2592 if (!iface->num_mcast)
2593 iface->flags &= ~INT_MCASTOPEN;
2600 * io_setbclient - open the broadcast client sockets
2605 #ifdef OPEN_BCAST_SOCKET
2607 unsigned int nif, ni4, ni6;
2609 nif = ni4 = ni6 = 0;
2612 for (ep = ep_list; ep != NULL; ep = ep->elink) {
2613 /* count IPv6 vs IPv4 interfaces. Needed later to decide
2614 * if we should log an error or not.
2616 switch (ep->family) {
2617 case AF_INET : ++ni4; break;
2618 case AF_INET6: ++ni6; break;
2622 if (ep->flags & (INT_WILDCARD | INT_LOOPBACK))
2625 /* use only allowed addresses */
2626 if (ep->ignore_packets)
2629 /* Need a broadcast-capable interface */
2630 if (!(ep->flags & INT_BROADCAST))
2633 /* Only IPv4 addresses are valid for broadcast */
2634 REQUIRE(IS_IPV4(&ep->bcast));
2636 /* Do we already have the broadcast address open? */
2637 if (ep->flags & INT_BCASTOPEN) {
2639 * account for already open interfaces to avoid
2640 * misleading warning below
2647 * Try to open the broadcast address
2649 ep->family = AF_INET;
2650 ep->bfd = open_socket(&ep->bcast, 1, 0, ep);
2653 * If we succeeded then we use it otherwise enable
2654 * broadcast on the interface address
2656 if (ep->bfd != INVALID_SOCKET) {
2658 ep->flags |= INT_BCASTOPEN;
2660 "Listen for broadcasts to %s on interface #%d %s",
2661 stoa(&ep->bcast), ep->ifnum, ep->name);
2662 } else switch (errno) {
2663 /* Silently ignore EADDRINUSE as we probably
2664 * opened the socket already for an address in
2665 * the same network */
2667 /* Some systems cannot bind a socket to a broadcast
2668 * address, as that is not a valid host address. */
2670 # ifdef SYS_WINNT /*TODO: use for other systems, too? */
2671 /* avoid recurrence here -- if we already have a
2672 * regular socket, it's quite useless to try this
2675 if (ep->fd != INVALID_SOCKET) {
2676 ep->flags |= INT_BCASTOPEN;
2684 "failed to listen for broadcasts to %s on interface #%d %s",
2685 stoa(&ep->bcast), ep->ifnum, ep->name);
2691 broadcast_client_enabled = ISC_TRUE;
2692 DPRINTF(1, ("io_setbclient: listening to %d broadcast addresses\n", nif));
2694 broadcast_client_enabled = ISC_FALSE;
2695 /* This is expected when having only IPv6 interfaces
2696 * and no IPv4 interfaces at all. We suppress the error
2697 * log in that case... everything else should work!
2701 "Unable to listen for broadcasts, no broadcast interfaces available");
2706 "io_setbclient: Broadcast Client disabled by build");
2707 #endif /* OPEN_BCAST_SOCKET */
2711 * io_unsetbclient - close the broadcast client sockets
2714 io_unsetbclient(void)
2718 for (ep = ep_list; ep != NULL; ep = ep->elink) {
2719 if (INT_WILDCARD & ep->flags)
2721 if (!(INT_BCASTOPEN & ep->flags))
2724 if (ep->bfd != INVALID_SOCKET) {
2725 /* destroy broadcast listening socket */
2727 "stop listening for broadcasts to %s on interface #%d %s",
2728 stoa(&ep->bcast), ep->ifnum, ep->name);
2729 # ifdef HAVE_IO_COMPLETION_PORT
2730 io_completion_port_remove_socket(ep->bfd, ep);
2732 close_and_delete_fd_from_list(ep->bfd);
2733 ep->bfd = INVALID_SOCKET;
2735 ep->flags &= ~INT_BCASTOPEN;
2737 broadcast_client_enabled = ISC_FALSE;
2741 * io_multicast_add() - add multicast group address
2753 * Check to see if this is a multicast address
2755 if (!addr_ismulticast(addr))
2758 /* If we already have it we can just return */
2759 if (NULL != find_flagged_addr_in_list(addr, INT_MCASTOPEN)) {
2761 "Duplicate request found for multicast address %s",
2766 # ifndef MULTICAST_NONEWSOCKET
2767 ep = new_interface(NULL);
2770 * Open a new socket for the multicast address
2773 SET_PORT(&ep->sin, NTP_PORT);
2774 ep->family = AF(&ep->sin);
2775 AF(&ep->mask) = ep->family;
2776 SET_ONESMASK(&ep->mask);
2779 ep->bfd = INVALID_SOCKET;
2780 ep->fd = open_socket(&ep->sin, 0, 0, ep);
2781 if (ep->fd != INVALID_SOCKET) {
2782 ep->ignore_packets = ISC_FALSE;
2783 ep->flags |= INT_MCASTIF;
2784 ep->ifindex = SCOPE(addr);
2786 strlcpy(ep->name, "multicast", sizeof(ep->name));
2787 DPRINT_INTERFACE(2, (ep, "multicast add ", "\n"));
2789 log_listen_address(ep);
2791 /* bind failed, re-use wildcard interface */
2792 delete_interface(ep);
2796 else if (IS_IPV6(addr))
2802 /* HACK ! -- stuff in an address */
2803 /* because we don't bind addr? DH */
2806 "multicast address %s using wildcard interface #%d %s",
2807 stoa(addr), ep->ifnum, ep->name);
2810 "No multicast socket available to use for address %s",
2815 { /* in place of the { following for in #else clause */
2817 # else /* MULTICAST_NONEWSOCKET follows */
2819 * For the case where we can't use a separate socket (Windows)
2820 * join each applicable endpoint socket to the group address.
2826 for (ep = ep_list; ep != NULL; ep = ep->elink) {
2827 if (ep->ignore_packets || AF(&ep->sin) != AF(addr) ||
2828 !(INT_MULTICAST & ep->flags) ||
2829 (INT_LOOPBACK | INT_WILDCARD) & ep->flags)
2832 # endif /* MULTICAST_NONEWSOCKET */
2833 if (socket_multicast_enable(ep, addr))
2835 "Joined %s socket to multicast group %s",
2840 add_addr_to_list(addr, one_ep);
2841 #else /* !MCAST follows*/
2843 "Can not add multicast address %s: no multicast support",
2851 * io_multicast_del() - delete multicast group address
2862 * Check to see if this is a multicast address
2864 if (!addr_ismulticast(addr)) {
2865 msyslog(LOG_ERR, "invalid multicast address %s",
2871 * Disable reception of multicast packets
2873 while ((iface = find_flagged_addr_in_list(addr, INT_MCASTOPEN))
2875 socket_multicast_disable(iface, addr);
2877 delete_addr_from_list(addr);
2879 #else /* not MCAST */
2881 "Can not delete multicast address %s: no multicast support",
2883 #endif /* not MCAST */
2888 * open_socket - open a socket, returning the file descriptor
2902 * int is OK for REUSEADR per
2903 * http://www.kohala.com/start/mcast.api.txt
2908 if (IS_IPV6(addr) && !ipv6_works)
2909 return INVALID_SOCKET;
2911 /* create a datagram (UDP) socket */
2912 fd = socket(AF(addr), SOCK_DGRAM, 0);
2913 if (INVALID_SOCKET == fd) {
2914 errval = socket_errno();
2916 "socket(AF_INET%s, SOCK_DGRAM, 0) failed on address %s: %m",
2917 IS_IPV6(addr) ? "6" : "", stoa(addr));
2919 if (errval == EPROTONOSUPPORT ||
2920 errval == EAFNOSUPPORT ||
2921 errval == EPFNOSUPPORT)
2922 return (INVALID_SOCKET);
2926 "unexpected socket() error %m code %d (not EPROTONOSUPPORT nor EAFNOSUPPORT nor EPFNOSUPPORT) - exiting",
2932 connection_reset_fix(fd, addr);
2935 * Fixup the file descriptor for some systems
2936 * See bug #530 for details of the issue.
2941 * set SO_REUSEADDR since we will be binding the same port
2942 * number on each interface according to turn_off_reuse.
2943 * This is undesirable on Windows versions starting with
2944 * Windows XP (numeric version 5.1).
2947 if (isc_win32os_versioncheck(5, 1, 0, 0) < 0) /* before 5.1 */
2949 if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
2950 (void *)((turn_off_reuse)
2956 "setsockopt SO_REUSEADDR %s fails for address %s: %m",
2962 return INVALID_SOCKET;
2964 #ifdef SO_EXCLUSIVEADDRUSE
2966 * setting SO_EXCLUSIVEADDRUSE on the wildcard we open
2967 * first will cause more specific binds to fail.
2969 if (!(interf->flags & INT_WILDCARD))
2970 set_excladdruse(fd);
2974 * IPv4 specific options go here
2976 if (IS_IPV4(addr)) {
2977 #if defined(IPPROTO_IP) && defined(IP_TOS)
2978 if (setsockopt(fd, IPPROTO_IP, IP_TOS, (void *)&qos,
2981 "setsockopt IP_TOS (%02x) fails on address %s: %m",
2983 #endif /* IPPROTO_IP && IP_TOS */
2985 socket_broadcast_enable(interf, fd, addr);
2989 * IPv6 specific options go here
2991 if (IS_IPV6(addr)) {
2992 #if defined(IPPROTO_IPV6) && defined(IPV6_TCLASS)
2993 if (setsockopt(fd, IPPROTO_IPV6, IPV6_TCLASS, (void *)&qos,
2996 "setsockopt IPV6_TCLASS (%02x) fails on address %s: %m",
2998 #endif /* IPPROTO_IPV6 && IPV6_TCLASS */
3000 if (isc_net_probe_ipv6only() == ISC_R_SUCCESS
3001 && setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY,
3002 (void *)&on, sizeof(on)))
3004 "setsockopt IPV6_V6ONLY on fails on address %s: %m",
3007 #ifdef IPV6_BINDV6ONLY
3008 if (setsockopt(fd, IPPROTO_IPV6, IPV6_BINDV6ONLY,
3009 (void *)&on, sizeof(on)))
3011 "setsockopt IPV6_BINDV6ONLY on fails on address %s: %m",
3016 #ifdef OS_NEEDS_REUSEADDR_FOR_IFADDRBIND
3018 * some OSes don't allow binding to more specific
3019 * addresses if a wildcard address already bound
3020 * to the port and SO_REUSEADDR is not set
3022 if (!is_wildcard_addr(addr))
3023 set_wildcard_reuse(AF(addr), 1);
3027 * bind the local address.
3029 errval = bind(fd, &addr->sa, SOCKLEN(addr));
3031 #ifdef OS_NEEDS_REUSEADDR_FOR_IFADDRBIND
3032 if (!is_wildcard_addr(addr))
3033 set_wildcard_reuse(AF(addr), 0);
3038 * Don't log this under all conditions
3040 if (turn_off_reuse == 0
3046 "bind(%d) AF_INET%s %s#%d%s flags 0x%x failed: %m",
3047 fd, IS_IPV6(addr) ? "6" : "",
3048 stoa(addr), SRCPORT(addr),
3049 IS_MCAST(addr) ? " (multicast)" : "",
3055 return INVALID_SOCKET;
3058 #ifdef HAVE_TIMESTAMP
3060 if (setsockopt(fd, SOL_SOCKET, SO_TIMESTAMP,
3061 (void *)&on, sizeof(on)))
3063 "setsockopt SO_TIMESTAMP on fails on address %s: %m",
3066 DPRINTF(4, ("setsockopt SO_TIMESTAMP enabled on fd %d address %s\n",
3070 #ifdef HAVE_TIMESTAMPNS
3072 if (setsockopt(fd, SOL_SOCKET, SO_TIMESTAMPNS,
3073 (void *)&on, sizeof(on)))
3075 "setsockopt SO_TIMESTAMPNS on fails on address %s: %m",
3078 DPRINTF(4, ("setsockopt SO_TIMESTAMPNS enabled on fd %d address %s\n",
3084 if (setsockopt(fd, SOL_SOCKET, SO_BINTIME,
3085 (void *)&on, sizeof(on)))
3087 "setsockopt SO_BINTIME on fails on address %s: %m",
3090 DPRINTF(4, ("setsockopt SO_BINTIME enabled on fd %d address %s\n",
3095 DPRINTF(4, ("bind(%d) AF_INET%s, addr %s%%%d#%d, flags 0x%x\n",
3096 fd, IS_IPV6(addr) ? "6" : "", stoa(addr),
3097 SCOPE(addr), SRCPORT(addr), interf->flags));
3099 make_socket_nonblocking(fd);
3101 #ifdef HAVE_SIGNALED_IO
3102 init_socket_sig(fd);
3103 #endif /* not HAVE_SIGNALED_IO */
3105 add_fd_to_list(fd, FD_TYPE_SOCKET);
3107 #if !defined(SYS_WINNT) && !defined(VMS)
3108 DPRINTF(4, ("flags for fd %d: 0x%x\n", fd,
3109 fcntl(fd, F_GETFL, 0)));
3110 #endif /* SYS_WINNT || VMS */
3112 #if defined(HAVE_IO_COMPLETION_PORT)
3114 * Add the socket to the completion port
3116 if (!io_completion_port_add_socket(fd, interf, bcast)) {
3117 msyslog(LOG_ERR, "unable to set up io completion port - EXITING");
3126 /* XXX ELIMINATE sendpkt similar in ntpq.c, ntpdc.c, ntp_io.c, ntptrace.c */
3128 * sendpkt - send a packet to the specified destination. Maintain a
3129 * send error cache so that only the first consecutive error for a
3130 * destination is logged.
3135 struct interface * ep,
3146 l_fp fp_zero = { { 0 }, 0 };
3149 ismcast = IS_MCAST(dest);
3153 src = (IS_IPV4(dest))
3159 * unbound peer - drop request and wait for better
3160 * network conditions
3162 DPRINTF(2, ("%ssendpkt(dst=%s, ttl=%d, len=%d): no interface - IGNORED\n",
3163 ismcast ? "\tMCAST\t***** " : "",
3164 stoa(dest), ttl, len));
3169 DPRINTF(2, ("%ssendpkt(%d, dst=%s, src=%s, ttl=%d, len=%d)\n",
3170 ismcast ? "\tMCAST\t***** " : "", src->fd,
3171 stoa(dest), stoa(&src->sin), ttl, len));
3174 * for the moment we use the bcast option to set multicast ttl
3176 if (ismcast && ttl > 0 && ttl != src->last_ttl) {
3178 * set the multicast ttl for outgoing packets
3180 switch (AF(&src->sin)) {
3184 rc = setsockopt(src->fd, IPPROTO_IP,
3190 # ifdef INCLUDE_IPV6_SUPPORT
3192 rc = setsockopt(src->fd, IPPROTO_IPV6,
3193 IPV6_MULTICAST_HOPS,
3197 # endif /* INCLUDE_IPV6_SUPPORT */
3204 src->last_ttl = ttl;
3207 "setsockopt IP_MULTICAST_TTL/IPV6_MULTICAST_HOPS fails on address %s: %m",
3213 cc = simulate_server(dest, src, pkt);
3214 #elif defined(HAVE_IO_COMPLETION_PORT)
3215 cc = io_completion_port_sendto(src, src->fd, pkt,
3216 (size_t)len, (sockaddr_u *)&dest->sa);
3218 cc = sendto(src->fd, (char *)pkt, (u_int)len, 0,
3219 &dest->sa, SOCKLEN(dest));
3230 } while (ismcast && src != NULL);
3232 /* HMS: pkt->rootdisp is usually random here */
3233 NTOHL_FP(&pkt->org, &org);
3234 NTOHL_FP(&pkt->rec, &rec);
3235 NTOHL_FP(&pkt->xmt, &xmt);
3236 record_raw_stats(src ? &src->sin : NULL, dest,
3237 &org, &rec, &xmt, &fp_zero,
3238 PKT_LEAP(pkt->li_vn_mode),
3239 PKT_VERSION(pkt->li_vn_mode),
3240 PKT_MODE(pkt->li_vn_mode),
3242 pkt->ppoll, pkt->precision,
3243 pkt->rootdelay, pkt->rootdisp, pkt->refid,
3244 len - MIN_V4_PKT_LEN, (u_char *)&pkt->exten);
3250 #if !defined(HAVE_IO_COMPLETION_PORT)
3251 #if !defined(HAVE_SIGNALED_IO)
3253 * fdbits - generate ascii representation of fd_set (FAU debug support)
3254 * HFDF format - highest fd first.
3262 static char buffer[256];
3263 char * buf = buffer;
3265 count = min(count, 255);
3267 while (count >= 0) {
3268 *buf++ = FD_ISSET(count, set) ? '#' : '-';
3279 * Routine to read the refclock packets for a specific interface
3280 * Return the number of bytes read. That way we know if we should
3281 * read it again or go on to the next one if no bytes returned
3284 read_refclock_packet(
3286 struct refclockio * rp,
3294 struct recvbuf * rb;
3296 rb = get_free_recv_buffer(TRUE);
3300 * No buffer space available - just drop the 'packet'.
3301 * Since this is a non-blocking character stream we read
3302 * all data that we can.
3304 * ...hmmmm... what about "tcflush(fd,TCIFLUSH)" here?!?
3308 buflen = read(fd, buf, sizeof(buf));
3314 /* TALOS-CAN-0064: avoid signed/unsigned clashes that can lead
3315 * to buffer overrun and memory corruption
3317 if (rp->datalen <= 0 || (size_t)rp->datalen > sizeof(rb->recv_space))
3318 read_count = sizeof(rb->recv_space);
3320 read_count = (u_int)rp->datalen;
3322 buflen = read(fd, (char *)&rb->recv_space, read_count);
3323 } while (buflen < 0 && EINTR == errno);
3326 saved_errno = errno;
3328 errno = saved_errno;
3333 * Got one. Mark how and when it got here,
3334 * put it on the full list and do bookkeeping.
3336 rb->recv_length = buflen;
3337 rb->recv_peer = rp->srcclock;
3341 rb->receiver = rp->clock_recv;
3343 consumed = indicate_refclock_packet(rp, rb);
3351 #endif /* REFCLOCK */
3354 #ifdef HAVE_PACKET_TIMESTAMP
3356 * extract timestamps from control message buffer
3360 struct recvbuf * rb,
3361 struct msghdr * msghdr,
3365 struct cmsghdr * cmsghdr;
3366 unsigned long ticks;
3374 cmsghdr = CMSG_FIRSTHDR(msghdr);
3375 while (cmsghdr != NULL) {
3376 switch (cmsghdr->cmsg_type)
3380 #endif /* HAVE_BINTIME */
3381 #ifdef HAVE_TIMESTAMPNS
3382 case SCM_TIMESTAMPNS:
3383 #endif /* HAVE_TIMESTAMPNS */
3384 #ifdef HAVE_TIMESTAMP
3386 #endif /* HAVE_TIMESTAMP */
3387 #if defined(HAVE_BINTIME) || defined (HAVE_TIMESTAMPNS) || defined(HAVE_TIMESTAMP)
3388 switch (cmsghdr->cmsg_type)
3394 memcpy(&pbt, CMSG_DATA(cmsghdr), sizeof(pbt));
3396 * bintime documentation is at http://phk.freebsd.dk/pubs/timecounter.pdf
3398 nts.l_i = pbt.sec + JAN_1970;
3399 nts.l_uf = (u_int32)(pbt.frac >> 32);
3400 if (sys_tick > measured_tick &&
3402 ticks = (unsigned long)(nts.l_uf / (unsigned long)(sys_tick * FRAC));
3403 nts.l_uf = (unsigned long)(ticks * (unsigned long)(sys_tick * FRAC));
3405 DPRINTF(4, ("fetch_timestamp: system bintime network time stamp: %ld.%09lu\n",
3406 pbt.sec, (unsigned long)((nts.l_uf / FRAC) * 1e9)));
3409 #endif /* HAVE_BINTIME */
3410 #ifdef HAVE_TIMESTAMPNS
3411 case SCM_TIMESTAMPNS:
3413 struct timespec pts;
3414 memcpy(&pts, CMSG_DATA(cmsghdr), sizeof(pts));
3415 if (sys_tick > measured_tick &&
3417 ticks = (unsigned long)((pts.tv_nsec * 1e-9) /
3419 pts.tv_nsec = (long)(ticks * 1e9 *
3422 DPRINTF(4, ("fetch_timestamp: system nsec network time stamp: %ld.%09ld\n",
3423 pts.tv_sec, pts.tv_nsec));
3424 nts = tspec_stamp_to_lfp(pts);
3427 #endif /* HAVE_TIMESTAMPNS */
3428 #ifdef HAVE_TIMESTAMP
3432 memcpy(&ptv, CMSG_DATA(cmsghdr), sizeof(ptv));
3433 if (sys_tick > measured_tick &&
3435 ticks = (unsigned long)((ptv.tv_usec * 1e-6) /
3437 ptv.tv_usec = (long)(ticks * 1e6 *
3440 DPRINTF(4, ("fetch_timestamp: system usec network time stamp: %jd.%06ld\n",
3441 (intmax_t)ptv.tv_sec, (long)ptv.tv_usec));
3442 nts = tval_stamp_to_lfp(ptv);
3445 #endif /* HAVE_TIMESTAMP */
3447 fuzz = ntp_random() * 2. / FRAC * sys_fuzz;
3448 DTOLFP(fuzz, &lfpfuzz);
3449 L_ADD(&nts, &lfpfuzz);
3453 collect_timing(rb, "input processing delay", 1,
3455 DPRINTF(4, ("fetch_timestamp: timestamp delta: %s (incl. fuzz)\n",
3457 #endif /* DEBUG_TIMING */
3458 ts = nts; /* network time stamp */
3460 #endif /* HAVE_BINTIME || HAVE_TIMESTAMPNS || HAVE_TIMESTAMP */
3463 DPRINTF(4, ("fetch_timestamp: skipping control message 0x%x\n",
3464 cmsghdr->cmsg_type));
3466 cmsghdr = CMSG_NXTHDR(msghdr, cmsghdr);
3470 #endif /* HAVE_PACKET_TIMESTAMP */
3474 * Routine to read the network NTP packets for a specific interface
3475 * Return the number of bytes read. That way we know if we should
3476 * read it again or go on to the next one if no bytes returned
3479 read_network_packet(
3481 struct interface * itf,
3485 GETSOCKNAME_SOCKLEN_TYPE fromlen;
3487 register struct recvbuf *rb;
3488 #ifdef HAVE_PACKET_TIMESTAMP
3489 struct msghdr msghdr;
3491 char control[CMSG_BUFSIZE];
3495 * Get a buffer and read the frame. If we haven't got a buffer,
3496 * or this is received on a disallowed socket, just dump the
3500 rb = itf->ignore_packets ? NULL : get_free_recv_buffer(FALSE);
3502 /* A partial read on a UDP socket truncates the data and
3503 * removes the message from the queue. So there's no
3504 * need to have a full buffer here on the stack.
3512 fromlen = sizeof(from);
3513 buflen = recvfrom(fd, buf, sizeof(buf), 0,
3514 &from.sa, &fromlen);
3515 DPRINTF(4, ("%s on (%lu) fd=%d from %s\n",
3516 (itf->ignore_packets)
3519 free_recvbuffs(), fd, stoa(&from)));
3520 if (itf->ignore_packets)
3527 fromlen = sizeof(rb->recv_srcadr);
3529 #ifndef HAVE_PACKET_TIMESTAMP
3530 rb->recv_length = recvfrom(fd, (char *)&rb->recv_space,
3531 sizeof(rb->recv_space), 0,
3532 &rb->recv_srcadr.sa, &fromlen);
3534 iovec.iov_base = &rb->recv_space;
3535 iovec.iov_len = sizeof(rb->recv_space);
3536 msghdr.msg_name = &rb->recv_srcadr;
3537 msghdr.msg_namelen = fromlen;
3538 msghdr.msg_iov = &iovec;
3539 msghdr.msg_iovlen = 1;
3540 msghdr.msg_control = (void *)&control;
3541 msghdr.msg_controllen = sizeof(control);
3542 msghdr.msg_flags = 0;
3543 rb->recv_length = recvmsg(fd, &msghdr, 0);
3546 buflen = rb->recv_length;
3548 if (buflen == 0 || (buflen == -1 &&
3549 (EWOULDBLOCK == errno
3556 } else if (buflen < 0) {
3557 msyslog(LOG_ERR, "recvfrom(%s) fd=%d: %m",
3558 stoa(&rb->recv_srcadr), fd);
3559 DPRINTF(5, ("read_network_packet: fd=%d dropped (bad recvfrom)\n",
3565 DPRINTF(3, ("read_network_packet: fd=%d length %d from %s\n",
3566 fd, buflen, stoa(&rb->recv_srcadr)));
3568 #ifdef ENABLE_BUG3020_FIX
3569 if (ISREFCLOCKADR(&rb->recv_srcadr)) {
3570 msyslog(LOG_ERR, "recvfrom(%s) fd=%d: refclock srcadr on a network interface!",
3571 stoa(&rb->recv_srcadr), fd);
3572 DPRINTF(1, ("read_network_packet: fd=%d dropped (refclock srcadr))\n",
3581 ** Bug 2672: Some OSes (MacOSX and Linux) don't block spoofed ::1
3584 if (AF_INET6 == itf->family) {
3585 DPRINTF(2, ("Got an IPv6 packet, from <%s> (%d) to <%s> (%d)\n",
3586 stoa(&rb->recv_srcadr),
3587 IN6_IS_ADDR_LOOPBACK(PSOCK_ADDR6(&rb->recv_srcadr)),
3589 !IN6_IS_ADDR_LOOPBACK(PSOCK_ADDR6(&itf->sin))
3592 if ( IN6_IS_ADDR_LOOPBACK(PSOCK_ADDR6(&rb->recv_srcadr))
3593 && !IN6_IS_ADDR_LOOPBACK(PSOCK_ADDR6(&itf->sin))
3596 DPRINTF(2, ("DROPPING that packet\n"));
3600 DPRINTF(2, ("processing that packet\n"));
3604 * Got one. Mark how and when it got here,
3605 * put it on the full list and do bookkeeping.
3609 #ifdef HAVE_PACKET_TIMESTAMP
3610 /* pick up a network time stamp if possible */
3611 ts = fetch_timestamp(rb, &msghdr, ts);
3614 rb->receiver = receive;
3616 add_full_recv_buffer(rb);
3624 * attempt to handle io (select()/signaled IO)
3629 # ifndef HAVE_SIGNALED_IO
3634 * Use select() on all on all input fd's for unlimited
3635 * time. select() will terminate on SIGALARM or on the
3636 * reception of input. Using select() means we can't do
3637 * robust signal handling and we get a potential race
3638 * between checking for alarms and doing the select().
3639 * Mostly harmless, I think.
3642 * On VMS, I suspect that select() can't be interrupted
3643 * by a "signal" either, so I take the easy way out and
3644 * have select() time out after one second.
3645 * System clock updates really aren't time-critical,
3646 * and - lacking a hardware reference clock - I have
3647 * yet to learn about anything else that is.
3651 # if !defined(VMS) && !defined(SYS_VXWORKS)
3652 nfound = select(maxactivefd + 1, &rdfdes, NULL,
3654 # else /* VMS, VxWorks */
3655 /* make select() wake up after one second */
3660 nfound = select(maxactivefd + 1,
3661 &rdfdes, NULL, NULL,
3664 # endif /* VMS, VxWorks */
3665 if (nfound < 0 && sanitize_fdset(errno)) {
3670 nfound = select(maxactivefd + 1,
3671 &rdfdes, NULL, NULL,
3680 input_handler_scan(&ts, &rdfdes);
3681 } else if (nfound == -1 && errno != EINTR) {
3682 msyslog(LOG_ERR, "select() error: %m");
3685 else if (debug > 4) {
3686 msyslog(LOG_DEBUG, "select(): nfound=%d, error: %m", nfound);
3688 DPRINTF(3, ("select() returned %d: %m\n", nfound));
3691 # else /* HAVE_SIGNALED_IO */
3693 # endif /* HAVE_SIGNALED_IO */
3696 #ifdef HAVE_SIGNALED_IO
3698 * input_handler - receive packets asynchronously
3700 * ALWAYS IN SIGNAL HANDLER CONTEXT -- only async-safe functions allowed!
3708 struct timeval tvzero;
3714 * Do a poll to see who has data
3718 tvzero.tv_sec = tvzero.tv_usec = 0;
3720 n = select(maxactivefd + 1, &fds, NULL, NULL, &tvzero);
3721 if (n < 0 && sanitize_fdset(errno)) {
3723 tvzero.tv_sec = tvzero.tv_usec = 0;
3724 n = select(maxactivefd + 1, &fds, NULL, NULL, &tvzero);
3727 input_handler_scan(cts, &fds);
3729 #endif /* HAVE_SIGNALED_IO */
3733 * Try to sanitize the global FD set
3735 * SIGNAL HANDLER CONTEXT if HAVE_SIGNALED_IO, ordinary userspace otherwise
3744 # ifndef HAVE_SIGNALED_IO
3746 * extended FAU debugging output
3748 if (errc != EINTR) {
3750 "select(%d, %s, 0L, 0L, &0.0) error: %m",
3752 fdbits(maxactivefd, &activefds));
3759 /* if we have oviously bad FDs, try to sanitize the FD set. */
3760 for (j = 0, maxscan = 0; j <= maxactivefd; j++) {
3761 if (FD_ISSET(j, &activefds)) {
3762 if (-1 != read(j, &b, 0)) {
3766 # ifndef HAVE_SIGNALED_IO
3768 "Removing bad file descriptor %d from select set",
3771 FD_CLR(j, &activefds);
3774 if (maxactivefd != maxscan)
3775 maxactivefd = maxscan;
3780 * scan the known FDs (clocks, servers, ...) for presence in a 'fd_set'.
3782 * SIGNAL HANDLER CONTEXT if HAVE_SIGNALED_IO, ordinary userspace otherwise
3795 l_fp ts; /* Timestamp at BOselect() gob */
3797 #if defined(DEBUG_TIMING)
3798 l_fp ts_e; /* Timestamp at EOselect() gob */
3802 struct refclockio *rp;
3806 #ifdef HAS_ROUTING_SOCKET
3807 struct asyncio_reader * asyncio_reader;
3808 struct asyncio_reader * next_asyncio_reader;
3816 * Check out the reference clocks first, if any
3819 for (rp = refio; rp != NULL; rp = rp->next) {
3822 if (!FD_ISSET(fd, pfds))
3824 buflen = read_refclock_packet(fd, rp, ts);
3826 * The first read must succeed after select() indicates
3827 * readability, or we've reached a permanent EOF.
3828 * http://bugs.ntp.org/1732 reported ntpd munching CPU
3829 * after a USB GPS was unplugged because select was
3830 * indicating EOF but ntpd didn't remove the descriptor
3831 * from the activefds set.
3833 if (buflen < 0 && EAGAIN != errno) {
3834 saved_errno = errno;
3835 clk = refnumtoa(&rp->srcclock->srcadr);
3836 errno = saved_errno;
3837 msyslog(LOG_ERR, "%s read: %m", clk);
3838 maintain_activefds(fd, TRUE);
3839 } else if (0 == buflen) {
3840 clk = refnumtoa(&rp->srcclock->srcadr);
3841 msyslog(LOG_ERR, "%s read EOF", clk);
3842 maintain_activefds(fd, TRUE);
3844 /* drain any remaining refclock input */
3846 buflen = read_refclock_packet(fd, rp, ts);
3847 } while (buflen > 0);
3850 #endif /* REFCLOCK */
3853 * Loop through the interfaces looking for data to read.
3855 for (ep = ep_list; ep != NULL; ep = ep->elink) {
3856 for (doing = 0; doing < 2; doing++) {
3860 if (!(ep->flags & INT_BCASTOPEN))
3866 if (FD_ISSET(fd, pfds))
3868 buflen = read_network_packet(
3870 } while (buflen > 0);
3871 /* Check more interfaces */
3875 #ifdef HAS_ROUTING_SOCKET
3877 * scan list of asyncio readers - currently only used for routing sockets
3879 asyncio_reader = asyncio_reader_list;
3881 while (asyncio_reader != NULL) {
3882 /* callback may unlink and free asyncio_reader */
3883 next_asyncio_reader = asyncio_reader->link;
3884 if (FD_ISSET(asyncio_reader->fd, pfds))
3885 (*asyncio_reader->receiver)(asyncio_reader);
3886 asyncio_reader = next_asyncio_reader;
3888 #endif /* HAS_ROUTING_SOCKET */
3891 * Check for a response from a blocking child
3893 for (idx = 0; idx < blocking_children_alloc; idx++) {
3894 c = blocking_children[idx];
3895 if (NULL == c || -1 == c->resp_read_pipe)
3897 if (FD_ISSET(c->resp_read_pipe, pfds)) {
3898 ++c->resp_ready_seen;
3899 ++blocking_child_ready_seen;
3903 /* We've done our work */
3904 #if defined(DEBUG_TIMING)
3907 * (ts_e - ts) is the amount of time we spent
3908 * processing this gob of file descriptors. Log
3912 collect_timing(NULL, "input handler", 1, &ts_e);
3915 "input_handler: Processed a gob of fd's in %s msec",
3917 #endif /* DEBUG_TIMING */
3919 #endif /* !HAVE_IO_COMPLETION_PORT */
3922 * find an interface suitable for the src address
3925 select_peerinterface(
3927 sockaddr_u * srcadr,
3935 wild = ANY_INTERFACE_CHOOSE(srcadr);
3938 * Initialize the peer structure and dance the interface jig.
3939 * Reference clocks step the loopback waltz, the others
3940 * squaredance around the interface list looking for a buddy. If
3941 * the dance peters out, there is always the wildcard interface.
3942 * This might happen in some systems and would preclude proper
3943 * operation with public key cryptography.
3945 if (ISREFCLOCKADR(srcadr)) {
3946 ep = loopback_interface;
3947 } else if (peer->cast_flags &
3948 (MDF_BCLNT | MDF_ACAST | MDF_MCAST | MDF_BCAST)) {
3949 ep = findbcastinter(srcadr);
3951 DPRINTF(4, ("Found *-cast interface %s for address %s\n",
3952 stoa(&ep->sin), stoa(srcadr)));
3954 DPRINTF(4, ("No *-cast local address found for address %s\n",
3962 * If it is a multicast address, findbcastinter() may not find
3963 * it. For unicast, we get to find the interface when dstadr is
3964 * given to us as the wildcard (ANY_INTERFACE_CHOOSE). Either
3965 * way, try a little harder.
3968 ep = findinterface(srcadr);
3970 * we do not bind to the wildcard interfaces for output
3971 * as our (network) source address would be undefined and
3972 * crypto will not work without knowing the own transmit address
3974 if (ep != NULL && INT_WILDCARD & ep->flags)
3975 if (!accept_wildcard_if_for_winnt)
3977 #else /* SIM follows */
3978 ep = loopback_interface;
3986 * findinterface - find local interface corresponding to address
3995 iface = findlocalinterface(addr, INT_WILDCARD, 0);
3997 if (NULL == iface) {
3998 DPRINTF(4, ("Found no interface for address %s - returning wildcard\n",
4001 iface = ANY_INTERFACE_CHOOSE(addr);
4003 DPRINTF(4, ("Found interface #%d %s for address %s\n",
4004 iface->ifnum, iface->name, stoa(addr)));
4010 * findlocalinterface - find local interface corresponding to addr,
4011 * which does not have any of flags set. If bast is nonzero, addr is
4012 * a broadcast address.
4014 * This code attempts to find the local sending address for an outgoing
4015 * address by connecting a new socket to destinationaddress:NTP_PORT
4016 * and reading the sockname of the resulting connect.
4017 * the complicated sequence simulates the routing table lookup
4018 * for to first hop without duplicating any of the routing logic into
4019 * ntpd. preferably we would have used an API call - but its not there -
4020 * so this is the best we can do here short of duplicating to entire routing
4021 * logic in ntpd which would be a silly and really unportable thing to do.
4031 GETSOCKNAME_SOCKLEN_TYPE sockaddrlen;
4038 DPRINTF(4, ("Finding interface for addr %s in list of addresses\n",
4041 /* [Bug 3437] The dummy POOL peer comes in with an AF of
4042 * zero. This is bound to fail, but on the way to nowhere it
4043 * triggers a security incident on SELinux.
4045 * Checking the condition and failing early is probably a good
4046 * advice, and even saves us some syscalls in that case.
4047 * Thanks to Miroslav Lichvar for finding this.
4049 if (AF_UNSPEC == AF(addr))
4052 s = socket(AF(addr), SOCK_DGRAM, 0);
4053 if (INVALID_SOCKET == s)
4057 * If we are looking for broadcast interface we need to set this
4058 * socket to allow broadcast
4062 if (SOCKET_ERROR == setsockopt(s, SOL_SOCKET,
4071 rtn = connect(s, &addr->sa, SOCKLEN(addr));
4072 if (SOCKET_ERROR == rtn) {
4077 sockaddrlen = sizeof(saddr);
4078 rtn = getsockname(s, &saddr.sa, &sockaddrlen);
4080 if (SOCKET_ERROR == rtn)
4083 DPRINTF(4, ("findlocalinterface: kernel maps %s to %s\n",
4084 stoa(addr), stoa(&saddr)));
4086 iface = getinterface(&saddr, flags);
4089 * if we didn't find an exact match on saddr, find the closest
4090 * available local address. This handles the case of the
4091 * address suggested by the kernel being excluded by nic rules
4092 * or the user's -I and -L options to ntpd.
4093 * See http://bugs.ntp.org/1184 and http://bugs.ntp.org/1683
4094 * for more background.
4096 if (NULL == iface || iface->ignore_packets)
4097 iface = findclosestinterface(&saddr,
4098 flags | INT_LOOPBACK);
4100 /* Don't use an interface which will ignore replies */
4101 if (iface != NULL && iface->ignore_packets)
4109 * findclosestinterface
4111 * If there are -I/--interface or -L/novirtualips command-line options,
4112 * or "nic" or "interface" rules in ntp.conf, findlocalinterface() may
4113 * find the kernel's preferred local address for a given peer address is
4114 * administratively unavailable to ntpd, and punt to this routine's more
4117 * Find the numerically closest local address to the one connect()
4118 * suggested. This matches an address on the same subnet first, as
4119 * needed by Bug 1184, and provides a consistent choice if there are
4120 * multiple feasible local addresses, regardless of the order ntpd
4124 findclosestinterface(
4131 sockaddr_u addr_dist;
4132 sockaddr_u min_dist;
4134 ZERO_SOCK(&min_dist);
4137 for (ep = ep_list; ep != NULL; ep = ep->elink) {
4138 if (ep->ignore_packets ||
4139 AF(addr) != ep->family ||
4143 calc_addr_distance(&addr_dist, addr, &ep->sin);
4144 if (NULL == winner ||
4145 -1 == cmp_addr_distance(&addr_dist, &min_dist)) {
4146 min_dist = addr_dist;
4151 DPRINTF(4, ("findclosestinterface(%s) failed\n",
4154 DPRINTF(4, ("findclosestinterface(%s) -> %s\n",
4155 stoa(addr), stoa(&winner->sin)));
4162 * calc_addr_distance - calculate the distance between two addresses,
4163 * the absolute value of the difference between
4164 * the addresses numerically, stored as an address.
4169 const sockaddr_u * a1,
4170 const sockaddr_u * a2
4180 REQUIRE(AF(a1) == AF(a2));
4185 /* v4 can be done a bit simpler */
4189 v4dist = (a1val > a2val)
4192 SET_ADDR4(dist, v4dist);
4197 found_greater = FALSE;
4198 a1_greater = FALSE; /* suppress pot. uninit. warning */
4199 for (i = 0; i < (int)sizeof(NSRCADR6(a1)); i++) {
4200 if (!found_greater &&
4201 NSRCADR6(a1)[i] != NSRCADR6(a2)[i]) {
4202 found_greater = TRUE;
4203 a1_greater = (NSRCADR6(a1)[i] > NSRCADR6(a2)[i]);
4205 if (!found_greater) {
4206 NSRCADR6(dist)[i] = 0;
4209 NSRCADR6(dist)[i] = NSRCADR6(a1)[i] -
4212 NSRCADR6(dist)[i] = NSRCADR6(a2)[i] -
4220 * cmp_addr_distance - compare two address distances, returning -1, 0,
4221 * 1 to indicate their relationship.
4225 const sockaddr_u * d1,
4226 const sockaddr_u * d2
4231 REQUIRE(AF(d1) == AF(d2));
4234 if (SRCADR(d1) < SRCADR(d2))
4236 else if (SRCADR(d1) == SRCADR(d2))
4242 for (i = 0; i < (int)sizeof(NSRCADR6(d1)); i++) {
4243 if (NSRCADR6(d1)[i] < NSRCADR6(d2)[i])
4245 else if (NSRCADR6(d1)[i] > NSRCADR6(d2)[i])
4255 * fetch an interface structure the matches the
4256 * address and has the given flags NOT set
4266 iface = find_addr_in_list(addr);
4268 if (iface != NULL && (iface->flags & flags))
4276 * findbcastinter - find broadcast interface corresponding to address
4286 #if !defined(MPE) && (defined(SIOCGIFCONF) || defined(SYS_WINNT))
4287 DPRINTF(4, ("Finding broadcast/multicast interface for addr %s in list of addresses\n",
4290 iface = findlocalinterface(addr, INT_LOOPBACK | INT_WILDCARD,
4292 if (iface != NULL) {
4293 DPRINTF(4, ("Easily found bcast-/mcast- interface index #%d %s\n",
4294 iface->ifnum, iface->name));
4299 * plan B - try to find something reasonable in our lists in
4300 * case kernel lookup doesn't help
4302 for (iface = ep_list; iface != NULL; iface = iface->elink) {
4303 if (iface->flags & INT_WILDCARD)
4306 /* Don't bother with ignored interfaces */
4307 if (iface->ignore_packets)
4311 * First look if this is the correct family
4313 if(AF(&iface->sin) != AF(addr))
4316 /* Skip the loopback addresses */
4317 if (iface->flags & INT_LOOPBACK)
4321 * If we are looking to match a multicast address and
4322 * this interface is one...
4324 if (addr_ismulticast(addr)
4325 && (iface->flags & INT_MULTICAST)) {
4326 #ifdef INCLUDE_IPV6_SUPPORT
4328 * ...it is the winner unless we're looking for
4329 * an interface to use for link-local multicast
4330 * and its address is not link-local.
4333 && IN6_IS_ADDR_MC_LINKLOCAL(PSOCK_ADDR6(addr))
4334 && !IN6_IS_ADDR_LINKLOCAL(PSOCK_ADDR6(&iface->sin)))
4341 * We match only those interfaces marked as
4342 * broadcastable and either the explicit broadcast
4343 * address or the network portion of the IP address.
4346 if (IS_IPV4(addr)) {
4347 if (SOCK_EQ(&iface->bcast, addr))
4350 if ((NSRCADR(&iface->sin) & NSRCADR(&iface->mask))
4351 == (NSRCADR(addr) & NSRCADR(&iface->mask)))
4354 #ifdef INCLUDE_IPV6_SUPPORT
4355 else if (IS_IPV6(addr)) {
4356 if (SOCK_EQ(&iface->bcast, addr))
4359 if (SOCK_EQ(netof(&iface->sin), netof(addr)))
4364 #endif /* SIOCGIFCONF */
4365 if (NULL == iface) {
4366 DPRINTF(4, ("No bcast interface found for %s\n",
4368 iface = ANY_INTERFACE_CHOOSE(addr);
4370 DPRINTF(4, ("Found bcast-/mcast- interface index #%d %s\n",
4371 iface->ifnum, iface->name));
4379 * io_clr_stats - clear I/O module statistics
4384 packets_dropped = 0;
4385 packets_ignored = 0;
4386 packets_received = 0;
4388 packets_notsent = 0;
4392 io_timereset = current_time;
4398 * io_addclock - add a reference clock to the list and arrange that we
4399 * get SIGIO interrupts from it.
4403 struct refclockio *rio
4409 * Stuff the I/O structure in the list and mark the descriptor
4410 * in use. There is a harmless (I hope) race condition here.
4414 # ifdef HAVE_SIGNALED_IO
4415 if (init_clock_sig(rio)) {
4419 # elif defined(HAVE_IO_COMPLETION_PORT)
4420 if (!io_completion_port_add_clock_io(rio)) {
4429 LINK_SLIST(refio, rio, next);
4434 add_fd_to_list(rio->fd, FD_TYPE_FILE);
4442 * io_closeclock - close the clock in the I/O structure given
4446 struct refclockio *rio
4449 struct refclockio *unlinked;
4454 * Remove structure from the list
4456 rio->active = FALSE;
4457 UNLINK_SLIST(unlinked, refio, rio, next, struct refclockio);
4458 if (NULL != unlinked) {
4459 /* Close the descriptor. The order of operations is
4460 * important here in case of async / overlapped IO:
4461 * only after we have removed the clock from the
4462 * IO completion port we can be sure no further
4463 * input is queued. So...
4464 * - we first disable feeding to the queu by removing
4465 * the clock from the IO engine
4466 * - close the file (which brings down any IO on it)
4467 * - clear the buffer from results for this fd
4469 # ifdef HAVE_IO_COMPLETION_PORT
4470 io_completion_port_remove_clock_io(rio);
4472 close_and_delete_fd_from_list(rio->fd);
4473 purge_recv_buffers_for_fd(rio->fd);
4479 #endif /* REFCLOCK */
4483 * On NT a SOCKET is an unsigned int so we cannot possibly keep it in
4484 * an array. So we use one of the ISC_LIST functions to hold the
4485 * socket value and use that when we want to enumerate it.
4487 * This routine is called by the forked intres child process to close
4488 * all open sockets. On Windows there's no need as intres runs in
4489 * the same process as a thread.
4500 * In the child process we do not maintain activefds and
4501 * maxactivefd. Zeroing maxactivefd disables code which
4502 * maintains it in close_and_delete_fd_from_list().
4506 while (fd_list != NULL)
4507 close_and_delete_fd_from_list(fd_list->fd);
4511 #endif /* !SYS_WINNT */
4515 * Add and delete functions for the list of open sockets
4523 vsock_t *lsock = emalloc(sizeof(*lsock));
4528 LINK_SLIST(fd_list, lsock, link);
4529 maintain_activefds(fd, 0);
4534 close_and_delete_fd_from_list(
4540 UNLINK_EXPR_SLIST(lsock, fd_list, fd ==
4541 UNLINK_EXPR_SLIST_CURRENT()->fd, link, vsock_t);
4546 switch (lsock->type) {
4548 case FD_TYPE_SOCKET:
4549 closesocket(lsock->fd);
4553 closeserial((int)lsock->fd);
4558 "internal error - illegal descriptor type %d - EXITING",
4565 * remove from activefds
4567 maintain_activefds(fd, 1);
4580 if (find_addr_in_list(addr) == NULL) {
4582 /* not there yet - add to list */
4583 laddr = emalloc(sizeof(*laddr));
4584 laddr->addr = *addr;
4587 LINK_SLIST(remoteaddr_list, laddr, link);
4589 DPRINTF(4, ("Added addr %s to list of addresses\n",
4593 DPRINTF(4, ("WARNING: Attempt to add duplicate addr %s to address list\n",
4600 delete_addr_from_list(
4604 remaddr_t *unlinked;
4606 UNLINK_EXPR_SLIST(unlinked, remoteaddr_list, SOCK_EQ(addr,
4607 &(UNLINK_EXPR_SLIST_CURRENT()->addr)), link, remaddr_t);
4609 if (unlinked != NULL) {
4610 DPRINTF(4, ("Deleted addr %s from list of addresses\n",
4618 delete_interface_from_list(
4622 remaddr_t *unlinked;
4625 UNLINK_EXPR_SLIST(unlinked, remoteaddr_list, iface ==
4626 UNLINK_EXPR_SLIST_CURRENT()->ep, link,
4629 if (unlinked == NULL)
4631 DPRINTF(4, ("Deleted addr %s for interface #%d %s from list of addresses\n",
4632 stoa(&unlinked->addr), iface->ifnum,
4639 static struct interface *
4646 DPRINTF(4, ("Searching for addr %s in list of addresses - ",
4649 for (entry = remoteaddr_list;
4651 entry = entry->link)
4652 if (SOCK_EQ(&entry->addr, addr)) {
4653 DPRINTF(4, ("FOUND\n"));
4657 DPRINTF(4, ("NOT FOUND\n"));
4663 * Find the given address with the all given flags set in the list
4666 find_flagged_addr_in_list(
4673 DPRINTF(4, ("Finding addr %s with flags %d in list: ",
4674 stoa(addr), flags));
4676 for (entry = remoteaddr_list;
4678 entry = entry->link)
4680 if (SOCK_EQ(&entry->addr, addr)
4681 && (entry->ep->flags & flags) == flags) {
4683 DPRINTF(4, ("FOUND\n"));
4687 DPRINTF(4, ("NOT FOUND\n"));
4703 #ifdef HAS_ROUTING_SOCKET
4704 # ifndef UPDATE_GRACE
4705 # define UPDATE_GRACE 2 /* wait UPDATE_GRACE seconds before scanning */
4709 process_routing_msgs(struct asyncio_reader *reader)
4713 #ifdef HAVE_RTNETLINK
4714 struct nlmsghdr *nh;
4716 struct rt_msghdr rtm;
4720 if (disable_dynamic_updates) {
4722 * discard ourselves if we are not needed any more
4723 * usually happens when running unprivileged
4725 remove_asyncio_reader(reader);
4726 delete_asyncio_reader(reader);
4730 cnt = read(reader->fd, buffer, sizeof(buffer));
4733 if (errno == ENOBUFS) {
4735 "routing socket reports: %m");
4738 "routing socket reports: %m - disabling");
4739 remove_asyncio_reader(reader);
4740 delete_asyncio_reader(reader);
4746 * process routing message
4748 #ifdef HAVE_RTNETLINK
4749 for (nh = UA_PTR(struct nlmsghdr, buffer);
4751 nh = NLMSG_NEXT(nh, cnt))
4753 msg_type = nh->nlmsg_type;
4756 (p + sizeof(struct rt_msghdr)) <= (buffer + cnt);
4757 p += rtm.rtm_msglen)
4759 memcpy(&rtm, p, sizeof(rtm));
4760 if (rtm.rtm_version != RTM_VERSION) {
4762 "version mismatch (got %d - expected %d) on routing socket - disabling",
4763 rtm.rtm_version, RTM_VERSION);
4765 remove_asyncio_reader(reader);
4766 delete_asyncio_reader(reader);
4769 msg_type = rtm.rtm_type;
4796 #ifdef RTM_IFANNOUNCE
4797 case RTM_IFANNOUNCE:
4812 * we are keen on new and deleted addresses and
4813 * if an interface goes up and down or routing
4816 DPRINTF(3, ("routing message op = %d: scheduling interface update\n",
4818 timer_interfacetimeout(current_time + UPDATE_GRACE);
4820 #ifdef HAVE_RTNETLINK
4822 /* end of multipart message */
4827 * the rest doesn't bother us.
4829 DPRINTF(4, ("routing message op = %d: ignored\n",
4837 * set up routing notifications
4840 init_async_notifications()
4842 struct asyncio_reader *reader;
4843 #ifdef HAVE_RTNETLINK
4844 int fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
4845 struct sockaddr_nl sa;
4847 int fd = socket(PF_ROUTE, SOCK_RAW, 0);
4851 "unable to open routing socket (%m) - using polled interface update");
4856 #ifdef HAVE_RTNETLINK
4858 sa.nl_family = PF_NETLINK;
4859 sa.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR
4860 | RTMGRP_IPV6_IFADDR | RTMGRP_IPV4_ROUTE
4861 | RTMGRP_IPV4_MROUTE | RTMGRP_IPV6_ROUTE
4862 | RTMGRP_IPV6_MROUTE;
4863 if (bind(fd, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
4865 "bind failed on routing socket (%m) - using polled interface update");
4869 make_socket_nonblocking(fd);
4870 #if defined(HAVE_SIGNALED_IO)
4871 init_socket_sig(fd);
4872 #endif /* HAVE_SIGNALED_IO */
4874 reader = new_asyncio_reader();
4877 reader->receiver = process_routing_msgs;
4879 add_asyncio_reader(reader, FD_TYPE_SOCKET);
4881 "Listening on routing socket on fd #%d for interface updates",
4885 /* HAS_ROUTING_SOCKET not defined */
4887 init_async_notifications(void)