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