/*

 * ntp_io.c - input/output routines for ntpd. The socket-opening code

 *       was shamelessly stolen from ntpd.

 */

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include <stdio.h>

#include <signal.h>

#ifdef HAVE_FNMATCH_H

# include <fnmatch.h>

# if !defined(FNM_CASEFOLD) && defined(FNM_IGNORECASE)

#  define FNM_CASEFOLD FNM_IGNORECASE

# endif

#endif

#ifdef HAVE_SYS_PARAM_H

# include <sys/param.h>

#endif

#ifdef HAVE_SYS_IOCTL_H

# include <sys/ioctl.h>

#endif

#ifdef HAVE_SYS_SOCKIO_H  /* UXPV: SIOC* #defines (Frank Vance <fvance@waii.com>) */

# include <sys/sockio.h>

#endif

#ifdef HAVE_SYS_UIO_H

# include <sys/uio.h>

#endif

#include "ntp_machine.h"

#include "ntpd.h"

#include "ntp_io.h"

#include "iosignal.h"

#include "ntp_lists.h"

#include "ntp_refclock.h"

#include "ntp_stdlib.h"

#include "ntp_worker.h"

#include "ntp_request.h"

#include "ntp_assert.h"

#include "timevalops.h"

#include "timespecops.h"

#include "ntpd-opts.h"

/* Don't include ISC's version of IPv6 variables and structures */

#define ISC_IPV6_H 1

#include <isc/mem.h>

#include <isc/interfaceiter.h>

#include <isc/netaddr.h>

#include <isc/result.h>

#include <isc/sockaddr.h>

#ifdef SIM

#include "ntpsim.h"

#endif

#ifdef HAS_ROUTING_SOCKET

# include <net/route.h>

# ifdef HAVE_RTNETLINK

#  include <linux/rtnetlink.h>

# endif

#endif

/*

 * setsockopt does not always have the same arg declaration

 * across all platforms. If it's not defined we make it empty

 */

#ifndef SETSOCKOPT_ARG_CAST

#define SETSOCKOPT_ARG_CAST

#endif

extern int listen_to_virtual_ips;

#ifndef IPTOS_DSCP_EF

#define IPTOS_DSCP_EF 0xb8

#endif

int qos = IPTOS_DSCP_EF;  /* QoS RFC3246 */

#ifdef LEAP_SMEAR

/* TODO burnicki: This should be moved to ntp_timer.c, but if we do so

 * we get a linker error. Since we're running out of time before the leap

 * second occurs, we let it here where it just works.

 */

int leap_smear_intv;

#endif

/*

 * NIC rule entry

 */

typedef struct nic_rule_tag nic_rule;

struct nic_rule_tag {

  nic_rule *  next;

  nic_rule_action action;

  nic_rule_match  match_type;

  char *    if_name;

  sockaddr_u  addr;

  int   prefixlen;

};

/*

 * NIC rule listhead.  Entries are added at the head so that the first

 * match in the list is the last matching rule specified.

 */

nic_rule *nic_rule_list;

#if defined(SO_BINTIME) && defined(SCM_BINTIME) && defined(CMSG_FIRSTHDR)

#  define HAVE_PACKET_TIMESTAMP

#  define HAVE_BINTIME

#  ifdef BINTIME_CTLMSGBUF_SIZE

#   define CMSG_BUFSIZE BINTIME_CTLMSGBUF_SIZE

#  else

#   define CMSG_BUFSIZE  1536 /* moderate default */

#  endif

#elif defined(SO_TIMESTAMPNS) && defined(SCM_TIMESTAMPNS) && defined(CMSG_FIRSTHDR)

#  define HAVE_PACKET_TIMESTAMP

#  define HAVE_TIMESTAMPNS

#  ifdef TIMESTAMPNS_CTLMSGBUF_SIZE

#   define CMSG_BUFSIZE TIMESTAMPNS_CTLMSGBUF_SIZE

#  else

#   define CMSG_BUFSIZE  1536 /* moderate default */

#  endif

#elif defined(SO_TIMESTAMP) && defined(SCM_TIMESTAMP) && defined(CMSG_FIRSTHDR)

