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