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 static isc_boolean_t broadcast_client_enabled; /* is broadcast client enabled */ 181 u_int sys_ifnum; /* next .ifnum to assign */ 182 int ninterfaces; /* Total number of interfaces */ 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 || sys_bclient) 2015 io_setbclient(); 2016 2017 #ifdef MCAST 2018 /* 2019 * Check multicast interfaces and try to join multicast groups if 2020 * not joined yet. 2021 */ 2022 for (ep = ep_list; ep != NULL; ep = ep->elink) { 2023 remaddr_t *entry; 2024 2025 if (!(INT_MCASTIF & ep->flags) || (INT_MCASTOPEN & ep->flags)) 2026 continue; 2027 2028 /* Find remote address that was linked to this interface */ 2029 for (entry = remoteaddr_list; 2030 entry != NULL; 2031 entry = entry->link) { 2032 if (entry->ep == ep) { 2033 if (socket_multicast_enable(ep, &entry->addr)) { 2034 msyslog(LOG_INFO, 2035 "Joined %s socket to multicast group %s", 2036 stoa(&ep->sin), 2037 stoa(&entry->addr)); 2038 } 2039 break; 2040 } 2041 } 2042 } 2043 #endif /* MCAST */ 2044 2045 return new_interface_found; 2046 } 2047 2048 2049 /* 2050 * create_sockets - create a socket for each interface plus a default 2051 * socket for when we don't know where to send 2052 */ 2053 static int 2054 create_sockets( 2055 u_short port 2056 ) 2057 { 2058 #ifndef HAVE_IO_COMPLETION_PORT 2059 /* 2060 * I/O Completion Ports don't care about the select and FD_SET 2061 */ 2062 maxactivefd = 0; 2063 FD_ZERO(&activefds); 2064 #endif 2065 2066 DPRINTF(2, ("create_sockets(%d)\n", port)); 2067 2068 create_wildcards(port); 2069 2070 update_interfaces(port, NULL, NULL); 2071 2072 /* 2073 * Now that we have opened all the sockets, turn off the reuse 2074 * flag for security. 2075 */ 2076 set_reuseaddr(0); 2077 2078 DPRINTF(2, ("create_sockets: Total interfaces = %d\n", ninterfaces)); 2079 2080 return ninterfaces; 2081 } 2082 2083 /* 2084 * create_interface - create a new interface for a given prototype 2085 * binding the socket. 2086 */ 2087 static struct interface * 2088 create_interface( 2089 u_short port, 2090 struct interface * protot 2091 ) 2092 { 2093 sockaddr_u resmask; 2094 endpt * iface; 2095 #if defined(MCAST) && defined(MULTICAST_NONEWSOCKET) 2096 remaddr_t * entry; 2097 remaddr_t * next_entry; 2098 #endif 2099 DPRINTF(2, ("create_interface(%s#%d)\n", stoa(&protot->sin), 2100 port)); 2101 2102 /* build an interface */ 2103 iface = new_interface(protot); 2104 2105 /* 2106 * create socket 2107 */ 2108 iface->fd = open_socket(&iface->sin, 0, 0, iface); 2109 2110 if (iface->fd != INVALID_SOCKET) 2111 log_listen_address(iface); 2112 2113 if ((INT_BROADCAST & iface->flags) 2114 && iface->bfd != INVALID_SOCKET) 2115 msyslog(LOG_INFO, "Listening on broadcast address %s#%d", 2116 stoa((&iface->bcast)), port); 2117 2118 if (INVALID_SOCKET == iface->fd 2119 && INVALID_SOCKET == iface->bfd) { 2120 msyslog(LOG_ERR, "unable to create socket on %s (%d) for %s#%d", 2121 iface->name, 2122 iface->ifnum, 2123 stoa((&iface->sin)), 2124 port); 2125 delete_interface(iface); 2126 return NULL; 2127 } 2128 2129 /* 2130 * Blacklist our own addresses, no use talking to ourself 2131 */ 2132 SET_HOSTMASK(&resmask, AF(&iface->sin)); 2133 hack_restrict(RESTRICT_FLAGS, &iface->sin, &resmask, 2134 -4, RESM_NTPONLY | RESM_INTERFACE, RES_IGNORE, 0); 2135 2136 /* 2137 * set globals with the first found 2138 * loopback interface of the appropriate class 2139 */ 2140 if (NULL == loopback_interface && AF_INET == iface->family 2141 && (INT_LOOPBACK & iface->flags)) 2142 loopback_interface = iface; 2143 2144 /* 2145 * put into our interface list 2146 */ 2147 add_addr_to_list(&iface->sin, iface); 2148 add_interface(iface); 2149 2150 #if defined(MCAST) && defined(MULTICAST_NONEWSOCKET) 2151 /* 2152 * Join any previously-configured compatible multicast groups. 2153 */ 2154 if (INT_MULTICAST & iface->flags && 2155 !((INT_LOOPBACK | INT_WILDCARD) & iface->flags) && 2156 !iface->ignore_packets) { 2157 for (entry = remoteaddr_list; 2158 entry != NULL; 2159 entry = next_entry) { 2160 next_entry = entry->link; 2161 if (AF(&iface->sin) != AF(&entry->addr) || 2162 !IS_MCAST(&entry->addr)) 2163 continue; 2164 if (socket_multicast_enable(iface, 2165 &entry->addr)) 2166 msyslog(LOG_INFO, 2167 "Joined %s socket to multicast group %s", 2168 stoa(&iface->sin), 2169 stoa(&entry->addr)); 2170 else 2171 msyslog(LOG_ERR, 2172 "Failed to join %s socket to multicast group %s", 2173 stoa(&iface->sin), 2174 stoa(&entry->addr)); 2175 } 2176 } 2177 #endif /* MCAST && MCAST_NONEWSOCKET */ 2178 2179 DPRINT_INTERFACE(2, (iface, "created ", "\n")); 2180 return iface; 2181 } 2182 2183 2184 #ifdef SO_EXCLUSIVEADDRUSE 2185 static void 2186 set_excladdruse( 2187 SOCKET fd 2188 ) 2189 { 2190 int one = 1; 2191 int failed; 2192 #ifdef SYS_WINNT 2193 DWORD err; 2194 #endif 2195 2196 failed = setsockopt(fd, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, 2197 (void *)&one, sizeof(one)); 2198 2199 if (!failed) 2200 return; 2201 2202 #ifdef SYS_WINNT 2203 /* 2204 * Prior to Windows XP setting SO_EXCLUSIVEADDRUSE can fail with 2205 * error WSAINVAL depending on service pack level and whether 2206 * the user account is in the Administrators group. Do not 2207 * complain if it fails that way on versions prior to XP (5.1). 2208 */ 2209 err = GetLastError(); 2210 2211 if (isc_win32os_versioncheck(5, 1, 0, 0) < 0 /* < 5.1/XP */ 2212 && WSAEINVAL == err) 2213 return; 2214 2215 SetLastError(err); 2216 #endif 2217 msyslog(LOG_ERR, 2218 "setsockopt(%d, SO_EXCLUSIVEADDRUSE, on): %m", 2219 (int)fd); 2220 } 2221 #endif /* SO_EXCLUSIVEADDRUSE */ 2222 2223 2224 /* 2225 * set_reuseaddr() - set/clear REUSEADDR on all sockets 2226 * NB possible hole - should we be doing this on broadcast 2227 * fd's also? 2228 */ 2229 static void 2230 set_reuseaddr( 2231 int flag 2232 ) 2233 { 2234 #ifndef SO_EXCLUSIVEADDRUSE 2235 endpt *ep; 2236 2237 for (ep = ep_list; ep != NULL; ep = ep->elink) { 2238 if (ep->flags & INT_WILDCARD) 2239 continue; 2240 2241 /* 2242 * if ep->fd is INVALID_SOCKET, we might have a adapter 2243 * configured but not present 2244 */ 2245 DPRINTF(4, ("setting SO_REUSEADDR on %.16s@%s to %s\n", 2246 ep->name, stoa(&ep->sin), 2247 flag ? "on" : "off")); 2248 2249 if (ep->fd != INVALID_SOCKET) { 2250 if (setsockopt(ep->fd, SOL_SOCKET, SO_REUSEADDR, 2251 (void *)&flag, sizeof(flag))) { 2252 msyslog(LOG_ERR, "set_reuseaddr: setsockopt(%s, SO_REUSEADDR, %s) failed: %m", 2253 stoa(&ep->sin), flag ? "on" : "off"); 2254 } 2255 } 2256 } 2257 #endif /* ! SO_EXCLUSIVEADDRUSE */ 2258 } 2259 2260 /* 2261 * This is just a wrapper around an internal function so we can 2262 * make other changes as necessary later on 2263 */ 2264 void 2265 enable_broadcast( 2266 struct interface * iface, 2267 sockaddr_u * baddr 2268 ) 2269 { 2270 #ifdef OPEN_BCAST_SOCKET 2271 socket_broadcast_enable(iface, iface->fd, baddr); 2272 #endif 2273 } 2274 2275 #ifdef OPEN_BCAST_SOCKET 2276 /* 2277 * Enable a broadcast address to a given socket 2278 * The socket is in the ep_list all we need to do is enable 2279 * broadcasting. It is not this function's job to select the socket 2280 */ 2281 static isc_boolean_t 2282 socket_broadcast_enable( 2283 struct interface * iface, 2284 SOCKET fd, 2285 sockaddr_u * baddr 2286 ) 2287 { 2288 #ifdef SO_BROADCAST 2289 int on = 1; 2290 2291 if (IS_IPV4(baddr)) { 2292 /* if this interface can support broadcast, set SO_BROADCAST */ 2293 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, 2294 (void *)&on, sizeof(on))) 2295 msyslog(LOG_ERR, 2296 "setsockopt(SO_BROADCAST) enable failure on address %s: %m", 2297 stoa(baddr)); 2298 else 2299 DPRINTF(2, ("Broadcast enabled on socket %d for address %s\n", 2300 fd, stoa(baddr))); 2301 } 2302 iface->flags |= INT_BCASTXMIT; 2303 return ISC_TRUE; 2304 #else 2305 return ISC_FALSE; 2306 #endif /* SO_BROADCAST */ 2307 } 2308 2309 #ifdef OS_MISSES_SPECIFIC_ROUTE_UPDATES 2310 /* 2311 * Remove a broadcast address from a given socket 2312 * The socket is in the ep_list all we need to do is disable 2313 * broadcasting. It is not this function's job to select the socket 2314 */ 2315 static isc_boolean_t 2316 socket_broadcast_disable( 2317 struct interface * iface, 2318 sockaddr_u * baddr 2319 ) 2320 { 2321 #ifdef SO_BROADCAST 2322 int off = 0; /* This seems to be OK as an int */ 2323 2324 if (IS_IPV4(baddr) && setsockopt(iface->fd, SOL_SOCKET, 2325 SO_BROADCAST, (void *)&off, sizeof(off))) 2326 msyslog(LOG_ERR, 2327 "setsockopt(SO_BROADCAST) disable failure on address %s: %m", 2328 stoa(baddr)); 2329 2330 iface->flags &= ~INT_BCASTXMIT; 2331 return ISC_TRUE; 2332 #else 2333 return ISC_FALSE; 2334 #endif /* SO_BROADCAST */ 2335 } 2336 #endif /* OS_MISSES_SPECIFIC_ROUTE_UPDATES */ 2337 2338 #endif /* OPEN_BCAST_SOCKET */ 2339 2340 /* 2341 * return the broadcast client flag value 2342 */ 2343 /*isc_boolean_t 2344 get_broadcastclient_flag(void) 2345 { 2346 return (broadcast_client_enabled); 2347 } 2348 */ 2349 2350 /* 2351 * Check to see if the address is a multicast address 2352 */ 2353 static isc_boolean_t 2354 addr_ismulticast( 2355 sockaddr_u *maddr 2356 ) 2357 { 2358 isc_boolean_t result; 2359 2360 #ifndef INCLUDE_IPV6_MULTICAST_SUPPORT 2361 /* 2362 * If we don't have IPV6 support any IPV6 addr is not multicast 2363 */ 2364 if (IS_IPV6(maddr)) 2365 result = ISC_FALSE; 2366 else 2367 #endif 2368 result = IS_MCAST(maddr); 2369 2370 if (!result) 2371 DPRINTF(4, ("address %s is not multicast\n", 2372 stoa(maddr))); 2373 2374 return result; 2375 } 2376 2377 /* 2378 * Multicast servers need to set the appropriate Multicast interface 2379 * socket option in order for it to know which interface to use for 2380 * send the multicast packet. 2381 */ 2382 void 2383 enable_multicast_if( 2384 struct interface * iface, 2385 sockaddr_u * maddr 2386 ) 2387 { 2388 #ifdef MCAST 2389 #ifdef IP_MULTICAST_LOOP 2390 TYPEOF_IP_MULTICAST_LOOP off = 0; 2391 #endif 2392 #if defined(INCLUDE_IPV6_MULTICAST_SUPPORT) && defined(IPV6_MULTICAST_LOOP) 2393 u_int off6 = 0; 2394 #endif 2395 2396 REQUIRE(AF(maddr) == AF(&iface->sin)); 2397 2398 switch (AF(&iface->sin)) { 2399 2400 case AF_INET: 2401 #ifdef IP_MULTICAST_LOOP 2402 /* 2403 * Don't send back to itself, but allow failure to set 2404 */ 2405 if (setsockopt(iface->fd, IPPROTO_IP, 2406 IP_MULTICAST_LOOP, 2407 (void *)&off, 2408 sizeof(off))) { 2409 2410 msyslog(LOG_ERR, 2411 "setsockopt IP_MULTICAST_LOOP failed: %m on socket %d, addr %s for multicast address %s", 2412 iface->fd, stoa(&iface->sin), 2413 stoa(maddr)); 2414 } 2415 #endif 2416 break; 2417 2418 case AF_INET6: 2419 #ifdef INCLUDE_IPV6_MULTICAST_SUPPORT 2420 #ifdef IPV6_MULTICAST_LOOP 2421 /* 2422 * Don't send back to itself, but allow failure to set 2423 */ 2424 if (setsockopt(iface->fd, IPPROTO_IPV6, 2425 IPV6_MULTICAST_LOOP, 2426 (void *) &off6, sizeof(off6))) { 2427 2428 msyslog(LOG_ERR, 2429 "setsockopt IPV6_MULTICAST_LOOP failed: %m on socket %d, addr %s for multicast address %s", 2430 iface->fd, stoa(&iface->sin), 2431 stoa(maddr)); 2432 } 2433 #endif 2434 break; 2435 #else 2436 return; 2437 #endif /* INCLUDE_IPV6_MULTICAST_SUPPORT */ 2438 } 2439 return; 2440 #endif 2441 } 2442 2443 /* 2444 * Add a multicast address to a given socket 2445 * The socket is in the ep_list all we need to do is enable 2446 * multicasting. It is not this function's job to select the socket 2447 */ 2448 #if defined(MCAST) 2449 static isc_boolean_t 2450 socket_multicast_enable( 2451 endpt * iface, 2452 sockaddr_u * maddr 2453 ) 2454 { 2455 struct ip_mreq mreq; 2456 # ifdef INCLUDE_IPV6_MULTICAST_SUPPORT 2457 struct ipv6_mreq mreq6; 2458 # endif 2459 switch (AF(maddr)) { 2460 2461 case AF_INET: 2462 ZERO(mreq); 2463 mreq.imr_multiaddr = SOCK_ADDR4(maddr); 2464 mreq.imr_interface.s_addr = htonl(INADDR_ANY); 2465 if (setsockopt(iface->fd, 2466 IPPROTO_IP, 2467 IP_ADD_MEMBERSHIP, 2468 (void *)&mreq, 2469 sizeof(mreq))) { 2470 DPRINTF(2, ( 2471 "setsockopt IP_ADD_MEMBERSHIP failed: %m on socket %d, addr %s for %x / %x (%s)", 2472 iface->fd, stoa(&iface->sin), 2473 mreq.imr_multiaddr.s_addr, 2474 mreq.imr_interface.s_addr, 2475 stoa(maddr))); 2476 return ISC_FALSE; 2477 } 2478 DPRINTF(4, ("Added IPv4 multicast membership on socket %d, addr %s for %x / %x (%s)\n", 2479 iface->fd, stoa(&iface->sin), 2480 mreq.imr_multiaddr.s_addr, 2481 mreq.imr_interface.s_addr, stoa(maddr))); 2482 break; 2483 2484 case AF_INET6: 2485 # ifdef INCLUDE_IPV6_MULTICAST_SUPPORT 2486 /* 2487 * Enable reception of multicast packets. 2488 * If the address is link-local we can get the 2489 * interface index from the scope id. Don't do this 2490 * for other types of multicast addresses. For now let 2491 * the kernel figure it out. 2492 */ 2493 ZERO(mreq6); 2494 mreq6.ipv6mr_multiaddr = SOCK_ADDR6(maddr); 2495 mreq6.ipv6mr_interface = iface->ifindex; 2496 2497 if (setsockopt(iface->fd, IPPROTO_IPV6, 2498 IPV6_JOIN_GROUP, (void *)&mreq6, 2499 sizeof(mreq6))) { 2500 DPRINTF(2, ( 2501 "setsockopt IPV6_JOIN_GROUP failed: %m on socket %d, addr %s for interface %u (%s)", 2502 iface->fd, stoa(&iface->sin), 2503 mreq6.ipv6mr_interface, stoa(maddr))); 2504 return ISC_FALSE; 2505 } 2506 DPRINTF(4, ("Added IPv6 multicast group on socket %d, addr %s for interface %u (%s)\n", 2507 iface->fd, stoa(&iface->sin), 2508 mreq6.ipv6mr_interface, stoa(maddr))); 2509 # else 2510 return ISC_FALSE; 2511 # endif /* INCLUDE_IPV6_MULTICAST_SUPPORT */ 2512 } 2513 iface->flags |= INT_MCASTOPEN; 2514 iface->num_mcast++; 2515 2516 return ISC_TRUE; 2517 } 2518 #endif /* MCAST */ 2519 2520 2521 /* 2522 * Remove a multicast address from a given socket 2523 * The socket is in the ep_list all we need to do is disable 2524 * multicasting. It is not this function's job to select the socket 2525 */ 2526 #ifdef MCAST 2527 static isc_boolean_t 2528 socket_multicast_disable( 2529 struct interface * iface, 2530 sockaddr_u * maddr 2531 ) 2532 { 2533 # ifdef INCLUDE_IPV6_MULTICAST_SUPPORT 2534 struct ipv6_mreq mreq6; 2535 # endif 2536 struct ip_mreq mreq; 2537 2538 ZERO(mreq); 2539 2540 if (find_addr_in_list(maddr) == NULL) { 2541 DPRINTF(4, ("socket_multicast_disable(%s): not found\n", 2542 stoa(maddr))); 2543 return ISC_TRUE; 2544 } 2545 2546 switch (AF(maddr)) { 2547 2548 case AF_INET: 2549 mreq.imr_multiaddr = SOCK_ADDR4(maddr); 2550 mreq.imr_interface = SOCK_ADDR4(&iface->sin); 2551 if (setsockopt(iface->fd, IPPROTO_IP, 2552 IP_DROP_MEMBERSHIP, (void *)&mreq, 2553 sizeof(mreq))) { 2554 2555 msyslog(LOG_ERR, 2556 "setsockopt IP_DROP_MEMBERSHIP failed: %m on socket %d, addr %s for %x / %x (%s)", 2557 iface->fd, stoa(&iface->sin), 2558 SRCADR(maddr), SRCADR(&iface->sin), 2559 stoa(maddr)); 2560 return ISC_FALSE; 2561 } 2562 break; 2563 case AF_INET6: 2564 # ifdef INCLUDE_IPV6_MULTICAST_SUPPORT 2565 /* 2566 * Disable reception of multicast packets 2567 * If the address is link-local we can get the 2568 * interface index from the scope id. Don't do this 2569 * for other types of multicast addresses. For now let 2570 * the kernel figure it out. 2571 */ 2572 mreq6.ipv6mr_multiaddr = SOCK_ADDR6(maddr); 2573 mreq6.ipv6mr_interface = iface->ifindex; 2574 2575 if (setsockopt(iface->fd, IPPROTO_IPV6, 2576 IPV6_LEAVE_GROUP, (void *)&mreq6, 2577 sizeof(mreq6))) { 2578 2579 msyslog(LOG_ERR, 2580 "setsockopt IPV6_LEAVE_GROUP failure: %m on socket %d, addr %s for %d (%s)", 2581 iface->fd, stoa(&iface->sin), 2582 iface->ifindex, stoa(maddr)); 2583 return ISC_FALSE; 2584 } 2585 break; 2586 # else 2587 return ISC_FALSE; 2588 # endif /* INCLUDE_IPV6_MULTICAST_SUPPORT */ 2589 } 2590 2591 iface->num_mcast--; 2592 if (!iface->num_mcast) 2593 iface->flags &= ~INT_MCASTOPEN; 2594 2595 return ISC_TRUE; 2596 } 2597 #endif /* MCAST */ 2598 2599 /* 2600 * io_setbclient - open the broadcast client sockets 2601 */ 2602 void 2603 io_setbclient(void) 2604 { 2605 #ifdef OPEN_BCAST_SOCKET 2606 endpt * ep; 2607 unsigned int nif, ni4, ni6; 2608 2609 nif = ni4 = ni6 = 0; 2610 set_reuseaddr(1); 2611 2612 for (ep = ep_list; ep != NULL; ep = ep->elink) { 2613 /* count IPv6 vs IPv4 interfaces. Needed later to decide 2614 * if we should log an error or not. 2615 */ 2616 switch (ep->family) { 2617 case AF_INET : ++ni4; break; 2618 case AF_INET6: ++ni6; break; 2619 default : break; 2620 } 2621 2622 if (ep->flags & (INT_WILDCARD | INT_LOOPBACK)) 2623 continue; 2624 2625 /* use only allowed addresses */ 2626 if (ep->ignore_packets) 2627 continue; 2628 2629 /* Need a broadcast-capable interface */ 2630 if (!(ep->flags & INT_BROADCAST)) 2631 continue; 2632 2633 /* Only IPv4 addresses are valid for broadcast */ 2634 REQUIRE(IS_IPV4(&ep->bcast)); 2635 2636 /* Do we already have the broadcast address open? */ 2637 if (ep->flags & INT_BCASTOPEN) { 2638 /* 2639 * account for already open interfaces to avoid 2640 * misleading warning below 2641 */ 2642 nif++; 2643 continue; 2644 } 2645 2646 /* 2647 * Try to open the broadcast address 2648 */ 2649 ep->family = AF_INET; 2650 ep->bfd = open_socket(&ep->bcast, 1, 0, ep); 2651 2652 /* 2653 * If we succeeded then we use it otherwise enable 2654 * broadcast on the interface address 2655 */ 2656 if (ep->bfd != INVALID_SOCKET) { 2657 nif++; 2658 ep->flags |= INT_BCASTOPEN; 2659 msyslog(LOG_INFO, 2660 "Listen for broadcasts to %s on interface #%d %s", 2661 stoa(&ep->bcast), ep->ifnum, ep->name); 2662 } else switch (errno) { 2663 /* Silently ignore EADDRINUSE as we probably 2664 * opened the socket already for an address in 2665 * the same network */ 2666 case EADDRINUSE: 2667 /* Some systems cannot bind a socket to a broadcast 2668 * address, as that is not a valid host address. */ 2669 case EADDRNOTAVAIL: 2670 # ifdef SYS_WINNT /*TODO: use for other systems, too? */ 2671 /* avoid recurrence here -- if we already have a 2672 * regular socket, it's quite useless to try this 2673 * again. 2674 */ 2675 if (ep->fd != INVALID_SOCKET) { 2676 ep->flags |= INT_BCASTOPEN; 2677 nif++; 2678 } 2679 # endif 2680 break; 2681 2682 default: 2683 msyslog(LOG_INFO, 2684 "failed to listen for broadcasts to %s on interface #%d %s", 2685 stoa(&ep->bcast), ep->ifnum, ep->name); 2686 break; 2687 } 2688 } 2689 set_reuseaddr(0); 2690 if (nif != 0) { 2691 broadcast_client_enabled = ISC_TRUE; 2692 DPRINTF(1, ("io_setbclient: listening to %d broadcast addresses\n", nif)); 2693 } else { 2694 broadcast_client_enabled = ISC_FALSE; 2695 /* This is expected when having only IPv6 interfaces 2696 * and no IPv4 interfaces at all. We suppress the error 2697 * log in that case... everything else should work! 2698 */ 2699 if (ni4 && !ni6) { 2700 msyslog(LOG_ERR, 2701 "Unable to listen for broadcasts, no broadcast interfaces available"); 2702 } 2703 } 2704 #else 2705 msyslog(LOG_ERR, 2706 "io_setbclient: Broadcast Client disabled by build"); 2707 #endif /* OPEN_BCAST_SOCKET */ 2708 } 2709 2710 /* 2711 * io_unsetbclient - close the broadcast client sockets 2712 */ 2713 void 2714 io_unsetbclient(void) 2715 { 2716 endpt *ep; 2717 2718 for (ep = ep_list; ep != NULL; ep = ep->elink) { 2719 if (INT_WILDCARD & ep->flags) 2720 continue; 2721 if (!(INT_BCASTOPEN & ep->flags)) 2722 continue; 2723 2724 if (ep->bfd != INVALID_SOCKET) { 2725 /* destroy broadcast listening socket */ 2726 msyslog(LOG_INFO, 2727 "stop listening for broadcasts to %s on interface #%d %s", 2728 stoa(&ep->bcast), ep->ifnum, ep->name); 2729 # ifdef HAVE_IO_COMPLETION_PORT 2730 io_completion_port_remove_socket(ep->bfd, ep); 2731 # endif 2732 close_and_delete_fd_from_list(ep->bfd); 2733 ep->bfd = INVALID_SOCKET; 2734 } 2735 ep->flags &= ~INT_BCASTOPEN; 2736 } 2737 broadcast_client_enabled = ISC_FALSE; 2738 } 2739 2740 /* 2741 * io_multicast_add() - add multicast group address 2742 */ 2743 void 2744 io_multicast_add( 2745 sockaddr_u *addr 2746 ) 2747 { 2748 #ifdef MCAST 2749 endpt * ep; 2750 endpt * one_ep; 2751 2752 /* 2753 * Check to see if this is a multicast address 2754 */ 2755 if (!addr_ismulticast(addr)) 2756 return; 2757 2758 /* If we already have it we can just return */ 2759 if (NULL != find_flagged_addr_in_list(addr, INT_MCASTOPEN)) { 2760 msyslog(LOG_INFO, 2761 "Duplicate request found for multicast address %s", 2762 stoa(addr)); 2763 return; 2764 } 2765 2766 # ifndef MULTICAST_NONEWSOCKET 2767 ep = new_interface(NULL); 2768 2769 /* 2770 * Open a new socket for the multicast address 2771 */ 2772 ep->sin = *addr; 2773 SET_PORT(&ep->sin, NTP_PORT); 2774 ep->family = AF(&ep->sin); 2775 AF(&ep->mask) = ep->family; 2776 SET_ONESMASK(&ep->mask); 2777 2778 set_reuseaddr(1); 2779 ep->bfd = INVALID_SOCKET; 2780 ep->fd = open_socket(&ep->sin, 0, 0, ep); 2781 if (ep->fd != INVALID_SOCKET) { 2782 ep->ignore_packets = ISC_FALSE; 2783 ep->flags |= INT_MCASTIF; 2784 ep->ifindex = SCOPE(addr); 2785 2786 strlcpy(ep->name, "multicast", sizeof(ep->name)); 2787 DPRINT_INTERFACE(2, (ep, "multicast add ", "\n")); 2788 add_interface(ep); 2789 log_listen_address(ep); 2790 } else { 2791 /* bind failed, re-use wildcard interface */ 2792 delete_interface(ep); 2793 2794 if (IS_IPV4(addr)) 2795 ep = wildipv4; 2796 else if (IS_IPV6(addr)) 2797 ep = wildipv6; 2798 else 2799 ep = NULL; 2800 2801 if (ep != NULL) { 2802 /* HACK ! -- stuff in an address */ 2803 /* because we don't bind addr? DH */ 2804 ep->bcast = *addr; 2805 msyslog(LOG_ERR, 2806 "multicast address %s using wildcard interface #%d %s", 2807 stoa(addr), ep->ifnum, ep->name); 2808 } else { 2809 msyslog(LOG_ERR, 2810 "No multicast socket available to use for address %s", 2811 stoa(addr)); 2812 return; 2813 } 2814 } 2815 { /* in place of the { following for in #else clause */ 2816 one_ep = ep; 2817 # else /* MULTICAST_NONEWSOCKET follows */ 2818 /* 2819 * For the case where we can't use a separate socket (Windows) 2820 * join each applicable endpoint socket to the group address. 2821 */ 2822 if (IS_IPV4(addr)) 2823 one_ep = wildipv4; 2824 else 2825 one_ep = wildipv6; 2826 for (ep = ep_list; ep != NULL; ep = ep->elink) { 2827 if (ep->ignore_packets || AF(&ep->sin) != AF(addr) || 2828 !(INT_MULTICAST & ep->flags) || 2829 (INT_LOOPBACK | INT_WILDCARD) & ep->flags) 2830 continue; 2831 one_ep = ep; 2832 # endif /* MULTICAST_NONEWSOCKET */ 2833 if (socket_multicast_enable(ep, addr)) 2834 msyslog(LOG_INFO, 2835 "Joined %s socket to multicast group %s", 2836 stoa(&ep->sin), 2837 stoa(addr)); 2838 } 2839 2840 add_addr_to_list(addr, one_ep); 2841 #else /* !MCAST follows*/ 2842 msyslog(LOG_ERR, 2843 "Can not add multicast address %s: no multicast support", 2844 stoa(addr)); 2845 #endif 2846 return; 2847 } 2848 2849 2850 /* 2851 * io_multicast_del() - delete multicast group address 2852 */ 2853 void 2854 io_multicast_del( 2855 sockaddr_u * addr 2856 ) 2857 { 2858 #ifdef MCAST 2859 endpt *iface; 2860 2861 /* 2862 * Check to see if this is a multicast address 2863 */ 2864 if (!addr_ismulticast(addr)) { 2865 msyslog(LOG_ERR, "invalid multicast address %s", 2866 stoa(addr)); 2867 return; 2868 } 2869 2870 /* 2871 * Disable reception of multicast packets 2872 */ 2873 while ((iface = find_flagged_addr_in_list(addr, INT_MCASTOPEN)) 2874 != NULL) 2875 socket_multicast_disable(iface, addr); 2876 2877 delete_addr_from_list(addr); 2878 2879 #else /* not MCAST */ 2880 msyslog(LOG_ERR, 2881 "Can not delete multicast address %s: no multicast support", 2882 stoa(addr)); 2883 #endif /* not MCAST */ 2884 } 2885 2886 2887 /* 2888 * open_socket - open a socket, returning the file descriptor 2889 */ 2890 2891 static SOCKET 2892 open_socket( 2893 sockaddr_u * addr, 2894 int bcast, 2895 int turn_off_reuse, 2896 endpt * interf 2897 ) 2898 { 2899 SOCKET fd; 2900 int errval; 2901 /* 2902 * int is OK for REUSEADR per 2903 * http://www.kohala.com/start/mcast.api.txt 2904 */ 2905 int on = 1; 2906 int off = 0; 2907 2908 if (IS_IPV6(addr) && !ipv6_works) 2909 return INVALID_SOCKET; 2910 2911 /* create a datagram (UDP) socket */ 2912 fd = socket(AF(addr), SOCK_DGRAM, 0); 2913 if (INVALID_SOCKET == fd) { 2914 errval = socket_errno(); 2915 msyslog(LOG_ERR, 2916 "socket(AF_INET%s, SOCK_DGRAM, 0) failed on address %s: %m", 2917 IS_IPV6(addr) ? "6" : "", stoa(addr)); 2918 2919 if (errval == EPROTONOSUPPORT || 2920 errval == EAFNOSUPPORT || 2921 errval == EPFNOSUPPORT) 2922 return (INVALID_SOCKET); 2923 2924 errno = errval; 2925 msyslog(LOG_ERR, 2926 "unexpected socket() error %m code %d (not EPROTONOSUPPORT nor EAFNOSUPPORT nor EPFNOSUPPORT) - exiting", 2927 errno); 2928 exit(1); 2929 } 2930 2931 #ifdef SYS_WINNT 2932 connection_reset_fix(fd, addr); 2933 #endif 2934 /* 2935 * Fixup the file descriptor for some systems 2936 * See bug #530 for details of the issue. 2937 */ 2938 fd = move_fd(fd); 2939 2940 /* 2941 * set SO_REUSEADDR since we will be binding the same port 2942 * number on each interface according to turn_off_reuse. 2943 * This is undesirable on Windows versions starting with 2944 * Windows XP (numeric version 5.1). 2945 */ 2946 #ifdef SYS_WINNT 2947 if (isc_win32os_versioncheck(5, 1, 0, 0) < 0) /* before 5.1 */ 2948 #endif 2949 if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, 2950 (void *)((turn_off_reuse) 2951 ? &off 2952 : &on), 2953 sizeof(on))) { 2954 2955 msyslog(LOG_ERR, 2956 "setsockopt SO_REUSEADDR %s fails for address %s: %m", 2957 (turn_off_reuse) 2958 ? "off" 2959 : "on", 2960 stoa(addr)); 2961 closesocket(fd); 2962 return INVALID_SOCKET; 2963 } 2964 #ifdef SO_EXCLUSIVEADDRUSE 2965 /* 2966 * setting SO_EXCLUSIVEADDRUSE on the wildcard we open 2967 * first will cause more specific binds to fail. 2968 */ 2969 if (!(interf->flags & INT_WILDCARD)) 2970 set_excladdruse(fd); 2971 #endif 2972 2973 /* 2974 * IPv4 specific options go here 2975 */ 2976 if (IS_IPV4(addr)) { 2977 #if defined(IPPROTO_IP) && defined(IP_TOS) 2978 if (setsockopt(fd, IPPROTO_IP, IP_TOS, (void *)&qos, 2979 sizeof(qos))) 2980 msyslog(LOG_ERR, 2981 "setsockopt IP_TOS (%02x) fails on address %s: %m", 2982 qos, stoa(addr)); 2983 #endif /* IPPROTO_IP && IP_TOS */ 2984 if (bcast) 2985 socket_broadcast_enable(interf, fd, addr); 2986 } 2987 2988 /* 2989 * IPv6 specific options go here 2990 */ 2991 if (IS_IPV6(addr)) { 2992 #if defined(IPPROTO_IPV6) && defined(IPV6_TCLASS) 2993 if (setsockopt(fd, IPPROTO_IPV6, IPV6_TCLASS, (void *)&qos, 2994 sizeof(qos))) 2995 msyslog(LOG_ERR, 2996 "setsockopt IPV6_TCLASS (%02x) fails on address %s: %m", 2997 qos, stoa(addr)); 2998 #endif /* IPPROTO_IPV6 && IPV6_TCLASS */ 2999 #ifdef IPV6_V6ONLY 3000 if (isc_net_probe_ipv6only() == ISC_R_SUCCESS 3001 && setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, 3002 (void *)&on, sizeof(on))) 3003 msyslog(LOG_ERR, 3004 "setsockopt IPV6_V6ONLY on fails on address %s: %m", 3005 stoa(addr)); 3006 #endif 3007 #ifdef IPV6_BINDV6ONLY 3008 if (setsockopt(fd, IPPROTO_IPV6, IPV6_BINDV6ONLY, 3009 (void *)&on, sizeof(on))) 3010 msyslog(LOG_ERR, 3011 "setsockopt IPV6_BINDV6ONLY on fails on address %s: %m", 3012 stoa(addr)); 3013 #endif 3014 } 3015 3016 #ifdef OS_NEEDS_REUSEADDR_FOR_IFADDRBIND 3017 /* 3018 * some OSes don't allow binding to more specific 3019 * addresses if a wildcard address already bound 3020 * to the port and SO_REUSEADDR is not set 3021 */ 3022 if (!is_wildcard_addr(addr)) 3023 set_wildcard_reuse(AF(addr), 1); 3024 #endif 3025 3026 /* 3027 * bind the local address. 3028 */ 3029 errval = bind(fd, &addr->sa, SOCKLEN(addr)); 3030 3031 #ifdef OS_NEEDS_REUSEADDR_FOR_IFADDRBIND 3032 if (!is_wildcard_addr(addr)) 3033 set_wildcard_reuse(AF(addr), 0); 3034 #endif 3035 3036 if (errval < 0) { 3037 /* 3038 * Don't log this under all conditions 3039 */ 3040 if (turn_off_reuse == 0 3041 #ifdef DEBUG 3042 || debug > 1 3043 #endif 3044 ) { 3045 msyslog(LOG_ERR, 3046 "bind(%d) AF_INET%s %s#%d%s flags 0x%x failed: %m", 3047 fd, IS_IPV6(addr) ? "6" : "", 3048 stoa(addr), SRCPORT(addr), 3049 IS_MCAST(addr) ? " (multicast)" : "", 3050 interf->flags); 3051 } 3052 3053 closesocket(fd); 3054 3055 return INVALID_SOCKET; 3056 } 3057 3058 #ifdef HAVE_TIMESTAMP 3059 { 3060 if (setsockopt(fd, SOL_SOCKET, SO_TIMESTAMP, 3061 (void *)&on, sizeof(on))) 3062 msyslog(LOG_DEBUG, 3063 "setsockopt SO_TIMESTAMP on fails on address %s: %m", 3064 stoa(addr)); 3065 else 3066 DPRINTF(4, ("setsockopt SO_TIMESTAMP enabled on fd %d address %s\n", 3067 fd, stoa(addr))); 3068 } 3069 #endif 3070 #ifdef HAVE_TIMESTAMPNS 3071 { 3072 if (setsockopt(fd, SOL_SOCKET, SO_TIMESTAMPNS, 3073 (void *)&on, sizeof(on))) 3074 msyslog(LOG_DEBUG, 3075 "setsockopt SO_TIMESTAMPNS on fails on address %s: %m", 3076 stoa(addr)); 3077 else 3078 DPRINTF(4, ("setsockopt SO_TIMESTAMPNS enabled on fd %d address %s\n", 3079 fd, stoa(addr))); 3080 } 3081 #endif 3082 #ifdef HAVE_BINTIME 3083 { 3084 if (setsockopt(fd, SOL_SOCKET, SO_BINTIME, 3085 (void *)&on, sizeof(on))) 3086 msyslog(LOG_DEBUG, 3087 "setsockopt SO_BINTIME on fails on address %s: %m", 3088 stoa(addr)); 3089 else 3090 DPRINTF(4, ("setsockopt SO_BINTIME enabled on fd %d address %s\n", 3091 fd, stoa(addr))); 3092 } 3093 #endif 3094 3095 DPRINTF(4, ("bind(%d) AF_INET%s, addr %s%%%d#%d, flags 0x%x\n", 3096 fd, IS_IPV6(addr) ? "6" : "", stoa(addr), 3097 SCOPE(addr), SRCPORT(addr), interf->flags)); 3098 3099 make_socket_nonblocking(fd); 3100 3101 #ifdef HAVE_SIGNALED_IO 3102 init_socket_sig(fd); 3103 #endif /* not HAVE_SIGNALED_IO */ 3104 3105 add_fd_to_list(fd, FD_TYPE_SOCKET); 3106 3107 #if !defined(SYS_WINNT) && !defined(VMS) 3108 DPRINTF(4, ("flags for fd %d: 0x%x\n", fd, 3109 fcntl(fd, F_GETFL, 0))); 3110 #endif /* SYS_WINNT || VMS */ 3111 3112 #if defined(HAVE_IO_COMPLETION_PORT) 3113 /* 3114 * Add the socket to the completion port 3115 */ 3116 if (!io_completion_port_add_socket(fd, interf, bcast)) { 3117 msyslog(LOG_ERR, "unable to set up io completion port - EXITING"); 3118 exit(1); 3119 } 3120 #endif 3121 return fd; 3122 } 3123 3124 3125 3126 /* XXX ELIMINATE sendpkt similar in ntpq.c, ntpdc.c, ntp_io.c, ntptrace.c */ 3127 /* 3128 * sendpkt - send a packet to the specified destination. Maintain a 3129 * send error cache so that only the first consecutive error for a 3130 * destination is logged. 3131 */ 3132 void 3133 sendpkt( 3134 sockaddr_u * dest, 3135 struct interface * ep, 3136 int ttl, 3137 struct pkt * pkt, 3138 int len 3139 ) 3140 { 3141 endpt * src; 3142 int ismcast; 3143 int cc; 3144 int rc; 3145 u_char cttl; 3146 l_fp fp_zero = { { 0 }, 0 }; 3147 l_fp org, rec, xmt; 3148 3149 ismcast = IS_MCAST(dest); 3150 if (!ismcast) 3151 src = ep; 3152 else 3153 src = (IS_IPV4(dest)) 3154 ? mc4_list 3155 : mc6_list; 3156 3157 if (NULL == src) { 3158 /* 3159 * unbound peer - drop request and wait for better 3160 * network conditions 3161 */ 3162 DPRINTF(2, ("%ssendpkt(dst=%s, ttl=%d, len=%d): no interface - IGNORED\n", 3163 ismcast ? "\tMCAST\t***** " : "", 3164 stoa(dest), ttl, len)); 3165 return; 3166 } 3167 3168 do { 3169 DPRINTF(2, ("%ssendpkt(%d, dst=%s, src=%s, ttl=%d, len=%d)\n", 3170 ismcast ? "\tMCAST\t***** " : "", src->fd, 3171 stoa(dest), stoa(&src->sin), ttl, len)); 3172 #ifdef MCAST 3173 /* 3174 * for the moment we use the bcast option to set multicast ttl 3175 */ 3176 if (ismcast && ttl > 0 && ttl != src->last_ttl) { 3177 /* 3178 * set the multicast ttl for outgoing packets 3179 */ 3180 switch (AF(&src->sin)) { 3181 3182 case AF_INET : 3183 cttl = (u_char)ttl; 3184 rc = setsockopt(src->fd, IPPROTO_IP, 3185 IP_MULTICAST_TTL, 3186 (void *)&cttl, 3187 sizeof(cttl)); 3188 break; 3189 3190 # ifdef INCLUDE_IPV6_SUPPORT 3191 case AF_INET6 : 3192 rc = setsockopt(src->fd, IPPROTO_IPV6, 3193 IPV6_MULTICAST_HOPS, 3194 (void *)&ttl, 3195 sizeof(ttl)); 3196 break; 3197 # endif /* INCLUDE_IPV6_SUPPORT */ 3198 3199 default: 3200 rc = 0; 3201 } 3202 3203 if (!rc) 3204 src->last_ttl = ttl; 3205 else 3206 msyslog(LOG_ERR, 3207 "setsockopt IP_MULTICAST_TTL/IPV6_MULTICAST_HOPS fails on address %s: %m", 3208 stoa(&src->sin)); 3209 } 3210 #endif /* MCAST */ 3211 3212 #ifdef SIM 3213 cc = simulate_server(dest, src, pkt); 3214 #elif defined(HAVE_IO_COMPLETION_PORT) 3215 cc = io_completion_port_sendto(src, src->fd, pkt, 3216 (size_t)len, (sockaddr_u *)&dest->sa); 3217 #else 3218 cc = sendto(src->fd, (char *)pkt, (u_int)len, 0, 3219 &dest->sa, SOCKLEN(dest)); 3220 #endif 3221 if (cc == -1) { 3222 src->notsent++; 3223 packets_notsent++; 3224 } else { 3225 src->sent++; 3226 packets_sent++; 3227 } 3228 if (ismcast) 3229 src = src->mclink; 3230 } while (ismcast && src != NULL); 3231 3232 /* HMS: pkt->rootdisp is usually random here */ 3233 NTOHL_FP(&pkt->org, &org); 3234 NTOHL_FP(&pkt->rec, &rec); 3235 NTOHL_FP(&pkt->xmt, &xmt); 3236 record_raw_stats(src ? &src->sin : NULL, dest, 3237 &org, &rec, &xmt, &fp_zero, 3238 PKT_LEAP(pkt->li_vn_mode), 3239 PKT_VERSION(pkt->li_vn_mode), 3240 PKT_MODE(pkt->li_vn_mode), 3241 pkt->stratum, 3242 pkt->ppoll, pkt->precision, 3243 pkt->rootdelay, pkt->rootdisp, pkt->refid, 3244 len - MIN_V4_PKT_LEN, (u_char *)&pkt->exten); 3245 3246 return; 3247 } 3248 3249 3250 #if !defined(HAVE_IO_COMPLETION_PORT) 3251 #if !defined(HAVE_SIGNALED_IO) 3252 /* 3253 * fdbits - generate ascii representation of fd_set (FAU debug support) 3254 * HFDF format - highest fd first. 3255 */ 3256 static char * 3257 fdbits( 3258 int count, 3259 const fd_set* set 3260 ) 3261 { 3262 static char buffer[256]; 3263 char * buf = buffer; 3264 3265 count = min(count, 255); 3266 3267 while (count >= 0) { 3268 *buf++ = FD_ISSET(count, set) ? '#' : '-'; 3269 count--; 3270 } 3271 *buf = '\0'; 3272 3273 return buffer; 3274 } 3275 #endif 3276 3277 #ifdef REFCLOCK 3278 /* 3279 * Routine to read the refclock packets for a specific interface 3280 * Return the number of bytes read. That way we know if we should 3281 * read it again or go on to the next one if no bytes returned 3282 */ 3283 static inline int 3284 read_refclock_packet( 3285 SOCKET fd, 3286 struct refclockio * rp, 3287 l_fp ts 3288 ) 3289 { 3290 u_int read_count; 3291 int buflen; 3292 int saved_errno; 3293 int consumed; 3294 struct recvbuf * rb; 3295 3296 rb = get_free_recv_buffer(TRUE); 3297 3298 if (NULL == rb) { 3299 /* 3300 * No buffer space available - just drop the 'packet'. 3301 * Since this is a non-blocking character stream we read 3302 * all data that we can. 3303 * 3304 * ...hmmmm... what about "tcflush(fd,TCIFLUSH)" here?!? 3305 */ 3306 char buf[128]; 3307 do 3308 buflen = read(fd, buf, sizeof(buf)); 3309 while (buflen > 0); 3310 packets_dropped++; 3311 return (buflen); 3312 } 3313 3314 /* TALOS-CAN-0064: avoid signed/unsigned clashes that can lead 3315 * to buffer overrun and memory corruption 3316 */ 3317 if (rp->datalen <= 0 || (size_t)rp->datalen > sizeof(rb->recv_space)) 3318 read_count = sizeof(rb->recv_space); 3319 else 3320 read_count = (u_int)rp->datalen; 3321 do { 3322 buflen = read(fd, (char *)&rb->recv_space, read_count); 3323 } while (buflen < 0 && EINTR == errno); 3324 3325 if (buflen <= 0) { 3326 saved_errno = errno; 3327 freerecvbuf(rb); 3328 errno = saved_errno; 3329 return buflen; 3330 } 3331 3332 /* 3333 * Got one. Mark how and when it got here, 3334 * put it on the full list and do bookkeeping. 3335 */ 3336 rb->recv_length = buflen; 3337 rb->recv_peer = rp->srcclock; 3338 rb->dstadr = 0; 3339 rb->fd = fd; 3340 rb->recv_time = ts; 3341 rb->receiver = rp->clock_recv; 3342 3343 consumed = indicate_refclock_packet(rp, rb); 3344 if (!consumed) { 3345 rp->recvcount++; 3346 packets_received++; 3347 } 3348 3349 return buflen; 3350 } 3351 #endif /* REFCLOCK */ 3352 3353 3354 #ifdef HAVE_PACKET_TIMESTAMP 3355 /* 3356 * extract timestamps from control message buffer 3357 */ 3358 static l_fp 3359 fetch_timestamp( 3360 struct recvbuf * rb, 3361 struct msghdr * msghdr, 3362 l_fp ts 3363 ) 3364 { 3365 struct cmsghdr * cmsghdr; 3366 unsigned long ticks; 3367 double fuzz; 3368 l_fp lfpfuzz; 3369 l_fp nts; 3370 #ifdef DEBUG_TIMING 3371 l_fp dts; 3372 #endif 3373 3374 cmsghdr = CMSG_FIRSTHDR(msghdr); 3375 while (cmsghdr != NULL) { 3376 switch (cmsghdr->cmsg_type) 3377 { 3378 #ifdef HAVE_BINTIME 3379 case SCM_BINTIME: 3380 #endif /* HAVE_BINTIME */ 3381 #ifdef HAVE_TIMESTAMPNS 3382 case SCM_TIMESTAMPNS: 3383 #endif /* HAVE_TIMESTAMPNS */ 3384 #ifdef HAVE_TIMESTAMP 3385 case SCM_TIMESTAMP: 3386 #endif /* HAVE_TIMESTAMP */ 3387 #if defined(HAVE_BINTIME) || defined (HAVE_TIMESTAMPNS) || defined(HAVE_TIMESTAMP) 3388 switch (cmsghdr->cmsg_type) 3389 { 3390 #ifdef HAVE_BINTIME 3391 case SCM_BINTIME: 3392 { 3393 struct bintime pbt; 3394 memcpy(&pbt, CMSG_DATA(cmsghdr), sizeof(pbt)); 3395 /* 3396 * bintime documentation is at http://phk.freebsd.dk/pubs/timecounter.pdf 3397 */ 3398 nts.l_i = pbt.sec + JAN_1970; 3399 nts.l_uf = (u_int32)(pbt.frac >> 32); 3400 if (sys_tick > measured_tick && 3401 sys_tick > 1e-9) { 3402 ticks = (unsigned long)(nts.l_uf / (unsigned long)(sys_tick * FRAC)); 3403 nts.l_uf = (unsigned long)(ticks * (unsigned long)(sys_tick * FRAC)); 3404 } 3405 DPRINTF(4, ("fetch_timestamp: system bintime network time stamp: %ld.%09lu\n", 3406 pbt.sec, (unsigned long)((nts.l_uf / FRAC) * 1e9))); 3407 } 3408 break; 3409 #endif /* HAVE_BINTIME */ 3410 #ifdef HAVE_TIMESTAMPNS 3411 case SCM_TIMESTAMPNS: 3412 { 3413 struct timespec pts; 3414 memcpy(&pts, CMSG_DATA(cmsghdr), sizeof(pts)); 3415 if (sys_tick > measured_tick && 3416 sys_tick > 1e-9) { 3417 ticks = (unsigned long)((pts.tv_nsec * 1e-9) / 3418 sys_tick); 3419 pts.tv_nsec = (long)(ticks * 1e9 * 3420 sys_tick); 3421 } 3422 DPRINTF(4, ("fetch_timestamp: system nsec network time stamp: %ld.%09ld\n", 3423 pts.tv_sec, pts.tv_nsec)); 3424 nts = tspec_stamp_to_lfp(pts); 3425 } 3426 break; 3427 #endif /* HAVE_TIMESTAMPNS */ 3428 #ifdef HAVE_TIMESTAMP 3429 case SCM_TIMESTAMP: 3430 { 3431 struct timeval ptv; 3432 memcpy(&ptv, CMSG_DATA(cmsghdr), sizeof(ptv)); 3433 if (sys_tick > measured_tick && 3434 sys_tick > 1e-6) { 3435 ticks = (unsigned long)((ptv.tv_usec * 1e-6) / 3436 sys_tick); 3437 ptv.tv_usec = (long)(ticks * 1e6 * 3438 sys_tick); 3439 } 3440 DPRINTF(4, ("fetch_timestamp: system usec network time stamp: %jd.%06ld\n", 3441 (intmax_t)ptv.tv_sec, (long)ptv.tv_usec)); 3442 nts = tval_stamp_to_lfp(ptv); 3443 } 3444 break; 3445 #endif /* HAVE_TIMESTAMP */ 3446 } 3447 fuzz = ntp_random() * 2. / FRAC * sys_fuzz; 3448 DTOLFP(fuzz, &lfpfuzz); 3449 L_ADD(&nts, &lfpfuzz); 3450 #ifdef DEBUG_TIMING 3451 dts = ts; 3452 L_SUB(&dts, &nts); 3453 collect_timing(rb, "input processing delay", 1, 3454 &dts); 3455 DPRINTF(4, ("fetch_timestamp: timestamp delta: %s (incl. fuzz)\n", 3456 lfptoa(&dts, 9))); 3457 #endif /* DEBUG_TIMING */ 3458 ts = nts; /* network time stamp */ 3459 break; 3460 #endif /* HAVE_BINTIME || HAVE_TIMESTAMPNS || HAVE_TIMESTAMP */ 3461 3462 default: 3463 DPRINTF(4, ("fetch_timestamp: skipping control message 0x%x\n", 3464 cmsghdr->cmsg_type)); 3465 } 3466 cmsghdr = CMSG_NXTHDR(msghdr, cmsghdr); 3467 } 3468 return ts; 3469 } 3470 #endif /* HAVE_PACKET_TIMESTAMP */ 3471 3472 3473 /* 3474 * Routine to read the network NTP packets for a specific interface 3475 * Return the number of bytes read. That way we know if we should 3476 * read it again or go on to the next one if no bytes returned 3477 */ 3478 static inline int 3479 read_network_packet( 3480 SOCKET fd, 3481 struct interface * itf, 3482 l_fp ts 3483 ) 3484 { 3485 GETSOCKNAME_SOCKLEN_TYPE fromlen; 3486 int buflen; 3487 register struct recvbuf *rb; 3488 #ifdef HAVE_PACKET_TIMESTAMP 3489 struct msghdr msghdr; 3490 struct iovec iovec; 3491 char control[CMSG_BUFSIZE]; 3492 #endif 3493 3494 /* 3495 * Get a buffer and read the frame. If we haven't got a buffer, 3496 * or this is received on a disallowed socket, just dump the 3497 * packet. 3498 */ 3499 3500 rb = itf->ignore_packets ? NULL : get_free_recv_buffer(FALSE); 3501 if (NULL == rb) { 3502 /* A partial read on a UDP socket truncates the data and 3503 * removes the message from the queue. So there's no 3504 * need to have a full buffer here on the stack. 3505 */ 3506 char buf[16]; 3507 sockaddr_u from; 3508 3509 if (rb != NULL) 3510 freerecvbuf(rb); 3511 3512 fromlen = sizeof(from); 3513 buflen = recvfrom(fd, buf, sizeof(buf), 0, 3514 &from.sa, &fromlen); 3515 DPRINTF(4, ("%s on (%lu) fd=%d from %s\n", 3516 (itf->ignore_packets) 3517 ? "ignore" 3518 : "drop", 3519 free_recvbuffs(), fd, stoa(&from))); 3520 if (itf->ignore_packets) 3521 packets_ignored++; 3522 else 3523 packets_dropped++; 3524 return (buflen); 3525 } 3526 3527 fromlen = sizeof(rb->recv_srcadr); 3528 3529 #ifndef HAVE_PACKET_TIMESTAMP 3530 rb->recv_length = recvfrom(fd, (char *)&rb->recv_space, 3531 sizeof(rb->recv_space), 0, 3532 &rb->recv_srcadr.sa, &fromlen); 3533 #else 3534 iovec.iov_base = &rb->recv_space; 3535 iovec.iov_len = sizeof(rb->recv_space); 3536 msghdr.msg_name = &rb->recv_srcadr; 3537 msghdr.msg_namelen = fromlen; 3538 msghdr.msg_iov = &iovec; 3539 msghdr.msg_iovlen = 1; 3540 msghdr.msg_control = (void *)&control; 3541 msghdr.msg_controllen = sizeof(control); 3542 msghdr.msg_flags = 0; 3543 rb->recv_length = recvmsg(fd, &msghdr, 0); 3544 #endif 3545 3546 buflen = rb->recv_length; 3547 3548 if (buflen == 0 || (buflen == -1 && 3549 (EWOULDBLOCK == errno 3550 #ifdef EAGAIN 3551 || EAGAIN == errno 3552 #endif 3553 ))) { 3554 freerecvbuf(rb); 3555 return (buflen); 3556 } else if (buflen < 0) { 3557 msyslog(LOG_ERR, "recvfrom(%s) fd=%d: %m", 3558 stoa(&rb->recv_srcadr), fd); 3559 DPRINTF(5, ("read_network_packet: fd=%d dropped (bad recvfrom)\n", 3560 fd)); 3561 freerecvbuf(rb); 3562 return (buflen); 3563 } 3564 3565 DPRINTF(3, ("read_network_packet: fd=%d length %d from %s\n", 3566 fd, buflen, stoa(&rb->recv_srcadr))); 3567 3568 #ifdef ENABLE_BUG3020_FIX 3569 if (ISREFCLOCKADR(&rb->recv_srcadr)) { 3570 msyslog(LOG_ERR, "recvfrom(%s) fd=%d: refclock srcadr on a network interface!", 3571 stoa(&rb->recv_srcadr), fd); 3572 DPRINTF(1, ("read_network_packet: fd=%d dropped (refclock srcadr))\n", 3573 fd)); 3574 packets_dropped++; 3575 freerecvbuf(rb); 3576 return (buflen); 3577 } 3578 #endif 3579 3580 /* 3581 ** Bug 2672: Some OSes (MacOSX and Linux) don't block spoofed ::1 3582 */ 3583 3584 if (AF_INET6 == itf->family) { 3585 DPRINTF(2, ("Got an IPv6 packet, from <%s> (%d) to <%s> (%d)\n", 3586 stoa(&rb->recv_srcadr), 3587 IN6_IS_ADDR_LOOPBACK(PSOCK_ADDR6(&rb->recv_srcadr)), 3588 stoa(&itf->sin), 3589 !IN6_IS_ADDR_LOOPBACK(PSOCK_ADDR6(&itf->sin)) 3590 )); 3591 3592 if ( IN6_IS_ADDR_LOOPBACK(PSOCK_ADDR6(&rb->recv_srcadr)) 3593 && !IN6_IS_ADDR_LOOPBACK(PSOCK_ADDR6(&itf->sin)) 3594 ) { 3595 packets_dropped++; 3596 DPRINTF(2, ("DROPPING that packet\n")); 3597 freerecvbuf(rb); 3598 return buflen; 3599 } 3600 DPRINTF(2, ("processing that packet\n")); 3601 } 3602 3603 /* 3604 * Got one. Mark how and when it got here, 3605 * put it on the full list and do bookkeeping. 3606 */ 3607 rb->dstadr = itf; 3608 rb->fd = fd; 3609 #ifdef HAVE_PACKET_TIMESTAMP 3610 /* pick up a network time stamp if possible */ 3611 ts = fetch_timestamp(rb, &msghdr, ts); 3612 #endif 3613 rb->recv_time = ts; 3614 rb->receiver = receive; 3615 3616 add_full_recv_buffer(rb); 3617 3618 itf->received++; 3619 packets_received++; 3620 return (buflen); 3621 } 3622 3623 /* 3624 * attempt to handle io (select()/signaled IO) 3625 */ 3626 void 3627 io_handler(void) 3628 { 3629 # ifndef HAVE_SIGNALED_IO 3630 fd_set rdfdes; 3631 int nfound; 3632 3633 /* 3634 * Use select() on all on all input fd's for unlimited 3635 * time. select() will terminate on SIGALARM or on the 3636 * reception of input. Using select() means we can't do 3637 * robust signal handling and we get a potential race 3638 * between checking for alarms and doing the select(). 3639 * Mostly harmless, I think. 3640 */ 3641 /* 3642 * On VMS, I suspect that select() can't be interrupted 3643 * by a "signal" either, so I take the easy way out and 3644 * have select() time out after one second. 3645 * System clock updates really aren't time-critical, 3646 * and - lacking a hardware reference clock - I have 3647 * yet to learn about anything else that is. 3648 */ 3649 ++handler_calls; 3650 rdfdes = activefds; 3651 # if !defined(VMS) && !defined(SYS_VXWORKS) 3652 nfound = select(maxactivefd + 1, &rdfdes, NULL, 3653 NULL, NULL); 3654 # else /* VMS, VxWorks */ 3655 /* make select() wake up after one second */ 3656 { 3657 struct timeval t1; 3658 t1.tv_sec = 1; 3659 t1.tv_usec = 0; 3660 nfound = select(maxactivefd + 1, 3661 &rdfdes, NULL, NULL, 3662 &t1); 3663 } 3664 # endif /* VMS, VxWorks */ 3665 if (nfound < 0 && sanitize_fdset(errno)) { 3666 struct timeval t1; 3667 t1.tv_sec = 0; 3668 t1.tv_usec = 0; 3669 rdfdes = activefds; 3670 nfound = select(maxactivefd + 1, 3671 &rdfdes, NULL, NULL, 3672 &t1); 3673 } 3674 3675 if (nfound > 0) { 3676 l_fp ts; 3677 3678 get_systime(&ts); 3679 3680 input_handler_scan(&ts, &rdfdes); 3681 } else if (nfound == -1 && errno != EINTR) { 3682 msyslog(LOG_ERR, "select() error: %m"); 3683 } 3684 # ifdef DEBUG 3685 else if (debug > 4) { 3686 msyslog(LOG_DEBUG, "select(): nfound=%d, error: %m", nfound); 3687 } else { 3688 DPRINTF(3, ("select() returned %d: %m\n", nfound)); 3689 } 3690 # endif /* DEBUG */ 3691 # else /* HAVE_SIGNALED_IO */ 3692 wait_for_signal(); 3693 # endif /* HAVE_SIGNALED_IO */ 3694 } 3695 3696 #ifdef HAVE_SIGNALED_IO 3697 /* 3698 * input_handler - receive packets asynchronously 3699 * 3700 * ALWAYS IN SIGNAL HANDLER CONTEXT -- only async-safe functions allowed! 3701 */ 3702 static RETSIGTYPE 3703 input_handler( 3704 l_fp * cts 3705 ) 3706 { 3707 int n; 3708 struct timeval tvzero; 3709 fd_set fds; 3710 3711 ++handler_calls; 3712 3713 /* 3714 * Do a poll to see who has data 3715 */ 3716 3717 fds = activefds; 3718 tvzero.tv_sec = tvzero.tv_usec = 0; 3719 3720 n = select(maxactivefd + 1, &fds, NULL, NULL, &tvzero); 3721 if (n < 0 && sanitize_fdset(errno)) { 3722 fds = activefds; 3723 tvzero.tv_sec = tvzero.tv_usec = 0; 3724 n = select(maxactivefd + 1, &fds, NULL, NULL, &tvzero); 3725 } 3726 if (n > 0) 3727 input_handler_scan(cts, &fds); 3728 } 3729 #endif /* HAVE_SIGNALED_IO */ 3730 3731 3732 /* 3733 * Try to sanitize the global FD set 3734 * 3735 * SIGNAL HANDLER CONTEXT if HAVE_SIGNALED_IO, ordinary userspace otherwise 3736 */ 3737 static int/*BOOL*/ 3738 sanitize_fdset( 3739 int errc 3740 ) 3741 { 3742 int j, b, maxscan; 3743 3744 # ifndef HAVE_SIGNALED_IO 3745 /* 3746 * extended FAU debugging output 3747 */ 3748 if (errc != EINTR) { 3749 msyslog(LOG_ERR, 3750 "select(%d, %s, 0L, 0L, &0.0) error: %m", 3751 maxactivefd + 1, 3752 fdbits(maxactivefd, &activefds)); 3753 } 3754 # endif 3755 3756 if (errc != EBADF) 3757 return FALSE; 3758 3759 /* if we have oviously bad FDs, try to sanitize the FD set. */ 3760 for (j = 0, maxscan = 0; j <= maxactivefd; j++) { 3761 if (FD_ISSET(j, &activefds)) { 3762 if (-1 != read(j, &b, 0)) { 3763 maxscan = j; 3764 continue; 3765 } 3766 # ifndef HAVE_SIGNALED_IO 3767 msyslog(LOG_ERR, 3768 "Removing bad file descriptor %d from select set", 3769 j); 3770 # endif 3771 FD_CLR(j, &activefds); 3772 } 3773 } 3774 if (maxactivefd != maxscan) 3775 maxactivefd = maxscan; 3776 return TRUE; 3777 } 3778 3779 /* 3780 * scan the known FDs (clocks, servers, ...) for presence in a 'fd_set'. 3781 * 3782 * SIGNAL HANDLER CONTEXT if HAVE_SIGNALED_IO, ordinary userspace otherwise 3783 */ 3784 static void 3785 input_handler_scan( 3786 const l_fp * cts, 3787 const fd_set * pfds 3788 ) 3789 { 3790 int buflen; 3791 u_int idx; 3792 int doing; 3793 SOCKET fd; 3794 blocking_child *c; 3795 l_fp ts; /* Timestamp at BOselect() gob */ 3796 3797 #if defined(DEBUG_TIMING) 3798 l_fp ts_e; /* Timestamp at EOselect() gob */ 3799 #endif 3800 endpt * ep; 3801 #ifdef REFCLOCK 3802 struct refclockio *rp; 3803 int saved_errno; 3804 const char * clk; 3805 #endif 3806 #ifdef HAS_ROUTING_SOCKET 3807 struct asyncio_reader * asyncio_reader; 3808 struct asyncio_reader * next_asyncio_reader; 3809 #endif 3810 3811 ++handler_pkts; 3812 ts = *cts; 3813 3814 #ifdef REFCLOCK 3815 /* 3816 * Check out the reference clocks first, if any 3817 */ 3818 3819 for (rp = refio; rp != NULL; rp = rp->next) { 3820 fd = rp->fd; 3821 3822 if (!FD_ISSET(fd, pfds)) 3823 continue; 3824 buflen = read_refclock_packet(fd, rp, ts); 3825 /* 3826 * The first read must succeed after select() indicates 3827 * readability, or we've reached a permanent EOF. 3828 * http://bugs.ntp.org/1732 reported ntpd munching CPU 3829 * after a USB GPS was unplugged because select was 3830 * indicating EOF but ntpd didn't remove the descriptor 3831 * from the activefds set. 3832 */ 3833 if (buflen < 0 && EAGAIN != errno) { 3834 saved_errno = errno; 3835 clk = refnumtoa(&rp->srcclock->srcadr); 3836 errno = saved_errno; 3837 msyslog(LOG_ERR, "%s read: %m", clk); 3838 maintain_activefds(fd, TRUE); 3839 } else if (0 == buflen) { 3840 clk = refnumtoa(&rp->srcclock->srcadr); 3841 msyslog(LOG_ERR, "%s read EOF", clk); 3842 maintain_activefds(fd, TRUE); 3843 } else { 3844 /* drain any remaining refclock input */ 3845 do { 3846 buflen = read_refclock_packet(fd, rp, ts); 3847 } while (buflen > 0); 3848 } 3849 } 3850 #endif /* REFCLOCK */ 3851 3852 /* 3853 * Loop through the interfaces looking for data to read. 3854 */ 3855 for (ep = ep_list; ep != NULL; ep = ep->elink) { 3856 for (doing = 0; doing < 2; doing++) { 3857 if (!doing) { 3858 fd = ep->fd; 3859 } else { 3860 if (!(ep->flags & INT_BCASTOPEN)) 3861 break; 3862 fd = ep->bfd; 3863 } 3864 if (fd < 0) 3865 continue; 3866 if (FD_ISSET(fd, pfds)) 3867 do { 3868 buflen = read_network_packet( 3869 fd, ep, ts); 3870 } while (buflen > 0); 3871 /* Check more interfaces */ 3872 } 3873 } 3874 3875 #ifdef HAS_ROUTING_SOCKET 3876 /* 3877 * scan list of asyncio readers - currently only used for routing sockets 3878 */ 3879 asyncio_reader = asyncio_reader_list; 3880 3881 while (asyncio_reader != NULL) { 3882 /* callback may unlink and free asyncio_reader */ 3883 next_asyncio_reader = asyncio_reader->link; 3884 if (FD_ISSET(asyncio_reader->fd, pfds)) 3885 (*asyncio_reader->receiver)(asyncio_reader); 3886 asyncio_reader = next_asyncio_reader; 3887 } 3888 #endif /* HAS_ROUTING_SOCKET */ 3889 3890 /* 3891 * Check for a response from a blocking child 3892 */ 3893 for (idx = 0; idx < blocking_children_alloc; idx++) { 3894 c = blocking_children[idx]; 3895 if (NULL == c || -1 == c->resp_read_pipe) 3896 continue; 3897 if (FD_ISSET(c->resp_read_pipe, pfds)) { 3898 ++c->resp_ready_seen; 3899 ++blocking_child_ready_seen; 3900 } 3901 } 3902 3903 /* We've done our work */ 3904 #if defined(DEBUG_TIMING) 3905 get_systime(&ts_e); 3906 /* 3907 * (ts_e - ts) is the amount of time we spent 3908 * processing this gob of file descriptors. Log 3909 * it. 3910 */ 3911 L_SUB(&ts_e, &ts); 3912 collect_timing(NULL, "input handler", 1, &ts_e); 3913 if (debug > 3) 3914 msyslog(LOG_DEBUG, 3915 "input_handler: Processed a gob of fd's in %s msec", 3916 lfptoms(&ts_e, 6)); 3917 #endif /* DEBUG_TIMING */ 3918 } 3919 #endif /* !HAVE_IO_COMPLETION_PORT */ 3920 3921 /* 3922 * find an interface suitable for the src address 3923 */ 3924 endpt * 3925 select_peerinterface( 3926 struct peer * peer, 3927 sockaddr_u * srcadr, 3928 endpt * dstadr 3929 ) 3930 { 3931 endpt *ep; 3932 #ifndef SIM 3933 endpt *wild; 3934 3935 wild = ANY_INTERFACE_CHOOSE(srcadr); 3936 3937 /* 3938 * Initialize the peer structure and dance the interface jig. 3939 * Reference clocks step the loopback waltz, the others 3940 * squaredance around the interface list looking for a buddy. If 3941 * the dance peters out, there is always the wildcard interface. 3942 * This might happen in some systems and would preclude proper 3943 * operation with public key cryptography. 3944 */ 3945 if (ISREFCLOCKADR(srcadr)) { 3946 ep = loopback_interface; 3947 } else if (peer->cast_flags & 3948 (MDF_BCLNT | MDF_ACAST | MDF_MCAST | MDF_BCAST)) { 3949 ep = findbcastinter(srcadr); 3950 if (ep != NULL) 3951 DPRINTF(4, ("Found *-cast interface %s for address %s\n", 3952 stoa(&ep->sin), stoa(srcadr))); 3953 else 3954 DPRINTF(4, ("No *-cast local address found for address %s\n", 3955 stoa(srcadr))); 3956 } else { 3957 ep = dstadr; 3958 if (NULL == ep) 3959 ep = wild; 3960 } 3961 /* 3962 * If it is a multicast address, findbcastinter() may not find 3963 * it. For unicast, we get to find the interface when dstadr is 3964 * given to us as the wildcard (ANY_INTERFACE_CHOOSE). Either 3965 * way, try a little harder. 3966 */ 3967 if (wild == ep) 3968 ep = findinterface(srcadr); 3969 /* 3970 * we do not bind to the wildcard interfaces for output 3971 * as our (network) source address would be undefined and 3972 * crypto will not work without knowing the own transmit address 3973 */ 3974 if (ep != NULL && INT_WILDCARD & ep->flags) 3975 if (!accept_wildcard_if_for_winnt) 3976 ep = NULL; 3977 #else /* SIM follows */ 3978 ep = loopback_interface; 3979 #endif 3980 3981 return ep; 3982 } 3983 3984 3985 /* 3986 * findinterface - find local interface corresponding to address 3987 */ 3988 endpt * 3989 findinterface( 3990 sockaddr_u *addr 3991 ) 3992 { 3993 endpt *iface; 3994 3995 iface = findlocalinterface(addr, INT_WILDCARD, 0); 3996 3997 if (NULL == iface) { 3998 DPRINTF(4, ("Found no interface for address %s - returning wildcard\n", 3999 stoa(addr))); 4000 4001 iface = ANY_INTERFACE_CHOOSE(addr); 4002 } else 4003 DPRINTF(4, ("Found interface #%d %s for address %s\n", 4004 iface->ifnum, iface->name, stoa(addr))); 4005 4006 return iface; 4007 } 4008 4009 /* 4010 * findlocalinterface - find local interface corresponding to addr, 4011 * which does not have any of flags set. If bast is nonzero, addr is 4012 * a broadcast address. 4013 * 4014 * This code attempts to find the local sending address for an outgoing 4015 * address by connecting a new socket to destinationaddress:NTP_PORT 4016 * and reading the sockname of the resulting connect. 4017 * the complicated sequence simulates the routing table lookup 4018 * for to first hop without duplicating any of the routing logic into 4019 * ntpd. preferably we would have used an API call - but its not there - 4020 * so this is the best we can do here short of duplicating to entire routing 4021 * logic in ntpd which would be a silly and really unportable thing to do. 4022 * 4023 */ 4024 static endpt * 4025 findlocalinterface( 4026 sockaddr_u * addr, 4027 int flags, 4028 int bcast 4029 ) 4030 { 4031 GETSOCKNAME_SOCKLEN_TYPE sockaddrlen; 4032 endpt * iface; 4033 sockaddr_u saddr; 4034 SOCKET s; 4035 int rtn; 4036 int on; 4037 4038 DPRINTF(4, ("Finding interface for addr %s in list of addresses\n", 4039 stoa(addr))); 4040 4041 /* [Bug 3437] The dummy POOL peer comes in with an AF of 4042 * zero. This is bound to fail, but on the way to nowhere it 4043 * triggers a security incident on SELinux. 4044 * 4045 * Checking the condition and failing early is probably a good 4046 * advice, and even saves us some syscalls in that case. 4047 * Thanks to Miroslav Lichvar for finding this. 4048 */ 4049 if (AF_UNSPEC == AF(addr)) 4050 return NULL; 4051 4052 s = socket(AF(addr), SOCK_DGRAM, 0); 4053 if (INVALID_SOCKET == s) 4054 return NULL; 4055 4056 /* 4057 * If we are looking for broadcast interface we need to set this 4058 * socket to allow broadcast 4059 */ 4060 if (bcast) { 4061 on = 1; 4062 if (SOCKET_ERROR == setsockopt(s, SOL_SOCKET, 4063 SO_BROADCAST, 4064 (void *)&on, 4065 sizeof(on))) { 4066 closesocket(s); 4067 return NULL; 4068 } 4069 } 4070 4071 rtn = connect(s, &addr->sa, SOCKLEN(addr)); 4072 if (SOCKET_ERROR == rtn) { 4073 closesocket(s); 4074 return NULL; 4075 } 4076 4077 sockaddrlen = sizeof(saddr); 4078 rtn = getsockname(s, &saddr.sa, &sockaddrlen); 4079 closesocket(s); 4080 if (SOCKET_ERROR == rtn) 4081 return NULL; 4082 4083 DPRINTF(4, ("findlocalinterface: kernel maps %s to %s\n", 4084 stoa(addr), stoa(&saddr))); 4085 4086 iface = getinterface(&saddr, flags); 4087 4088 /* 4089 * if we didn't find an exact match on saddr, find the closest 4090 * available local address. This handles the case of the 4091 * address suggested by the kernel being excluded by nic rules 4092 * or the user's -I and -L options to ntpd. 4093 * See http://bugs.ntp.org/1184 and http://bugs.ntp.org/1683 4094 * for more background. 4095 */ 4096 if (NULL == iface || iface->ignore_packets) 4097 iface = findclosestinterface(&saddr, 4098 flags | INT_LOOPBACK); 4099 4100 /* Don't use an interface which will ignore replies */ 4101 if (iface != NULL && iface->ignore_packets) 4102 iface = NULL; 4103 4104 return iface; 4105 } 4106 4107 4108 /* 4109 * findclosestinterface 4110 * 4111 * If there are -I/--interface or -L/novirtualips command-line options, 4112 * or "nic" or "interface" rules in ntp.conf, findlocalinterface() may 4113 * find the kernel's preferred local address for a given peer address is 4114 * administratively unavailable to ntpd, and punt to this routine's more 4115 * expensive search. 4116 * 4117 * Find the numerically closest local address to the one connect() 4118 * suggested. This matches an address on the same subnet first, as 4119 * needed by Bug 1184, and provides a consistent choice if there are 4120 * multiple feasible local addresses, regardless of the order ntpd 4121 * enumerated them. 4122 */ 4123 endpt * 4124 findclosestinterface( 4125 sockaddr_u * addr, 4126 int flags 4127 ) 4128 { 4129 endpt * ep; 4130 endpt * winner; 4131 sockaddr_u addr_dist; 4132 sockaddr_u min_dist; 4133 4134 ZERO_SOCK(&min_dist); 4135 winner = NULL; 4136 4137 for (ep = ep_list; ep != NULL; ep = ep->elink) { 4138 if (ep->ignore_packets || 4139 AF(addr) != ep->family || 4140 flags & ep->flags) 4141 continue; 4142 4143 calc_addr_distance(&addr_dist, addr, &ep->sin); 4144 if (NULL == winner || 4145 -1 == cmp_addr_distance(&addr_dist, &min_dist)) { 4146 min_dist = addr_dist; 4147 winner = ep; 4148 } 4149 } 4150 if (NULL == winner) 4151 DPRINTF(4, ("findclosestinterface(%s) failed\n", 4152 stoa(addr))); 4153 else 4154 DPRINTF(4, ("findclosestinterface(%s) -> %s\n", 4155 stoa(addr), stoa(&winner->sin))); 4156 4157 return winner; 4158 } 4159 4160 4161 /* 4162 * calc_addr_distance - calculate the distance between two addresses, 4163 * the absolute value of the difference between 4164 * the addresses numerically, stored as an address. 4165 */ 4166 static void 4167 calc_addr_distance( 4168 sockaddr_u * dist, 4169 const sockaddr_u * a1, 4170 const sockaddr_u * a2 4171 ) 4172 { 4173 u_int32 a1val; 4174 u_int32 a2val; 4175 u_int32 v4dist; 4176 int found_greater; 4177 int a1_greater; 4178 int i; 4179 4180 REQUIRE(AF(a1) == AF(a2)); 4181 4182 ZERO_SOCK(dist); 4183 AF(dist) = AF(a1); 4184 4185 /* v4 can be done a bit simpler */ 4186 if (IS_IPV4(a1)) { 4187 a1val = SRCADR(a1); 4188 a2val = SRCADR(a2); 4189 v4dist = (a1val > a2val) 4190 ? a1val - a2val 4191 : a2val - a1val; 4192 SET_ADDR4(dist, v4dist); 4193 4194 return; 4195 } 4196 4197 found_greater = FALSE; 4198 a1_greater = FALSE; /* suppress pot. uninit. warning */ 4199 for (i = 0; i < (int)sizeof(NSRCADR6(a1)); i++) { 4200 if (!found_greater && 4201 NSRCADR6(a1)[i] != NSRCADR6(a2)[i]) { 4202 found_greater = TRUE; 4203 a1_greater = (NSRCADR6(a1)[i] > NSRCADR6(a2)[i]); 4204 } 4205 if (!found_greater) { 4206 NSRCADR6(dist)[i] = 0; 4207 } else { 4208 if (a1_greater) 4209 NSRCADR6(dist)[i] = NSRCADR6(a1)[i] - 4210 NSRCADR6(a2)[i]; 4211 else 4212 NSRCADR6(dist)[i] = NSRCADR6(a2)[i] - 4213 NSRCADR6(a1)[i]; 4214 } 4215 } 4216 } 4217 4218 4219 /* 4220 * cmp_addr_distance - compare two address distances, returning -1, 0, 4221 * 1 to indicate their relationship. 4222 */ 4223 static int 4224 cmp_addr_distance( 4225 const sockaddr_u * d1, 4226 const sockaddr_u * d2 4227 ) 4228 { 4229 int i; 4230 4231 REQUIRE(AF(d1) == AF(d2)); 4232 4233 if (IS_IPV4(d1)) { 4234 if (SRCADR(d1) < SRCADR(d2)) 4235 return -1; 4236 else if (SRCADR(d1) == SRCADR(d2)) 4237 return 0; 4238 else 4239 return 1; 4240 } 4241 4242 for (i = 0; i < (int)sizeof(NSRCADR6(d1)); i++) { 4243 if (NSRCADR6(d1)[i] < NSRCADR6(d2)[i]) 4244 return -1; 4245 else if (NSRCADR6(d1)[i] > NSRCADR6(d2)[i]) 4246 return 1; 4247 } 4248 4249 return 0; 4250 } 4251 4252 4253 4254 /* 4255 * fetch an interface structure the matches the 4256 * address and has the given flags NOT set 4257 */ 4258 endpt * 4259 getinterface( 4260 sockaddr_u * addr, 4261 u_int32 flags 4262 ) 4263 { 4264 endpt *iface; 4265 4266 iface = find_addr_in_list(addr); 4267 4268 if (iface != NULL && (iface->flags & flags)) 4269 iface = NULL; 4270 4271 return iface; 4272 } 4273 4274 4275 /* 4276 * findbcastinter - find broadcast interface corresponding to address 4277 */ 4278 endpt * 4279 findbcastinter( 4280 sockaddr_u *addr 4281 ) 4282 { 4283 endpt * iface; 4284 4285 iface = NULL; 4286 #if !defined(MPE) && (defined(SIOCGIFCONF) || defined(SYS_WINNT)) 4287 DPRINTF(4, ("Finding broadcast/multicast interface for addr %s in list of addresses\n", 4288 stoa(addr))); 4289 4290 iface = findlocalinterface(addr, INT_LOOPBACK | INT_WILDCARD, 4291 1); 4292 if (iface != NULL) { 4293 DPRINTF(4, ("Easily found bcast-/mcast- interface index #%d %s\n", 4294 iface->ifnum, iface->name)); 4295 return iface; 4296 } 4297 4298 /* 4299 * plan B - try to find something reasonable in our lists in 4300 * case kernel lookup doesn't help 4301 */ 4302 for (iface = ep_list; iface != NULL; iface = iface->elink) { 4303 if (iface->flags & INT_WILDCARD) 4304 continue; 4305 4306 /* Don't bother with ignored interfaces */ 4307 if (iface->ignore_packets) 4308 continue; 4309 4310 /* 4311 * First look if this is the correct family 4312 */ 4313 if(AF(&iface->sin) != AF(addr)) 4314 continue; 4315 4316 /* Skip the loopback addresses */ 4317 if (iface->flags & INT_LOOPBACK) 4318 continue; 4319 4320 /* 4321 * If we are looking to match a multicast address and 4322 * this interface is one... 4323 */ 4324 if (addr_ismulticast(addr) 4325 && (iface->flags & INT_MULTICAST)) { 4326 #ifdef INCLUDE_IPV6_SUPPORT 4327 /* 4328 * ...it is the winner unless we're looking for 4329 * an interface to use for link-local multicast 4330 * and its address is not link-local. 4331 */ 4332 if (IS_IPV6(addr) 4333 && IN6_IS_ADDR_MC_LINKLOCAL(PSOCK_ADDR6(addr)) 4334 && !IN6_IS_ADDR_LINKLOCAL(PSOCK_ADDR6(&iface->sin))) 4335 continue; 4336 #endif 4337 break; 4338 } 4339 4340 /* 4341 * We match only those interfaces marked as 4342 * broadcastable and either the explicit broadcast 4343 * address or the network portion of the IP address. 4344 * Sloppy. 4345 */ 4346 if (IS_IPV4(addr)) { 4347 if (SOCK_EQ(&iface->bcast, addr)) 4348 break; 4349 4350 if ((NSRCADR(&iface->sin) & NSRCADR(&iface->mask)) 4351 == (NSRCADR(addr) & NSRCADR(&iface->mask))) 4352 break; 4353 } 4354 #ifdef INCLUDE_IPV6_SUPPORT 4355 else if (IS_IPV6(addr)) { 4356 if (SOCK_EQ(&iface->bcast, addr)) 4357 break; 4358 4359 if (SOCK_EQ(netof(&iface->sin), netof(addr))) 4360 break; 4361 } 4362 #endif 4363 } 4364 #endif /* SIOCGIFCONF */ 4365 if (NULL == iface) { 4366 DPRINTF(4, ("No bcast interface found for %s\n", 4367 stoa(addr))); 4368 iface = ANY_INTERFACE_CHOOSE(addr); 4369 } else { 4370 DPRINTF(4, ("Found bcast-/mcast- interface index #%d %s\n", 4371 iface->ifnum, iface->name)); 4372 } 4373 4374 return iface; 4375 } 4376 4377 4378 /* 4379 * io_clr_stats - clear I/O module statistics 4380 */ 4381 void 4382 io_clr_stats(void) 4383 { 4384 packets_dropped = 0; 4385 packets_ignored = 0; 4386 packets_received = 0; 4387 packets_sent = 0; 4388 packets_notsent = 0; 4389 4390 handler_calls = 0; 4391 handler_pkts = 0; 4392 io_timereset = current_time; 4393 } 4394 4395 4396 #ifdef REFCLOCK 4397 /* 4398 * io_addclock - add a reference clock to the list and arrange that we 4399 * get SIGIO interrupts from it. 4400 */ 4401 int 4402 io_addclock( 4403 struct refclockio *rio 4404 ) 4405 { 4406 BLOCKIO(); 4407 4408 /* 4409 * Stuff the I/O structure in the list and mark the descriptor 4410 * in use. There is a harmless (I hope) race condition here. 4411 */ 4412 rio->active = TRUE; 4413 4414 # ifdef HAVE_SIGNALED_IO 4415 if (init_clock_sig(rio)) { 4416 UNBLOCKIO(); 4417 return 0; 4418 } 4419 # elif defined(HAVE_IO_COMPLETION_PORT) 4420 if (!io_completion_port_add_clock_io(rio)) { 4421 UNBLOCKIO(); 4422 return 0; 4423 } 4424 # endif 4425 4426 /* 4427 * enqueue 4428 */ 4429 LINK_SLIST(refio, rio, next); 4430 4431 /* 4432 * register fd 4433 */ 4434 add_fd_to_list(rio->fd, FD_TYPE_FILE); 4435 4436 UNBLOCKIO(); 4437 return 1; 4438 } 4439 4440 4441 /* 4442 * io_closeclock - close the clock in the I/O structure given 4443 */ 4444 void 4445 io_closeclock( 4446 struct refclockio *rio 4447 ) 4448 { 4449 struct refclockio *unlinked; 4450 4451 BLOCKIO(); 4452 4453 /* 4454 * Remove structure from the list 4455 */ 4456 rio->active = FALSE; 4457 UNLINK_SLIST(unlinked, refio, rio, next, struct refclockio); 4458 if (NULL != unlinked) { 4459 /* Close the descriptor. The order of operations is 4460 * important here in case of async / overlapped IO: 4461 * only after we have removed the clock from the 4462 * IO completion port we can be sure no further 4463 * input is queued. So... 4464 * - we first disable feeding to the queu by removing 4465 * the clock from the IO engine 4466 * - close the file (which brings down any IO on it) 4467 * - clear the buffer from results for this fd 4468 */ 4469 # ifdef HAVE_IO_COMPLETION_PORT 4470 io_completion_port_remove_clock_io(rio); 4471 # endif 4472 close_and_delete_fd_from_list(rio->fd); 4473 purge_recv_buffers_for_fd(rio->fd); 4474 rio->fd = -1; 4475 } 4476 4477 UNBLOCKIO(); 4478 } 4479 #endif /* REFCLOCK */ 4480 4481 4482 /* 4483 * On NT a SOCKET is an unsigned int so we cannot possibly keep it in 4484 * an array. So we use one of the ISC_LIST functions to hold the 4485 * socket value and use that when we want to enumerate it. 4486 * 4487 * This routine is called by the forked intres child process to close 4488 * all open sockets. On Windows there's no need as intres runs in 4489 * the same process as a thread. 4490 */ 4491 #ifndef SYS_WINNT 4492 void 4493 kill_asyncio( 4494 int startfd 4495 ) 4496 { 4497 BLOCKIO(); 4498 4499 /* 4500 * In the child process we do not maintain activefds and 4501 * maxactivefd. Zeroing maxactivefd disables code which 4502 * maintains it in close_and_delete_fd_from_list(). 4503 */ 4504 maxactivefd = 0; 4505 4506 while (fd_list != NULL) 4507 close_and_delete_fd_from_list(fd_list->fd); 4508 4509 UNBLOCKIO(); 4510 } 4511 #endif /* !SYS_WINNT */ 4512 4513 4514 /* 4515 * Add and delete functions for the list of open sockets 4516 */ 4517 static void 4518 add_fd_to_list( 4519 SOCKET fd, 4520 enum desc_type type 4521 ) 4522 { 4523 vsock_t *lsock = emalloc(sizeof(*lsock)); 4524 4525 lsock->fd = fd; 4526 lsock->type = type; 4527 4528 LINK_SLIST(fd_list, lsock, link); 4529 maintain_activefds(fd, 0); 4530 } 4531 4532 4533 static void 4534 close_and_delete_fd_from_list( 4535 SOCKET fd 4536 ) 4537 { 4538 vsock_t *lsock; 4539 4540 UNLINK_EXPR_SLIST(lsock, fd_list, fd == 4541 UNLINK_EXPR_SLIST_CURRENT()->fd, link, vsock_t); 4542 4543 if (NULL == lsock) 4544 return; 4545 4546 switch (lsock->type) { 4547 4548 case FD_TYPE_SOCKET: 4549 closesocket(lsock->fd); 4550 break; 4551 4552 case FD_TYPE_FILE: 4553 closeserial((int)lsock->fd); 4554 break; 4555 4556 default: 4557 msyslog(LOG_ERR, 4558 "internal error - illegal descriptor type %d - EXITING", 4559 (int)lsock->type); 4560 exit(1); 4561 } 4562 4563 free(lsock); 4564 /* 4565 * remove from activefds 4566 */ 4567 maintain_activefds(fd, 1); 4568 } 4569 4570 4571 static void 4572 add_addr_to_list( 4573 sockaddr_u * addr, 4574 endpt * ep 4575 ) 4576 { 4577 remaddr_t *laddr; 4578 4579 #ifdef DEBUG 4580 if (find_addr_in_list(addr) == NULL) { 4581 #endif 4582 /* not there yet - add to list */ 4583 laddr = emalloc(sizeof(*laddr)); 4584 laddr->addr = *addr; 4585 laddr->ep = ep; 4586 4587 LINK_SLIST(remoteaddr_list, laddr, link); 4588 4589 DPRINTF(4, ("Added addr %s to list of addresses\n", 4590 stoa(addr))); 4591 #ifdef DEBUG 4592 } else 4593 DPRINTF(4, ("WARNING: Attempt to add duplicate addr %s to address list\n", 4594 stoa(addr))); 4595 #endif 4596 } 4597 4598 4599 static void 4600 delete_addr_from_list( 4601 sockaddr_u *addr 4602 ) 4603 { 4604 remaddr_t *unlinked; 4605 4606 UNLINK_EXPR_SLIST(unlinked, remoteaddr_list, SOCK_EQ(addr, 4607 &(UNLINK_EXPR_SLIST_CURRENT()->addr)), link, remaddr_t); 4608 4609 if (unlinked != NULL) { 4610 DPRINTF(4, ("Deleted addr %s from list of addresses\n", 4611 stoa(addr))); 4612 free(unlinked); 4613 } 4614 } 4615 4616 4617 static void 4618 delete_interface_from_list( 4619 endpt *iface 4620 ) 4621 { 4622 remaddr_t *unlinked; 4623 4624 for (;;) { 4625 UNLINK_EXPR_SLIST(unlinked, remoteaddr_list, iface == 4626 UNLINK_EXPR_SLIST_CURRENT()->ep, link, 4627 remaddr_t); 4628 4629 if (unlinked == NULL) 4630 break; 4631 DPRINTF(4, ("Deleted addr %s for interface #%d %s from list of addresses\n", 4632 stoa(&unlinked->addr), iface->ifnum, 4633 iface->name)); 4634 free(unlinked); 4635 } 4636 } 4637 4638 4639 static struct interface * 4640 find_addr_in_list( 4641 sockaddr_u *addr 4642 ) 4643 { 4644 remaddr_t *entry; 4645 4646 DPRINTF(4, ("Searching for addr %s in list of addresses - ", 4647 stoa(addr))); 4648 4649 for (entry = remoteaddr_list; 4650 entry != NULL; 4651 entry = entry->link) 4652 if (SOCK_EQ(&entry->addr, addr)) { 4653 DPRINTF(4, ("FOUND\n")); 4654 return entry->ep; 4655 } 4656 4657 DPRINTF(4, ("NOT FOUND\n")); 4658 return NULL; 4659 } 4660 4661 4662 /* 4663 * Find the given address with the all given flags set in the list 4664 */ 4665 static endpt * 4666 find_flagged_addr_in_list( 4667 sockaddr_u * addr, 4668 u_int32 flags 4669 ) 4670 { 4671 remaddr_t *entry; 4672 4673 DPRINTF(4, ("Finding addr %s with flags %d in list: ", 4674 stoa(addr), flags)); 4675 4676 for (entry = remoteaddr_list; 4677 entry != NULL; 4678 entry = entry->link) 4679 4680 if (SOCK_EQ(&entry->addr, addr) 4681 && (entry->ep->flags & flags) == flags) { 4682 4683 DPRINTF(4, ("FOUND\n")); 4684 return entry->ep; 4685 } 4686 4687 DPRINTF(4, ("NOT FOUND\n")); 4688 return NULL; 4689 } 4690 4691 4692 const char * 4693 localaddrtoa( 4694 endpt *la 4695 ) 4696 { 4697 return (NULL == la) 4698 ? "<null>" 4699 : stoa(&la->sin); 4700 } 4701 4702 4703 #ifdef HAS_ROUTING_SOCKET 4704 # ifndef UPDATE_GRACE 4705 # define UPDATE_GRACE 2 /* wait UPDATE_GRACE seconds before scanning */ 4706 # endif 4707 4708 static void 4709 process_routing_msgs(struct asyncio_reader *reader) 4710 { 4711 char buffer[5120]; 4712 int cnt, msg_type; 4713 #ifdef HAVE_RTNETLINK 4714 struct nlmsghdr *nh; 4715 #else 4716 struct rt_msghdr rtm; 4717 char *p; 4718 #endif 4719 4720 if (disable_dynamic_updates) { 4721 /* 4722 * discard ourselves if we are not needed any more 4723 * usually happens when running unprivileged 4724 */ 4725 remove_asyncio_reader(reader); 4726 delete_asyncio_reader(reader); 4727 return; 4728 } 4729 4730 cnt = read(reader->fd, buffer, sizeof(buffer)); 4731 4732 if (cnt < 0) { 4733 if (errno == ENOBUFS) { 4734 msyslog(LOG_ERR, 4735 "routing socket reports: %m"); 4736 } else { 4737 msyslog(LOG_ERR, 4738 "routing socket reports: %m - disabling"); 4739 remove_asyncio_reader(reader); 4740 delete_asyncio_reader(reader); 4741 } 4742 return; 4743 } 4744 4745 /* 4746 * process routing message 4747 */ 4748 #ifdef HAVE_RTNETLINK 4749 for (nh = UA_PTR(struct nlmsghdr, buffer); 4750 NLMSG_OK(nh, cnt); 4751 nh = NLMSG_NEXT(nh, cnt)) 4752 { 4753 msg_type = nh->nlmsg_type; 4754 #else 4755 for (p = buffer; 4756 (p + sizeof(struct rt_msghdr)) <= (buffer + cnt); 4757 p += rtm.rtm_msglen) 4758 { 4759 memcpy(&rtm, p, sizeof(rtm)); 4760 if (rtm.rtm_version != RTM_VERSION) { 4761 msyslog(LOG_ERR, 4762 "version mismatch (got %d - expected %d) on routing socket - disabling", 4763 rtm.rtm_version, RTM_VERSION); 4764 4765 remove_asyncio_reader(reader); 4766 delete_asyncio_reader(reader); 4767 return; 4768 } 4769 msg_type = rtm.rtm_type; 4770 #endif 4771 switch (msg_type) { 4772 #ifdef RTM_NEWADDR 4773 case RTM_NEWADDR: 4774 #endif 4775 #ifdef RTM_DELADDR 4776 case RTM_DELADDR: 4777 #endif 4778 #ifdef RTM_ADD 4779 case RTM_ADD: 4780 #endif 4781 #ifdef RTM_DELETE 4782 case RTM_DELETE: 4783 #endif 4784 #ifdef RTM_REDIRECT 4785 case RTM_REDIRECT: 4786 #endif 4787 #ifdef RTM_CHANGE 4788 case RTM_CHANGE: 4789 #endif 4790 #ifdef RTM_LOSING 4791 case RTM_LOSING: 4792 #endif 4793 #ifdef RTM_IFINFO 4794 case RTM_IFINFO: 4795 #endif 4796 #ifdef RTM_IFANNOUNCE 4797 case RTM_IFANNOUNCE: 4798 #endif 4799 #ifdef RTM_NEWLINK 4800 case RTM_NEWLINK: 4801 #endif 4802 #ifdef RTM_DELLINK 4803 case RTM_DELLINK: 4804 #endif 4805 #ifdef RTM_NEWROUTE 4806 case RTM_NEWROUTE: 4807 #endif 4808 #ifdef RTM_DELROUTE 4809 case RTM_DELROUTE: 4810 #endif 4811 /* 4812 * we are keen on new and deleted addresses and 4813 * if an interface goes up and down or routing 4814 * changes 4815 */ 4816 DPRINTF(3, ("routing message op = %d: scheduling interface update\n", 4817 msg_type)); 4818 timer_interfacetimeout(current_time + UPDATE_GRACE); 4819 break; 4820 #ifdef HAVE_RTNETLINK 4821 case NLMSG_DONE: 4822 /* end of multipart message */ 4823 return; 4824 #endif 4825 default: 4826 /* 4827 * the rest doesn't bother us. 4828 */ 4829 DPRINTF(4, ("routing message op = %d: ignored\n", 4830 msg_type)); 4831 break; 4832 } 4833 } 4834 } 4835 4836 /* 4837 * set up routing notifications 4838 */ 4839 static void 4840 init_async_notifications() 4841 { 4842 struct asyncio_reader *reader; 4843 #ifdef HAVE_RTNETLINK 4844 int fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE); 4845 struct sockaddr_nl sa; 4846 #else 4847 int fd = socket(PF_ROUTE, SOCK_RAW, 0); 4848 #endif 4849 if (fd < 0) { 4850 msyslog(LOG_ERR, 4851 "unable to open routing socket (%m) - using polled interface update"); 4852 return; 4853 } 4854 4855 fd = move_fd(fd); 4856 #ifdef HAVE_RTNETLINK 4857 ZERO(sa); 4858 sa.nl_family = PF_NETLINK; 4859 sa.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR 4860 | RTMGRP_IPV6_IFADDR | RTMGRP_IPV4_ROUTE 4861 | RTMGRP_IPV4_MROUTE | RTMGRP_IPV6_ROUTE 4862 | RTMGRP_IPV6_MROUTE; 4863 if (bind(fd, (struct sockaddr *)&sa, sizeof(sa)) < 0) { 4864 msyslog(LOG_ERR, 4865 "bind failed on routing socket (%m) - using polled interface update"); 4866 return; 4867 } 4868 #endif 4869 make_socket_nonblocking(fd); 4870 #if defined(HAVE_SIGNALED_IO) 4871 init_socket_sig(fd); 4872 #endif /* HAVE_SIGNALED_IO */ 4873 4874 reader = new_asyncio_reader(); 4875 4876 reader->fd = fd; 4877 reader->receiver = process_routing_msgs; 4878 4879 add_asyncio_reader(reader, FD_TYPE_SOCKET); 4880 msyslog(LOG_INFO, 4881 "Listening on routing socket on fd #%d for interface updates", 4882 fd); 4883 } 4884 #else 4885 /* HAS_ROUTING_SOCKET not defined */ 4886 static void 4887 init_async_notifications(void) 4888 { 4889 } 4890 #endif 4891 4892