#  define HAVE_PACKET_TIMESTAMP

#  define HAVE_TIMESTAMP

#  ifdef TIMESTAMP_CTLMSGBUF_SIZE

#   define CMSG_BUFSIZE TIMESTAMP_CTLMSGBUF_SIZE

#  else

#   define CMSG_BUFSIZE  1536 /* moderate default */

#  endif

#else

/* fill in for old/other timestamp interfaces */

#endif

#if defined(SYS_WINNT)

#include "win32_io.h"

#include <isc/win32os.h>

#endif

/*

 * We do asynchronous input using the SIGIO facility.  A number of

 * recvbuf buffers are preallocated for input.  In the signal

 * handler we poll to see which sockets are ready and read the

 * packets from them into the recvbuf's along with a time stamp and

 * an indication of the source host and the interface it was received

 * through.  This allows us to get as accurate receive time stamps

 * as possible independent of other processing going on.

 *

 * We watch the number of recvbufs available to the signal handler

 * and allocate more when this number drops below the low water

 * mark.  If the signal handler should run out of buffers in the

 * interim it will drop incoming frames, the idea being that it is

 * better to drop a packet than to be inaccurate.

 */

/*

 * Other statistics of possible interest

 */

volatile u_long packets_dropped;  /* total number of packets dropped on reception */

volatile u_long packets_ignored;  /* packets received on wild card interface */

volatile u_long packets_received; /* total number of packets received */

   u_long packets_sent;   /* total number of packets sent */

   u_long packets_notsent;  /* total number of packets which couldn't be sent */

volatile u_long handler_calls;  /* number of calls to interrupt handler */

volatile u_long handler_pkts; /* number of pkts received by handler */

u_long io_timereset;    /* time counters were reset */

/*

 * Interface stuff

 */

endpt * any_interface;    /* wildcard ipv4 interface */

endpt * any6_interface;   /* wildcard ipv6 interface */

endpt * loopback_interface; /* loopback ipv4 interface */

static isc_boolean_t broadcast_client_enabled;

u_int sys_ifnum;      /* next .ifnum to assign */

int ninterfaces;      /* Total number of interfaces */

int no_periodic_scan;   /* network endpoint scans */

int scan_addrs_once;    /* because dropped privs */

int nonlocal_v4_addr_up;  /* should we try IPv4 pool? */

int nonlocal_v6_addr_up;  /* should we try IPv6 pool? */

#ifdef REFCLOCK

/*

 * Refclock stuff.  We keep a chain of structures with data concerning

 * the guys we are doing I/O for.

 */

static  struct refclockio *refio;

#endif /* REFCLOCK */

/*

 * File descriptor masks etc. for call to select

 * Not needed for I/O Completion Ports or anything outside this file

 */

static fd_set activefds;

static int maxactivefd;

/*

 * bit alternating value to detect verified interfaces during an update cycle

 */

static  u_short   sys_interphase = 0;

static endpt *  new_interface(endpt *);

static void add_interface(endpt *);

static int  update_interfaces(u_short, interface_receiver_t,

          void *);

static void remove_interface(endpt *);

static endpt *  create_interface(u_short, endpt *);

static inline int is_wildcard_addr(const sockaddr_u *psau);

/*

 * Multicast functions

 */

static  isc_boolean_t addr_ismulticast  (sockaddr_u *);

static  isc_boolean_t is_anycast    (sockaddr_u *,

             const char *);

/*

 * Not all platforms support multicast

 */

#ifdef MCAST

static  isc_boolean_t socket_multicast_enable (endpt *, sockaddr_u *);

static  isc_boolean_t socket_multicast_disable(endpt *, sockaddr_u *);

#endif

#ifdef DEBUG

static void interface_dump  (const endpt *);

static void print_interface (const endpt *, const char *, const char *);

#define DPRINT_INTERFACE(level, args) do { if (debug >= (level)) { print_interface args; } } while (0)

#else

#define DPRINT_INTERFACE(level, args) do {} while (0)

#endif

typedef struct vsock vsock_t;

enum desc_type { FD_TYPE_SOCKET, FD_TYPE_FILE };

struct vsock {

