contrib/ntp/ntpd/ntp_io.c

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