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