  vsock_t * link;

  SOCKET    fd;

  enum desc_type  type;

};

vsock_t *fd_list;

#if !defined(HAVE_IO_COMPLETION_PORT) && defined(HAS_ROUTING_SOCKET)

/*

 * async notification processing (e. g. routing sockets)

 */

/*

 * support for receiving data on fd that is not a refclock or a socket

 * like e. g. routing sockets

 */

struct asyncio_reader {

  struct asyncio_reader *link;        /* the list this is being kept in */

  SOCKET fd;            /* fd to be read */

  void  *data;            /* possibly local data */

  void (*receiver)(struct asyncio_reader *);  /* input handler */

};

struct asyncio_reader *asyncio_reader_list;

static void delete_asyncio_reader (struct asyncio_reader *);

static struct asyncio_reader *new_asyncio_reader (void);

static void add_asyncio_reader (struct asyncio_reader *, enum desc_type);

static void remove_asyncio_reader (struct asyncio_reader *);

#endif /* !defined(HAVE_IO_COMPLETION_PORT) && defined(HAS_ROUTING_SOCKET) */

static void init_async_notifications (void);

static  int addr_eqprefix (const sockaddr_u *, const sockaddr_u *,

         int);

static int  addr_samesubnet (const sockaddr_u *, const sockaddr_u *,

         const sockaddr_u *, const sockaddr_u *);

static  int create_sockets  (u_short);

static  SOCKET  open_socket (sockaddr_u *, int, int, endpt *);

static  void  set_reuseaddr (int);

static  isc_boolean_t socket_broadcast_enable  (endpt *, SOCKET, sockaddr_u *);

#if !defined(HAVE_IO_COMPLETION_PORT) && !defined(HAVE_SIGNALED_IO)

static  char *  fdbits    (int, const fd_set *);

#endif

#ifdef  OS_MISSES_SPECIFIC_ROUTE_UPDATES

static  isc_boolean_t socket_broadcast_disable (endpt *, sockaddr_u *);

#endif

typedef struct remaddr remaddr_t;

struct remaddr {

  remaddr_t *   link;

  sockaddr_u    addr;

  endpt *     ep;

};

remaddr_t * remoteaddr_list;

endpt *   ep_list;  /* complete endpt list */

endpt *   mc4_list; /* IPv4 mcast-capable unicast endpts */

endpt *   mc6_list; /* IPv6 mcast-capable unicast endpts */

static endpt *  wildipv4;

static endpt *  wildipv6;

#define   RFC3927_ADDR  0xa9fe0000  /* 169.254. */

#define   RFC3927_MASK  0xffff0000

#define   IS_AUTOCONF(addr4)          \

    ((SRCADR(addr4) & RFC3927_MASK) == RFC3927_ADDR)

#ifdef SYS_WINNT

int accept_wildcard_if_for_winnt;

#else

const int accept_wildcard_if_for_winnt = FALSE;

#define   init_io_completion_port() do {} while (FALSE)

#endif

static void add_fd_to_list    (SOCKET, enum desc_type);

static endpt *  find_addr_in_list (sockaddr_u *);

static endpt *  find_flagged_addr_in_list(sockaddr_u *, u_int32);

static void delete_addr_from_list (sockaddr_u *);

static void delete_interface_from_list(endpt *);

static void close_and_delete_fd_from_list(SOCKET, endpt *);

static void add_addr_to_list  (sockaddr_u *, endpt *);

static void create_wildcards  (u_short);

static endpt *  findlocalinterface  (sockaddr_u *, int, int);

static endpt *  findclosestinterface  (sockaddr_u *, int);

#ifdef DEBUG

static const char * action_text (nic_rule_action);

#endif

static nic_rule_action  interface_action(char *, sockaddr_u *, u_int32);

static void   convert_isc_if  (isc_interface_t *,

           endpt *, u_short);

static void   calc_addr_distance(sockaddr_u *,

             const sockaddr_u *,

             const sockaddr_u *);

static int    cmp_addr_distance(const sockaddr_u *,

            const sockaddr_u *);

/*

 * Routines to read the ntp packets

 */

