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