xref: /freebsd/contrib/ntp/ntpd/ntp_io.c (revision 36712a94975f5bd0d26c85377283b49a2369c82f)
1 /*
2  * ntp_io.c - input/output routines for ntpd.	The socket-opening code
3  *		   was shamelessly stolen from ntpd.
4  */
5 
6 #ifdef HAVE_CONFIG_H
7 # include <config.h>
8 #endif
9 
10 #include <stdio.h>
11 #include <signal.h>
12 #ifdef HAVE_FNMATCH_H
13 # include <fnmatch.h>
14 # if !defined(FNM_CASEFOLD) && defined(FNM_IGNORECASE)
15 #  define FNM_CASEFOLD FNM_IGNORECASE
16 # endif
17 #endif
18 #ifdef HAVE_SYS_PARAM_H
19 # include <sys/param.h>
20 #endif
21 #ifdef HAVE_SYS_IOCTL_H
22 # include <sys/ioctl.h>
23 #endif
24 #ifdef HAVE_SYS_SOCKIO_H	/* UXPV: SIOC* #defines (Frank Vance <fvance@waii.com>) */
25 # include <sys/sockio.h>
26 #endif
27 #ifdef HAVE_SYS_UIO_H
28 # include <sys/uio.h>
29 #endif
30 
31 #include "ntp_machine.h"
32 #include "ntpd.h"
33 #include "ntp_io.h"
34 #include "iosignal.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"
44 #include "safecast.h"
45 
46 /* Don't include ISC's version of IPv6 variables and structures */
47 #define ISC_IPV6_H 1
48 #include <isc/mem.h>
49 #include <isc/interfaceiter.h>
50 #include <isc/netaddr.h>
51 #include <isc/result.h>
52 #include <isc/sockaddr.h>
53 
54 #ifdef SIM
55 #include "ntpsim.h"
56 #endif
57 
58 #ifdef HAS_ROUTING_SOCKET
59 # include <net/route.h>
60 # ifdef HAVE_RTNETLINK
61 #  include <linux/rtnetlink.h>
62 # endif
63 #endif
64 
65 /*
66  * setsockopt does not always have the same arg declaration
67  * across all platforms. If it's not defined we make it empty
68  */
69 
70 #ifndef SETSOCKOPT_ARG_CAST
71 #define SETSOCKOPT_ARG_CAST
72 #endif
73 
74 extern int listen_to_virtual_ips;
75 
76 #ifndef IPTOS_DSCP_EF
77 #define IPTOS_DSCP_EF 0xb8
78 #endif
79 int qos = IPTOS_DSCP_EF;	/* QoS RFC3246 */
80 
81 #ifdef LEAP_SMEAR
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.
85  */
86 int leap_smear_intv;
87 #endif
88 
89 /*
90  * NIC rule entry
91  */
92 typedef struct nic_rule_tag nic_rule;
93 
94 struct nic_rule_tag {
95 	nic_rule *	next;
96 	nic_rule_action	action;
97 	nic_rule_match	match_type;
98 	char *		if_name;
99 	sockaddr_u	addr;
100 	int		prefixlen;
101 };
102 
103 /*
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.
106  */
107 nic_rule *nic_rule_list;
108 
109 
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
115 #  else
116 #   define CMSG_BUFSIZE  1536 /* moderate default */
117 #  endif
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
123 #  else
124 #   define CMSG_BUFSIZE  1536 /* moderate default */
125 #  endif
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
131 #  else
132 #   define CMSG_BUFSIZE  1536 /* moderate default */
133 #  endif
134 #else
135 /* fill in for old/other timestamp interfaces */
136 #endif
137 
138 #if defined(SYS_WINNT)
139 #include "win32_io.h"
140 #include <isc/win32os.h>
141 #endif
142 
143 /*
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.
151  *
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.
157  */
158 
159 
160 /*
161  * Other statistics of possible interest
162  */
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 */
168 
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 */
172 
173 /*
174  * Interface stuff
175  */
176 endpt *	any_interface;		/* wildcard ipv4 interface */
177 endpt *	any6_interface;		/* wildcard ipv6 interface */
178 endpt *	loopback_interface;	/* loopback ipv4 interface */
179 
180 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 */
183 
184 int disable_dynamic_updates;		/* scan interfaces once only */
185 
186 #ifdef REFCLOCK
187 /*
188  * Refclock stuff.	We keep a chain of structures with data concerning
189  * the guys we are doing I/O for.
190  */
191 static	struct refclockio *refio;
192 #endif /* REFCLOCK */
193 
194 /*
195  * File descriptor masks etc. for call to select
196  * Not needed for I/O Completion Ports or anything outside this file
197  */
198 static fd_set activefds;
199 static int maxactivefd;
200 
201 /*
202  * bit alternating value to detect verified interfaces during an update cycle
203  */
204 static  u_short		sys_interphase = 0;
205 
206 static endpt *	new_interface(endpt *);
207 static void	add_interface(endpt *);
208 static int	update_interfaces(u_short, interface_receiver_t,
209 				  void *);
210 static void	remove_interface(endpt *);
211 static endpt *	create_interface(u_short, endpt *);
212 
213 static int	is_wildcard_addr	(const sockaddr_u *);
214 
215 /*
216  * Multicast functions
217  */
218 static	isc_boolean_t	addr_ismulticast	(sockaddr_u *);
219 static	isc_boolean_t	is_anycast		(sockaddr_u *,
220 						 const char *);
221 
222 /*
223  * Not all platforms support multicast
224  */
225 #ifdef MCAST
226 static	isc_boolean_t	socket_multicast_enable	(endpt *, sockaddr_u *);
227 static	isc_boolean_t	socket_multicast_disable(endpt *, sockaddr_u *);
228 #endif
229 
230 #ifdef DEBUG
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)
235 #else
236 #define DPRINT_INTERFACE(level, args) do {} while (0)
237 #endif
238 
239 typedef struct vsock vsock_t;
240 enum desc_type { FD_TYPE_SOCKET, FD_TYPE_FILE };
241 
242 struct vsock {
243 	vsock_t	*	link;
244 	SOCKET		fd;
245 	enum desc_type	type;
246 };
247 
248 vsock_t	*fd_list;
249 
250 #if !defined(HAVE_IO_COMPLETION_PORT) && defined(HAS_ROUTING_SOCKET)
251 /*
252  * async notification processing (e. g. routing sockets)
253  */
254 /*
255  * support for receiving data on fd that is not a refclock or a socket
256  * like e. g. routing sockets
257  */
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 */
263 };
264 
265 struct asyncio_reader *asyncio_reader_list;
266 
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 *);
271 
272 #endif /* !defined(HAVE_IO_COMPLETION_PORT) && defined(HAS_ROUTING_SOCKET) */
273 
274 static void init_async_notifications (void);
275 
276 static	int	addr_eqprefix	(const sockaddr_u *, const sockaddr_u *,
277 				 int);
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 *);
284 
285 #if !defined(HAVE_IO_COMPLETION_PORT) && !defined(HAVE_SIGNALED_IO)
286 static	char *	fdbits		(int, const fd_set *);
287 #endif
288 #ifdef  OS_MISSES_SPECIFIC_ROUTE_UPDATES
289 static	isc_boolean_t	socket_broadcast_disable (struct interface *, sockaddr_u *);
290 #endif
291 
292 typedef struct remaddr remaddr_t;
293 
294 struct remaddr {
295 	remaddr_t *		link;
296 	sockaddr_u		addr;
297 	endpt *			ep;
298 };
299 
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 */
304 
305 static endpt *	wildipv4;
306 static endpt *	wildipv6;
307 
308 #ifdef SYS_WINNT
309 int accept_wildcard_if_for_winnt;
310 #else
311 const int accept_wildcard_if_for_winnt = FALSE;
312 #endif
313 
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);
324 #ifdef DEBUG
325 static const char *	action_text	(nic_rule_action);
326 #endif
327 static nic_rule_action	interface_action(char *, sockaddr_u *, u_int32);
328 static void		convert_isc_if	(isc_interface_t *,
329 					 endpt *, u_short);
330 static void		calc_addr_distance(sockaddr_u *,
331 					   const sockaddr_u *,
332 					   const sockaddr_u *);
333 static int		cmp_addr_distance(const sockaddr_u *,
334 					  const sockaddr_u *);
335 
336 /*
337  * Routines to read the ntp packets
338  */
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);
344 #ifdef REFCLOCK
345 static inline int	read_refclock_packet	(SOCKET, struct refclockio *, l_fp);
346 #endif
347 #ifdef HAVE_SIGNALED_IO
348 static void 		input_handler		(l_fp*);
349 #endif
350 #endif
351 
352 
353 #ifndef HAVE_IO_COMPLETION_PORT
354 void
355 maintain_activefds(
356 	int fd,
357 	int closing
358 	)
359 {
360 	int i;
361 
362 	if (fd < 0 || fd >= FD_SETSIZE) {
363 		msyslog(LOG_ERR,
364 			"Too many sockets in use, FD_SETSIZE %d exceeded by fd %d",
365 			FD_SETSIZE, fd);
366 		exit(1);
367 	}
368 
369 	if (!closing) {
370 		FD_SET(fd, &activefds);
371 		maxactivefd = max(fd, maxactivefd);
372 	} else {
373 		FD_CLR(fd, &activefds);
374 		if (maxactivefd && fd == maxactivefd) {
375 			for (i = maxactivefd - 1; i >= 0; i--)
376 				if (FD_ISSET(i, &activefds)) {
377 					maxactivefd = i;
378 					break;
379 				}
380 			INSIST(fd != maxactivefd);
381 		}
382 	}
383 }
384 #endif	/* !HAVE_IO_COMPLETION_PORT */
385 
386 
387 #ifdef DEBUG_TIMING
388 /*
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
394  */
395 void
396 collect_timing(struct recvbuf *rb, const char *tag, int count, l_fp *dts)
397 {
398 	char buf[256];
399 
400 	snprintf(buf, sizeof(buf), "%s %d %s %s",
401 		 (rb != NULL)
402 		     ? ((rb->dstadr != NULL)
403 			    ? stoa(&rb->recv_srcadr)
404 			    : "-REFCLOCK-")
405 		     : "-",
406 		 count, lfptoa(dts, 9), tag);
407 	record_timing_stats(buf);
408 }
409 #endif
410 
411 /*
412  * About dynamic interfaces, sockets, reception and more...
413  *
414  * the code solves following tasks:
415  *
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
423  *     down)
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
430  *
431  * special issues:
432  *
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.
444  *
445  * Frank Kardel 20050910
446  */
447 
448 /*
449  * init_io - initialize I/O module.
450  */
451 void
452 init_io(void)
453 {
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;
458 
459 #ifdef WORK_PIPE
460 	addremove_io_fd = &ntpd_addremove_io_fd;
461 #endif
462 
463 #if defined(SYS_WINNT)
464 	init_io_completion_port();
465 #elif defined(HAVE_SIGNALED_IO)
466 	(void) set_signal(input_handler);
467 #endif
468 }
469 
470 
471 static void
472 ntpd_addremove_io_fd(
473 	int	fd,
474 	int	is_pipe,
475 	int	remove_it
476 	)
477 {
478 	UNUSED_ARG(is_pipe);
479 
480 #ifdef HAVE_SIGNALED_IO
481 	if (!remove_it)
482 		init_socket_sig(fd);
483 #endif /* not HAVE_SIGNALED_IO */
484 
485 	maintain_activefds(fd, remove_it);
486 }
487 
488 
489 /*
490  * io_open_sockets - call socket creation routine
491  */
492 void
493 io_open_sockets(void)
494 {
495 	static int already_opened;
496 
497 	if (already_opened || HAVE_OPT( SAVECONFIGQUIT ))
498 		return;
499 
500 	already_opened = 1;
501 
502 	/*
503 	 * Create the sockets
504 	 */
505 	BLOCKIO();
506 	create_sockets(NTP_PORT);
507 	UNBLOCKIO();
508 
509 	init_async_notifications();
510 
511 	DPRINTF(3, ("io_open_sockets: maxactivefd %d\n", maxactivefd));
512 }
513 
514 
515 #ifdef DEBUG
516 /*
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.
523  */
524 void
525 interface_dump(const endpt *itf)
526 {
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);
547 }
548 
549 /*
550  * sockaddr_dump - hex dump the start of a sockaddr_u
551  */
552 static void
553 sockaddr_dump(const sockaddr_u *psau)
554 {
555 	/* Limit the size of the sockaddr_in6 hex dump */
556 	const int maxsize = min(32, sizeof(psau->sa6));
557 	const u_char *	cp;
558 	int		i;
559 
560 	/* XXX: Should we limit maxsize based on psau->saX.sin_family? */
561 	cp = (const void *)&psau->sa6;
562 
563 	for(i = 0; i < maxsize; i++) {
564 		printf("%02x", *cp++);
565 		if (!((i + 1) % 4))
566 			printf(" ");
567 	}
568 	printf("\n");
569 }
570 
571 /*
572  * print_interface - helper to output debug information
573  */
574 static void
575 print_interface(const endpt *iface, const char *pfx, const char *sfx)
576 {
577 	printf("%sinterface #%d: fd=%lld, bfd=%lld, name=%s, flags=0x%x, ifindex=%u, sin=%s",
578 	       pfx,
579 	       iface->ifnum,
580 	       (long long)iface->fd,
581 	       (long long)iface->bfd,
582 	       iface->name,
583 	       iface->flags,
584 	       iface->ifindex,
585 	       stoa(&iface->sin));
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));
590 	}
591 	printf(", %s:%s",
592 	       (iface->ignore_packets)
593 		   ? "Disabled"
594 		   : "Enabled",
595 	       sfx);
596 	if (debug > 4)	/* in-depth debugging only */
597 		interface_dump(iface);
598 }
599 #endif
600 
601 #if !defined(HAVE_IO_COMPLETION_PORT) && defined(HAS_ROUTING_SOCKET)
602 /*
603  * create an asyncio_reader structure
604  */
605 static struct asyncio_reader *
606 new_asyncio_reader(void)
607 {
608 	struct asyncio_reader *reader;
609 
610 	reader = emalloc_zero(sizeof(*reader));
611 	reader->fd = INVALID_SOCKET;
612 
613 	return reader;
614 }
615 
616 /*
617  * delete a reader
618  */
619 static void
620 delete_asyncio_reader(
621 	struct asyncio_reader *reader
622 	)
623 {
624 	free(reader);
625 }
626 
627 /*
628  * add asynchio_reader
629  */
630 static void
631 add_asyncio_reader(
632 	struct asyncio_reader *	reader,
633 	enum desc_type		type)
634 {
635 	LINK_SLIST(asyncio_reader_list, reader, link);
636 	add_fd_to_list(reader->fd, type);
637 }
638 
639 /*
640  * remove asynchio_reader
641  */
642 static void
643 remove_asyncio_reader(
644 	struct asyncio_reader *reader
645 	)
646 {
647 	struct asyncio_reader *unlinked;
648 
649 	UNLINK_SLIST(unlinked, asyncio_reader_list, reader, link,
650 	    struct asyncio_reader);
651 
652 	if (reader->fd != INVALID_SOCKET)
653 		close_and_delete_fd_from_list(reader->fd);
654 
655 	reader->fd = INVALID_SOCKET;
656 }
657 #endif /* !defined(HAVE_IO_COMPLETION_PORT) && defined(HAS_ROUTING_SOCKET) */
658 
659 
660 /* compare two sockaddr prefixes */
661 static int
662 addr_eqprefix(
663 	const sockaddr_u *	a,
664 	const sockaddr_u *	b,
665 	int			prefixlen
666 	)
667 {
668 	isc_netaddr_t		isc_a;
669 	isc_netaddr_t		isc_b;
670 	isc_sockaddr_t		isc_sa;
671 
672 	ZERO(isc_sa);
673 	memcpy(&isc_sa.type, a, min(sizeof(isc_sa.type), sizeof(*a)));
674 	isc_netaddr_fromsockaddr(&isc_a, &isc_sa);
675 
676 	ZERO(isc_sa);
677 	memcpy(&isc_sa.type, b, min(sizeof(isc_sa.type), sizeof(*b)));
678 	isc_netaddr_fromsockaddr(&isc_b, &isc_sa);
679 
680 	return (int)isc_netaddr_eqprefix(&isc_a, &isc_b,
681 					 (u_int)prefixlen);
682 }
683 
684 
685 static int
686 addr_samesubnet(
687 	const sockaddr_u *	a,
688 	const sockaddr_u *	a_mask,
689 	const sockaddr_u *	b,
690 	const sockaddr_u *	b_mask
691 	)
692 {
693 	const u_int32 *	pa;
694 	const u_int32 *	pa_limit;
695 	const u_int32 *	pb;
696 	const u_int32 *	pm;
697 	size_t		loops;
698 
699 	REQUIRE(AF(a) == AF(a_mask));
700 	REQUIRE(AF(b) == AF(b_mask));
701 	/*
702 	 * With address and mask families verified to match, comparing
703 	 * the masks also validates the address's families match.
704 	 */
705 	if (!SOCK_EQ(a_mask, b_mask))
706 		return FALSE;
707 
708 	if (IS_IPV6(a)) {
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);
713 	} else {
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);
718 	}
719 	for (pa_limit = pa + loops; pa < pa_limit; pa++, pb++, pm++)
720 		if ((*pa & *pm) != (*pb & *pm))
721 			return FALSE;
722 
723 	return TRUE;
724 }
725 
726 
727 /*
728  * interface list enumerator - visitor pattern
729  */
730 void
731 interface_enumerate(
732 	interface_receiver_t	receiver,
733 	void *			data
734 	)
735 {
736 	interface_info_t ifi;
737 
738 	ifi.action = IFS_EXISTS;
739 	for (ifi.ep = ep_list; ifi.ep != NULL; ifi.ep = ifi.ep->elink)
740 		(*receiver)(data, &ifi);
741 }
742 
743 /*
744  * do standard initialization of interface structure
745  */
746 static void
747 init_interface(
748 	endpt *ep
749 	)
750 {
751 	ZERO(*ep);
752 	ep->fd = INVALID_SOCKET;
753 	ep->bfd = INVALID_SOCKET;
754 	ep->phase = sys_interphase;
755 }
756 
757 
758 /*
759  * create new interface structure initialize from
760  * template structure or via standard initialization
761  * function
762  */
763 static struct interface *
764 new_interface(
765 	struct interface *interface
766 	)
767 {
768 	struct interface *	iface;
769 
770 	iface = emalloc(sizeof(*iface));
771 
772 	if (NULL == interface)
773 		init_interface(iface);
774 	else				/* use the template */
775 		memcpy(iface, interface, sizeof(*iface));
776 
777 	/* count every new instance of an interface in the system */
778 	iface->ifnum = sys_ifnum++;
779 	iface->starttime = current_time;
780 
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");
784 		exit(1);
785 	}
786 #   endif
787 	return iface;
788 }
789 
790 
791 /*
792  * return interface storage into free memory pool
793  */
794 static void
795 delete_interface(
796 	endpt *ep
797 	)
798 {
799 #    ifdef HAVE_IO_COMPLETION_PORT
800 	io_completion_port_remove_interface(ep);
801 #    endif
802 	free(ep);
803 }
804 
805 
806 /*
807  * link interface into list of known interfaces
808  */
809 static void
810 add_interface(
811 	endpt *	ep
812 	)
813 {
814 	endpt **	pmclisthead;
815 	endpt *		scan;
816 	endpt *		scan_next;
817 	endpt *		unlinked;
818 	sockaddr_u *	addr;
819 	int		ep_local;
820 	int		scan_local;
821 	int		same_subnet;
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 */
826 	int		rc;
827 
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);
832 	ninterfaces++;
833 #ifdef MCAST
834 	/* the rest is for enabled multicast-capable addresses only */
835 	if (ep->ignore_packets || !(INT_MULTICAST & ep->flags) ||
836 	    INT_LOOPBACK & ep->flags)
837 		return;
838 # ifndef INCLUDE_IPV6_MULTICAST_SUPPORT
839 	if (AF_INET6 == ep->family)
840 		return;
841 # endif
842 	pmclisthead = (AF_INET == ep->family)
843 			 ? &mc4_list
844 			 : &mc6_list;
845 
846 	if (AF_INET6 == ep->family) {
847 		ep_local =
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);
852 	} else {
853 		ep_local = FALSE;
854 		ep_univ_iid = FALSE;
855 		ep_privacy = FALSE;
856 	}
857 	DPRINTF(4, ("add_interface mcast-capable %s%s%s%s\n",
858 		    stoa(&ep->sin),
859 		    (ep_local) ? " link/scope-local" : "",
860 		    (ep_univ_iid) ? " univ-IID" : "",
861 		    (ep_privacy) ? " privacy" : ""));
862 	/*
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
872 	 * addresses.
873 	 */
874 	for (scan = *pmclisthead; scan != NULL; scan = scan_next) {
875 		scan_next = scan->mclink;
876 		if (ep->family != scan->family)
877 			continue;
878 		if (strcmp(ep->name, scan->name))
879 			continue;
880 		same_subnet = addr_samesubnet(&ep->sin, &ep->mask,
881 					      &scan->sin, &scan->mask);
882 		if (AF_INET6 == ep->family) {
883 			addr = &scan->sin;
884 			scan_local =
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);
889 		} else {
890 			scan_local = FALSE;
891 			scan_univ_iid = FALSE;
892 			scan_privacy = FALSE;
893 		}
894 		DPRINTF(4, ("add_interface mcast-capable scan %s%s%s%s\n",
895 			    stoa(&scan->sin),
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",
903 				stoa(&ep->sin),
904 				(ep_local)
905 				    ? "tail"
906 				    : "head",
907 				stoa(&scan->sin)));
908 			return;
909 		}
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",
916 				(unlinked != scan)
917 				    ? "Failed to remove"
918 				    : "removed",
919 				stoa(&scan->sin), stoa(&ep->sin)));
920 		}
921 	}
922 	/*
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
926 	 * ones.
927 	 */
928 	if (ep_local)
929 		LINK_TAIL_SLIST(*pmclisthead, ep, mclink, endpt);
930 	else
931 		LINK_SLIST(*pmclisthead, ep, mclink);
932 	DPRINTF(4, ("added %s to %s of IPv%s multicast-capable unicast local address list\n",
933 		stoa(&ep->sin),
934 		(ep_local)
935 		    ? "tail"
936 		    : "head",
937 		(AF_INET == ep->family)
938 		    ? "4"
939 		    : "6"));
940 
941 	if (INVALID_SOCKET == ep->fd)
942 		return;
943 
944 	/*
945 	 * select the local address from which to send to multicast.
946 	 */
947 	switch (AF(&ep->sin)) {
948 
949 	case AF_INET :
950 		rc = setsockopt(ep->fd, IPPROTO_IP,
951 				IP_MULTICAST_IF,
952 				(void *)&NSRCADR(&ep->sin),
953 				sizeof(NSRCADR(&ep->sin)));
954 		if (rc)
955 			msyslog(LOG_ERR,
956 				"setsockopt IP_MULTICAST_IF %s fails: %m",
957 				stoa(&ep->sin));
958 		break;
959 
960 # ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
961 	case AF_INET6 :
962 		rc = setsockopt(ep->fd, IPPROTO_IPV6,
963 				 IPV6_MULTICAST_IF,
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))
968 			msyslog(LOG_ERR,
969 				"setsockopt IPV6_MULTICAST_IF %u for %s fails: %m",
970 				ep->ifindex, stoa(&ep->sin));
971 		break;
972 # endif
973 	}
974 #endif	/* MCAST */
975 }
976 
977 
978 /*
979  * remove interface from known interface list and clean up
980  * associated resources
981  */
982 static void
983 remove_interface(
984 	endpt *	ep
985 	)
986 {
987 	endpt *		unlinked;
988 	endpt **	pmclisthead;
989 	sockaddr_u	resmask;
990 
991 	UNLINK_SLIST(unlinked, ep_list, ep, elink, endpt);
992 	if (!ep->ignore_packets && INT_MULTICAST & ep->flags) {
993 		pmclisthead = (AF_INET == ep->family)
994 				 ? &mc4_list
995 				 : &mc6_list;
996 		UNLINK_SLIST(unlinked, *pmclisthead, ep, mclink, endpt);
997 		DPRINTF(4, ("%s %s IPv%s multicast-capable unicast local address list\n",
998 			stoa(&ep->sin),
999 			(unlinked != NULL)
1000 			    ? "removed from"
1001 			    : "not found on",
1002 			(AF_INET == ep->family)
1003 			    ? "4"
1004 			    : "6"));
1005 	}
1006 	delete_interface_from_list(ep);
1007 
1008 	if (ep->fd != INVALID_SOCKET) {
1009 		msyslog(LOG_INFO,
1010 			"Deleting interface #%d %s, %s#%d, interface stats: received=%ld, sent=%ld, dropped=%ld, active_time=%ld secs",
1011 			ep->ifnum,
1012 			ep->name,
1013 			stoa(&ep->sin),
1014 			SRCPORT(&ep->sin),
1015 			ep->received,
1016 			ep->sent,
1017 			ep->notsent,
1018 			current_time - ep->starttime);
1019 #	    ifdef HAVE_IO_COMPLETION_PORT
1020 		io_completion_port_remove_socket(ep->fd, ep);
1021 #	    endif
1022 		close_and_delete_fd_from_list(ep->fd);
1023 		ep->fd = INVALID_SOCKET;
1024 	}
1025 
1026 	if (ep->bfd != INVALID_SOCKET) {
1027 		msyslog(LOG_INFO,
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);
1032 #	    endif
1033 		close_and_delete_fd_from_list(ep->bfd);
1034 		ep->bfd = INVALID_SOCKET;
1035 	}
1036 #   ifdef HAVE_IO_COMPLETION_PORT
1037 	io_completion_port_remove_interface(ep);
1038 #   endif
1039 
1040 	ninterfaces--;
1041 	mon_clearinterface(ep);
1042 
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);
1047 }
1048 
1049 
1050 static void
1051 log_listen_address(
1052 	endpt *	ep
1053 	)
1054 {
1055 	msyslog(LOG_INFO, "%s on %d %s %s",
1056 		(ep->ignore_packets)
1057 		    ? "Listen and drop"
1058 		    : "Listen normally",
1059 		ep->ifnum,
1060 		ep->name,
1061 		sptoa(&ep->sin));
1062 }
1063 
1064 
1065 static void
1066 create_wildcards(
1067 	u_short	port
1068 	)
1069 {
1070 	int			v4wild;
1071 #ifdef INCLUDE_IPV6_SUPPORT
1072 	int			v6wild;
1073 #endif
1074 	sockaddr_u		wildaddr;
1075 	nic_rule_action		action;
1076 	struct interface *	wildif;
1077 
1078 	/*
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).
1083 	 */
1084 	action = ACTION_LISTEN;
1085 	ZERO(wildaddr);
1086 
1087 #ifdef INCLUDE_IPV6_SUPPORT
1088 	/*
1089 	 * create pseudo-interface with wildcard IPv6 address
1090 	 */
1091 	v6wild = ipv6_works;
1092 	if (v6wild) {
1093 		/* set wildaddr to the v6 wildcard address :: */
1094 		ZERO(wildaddr);
1095 		AF(&wildaddr) = AF_INET6;
1096 		SET_ADDR6N(&wildaddr, in6addr_any);
1097 		SET_PORT(&wildaddr, port);
1098 		SET_SCOPE(&wildaddr, 0);
1099 
1100 		/* check for interface/nic rules affecting the wildcard */
1101 		action = interface_action(NULL, &wildaddr, 0);
1102 		v6wild = (ACTION_IGNORE != action);
1103 	}
1104 	if (v6wild) {
1105 		wildif = new_interface(NULL);
1106 
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);
1112 
1113 		wildif->flags = INT_UP | INT_WILDCARD;
1114 		wildif->ignore_packets = (ACTION_DROP == action);
1115 
1116 		wildif->fd = open_socket(&wildif->sin, 0, 1, wildif);
1117 
1118 		if (wildif->fd != INVALID_SOCKET) {
1119 			wildipv6 = wildif;
1120 			any6_interface = wildif;
1121 			add_addr_to_list(&wildif->sin, wildif);
1122 			add_interface(wildif);
1123 			log_listen_address(wildif);
1124 		} else {
1125 			msyslog(LOG_ERR,
1126 				"unable to bind to wildcard address %s - another process may be running - EXITING",
1127 				stoa(&wildif->sin));
1128 			exit(1);
1129 		}
1130 		DPRINT_INTERFACE(2, (wildif, "created ", "\n"));
1131 	}
1132 #endif
1133 
1134 	/*
1135 	 * create pseudo-interface with wildcard IPv4 address
1136 	 */
1137 	v4wild = ipv4_works;
1138 	if (v4wild) {
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);
1143 
1144 		/* check for interface/nic rules affecting the wildcard */
1145 		action = interface_action(NULL, &wildaddr, 0);
1146 		v4wild = (ACTION_IGNORE != action);
1147 	}
1148 	if (v4wild) {
1149 		wildif = new_interface(NULL);
1150 
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);
1156 
1157 		wildif->flags = INT_BROADCAST | INT_UP | INT_WILDCARD;
1158 		wildif->ignore_packets = (ACTION_DROP == action);
1159 #if defined(MCAST)
1160 		/*
1161 		 * enable multicast reception on the broadcast socket
1162 		 */
1163 		AF(&wildif->bcast) = AF_INET;
1164 		SET_ADDR4N(&wildif->bcast, INADDR_ANY);
1165 		SET_PORT(&wildif->bcast, port);
1166 #endif /* MCAST */
1167 		wildif->fd = open_socket(&wildif->sin, 0, 1, wildif);
1168 
1169 		if (wildif->fd != INVALID_SOCKET) {
1170 			wildipv4 = wildif;
1171 			any_interface = wildif;
1172 
1173 			add_addr_to_list(&wildif->sin, wildif);
1174 			add_interface(wildif);
1175 			log_listen_address(wildif);
1176 		} else {
1177 			msyslog(LOG_ERR,
1178 				"unable to bind to wildcard address %s - another process may be running - EXITING",
1179 				stoa(&wildif->sin));
1180 			exit(1);
1181 		}
1182 		DPRINT_INTERFACE(2, (wildif, "created ", "\n"));
1183 	}
1184 }
1185 
1186 
1187 /*
1188  * add_nic_rule() -- insert a rule entry at the head of nic_rule_list.
1189  */
1190 void
1191 add_nic_rule(
1192 	nic_rule_match	match_type,
1193 	const char *	if_name,	/* interface name or numeric address */
1194 	int		prefixlen,
1195 	nic_rule_action	action
1196 	)
1197 {
1198 	nic_rule *	rule;
1199 	isc_boolean_t	is_ip;
1200 
1201 	rule = emalloc_zero(sizeof(*rule));
1202 	rule->match_type = match_type;
1203 	rule->prefixlen = prefixlen;
1204 	rule->action = action;
1205 
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);
1213 		REQUIRE(is_ip);
1214 	} else
1215 		REQUIRE(NULL == if_name);
1216 
1217 	LINK_SLIST(nic_rule_list, rule, next);
1218 }
1219 
1220 
1221 #ifdef DEBUG
1222 static const char *
1223 action_text(
1224 	nic_rule_action	action
1225 	)
1226 {
1227 	const char *t;
1228 
1229 	switch (action) {
1230 
1231 	default:
1232 		t = "ERROR";	/* quiet uninit warning */
1233 		DPRINTF(1, ("fatal: unknown nic_rule_action %d\n",
1234 			    action));
1235 		ENSURE(0);
1236 		break;
1237 
1238 	case ACTION_LISTEN:
1239 		t = "listen";
1240 		break;
1241 
1242 	case ACTION_IGNORE:
1243 		t = "ignore";
1244 		break;
1245 
1246 	case ACTION_DROP:
1247 		t = "drop";
1248 		break;
1249 	}
1250 
1251 	return t;
1252 }
1253 #endif	/* DEBUG */
1254 
1255 
1256 static nic_rule_action
1257 interface_action(
1258 	char *		if_name,
1259 	sockaddr_u *	if_addr,
1260 	u_int32		if_flags
1261 	)
1262 {
1263 	nic_rule *	rule;
1264 	int		isloopback;
1265 	int		iswildcard;
1266 
1267 	DPRINTF(4, ("interface_action: interface %s ",
1268 		    (if_name != NULL) ? if_name : "wildcard"));
1269 
1270 	iswildcard = is_wildcard_addr(if_addr);
1271 	isloopback = !!(INT_LOOPBACK & if_flags);
1272 
1273 	/*
1274 	 * Find any matching NIC rule from --interface / -I or ntp.conf
1275 	 * interface/nic rules.
1276 	 */
1277 	for (rule = nic_rule_list; rule != NULL; rule = rule->next) {
1278 
1279 		switch (rule->match_type) {
1280 
1281 		case MATCH_ALL:
1282 			/* loopback and wildcard excluded from "all" */
1283 			if (isloopback || iswildcard)
1284 				break;
1285 			DPRINTF(4, ("nic all %s\n",
1286 			    action_text(rule->action)));
1287 			return rule->action;
1288 
1289 		case MATCH_IPV4:
1290 			if (IS_IPV4(if_addr)) {
1291 				DPRINTF(4, ("nic ipv4 %s\n",
1292 				    action_text(rule->action)));
1293 				return rule->action;
1294 			}
1295 			break;
1296 
1297 		case MATCH_IPV6:
1298 			if (IS_IPV6(if_addr)) {
1299 				DPRINTF(4, ("nic ipv6 %s\n",
1300 				    action_text(rule->action)));
1301 				return rule->action;
1302 			}
1303 			break;
1304 
1305 		case MATCH_WILDCARD:
1306 			if (iswildcard) {
1307 				DPRINTF(4, ("nic wildcard %s\n",
1308 				    action_text(rule->action)));
1309 				return rule->action;
1310 			}
1311 			break;
1312 
1313 		case MATCH_IFADDR:
1314 			if (rule->prefixlen != -1) {
1315 				if (addr_eqprefix(if_addr, &rule->addr,
1316 						  rule->prefixlen)) {
1317 
1318 					DPRINTF(4, ("subnet address match - %s\n",
1319 					    action_text(rule->action)));
1320 					return rule->action;
1321 				}
1322 			} else
1323 				if (SOCK_EQ(if_addr, &rule->addr)) {
1324 
1325 					DPRINTF(4, ("address match - %s\n",
1326 					    action_text(rule->action)));
1327 					return rule->action;
1328 				}
1329 			break;
1330 
1331 		case MATCH_IFNAME:
1332 			if (if_name != NULL
1333 #if defined(HAVE_FNMATCH) && defined(FNM_CASEFOLD)
1334 			    && !fnmatch(rule->if_name, if_name, FNM_CASEFOLD)
1335 #else
1336 			    && !strcasecmp(if_name, rule->if_name)
1337 #endif
1338 			    ) {
1339 
1340 				DPRINTF(4, ("interface name match - %s\n",
1341 				    action_text(rule->action)));
1342 				return rule->action;
1343 			}
1344 			break;
1345 		}
1346 	}
1347 
1348 	/*
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.
1353 	 */
1354 	if (isloopback) {
1355 		DPRINTF(4, ("default loopback listen\n"));
1356 		return ACTION_LISTEN;
1357 	}
1358 
1359 	/*
1360 	 * Treat wildcard addresses specially.  If there is no explicit
1361 	 * "nic ... wildcard" or "nic ... 0.0.0.0" or "nic ... ::" rule
1362 	 * default to drop.
1363 	 */
1364 	if (iswildcard) {
1365 		DPRINTF(4, ("default wildcard drop\n"));
1366 		return ACTION_DROP;
1367 	}
1368 
1369 	/*
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.
1373 	 */
1374 	if (!listen_to_virtual_ips && if_name != NULL
1375 	    && (strchr(if_name, ':') != NULL)) {
1376 
1377 		DPRINTF(4, ("virtual ip - ignore\n"));
1378 		return ACTION_IGNORE;
1379 	}
1380 
1381 	/*
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.
1389 	 */
1390 	if (NULL == nic_rule_list) {
1391 		DPRINTF(4, ("default listen\n"));
1392 		return ACTION_LISTEN;
1393 	}
1394 
1395 	DPRINTF(4, ("implicit ignore\n"));
1396 	return ACTION_IGNORE;
1397 }
1398 
1399 
1400 static void
1401 convert_isc_if(
1402 	isc_interface_t *isc_if,
1403 	endpt *itf,
1404 	u_short port
1405 	)
1406 {
1407 	const u_char v6loop[16] = {0, 0, 0, 0, 0, 0, 0, 0,
1408 				   0, 0, 0, 0, 0, 0, 0, 1};
1409 
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);
1419 
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;
1423 
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;
1428 		}
1429 	}
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);
1434 
1435 		SET_SCOPE(&itf->sin, isc_if->address.zone);
1436 	}
1437 #endif /* INCLUDE_IPV6_SUPPORT */
1438 
1439 
1440 	/* Process the rest of the flags */
1441 
1442 	itf->flags |=
1443 		  ((INTERFACE_F_UP & isc_if->flags)
1444 			? INT_UP : 0)
1445 		| ((INTERFACE_F_LOOPBACK & isc_if->flags)
1446 			? INT_LOOPBACK : 0)
1447 		| ((INTERFACE_F_POINTTOPOINT & isc_if->flags)
1448 			? INT_PPP : 0)
1449 		| ((INTERFACE_F_MULTICAST & isc_if->flags)
1450 			? INT_MULTICAST : 0)
1451 		| ((INTERFACE_F_PRIVACY & isc_if->flags)
1452 			? INT_PRIVACY : 0)
1453 		;
1454 
1455 	/*
1456 	 * Clear the loopback flag if the address is not localhost.
1457 	 * http://bugs.ntp.org/1683
1458 	 */
1459 	if (INT_LOOPBACK & itf->flags) {
1460 		if (AF_INET == itf->family) {
1461 			if (127 != (SRCADR(&itf->sin) >> 24))
1462 				itf->flags &= ~INT_LOOPBACK;
1463 		} else {
1464 			if (memcmp(v6loop, NSRCADR6(&itf->sin),
1465 				   sizeof(NSRCADR6(&itf->sin))))
1466 				itf->flags &= ~INT_LOOPBACK;
1467 		}
1468 	}
1469 }
1470 
1471 
1472 /*
1473  * refresh_interface
1474  *
1475  * some OSes have been observed to keep
1476  * cached routes even when more specific routes
1477  * become available.
1478  * this can be mitigated by re-binding
1479  * the socket.
1480  */
1481 static int
1482 refresh_interface(
1483 	struct interface * interface
1484 	)
1485 {
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 */
1491 		if (bcast)
1492 			socket_broadcast_disable(interface, &interface->sin);
1493 
1494 		close_and_delete_fd_from_list(interface->fd);
1495 
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);
1500 		 /*
1501 		  * reset TTL indication so TTL is is set again
1502 		  * next time around
1503 		  */
1504 		interface->last_ttl = 0;
1505 		return (interface->fd != INVALID_SOCKET);
1506 	} else
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 */
1511 }
1512 
1513 /*
1514  * interface_update - externally callable update function
1515  */
1516 void
1517 interface_update(
1518 	interface_receiver_t	receiver,
1519 	void *			data)
1520 {
1521 	int new_interface_found;
1522 
1523 	if (disable_dynamic_updates)
1524 		return;
1525 
1526 	BLOCKIO();
1527 	new_interface_found = update_interfaces(NTP_PORT, receiver, data);
1528 	UNBLOCKIO();
1529 
1530 	if (!new_interface_found)
1531 		return;
1532 
1533 #ifdef DEBUG
1534 	msyslog(LOG_DEBUG, "new interface(s) found: waking up resolver");
1535 #endif
1536 	interrupt_worker_sleep();
1537 }
1538 
1539 
1540 /*
1541  * sau_from_netaddr() - convert network address on-wire formats.
1542  * Convert from libisc's isc_netaddr_t to NTP's sockaddr_u
1543  */
1544 void
1545 sau_from_netaddr(
1546 	sockaddr_u *psau,
1547 	const isc_netaddr_t *pna
1548 	)
1549 {
1550 	ZERO_SOCK(psau);
1551 	AF(psau) = (u_short)pna->family;
1552 	switch (pna->family) {
1553 
1554 	case AF_INET:
1555 		memcpy(&psau->sa4.sin_addr, &pna->type.in,
1556 		       sizeof(psau->sa4.sin_addr));
1557 		break;
1558 
1559 	case AF_INET6:
1560 		memcpy(&psau->sa6.sin6_addr, &pna->type.in6,
1561 		       sizeof(psau->sa6.sin6_addr));
1562 		break;
1563 	}
1564 }
1565 
1566 
1567 static int
1568 is_wildcard_addr(
1569 	const sockaddr_u *psau
1570 	)
1571 {
1572 	if (IS_IPV4(psau) && !NSRCADR(psau))
1573 		return 1;
1574 
1575 #ifdef INCLUDE_IPV6_SUPPORT
1576 	if (IS_IPV6(psau) && S_ADDR6_EQ(psau, &in6addr_any))
1577 		return 1;
1578 #endif
1579 
1580 	return 0;
1581 }
1582 
1583 
1584 #ifdef OS_NEEDS_REUSEADDR_FOR_IFADDRBIND
1585 /*
1586  * enable/disable re-use of wildcard address socket
1587  */
1588 static void
1589 set_wildcard_reuse(
1590 	u_short	family,
1591 	int	on
1592 	)
1593 {
1594 	struct interface *any;
1595 	SOCKET fd = INVALID_SOCKET;
1596 
1597 	any = ANY_INTERFACE_BYFAM(family);
1598 	if (any != NULL)
1599 		fd = any->fd;
1600 
1601 	if (fd != INVALID_SOCKET) {
1602 		if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
1603 			       (void *)&on, sizeof(on)))
1604 			msyslog(LOG_ERR,
1605 				"set_wildcard_reuse: setsockopt(SO_REUSEADDR, %s) failed: %m",
1606 				on ? "on" : "off");
1607 
1608 		DPRINTF(4, ("set SO_REUSEADDR to %s on %s\n",
1609 			    on ? "on" : "off",
1610 			    stoa(&any->sin)));
1611 	}
1612 }
1613 #endif /* OS_NEEDS_REUSEADDR_FOR_IFADDRBIND */
1614 
1615 static isc_boolean_t
1616 check_flags(
1617 	sockaddr_u *psau,
1618 	const char *name,
1619 	u_int32 flags
1620 	)
1621 {
1622 #if defined(SIOCGIFAFLAG_IN)
1623 	struct ifreq ifr;
1624 	int fd;
1625 
1626 	if (psau->sa.sa_family != AF_INET)
1627 		return ISC_FALSE;
1628 	if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
1629 		return ISC_FALSE;
1630 	ZERO(ifr);
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) {
1634 		close(fd);
1635 		return ISC_FALSE;
1636 	}
1637 	close(fd);
1638 	if ((ifr.ifr_addrflags & flags) != 0)
1639 		return ISC_TRUE;
1640 #endif	/* SIOCGIFAFLAG_IN */
1641 	return ISC_FALSE;
1642 }
1643 
1644 static isc_boolean_t
1645 check_flags6(
1646 	sockaddr_u *psau,
1647 	const char *name,
1648 	u_int32 flags6
1649 	)
1650 {
1651 #if defined(INCLUDE_IPV6_SUPPORT) && defined(SIOCGIFAFLAG_IN6)
1652 	struct in6_ifreq ifr6;
1653 	int fd;
1654 
1655 	if (psau->sa.sa_family != AF_INET6)
1656 		return ISC_FALSE;
1657 	if ((fd = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
1658 		return ISC_FALSE;
1659 	ZERO(ifr6);
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) {
1663 		close(fd);
1664 		return ISC_FALSE;
1665 	}
1666 	close(fd);
1667 	if ((ifr6.ifr_ifru.ifru_flags6 & flags6) != 0)
1668 		return ISC_TRUE;
1669 #endif	/* INCLUDE_IPV6_SUPPORT && SIOCGIFAFLAG_IN6 */
1670 	return ISC_FALSE;
1671 }
1672 
1673 static isc_boolean_t
1674 is_anycast(
1675 	sockaddr_u *psau,
1676 	const char *name
1677 	)
1678 {
1679 #ifdef IN6_IFF_ANYCAST
1680 	return check_flags6(psau, name, IN6_IFF_ANYCAST);
1681 #else
1682 	return ISC_FALSE;
1683 #endif
1684 }
1685 
1686 static isc_boolean_t
1687 is_valid(
1688 	sockaddr_u *psau,
1689 	const char *name
1690 	)
1691 {
1692 	u_int32 flags;
1693 
1694 	flags = 0;
1695 	switch (psau->sa.sa_family) {
1696 	case AF_INET:
1697 #ifdef IN_IFF_DETACHED
1698 		flags |= IN_IFF_DETACHED;
1699 #endif
1700 #ifdef IN_IFF_TENTATIVE
1701 		flags |= IN_IFF_TENTATIVE;
1702 #endif
1703 		return check_flags(psau, name, flags) ? ISC_FALSE : ISC_TRUE;
1704 	case AF_INET6:
1705 #ifdef IN6_IFF_DEPARTED
1706 		flags |= IN6_IFF_DEPARTED;
1707 #endif
1708 #ifdef IN6_IFF_DETACHED
1709 		flags |= IN6_IFF_DETACHED;
1710 #endif
1711 #ifdef IN6_IFF_TENTATIVE
1712 		flags |= IN6_IFF_TENTATIVE;
1713 #endif
1714 		return check_flags6(psau, name, flags) ? ISC_FALSE : ISC_TRUE;
1715 	default:
1716 		return ISC_FALSE;
1717 	}
1718 }
1719 
1720 /*
1721  * update_interface strategy
1722  *
1723  * toggle configuration phase
1724  *
1725  * Phase 1:
1726  * forall currently existing interfaces
1727  *   if address is known:
1728  *	drop socket - rebind again
1729  *
1730  *   if address is NOT known:
1731  *	attempt to create a new interface entry
1732  *
1733  * Phase 2:
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
1739  *
1740  * Phase 3:
1741  *   attempt to re-assign interfaces to peers
1742  *
1743  */
1744 
1745 static int
1746 update_interfaces(
1747 	u_short			port,
1748 	interface_receiver_t	receiver,
1749 	void *			data
1750 	)
1751 {
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;
1759 	endpt			enumep;
1760 	endpt *			ep;
1761 	endpt *			next_ep;
1762 
1763 	DPRINTF(3, ("update_interfaces(%d)\n", port));
1764 
1765 	/*
1766 	 * phase one - scan interfaces
1767 	 * - create those that are not found
1768 	 * - update those that are found
1769 	 */
1770 
1771 	new_interface_found = FALSE;
1772 	iter = NULL;
1773 	result = isc_interfaceiter_create(mctx, &iter);
1774 
1775 	if (result != ISC_R_SUCCESS)
1776 		return 0;
1777 
1778 	/*
1779 	 * Toggle system interface scan phase to find untouched
1780 	 * interfaces to be deleted.
1781 	 */
1782 	sys_interphase ^= 0x1;
1783 
1784 	for (result = isc_interfaceiter_first(iter);
1785 	     ISC_R_SUCCESS == result;
1786 	     result = isc_interfaceiter_next(iter)) {
1787 
1788 		result = isc_interfaceiter_current(iter, &isc_if);
1789 
1790 		if (result != ISC_R_SUCCESS)
1791 			break;
1792 
1793 		/* See if we have a valid family to use */
1794 		family = isc_if.address.family;
1795 		if (AF_INET != family && AF_INET6 != family)
1796 			continue;
1797 		if (AF_INET == family && !ipv4_works)
1798 			continue;
1799 		if (AF_INET6 == family && !ipv6_works)
1800 			continue;
1801 
1802 		/* create prototype */
1803 		init_interface(&enumep);
1804 
1805 		convert_isc_if(&isc_if, &enumep, port);
1806 
1807 		DPRINT_INTERFACE(4, (&enumep, "examining ", "\n"));
1808 
1809 		/*
1810 		 * Check if and how we are going to use the interface.
1811 		 */
1812 		switch (interface_action(enumep.name, &enumep.sin,
1813 					 enumep.flags)) {
1814 
1815 		case ACTION_IGNORE:
1816 			DPRINTF(4, ("ignoring interface %s (%s) - by nic rules\n",
1817 				    enumep.name, stoa(&enumep.sin)));
1818 			continue;
1819 
1820 		case ACTION_LISTEN:
1821 			DPRINTF(4, ("listen interface %s (%s) - by nic rules\n",
1822 				    enumep.name, stoa(&enumep.sin)));
1823 			enumep.ignore_packets = ISC_FALSE;
1824 			break;
1825 
1826 		case ACTION_DROP:
1827 			DPRINTF(4, ("drop on interface %s (%s) - by nic rules\n",
1828 				    enumep.name, stoa(&enumep.sin)));
1829 			enumep.ignore_packets = ISC_TRUE;
1830 			break;
1831 		}
1832 
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)));
1837 			continue;
1838 		}
1839 
1840 		/*
1841 		 * skip any interfaces UP and bound to a wildcard
1842 		 * address - some dhcp clients produce that in the
1843 		 * wild
1844 		 */
1845 		if (is_wildcard_addr(&enumep.sin))
1846 			continue;
1847 
1848 		if (is_anycast(&enumep.sin, isc_if.name))
1849 			continue;
1850 
1851 		/*
1852 		 * skip any address that is an invalid state to be used
1853 		 */
1854 		if (!is_valid(&enumep.sin, isc_if.name))
1855 			continue;
1856 
1857 		/*
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).
1862 		 */
1863 		ep = getinterface(&enumep.sin, INT_WILDCARD);
1864 
1865 		if (ep != NULL && refresh_interface(ep)) {
1866 			/*
1867 			 * found existing and up to date interface -
1868 			 * mark present.
1869 			 */
1870 			if (ep->phase != sys_interphase) {
1871 				/*
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.
1878 				 */
1879 				strlcpy(ep->name, enumep.name,
1880 					sizeof(ep->name));
1881 				ep->ignore_packets =
1882 					    enumep.ignore_packets;
1883 			} else {
1884 				/* name collision - rename interface */
1885 				strlcpy(ep->name, "*multiple*",
1886 					sizeof(ep->name));
1887 			}
1888 
1889 			DPRINT_INTERFACE(4, (ep, "updating ",
1890 					     " present\n"));
1891 
1892 			if (ep->ignore_packets !=
1893 			    enumep.ignore_packets) {
1894 				/*
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
1913 				 * occurs.
1914 				 */
1915 				msyslog(LOG_ERR,
1916 					"WARNING: conflicting enable configuration for interfaces %s and %s for address %s - unsupported configuration - address DISABLED",
1917 					enumep.name, ep->name,
1918 					stoa(&enumep.sin));
1919 
1920 				ep->ignore_packets = ISC_TRUE;
1921 			}
1922 
1923 			ep->phase = sys_interphase;
1924 
1925 			ifi.action = IFS_EXISTS;
1926 			ifi.ep = ep;
1927 			if (receiver != NULL)
1928 				(*receiver)(data, &ifi);
1929 		} else {
1930 			/*
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
1937 			 */
1938 			ep = create_interface(port, &enumep);
1939 
1940 			if (ep != NULL) {
1941 				ifi.action = IFS_CREATED;
1942 				ifi.ep = ep;
1943 				if (receiver != NULL)
1944 					(*receiver)(data, &ifi);
1945 
1946 				new_interface_found = TRUE;
1947 				DPRINT_INTERFACE(3,
1948 					(ep, "updating ",
1949 					 " new - created\n"));
1950 			} else {
1951 				DPRINT_INTERFACE(3,
1952 					(&enumep, "updating ",
1953 					 " new - creation FAILED"));
1954 
1955 				msyslog(LOG_INFO,
1956 					"failed to init interface for address %s",
1957 					stoa(&enumep.sin));
1958 				continue;
1959 			}
1960 		}
1961 	}
1962 
1963 	isc_interfaceiter_destroy(&iter);
1964 
1965 	/*
1966 	 * phase 2 - delete gone interfaces - reassigning peers to
1967 	 * other interfaces
1968 	 */
1969 	for (ep = ep_list; ep != NULL; ep = next_ep) {
1970 		next_ep = ep->elink;
1971 
1972 		/*
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,
1977 		 * INT_MCASTIF).
1978 		 */
1979 		if (((INT_WILDCARD | INT_MCASTIF) & ep->flags) ||
1980 		    ep->phase == sys_interphase)
1981 			continue;
1982 
1983 		DPRINT_INTERFACE(3, (ep, "updating ",
1984 				     "GONE - deleting\n"));
1985 		remove_interface(ep);
1986 
1987 		ifi.action = IFS_DELETED;
1988 		ifi.ep = ep;
1989 		if (receiver != NULL)
1990 			(*receiver)(data, &ifi);
1991 
1992 		/* disconnect peers from deleted endpt. */
1993 		while (ep->peers != NULL)
1994 			set_peerdstadr(ep->peers, NULL);
1995 
1996 		/*
1997 		 * update globals in case we lose
1998 		 * a loopback interface
1999 		 */
2000 		if (ep == loopback_interface)
2001 			loopback_interface = NULL;
2002 
2003 		delete_interface(ep);
2004 	}
2005 
2006 	/*
2007 	 * phase 3 - re-configure as the world has possibly changed
2008 	 *
2009 	 * never ever make this conditional again - it is needed to track
2010 	 * routing updates. see bug #2506
2011 	 */
2012 	refresh_all_peerinterfaces();
2013 
2014 	if (broadcast_client_enabled)
2015 		io_setbclient();
2016 
2017 	if (sys_bclient)
2018 		io_setbclient();
2019 
2020 #ifdef MCAST
2021 	/*
2022 	 * Check multicast interfaces and try to join multicast groups if
2023          * not joined yet.
2024          */
2025 	for (ep = ep_list; ep != NULL; ep = ep->elink) {
2026 		remaddr_t *entry;
2027 
2028 		if (!(INT_MCASTIF & ep->flags) || (INT_MCASTOPEN & ep->flags))
2029 			continue;
2030 
2031 		/* Find remote address that was linked to this interface */
2032 		for (entry = remoteaddr_list;
2033 		     entry != NULL;
2034 		     entry = entry->link) {
2035 			if (entry->ep == ep) {
2036 				if (socket_multicast_enable(ep, &entry->addr)) {
2037 					msyslog(LOG_INFO,
2038 						"Joined %s socket to multicast group %s",
2039 						stoa(&ep->sin),
2040 						stoa(&entry->addr));
2041 				}
2042 				break;
2043 			}
2044 		}
2045 	}
2046 #endif /* MCAST */
2047 
2048 	return new_interface_found;
2049 }
2050 
2051 
2052 /*
2053  * create_sockets - create a socket for each interface plus a default
2054  *			socket for when we don't know where to send
2055  */
2056 static int
2057 create_sockets(
2058 	u_short port
2059 	)
2060 {
2061 #ifndef HAVE_IO_COMPLETION_PORT
2062 	/*
2063 	 * I/O Completion Ports don't care about the select and FD_SET
2064 	 */
2065 	maxactivefd = 0;
2066 	FD_ZERO(&activefds);
2067 #endif
2068 
2069 	DPRINTF(2, ("create_sockets(%d)\n", port));
2070 
2071 	create_wildcards(port);
2072 
2073 	update_interfaces(port, NULL, NULL);
2074 
2075 	/*
2076 	 * Now that we have opened all the sockets, turn off the reuse
2077 	 * flag for security.
2078 	 */
2079 	set_reuseaddr(0);
2080 
2081 	DPRINTF(2, ("create_sockets: Total interfaces = %d\n", ninterfaces));
2082 
2083 	return ninterfaces;
2084 }
2085 
2086 /*
2087  * create_interface - create a new interface for a given prototype
2088  *		      binding the socket.
2089  */
2090 static struct interface *
2091 create_interface(
2092 	u_short			port,
2093 	struct interface *	protot
2094 	)
2095 {
2096 	sockaddr_u	resmask;
2097 	endpt *		iface;
2098 #if defined(MCAST) && defined(MULTICAST_NONEWSOCKET)
2099 	remaddr_t *	entry;
2100 	remaddr_t *	next_entry;
2101 #endif
2102 	DPRINTF(2, ("create_interface(%s#%d)\n", stoa(&protot->sin),
2103 		    port));
2104 
2105 	/* build an interface */
2106 	iface = new_interface(protot);
2107 
2108 	/*
2109 	 * create socket
2110 	 */
2111 	iface->fd = open_socket(&iface->sin, 0, 0, iface);
2112 
2113 	if (iface->fd != INVALID_SOCKET)
2114 		log_listen_address(iface);
2115 
2116 	if ((INT_BROADCAST & iface->flags)
2117 	    && iface->bfd != INVALID_SOCKET)
2118 		msyslog(LOG_INFO, "Listening on broadcast address %s#%d",
2119 			stoa((&iface->bcast)), port);
2120 
2121 	if (INVALID_SOCKET == iface->fd
2122 	    && INVALID_SOCKET == iface->bfd) {
2123 		msyslog(LOG_ERR, "unable to create socket on %s (%d) for %s#%d",
2124 			iface->name,
2125 			iface->ifnum,
2126 			stoa((&iface->sin)),
2127 			port);
2128 		delete_interface(iface);
2129 		return NULL;
2130 	}
2131 
2132 	/*
2133 	 * Blacklist our own addresses, no use talking to ourself
2134 	 */
2135 	SET_HOSTMASK(&resmask, AF(&iface->sin));
2136 	hack_restrict(RESTRICT_FLAGS, &iface->sin, &resmask,
2137 		      -4, RESM_NTPONLY | RESM_INTERFACE, RES_IGNORE, 0);
2138 
2139 	/*
2140 	 * set globals with the first found
2141 	 * loopback interface of the appropriate class
2142 	 */
2143 	if (NULL == loopback_interface && AF_INET == iface->family
2144 	    && (INT_LOOPBACK & iface->flags))
2145 		loopback_interface = iface;
2146 
2147 	/*
2148 	 * put into our interface list
2149 	 */
2150 	add_addr_to_list(&iface->sin, iface);
2151 	add_interface(iface);
2152 
2153 #if defined(MCAST) && defined(MULTICAST_NONEWSOCKET)
2154 	/*
2155 	 * Join any previously-configured compatible multicast groups.
2156 	 */
2157 	if (INT_MULTICAST & iface->flags &&
2158 	    !((INT_LOOPBACK | INT_WILDCARD) & iface->flags) &&
2159 	    !iface->ignore_packets) {
2160 		for (entry = remoteaddr_list;
2161 		     entry != NULL;
2162 		     entry = next_entry) {
2163 			next_entry = entry->link;
2164 			if (AF(&iface->sin) != AF(&entry->addr) ||
2165 			    !IS_MCAST(&entry->addr))
2166 				continue;
2167 			if (socket_multicast_enable(iface,
2168 						    &entry->addr))
2169 				msyslog(LOG_INFO,
2170 					"Joined %s socket to multicast group %s",
2171 					stoa(&iface->sin),
2172 					stoa(&entry->addr));
2173 			else
2174 				msyslog(LOG_ERR,
2175 					"Failed to join %s socket to multicast group %s",
2176 					stoa(&iface->sin),
2177 					stoa(&entry->addr));
2178 		}
2179 	}
2180 #endif	/* MCAST && MCAST_NONEWSOCKET */
2181 
2182 	DPRINT_INTERFACE(2, (iface, "created ", "\n"));
2183 	return iface;
2184 }
2185 
2186 
2187 #ifdef SO_EXCLUSIVEADDRUSE
2188 static void
2189 set_excladdruse(
2190 	SOCKET fd
2191 	)
2192 {
2193 	int one = 1;
2194 	int failed;
2195 #ifdef SYS_WINNT
2196 	DWORD err;
2197 #endif
2198 
2199 	failed = setsockopt(fd, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
2200 			    (void *)&one, sizeof(one));
2201 
2202 	if (!failed)
2203 		return;
2204 
2205 #ifdef SYS_WINNT
2206 	/*
2207 	 * Prior to Windows XP setting SO_EXCLUSIVEADDRUSE can fail with
2208 	 * error WSAINVAL depending on service pack level and whether
2209 	 * the user account is in the Administrators group.  Do not
2210 	 * complain if it fails that way on versions prior to XP (5.1).
2211 	 */
2212 	err = GetLastError();
2213 
2214 	if (isc_win32os_versioncheck(5, 1, 0, 0) < 0	/* < 5.1/XP */
2215 	    && WSAEINVAL == err)
2216 		return;
2217 
2218 	SetLastError(err);
2219 #endif
2220 	msyslog(LOG_ERR,
2221 		"setsockopt(%d, SO_EXCLUSIVEADDRUSE, on): %m",
2222 		(int)fd);
2223 }
2224 #endif  /* SO_EXCLUSIVEADDRUSE */
2225 
2226 
2227 /*
2228  * set_reuseaddr() - set/clear REUSEADDR on all sockets
2229  *			NB possible hole - should we be doing this on broadcast
2230  *			fd's also?
2231  */
2232 static void
2233 set_reuseaddr(
2234 	int flag
2235 	)
2236 {
2237 #ifndef SO_EXCLUSIVEADDRUSE
2238 	endpt *ep;
2239 
2240 	for (ep = ep_list; ep != NULL; ep = ep->elink) {
2241 		if (ep->flags & INT_WILDCARD)
2242 			continue;
2243 
2244 		/*
2245 		 * if ep->fd  is INVALID_SOCKET, we might have a adapter
2246 		 * configured but not present
2247 		 */
2248 		DPRINTF(4, ("setting SO_REUSEADDR on %.16s@%s to %s\n",
2249 			    ep->name, stoa(&ep->sin),
2250 			    flag ? "on" : "off"));
2251 
2252 		if (ep->fd != INVALID_SOCKET) {
2253 			if (setsockopt(ep->fd, SOL_SOCKET, SO_REUSEADDR,
2254 				       (void *)&flag, sizeof(flag))) {
2255 				msyslog(LOG_ERR, "set_reuseaddr: setsockopt(%s, SO_REUSEADDR, %s) failed: %m",
2256 					stoa(&ep->sin), flag ? "on" : "off");
2257 			}
2258 		}
2259 	}
2260 #endif /* ! SO_EXCLUSIVEADDRUSE */
2261 }
2262 
2263 /*
2264  * This is just a wrapper around an internal function so we can
2265  * make other changes as necessary later on
2266  */
2267 void
2268 enable_broadcast(
2269 	struct interface *	iface,
2270 	sockaddr_u *		baddr
2271 	)
2272 {
2273 #ifdef OPEN_BCAST_SOCKET
2274 	socket_broadcast_enable(iface, iface->fd, baddr);
2275 #endif
2276 }
2277 
2278 #ifdef OPEN_BCAST_SOCKET
2279 /*
2280  * Enable a broadcast address to a given socket
2281  * The socket is in the ep_list all we need to do is enable
2282  * broadcasting. It is not this function's job to select the socket
2283  */
2284 static isc_boolean_t
2285 socket_broadcast_enable(
2286 	struct interface *	iface,
2287 	SOCKET			fd,
2288 	sockaddr_u *		baddr
2289 	)
2290 {
2291 #ifdef SO_BROADCAST
2292 	int on = 1;
2293 
2294 	if (IS_IPV4(baddr)) {
2295 		/* if this interface can support broadcast, set SO_BROADCAST */
2296 		if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST,
2297 			       (void *)&on, sizeof(on)))
2298 			msyslog(LOG_ERR,
2299 				"setsockopt(SO_BROADCAST) enable failure on address %s: %m",
2300 				stoa(baddr));
2301 		else
2302 			DPRINTF(2, ("Broadcast enabled on socket %d for address %s\n",
2303 				    fd, stoa(baddr)));
2304 	}
2305 	iface->flags |= INT_BCASTXMIT;
2306 	return ISC_TRUE;
2307 #else
2308 	return ISC_FALSE;
2309 #endif /* SO_BROADCAST */
2310 }
2311 
2312 #ifdef  OS_MISSES_SPECIFIC_ROUTE_UPDATES
2313 /*
2314  * Remove a broadcast address from a given socket
2315  * The socket is in the ep_list all we need to do is disable
2316  * broadcasting. It is not this function's job to select the socket
2317  */
2318 static isc_boolean_t
2319 socket_broadcast_disable(
2320 	struct interface *	iface,
2321 	sockaddr_u *		baddr
2322 	)
2323 {
2324 #ifdef SO_BROADCAST
2325 	int off = 0;	/* This seems to be OK as an int */
2326 
2327 	if (IS_IPV4(baddr) && setsockopt(iface->fd, SOL_SOCKET,
2328 	    SO_BROADCAST, (void *)&off, sizeof(off)))
2329 		msyslog(LOG_ERR,
2330 			"setsockopt(SO_BROADCAST) disable failure on address %s: %m",
2331 			stoa(baddr));
2332 
2333 	iface->flags &= ~INT_BCASTXMIT;
2334 	return ISC_TRUE;
2335 #else
2336 	return ISC_FALSE;
2337 #endif /* SO_BROADCAST */
2338 }
2339 #endif /* OS_MISSES_SPECIFIC_ROUTE_UPDATES */
2340 
2341 #endif /* OPEN_BCAST_SOCKET */
2342 
2343 /*
2344  * return the broadcast client flag value
2345  */
2346 isc_boolean_t
2347 get_broadcastclient_flag(void)
2348 {
2349 	return (broadcast_client_enabled);
2350 }
2351 
2352 /*
2353  * Check to see if the address is a multicast address
2354  */
2355 static isc_boolean_t
2356 addr_ismulticast(
2357 	sockaddr_u *maddr
2358 	)
2359 {
2360 	isc_boolean_t result;
2361 
2362 #ifndef INCLUDE_IPV6_MULTICAST_SUPPORT
2363 	/*
2364 	 * If we don't have IPV6 support any IPV6 addr is not multicast
2365 	 */
2366 	if (IS_IPV6(maddr))
2367 		result = ISC_FALSE;
2368 	else
2369 #endif
2370 		result = IS_MCAST(maddr);
2371 
2372 	if (!result)
2373 		DPRINTF(4, ("address %s is not multicast\n",
2374 			    stoa(maddr)));
2375 
2376 	return result;
2377 }
2378 
2379 /*
2380  * Multicast servers need to set the appropriate Multicast interface
2381  * socket option in order for it to know which interface to use for
2382  * send the multicast packet.
2383  */
2384 void
2385 enable_multicast_if(
2386 	struct interface *	iface,
2387 	sockaddr_u *		maddr
2388 	)
2389 {
2390 #ifdef MCAST
2391 #ifdef IP_MULTICAST_LOOP
2392 	TYPEOF_IP_MULTICAST_LOOP off = 0;
2393 #endif
2394 #if defined(INCLUDE_IPV6_MULTICAST_SUPPORT) && defined(IPV6_MULTICAST_LOOP)
2395 	u_int off6 = 0;
2396 #endif
2397 
2398 	REQUIRE(AF(maddr) == AF(&iface->sin));
2399 
2400 	switch (AF(&iface->sin)) {
2401 
2402 	case AF_INET:
2403 #ifdef IP_MULTICAST_LOOP
2404 		/*
2405 		 * Don't send back to itself, but allow failure to set
2406 		 */
2407 		if (setsockopt(iface->fd, IPPROTO_IP,
2408 			       IP_MULTICAST_LOOP,
2409 			       (void *)&off,
2410 			       sizeof(off))) {
2411 
2412 			msyslog(LOG_ERR,
2413 				"setsockopt IP_MULTICAST_LOOP failed: %m on socket %d, addr %s for multicast address %s",
2414 				iface->fd, stoa(&iface->sin),
2415 				stoa(maddr));
2416 		}
2417 #endif
2418 		break;
2419 
2420 	case AF_INET6:
2421 #ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
2422 #ifdef IPV6_MULTICAST_LOOP
2423 		/*
2424 		 * Don't send back to itself, but allow failure to set
2425 		 */
2426 		if (setsockopt(iface->fd, IPPROTO_IPV6,
2427 			       IPV6_MULTICAST_LOOP,
2428 			       (void *) &off6, sizeof(off6))) {
2429 
2430 			msyslog(LOG_ERR,
2431 				"setsockopt IPV6_MULTICAST_LOOP failed: %m on socket %d, addr %s for multicast address %s",
2432 				iface->fd, stoa(&iface->sin),
2433 				stoa(maddr));
2434 		}
2435 #endif
2436 		break;
2437 #else
2438 		return;
2439 #endif	/* INCLUDE_IPV6_MULTICAST_SUPPORT */
2440 	}
2441 	return;
2442 #endif
2443 }
2444 
2445 /*
2446  * Add a multicast address to a given socket
2447  * The socket is in the ep_list all we need to do is enable
2448  * multicasting. It is not this function's job to select the socket
2449  */
2450 #if defined(MCAST)
2451 static isc_boolean_t
2452 socket_multicast_enable(
2453 	endpt *		iface,
2454 	sockaddr_u *	maddr
2455 	)
2456 {
2457 	struct ip_mreq		mreq;
2458 # ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
2459 	struct ipv6_mreq	mreq6;
2460 # endif
2461 	switch (AF(maddr)) {
2462 
2463 	case AF_INET:
2464 		ZERO(mreq);
2465 		mreq.imr_multiaddr = SOCK_ADDR4(maddr);
2466 		mreq.imr_interface.s_addr = htonl(INADDR_ANY);
2467 		if (setsockopt(iface->fd,
2468 			       IPPROTO_IP,
2469 			       IP_ADD_MEMBERSHIP,
2470 			       (void *)&mreq,
2471 			       sizeof(mreq))) {
2472 			DPRINTF(2, (
2473 				"setsockopt IP_ADD_MEMBERSHIP failed: %m on socket %d, addr %s for %x / %x (%s)",
2474 				iface->fd, stoa(&iface->sin),
2475 				mreq.imr_multiaddr.s_addr,
2476 				mreq.imr_interface.s_addr,
2477 				stoa(maddr)));
2478 			return ISC_FALSE;
2479 		}
2480 		DPRINTF(4, ("Added IPv4 multicast membership on socket %d, addr %s for %x / %x (%s)\n",
2481 			    iface->fd, stoa(&iface->sin),
2482 			    mreq.imr_multiaddr.s_addr,
2483 			    mreq.imr_interface.s_addr, stoa(maddr)));
2484 		break;
2485 
2486 	case AF_INET6:
2487 # ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
2488 		/*
2489 		 * Enable reception of multicast packets.
2490 		 * If the address is link-local we can get the
2491 		 * interface index from the scope id. Don't do this
2492 		 * for other types of multicast addresses. For now let
2493 		 * the kernel figure it out.
2494 		 */
2495 		ZERO(mreq6);
2496 		mreq6.ipv6mr_multiaddr = SOCK_ADDR6(maddr);
2497 		mreq6.ipv6mr_interface = iface->ifindex;
2498 
2499 		if (setsockopt(iface->fd, IPPROTO_IPV6,
2500 			       IPV6_JOIN_GROUP, (void *)&mreq6,
2501 			       sizeof(mreq6))) {
2502 			DPRINTF(2, (
2503 				"setsockopt IPV6_JOIN_GROUP failed: %m on socket %d, addr %s for interface %u (%s)",
2504 				iface->fd, stoa(&iface->sin),
2505 				mreq6.ipv6mr_interface, stoa(maddr)));
2506 			return ISC_FALSE;
2507 		}
2508 		DPRINTF(4, ("Added IPv6 multicast group on socket %d, addr %s for interface %u (%s)\n",
2509 			    iface->fd, stoa(&iface->sin),
2510 			    mreq6.ipv6mr_interface, stoa(maddr)));
2511 # else
2512 		return ISC_FALSE;
2513 # endif	/* INCLUDE_IPV6_MULTICAST_SUPPORT */
2514 	}
2515 	iface->flags |= INT_MCASTOPEN;
2516 	iface->num_mcast++;
2517 
2518 	return ISC_TRUE;
2519 }
2520 #endif	/* MCAST */
2521 
2522 
2523 /*
2524  * Remove a multicast address from a given socket
2525  * The socket is in the ep_list all we need to do is disable
2526  * multicasting. It is not this function's job to select the socket
2527  */
2528 #ifdef MCAST
2529 static isc_boolean_t
2530 socket_multicast_disable(
2531 	struct interface *	iface,
2532 	sockaddr_u *		maddr
2533 	)
2534 {
2535 # ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
2536 	struct ipv6_mreq mreq6;
2537 # endif
2538 	struct ip_mreq mreq;
2539 
2540 	ZERO(mreq);
2541 
2542 	if (find_addr_in_list(maddr) == NULL) {
2543 		DPRINTF(4, ("socket_multicast_disable(%s): not found\n",
2544 			    stoa(maddr)));
2545 		return ISC_TRUE;
2546 	}
2547 
2548 	switch (AF(maddr)) {
2549 
2550 	case AF_INET:
2551 		mreq.imr_multiaddr = SOCK_ADDR4(maddr);
2552 		mreq.imr_interface = SOCK_ADDR4(&iface->sin);
2553 		if (setsockopt(iface->fd, IPPROTO_IP,
2554 			       IP_DROP_MEMBERSHIP, (void *)&mreq,
2555 			       sizeof(mreq))) {
2556 
2557 			msyslog(LOG_ERR,
2558 				"setsockopt IP_DROP_MEMBERSHIP failed: %m on socket %d, addr %s for %x / %x (%s)",
2559 				iface->fd, stoa(&iface->sin),
2560 				SRCADR(maddr), SRCADR(&iface->sin),
2561 				stoa(maddr));
2562 			return ISC_FALSE;
2563 		}
2564 		break;
2565 	case AF_INET6:
2566 # ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
2567 		/*
2568 		 * Disable reception of multicast packets
2569 		 * If the address is link-local we can get the
2570 		 * interface index from the scope id.  Don't do this
2571 		 * for other types of multicast addresses. For now let
2572 		 * the kernel figure it out.
2573 		 */
2574 		mreq6.ipv6mr_multiaddr = SOCK_ADDR6(maddr);
2575 		mreq6.ipv6mr_interface = iface->ifindex;
2576 
2577 		if (setsockopt(iface->fd, IPPROTO_IPV6,
2578 			       IPV6_LEAVE_GROUP, (void *)&mreq6,
2579 			       sizeof(mreq6))) {
2580 
2581 			msyslog(LOG_ERR,
2582 				"setsockopt IPV6_LEAVE_GROUP failure: %m on socket %d, addr %s for %d (%s)",
2583 				iface->fd, stoa(&iface->sin),
2584 				iface->ifindex, stoa(maddr));
2585 			return ISC_FALSE;
2586 		}
2587 		break;
2588 # else
2589 		return ISC_FALSE;
2590 # endif	/* INCLUDE_IPV6_MULTICAST_SUPPORT */
2591 	}
2592 
2593 	iface->num_mcast--;
2594 	if (!iface->num_mcast)
2595 		iface->flags &= ~INT_MCASTOPEN;
2596 
2597 	return ISC_TRUE;
2598 }
2599 #endif	/* MCAST */
2600 
2601 /*
2602  * io_setbclient - open the broadcast client sockets
2603  */
2604 void
2605 io_setbclient(void)
2606 {
2607 #ifdef OPEN_BCAST_SOCKET
2608 	struct interface *	interf;
2609 	unsigned int		nif;
2610 
2611 	nif = 0;
2612 	set_reuseaddr(1);
2613 
2614 	for (interf = ep_list;
2615 	     interf != NULL;
2616 	     interf = interf->elink) {
2617 
2618 		if (interf->flags & (INT_WILDCARD | INT_LOOPBACK))
2619 			continue;
2620 
2621 		/* use only allowed addresses */
2622 		if (interf->ignore_packets)
2623 			continue;
2624 
2625 		/* Need a broadcast-capable interface */
2626 		if (!(interf->flags & INT_BROADCAST))
2627 			continue;
2628 
2629 		/* Only IPv4 addresses are valid for broadcast */
2630 		REQUIRE(IS_IPV4(&interf->bcast));
2631 
2632 		/* Do we already have the broadcast address open? */
2633 		if (interf->flags & INT_BCASTOPEN) {
2634 			/*
2635 			 * account for already open interfaces to avoid
2636 			 * misleading warning below
2637 			 */
2638 			nif++;
2639 			continue;
2640 		}
2641 
2642 		/*
2643 		 * Try to open the broadcast address
2644 		 */
2645 		interf->family = AF_INET;
2646 		interf->bfd = open_socket(&interf->bcast, 1, 0, interf);
2647 
2648 		/*
2649 		 * If we succeeded then we use it otherwise enable
2650 		 * broadcast on the interface address
2651 		 */
2652 		if (interf->bfd != INVALID_SOCKET) {
2653 			nif++;
2654 			interf->flags |= INT_BCASTOPEN;
2655 			msyslog(LOG_INFO,
2656 				"Listen for broadcasts to %s on interface #%d %s",
2657 				stoa(&interf->bcast), interf->ifnum, interf->name);
2658 		} else switch (errno) {
2659 			/* Silently ignore EADDRINUSE as we probably
2660 			 * opened the socket already for an address in
2661 			 * the same network */
2662 		case EADDRINUSE:
2663 			/* Some systems cannot bind a socket to a broadcast
2664 			 * address, as that is not a valid host address. */
2665 		case EADDRNOTAVAIL:
2666 #		    ifdef SYS_WINNT	/*TODO: use for other systems, too? */
2667 			/* avoid recurrence here -- if we already have a
2668 			 * regular socket, it's quite useless to try this
2669 			 * again.
2670 			 */
2671 			if (interf->fd != INVALID_SOCKET) {
2672 				interf->flags |= INT_BCASTOPEN;
2673 				nif++;
2674 			}
2675 #		    endif
2676 			break;
2677 
2678 		default:
2679 			msyslog(LOG_INFO,
2680 				"failed to listen for broadcasts to %s on interface #%d %s",
2681 				stoa(&interf->bcast), interf->ifnum, interf->name);
2682 			break;
2683 		}
2684 	}
2685 	set_reuseaddr(0);
2686 	if (nif != 0) {
2687 		broadcast_client_enabled = ISC_TRUE;
2688 		DPRINTF(1, ("io_setbclient: listening to %d broadcast addresses\n", nif));
2689 	} else {
2690 		broadcast_client_enabled = ISC_FALSE;
2691 		msyslog(LOG_ERR,
2692 			"Unable to listen for broadcasts, no broadcast interfaces available");
2693 	}
2694 #else
2695 	msyslog(LOG_ERR,
2696 		"io_setbclient: Broadcast Client disabled by build");
2697 #endif	/* OPEN_BCAST_SOCKET */
2698 }
2699 
2700 /*
2701  * io_unsetbclient - close the broadcast client sockets
2702  */
2703 void
2704 io_unsetbclient(void)
2705 {
2706 	endpt *ep;
2707 
2708 	for (ep = ep_list; ep != NULL; ep = ep->elink) {
2709 		if (INT_WILDCARD & ep->flags)
2710 			continue;
2711 		if (!(INT_BCASTOPEN & ep->flags))
2712 			continue;
2713 
2714 		if (ep->bfd != INVALID_SOCKET) {
2715 			/* destroy broadcast listening socket */
2716 			msyslog(LOG_INFO,
2717 				"stop listening for broadcasts to %s on interface #%d %s",
2718 				stoa(&ep->bcast), ep->ifnum, ep->name);
2719 #		    ifdef HAVE_IO_COMPLETION_PORT
2720 			io_completion_port_remove_socket(ep->bfd, ep);
2721 #		    endif
2722 			close_and_delete_fd_from_list(ep->bfd);
2723 			ep->bfd = INVALID_SOCKET;
2724 		}
2725 		ep->flags &= ~INT_BCASTOPEN;
2726 	}
2727 	broadcast_client_enabled = ISC_FALSE;
2728 }
2729 
2730 /*
2731  * io_multicast_add() - add multicast group address
2732  */
2733 void
2734 io_multicast_add(
2735 	sockaddr_u *addr
2736 	)
2737 {
2738 #ifdef MCAST
2739 	endpt *	ep;
2740 	endpt *	one_ep;
2741 
2742 	/*
2743 	 * Check to see if this is a multicast address
2744 	 */
2745 	if (!addr_ismulticast(addr))
2746 		return;
2747 
2748 	/* If we already have it we can just return */
2749 	if (NULL != find_flagged_addr_in_list(addr, INT_MCASTOPEN)) {
2750 		msyslog(LOG_INFO,
2751 			"Duplicate request found for multicast address %s",
2752 			stoa(addr));
2753 		return;
2754 	}
2755 
2756 # ifndef MULTICAST_NONEWSOCKET
2757 	ep = new_interface(NULL);
2758 
2759 	/*
2760 	 * Open a new socket for the multicast address
2761 	 */
2762 	ep->sin = *addr;
2763 	SET_PORT(&ep->sin, NTP_PORT);
2764 	ep->family = AF(&ep->sin);
2765 	AF(&ep->mask) = ep->family;
2766 	SET_ONESMASK(&ep->mask);
2767 
2768 	set_reuseaddr(1);
2769 	ep->bfd = INVALID_SOCKET;
2770 	ep->fd = open_socket(&ep->sin, 0, 0, ep);
2771 	if (ep->fd != INVALID_SOCKET) {
2772 		ep->ignore_packets = ISC_FALSE;
2773 		ep->flags |= INT_MCASTIF;
2774 		ep->ifindex = SCOPE(addr);
2775 
2776 		strlcpy(ep->name, "multicast", sizeof(ep->name));
2777 		DPRINT_INTERFACE(2, (ep, "multicast add ", "\n"));
2778 		add_interface(ep);
2779 		log_listen_address(ep);
2780 	} else {
2781 		/* bind failed, re-use wildcard interface */
2782 		delete_interface(ep);
2783 
2784 		if (IS_IPV4(addr))
2785 			ep = wildipv4;
2786 		else if (IS_IPV6(addr))
2787 			ep = wildipv6;
2788 		else
2789 			ep = NULL;
2790 
2791 		if (ep != NULL) {
2792 			/* HACK ! -- stuff in an address */
2793 			/* because we don't bind addr? DH */
2794 			ep->bcast = *addr;
2795 			msyslog(LOG_ERR,
2796 				"multicast address %s using wildcard interface #%d %s",
2797 				stoa(addr), ep->ifnum, ep->name);
2798 		} else {
2799 			msyslog(LOG_ERR,
2800 				"No multicast socket available to use for address %s",
2801 				stoa(addr));
2802 			return;
2803 		}
2804 	}
2805 	{	/* in place of the { following for in #else clause */
2806 		one_ep = ep;
2807 # else	/* MULTICAST_NONEWSOCKET follows */
2808 	/*
2809 	 * For the case where we can't use a separate socket (Windows)
2810 	 * join each applicable endpoint socket to the group address.
2811 	 */
2812 	if (IS_IPV4(addr))
2813 		one_ep = wildipv4;
2814 	else
2815 		one_ep = wildipv6;
2816 	for (ep = ep_list; ep != NULL; ep = ep->elink) {
2817 		if (ep->ignore_packets || AF(&ep->sin) != AF(addr) ||
2818 		    !(INT_MULTICAST & ep->flags) ||
2819 		    (INT_LOOPBACK | INT_WILDCARD) & ep->flags)
2820 			continue;
2821 		one_ep = ep;
2822 # endif	/* MULTICAST_NONEWSOCKET */
2823 		if (socket_multicast_enable(ep, addr))
2824 			msyslog(LOG_INFO,
2825 				"Joined %s socket to multicast group %s",
2826 				stoa(&ep->sin),
2827 				stoa(addr));
2828 	}
2829 
2830 	add_addr_to_list(addr, one_ep);
2831 #else	/* !MCAST  follows*/
2832 	msyslog(LOG_ERR,
2833 		"Can not add multicast address %s: no multicast support",
2834 		stoa(addr));
2835 #endif
2836 	return;
2837 }
2838 
2839 
2840 /*
2841  * io_multicast_del() - delete multicast group address
2842  */
2843 void
2844 io_multicast_del(
2845 	sockaddr_u *	addr
2846 	)
2847 {
2848 #ifdef MCAST
2849 	endpt *iface;
2850 
2851 	/*
2852 	 * Check to see if this is a multicast address
2853 	 */
2854 	if (!addr_ismulticast(addr)) {
2855 		msyslog(LOG_ERR, "invalid multicast address %s",
2856 			stoa(addr));
2857 		return;
2858 	}
2859 
2860 	/*
2861 	 * Disable reception of multicast packets
2862 	 */
2863 	while ((iface = find_flagged_addr_in_list(addr, INT_MCASTOPEN))
2864 	       != NULL)
2865 		socket_multicast_disable(iface, addr);
2866 
2867 	delete_addr_from_list(addr);
2868 
2869 #else /* not MCAST */
2870 	msyslog(LOG_ERR,
2871 		"Can not delete multicast address %s: no multicast support",
2872 		stoa(addr));
2873 #endif /* not MCAST */
2874 }
2875 
2876 
2877 /*
2878  * open_socket - open a socket, returning the file descriptor
2879  */
2880 
2881 static SOCKET
2882 open_socket(
2883 	sockaddr_u *	addr,
2884 	int		bcast,
2885 	int		turn_off_reuse,
2886 	endpt *		interf
2887 	)
2888 {
2889 	SOCKET	fd;
2890 	int	errval;
2891 	/*
2892 	 * int is OK for REUSEADR per
2893 	 * http://www.kohala.com/start/mcast.api.txt
2894 	 */
2895 	int	on = 1;
2896 	int	off = 0;
2897 
2898 	if (IS_IPV6(addr) && !ipv6_works)
2899 		return INVALID_SOCKET;
2900 
2901 	/* create a datagram (UDP) socket */
2902 	fd = socket(AF(addr), SOCK_DGRAM, 0);
2903 	if (INVALID_SOCKET == fd) {
2904 		errval = socket_errno();
2905 		msyslog(LOG_ERR,
2906 			"socket(AF_INET%s, SOCK_DGRAM, 0) failed on address %s: %m",
2907 			IS_IPV6(addr) ? "6" : "", stoa(addr));
2908 
2909 		if (errval == EPROTONOSUPPORT ||
2910 		    errval == EAFNOSUPPORT ||
2911 		    errval == EPFNOSUPPORT)
2912 			return (INVALID_SOCKET);
2913 
2914 		errno = errval;
2915 		msyslog(LOG_ERR,
2916 			"unexpected socket() error %m code %d (not EPROTONOSUPPORT nor EAFNOSUPPORT nor EPFNOSUPPORT) - exiting",
2917 			errno);
2918 		exit(1);
2919 	}
2920 
2921 #ifdef SYS_WINNT
2922 	connection_reset_fix(fd, addr);
2923 #endif
2924 	/*
2925 	 * Fixup the file descriptor for some systems
2926 	 * See bug #530 for details of the issue.
2927 	 */
2928 	fd = move_fd(fd);
2929 
2930 	/*
2931 	 * set SO_REUSEADDR since we will be binding the same port
2932 	 * number on each interface according to turn_off_reuse.
2933 	 * This is undesirable on Windows versions starting with
2934 	 * Windows XP (numeric version 5.1).
2935 	 */
2936 #ifdef SYS_WINNT
2937 	if (isc_win32os_versioncheck(5, 1, 0, 0) < 0)  /* before 5.1 */
2938 #endif
2939 		if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
2940 			       (void *)((turn_off_reuse)
2941 					    ? &off
2942 					    : &on),
2943 			       sizeof(on))) {
2944 
2945 			msyslog(LOG_ERR,
2946 				"setsockopt SO_REUSEADDR %s fails for address %s: %m",
2947 				(turn_off_reuse)
2948 				    ? "off"
2949 				    : "on",
2950 				stoa(addr));
2951 			closesocket(fd);
2952 			return INVALID_SOCKET;
2953 		}
2954 #ifdef SO_EXCLUSIVEADDRUSE
2955 	/*
2956 	 * setting SO_EXCLUSIVEADDRUSE on the wildcard we open
2957 	 * first will cause more specific binds to fail.
2958 	 */
2959 	if (!(interf->flags & INT_WILDCARD))
2960 		set_excladdruse(fd);
2961 #endif
2962 
2963 	/*
2964 	 * IPv4 specific options go here
2965 	 */
2966 	if (IS_IPV4(addr)) {
2967 #if defined(IPPROTO_IP) && defined(IP_TOS)
2968 		if (setsockopt(fd, IPPROTO_IP, IP_TOS, (void *)&qos,
2969 			       sizeof(qos)))
2970 			msyslog(LOG_ERR,
2971 				"setsockopt IP_TOS (%02x) fails on address %s: %m",
2972 				qos, stoa(addr));
2973 #endif /* IPPROTO_IP && IP_TOS */
2974 		if (bcast)
2975 			socket_broadcast_enable(interf, fd, addr);
2976 	}
2977 
2978 	/*
2979 	 * IPv6 specific options go here
2980 	 */
2981 	if (IS_IPV6(addr)) {
2982 #if defined(IPPROTO_IPV6) && defined(IPV6_TCLASS)
2983 		if (setsockopt(fd, IPPROTO_IPV6, IPV6_TCLASS, (void *)&qos,
2984 			       sizeof(qos)))
2985 			msyslog(LOG_ERR,
2986 				"setsockopt IPV6_TCLASS (%02x) fails on address %s: %m",
2987 				qos, stoa(addr));
2988 #endif /* IPPROTO_IPV6 && IPV6_TCLASS */
2989 #ifdef IPV6_V6ONLY
2990 		if (isc_net_probe_ipv6only() == ISC_R_SUCCESS
2991 		    && setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY,
2992 		    (void *)&on, sizeof(on)))
2993 			msyslog(LOG_ERR,
2994 				"setsockopt IPV6_V6ONLY on fails on address %s: %m",
2995 				stoa(addr));
2996 #endif
2997 #ifdef IPV6_BINDV6ONLY
2998 		if (setsockopt(fd, IPPROTO_IPV6, IPV6_BINDV6ONLY,
2999 		    (void *)&on, sizeof(on)))
3000 			msyslog(LOG_ERR,
3001 				"setsockopt IPV6_BINDV6ONLY on fails on address %s: %m",
3002 				stoa(addr));
3003 #endif
3004 	}
3005 
3006 #ifdef OS_NEEDS_REUSEADDR_FOR_IFADDRBIND
3007 	/*
3008 	 * some OSes don't allow binding to more specific
3009 	 * addresses if a wildcard address already bound
3010 	 * to the port and SO_REUSEADDR is not set
3011 	 */
3012 	if (!is_wildcard_addr(addr))
3013 		set_wildcard_reuse(AF(addr), 1);
3014 #endif
3015 
3016 	/*
3017 	 * bind the local address.
3018 	 */
3019 	errval = bind(fd, &addr->sa, SOCKLEN(addr));
3020 
3021 #ifdef OS_NEEDS_REUSEADDR_FOR_IFADDRBIND
3022 	if (!is_wildcard_addr(addr))
3023 		set_wildcard_reuse(AF(addr), 0);
3024 #endif
3025 
3026 	if (errval < 0) {
3027 		/*
3028 		 * Don't log this under all conditions
3029 		 */
3030 		if (turn_off_reuse == 0
3031 #ifdef DEBUG
3032 		    || debug > 1
3033 #endif
3034 		    ) {
3035 			msyslog(LOG_ERR,
3036 				"bind(%d) AF_INET%s %s#%d%s flags 0x%x failed: %m",
3037 				fd, IS_IPV6(addr) ? "6" : "",
3038 				stoa(addr), SRCPORT(addr),
3039 				IS_MCAST(addr) ? " (multicast)" : "",
3040 				interf->flags);
3041 		}
3042 
3043 		closesocket(fd);
3044 
3045 		return INVALID_SOCKET;
3046 	}
3047 
3048 #ifdef HAVE_TIMESTAMP
3049 	{
3050 		if (setsockopt(fd, SOL_SOCKET, SO_TIMESTAMP,
3051 			       (void *)&on, sizeof(on)))
3052 			msyslog(LOG_DEBUG,
3053 				"setsockopt SO_TIMESTAMP on fails on address %s: %m",
3054 				stoa(addr));
3055 		else
3056 			DPRINTF(4, ("setsockopt SO_TIMESTAMP enabled on fd %d address %s\n",
3057 				    fd, stoa(addr)));
3058 	}
3059 #endif
3060 #ifdef HAVE_TIMESTAMPNS
3061 	{
3062 		if (setsockopt(fd, SOL_SOCKET, SO_TIMESTAMPNS,
3063 			       (void *)&on, sizeof(on)))
3064 			msyslog(LOG_DEBUG,
3065 				"setsockopt SO_TIMESTAMPNS on fails on address %s: %m",
3066 				stoa(addr));
3067 		else
3068 			DPRINTF(4, ("setsockopt SO_TIMESTAMPNS enabled on fd %d address %s\n",
3069 				    fd, stoa(addr)));
3070 	}
3071 #endif
3072 #ifdef HAVE_BINTIME
3073 	{
3074 		if (setsockopt(fd, SOL_SOCKET, SO_BINTIME,
3075 			       (void *)&on, sizeof(on)))
3076 			msyslog(LOG_DEBUG,
3077 				"setsockopt SO_BINTIME on fails on address %s: %m",
3078 				stoa(addr));
3079 		else
3080 			DPRINTF(4, ("setsockopt SO_BINTIME enabled on fd %d address %s\n",
3081 				    fd, stoa(addr)));
3082 	}
3083 #endif
3084 
3085 	DPRINTF(4, ("bind(%d) AF_INET%s, addr %s%%%d#%d, flags 0x%x\n",
3086 		   fd, IS_IPV6(addr) ? "6" : "", stoa(addr),
3087 		   SCOPE(addr), SRCPORT(addr), interf->flags));
3088 
3089 	make_socket_nonblocking(fd);
3090 
3091 #ifdef HAVE_SIGNALED_IO
3092 	init_socket_sig(fd);
3093 #endif /* not HAVE_SIGNALED_IO */
3094 
3095 	add_fd_to_list(fd, FD_TYPE_SOCKET);
3096 
3097 #if !defined(SYS_WINNT) && !defined(VMS)
3098 	DPRINTF(4, ("flags for fd %d: 0x%x\n", fd,
3099 		    fcntl(fd, F_GETFL, 0)));
3100 #endif /* SYS_WINNT || VMS */
3101 
3102 #if defined(HAVE_IO_COMPLETION_PORT)
3103 /*
3104  * Add the socket to the completion port
3105  */
3106 	if (!io_completion_port_add_socket(fd, interf, bcast)) {
3107 		msyslog(LOG_ERR, "unable to set up io completion port - EXITING");
3108 		exit(1);
3109 	}
3110 #endif
3111 	return fd;
3112 }
3113 
3114 
3115 
3116 /* XXX ELIMINATE sendpkt similar in ntpq.c, ntpdc.c, ntp_io.c, ntptrace.c */
3117 /*
3118  * sendpkt - send a packet to the specified destination. Maintain a
3119  * send error cache so that only the first consecutive error for a
3120  * destination is logged.
3121  */
3122 void
3123 sendpkt(
3124 	sockaddr_u *		dest,
3125 	struct interface *	ep,
3126 	int			ttl,
3127 	struct pkt *		pkt,
3128 	int			len
3129 	)
3130 {
3131 	endpt *	src;
3132 	int	ismcast;
3133 	int	cc;
3134 	int	rc;
3135 	u_char	cttl;
3136 	l_fp	fp_zero = { { 0 }, 0 };
3137 
3138 	ismcast = IS_MCAST(dest);
3139 	if (!ismcast)
3140 		src = ep;
3141 	else
3142 		src = (IS_IPV4(dest))
3143 			  ? mc4_list
3144 			  : mc6_list;
3145 
3146 	if (NULL == src) {
3147 		/*
3148 		 * unbound peer - drop request and wait for better
3149 		 * network conditions
3150 		 */
3151 		DPRINTF(2, ("%ssendpkt(dst=%s, ttl=%d, len=%d): no interface - IGNORED\n",
3152 			    ismcast ? "\tMCAST\t***** " : "",
3153 			    stoa(dest), ttl, len));
3154 		return;
3155 	}
3156 
3157 	do {
3158 		DPRINTF(2, ("%ssendpkt(%d, dst=%s, src=%s, ttl=%d, len=%d)\n",
3159 			    ismcast ? "\tMCAST\t***** " : "", src->fd,
3160 			    stoa(dest), stoa(&src->sin), ttl, len));
3161 #ifdef MCAST
3162 		/*
3163 		 * for the moment we use the bcast option to set multicast ttl
3164 		 */
3165 		if (ismcast && ttl > 0 && ttl != src->last_ttl) {
3166 			/*
3167 			 * set the multicast ttl for outgoing packets
3168 			 */
3169 			switch (AF(&src->sin)) {
3170 
3171 			case AF_INET :
3172 				cttl = (u_char)ttl;
3173 				rc = setsockopt(src->fd, IPPROTO_IP,
3174 						IP_MULTICAST_TTL,
3175 						(void *)&cttl,
3176 						sizeof(cttl));
3177 				break;
3178 
3179 # ifdef INCLUDE_IPV6_SUPPORT
3180 			case AF_INET6 :
3181 				rc = setsockopt(src->fd, IPPROTO_IPV6,
3182 						 IPV6_MULTICAST_HOPS,
3183 						 (void *)&ttl,
3184 						 sizeof(ttl));
3185 				break;
3186 # endif	/* INCLUDE_IPV6_SUPPORT */
3187 
3188 			default:
3189 				rc = 0;
3190 			}
3191 
3192 			if (!rc)
3193 				src->last_ttl = ttl;
3194 			else
3195 				msyslog(LOG_ERR,
3196 					"setsockopt IP_MULTICAST_TTL/IPV6_MULTICAST_HOPS fails on address %s: %m",
3197 					stoa(&src->sin));
3198 		}
3199 #endif	/* MCAST */
3200 
3201 #ifdef SIM
3202 		cc = simulate_server(dest, src, pkt);
3203 #elif defined(HAVE_IO_COMPLETION_PORT)
3204 		cc = io_completion_port_sendto(src, src->fd, pkt,
3205 			(size_t)len, (sockaddr_u *)&dest->sa);
3206 #else
3207 		cc = sendto(src->fd, (char *)pkt, (u_int)len, 0,
3208 			    &dest->sa, SOCKLEN(dest));
3209 #endif
3210 		if (cc == -1) {
3211 			src->notsent++;
3212 			packets_notsent++;
3213 		} else	{
3214 			src->sent++;
3215 			packets_sent++;
3216 		}
3217 		if (ismcast)
3218 			src = src->mclink;
3219 	} while (ismcast && src != NULL);
3220 
3221 	/* HMS: pkt->rootdisp is usually random here */
3222 	record_raw_stats(src ? &src->sin : NULL, dest,
3223 			&pkt->org, &pkt->rec, &pkt->xmt, &fp_zero,
3224 			PKT_MODE(pkt->li_vn_mode),
3225 			PKT_VERSION(pkt->li_vn_mode),
3226 			PKT_LEAP(pkt->li_vn_mode),
3227 			pkt->stratum,
3228 			pkt->ppoll, pkt->precision,
3229 			pkt->rootdelay, pkt->rootdisp, pkt->refid,
3230 			len - MIN_V4_PKT_LEN, (u_char *)&pkt->exten);
3231 
3232 	return;
3233 }
3234 
3235 
3236 #if !defined(HAVE_IO_COMPLETION_PORT)
3237 #if !defined(HAVE_SIGNALED_IO)
3238 /*
3239  * fdbits - generate ascii representation of fd_set (FAU debug support)
3240  * HFDF format - highest fd first.
3241  */
3242 static char *
3243 fdbits(
3244 	int		count,
3245 	const fd_set*	set
3246 	)
3247 {
3248 	static char buffer[256];
3249 	char * buf = buffer;
3250 
3251 	count = min(count,  255);
3252 
3253 	while (count >= 0) {
3254 		*buf++ = FD_ISSET(count, set) ? '#' : '-';
3255 		count--;
3256 	}
3257 	*buf = '\0';
3258 
3259 	return buffer;
3260 }
3261 #endif
3262 
3263 #ifdef REFCLOCK
3264 /*
3265  * Routine to read the refclock packets for a specific interface
3266  * Return the number of bytes read. That way we know if we should
3267  * read it again or go on to the next one if no bytes returned
3268  */
3269 static inline int
3270 read_refclock_packet(
3271 	SOCKET			fd,
3272 	struct refclockio *	rp,
3273 	l_fp			ts
3274 	)
3275 {
3276 	u_int			read_count;
3277 	int			buflen;
3278 	int			saved_errno;
3279 	int			consumed;
3280 	struct recvbuf *	rb;
3281 
3282 	rb = get_free_recv_buffer();
3283 
3284 	if (NULL == rb) {
3285 		/*
3286 		 * No buffer space available - just drop the packet
3287 		 */
3288 		char buf[RX_BUFF_SIZE];
3289 
3290 		buflen = read(fd, buf, sizeof buf);
3291 		packets_dropped++;
3292 		return (buflen);
3293 	}
3294 
3295 	/* TALOS-CAN-0064: avoid signed/unsigned clashes that can lead
3296 	 * to buffer overrun and memory corruption
3297 	 */
3298 	if (rp->datalen <= 0 || (size_t)rp->datalen > sizeof(rb->recv_space))
3299 		read_count = sizeof(rb->recv_space);
3300 	else
3301 		read_count = (u_int)rp->datalen;
3302 	do {
3303 		buflen = read(fd, (char *)&rb->recv_space, read_count);
3304 	} while (buflen < 0 && EINTR == errno);
3305 
3306 	if (buflen <= 0) {
3307 		saved_errno = errno;
3308 		freerecvbuf(rb);
3309 		errno = saved_errno;
3310 		return buflen;
3311 	}
3312 
3313 	/*
3314 	 * Got one. Mark how and when it got here,
3315 	 * put it on the full list and do bookkeeping.
3316 	 */
3317 	rb->recv_length = buflen;
3318 	rb->recv_peer = rp->srcclock;
3319 	rb->dstadr = 0;
3320 	rb->fd = fd;
3321 	rb->recv_time = ts;
3322 	rb->receiver = rp->clock_recv;
3323 
3324 	consumed = indicate_refclock_packet(rp, rb);
3325 	if (!consumed) {
3326 		rp->recvcount++;
3327 		packets_received++;
3328 	}
3329 
3330 	return buflen;
3331 }
3332 #endif	/* REFCLOCK */
3333 
3334 
3335 #ifdef HAVE_PACKET_TIMESTAMP
3336 /*
3337  * extract timestamps from control message buffer
3338  */
3339 static l_fp
3340 fetch_timestamp(
3341 	struct recvbuf *	rb,
3342 	struct msghdr *		msghdr,
3343 	l_fp			ts
3344 	)
3345 {
3346 	struct cmsghdr *	cmsghdr;
3347 	unsigned long		ticks;
3348 	double			fuzz;
3349 	l_fp			lfpfuzz;
3350 	l_fp			nts;
3351 #ifdef DEBUG_TIMING
3352 	l_fp			dts;
3353 #endif
3354 
3355 	cmsghdr = CMSG_FIRSTHDR(msghdr);
3356 	while (cmsghdr != NULL) {
3357 		switch (cmsghdr->cmsg_type)
3358 		{
3359 #ifdef HAVE_BINTIME
3360 		case SCM_BINTIME:
3361 #endif  /* HAVE_BINTIME */
3362 #ifdef HAVE_TIMESTAMPNS
3363 		case SCM_TIMESTAMPNS:
3364 #endif	/* HAVE_TIMESTAMPNS */
3365 #ifdef HAVE_TIMESTAMP
3366 		case SCM_TIMESTAMP:
3367 #endif	/* HAVE_TIMESTAMP */
3368 #if defined(HAVE_BINTIME) || defined (HAVE_TIMESTAMPNS) || defined(HAVE_TIMESTAMP)
3369 			switch (cmsghdr->cmsg_type)
3370 			{
3371 #ifdef HAVE_BINTIME
3372 			case SCM_BINTIME:
3373 				{
3374 					struct bintime	pbt;
3375 					memcpy(&pbt, CMSG_DATA(cmsghdr), sizeof(pbt));
3376 					/*
3377 					 * bintime documentation is at http://phk.freebsd.dk/pubs/timecounter.pdf
3378 					 */
3379 					nts.l_i = pbt.sec + JAN_1970;
3380 					nts.l_uf = (u_int32)(pbt.frac >> 32);
3381 					if (sys_tick > measured_tick &&
3382 					    sys_tick > 1e-9) {
3383 						ticks = (unsigned long)(nts.l_uf / (unsigned long)(sys_tick * FRAC));
3384 						nts.l_uf = (unsigned long)(ticks * (unsigned long)(sys_tick * FRAC));
3385 					}
3386 					DPRINTF(4, ("fetch_timestamp: system bintime network time stamp: %ld.%09lu\n",
3387 						    pbt.sec, (unsigned long)((nts.l_uf / FRAC) * 1e9)));
3388 				}
3389 				break;
3390 #endif  /* HAVE_BINTIME */
3391 #ifdef HAVE_TIMESTAMPNS
3392 			case SCM_TIMESTAMPNS:
3393 				{
3394 					struct timespec	pts;
3395 					memcpy(&pts, CMSG_DATA(cmsghdr), sizeof(pts));
3396 					if (sys_tick > measured_tick &&
3397 					    sys_tick > 1e-9) {
3398 						ticks = (unsigned long)((pts.tv_nsec * 1e-9) /
3399 									sys_tick);
3400 						pts.tv_nsec = (long)(ticks * 1e9 *
3401 								     sys_tick);
3402 					}
3403 					DPRINTF(4, ("fetch_timestamp: system nsec network time stamp: %ld.%09ld\n",
3404 						    pts.tv_sec, pts.tv_nsec));
3405 					nts = tspec_stamp_to_lfp(pts);
3406 				}
3407 				break;
3408 #endif	/* HAVE_TIMESTAMPNS */
3409 #ifdef HAVE_TIMESTAMP
3410 			case SCM_TIMESTAMP:
3411 				{
3412 					struct timeval	ptv;
3413 					memcpy(&ptv, CMSG_DATA(cmsghdr), sizeof(ptv));
3414 					if (sys_tick > measured_tick &&
3415 					    sys_tick > 1e-6) {
3416 						ticks = (unsigned long)((ptv.tv_usec * 1e-6) /
3417 									sys_tick);
3418 						ptv.tv_usec = (long)(ticks * 1e6 *
3419 								    sys_tick);
3420 					}
3421 					DPRINTF(4, ("fetch_timestamp: system usec network time stamp: %jd.%06ld\n",
3422 						    (intmax_t)ptv.tv_sec, (long)ptv.tv_usec));
3423 					nts = tval_stamp_to_lfp(ptv);
3424 				}
3425 				break;
3426 #endif  /* HAVE_TIMESTAMP */
3427 			}
3428 			fuzz = ntp_random() * 2. / FRAC * sys_fuzz;
3429 			DTOLFP(fuzz, &lfpfuzz);
3430 			L_ADD(&nts, &lfpfuzz);
3431 #ifdef DEBUG_TIMING
3432 			dts = ts;
3433 			L_SUB(&dts, &nts);
3434 			collect_timing(rb, "input processing delay", 1,
3435 				       &dts);
3436 			DPRINTF(4, ("fetch_timestamp: timestamp delta: %s (incl. fuzz)\n",
3437 				    lfptoa(&dts, 9)));
3438 #endif	/* DEBUG_TIMING */
3439 			ts = nts;  /* network time stamp */
3440 			break;
3441 #endif	/* HAVE_BINTIME || HAVE_TIMESTAMPNS || HAVE_TIMESTAMP */
3442 
3443 		default:
3444 			DPRINTF(4, ("fetch_timestamp: skipping control message 0x%x\n",
3445 				    cmsghdr->cmsg_type));
3446 		}
3447 		cmsghdr = CMSG_NXTHDR(msghdr, cmsghdr);
3448 	}
3449 	return ts;
3450 }
3451 #endif	/* HAVE_PACKET_TIMESTAMP */
3452 
3453 
3454 /*
3455  * Routine to read the network NTP packets for a specific interface
3456  * Return the number of bytes read. That way we know if we should
3457  * read it again or go on to the next one if no bytes returned
3458  */
3459 static inline int
3460 read_network_packet(
3461 	SOCKET			fd,
3462 	struct interface *	itf,
3463 	l_fp			ts
3464 	)
3465 {
3466 	GETSOCKNAME_SOCKLEN_TYPE fromlen;
3467 	int buflen;
3468 	register struct recvbuf *rb;
3469 #ifdef HAVE_PACKET_TIMESTAMP
3470 	struct msghdr msghdr;
3471 	struct iovec iovec;
3472 	char control[CMSG_BUFSIZE];
3473 #endif
3474 
3475 	/*
3476 	 * Get a buffer and read the frame.  If we
3477 	 * haven't got a buffer, or this is received
3478 	 * on a disallowed socket, just dump the
3479 	 * packet.
3480 	 */
3481 
3482 	rb = get_free_recv_buffer();
3483 	if (NULL == rb || itf->ignore_packets) {
3484 		char buf[RX_BUFF_SIZE];
3485 		sockaddr_u from;
3486 
3487 		if (rb != NULL)
3488 			freerecvbuf(rb);
3489 
3490 		fromlen = sizeof(from);
3491 		buflen = recvfrom(fd, buf, sizeof(buf), 0,
3492 				  &from.sa, &fromlen);
3493 		DPRINTF(4, ("%s on (%lu) fd=%d from %s\n",
3494 			(itf->ignore_packets)
3495 			    ? "ignore"
3496 			    : "drop",
3497 			free_recvbuffs(), fd, stoa(&from)));
3498 		if (itf->ignore_packets)
3499 			packets_ignored++;
3500 		else
3501 			packets_dropped++;
3502 		return (buflen);
3503 	}
3504 
3505 	fromlen = sizeof(rb->recv_srcadr);
3506 
3507 #ifndef HAVE_PACKET_TIMESTAMP
3508 	rb->recv_length = recvfrom(fd, (char *)&rb->recv_space,
3509 				   sizeof(rb->recv_space), 0,
3510 				   &rb->recv_srcadr.sa, &fromlen);
3511 #else
3512 	iovec.iov_base        = &rb->recv_space;
3513 	iovec.iov_len         = sizeof(rb->recv_space);
3514 	msghdr.msg_name       = &rb->recv_srcadr;
3515 	msghdr.msg_namelen    = fromlen;
3516 	msghdr.msg_iov        = &iovec;
3517 	msghdr.msg_iovlen     = 1;
3518 	msghdr.msg_control    = (void *)&control;
3519 	msghdr.msg_controllen = sizeof(control);
3520 	msghdr.msg_flags      = 0;
3521 	rb->recv_length       = recvmsg(fd, &msghdr, 0);
3522 #endif
3523 
3524 	buflen = rb->recv_length;
3525 
3526 	if (buflen == 0 || (buflen == -1 &&
3527 	    (EWOULDBLOCK == errno
3528 #ifdef EAGAIN
3529 	     || EAGAIN == errno
3530 #endif
3531 	     ))) {
3532 		freerecvbuf(rb);
3533 		return (buflen);
3534 	} else if (buflen < 0) {
3535 		msyslog(LOG_ERR, "recvfrom(%s) fd=%d: %m",
3536 			stoa(&rb->recv_srcadr), fd);
3537 		DPRINTF(5, ("read_network_packet: fd=%d dropped (bad recvfrom)\n",
3538 			    fd));
3539 		freerecvbuf(rb);
3540 		return (buflen);
3541 	}
3542 
3543 	DPRINTF(3, ("read_network_packet: fd=%d length %d from %s\n",
3544 		    fd, buflen, stoa(&rb->recv_srcadr)));
3545 
3546 #ifdef ENABLE_BUG3020_FIX
3547 	if (ISREFCLOCKADR(&rb->recv_srcadr)) {
3548 		msyslog(LOG_ERR, "recvfrom(%s) fd=%d: refclock srcadr on a network interface!",
3549 			stoa(&rb->recv_srcadr), fd);
3550 		DPRINTF(1, ("read_network_packet: fd=%d dropped (refclock srcadr))\n",
3551 			    fd));
3552 		packets_dropped++;
3553 		freerecvbuf(rb);
3554 		return (buflen);
3555 	}
3556 #endif
3557 
3558 	/*
3559 	** Bug 2672: Some OSes (MacOSX and Linux) don't block spoofed ::1
3560 	*/
3561 
3562 	if (AF_INET6 == itf->family) {
3563 		DPRINTF(2, ("Got an IPv6 packet, from <%s> (%d) to <%s> (%d)\n",
3564 			stoa(&rb->recv_srcadr),
3565 			IN6_IS_ADDR_LOOPBACK(PSOCK_ADDR6(&rb->recv_srcadr)),
3566 			stoa(&itf->sin),
3567 			!IN6_IS_ADDR_LOOPBACK(PSOCK_ADDR6(&itf->sin))
3568 			));
3569 
3570 		if (   IN6_IS_ADDR_LOOPBACK(PSOCK_ADDR6(&rb->recv_srcadr))
3571 		    && !IN6_IS_ADDR_LOOPBACK(PSOCK_ADDR6(&itf->sin))
3572 		   ) {
3573 			packets_dropped++;
3574 			DPRINTF(2, ("DROPPING that packet\n"));
3575 			freerecvbuf(rb);
3576 			return buflen;
3577 		}
3578 		DPRINTF(2, ("processing that packet\n"));
3579 	}
3580 
3581 	/*
3582 	 * Got one.  Mark how and when it got here,
3583 	 * put it on the full list and do bookkeeping.
3584 	 */
3585 	rb->dstadr = itf;
3586 	rb->fd = fd;
3587 #ifdef HAVE_PACKET_TIMESTAMP
3588 	/* pick up a network time stamp if possible */
3589 	ts = fetch_timestamp(rb, &msghdr, ts);
3590 #endif
3591 	rb->recv_time = ts;
3592 	rb->receiver = receive;
3593 
3594 	add_full_recv_buffer(rb);
3595 
3596 	itf->received++;
3597 	packets_received++;
3598 	return (buflen);
3599 }
3600 
3601 /*
3602  * attempt to handle io (select()/signaled IO)
3603  */
3604 void
3605 io_handler(void)
3606 {
3607 #  ifndef HAVE_SIGNALED_IO
3608 	fd_set rdfdes;
3609 	int nfound;
3610 
3611 	/*
3612 	 * Use select() on all on all input fd's for unlimited
3613 	 * time.  select() will terminate on SIGALARM or on the
3614 	 * reception of input.	Using select() means we can't do
3615 	 * robust signal handling and we get a potential race
3616 	 * between checking for alarms and doing the select().
3617 	 * Mostly harmless, I think.
3618 	 */
3619 	/*
3620 	 * On VMS, I suspect that select() can't be interrupted
3621 	 * by a "signal" either, so I take the easy way out and
3622 	 * have select() time out after one second.
3623 	 * System clock updates really aren't time-critical,
3624 	 * and - lacking a hardware reference clock - I have
3625 	 * yet to learn about anything else that is.
3626 	 */
3627 	++handler_calls;
3628 	rdfdes = activefds;
3629 #   if !defined(VMS) && !defined(SYS_VXWORKS)
3630 	nfound = select(maxactivefd + 1, &rdfdes, NULL,
3631 			NULL, NULL);
3632 #   else	/* VMS, VxWorks */
3633 	/* make select() wake up after one second */
3634 	{
3635 		struct timeval t1;
3636 		t1.tv_sec  = 1;
3637 		t1.tv_usec = 0;
3638 		nfound = select(maxactivefd + 1,
3639 				&rdfdes, NULL, NULL,
3640 				&t1);
3641 	}
3642 #   endif	/* VMS, VxWorks */
3643 	if (nfound < 0 && sanitize_fdset(errno)) {
3644 		struct timeval t1;
3645 		t1.tv_sec  = 0;
3646 		t1.tv_usec = 0;
3647 		rdfdes = activefds;
3648 		nfound = select(maxactivefd + 1,
3649 				&rdfdes, NULL, NULL,
3650 				&t1);
3651 	}
3652 
3653 	if (nfound > 0) {
3654 		l_fp ts;
3655 
3656 		get_systime(&ts);
3657 
3658 		input_handler_scan(&ts, &rdfdes);
3659 	} else if (nfound == -1 && errno != EINTR) {
3660 		msyslog(LOG_ERR, "select() error: %m");
3661 	}
3662 #   ifdef DEBUG
3663 	else if (debug > 4) {
3664 		msyslog(LOG_DEBUG, "select(): nfound=%d, error: %m", nfound);
3665 	} else {
3666 		DPRINTF(3, ("select() returned %d: %m\n", nfound));
3667 	}
3668 #   endif /* DEBUG */
3669 #  else /* HAVE_SIGNALED_IO */
3670 	wait_for_signal();
3671 #  endif /* HAVE_SIGNALED_IO */
3672 }
3673 
3674 #ifdef HAVE_SIGNALED_IO
3675 /*
3676  * input_handler - receive packets asynchronously
3677  *
3678  * ALWAYS IN SIGNAL HANDLER CONTEXT -- only async-safe functions allowed!
3679  */
3680 static RETSIGTYPE
3681 input_handler(
3682 	l_fp *	cts
3683 	)
3684 {
3685 	int		n;
3686 	struct timeval	tvzero;
3687 	fd_set		fds;
3688 
3689 	++handler_calls;
3690 
3691 	/*
3692 	 * Do a poll to see who has data
3693 	 */
3694 
3695 	fds = activefds;
3696 	tvzero.tv_sec = tvzero.tv_usec = 0;
3697 
3698 	n = select(maxactivefd + 1, &fds, NULL, NULL, &tvzero);
3699 	if (n < 0 && sanitize_fdset(errno)) {
3700 		fds = activefds;
3701 		tvzero.tv_sec = tvzero.tv_usec = 0;
3702 		n = select(maxactivefd + 1, &fds, NULL, NULL, &tvzero);
3703 	}
3704 	if (n > 0)
3705 		input_handler_scan(cts, &fds);
3706 }
3707 #endif /* HAVE_SIGNALED_IO */
3708 
3709 
3710 /*
3711  * Try to sanitize the global FD set
3712  *
3713  * SIGNAL HANDLER CONTEXT if HAVE_SIGNALED_IO, ordinary userspace otherwise
3714  */
3715 static int/*BOOL*/
3716 sanitize_fdset(
3717 	int	errc
3718 	)
3719 {
3720 	int j, b, maxscan;
3721 
3722 #  ifndef HAVE_SIGNALED_IO
3723 	/*
3724 	 * extended FAU debugging output
3725 	 */
3726 	if (errc != EINTR) {
3727 		msyslog(LOG_ERR,
3728 			"select(%d, %s, 0L, 0L, &0.0) error: %m",
3729 			maxactivefd + 1,
3730 			fdbits(maxactivefd, &activefds));
3731 	}
3732 #   endif
3733 
3734 	if (errc != EBADF)
3735 		return FALSE;
3736 
3737 	/* if we have oviously bad FDs, try to sanitize the FD set. */
3738 	for (j = 0, maxscan = 0; j <= maxactivefd; j++) {
3739 		if (FD_ISSET(j, &activefds)) {
3740 			if (-1 != read(j, &b, 0)) {
3741 				maxscan = j;
3742 				continue;
3743 			}
3744 #		    ifndef HAVE_SIGNALED_IO
3745 			msyslog(LOG_ERR,
3746 				"Removing bad file descriptor %d from select set",
3747 				j);
3748 #		    endif
3749 			FD_CLR(j, &activefds);
3750 		}
3751 	}
3752 	if (maxactivefd != maxscan)
3753 		maxactivefd = maxscan;
3754 	return TRUE;
3755 }
3756 
3757 /*
3758  * scan the known FDs (clocks, servers, ...) for presence in a 'fd_set'.
3759  *
3760  * SIGNAL HANDLER CONTEXT if HAVE_SIGNALED_IO, ordinary userspace otherwise
3761  */
3762 static void
3763 input_handler_scan(
3764 	const l_fp *	cts,
3765 	const fd_set *	pfds
3766 	)
3767 {
3768 	int		buflen;
3769 	u_int		idx;
3770 	int		doing;
3771 	SOCKET		fd;
3772 	blocking_child *c;
3773 	l_fp		ts;	/* Timestamp at BOselect() gob */
3774 
3775 #if defined(DEBUG_TIMING)
3776 	l_fp		ts_e;	/* Timestamp at EOselect() gob */
3777 #endif
3778 	endpt *		ep;
3779 #ifdef REFCLOCK
3780 	struct refclockio *rp;
3781 	int		saved_errno;
3782 	const char *	clk;
3783 #endif
3784 #ifdef HAS_ROUTING_SOCKET
3785 	struct asyncio_reader *	asyncio_reader;
3786 	struct asyncio_reader *	next_asyncio_reader;
3787 #endif
3788 
3789 	++handler_pkts;
3790 	ts = *cts;
3791 
3792 #ifdef REFCLOCK
3793 	/*
3794 	 * Check out the reference clocks first, if any
3795 	 */
3796 
3797 	for (rp = refio; rp != NULL; rp = rp->next) {
3798 		fd = rp->fd;
3799 
3800 		if (!FD_ISSET(fd, pfds))
3801 			continue;
3802 		buflen = read_refclock_packet(fd, rp, ts);
3803 		/*
3804 		 * The first read must succeed after select() indicates
3805 		 * readability, or we've reached a permanent EOF.
3806 		 * http://bugs.ntp.org/1732 reported ntpd munching CPU
3807 		 * after a USB GPS was unplugged because select was
3808 		 * indicating EOF but ntpd didn't remove the descriptor
3809 		 * from the activefds set.
3810 		 */
3811 		if (buflen < 0 && EAGAIN != errno) {
3812 			saved_errno = errno;
3813 			clk = refnumtoa(&rp->srcclock->srcadr);
3814 			errno = saved_errno;
3815 			msyslog(LOG_ERR, "%s read: %m", clk);
3816 			maintain_activefds(fd, TRUE);
3817 		} else if (0 == buflen) {
3818 			clk = refnumtoa(&rp->srcclock->srcadr);
3819 			msyslog(LOG_ERR, "%s read EOF", clk);
3820 			maintain_activefds(fd, TRUE);
3821 		} else {
3822 			/* drain any remaining refclock input */
3823 			do {
3824 				buflen = read_refclock_packet(fd, rp, ts);
3825 			} while (buflen > 0);
3826 		}
3827 	}
3828 #endif /* REFCLOCK */
3829 
3830 	/*
3831 	 * Loop through the interfaces looking for data to read.
3832 	 */
3833 	for (ep = ep_list; ep != NULL; ep = ep->elink) {
3834 		for (doing = 0; doing < 2; doing++) {
3835 			if (!doing) {
3836 				fd = ep->fd;
3837 			} else {
3838 				if (!(ep->flags & INT_BCASTOPEN))
3839 					break;
3840 				fd = ep->bfd;
3841 			}
3842 			if (fd < 0)
3843 				continue;
3844 			if (FD_ISSET(fd, pfds))
3845 				do {
3846 					buflen = read_network_packet(
3847 							fd, ep, ts);
3848 				} while (buflen > 0);
3849 			/* Check more interfaces */
3850 		}
3851 	}
3852 
3853 #ifdef HAS_ROUTING_SOCKET
3854 	/*
3855 	 * scan list of asyncio readers - currently only used for routing sockets
3856 	 */
3857 	asyncio_reader = asyncio_reader_list;
3858 
3859 	while (asyncio_reader != NULL) {
3860 		/* callback may unlink and free asyncio_reader */
3861 		next_asyncio_reader = asyncio_reader->link;
3862 		if (FD_ISSET(asyncio_reader->fd, pfds))
3863 			(*asyncio_reader->receiver)(asyncio_reader);
3864 		asyncio_reader = next_asyncio_reader;
3865 	}
3866 #endif /* HAS_ROUTING_SOCKET */
3867 
3868 	/*
3869 	 * Check for a response from a blocking child
3870 	 */
3871 	for (idx = 0; idx < blocking_children_alloc; idx++) {
3872 		c = blocking_children[idx];
3873 		if (NULL == c || -1 == c->resp_read_pipe)
3874 			continue;
3875 		if (FD_ISSET(c->resp_read_pipe, pfds)) {
3876 			++c->resp_ready_seen;
3877 			++blocking_child_ready_seen;
3878 		}
3879 	}
3880 
3881 	/* We've done our work */
3882 #if defined(DEBUG_TIMING)
3883 	get_systime(&ts_e);
3884 	/*
3885 	 * (ts_e - ts) is the amount of time we spent
3886 	 * processing this gob of file descriptors.  Log
3887 	 * it.
3888 	 */
3889 	L_SUB(&ts_e, &ts);
3890 	collect_timing(NULL, "input handler", 1, &ts_e);
3891 	if (debug > 3)
3892 		msyslog(LOG_DEBUG,
3893 			"input_handler: Processed a gob of fd's in %s msec",
3894 			lfptoms(&ts_e, 6));
3895 #endif /* DEBUG_TIMING */
3896 }
3897 #endif /* !HAVE_IO_COMPLETION_PORT */
3898 
3899 /*
3900  * find an interface suitable for the src address
3901  */
3902 endpt *
3903 select_peerinterface(
3904 	struct peer *	peer,
3905 	sockaddr_u *	srcadr,
3906 	endpt *		dstadr
3907 	)
3908 {
3909 	endpt *ep;
3910 #ifndef SIM
3911 	endpt *wild;
3912 
3913 	wild = ANY_INTERFACE_CHOOSE(srcadr);
3914 
3915 	/*
3916 	 * Initialize the peer structure and dance the interface jig.
3917 	 * Reference clocks step the loopback waltz, the others
3918 	 * squaredance around the interface list looking for a buddy. If
3919 	 * the dance peters out, there is always the wildcard interface.
3920 	 * This might happen in some systems and would preclude proper
3921 	 * operation with public key cryptography.
3922 	 */
3923 	if (ISREFCLOCKADR(srcadr)) {
3924 		ep = loopback_interface;
3925 	} else if (peer->cast_flags &
3926 		   (MDF_BCLNT | MDF_ACAST | MDF_MCAST | MDF_BCAST)) {
3927 		ep = findbcastinter(srcadr);
3928 		if (ep != NULL)
3929 			DPRINTF(4, ("Found *-cast interface %s for address %s\n",
3930 				stoa(&ep->sin), stoa(srcadr)));
3931 		else
3932 			DPRINTF(4, ("No *-cast local address found for address %s\n",
3933 				stoa(srcadr)));
3934 	} else {
3935 		ep = dstadr;
3936 		if (NULL == ep)
3937 			ep = wild;
3938 	}
3939 	/*
3940 	 * If it is a multicast address, findbcastinter() may not find
3941 	 * it.  For unicast, we get to find the interface when dstadr is
3942 	 * given to us as the wildcard (ANY_INTERFACE_CHOOSE).  Either
3943 	 * way, try a little harder.
3944 	 */
3945 	if (wild == ep)
3946 		ep = findinterface(srcadr);
3947 	/*
3948 	 * we do not bind to the wildcard interfaces for output
3949 	 * as our (network) source address would be undefined and
3950 	 * crypto will not work without knowing the own transmit address
3951 	 */
3952 	if (ep != NULL && INT_WILDCARD & ep->flags)
3953 		if (!accept_wildcard_if_for_winnt)
3954 			ep = NULL;
3955 #else	/* SIM follows */
3956 	ep = loopback_interface;
3957 #endif
3958 
3959 	return ep;
3960 }
3961 
3962 
3963 /*
3964  * findinterface - find local interface corresponding to address
3965  */
3966 endpt *
3967 findinterface(
3968 	sockaddr_u *addr
3969 	)
3970 {
3971 	endpt *iface;
3972 
3973 	iface = findlocalinterface(addr, INT_WILDCARD, 0);
3974 
3975 	if (NULL == iface) {
3976 		DPRINTF(4, ("Found no interface for address %s - returning wildcard\n",
3977 			    stoa(addr)));
3978 
3979 		iface = ANY_INTERFACE_CHOOSE(addr);
3980 	} else
3981 		DPRINTF(4, ("Found interface #%d %s for address %s\n",
3982 			    iface->ifnum, iface->name, stoa(addr)));
3983 
3984 	return iface;
3985 }
3986 
3987 /*
3988  * findlocalinterface - find local interface corresponding to addr,
3989  * which does not have any of flags set.  If bast is nonzero, addr is
3990  * a broadcast address.
3991  *
3992  * This code attempts to find the local sending address for an outgoing
3993  * address by connecting a new socket to destinationaddress:NTP_PORT
3994  * and reading the sockname of the resulting connect.
3995  * the complicated sequence simulates the routing table lookup
3996  * for to first hop without duplicating any of the routing logic into
3997  * ntpd. preferably we would have used an API call - but its not there -
3998  * so this is the best we can do here short of duplicating to entire routing
3999  * logic in ntpd which would be a silly and really unportable thing to do.
4000  *
4001  */
4002 static endpt *
4003 findlocalinterface(
4004 	sockaddr_u *	addr,
4005 	int		flags,
4006 	int		bcast
4007 	)
4008 {
4009 	GETSOCKNAME_SOCKLEN_TYPE	sockaddrlen;
4010 	endpt *				iface;
4011 	sockaddr_u			saddr;
4012 	SOCKET				s;
4013 	int				rtn;
4014 	int				on;
4015 
4016 	DPRINTF(4, ("Finding interface for addr %s in list of addresses\n",
4017 		    stoa(addr)));
4018 
4019 	/* [Bug 3437] The dummy POOL peer comes in with an AF of
4020 	 * zero. This is bound to fail, but on the way to nowhere it
4021 	 * triggers a security incident on SELinux.
4022 	 *
4023 	 * Checking the condition and failing early is probably a good
4024 	 * advice, and even saves us some syscalls in that case.
4025 	 * Thanks to Miroslav Lichvar for finding this.
4026 	 */
4027 	if (AF_UNSPEC == AF(addr))
4028 		return NULL;
4029 
4030 	s = socket(AF(addr), SOCK_DGRAM, 0);
4031 	if (INVALID_SOCKET == s)
4032 		return NULL;
4033 
4034 	/*
4035 	 * If we are looking for broadcast interface we need to set this
4036 	 * socket to allow broadcast
4037 	 */
4038 	if (bcast) {
4039 		on = 1;
4040 		if (SOCKET_ERROR == setsockopt(s, SOL_SOCKET,
4041 						SO_BROADCAST,
4042 						(void *)&on,
4043 						sizeof(on))) {
4044 			closesocket(s);
4045 			return NULL;
4046 		}
4047 	}
4048 
4049 	rtn = connect(s, &addr->sa, SOCKLEN(addr));
4050 	if (SOCKET_ERROR == rtn) {
4051 		closesocket(s);
4052 		return NULL;
4053 	}
4054 
4055 	sockaddrlen = sizeof(saddr);
4056 	rtn = getsockname(s, &saddr.sa, &sockaddrlen);
4057 	closesocket(s);
4058 	if (SOCKET_ERROR == rtn)
4059 		return NULL;
4060 
4061 	DPRINTF(4, ("findlocalinterface: kernel maps %s to %s\n",
4062 		    stoa(addr), stoa(&saddr)));
4063 
4064 	iface = getinterface(&saddr, flags);
4065 
4066 	/*
4067 	 * if we didn't find an exact match on saddr, find the closest
4068 	 * available local address.  This handles the case of the
4069 	 * address suggested by the kernel being excluded by nic rules
4070 	 * or the user's -I and -L options to ntpd.
4071 	 * See http://bugs.ntp.org/1184 and http://bugs.ntp.org/1683
4072 	 * for more background.
4073 	 */
4074 	if (NULL == iface || iface->ignore_packets)
4075 		iface = findclosestinterface(&saddr,
4076 					     flags | INT_LOOPBACK);
4077 
4078 	/* Don't use an interface which will ignore replies */
4079 	if (iface != NULL && iface->ignore_packets)
4080 		iface = NULL;
4081 
4082 	return iface;
4083 }
4084 
4085 
4086 /*
4087  * findclosestinterface
4088  *
4089  * If there are -I/--interface or -L/novirtualips command-line options,
4090  * or "nic" or "interface" rules in ntp.conf, findlocalinterface() may
4091  * find the kernel's preferred local address for a given peer address is
4092  * administratively unavailable to ntpd, and punt to this routine's more
4093  * expensive search.
4094  *
4095  * Find the numerically closest local address to the one connect()
4096  * suggested.  This matches an address on the same subnet first, as
4097  * needed by Bug 1184, and provides a consistent choice if there are
4098  * multiple feasible local addresses, regardless of the order ntpd
4099  * enumerated them.
4100  */
4101 endpt *
4102 findclosestinterface(
4103 	sockaddr_u *	addr,
4104 	int		flags
4105 	)
4106 {
4107 	endpt *		ep;
4108 	endpt *		winner;
4109 	sockaddr_u	addr_dist;
4110 	sockaddr_u	min_dist;
4111 
4112 	ZERO_SOCK(&min_dist);
4113 	winner = NULL;
4114 
4115 	for (ep = ep_list; ep != NULL; ep = ep->elink) {
4116 		if (ep->ignore_packets ||
4117 		    AF(addr) != ep->family ||
4118 		    flags & ep->flags)
4119 			continue;
4120 
4121 		calc_addr_distance(&addr_dist, addr, &ep->sin);
4122 		if (NULL == winner ||
4123 		    -1 == cmp_addr_distance(&addr_dist, &min_dist)) {
4124 			min_dist = addr_dist;
4125 			winner = ep;
4126 		}
4127 	}
4128 	if (NULL == winner)
4129 		DPRINTF(4, ("findclosestinterface(%s) failed\n",
4130 			    stoa(addr)));
4131 	else
4132 		DPRINTF(4, ("findclosestinterface(%s) -> %s\n",
4133 			    stoa(addr), stoa(&winner->sin)));
4134 
4135 	return winner;
4136 }
4137 
4138 
4139 /*
4140  * calc_addr_distance - calculate the distance between two addresses,
4141  *			the absolute value of the difference between
4142  *			the addresses numerically, stored as an address.
4143  */
4144 static void
4145 calc_addr_distance(
4146 	sockaddr_u *		dist,
4147 	const sockaddr_u *	a1,
4148 	const sockaddr_u *	a2
4149 	)
4150 {
4151 	u_int32	a1val;
4152 	u_int32	a2val;
4153 	u_int32	v4dist;
4154 	int	found_greater;
4155 	int	a1_greater;
4156 	int	i;
4157 
4158 	REQUIRE(AF(a1) == AF(a2));
4159 
4160 	ZERO_SOCK(dist);
4161 	AF(dist) = AF(a1);
4162 
4163 	/* v4 can be done a bit simpler */
4164 	if (IS_IPV4(a1)) {
4165 		a1val = SRCADR(a1);
4166 		a2val = SRCADR(a2);
4167 		v4dist = (a1val > a2val)
4168 			     ? a1val - a2val
4169 			     : a2val - a1val;
4170 		SET_ADDR4(dist, v4dist);
4171 
4172 		return;
4173 	}
4174 
4175 	found_greater = FALSE;
4176 	a1_greater = FALSE;	/* suppress pot. uninit. warning */
4177 	for (i = 0; i < (int)sizeof(NSRCADR6(a1)); i++) {
4178 		if (!found_greater &&
4179 		    NSRCADR6(a1)[i] != NSRCADR6(a2)[i]) {
4180 			found_greater = TRUE;
4181 			a1_greater = (NSRCADR6(a1)[i] > NSRCADR6(a2)[i]);
4182 		}
4183 		if (!found_greater) {
4184 			NSRCADR6(dist)[i] = 0;
4185 		} else {
4186 			if (a1_greater)
4187 				NSRCADR6(dist)[i] = NSRCADR6(a1)[i] -
4188 						    NSRCADR6(a2)[i];
4189 			else
4190 				NSRCADR6(dist)[i] = NSRCADR6(a2)[i] -
4191 						    NSRCADR6(a1)[i];
4192 		}
4193 	}
4194 }
4195 
4196 
4197 /*
4198  * cmp_addr_distance - compare two address distances, returning -1, 0,
4199  *		       1 to indicate their relationship.
4200  */
4201 static int
4202 cmp_addr_distance(
4203 	const sockaddr_u *	d1,
4204 	const sockaddr_u *	d2
4205 	)
4206 {
4207 	int	i;
4208 
4209 	REQUIRE(AF(d1) == AF(d2));
4210 
4211 	if (IS_IPV4(d1)) {
4212 		if (SRCADR(d1) < SRCADR(d2))
4213 			return -1;
4214 		else if (SRCADR(d1) == SRCADR(d2))
4215 			return 0;
4216 		else
4217 			return 1;
4218 	}
4219 
4220 	for (i = 0; i < (int)sizeof(NSRCADR6(d1)); i++) {
4221 		if (NSRCADR6(d1)[i] < NSRCADR6(d2)[i])
4222 			return -1;
4223 		else if (NSRCADR6(d1)[i] > NSRCADR6(d2)[i])
4224 			return 1;
4225 	}
4226 
4227 	return 0;
4228 }
4229 
4230 
4231 
4232 /*
4233  * fetch an interface structure the matches the
4234  * address and has the given flags NOT set
4235  */
4236 endpt *
4237 getinterface(
4238 	sockaddr_u *	addr,
4239 	u_int32		flags
4240 	)
4241 {
4242 	endpt *iface;
4243 
4244 	iface = find_addr_in_list(addr);
4245 
4246 	if (iface != NULL && (iface->flags & flags))
4247 		iface = NULL;
4248 
4249 	return iface;
4250 }
4251 
4252 
4253 /*
4254  * findbcastinter - find broadcast interface corresponding to address
4255  */
4256 endpt *
4257 findbcastinter(
4258 	sockaddr_u *addr
4259 	)
4260 {
4261 	endpt *	iface;
4262 
4263 	iface = NULL;
4264 #if !defined(MPE) && (defined(SIOCGIFCONF) || defined(SYS_WINNT))
4265 	DPRINTF(4, ("Finding broadcast/multicast interface for addr %s in list of addresses\n",
4266 		    stoa(addr)));
4267 
4268 	iface = findlocalinterface(addr, INT_LOOPBACK | INT_WILDCARD,
4269 				   1);
4270 	if (iface != NULL) {
4271 		DPRINTF(4, ("Easily found bcast-/mcast- interface index #%d %s\n",
4272 			    iface->ifnum, iface->name));
4273 		return iface;
4274 	}
4275 
4276 	/*
4277 	 * plan B - try to find something reasonable in our lists in
4278 	 * case kernel lookup doesn't help
4279 	 */
4280 	for (iface = ep_list; iface != NULL; iface = iface->elink) {
4281 		if (iface->flags & INT_WILDCARD)
4282 			continue;
4283 
4284 		/* Don't bother with ignored interfaces */
4285 		if (iface->ignore_packets)
4286 			continue;
4287 
4288 		/*
4289 		 * First look if this is the correct family
4290 		 */
4291 		if(AF(&iface->sin) != AF(addr))
4292 			continue;
4293 
4294 		/* Skip the loopback addresses */
4295 		if (iface->flags & INT_LOOPBACK)
4296 			continue;
4297 
4298 		/*
4299 		 * If we are looking to match a multicast address and
4300 		 * this interface is one...
4301 		 */
4302 		if (addr_ismulticast(addr)
4303 		    && (iface->flags & INT_MULTICAST)) {
4304 #ifdef INCLUDE_IPV6_SUPPORT
4305 			/*
4306 			 * ...it is the winner unless we're looking for
4307 			 * an interface to use for link-local multicast
4308 			 * and its address is not link-local.
4309 			 */
4310 			if (IS_IPV6(addr)
4311 			    && IN6_IS_ADDR_MC_LINKLOCAL(PSOCK_ADDR6(addr))
4312 			    && !IN6_IS_ADDR_LINKLOCAL(PSOCK_ADDR6(&iface->sin)))
4313 				continue;
4314 #endif
4315 			break;
4316 		}
4317 
4318 		/*
4319 		 * We match only those interfaces marked as
4320 		 * broadcastable and either the explicit broadcast
4321 		 * address or the network portion of the IP address.
4322 		 * Sloppy.
4323 		 */
4324 		if (IS_IPV4(addr)) {
4325 			if (SOCK_EQ(&iface->bcast, addr))
4326 				break;
4327 
4328 			if ((NSRCADR(&iface->sin) & NSRCADR(&iface->mask))
4329 			    == (NSRCADR(addr)	  & NSRCADR(&iface->mask)))
4330 				break;
4331 		}
4332 #ifdef INCLUDE_IPV6_SUPPORT
4333 		else if (IS_IPV6(addr)) {
4334 			if (SOCK_EQ(&iface->bcast, addr))
4335 				break;
4336 
4337 			if (SOCK_EQ(netof(&iface->sin), netof(addr)))
4338 				break;
4339 		}
4340 #endif
4341 	}
4342 #endif /* SIOCGIFCONF */
4343 	if (NULL == iface) {
4344 		DPRINTF(4, ("No bcast interface found for %s\n",
4345 			    stoa(addr)));
4346 		iface = ANY_INTERFACE_CHOOSE(addr);
4347 	} else {
4348 		DPRINTF(4, ("Found bcast-/mcast- interface index #%d %s\n",
4349 			    iface->ifnum, iface->name));
4350 	}
4351 
4352 	return iface;
4353 }
4354 
4355 
4356 /*
4357  * io_clr_stats - clear I/O module statistics
4358  */
4359 void
4360 io_clr_stats(void)
4361 {
4362 	packets_dropped = 0;
4363 	packets_ignored = 0;
4364 	packets_received = 0;
4365 	packets_sent = 0;
4366 	packets_notsent = 0;
4367 
4368 	handler_calls = 0;
4369 	handler_pkts = 0;
4370 	io_timereset = current_time;
4371 }
4372 
4373 
4374 #ifdef REFCLOCK
4375 /*
4376  * io_addclock - add a reference clock to the list and arrange that we
4377  *				 get SIGIO interrupts from it.
4378  */
4379 int
4380 io_addclock(
4381 	struct refclockio *rio
4382 	)
4383 {
4384 	BLOCKIO();
4385 
4386 	/*
4387 	 * Stuff the I/O structure in the list and mark the descriptor
4388 	 * in use.  There is a harmless (I hope) race condition here.
4389 	 */
4390 	rio->active = TRUE;
4391 
4392 # ifdef HAVE_SIGNALED_IO
4393 	if (init_clock_sig(rio)) {
4394 		UNBLOCKIO();
4395 		return 0;
4396 	}
4397 # elif defined(HAVE_IO_COMPLETION_PORT)
4398 	if (!io_completion_port_add_clock_io(rio)) {
4399 		UNBLOCKIO();
4400 		return 0;
4401 	}
4402 # endif
4403 
4404 	/*
4405 	 * enqueue
4406 	 */
4407 	LINK_SLIST(refio, rio, next);
4408 
4409 	/*
4410 	 * register fd
4411 	 */
4412 	add_fd_to_list(rio->fd, FD_TYPE_FILE);
4413 
4414 	UNBLOCKIO();
4415 	return 1;
4416 }
4417 
4418 
4419 /*
4420  * io_closeclock - close the clock in the I/O structure given
4421  */
4422 void
4423 io_closeclock(
4424 	struct refclockio *rio
4425 	)
4426 {
4427 	struct refclockio *unlinked;
4428 
4429 	BLOCKIO();
4430 
4431 	/*
4432 	 * Remove structure from the list
4433 	 */
4434 	rio->active = FALSE;
4435 	UNLINK_SLIST(unlinked, refio, rio, next, struct refclockio);
4436 	if (NULL != unlinked) {
4437 		/* Close the descriptor. The order of operations is
4438 		 * important here in case of async / overlapped IO:
4439 		 * only after we have removed the clock from the
4440 		 * IO completion port we can be sure no further
4441 		 * input is queued. So...
4442 		 *  - we first disable feeding to the queu by removing
4443 		 *    the clock from the IO engine
4444 		 *  - close the file (which brings down any IO on it)
4445 		 *  - clear the buffer from results for this fd
4446 		 */
4447 #	    ifdef HAVE_IO_COMPLETION_PORT
4448 		io_completion_port_remove_clock_io(rio);
4449 #	    endif
4450 		close_and_delete_fd_from_list(rio->fd);
4451 		purge_recv_buffers_for_fd(rio->fd);
4452 		rio->fd = -1;
4453 	}
4454 
4455 	UNBLOCKIO();
4456 }
4457 #endif	/* REFCLOCK */
4458 
4459 
4460 /*
4461  * On NT a SOCKET is an unsigned int so we cannot possibly keep it in
4462  * an array. So we use one of the ISC_LIST functions to hold the
4463  * socket value and use that when we want to enumerate it.
4464  *
4465  * This routine is called by the forked intres child process to close
4466  * all open sockets.  On Windows there's no need as intres runs in
4467  * the same process as a thread.
4468  */
4469 #ifndef SYS_WINNT
4470 void
4471 kill_asyncio(
4472 	int	startfd
4473 	)
4474 {
4475 	BLOCKIO();
4476 
4477 	/*
4478 	 * In the child process we do not maintain activefds and
4479 	 * maxactivefd.  Zeroing maxactivefd disables code which
4480 	 * maintains it in close_and_delete_fd_from_list().
4481 	 */
4482 	maxactivefd = 0;
4483 
4484 	while (fd_list != NULL)
4485 		close_and_delete_fd_from_list(fd_list->fd);
4486 
4487 	UNBLOCKIO();
4488 }
4489 #endif	/* !SYS_WINNT */
4490 
4491 
4492 /*
4493  * Add and delete functions for the list of open sockets
4494  */
4495 static void
4496 add_fd_to_list(
4497 	SOCKET fd,
4498 	enum desc_type type
4499 	)
4500 {
4501 	vsock_t *lsock = emalloc(sizeof(*lsock));
4502 
4503 	lsock->fd = fd;
4504 	lsock->type = type;
4505 
4506 	LINK_SLIST(fd_list, lsock, link);
4507 	maintain_activefds(fd, 0);
4508 }
4509 
4510 
4511 static void
4512 close_and_delete_fd_from_list(
4513 	SOCKET fd
4514 	)
4515 {
4516 	vsock_t *lsock;
4517 
4518 	UNLINK_EXPR_SLIST(lsock, fd_list, fd ==
4519 	    UNLINK_EXPR_SLIST_CURRENT()->fd, link, vsock_t);
4520 
4521 	if (NULL == lsock)
4522 		return;
4523 
4524 	switch (lsock->type) {
4525 
4526 	case FD_TYPE_SOCKET:
4527 		closesocket(lsock->fd);
4528 		break;
4529 
4530 	case FD_TYPE_FILE:
4531 		closeserial((int)lsock->fd);
4532 		break;
4533 
4534 	default:
4535 		msyslog(LOG_ERR,
4536 			"internal error - illegal descriptor type %d - EXITING",
4537 			(int)lsock->type);
4538 		exit(1);
4539 	}
4540 
4541 	free(lsock);
4542 	/*
4543 	 * remove from activefds
4544 	 */
4545 	maintain_activefds(fd, 1);
4546 }
4547 
4548 
4549 static void
4550 add_addr_to_list(
4551 	sockaddr_u *	addr,
4552 	endpt *		ep
4553 	)
4554 {
4555 	remaddr_t *laddr;
4556 
4557 #ifdef DEBUG
4558 	if (find_addr_in_list(addr) == NULL) {
4559 #endif
4560 		/* not there yet - add to list */
4561 		laddr = emalloc(sizeof(*laddr));
4562 		laddr->addr = *addr;
4563 		laddr->ep = ep;
4564 
4565 		LINK_SLIST(remoteaddr_list, laddr, link);
4566 
4567 		DPRINTF(4, ("Added addr %s to list of addresses\n",
4568 			    stoa(addr)));
4569 #ifdef DEBUG
4570 	} else
4571 		DPRINTF(4, ("WARNING: Attempt to add duplicate addr %s to address list\n",
4572 			    stoa(addr)));
4573 #endif
4574 }
4575 
4576 
4577 static void
4578 delete_addr_from_list(
4579 	sockaddr_u *addr
4580 	)
4581 {
4582 	remaddr_t *unlinked;
4583 
4584 	UNLINK_EXPR_SLIST(unlinked, remoteaddr_list, SOCK_EQ(addr,
4585 		&(UNLINK_EXPR_SLIST_CURRENT()->addr)), link, remaddr_t);
4586 
4587 	if (unlinked != NULL) {
4588 		DPRINTF(4, ("Deleted addr %s from list of addresses\n",
4589 			stoa(addr)));
4590 		free(unlinked);
4591 	}
4592 }
4593 
4594 
4595 static void
4596 delete_interface_from_list(
4597 	endpt *iface
4598 	)
4599 {
4600 	remaddr_t *unlinked;
4601 
4602 	for (;;) {
4603 		UNLINK_EXPR_SLIST(unlinked, remoteaddr_list, iface ==
4604 		    UNLINK_EXPR_SLIST_CURRENT()->ep, link,
4605 		    remaddr_t);
4606 
4607 		if (unlinked == NULL)
4608 			break;
4609 		DPRINTF(4, ("Deleted addr %s for interface #%d %s from list of addresses\n",
4610 			    stoa(&unlinked->addr), iface->ifnum,
4611 			    iface->name));
4612 		free(unlinked);
4613 	}
4614 }
4615 
4616 
4617 static struct interface *
4618 find_addr_in_list(
4619 	sockaddr_u *addr
4620 	)
4621 {
4622 	remaddr_t *entry;
4623 
4624 	DPRINTF(4, ("Searching for addr %s in list of addresses - ",
4625 		    stoa(addr)));
4626 
4627 	for (entry = remoteaddr_list;
4628 	     entry != NULL;
4629 	     entry = entry->link)
4630 		if (SOCK_EQ(&entry->addr, addr)) {
4631 			DPRINTF(4, ("FOUND\n"));
4632 			return entry->ep;
4633 		}
4634 
4635 	DPRINTF(4, ("NOT FOUND\n"));
4636 	return NULL;
4637 }
4638 
4639 
4640 /*
4641  * Find the given address with the all given flags set in the list
4642  */
4643 static endpt *
4644 find_flagged_addr_in_list(
4645 	sockaddr_u *	addr,
4646 	u_int32		flags
4647 	)
4648 {
4649 	remaddr_t *entry;
4650 
4651 	DPRINTF(4, ("Finding addr %s with flags %d in list: ",
4652 		    stoa(addr), flags));
4653 
4654 	for (entry = remoteaddr_list;
4655 	     entry != NULL;
4656 	     entry = entry->link)
4657 
4658 		if (SOCK_EQ(&entry->addr, addr)
4659 		    && (entry->ep->flags & flags) == flags) {
4660 
4661 			DPRINTF(4, ("FOUND\n"));
4662 			return entry->ep;
4663 		}
4664 
4665 	DPRINTF(4, ("NOT FOUND\n"));
4666 	return NULL;
4667 }
4668 
4669 
4670 const char *
4671 localaddrtoa(
4672 	endpt *la
4673 	)
4674 {
4675 	return (NULL == la)
4676 		   ? "<null>"
4677 		   : stoa(&la->sin);
4678 }
4679 
4680 
4681 #ifdef HAS_ROUTING_SOCKET
4682 # ifndef UPDATE_GRACE
4683 #  define UPDATE_GRACE	2	/* wait UPDATE_GRACE seconds before scanning */
4684 # endif
4685 
4686 static void
4687 process_routing_msgs(struct asyncio_reader *reader)
4688 {
4689 	char buffer[5120];
4690 	int cnt, msg_type;
4691 #ifdef HAVE_RTNETLINK
4692 	struct nlmsghdr *nh;
4693 #else
4694 	struct rt_msghdr rtm;
4695 	char *p;
4696 #endif
4697 
4698 	if (disable_dynamic_updates) {
4699 		/*
4700 		 * discard ourselves if we are not needed any more
4701 		 * usually happens when running unprivileged
4702 		 */
4703 		remove_asyncio_reader(reader);
4704 		delete_asyncio_reader(reader);
4705 		return;
4706 	}
4707 
4708 	cnt = read(reader->fd, buffer, sizeof(buffer));
4709 
4710 	if (cnt < 0) {
4711 		if (errno == ENOBUFS) {
4712 			msyslog(LOG_ERR,
4713 				"routing socket reports: %m");
4714 		} else {
4715 			msyslog(LOG_ERR,
4716 				"routing socket reports: %m - disabling");
4717 			remove_asyncio_reader(reader);
4718 			delete_asyncio_reader(reader);
4719 		}
4720 		return;
4721 	}
4722 
4723 	/*
4724 	 * process routing message
4725 	 */
4726 #ifdef HAVE_RTNETLINK
4727 	for (nh = UA_PTR(struct nlmsghdr, buffer);
4728 	     NLMSG_OK(nh, cnt);
4729 	     nh = NLMSG_NEXT(nh, cnt)) {
4730 		msg_type = nh->nlmsg_type;
4731 #else
4732 	for (p = buffer;
4733 	     (p + sizeof(struct rt_msghdr)) <= (buffer + cnt);
4734 	     p += rtm.rtm_msglen) {
4735 		memcpy(&rtm, p, sizeof(rtm));
4736 		if (rtm.rtm_version != RTM_VERSION) {
4737 			msyslog(LOG_ERR,
4738 				"version mismatch (got %d - expected %d) on routing socket - disabling",
4739 				rtm.rtm_version, RTM_VERSION);
4740 
4741 			remove_asyncio_reader(reader);
4742 			delete_asyncio_reader(reader);
4743 			return;
4744 		}
4745 		msg_type = rtm.rtm_type;
4746 #endif
4747 		switch (msg_type) {
4748 #ifdef RTM_NEWADDR
4749 		case RTM_NEWADDR:
4750 #endif
4751 #ifdef RTM_DELADDR
4752 		case RTM_DELADDR:
4753 #endif
4754 #ifdef RTM_ADD
4755 		case RTM_ADD:
4756 #endif
4757 #ifdef RTM_DELETE
4758 		case RTM_DELETE:
4759 #endif
4760 #ifdef RTM_REDIRECT
4761 		case RTM_REDIRECT:
4762 #endif
4763 #ifdef RTM_CHANGE
4764 		case RTM_CHANGE:
4765 #endif
4766 #ifdef RTM_LOSING
4767 		case RTM_LOSING:
4768 #endif
4769 #ifdef RTM_IFINFO
4770 		case RTM_IFINFO:
4771 #endif
4772 #ifdef RTM_IFANNOUNCE
4773 		case RTM_IFANNOUNCE:
4774 #endif
4775 #ifdef RTM_NEWLINK
4776 		case RTM_NEWLINK:
4777 #endif
4778 #ifdef RTM_DELLINK
4779 		case RTM_DELLINK:
4780 #endif
4781 #ifdef RTM_NEWROUTE
4782 		case RTM_NEWROUTE:
4783 #endif
4784 #ifdef RTM_DELROUTE
4785 		case RTM_DELROUTE:
4786 #endif
4787 			/*
4788 			 * we are keen on new and deleted addresses and
4789 			 * if an interface goes up and down or routing
4790 			 * changes
4791 			 */
4792 			DPRINTF(3, ("routing message op = %d: scheduling interface update\n",
4793 				    msg_type));
4794 			timer_interfacetimeout(current_time + UPDATE_GRACE);
4795 			break;
4796 #ifdef HAVE_RTNETLINK
4797 		case NLMSG_DONE:
4798 			/* end of multipart message */
4799 			return;
4800 #endif
4801 		default:
4802 			/*
4803 			 * the rest doesn't bother us.
4804 			 */
4805 			DPRINTF(4, ("routing message op = %d: ignored\n",
4806 				    msg_type));
4807 			break;
4808 		}
4809 	}
4810 }
4811 
4812 /*
4813  * set up routing notifications
4814  */
4815 static void
4816 init_async_notifications()
4817 {
4818 	struct asyncio_reader *reader;
4819 #ifdef HAVE_RTNETLINK
4820 	int fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
4821 	struct sockaddr_nl sa;
4822 #else
4823 	int fd = socket(PF_ROUTE, SOCK_RAW, 0);
4824 #endif
4825 	if (fd < 0) {
4826 		msyslog(LOG_ERR,
4827 			"unable to open routing socket (%m) - using polled interface update");
4828 		return;
4829 	}
4830 
4831 	fd = move_fd(fd);
4832 #ifdef HAVE_RTNETLINK
4833 	ZERO(sa);
4834 	sa.nl_family = PF_NETLINK;
4835 	sa.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR
4836 		       | RTMGRP_IPV6_IFADDR | RTMGRP_IPV4_ROUTE
4837 		       | RTMGRP_IPV4_MROUTE | RTMGRP_IPV6_ROUTE
4838 		       | RTMGRP_IPV6_MROUTE;
4839 	if (bind(fd, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
4840 		msyslog(LOG_ERR,
4841 			"bind failed on routing socket (%m) - using polled interface update");
4842 		return;
4843 	}
4844 #endif
4845 	make_socket_nonblocking(fd);
4846 #if defined(HAVE_SIGNALED_IO)
4847 	init_socket_sig(fd);
4848 #endif /* HAVE_SIGNALED_IO */
4849 
4850 	reader = new_asyncio_reader();
4851 
4852 	reader->fd = fd;
4853 	reader->receiver = process_routing_msgs;
4854 
4855 	add_asyncio_reader(reader, FD_TYPE_SOCKET);
4856 	msyslog(LOG_INFO,
4857 		"Listening on routing socket on fd #%d for interface updates",
4858 		fd);
4859 }
4860 #else
4861 /* HAS_ROUTING_SOCKET not defined */
4862 static void
4863 init_async_notifications(void)
4864 {
4865 }
4866 #endif
4867 
4868