#if !defined(HAVE_IO_COMPLETION_PORT)

static inline int read_network_packet (SOCKET, endpt *, l_fp);

static void   ntpd_addremove_io_fd  (int, int, int);

static void     input_handler_scan  (const l_fp*, const fd_set*);

static int/*BOOL*/  sanitize_fdset    (int errc);

#ifdef REFCLOCK

static inline int read_refclock_packet  (SOCKET, struct refclockio *, l_fp);

#endif

#ifdef HAVE_SIGNALED_IO

static void     input_handler   (l_fp*);

#endif

#endif

#ifndef HAVE_IO_COMPLETION_PORT

void

maintain_activefds(

  int fd,

  int closing

  )

{

  int i;

  if (fd < 0 || fd >= FD_SETSIZE) {

    msyslog(LOG_ERR,

      "Too many sockets in use, FD_SETSIZE %d exceeded by fd %d",

      FD_SETSIZE, fd);

    exit(1);

  }

  if (!closing) {

    FD_SET(fd, &activefds);

    maxactivefd = max(fd, maxactivefd);

  } else {

    FD_CLR(fd, &activefds);

    if (maxactivefd && fd == maxactivefd) {

      for (i = maxactivefd - 1; i >= 0; i--)

        if (FD_ISSET(i, &activefds)) {

          maxactivefd = i;

          break;

        }

      INSIST(fd != maxactivefd);

    }

  }

}

#endif  /* !HAVE_IO_COMPLETION_PORT */

#ifdef DEBUG_TIMING

/*

 * collect timing information for various processing

 * paths. currently we only pass them on to the file

 * for later processing. this could also do histogram

 * based analysis in other to reduce the load (and skew)

 * dur to the file output

 */

void

collect_timing(struct recvbuf *rb, const char *tag, int count, l_fp *dts)

{

  char buf[256];

  snprintf(buf, sizeof(buf), "%s %d %s %s",

     (rb != NULL)

         ? ((rb->dstadr != NULL)

          ? stoa(&rb->recv_srcadr)

          : "-REFCLOCK-")

         : "-",

     count, lfptoa(dts, 9), tag);

  record_timing_stats(buf);

}

#endif

/*

 * About dynamic interfaces, sockets, reception and more...

 *

 * the code solves following tasks:

 *

 *   - keep a current list of active interfaces in order

 *     to bind to to the interface address on NTP_PORT so that

 *     all wild and specific bindings for NTP_PORT are taken by ntpd

 *     to avoid other daemons messing with the time or sockets.

 *   - all interfaces keep a list of peers that are referencing

 *     the interface in order to quickly re-assign the peers to

 *     new interface in case an interface is deleted (=> gone from system or

 *     down)

 *   - have a preconfigured socket ready with the right local address

 *     for transmission and reception

 *   - have an address list for all destination addresses used within ntpd

 *     to find the "right" preconfigured socket.

 *   - facilitate updating the internal interface list with respect to

 *     the current kernel state

 *

 * special issues:

 *

 *   - mapping of multicast addresses to the interface affected is not always

 *     one to one - especially on hosts with multiple interfaces

 *     the code here currently allocates a separate interface entry for those

 *     multicast addresses

 *     iff it is able to bind to a *new* socket with the multicast address (flags |= MCASTIF)

 *     in case of failure the multicast address is bound to an existing interface.

 *   - on some systems it is perfectly legal to assign the same address to

 *     multiple interfaces. Therefore this code does not keep a list of interfaces

 *     but a list of interfaces that represent a unique address as determined by the kernel

 *     by the procedure in findlocalinterface. Thus it is perfectly legal to see only

 *     one representative of a group of real interfaces if they share the same address.

 *

 * Frank Kardel 20050910

 */

/*

 * init_io - initialize I/O module.

 */

void

init_io(void)

{

  /* Init buffer free list and stat counters */

  init_recvbuff(RECV_INIT);

  /* update interface every 5 minutes as default */

  endpt_scan_period = 301;

#ifdef WORK_PIPE

  addremove_io_fd = &ntpd_addremove_io_fd;

#endif

  init_io_completion_port();

#if defined(HAVE_SIGNALED_IO)

  (void) set_signal(input_handler);

#endif

}

