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