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