static void

ntpd_addremove_io_fd(

  int fd,

  int is_pipe,

  int remove_it

  )

{

  UNUSED_ARG(is_pipe);

#ifdef HAVE_SIGNALED_IO

  if (!remove_it)

    init_socket_sig(fd);

#endif /* not HAVE_SIGNALED_IO */

  maintain_activefds(fd, remove_it);

}

/*

 * io_open_sockets - call socket creation routine

 */

void

io_open_sockets(void)

{

  static int already_opened;

  if (already_opened || HAVE_OPT( SAVECONFIGQUIT ))

    return;

  already_opened = 1;

  /*

   * Create the sockets

   */

  BLOCKIO();

#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION

  create_sockets(4123);

#else

  create_sockets(NTP_PORT);

#endif

  UNBLOCKIO();

  init_async_notifications();

  DPRINTF(3, ("io_open_sockets: maxactivefd %d\n", maxactivefd));

}

#ifdef DEBUG

/*

 * function to dump the contents of the interface structure

 * for debugging use only.

 * We face a dilemma here -- sockets are FDs under POSIX and

 * actually HANDLES under Windows. So we use '%lld' as format

 * and cast the value to 'long long'; this should not hurt

 * with UNIX-like systems and does not truncate values on Win64.

 */

void

interface_dump(const endpt *itf)

{

  printf("Dumping interface: %p\n", itf);

  printf("fd = %lld\n", (long long)itf->fd);

  printf("bfd = %lld\n", (long long)itf->bfd);

  printf("sin = %s,\n", stoa(&itf->sin));

  printf("bcast = %s,\n", stoa(&itf->bcast));

  printf("mask = %s,\n", stoa(&itf->mask));

  printf("name = %s\n", itf->name);

  printf("flags = 0x%08x\n", itf->flags);

  printf("last_ttl = %d\n", itf->last_ttl);

  printf("addr_refid = %08x\n", itf->addr_refid);

  printf("num_mcast = %d\n", itf->num_mcast);

  printf("received = %ld\n", itf->received);

  printf("sent = %ld\n", itf->sent);

  printf("notsent = %ld\n", itf->notsent);

  printf("ifindex = %u\n", itf->ifindex);

  printf("peercnt = %u\n", itf->peercnt);

  printf("phase = %u\n", itf->phase);

}

/*

 * print_interface - helper to output debug information

 */

static void

print_interface(const endpt *iface, const char *pfx, const char *sfx)

{

  printf("%sinterface #%d: fd=%lld, bfd=%lld, name=%s, flags=0x%x, ifindex=%u, sin=%s",

         pfx,

         iface->ifnum,

         (long long)iface->fd,

         (long long)iface->bfd,

         iface->name,

         iface->flags,

         iface->ifindex,

         stoa(&iface->sin));

  if (AF_INET == iface->family) {

    if (iface->flags & INT_BROADCAST)

      printf(", bcast=%s", stoa(&iface->bcast));

    printf(", mask=%s", stoa(&iface->mask));

  }

  printf(", %s:%s",

         (iface->ignore_packets)

       ? "Disabled"

       : "Enabled",

         sfx);

  if (debug > 4) /* in-depth debugging only */

    interface_dump(iface);

}

#endif

#if !defined(HAVE_IO_COMPLETION_PORT) && defined(HAS_ROUTING_SOCKET)

/*

 * create an asyncio_reader structure

 */

static struct asyncio_reader *

new_asyncio_reader(void)

{

  struct asyncio_reader *reader;

  reader = emalloc_zero(sizeof(*reader));

  reader->fd = INVALID_SOCKET;

  return reader;

}

/*

 * delete a reader

 */

static void

delete_asyncio_reader(

  struct asyncio_reader *reader

  )

{

  free(reader);

}

/*

 * add asynchio_reader

 */

static void

add_asyncio_reader(

  struct asyncio_reader * reader,

  enum desc_type    type)

{

  LINK_SLIST(asyncio_reader_list, reader, link);

  add_fd_to_list(reader->fd, type);

}

/*

 * remove asyncio_reader

 */

static void

remove_asyncio_reader(

  struct asyncio_reader *reader

  )

{

  struct asyncio_reader *unlinked;

  UNLINK_SLIST(unlinked, asyncio_reader_list, reader, link,

      struct asyncio_reader);

  if (reader->fd != INVALID_SOCKET) {

    close_and_delete_fd_from_list(reader->fd, NULL);

  }

  reader->fd = INVALID_SOCKET;

}

#endif /* !defined(HAVE_IO_COMPLETION_PORT) && defined(HAS_ROUTING_SOCKET) */

/* compare two sockaddr prefixes */

static int

addr_eqprefix(

  const sockaddr_u *  a,

  const sockaddr_u *  b,

  int     prefixlen

  )

{

  isc_netaddr_t   isc_a;

  isc_netaddr_t   isc_b;

  isc_sockaddr_t    isc_sa;

  ZERO(isc_sa);

  memcpy(&isc_sa.type, a, min(sizeof(isc_sa.type), sizeof(*a)));

  isc_netaddr_fromsockaddr(&isc_a, &isc_sa);

  ZERO(isc_sa);

  memcpy(&isc_sa.type, b, min(sizeof(isc_sa.type), sizeof(*b)));

  isc_netaddr_fromsockaddr(&isc_b, &isc_sa);

  return (int)isc_netaddr_eqprefix(&isc_a, &isc_b,

           (u_int)prefixlen);

}

static int

addr_samesubnet(

  const sockaddr_u *  a,

  const sockaddr_u *  a_mask,

  const sockaddr_u *  b,

  const sockaddr_u *  b_mask

  )

{

  const u_int32 * pa;

  const u_int32 * pa_limit;

  const u_int32 * pb;

  const u_int32 * pm;

  size_t    loops;

  REQUIRE(AF(a) == AF(a_mask));

  REQUIRE(AF(b) == AF(b_mask));

  /*

   * With address and mask families verified to match, comparing

   * the masks also validates the address's families match.

   */

  if (!SOCK_EQ(a_mask, b_mask))

    return FALSE;

  if (IS_IPV6(a)) {

    loops = sizeof(NSRCADR6(a)) / sizeof(*pa);

    pa = (const void *)&NSRCADR6(a);

    pb = (const void *)&NSRCADR6(b);

    pm = (const void *)&NSRCADR6(a_mask);

  } else {

    loops = sizeof(NSRCADR(a)) / sizeof(*pa);

    pa = (const void *)&NSRCADR(a);

    pb = (const void *)&NSRCADR(b);

    pm = (const void *)&NSRCADR(a_mask);

  }

  for (pa_limit = pa + loops; pa < pa_limit; pa++, pb++, pm++)

    if ((*pa & *pm) != (*pb & *pm))

      return FALSE;

  return TRUE;

}

/*

 * interface list enumerator - visitor pattern

 */

void

interface_enumerate(

  interface_receiver_t  receiver,

  void *      data

  )

{

  interface_info_t ifi;

  ifi.action = IFS_EXISTS;

  for (ifi.ep = ep_list; ifi.ep != NULL; ifi.ep = ifi.ep->elink)

    (*receiver)(data, &ifi);

}

/*

 * do standard initialization of interface structure

 */

static inline void

init_interface(

  endpt *ep

  )

{

  ZERO(*ep);

  ep->fd = INVALID_SOCKET;

  ep->bfd = INVALID_SOCKET;

  ep->phase = sys_interphase;

}

/*

 * create new interface structure initialize from

 * template structure or via standard initialization

 * function

 */

static endpt *

new_interface(

  endpt *protot

  )

{

  endpt * iface;

  iface = emalloc(sizeof(*iface));

  if (NULL == protot) {

    ZERO(*iface);

  } else {

    memcpy(iface, protot, sizeof(*iface));

  }

  /* count every new instance of an interface in the system */

  iface->ifnum = sys_ifnum++;

  iface->starttime = current_time;

#   ifdef HAVE_IO_COMPLETION_PORT

  if (!io_completion_port_add_interface(iface)) {

    msyslog(LOG_EMERG, "cannot register interface with IO engine -- will exit now");

    exit(1);

  }

#   endif

  return iface;

}

/*

 * return interface storage into free memory pool

 */

static void

delete_interface(

  endpt *ep

  )

{

#    ifdef HAVE_IO_COMPLETION_PORT

  io_completion_port_remove_interface(ep);

#    endif

  free(ep);

}

/*

 * link interface into list of known interfaces

 */

static void

add_interface(

  endpt * ep

  )

{

  endpt **  pmclisthead;

  endpt *   scan;

  endpt *   scan_next;

  int   same_subnet;

  int   rc;

  /* Calculate the refid */

  ep->addr_refid = addr2refid(&ep->sin);

#    ifdef WORDS_BIGENDIAN

  if (IS_IPV6(&ep->sin)) {

    ep->old_refid = BYTESWAP32(ep->addr_refid);

  }

#    endif

  /* link at tail so ntpdc -c ifstats index increases each row */

  LINK_TAIL_SLIST(ep_list, ep, elink, endpt);

  ninterfaces++;

#ifdef MCAST

  /* the rest is for enabled multicast-capable addresses only */

  if (ep->ignore_packets || !(INT_MULTICAST & ep->flags) ||

      INT_LOOPBACK & ep->flags)

    return;

# ifndef INCLUDE_IPV6_MULTICAST_SUPPORT

  if (AF_INET6 == ep->family)

    return;

# endif

  pmclisthead = (AF_INET == ep->family)

       ? &mc4_list

       : &mc6_list;

  /*

   * If we have multiple global addresses from the same prefix

   * on the same network interface, multicast from one.

   */

  for (scan = *pmclisthead; scan != NULL; scan = scan_next) {

    scan_next = scan->mclink;

    if (   ep->family != scan->family

        || ep->ifindex != scan->ifindex) {

      continue;

    }

    same_subnet = addr_samesubnet(&ep->sin, &ep->mask,

                &scan->sin, &scan->mask);

    if (same_subnet) {

      DPRINTF(4, ("did not add %s to multicast-capable list"

            "which already has %s\n",

            stoa(&ep->sin), stoa(&scan->sin)));

      return;

    }

  }

  LINK_SLIST(*pmclisthead, ep, mclink);

  if (INVALID_SOCKET == ep->fd)

    return;

  /*

   * select the local address from which to send to multicast.

   */

  switch (AF(&ep->sin)) {

  case AF_INET :

    rc = setsockopt(ep->fd, IPPROTO_IP,

        IP_MULTICAST_IF,

        (void *)&NSRCADR(&ep->sin),

        sizeof(NSRCADR(&ep->sin)));

    if (rc)

      msyslog(LOG_ERR,

        "setsockopt IP_MULTICAST_IF %s fails: %m",

        stoa(&ep->sin));

    break;

# ifdef INCLUDE_IPV6_MULTICAST_SUPPORT

  case AF_INET6 :

    rc = setsockopt(ep->fd, IPPROTO_IPV6,

         IPV6_MULTICAST_IF,

         (void *)&ep->ifindex,

         sizeof(ep->ifindex));

    /* do not complain if bound addr scope is ifindex */

    if (rc && ep->ifindex != SCOPE(&ep->sin))

      msyslog(LOG_ERR,

        "setsockopt IPV6_MULTICAST_IF %u for %s fails: %m",

        ep->ifindex, stoa(&ep->sin));

    break;

# endif

  }

#endif  /* MCAST */

}

/*

 * remove interface from known interface list and clean up

 * associated resources

 */

static void

remove_interface(

  endpt * ep

  )

{

  endpt *   unlinked;

  endpt **  pmclisthead;

  sockaddr_u  resmask;

  int/*BOOL*/ success;

  UNLINK_SLIST(unlinked, ep_list, ep, elink, endpt);

  if (!ep->ignore_packets && INT_MULTICAST & ep->flags) {

    pmclisthead = (AF_INET == ep->family)

         ? &mc4_list

         : &mc6_list;

    UNLINK_SLIST(unlinked, *pmclisthead, ep, mclink, endpt);

    DPRINTF(4, ("%s %s IPv%s multicast-capable unicast local address list\n",

      stoa(&ep->sin),

      (unlinked != NULL)

          ? "removed from"

          : "not found on",

      (AF_INET == ep->family)

          ? "4"

          : "6"));

  }

  delete_interface_from_list(ep);

  if (ep->fd != INVALID_SOCKET) {

    msyslog(LOG_INFO,

      "Deleting %d %s, [%s]:%hd, stats:"

      " received=%ld, sent=%ld, dropped=%ld,"

      " active_time=%ld secs",

      ep->ifnum,

      ep->name,

      stoa(&ep->sin),

      SRCPORT(&ep->sin),

      ep->received,

      ep->sent,

      ep->notsent,

      current_time - ep->starttime);

    close_and_delete_fd_from_list(ep->fd, ep);

    ep->fd = INVALID_SOCKET;

  }

  if (ep->bfd != INVALID_SOCKET) {

    msyslog(LOG_INFO,

      "stop listening for broadcasts to %s on interface #%d %s",

      stoa(&ep->bcast), ep->ifnum, ep->name);

    close_and_delete_fd_from_list(ep->bfd, ep);

    ep->bfd = INVALID_SOCKET;

  }

#   ifdef HAVE_IO_COMPLETION_PORT

  io_completion_port_remove_interface(ep);

#   endif

  ninterfaces--;

  mon_clearinterface(ep);

  /* remove restrict interface entry */

  SET_HOSTMASK(&resmask, AF(&ep->sin));

  success = hack_restrict(RESTRICT_REMOVEIF, &ep->sin, &resmask, 0,

        RESM_NTPONLY | RESM_INTERFACE, 0, 0);

  if (!success) {

    msyslog(LOG_ERR,

      "unable to remove self-restriction for %s",

      stoa(&ep->sin));

  }

}

static void

log_listen_address(

  endpt * ep

  )

{

  msyslog(LOG_INFO, "%s on %d %s %s",

    (ep->ignore_packets)

        ? "Listen and drop"

        : "Listen normally",

    ep->ifnum,

    ep->name,

    sptoa(&ep->sin));

}

static void

create_wildcards(

  u_short port

  )

{

  int     v4wild;

#ifdef INCLUDE_IPV6_SUPPORT

  int     v6wild;

#endif

  sockaddr_u    wildaddr;

  nic_rule_action   action;

  endpt *     wildif;

  /*

   * silence "potentially uninitialized" warnings from VC9

   * failing to follow the logic.  Ideally action could remain

   * uninitialized, and the memset be the first statement under

   * the first if (v4wild).

   */

  action = ACTION_LISTEN;

  ZERO(wildaddr);

#ifdef INCLUDE_IPV6_SUPPORT

  /*

   * create pseudo-interface with wildcard IPv6 address

   */

  v6wild = ipv6_works;

  if (v6wild) {

    /* set wildaddr to the v6 wildcard address :: */

    ZERO(wildaddr);

    AF(&wildaddr) = AF_INET6;

    SET_ADDR6N(&wildaddr, in6addr_any);

    SET_PORT(&wildaddr, port);

    SET_SCOPE(&wildaddr, 0);

    /* check for interface/nic rules affecting the wildcard */

    action = interface_action(NULL, &wildaddr, 0);

    v6wild = (ACTION_IGNORE != action);

  }

  if (v6wild) {

    wildif = new_interface(NULL);

    strlcpy(wildif->name, "v6wildcard", sizeof(wildif->name));

    memcpy(&wildif->sin, &wildaddr, sizeof(wildif->sin));

    wildif->family = AF_INET6;

    AF(&wildif->mask) = AF_INET6;

    SET_ONESMASK(&wildif->mask);

    wildif->flags = INT_UP | INT_WILDCARD;

    wildif->ignore_packets = (ACTION_DROP == action);

    wildif->fd = open_socket(&wildif->sin, 0, 1, wildif);

    if (wildif->fd != INVALID_SOCKET) {

      wildipv6 = wildif;

      any6_interface = wildif;

      add_addr_to_list(&wildif->sin, wildif);

      add_interface(wildif);

      log_listen_address(wildif);