#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "ntp_machine.h"
#include "ntpd.h"
#include "ntp_io.h"
#include "iosignal.h"
#include "ntp_refclock.h"
#include "ntp_stdlib.h"
#include "ntp_request.h"
#include "ntp.h"
#include "ntp_unixtime.h"
#define ISC_IPV6_H 1
#include <isc/interfaceiter.h>
#include <isc/list.h>
#include <isc/result.h>
#ifdef SIM
#include "ntpsim.h"
#endif
#include <stdio.h>
#include <signal.h>
#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
# include <sys/sockio.h>
#endif
#ifdef HAVE_SYS_UIO_H
# include <sys/uio.h>
#endif
#include <net/if.h>
#include <netinet/in_var.h>
#include <netinet6/in6_var.h>
#ifndef SETSOCKOPT_ARG_CAST
#define SETSOCKOPT_ARG_CAST
#endif
#if defined(ISC_PLATFORM_HAVEIPV6) && !defined(DISABLE_IPV6)
#define INCLUDE_IPV6_SUPPORT
#if defined(INCLUDE_IPV6_SUPPORT) && defined(IPV6_JOIN_GROUP) && defined(IPV6_LEAVE_GROUP)
#define INCLUDE_IPV6_MULTICAST_SUPPORT
#endif
#endif
extern int listen_to_virtual_ips;
extern const char *specific_interface;
#if defined(SO_TIMESTAMP) && defined(SCM_TIMESTAMP)
#if defined(CMSG_FIRSTHDR)
#ifndef TIMESTAMP_CTLMSGBUF_SIZE
#define TIMESTAMP_CTLMSGBUF_SIZE 1536
#endif
#else
#endif
#endif
#if defined(SYS_WINNT)
#include <transmitbuff.h>
#include <isc/win32os.h>
#ifndef SIO_UDP_CONNRESET
#define SIO_UDP_CONNRESET _WSAIOW(IOC_VENDOR,12)
#endif
#endif
volatile u_long packets_dropped;
volatile u_long packets_ignored;
volatile u_long packets_received;
u_long packets_sent;
u_long packets_notsent;
volatile u_long handler_calls;
volatile u_long handler_pkts;
u_long io_timereset;
struct interface *any_interface;
struct interface *any6_interface;
struct interface *loopback_interface;
int ninterfaces;
volatile int disable_dynamic_updates;
#ifdef REFCLOCK
static struct refclockio *refio;
#endif
#define SOFT_ERROR(e) ((e) == EAGAIN || \
(e) == EWOULDBLOCK || \
(e) == EINTR || \
(e) == 0)
fd_set activefds;
int maxactivefd;
static u_char sys_interphase = 0;
static struct interface *new_interface P((struct interface *));
static void add_interface P((struct interface *));
static void update_interfaces P((u_short, interface_receiver_t, void *));
static void remove_interface P((struct interface *));
static struct interface *create_interface P((u_short, struct interface *));
static int move_fd P((SOCKET));
static isc_boolean_t addr_ismulticast P((struct sockaddr_storage *));
#ifdef MCAST
static isc_boolean_t socket_multicast_enable P((struct interface *, int, struct sockaddr_storage *));
static isc_boolean_t socket_multicast_disable P((struct interface *, struct sockaddr_storage *));
#endif
#ifdef DEBUG
static void print_interface P((struct interface *, char *, char *));
#define DPRINT_INTERFACE(_LVL_, _ARGS_) do { if (debug >= (_LVL_)) { print_interface _ARGS_; } } while (0)
#else
#define DPRINT_INTERFACE(_LVL_, _ARGS_)
#endif
typedef struct vsock vsock_t;
enum desc_type { FD_TYPE_SOCKET, FD_TYPE_FILE };
struct vsock {
SOCKET fd;
enum desc_type type;
ISC_LINK(vsock_t) link;
};
#if !defined(HAVE_IO_COMPLETION_PORT) && defined(HAS_ROUTING_SOCKET)
struct asyncio_reader {
SOCKET fd;
void *data;
void (*receiver)(struct asyncio_reader *);
ISC_LINK(struct asyncio_reader) link;
};
ISC_LIST(struct asyncio_reader) asyncio_reader_list;
static void delete_asyncio_reader P((struct asyncio_reader *));
static struct asyncio_reader *new_asyncio_reader P((void));
static void add_asyncio_reader P((struct asyncio_reader *, enum desc_type));
static void remove_asyncio_reader P((struct asyncio_reader *));
#endif
static void init_async_notifications P((void));
static int create_sockets P((u_short));
static SOCKET open_socket P((struct sockaddr_storage *, int, int, struct interface *));
static char * fdbits P((int, fd_set *));
static void set_reuseaddr P((int));
static isc_boolean_t socket_broadcast_enable P((struct interface *, SOCKET, struct sockaddr_storage *));
static isc_boolean_t socket_broadcast_disable P((struct interface *, struct sockaddr_storage *));
ISC_LIST(vsock_t) fd_list;
typedef struct remaddr remaddr_t;
struct remaddr {
struct sockaddr_storage addr;
struct interface *interface;
ISC_LINK(remaddr_t) link;
};
ISC_LIST(remaddr_t) remoteaddr_list;
ISC_LIST(struct interface) inter_list;
static struct interface *wildipv4 = NULL;
static struct interface *wildipv6 = NULL;
static void add_fd_to_list P((SOCKET, enum desc_type));
static void close_and_delete_fd_from_list P((SOCKET));
static void add_addr_to_list P((struct sockaddr_storage *, struct interface *));
static void delete_addr_from_list P((struct sockaddr_storage *));
static struct interface *find_addr_in_list P((struct sockaddr_storage *));
static struct interface *find_flagged_addr_in_list P((struct sockaddr_storage *, int));
static void create_wildcards P((u_short));
static isc_boolean_t address_okay P((struct interface *));
static void convert_isc_if P((isc_interface_t *, struct interface *, u_short));
static void delete_interface_from_list P((struct interface *));
static struct interface *getinterface P((struct sockaddr_storage *, int));
static struct interface *findlocalinterface P((struct sockaddr_storage *, int));
static struct interface *findlocalcastinterface P((struct sockaddr_storage *, int));
#if !defined(HAVE_IO_COMPLETION_PORT)
static inline int read_network_packet P((SOCKET, struct interface *, l_fp));
static inline int read_refclock_packet P((SOCKET, struct refclockio *, l_fp));
#endif
#ifdef SYS_WINNT
isc_result_t
connection_reset_fix(SOCKET fd) {
DWORD dwBytesReturned = 0;
BOOL bNewBehavior = FALSE;
DWORD status;
if(isc_win32os_majorversion() < 5)
return (ISC_R_SUCCESS);
status = WSAIoctl(fd, SIO_UDP_CONNRESET, &bNewBehavior,
sizeof(bNewBehavior), NULL, 0,
&dwBytesReturned, NULL, NULL);
if (status != SOCKET_ERROR)
return (ISC_R_SUCCESS);
else
return (ISC_R_UNEXPECTED);
}
#endif
static int move_fd(SOCKET fd)
{
#if !defined(SYS_WINNT) && defined(F_DUPFD)
#ifndef FD_CHUNK
#define FD_CHUNK 10
#endif
#ifndef FD_PREFERRED_SOCKBOUNDARY
#define FD_PREFERRED_SOCKBOUNDARY 48
#endif
#ifndef HAVE_GETDTABLESIZE
#define getdtablesize() (FOPEN_MAX+FD_CHUNK)
#endif
#ifndef FOPEN_MAX
#define FOPEN_MAX 20
#endif
static SOCKET socket_boundary = -1;
SOCKET newfd;
if (socket_boundary == -1) {
socket_boundary = max(0, min(getdtablesize() - FD_CHUNK,
min(FOPEN_MAX, FD_PREFERRED_SOCKBOUNDARY)));
#ifdef DEBUG
msyslog(LOG_DEBUG, "ntp_io: estimated max descriptors: %d, initial socket boundary: %d",
getdtablesize(), socket_boundary);
#endif
}
do {
if (fd >= 0 && fd < socket_boundary) {
newfd = fcntl(fd, F_DUPFD, socket_boundary);
if (newfd != -1) {
(void)close(fd);
return (newfd);
}
} else {
return (fd);
}
socket_boundary = max(0, socket_boundary - FD_CHUNK);
#ifdef DEBUG
msyslog(LOG_DEBUG, "ntp_io: selecting new socket boundary: %d",
socket_boundary);
#endif
} while (socket_boundary > 0);
#endif
return (fd);
}
#ifdef DEBUG_TIMING
void
collect_timing(struct recvbuf *rb, const char *tag, int count, l_fp *dts)
{
char buf[2048];
snprintf(buf, sizeof(buf), "%s %d %s %s",
(rb != NULL) ?
((rb->dstadr) ? stoa(&rb->recv_srcadr) : "-REFCLOCK-") : "-",
count, lfptoa(dts, 9), tag);
record_timing_stats(buf);
}
#endif
void
init_io(void)
{
#ifdef SYS_WINNT
if (!Win32InitSockets())
{
netsyslog(LOG_ERR, "No useable winsock.dll: %m");
exit(1);
}
init_transmitbuff();
#endif
init_recvbuff(RECV_INIT);
packets_dropped = packets_received = 0;
packets_ignored = 0;
packets_sent = packets_notsent = 0;
handler_calls = handler_pkts = 0;
io_timereset = 0;
loopback_interface = NULL;
any_interface = NULL;
any6_interface = NULL;
#ifdef REFCLOCK
refio = NULL;
#endif
#if defined(HAVE_SIGNALED_IO)
(void) set_signal();
#endif
ISC_LIST_INIT(fd_list);
#if !defined(HAVE_IO_COMPLETION_PORT) && defined(HAS_ROUTING_SOCKET)
ISC_LIST_INIT(asyncio_reader_list);
#endif
ISC_LIST_INIT(remoteaddr_list);
ISC_LIST_INIT(inter_list);
BLOCKIO();
(void) create_sockets(htons(NTP_PORT));
UNBLOCKIO();
init_async_notifications();
DPRINTF(3, ("init_io: maxactivefd %d\n", maxactivefd));
}
#ifdef DEBUG
void
interface_dump(struct interface *itf)
{
u_char* cp;
int i;
int maxsize = min(32, sizeof(struct sockaddr_storage));
printf("Dumping interface: %p\n", itf);
printf("fd = %d\n", itf->fd);
printf("bfd = %d\n", itf->bfd);
printf("sin = %s,\n", stoa(&(itf->sin)));
cp = (u_char*) &(itf->sin);
for(i = 0; i < maxsize; i++)
{
printf("%02x", *cp++);
if((i+1)%4 == 0)
printf(" ");
}
printf("\n");
printf("bcast = %s,\n", stoa(&(itf->bcast)));
cp = (u_char*) &(itf->bcast);
for(i = 0; i < maxsize; i++)
{
printf("%02x", *cp++);
if((i+1)%4 == 0)
printf(" ");
}
printf("\n");
printf("mask = %s,\n", stoa(&(itf->mask)));
cp = (u_char*) &(itf->mask);
for(i = 0; i < maxsize; i++)
{
printf("%02x", *cp++);
if((i+1)%4 == 0)
printf(" ");
}
printf("\n");
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("scopeid = %u\n", itf->scopeid);
printf("peercnt = %u\n", itf->peercnt);
printf("phase = %u\n", itf->phase);
}
static void
print_interface(struct interface *iface, char *pfx, char *sfx)
{
printf("%sinterface #%d: fd=%d, bfd=%d, name=%s, flags=0x%x, scope=%d, ifindex=%d",
pfx,
iface->ifnum,
iface->fd,
iface->bfd,
iface->name,
iface->flags,
iface->scopeid,
iface->ifindex);
printf(", sin=%s",
stoa((&iface->sin)));
if (iface->flags & INT_BROADCAST)
printf(", bcast=%s,",
stoa((&iface->bcast)));
if (iface->family == AF_INET)
printf(", mask=%s",
stoa((&iface->mask)));
printf(", %s:%s", iface->ignore_packets == ISC_FALSE ? "Enabled" : "Disabled", sfx);
if (debug > 4)
interface_dump(iface);
}
#endif
#if !defined(HAVE_IO_COMPLETION_PORT) && defined(HAS_ROUTING_SOCKET)
static struct asyncio_reader *
new_asyncio_reader()
{
struct asyncio_reader *reader;
reader = (struct asyncio_reader *)emalloc(sizeof(struct asyncio_reader));
memset((char *)reader, 0, sizeof(*reader));
ISC_LINK_INIT(reader, link);
reader->fd = INVALID_SOCKET;
return reader;
}
static void
delete_asyncio_reader(struct asyncio_reader *reader)
{
free(reader);
}
static void
add_asyncio_reader(struct asyncio_reader *reader, enum desc_type type)
{
ISC_LIST_APPEND(asyncio_reader_list, reader, link);
add_fd_to_list(reader->fd, type);
}
static void
remove_asyncio_reader(struct asyncio_reader *reader)
{
ISC_LIST_UNLINK_TYPE(asyncio_reader_list, reader, link, struct asyncio_reader);
if (reader->fd != INVALID_SOCKET)
close_and_delete_fd_from_list(reader->fd);
reader->fd = INVALID_SOCKET;
}
#endif
void
interface_enumerate(interface_receiver_t receiver, void *data)
{
interface_info_t ifi;
struct interface *interf;
ifi.action = IFS_EXISTS;
for (interf = ISC_LIST_HEAD(inter_list);
interf != NULL;
interf = ISC_LIST_NEXT(interf, link)) {
ifi.interface = interf;
receiver(data, &ifi);
}
}
static void
init_interface(struct interface *interface)
{
memset((char *)interface, 0, sizeof(struct interface));
ISC_LINK_INIT(interface, link);
ISC_LIST_INIT(interface->peers);
interface->fd = INVALID_SOCKET;
interface->bfd = INVALID_SOCKET;
interface->num_mcast = 0;
interface->received = 0;
interface->sent = 0;
interface->notsent = 0;
interface->peercnt = 0;
interface->phase = sys_interphase;
}
static struct interface *
new_interface(struct interface *interface)
{
static u_int sys_ifnum = 0;
struct interface *iface = (struct interface *)emalloc(sizeof(struct interface));
if (interface != NULL)
{
memcpy((char*)iface, (char*)interface, sizeof(*interface));
}
else
{
init_interface(iface);
}
iface->ifnum = sys_ifnum++;
iface->starttime = current_time;
return iface;
}
static void
delete_interface(struct interface *interface)
{
free(interface);
}
static void
add_interface(struct interface *interface)
{
interface->addr_refid = addr2refid(&interface->sin);
ISC_LIST_APPEND(inter_list, interface, link);
ninterfaces++;
}
static void
remove_interface(struct interface *interface)
{
struct sockaddr_storage resmask;
ISC_LIST_UNLINK_TYPE(inter_list, interface, link, struct interface);
delete_interface_from_list(interface);
if (interface->fd != INVALID_SOCKET)
{
msyslog(LOG_INFO, "Deleting interface #%d %s, %s#%d, interface stats: received=%ld, sent=%ld, dropped=%ld, active_time=%ld secs",
interface->ifnum,
interface->name,
stoa((&interface->sin)),
NTP_PORT,
interface->received,
interface->sent,
interface->notsent,
current_time - interface->starttime);
close_and_delete_fd_from_list(interface->fd);
}
if (interface->bfd != INVALID_SOCKET)
{
msyslog(LOG_INFO, "Deleting interface #%d %s, broadcast address %s#%d",
interface->ifnum,
interface->name,
stoa((&interface->bcast)),
(u_short) NTP_PORT);
close_and_delete_fd_from_list(interface->bfd);
}
ninterfaces--;
ntp_monclearinterface(interface);
SET_HOSTMASK(&resmask, interface->sin.ss_family);
hack_restrict(RESTRICT_REMOVEIF, &interface->sin, &resmask,
RESM_NTPONLY|RESM_INTERFACE, RES_IGNORE);
}
static void
list_if_listening(struct interface *interface, u_short port)
{
if (awoke()) {
awake_timer = current_time;
}
msyslog(LOG_INFO, "Listening on interface #%d %s, %s#%d %s",
interface->ifnum,
interface->name,
stoa((&interface->sin)),
ntohs( (u_short) port),
(interface->ignore_packets == ISC_FALSE) ?
"Enabled": "Disabled");
}
static void
create_wildcards(u_short port) {
isc_boolean_t okipv4 = ISC_TRUE;
#ifdef IPV6_V6ONLY
if(isc_net_probeipv4() != ISC_R_SUCCESS)
okipv4 = ISC_FALSE;
#endif
if(okipv4 == ISC_TRUE) {
struct interface *interface = new_interface(NULL);
interface->family = AF_INET;
interface->sin.ss_family = AF_INET;
((struct sockaddr_in*)&interface->sin)->sin_addr.s_addr = htonl(INADDR_ANY);
((struct sockaddr_in*)&interface->sin)->sin_port = port;
(void) strncpy(interface->name, "wildcard", sizeof(interface->name));
interface->mask.ss_family = AF_INET;
((struct sockaddr_in*)&interface->mask)->sin_addr.s_addr = htonl(~(u_int32)0);
interface->flags = INT_BROADCAST | INT_UP | INT_WILDCARD;
interface->ignore_packets = ISC_TRUE;
#if defined(MCAST)
interface->bcast.ss_family = AF_INET;
((struct sockaddr_in*)&interface->bcast)->sin_port = port;
((struct sockaddr_in*)&interface->bcast)->sin_addr.s_addr = htonl(INADDR_ANY);
#endif
interface->fd = open_socket(&interface->sin,
interface->flags, 1, interface);
if (interface->fd != INVALID_SOCKET) {
wildipv4 = interface;
any_interface = interface;
add_addr_to_list(&interface->sin, interface);
add_interface(interface);
list_if_listening(interface, port);
} else {
msyslog(LOG_ERR, "unable to bind to wildcard socket address %s - another process may be running - EXITING",
stoa((&interface->sin)));
exit(1);
}
}
#ifdef INCLUDE_IPV6_SUPPORT
if (isc_net_probeipv6() == ISC_R_SUCCESS) {
struct interface *interface = new_interface(NULL);
interface->family = AF_INET6;
interface->sin.ss_family = AF_INET6;
((struct sockaddr_in6*)&interface->sin)->sin6_addr = in6addr_any;
((struct sockaddr_in6*)&interface->sin)->sin6_port = port;
# ifdef ISC_PLATFORM_HAVESCOPEID
((struct sockaddr_in6*)&interface->sin)->sin6_scope_id = 0;
# endif
(void) strncpy(interface->name, "wildcard", sizeof(interface->name));
interface->mask.ss_family = AF_INET6;
memset(&((struct sockaddr_in6*)&interface->mask)->sin6_addr.s6_addr, 0xff, sizeof(struct in6_addr));
interface->flags = INT_UP | INT_WILDCARD;
interface->ignore_packets = ISC_TRUE;
interface->fd = open_socket(&interface->sin,
interface->flags, 1, interface);
if (interface->fd != INVALID_SOCKET) {
wildipv6 = interface;
any6_interface = interface;
add_addr_to_list(&interface->sin, interface);
add_interface(interface);
list_if_listening(interface, port);
} else {
msyslog(LOG_ERR, "unable to bind to wildcard socket address %s - another process may be running - EXITING",
stoa((&interface->sin)));
exit(1);
}
}
#endif
}
static isc_boolean_t
address_okay(struct interface *iface) {
DPRINTF(4, ("address_okay: listen Virtual: %d, IF name: %s\n",
listen_to_virtual_ips, iface->name));
if((iface->flags & INT_LOOPBACK) != 0) {
DPRINTF(4, ("address_okay: loopback - OK\n"));
return (ISC_TRUE);
}
if (specific_interface != NULL) {
if (strcasecmp(iface->name, specific_interface) == 0) {
DPRINTF(4, ("address_okay: specific interface name matched - OK\n"));
return (ISC_TRUE);
} else {
DPRINTF(4, ("address_okay: specific interface name NOT matched - FAIL\n"));
return (ISC_FALSE);
}
}
else {
if (listen_to_virtual_ips == 0 &&
(strchr(iface->name, (int)':') != NULL)) {
DPRINTF(4, ("address_okay: virtual ip/alias - FAIL\n"));
return (ISC_FALSE);
}
}
DPRINTF(4, ("address_okay: OK\n"));
return (ISC_TRUE);
}
static void
convert_isc_if(isc_interface_t *isc_if, struct interface *itf, u_short port)
{
itf->scopeid = 0;
itf->family = (short) isc_if->af;
strcpy(itf->name, isc_if->name);
if(isc_if->af == AF_INET) {
itf->sin.ss_family = (u_short) isc_if->af;
memcpy(&(((struct sockaddr_in*)&itf->sin)->sin_addr),
&(isc_if->address.type.in),
sizeof(struct in_addr));
((struct sockaddr_in*)&itf->sin)->sin_port = port;
if((isc_if->flags & INTERFACE_F_BROADCAST) != 0) {
itf->flags |= INT_BROADCAST;
itf->bcast.ss_family = itf->sin.ss_family;
memcpy(&(((struct sockaddr_in*)&itf->bcast)->sin_addr),
&(isc_if->broadcast.type.in),
sizeof(struct in_addr));
((struct sockaddr_in*)&itf->bcast)->sin_port = port;
}
itf->mask.ss_family = itf->sin.ss_family;
memcpy(&(((struct sockaddr_in*)&itf->mask)->sin_addr),
&(isc_if->netmask.type.in),
sizeof(struct in_addr));
((struct sockaddr_in*)&itf->mask)->sin_port = port;
}
#ifdef INCLUDE_IPV6_SUPPORT
else if (isc_if->af == AF_INET6) {
itf->sin.ss_family = (u_short) isc_if->af;
memcpy(&(((struct sockaddr_in6 *)&itf->sin)->sin6_addr),
&(isc_if->address.type.in6),
sizeof(((struct sockaddr_in6 *)&itf->sin)->sin6_addr));
((struct sockaddr_in6 *)&itf->sin)->sin6_port = port;
#ifdef ISC_PLATFORM_HAVESCOPEID
((struct sockaddr_in6 *)&itf->sin)->sin6_scope_id = isc_netaddr_getzone(&isc_if->address);
itf->scopeid = isc_netaddr_getzone(&isc_if->address);
#endif
itf->mask.ss_family = itf->sin.ss_family;
memcpy(&(((struct sockaddr_in6 *)&itf->mask)->sin6_addr),
&(isc_if->netmask.type.in6),
sizeof(struct in6_addr));
((struct sockaddr_in6 *)&itf->mask)->sin6_port = port;
itf->ifindex = isc_if->ifindex;
}
#endif
if((isc_if->flags & INTERFACE_F_UP) != 0)
itf->flags |= INT_UP;
if((isc_if->flags & INTERFACE_F_LOOPBACK) != 0)
itf->flags |= INT_LOOPBACK;
if((isc_if->flags & INTERFACE_F_POINTTOPOINT) != 0)
itf->flags |= INT_PPP;
if((isc_if->flags & INTERFACE_F_MULTICAST) != 0)
itf->flags |= INT_MULTICAST;
}
static int
refresh_interface(struct interface * interface)
{
#ifdef OS_MISSES_SPECIFIC_ROUTE_UPDATES
if (interface->fd != INVALID_SOCKET)
{
close_and_delete_fd_from_list(interface->fd);
interface->fd = open_socket(&interface->sin,
interface->flags, 0, interface);
interface->last_ttl = 0;
return interface->fd != INVALID_SOCKET;
}
else
{
return 0;
}
#else
return interface->fd != INVALID_SOCKET;
#endif
}
void
interface_update(interface_receiver_t receiver, void *data)
{
if (!disable_dynamic_updates) {
BLOCKIO();
update_interfaces(htons(NTP_PORT), receiver, data);
UNBLOCKIO();
}
}
static int
is_wildcard_addr(struct sockaddr_storage *sas)
{
if (sas->ss_family == AF_INET &&
((struct sockaddr_in*)sas)->sin_addr.s_addr == htonl(INADDR_ANY))
return 1;
#ifdef INCLUDE_IPV6_SUPPORT
if (sas->ss_family == AF_INET6 &&
memcmp(&((struct sockaddr_in6*)sas)->sin6_addr, &in6addr_any,
sizeof(in6addr_any) == 0))
return 1;
#endif
return 0;
}
#ifdef OS_NEEDS_REUSEADDR_FOR_IFADDRBIND
static void
set_wildcard_reuse(int family, int on)
{
int onvalue = 1;
int offvalue = 0;
int *onoff;
SOCKET fd = INVALID_SOCKET;
onoff = on ? &onvalue : &offvalue;
switch (family) {
case AF_INET:
if (any_interface) {
fd = any_interface->fd;
}
break;
#ifdef INCLUDE_IPV6_SUPPORT
case AF_INET6:
if (any6_interface) {
fd = any6_interface->fd;
}
break;
#endif
}
if (fd != INVALID_SOCKET) {
if (setsockopt(fd, SOL_SOCKET,
SO_REUSEADDR, (char *)onoff,
sizeof(*onoff))) {
netsyslog(LOG_ERR, "set_wildcard_reuse: setsockopt(SO_REUSEADDR, %s) failed: %m", *onoff ? "on" : "off");
}
DPRINTF(4, ("set SO_REUSEADDR to %s on %s\n", *onoff ? "ON" : "OFF",
stoa((family == AF_INET) ?
&any_interface->sin : &any6_interface->sin)));
}
}
#endif
static void
update_interfaces(
u_short port,
interface_receiver_t receiver,
void *data
)
{
interface_info_t ifi;
isc_mem_t *mctx = NULL;
isc_interfaceiter_t *iter = NULL;
isc_boolean_t scan_ipv4 = ISC_FALSE;
isc_boolean_t scan_ipv6 = ISC_FALSE;
isc_result_t result;
DPRINTF(3, ("update_interfaces(%d)\n", ntohs( (u_short) port)));
#ifdef INCLUDE_IPV6_SUPPORT
if (isc_net_probeipv6() == ISC_R_SUCCESS)
scan_ipv6 = ISC_TRUE;
#if defined(DEBUG)
else
if(debug)
netsyslog(LOG_ERR, "no IPv6 interfaces found");
#endif
#endif
if (isc_net_probeipv6() == ISC_R_SUCCESS)
scan_ipv6 = ISC_TRUE;
#if defined(ISC_PLATFORM_HAVEIPV6) && defined(DEBUG)
else
if(debug)
netsyslog(LOG_ERR, "no IPv6 interfaces found");
#endif
if (isc_net_probeipv4() == ISC_R_SUCCESS)
scan_ipv4 = ISC_TRUE;
#ifdef DEBUG
else
if(debug)
netsyslog(LOG_ERR, "no IPv4 interfaces found");
#endif
result = isc_interfaceiter_create(mctx, &iter);
if (result != ISC_R_SUCCESS)
return;
sys_interphase ^= 0x1;
for (result = isc_interfaceiter_first(iter);
result == ISC_R_SUCCESS;
result = isc_interfaceiter_next(iter))
{
isc_interface_t isc_if;
unsigned int family;
struct interface interface;
struct interface *iface;
result = isc_interfaceiter_current(iter, &isc_if);
if (result != ISC_R_SUCCESS)
break;
family = isc_if.address.family;
if (family != AF_INET && family != AF_INET6)
continue;
if (scan_ipv4 == ISC_FALSE && family == AF_INET)
continue;
if (scan_ipv6 == ISC_FALSE && family == AF_INET6)
continue;
init_interface(&interface);
convert_isc_if(&isc_if, &interface, port);
if (address_okay(&interface) == ISC_TRUE) {
interface.ignore_packets = ISC_FALSE;
}
else {
interface.ignore_packets = ISC_TRUE;
}
DPRINT_INTERFACE(4, (&interface, "examining ", "\n"));
if (!(interface.flags & INT_UP)) {
DPRINTF(4, ("skipping interface %s (%s) - DOWN\n", interface.name, stoa(&interface.sin)));
continue;
}
if (is_wildcard_addr(&interface.sin))
continue;
iface = getinterface(&interface.sin, INT_WILDCARD);
if (iface && refresh_interface(iface))
{
iface->phase = sys_interphase;
DPRINT_INTERFACE(4, (iface, "updating ", " present\n"));
ifi.action = IFS_EXISTS;
ifi.interface = iface;
if (receiver)
receiver(data, &ifi);
}
else
{
iface = create_interface(port, &interface);
if (iface)
{
ifi.action = IFS_CREATED;
ifi.interface = iface;
if (receiver)
receiver(data, &ifi);
DPRINT_INTERFACE(3, (iface, "updating ", " new - created\n"));
}
else
{
DPRINT_INTERFACE(3, (&interface, "updating ", " new - creation FAILED"));
msyslog(LOG_INFO, "failed to initialize interface for address %s", stoa(&interface.sin));
continue;
}
}
}
isc_interfaceiter_destroy(&iter);
{
struct interface *interf = ISC_LIST_HEAD(inter_list);
while (interf != NULL)
{
struct interface *next = ISC_LIST_NEXT(interf, link);
if (!(interf->flags & (INT_WILDCARD|INT_MCASTIF))) {
if (interf->phase != sys_interphase) {
struct peer *peer;
DPRINT_INTERFACE(3, (interf, "updating ", "GONE - deleting\n"));
remove_interface(interf);
ifi.action = IFS_DELETED;
ifi.interface = interf;
if (receiver)
receiver(data, &ifi);
peer = ISC_LIST_HEAD(interf->peers);
while (peer != NULL) {
struct peer *npeer = ISC_LIST_NEXT(peer, ilink);
set_peerdstadr(peer, NULL);
peer = npeer;
}
if (interf == loopback_interface)
loopback_interface = NULL;
delete_interface(interf);
}
}
interf = next;
}
}
refresh_all_peerinterfaces();
}
static int
create_sockets(
u_short port
)
{
#ifndef HAVE_IO_COMPLETION_PORT
maxactivefd = 0;
FD_ZERO(&activefds);
#endif
DPRINTF(2, ("create_sockets(%d)\n", ntohs( (u_short) port)));
create_wildcards(port);
update_interfaces(port, NULL, NULL);
set_reuseaddr(0);
DPRINTF(2, ("create_sockets: Total interfaces = %d\n", ninterfaces));
return ninterfaces;
}
static struct interface *
create_interface(
u_short port,
struct interface *iface
)
{
struct sockaddr_storage resmask;
struct interface *interface;
DPRINTF(2, ("create_interface(%s#%d)\n", stoa(&iface->sin), ntohs( (u_short) port)));
interface = new_interface(iface);
interface->fd = open_socket(&interface->sin,
interface->flags, 0, interface);
if (interface->fd != INVALID_SOCKET)
list_if_listening(interface, port);
if ((interface->flags & INT_BROADCAST) &&
interface->bfd != INVALID_SOCKET)
msyslog(LOG_INFO, "Listening on broadcast address %s#%d",
stoa((&interface->bcast)),
ntohs( (u_short) port));
if (interface->fd == INVALID_SOCKET &&
interface->bfd == INVALID_SOCKET) {
msyslog(LOG_ERR, "unable to create socket on %s (%d) for %s#%d",
interface->name,
interface->ifnum,
stoa((&interface->sin)),
ntohs( (u_short) port));
delete_interface(interface);
return NULL;
}
SET_HOSTMASK(&resmask, interface->sin.ss_family);
hack_restrict(RESTRICT_FLAGS, &interface->sin, &resmask,
RESM_NTPONLY|RESM_INTERFACE, RES_IGNORE);
if ((loopback_interface == NULL) &&
(interface->family == AF_INET) &&
((interface->flags & INT_LOOPBACK) != 0))
{
loopback_interface = interface;
}
add_addr_to_list(&interface->sin, interface);
add_interface(interface);
DPRINT_INTERFACE(2, (interface, "created ", "\n"));
return interface;
}
static void
set_reuseaddr(int flag) {
struct interface *interf;
for (interf = ISC_LIST_HEAD(inter_list);
interf != NULL;
interf = ISC_LIST_NEXT(interf, link)) {
if (interf->flags & INT_WILDCARD)
continue;
DPRINTF(4, ("setting SO_REUSEADDR on %.16s@%s to %s\n", interf->name, stoa(&interf->sin), flag ? "on" : "off"));
if (interf->fd != INVALID_SOCKET) {
if (setsockopt(interf->fd, SOL_SOCKET,
SO_REUSEADDR, (char *)&flag,
sizeof(flag))) {
netsyslog(LOG_ERR, "set_reuseaddr: setsockopt(SO_REUSEADDR, %s) failed: %m", flag ? "on" : "off");
}
}
}
}
void
enable_broadcast(struct interface *iface, struct sockaddr_storage *baddr)
{
#ifdef SO_BROADCAST
socket_broadcast_enable(iface, iface->fd, baddr);
#endif
}
#ifdef OPEN_BCAST_SOCKET
static isc_boolean_t
socket_broadcast_enable(struct interface *iface, SOCKET fd, struct sockaddr_storage *maddr)
{
#ifdef SO_BROADCAST
int on = 1;
if (maddr->ss_family == AF_INET)
{
if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST,
(char *)&on, sizeof(on)))
{
netsyslog(LOG_ERR, "setsockopt(SO_BROADCAST) enable failure on address %s: %m",
stoa(maddr));
}
#ifdef DEBUG
else if (debug > 1) {
printf("Broadcast enabled on socket %d for address %s\n",
fd, stoa(maddr));
}
#endif
}
iface->flags |= INT_BCASTOPEN;
return ISC_TRUE;
#else
return ISC_FALSE;
#endif
}
static isc_boolean_t
socket_broadcast_disable(struct interface *iface, struct sockaddr_storage *maddr)
{
#ifdef SO_BROADCAST
int off = 0;
if (maddr->ss_family == AF_INET)
{
if (setsockopt(iface->fd, SOL_SOCKET, SO_BROADCAST,
(char *)&off, sizeof(off)))
{
netsyslog(LOG_ERR, "setsockopt(SO_BROADCAST) disable failure on address %s: %m",
stoa(maddr));
}
}
iface->flags &= ~INT_BCASTOPEN;
return ISC_TRUE;
#else
return ISC_FALSE;
#endif
}
#endif
static isc_boolean_t
addr_ismulticast(struct sockaddr_storage *maddr)
{
switch (maddr->ss_family)
{
case AF_INET :
if (!IN_CLASSD(ntohl(((struct sockaddr_in*)maddr)->sin_addr.s_addr))) {
DPRINTF(4, ("multicast address %s not class D\n", stoa(maddr)));
return (ISC_FALSE);
}
else
{
return (ISC_TRUE);
}
case AF_INET6 :
#ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
if (!IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6*)maddr)->sin6_addr)) {
DPRINTF(4, ("address %s not IPv6 multicast address\n", stoa(maddr)));
return (ISC_FALSE);
}
else
{
return (ISC_TRUE);
}
#else
return (ISC_FALSE);
#endif
default:
return (ISC_FALSE);
}
}
void
enable_multicast_if(struct interface *iface, struct sockaddr_storage *maddr)
{
#ifdef MCAST
TYPEOF_IP_MULTICAST_LOOP off = 0;
switch (maddr->ss_family)
{
case AF_INET:
if (setsockopt(iface->fd, IPPROTO_IP, IP_MULTICAST_IF,
(char *)&(((struct sockaddr_in*)&iface->sin)->sin_addr.s_addr),
sizeof(struct in_addr)) == -1) {
netsyslog(LOG_ERR,
"setsockopt IP_MULTICAST_IF failure: %m on socket %d, addr %s for multicast address %s",
iface->fd, stoa(&iface->sin), stoa(maddr));
return;
}
#ifdef IP_MULTICAST_LOOP
if (setsockopt(iface->fd, IPPROTO_IP, IP_MULTICAST_LOOP,
SETSOCKOPT_ARG_CAST &off, sizeof(off)) == -1) {
netsyslog(LOG_ERR,
"setsockopt IP_MULTICAST_LOOP failure: %m on socket %d, addr %s for multicast address %s",
iface->fd, stoa(&iface->sin), stoa(maddr));
}
#endif
DPRINTF(4, ("Added IPv4 multicast interface on socket %d, addr %s for multicast address %s\n",
iface->fd, stoa(&iface->sin),
stoa(maddr)));
break;
case AF_INET6:
#ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
if (setsockopt(iface->fd, IPPROTO_IPV6, IPV6_MULTICAST_IF,
&iface->scopeid, sizeof(iface->scopeid)) == -1) {
netsyslog(LOG_ERR,
"setsockopt IPV6_MULTICAST_IF failure: %m on socket %d, addr %s, scope %d for multicast address %s",
iface->fd, stoa(&iface->sin), iface->scopeid,
stoa(maddr));
return;
}
#ifdef IPV6_MULTICAST_LOOP
if (setsockopt(iface->fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
&off, sizeof(off)) == -1) {
netsyslog(LOG_ERR,
"setsockopt IP_MULTICAST_LOOP failure: %m on socket %d, addr %s for multicast address %s",
iface->fd, stoa(&iface->sin), stoa(maddr));
}
#endif
DPRINTF(4, ("Added IPv6 multicast interface on socket %d, addr %s, scope %d for multicast address %s\n",
iface->fd, stoa(&iface->sin), iface->scopeid,
stoa(maddr)));
break;
#else
return;
#endif
}
return;
#endif
}
static isc_boolean_t
socket_multicast_enable(struct interface *iface, int lscope, struct sockaddr_storage *maddr)
{
#ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
struct ipv6_mreq mreq6;
struct in6_addr iaddr6;
#endif
struct ip_mreq mreq;
if (find_addr_in_list(maddr)) {
DPRINTF(4, ("socket_multicast_enable(%s): already enabled\n", stoa(maddr)));
return ISC_TRUE;
}
switch (maddr->ss_family)
{
case AF_INET:
memset((char *)&mreq, 0, sizeof(mreq));
mreq.imr_multiaddr = (((struct sockaddr_in*)maddr)->sin_addr);
mreq.imr_interface.s_addr = htonl(INADDR_ANY);
if (setsockopt(iface->fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
(char *)&mreq, sizeof(mreq)) == -1) {
netsyslog(LOG_ERR,
"setsockopt IP_ADD_MEMBERSHIP failure: %m on socket %d, addr %s for %x / %x (%s)",
iface->fd, stoa(&iface->sin),
mreq.imr_multiaddr.s_addr,
mreq.imr_interface.s_addr, stoa(maddr));
return ISC_FALSE;
}
DPRINTF(4, ("Added IPv4 multicast membership on socket %d, addr %s for %x / %x (%s)\n",
iface->fd, stoa(&iface->sin),
mreq.imr_multiaddr.s_addr,
mreq.imr_interface.s_addr, stoa(maddr)));
break;
case AF_INET6:
#ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
memset((char *)&mreq6, 0, sizeof(mreq6));
iaddr6 = ((struct sockaddr_in6*)maddr)->sin6_addr;
mreq6.ipv6mr_multiaddr = iaddr6;
mreq6.ipv6mr_interface = lscope;
if (setsockopt(iface->fd, IPPROTO_IPV6, IPV6_JOIN_GROUP,
(char *)&mreq6, sizeof(mreq6)) == -1) {
netsyslog(LOG_ERR,
"setsockopt IPV6_JOIN_GROUP failure: %m on socket %d, addr %s for interface %d(%s)",
iface->fd, stoa(&iface->sin),
mreq6.ipv6mr_interface, stoa(maddr));
return ISC_FALSE;
}
DPRINTF(4, ("Added IPv6 multicast group on socket %d, addr %s for interface %d(%s)\n",
iface->fd, stoa(&iface->sin),
mreq6.ipv6mr_interface, stoa(maddr)));
break;
#else
return ISC_FALSE;
#endif
}
iface->flags |= INT_MCASTOPEN;
iface->num_mcast++;
add_addr_to_list(maddr, iface);
return ISC_TRUE;
}
static isc_boolean_t
socket_multicast_disable(struct interface *iface, struct sockaddr_storage *maddr)
{
#ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
struct ipv6_mreq mreq6;
struct in6_addr iaddr6;
#endif
struct ip_mreq mreq;
memset((char *)&mreq, 0, sizeof(mreq));
if (find_addr_in_list(maddr) == NULL) {
DPRINTF(4, ("socket_multicast_disable(%s): not enabled\n", stoa(maddr)));
return ISC_TRUE;
}
switch (maddr->ss_family)
{
case AF_INET:
mreq.imr_multiaddr = (((struct sockaddr_in*)&maddr)->sin_addr);
mreq.imr_interface.s_addr = ((struct sockaddr_in*)&iface->sin)->sin_addr.s_addr;
if (setsockopt(iface->fd, IPPROTO_IP, IP_DROP_MEMBERSHIP,
(char *)&mreq, sizeof(mreq)) == -1) {
netsyslog(LOG_ERR,
"setsockopt IP_DROP_MEMBERSHIP failure: %m on socket %d, addr %s for %x / %x (%s)",
iface->fd, stoa(&iface->sin),
mreq.imr_multiaddr.s_addr,
mreq.imr_interface.s_addr, stoa(maddr));
return ISC_FALSE;
}
break;
case AF_INET6:
#ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
iaddr6 = ((struct sockaddr_in6*)&maddr)->sin6_addr;
mreq6.ipv6mr_multiaddr = iaddr6;
mreq6.ipv6mr_interface = iface->scopeid;
if (setsockopt(iface->fd, IPPROTO_IPV6, IPV6_LEAVE_GROUP,
(char *)&mreq6, sizeof(mreq6)) == -1) {
netsyslog(LOG_ERR,
"setsockopt IPV6_LEAVE_GROUP failure: %m on socket %d, addr %s for %d(%s)",
iface->fd, stoa(&iface->sin),
mreq6.ipv6mr_interface, stoa(maddr));
return ISC_FALSE;
}
break;
#else
return ISC_FALSE;
#endif
}
iface->num_mcast--;
if (iface->num_mcast <= 0) {
iface->num_mcast = 0;
iface->flags &= ~INT_MCASTOPEN;
}
return ISC_TRUE;
}
void
io_setbclient(void)
{
#ifdef OPEN_BCAST_SOCKET
struct interface *interf;
int nif = 0;
isc_boolean_t jstatus;
SOCKET fd;
set_reuseaddr(1);
for (interf = ISC_LIST_HEAD(inter_list);
interf != NULL;
interf = ISC_LIST_NEXT(interf, link)) {
if (interf->flags & INT_WILDCARD)
continue;
if (interf->ignore_packets == ISC_TRUE)
continue;
if (interf->sin.ss_family != AF_INET)
continue;
if (!(interf->flags & INT_BROADCAST))
continue;
if (interf->flags & INT_LOOPBACK)
continue;
if (interf->flags & INT_BCASTOPEN) {
nif++;
continue;
}
interf->family = AF_INET;
interf->bfd = open_socket(&interf->bcast,
INT_BROADCAST, 0, interf);
if (interf->bfd == INVALID_SOCKET) {
fd = interf->fd;
}
else {
fd = interf->bfd;
}
jstatus = socket_broadcast_enable(interf, fd, &interf->sin);
if (jstatus == ISC_TRUE)
{
nif++;
netsyslog(LOG_INFO,"io_setbclient: Opened broadcast client on interface #%d %s, socket: %d",
interf->ifnum, interf->name, fd);
interf->addr_refid = addr2refid(&interf->sin);
}
}
set_reuseaddr(0);
#ifdef DEBUG
if (debug)
if (nif > 0)
printf("io_setbclient: Opened broadcast clients\n");
#endif
if (nif == 0)
netsyslog(LOG_ERR, "Unable to listen for broadcasts, no broadcast interfaces available");
#else
netsyslog(LOG_ERR, "io_setbclient: Broadcast Client disabled by build");
#endif
}
void
io_unsetbclient(void)
{
struct interface *interf;
isc_boolean_t lstatus;
for (interf = ISC_LIST_HEAD(inter_list);
interf != NULL;
interf = ISC_LIST_NEXT(interf, link))
{
if (interf->flags & INT_WILDCARD)
continue;
if (!(interf->flags & INT_BCASTOPEN))
continue;
lstatus = socket_broadcast_disable(interf, &interf->sin);
}
}
void
io_multicast_add(
struct sockaddr_storage addr
)
{
#ifdef MCAST
struct interface *interface, *iface;
int lscope = 0;
if (addr_ismulticast(&addr) == ISC_FALSE)
return;
if (find_flagged_addr_in_list(&addr, INT_MCASTOPEN|INT_MCASTIF) != NULL)
{
netsyslog(LOG_INFO, "Duplicate request found for multicast address %s",
stoa(&addr));
return;
}
#ifndef MULTICAST_NONEWSOCKET
interface = new_interface(NULL);
interface->sin.ss_family = addr.ss_family;
interface->family = addr.ss_family;
switch(addr.ss_family) {
case AF_INET:
memcpy(&(((struct sockaddr_in *)&interface->sin)->sin_addr),
&(((struct sockaddr_in*)&addr)->sin_addr),
sizeof(struct in_addr));
((struct sockaddr_in*)&interface->sin)->sin_port = htons(NTP_PORT);
memset(&((struct sockaddr_in*)&interface->mask)->sin_addr.s_addr, 0xff, sizeof(struct in_addr));
break;
case AF_INET6:
#ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
memcpy(&(((struct sockaddr_in6 *)&interface->sin)->sin6_addr),
&((struct sockaddr_in6*)&addr)->sin6_addr,
sizeof(struct in6_addr));
((struct sockaddr_in6*)&interface->sin)->sin6_port = htons(NTP_PORT);
#ifdef ISC_PLATFORM_HAVESCOPEID
((struct sockaddr_in6*)&interface->sin)->sin6_scope_id = ((struct sockaddr_in6*)&addr)->sin6_scope_id;
#endif
memset(&((struct sockaddr_in6*)&interface->mask)->sin6_addr.s6_addr, 0xff, sizeof(struct in6_addr));
#endif
iface = findlocalcastinterface(&addr, INT_MULTICAST);
if (iface) {
# ifdef ISC_PLATFORM_HAVESCOPEID
lscope = ((struct sockaddr_in6*)&iface->sin)->sin6_scope_id;
# endif
DPRINTF(4, ("Found interface #%d %s, scope: %d for address %s\n", iface->ifnum, iface->name, lscope, stoa(&addr)));
}
break;
}
set_reuseaddr(1);
interface->bfd = INVALID_SOCKET;
interface->fd = open_socket(&interface->sin,
INT_MULTICAST, 0, interface);
if (interface->fd != INVALID_SOCKET)
{
interface->bfd = INVALID_SOCKET;
interface->ignore_packets = ISC_FALSE;
interface->flags |= INT_MCASTIF;
(void) strncpy(interface->name, "multicast",
sizeof(interface->name));
((struct sockaddr_in*)&interface->mask)->sin_addr.s_addr =
htonl(~(u_int32)0);
DPRINT_INTERFACE(2, (interface, "multicast add ", "\n"));
add_interface(interface);
list_if_listening(interface, htons(NTP_PORT));
}
else
{
delete_interface(interface);
interface = NULL;
if (addr.ss_family == AF_INET)
interface = wildipv4;
else if (addr.ss_family == AF_INET6)
interface = wildipv6;
if (interface != NULL) {
interface->bcast = addr;
netsyslog(LOG_ERR,
"...multicast address %s using wildcard interface #%d %s",
stoa(&addr), interface->ifnum, interface->name);
} else {
netsyslog(LOG_ERR,
"No multicast socket available to use for address %s",
stoa(&addr));
return;
}
}
#else
interface = findlocalcastinterface(&addr, INT_MULTICAST);
if (!interface)
{
netsyslog(LOG_ERR,
"Cannot add multicast address %s: Cannot find slot",
stoa(&addr));
return;
}
#endif
{
isc_boolean_t jstatus;
jstatus = socket_multicast_enable(interface, lscope, &addr);
if (jstatus == ISC_TRUE)
netsyslog(LOG_INFO, "Added Multicast Listener %s on interface #%d %s\n", stoa(&addr), interface->ifnum, interface->name);
else
netsyslog(LOG_ERR, "Failed to add Multicast Listener %s\n", stoa(&addr));
}
#else
netsyslog(LOG_ERR,
"Cannot add multicast address %s: no Multicast support",
stoa(&addr));
#endif
return;
}
void
io_multicast_del(
struct sockaddr_storage addr
)
{
#ifdef MCAST
struct interface *interface;
isc_boolean_t lstatus;
if (addr_ismulticast(&addr) == ISC_FALSE)
{
netsyslog(LOG_ERR,
"invalid multicast address %s", stoa(&addr));
return;
}
switch (addr.ss_family)
{
case AF_INET :
interface = find_flagged_addr_in_list(&addr, INT_MCASTOPEN);
while ( interface != NULL) {
lstatus = socket_multicast_disable(interface, &addr);
interface = find_flagged_addr_in_list(&addr, INT_MCASTOPEN);
}
break;
#ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
case AF_INET6 :
for (interface = ISC_LIST_HEAD(inter_list);
interface != NULL;
interface = ISC_LIST_NEXT(interface, link))
{
if (interface->flags & INT_WILDCARD)
continue;
if (interface->sin.ss_family != AF_INET6)
continue;
if (!(interface->flags & INT_MCASTOPEN))
continue;
if (!(interface->fd < 0))
continue;
if (!SOCKCMP(&addr, &interface->sin))
continue;
lstatus = socket_multicast_disable(interface, &addr);
}
break;
#endif
}
delete_addr_from_list(&addr);
#else
netsyslog(LOG_ERR, "this function requires multicast kernel");
#endif
}
static void init_nonblocking_io(SOCKET fd)
{
#ifdef USE_FIONBIO
#undef O_NONBLOCK
#undef FNDELAY
#undef O_NDELAY
#endif
#if defined(O_NONBLOCK)
if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0)
{
netsyslog(LOG_ERR, "fcntl(O_NONBLOCK) fails on fd #%d: %m",
fd);
exit(1);
}
#elif defined(FNDELAY)
if (fcntl(fd, F_SETFL, FNDELAY) < 0)
{
netsyslog(LOG_ERR, "fcntl(FNDELAY) fails on fd #%d: %m",
fd);
exit(1);
}
#elif defined(O_NDELAY)
if (fcntl(fd, F_SETFL, O_NDELAY) < 0)
{
netsyslog(LOG_ERR, "fcntl(O_NDELAY) fails on fd #%d: %m",
fd);
exit(1);
}
#elif defined(FIONBIO)
{
int on = 1;
# if defined(SYS_WINNT)
if (ioctlsocket(fd,FIONBIO,(u_long *) &on) == SOCKET_ERROR)
# else
if (ioctl(fd,FIONBIO,&on) < 0)
# endif
{
netsyslog(LOG_ERR, "ioctl(FIONBIO) fails on fd #%d: %m",
fd);
exit(1);
}
}
#elif defined(FIOSNBIO)
if (ioctl(fd,FIOSNBIO,&on) < 0)
{
netsyslog(LOG_ERR, "ioctl(FIOSNBIO) fails on fd #%d: %m",
fd);
exit(1);
}
#else
# include "Bletch: Need non-blocking I/O!"
#endif
}
static SOCKET
open_socket(
struct sockaddr_storage *addr,
int flags,
int turn_off_reuse,
struct interface *interf
)
{
int errval;
SOCKET fd;
int on = 1, off = 0;
#if defined(IPTOS_LOWDELAY) && defined(IPPROTO_IP) && defined(IP_TOS)
int tos;
#endif
if ((addr->ss_family == AF_INET6) && (isc_net_probeipv6() != ISC_R_SUCCESS))
return (INVALID_SOCKET);
#ifndef SYS_WINNT
if ( (fd = socket(addr->ss_family, SOCK_DGRAM, 0)) < 0) {
errval = errno;
#else
if ( (fd = socket(addr->ss_family, SOCK_DGRAM, 0)) == INVALID_SOCKET) {
errval = WSAGetLastError();
#endif
if(addr->ss_family == AF_INET)
netsyslog(LOG_ERR, "socket(AF_INET, SOCK_DGRAM, 0) failed on address %s: %m",
stoa(addr));
else if(addr->ss_family == AF_INET6)
netsyslog(LOG_ERR, "socket(AF_INET6, SOCK_DGRAM, 0) failed on address %s: %m",
stoa(addr));
#ifndef SYS_WINNT
if (errval == EPROTONOSUPPORT || errval == EAFNOSUPPORT ||
errval == EPFNOSUPPORT)
#else
if (errval == WSAEPROTONOSUPPORT || errval == WSAEAFNOSUPPORT ||
errval == WSAEPFNOSUPPORT)
#endif
return (INVALID_SOCKET);
msyslog(LOG_ERR, "unexpected error code %d (not PROTONOSUPPORT|AFNOSUPPORT|FPNOSUPPORT) - exiting", errval);
exit(1);
}
#ifdef SYS_WINNT
if (connection_reset_fix(fd) != ISC_R_SUCCESS) {
netsyslog(LOG_ERR, "connection_reset_fix(fd) failed on address %s: %m",
stoa(addr));
}
#endif
fd = move_fd(fd);
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
turn_off_reuse ? (char *)&off : (char *)&on, sizeof(on)))
{
netsyslog(LOG_ERR, "setsockopt SO_REUSEADDR %s on fails on address %s: %m",
turn_off_reuse ? "off" : "on", stoa(addr));
closesocket(fd);
return INVALID_SOCKET;
}
if (addr->ss_family == AF_INET) {
#if defined(IPTOS_LOWDELAY) && defined(IPPROTO_IP) && defined(IP_TOS)
tos = IPTOS_LOWDELAY;
if (setsockopt(fd, IPPROTO_IP, IP_TOS, (char *) &tos, sizeof(tos)) < 0)
{
netsyslog(LOG_ERR, "setsockopt IPTOS_LOWDELAY on fails on address %s: %m",
stoa(addr));
}
#endif
}
if (addr->ss_family == AF_INET6) {
struct in6_ifreq ifr6;
ifr6.ifr_addr = *(struct sockaddr_in6 *)addr;
if (ioctl(fd, SIOCGIFAFLAG_IN6, &ifr6) >= 0) {
if (ifr6.ifr_ifru.ifru_flags6 & IN6_IFF_TENTATIVE) {
closesocket(fd);
return INVALID_SOCKET;
}
}
#if defined(IPV6_V6ONLY)
if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY,
(char*)&on, sizeof(on)))
{
netsyslog(LOG_ERR, "setsockopt IPV6_V6ONLY on fails on address %s: %m",
stoa(addr));
}
#endif
#if defined(IPV6_BINDV6ONLY)
if (setsockopt(fd, IPPROTO_IPV6, IPV6_BINDV6ONLY,
(char*)&on, sizeof(on)))
{
netsyslog(LOG_ERR,
"setsockopt IPV6_BINDV6ONLY on fails on address %s: %m",
stoa(addr));
}
#endif
}
#ifdef OS_NEEDS_REUSEADDR_FOR_IFADDRBIND
if (!is_wildcard_addr(addr)) {
set_wildcard_reuse(addr->ss_family, 1);
}
#endif
errval = bind(fd, (struct sockaddr *)addr, SOCKLEN(addr));
#ifdef OS_NEEDS_REUSEADDR_FOR_IFADDRBIND
if (!is_wildcard_addr(addr)) {
set_wildcard_reuse(addr->ss_family, 0);
}
#endif
if (errval < 0) {
if (turn_off_reuse == 0
#ifdef DEBUG
|| debug > 1
#endif
) {
if (addr->ss_family == AF_INET)
netsyslog(LOG_ERR,
"bind() fd %d, family %d, port %d, addr %s, in_classd=%d flags=0x%x fails: %m",
fd, addr->ss_family, (int)ntohs(((struct sockaddr_in*)addr)->sin_port),
stoa(addr),
IN_CLASSD(ntohl(((struct sockaddr_in*)addr)->sin_addr.s_addr)), flags);
#ifdef INCLUDE_IPV6_SUPPORT
else if (addr->ss_family == AF_INET6)
netsyslog(LOG_ERR,
"bind() fd %d, family %d, port %d, scope %d, addr %s, in6_is_addr_multicast=%d flags=0x%x fails: %m",
fd, addr->ss_family, (int)ntohs(((struct sockaddr_in6*)addr)->sin6_port),
# ifdef ISC_PLATFORM_HAVESCOPEID
((struct sockaddr_in6*)addr)->sin6_scope_id
# else
-1
# endif
, stoa(addr),
IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6*)addr)->sin6_addr), flags);
#endif
}
closesocket(fd);
return INVALID_SOCKET;
}
#ifdef HAVE_TIMESTAMP
{
if (setsockopt(fd, SOL_SOCKET, SO_TIMESTAMP,
(char*)&on, sizeof(on)))
{
netsyslog(LOG_DEBUG,
"setsockopt SO_TIMESTAMP on fails on address %s: %m",
stoa(addr));
}
#ifdef DEBUG
else
{
DPRINTF(4, ("setsockopt SO_TIMESTAMP enabled on fd %d address %s\n", fd, stoa(addr)));
}
#endif
}
#endif
DPRINTF(4, ("bind() fd %d, family %d, port %d, addr %s, flags=0x%x\n",
fd,
addr->ss_family,
(int)ntohs(((struct sockaddr_in*)addr)->sin_port),
stoa(addr),
flags));
init_nonblocking_io(fd);
#ifdef HAVE_SIGNALED_IO
init_socket_sig(fd);
#endif
add_fd_to_list(fd, FD_TYPE_SOCKET);
#if !defined(SYS_WINNT) && !defined(VMS)
DPRINTF(4, ("flags for fd %d: 0x%x\n", fd,
fcntl(fd, F_GETFL, 0)));
#endif
#if defined (HAVE_IO_COMPLETION_PORT)
io_completion_port_add_socket(fd, interf);
#endif
return fd;
}
void
sendpkt(
struct sockaddr_storage *dest,
struct interface *inter,
int ttl,
struct pkt *pkt,
int len
)
{
int cc, slot;
static int last_errno;
#ifdef SYS_WINNT
DWORD err;
#endif
struct cache {
u_short port;
struct in_addr addr;
};
#ifdef INCLUDE_IPV6_SUPPORT
struct cache6 {
u_short port;
struct in6_addr addr;
};
#endif
#ifndef ERRORCACHESIZE
#define ERRORCACHESIZE 8
#endif
#if ERRORCACHESIZE > 0
static struct cache badaddrs[ERRORCACHESIZE];
#ifdef INCLUDE_IPV6_SUPPORT
static struct cache6 badaddrs6[ERRORCACHESIZE];
#endif
#else
#define badaddrs ((struct cache *)0)
#ifdef INCLUDE_IPV6_SUPPORT
#define badaddrs6 ((struct cache6 *)0)
#endif
#endif
#ifdef DEBUG
if (debug > 1)
{
if (inter != NULL)
{
printf("%ssendpkt(fd=%d dst=%s, src=%s, ttl=%d, len=%d)\n",
(ttl > 0) ? "\tMCAST\t***** " : "",
inter->fd, stoa(dest),
stoa(&inter->sin), ttl, len);
}
else
{
printf("%ssendpkt(dst=%s, ttl=%d, len=%d): no interface - IGNORED\n",
(ttl > 0) ? "\tMCAST\t***** " : "",
stoa(dest),
ttl, len);
}
}
#endif
if (inter == NULL)
return;
#ifdef MCAST
if (ttl > 0 && ttl != inter->last_ttl) {
int rtc;
switch (inter->sin.ss_family) {
case AF_INET :
{
u_char mttl = (u_char) ttl;
rtc = setsockopt(inter->fd, IPPROTO_IP, IP_MULTICAST_TTL,
(const void *) &mttl, sizeof(mttl));
break;
}
#ifdef INCLUDE_IPV6_SUPPORT
case AF_INET6 :
{
u_int ittl = (u_char) ttl;
rtc = setsockopt(inter->fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
(const void *) &ittl, sizeof(ittl));
break;
}
#endif
default:
rtc = 0;
break;
}
if (rtc != 0) {
netsyslog(LOG_ERR, "setsockopt IP_MULTICAST_TTL/IPV6_MULTICAST_HOPS fails on address %s: %m",
stoa(&inter->sin));
}
else
inter->last_ttl = ttl;
}
#endif
for (slot = ERRORCACHESIZE; --slot >= 0; )
if(dest->ss_family == AF_INET) {
if (badaddrs[slot].port == ((struct sockaddr_in*)dest)->sin_port &&
badaddrs[slot].addr.s_addr == ((struct sockaddr_in*)dest)->sin_addr.s_addr)
break;
}
#ifdef INCLUDE_IPV6_SUPPORT
else if (dest->ss_family == AF_INET6) {
if (badaddrs6[slot].port == ((struct sockaddr_in6*)dest)->sin6_port &&
badaddrs6[slot].addr.s6_addr == ((struct sockaddr_in6*)dest)->sin6_addr.s6_addr)
break;
}
#endif
#if defined(HAVE_IO_COMPLETION_PORT)
err = io_completion_port_sendto(inter, pkt, len, dest);
if (err != ERROR_SUCCESS)
#else
#ifdef SIM
cc = srvr_rply(&ntp_node, dest, inter, pkt);
#else
cc = sendto(inter->fd, (char *)pkt, (unsigned int)len, 0, (struct sockaddr *)dest,
SOCKLEN(dest));
#endif
if (cc == -1)
#endif
{
inter->notsent++;
packets_notsent++;
#if defined(HAVE_IO_COMPLETION_PORT)
err = WSAGetLastError();
if (err != WSAEWOULDBLOCK && err != WSAENOBUFS && slot < 0)
#else
if (errno != EWOULDBLOCK && errno != ENOBUFS && slot < 0)
#endif
{
switch (dest->ss_family) {
case AF_INET :
for (slot = ERRORCACHESIZE; --slot >= 0; )
if (badaddrs[slot].port == 0)
{
badaddrs[slot].port = SRCPORT(dest);
badaddrs[slot].addr = ((struct sockaddr_in*)dest)->sin_addr;
break;
}
break;
#ifdef INCLUDE_IPV6_SUPPORT
case AF_INET6 :
for (slot = ERRORCACHESIZE; --slot >= 0; )
if (badaddrs6[slot].port == 0)
{
badaddrs6[slot].port = SRCPORT(dest);
badaddrs6[slot].addr = ((struct sockaddr_in6*)dest)->sin6_addr;
break;
}
break;
#endif
default:
break;
}
if (last_errno != errno) {
last_errno = errno;
netsyslog(LOG_ERR, "sendto(%s) (fd=%d): %m",
stoa(dest), inter->fd);
}
}
}
else
{
last_errno = 0;
inter->sent++;
packets_sent++;
if (slot >= 0)
{
netsyslog(LOG_INFO, "Connection re-established to %s", stoa(dest));
switch (dest->ss_family) {
case AF_INET :
badaddrs[slot].port = 0;
break;
#ifdef INCLUDE_IPV6_SUPPORT
case AF_INET6 :
badaddrs6[slot].port = 0;
break;
#endif
default:
break;
}
}
}
}
#if !defined(HAVE_IO_COMPLETION_PORT)
static char *
fdbits(
int count,
fd_set *set
)
{
static char buffer[256];
char * buf = buffer;
count = (count < 256) ? count : 255;
while (count >= 0)
{
*buf++ = FD_ISSET(count, set) ? '#' : '-';
count--;
}
*buf = '\0';
return buffer;
}
static inline int
read_refclock_packet(SOCKET fd, struct refclockio *rp, l_fp ts)
{
int i;
int buflen;
register struct recvbuf *rb;
rb = get_free_recv_buffer();
if (rb == NULL)
{
char buf[RX_BUFF_SIZE];
buflen = read(fd, buf, sizeof buf);
packets_dropped++;
return (buflen);
}
i = (rp->datalen == 0
|| rp->datalen > sizeof(rb->recv_space))
? sizeof(rb->recv_space) : rp->datalen;
buflen = read(fd, (char *)&rb->recv_space, (unsigned)i);
if (buflen < 0)
{
if (errno != EINTR && errno != EAGAIN) {
netsyslog(LOG_ERR, "clock read fd %d: %m", fd);
}
freerecvbuf(rb);
return (buflen);
}
rb->recv_length = buflen;
rb->recv_srcclock = rp->srcclock;
rb->dstadr = 0;
rb->fd = fd;
rb->recv_time = ts;
rb->receiver = rp->clock_recv;
if (rp->io_input)
{
if (rp->io_input(rb) == 0)
{
freerecvbuf(rb);
return (buflen);
}
}
add_full_recv_buffer(rb);
rp->recvcount++;
packets_received++;
return (buflen);
}
#ifdef HAVE_TIMESTAMP
static l_fp
fetch_timestamp(struct recvbuf *rb, struct msghdr *msghdr, l_fp ts)
{
#ifdef USE_TIMESTAMP_CMSG
struct cmsghdr *cmsghdr;
cmsghdr = CMSG_FIRSTHDR(msghdr);
while (cmsghdr != NULL) {
switch (cmsghdr->cmsg_type)
{
case SCM_TIMESTAMP:
{
struct timeval *tvp = (struct timeval *)CMSG_DATA(cmsghdr);
double dtemp;
l_fp nts;
DPRINTF(4, ("fetch_timestamp: system network time stamp: %ld.%06ld\n", tvp->tv_sec, tvp->tv_usec));
nts.l_i = tvp->tv_sec + JAN_1970;
dtemp = tvp->tv_usec / 1e6;
if (sys_precision != 0)
dtemp += (ntp_random() / FRAC - .5) / (1 <<
-sys_precision);
nts.l_uf = (u_int32)(dtemp*FRAC);
#ifdef DEBUG_TIMING
{
l_fp dts = ts;
L_SUB(&dts, &nts);
collect_timing(rb, "input processing delay", 1, &dts);
DPRINTF(4, ("fetch_timestamp: timestamp delta: %s (incl. prec fuzz)\n", lfptoa(&dts, 9)));
}
#endif
ts = nts;
break;
}
default:
DPRINTF(4, ("fetch_timestamp: skipping control message 0x%x\n", cmsghdr->cmsg_type));
break;
}
cmsghdr = CMSG_NXTHDR(msghdr, cmsghdr);
}
#endif
return ts;
}
#endif
static inline int
read_network_packet(SOCKET fd, struct interface *itf, l_fp ts)
{
GETSOCKNAME_SOCKLEN_TYPE fromlen;
int buflen;
register struct recvbuf *rb;
#ifdef HAVE_TIMESTAMP
struct msghdr msghdr;
struct iovec iovec;
char control[TIMESTAMP_CTLMSGBUF_SIZE];
#endif
rb = get_free_recv_buffer();
if (rb == NULL || itf->ignore_packets == ISC_TRUE)
{
char buf[RX_BUFF_SIZE];
struct sockaddr_storage from;
if (rb != NULL)
freerecvbuf(rb);
fromlen = sizeof(from);
buflen = recvfrom(fd, buf, sizeof(buf), 0,
(struct sockaddr*)&from, &fromlen);
DPRINTF(4, ("%s on (%lu) fd=%d from %s\n",
(itf->ignore_packets == ISC_TRUE) ? "ignore" : "drop",
free_recvbuffs(), fd,
stoa(&from)));
if (itf->ignore_packets == ISC_TRUE)
packets_ignored++;
else
packets_dropped++;
return (buflen);
}
fromlen = sizeof(struct sockaddr_storage);
#ifndef HAVE_TIMESTAMP
rb->recv_length = recvfrom(fd,
(char *)&rb->recv_space,
sizeof(rb->recv_space), 0,
(struct sockaddr *)&rb->recv_srcadr,
&fromlen);
#else
iovec.iov_base = (void *)&rb->recv_space;
iovec.iov_len = sizeof(rb->recv_space);
msghdr.msg_name = (void *)&rb->recv_srcadr;
msghdr.msg_namelen = sizeof(rb->recv_srcadr);
msghdr.msg_iov = &iovec;
msghdr.msg_iovlen = 1;
msghdr.msg_control = (void *)&control;
msghdr.msg_controllen = sizeof(control);
msghdr.msg_flags = 0;
rb->recv_length = recvmsg(fd, &msghdr, 0);
#endif
buflen = rb->recv_length;
if (buflen == 0 || (buflen == -1 &&
(errno==EWOULDBLOCK
#ifdef EAGAIN
|| errno==EAGAIN
#endif
))) {
freerecvbuf(rb);
return (buflen);
}
else if (buflen < 0)
{
netsyslog(LOG_ERR, "recvfrom(%s) fd=%d: %m",
stoa(&rb->recv_srcadr), fd);
DPRINTF(5, ("read_network_packet: fd=%d dropped (bad recvfrom)\n", fd));
freerecvbuf(rb);
return (buflen);
}
#ifdef DEBUG
if (debug > 2) {
if(rb->recv_srcadr.ss_family == AF_INET)
printf("read_network_packet: fd=%d length %d from %08lx %s\n",
fd, buflen,
(u_long)ntohl(((struct sockaddr_in*)&rb->recv_srcadr)->sin_addr.s_addr) &
0x00000000ffffffff,
stoa(&rb->recv_srcadr));
else
printf("read_network_packet: fd=%d length %d from %s\n",
fd, buflen,
stoa(&rb->recv_srcadr));
}
#endif
rb->dstadr = itf;
rb->fd = fd;
#ifdef HAVE_TIMESTAMP
ts = fetch_timestamp(rb, &msghdr, ts);
#endif
rb->recv_time = ts;
rb->receiver = receive;
add_full_recv_buffer(rb);
itf->received++;
packets_received++;
return (buflen);
}
void
input_handler(
l_fp *cts
)
{
int buflen;
int n;
int doing;
SOCKET fd;
struct timeval tvzero;
l_fp ts;
#ifdef DEBUG_TIMING
l_fp ts_e;
#endif
fd_set fds;
int select_count = 0;
struct interface *interface;
#if defined(HAS_ROUTING_SOCKET)
struct asyncio_reader *asyncio_reader;
#endif
handler_calls++;
ts = *cts;
fds = activefds;
tvzero.tv_sec = tvzero.tv_usec = 0;
n = select(maxactivefd+1, &fds, (fd_set *)0, (fd_set *)0, &tvzero);
if (n < 0)
{
int err = errno;
if (err != EINTR)
netsyslog(LOG_ERR,
"select(%d, %s, 0L, 0L, &0.0) error: %m",
maxactivefd+1,
fdbits(maxactivefd, &activefds));
if (err == EBADF) {
int j, b;
fds = activefds;
for (j = 0; j <= maxactivefd; j++)
if ((FD_ISSET(j, &fds) && (read(j, &b, 0) == -1)))
netsyslog(LOG_ERR, "Bad file descriptor %d", j);
}
return;
}
else if (n == 0)
return;
++handler_pkts;
#ifdef REFCLOCK
if (refio != NULL)
{
register struct refclockio *rp;
for (rp = refio; rp != NULL; rp = rp->next)
{
fd = rp->fd;
if (FD_ISSET(fd, &fds))
{
do {
++select_count;
buflen = read_refclock_packet(fd, rp, ts);
} while (buflen > 0);
}
}
}
#endif
for (interface = ISC_LIST_TAIL(inter_list);
interface != NULL;
interface = ISC_LIST_PREV(interface, link))
{
for (doing = 0; (doing < 2); doing++)
{
if (doing == 0)
{
fd = interface->fd;
}
else
{
if (!(interface->flags & INT_BCASTOPEN))
break;
fd = interface->bfd;
}
if (fd < 0) continue;
if (FD_ISSET(fd, &fds))
{
do {
++select_count;
buflen = read_network_packet(fd, interface, ts);
} while (buflen > 0);
}
}
}
#ifdef HAS_ROUTING_SOCKET
asyncio_reader = ISC_LIST_TAIL(asyncio_reader_list);
while (asyncio_reader != NULL)
{
struct asyncio_reader *next = ISC_LIST_PREV(asyncio_reader, link);
if (FD_ISSET(asyncio_reader->fd, &fds)) {
++select_count;
asyncio_reader->receiver(asyncio_reader);
}
asyncio_reader = next;
}
#endif
if (select_count == 0)
{
#ifdef DEBUG
if (debug)
netsyslog(LOG_DEBUG, "input_handler: select() returned 0");
#endif
return;
}
#ifdef DEBUG_TIMING
get_systime(&ts_e);
L_SUB(&ts_e, &ts);
collect_timing(NULL, "input handler", 1, &ts_e);
if (debug > 3)
netsyslog(LOG_INFO, "input_handler: Processed a gob of fd's in %s msec", lfptoms(&ts_e, 6));
#endif
return;
}
#endif
struct interface *
findinterface(
struct sockaddr_storage *addr
)
{
struct interface *interface;
interface = findlocalinterface(addr, INT_WILDCARD);
if (interface == NULL)
{
DPRINTF(4, ("Found no interface for address %s - returning wildcard\n",
stoa(addr)));
return (ANY_INTERFACE_CHOOSE(addr));
}
else
{
DPRINTF(4, ("Found interface #%d %s for address %s\n",
interface->ifnum, interface->name, stoa(addr)));
return (interface);
}
}
static struct interface *
findlocalinterface(
struct sockaddr_storage *addr,
int flags
)
{
SOCKET s;
int rtn;
struct sockaddr_storage saddr;
GETSOCKNAME_SOCKLEN_TYPE saddrlen = SOCKLEN(addr);
struct interface *iface;
DPRINTF(4, ("Finding interface for addr %s in list of addresses\n",
stoa(addr));)
memset(&saddr, 0, sizeof(saddr));
saddr.ss_family = addr->ss_family;
if(addr->ss_family == AF_INET) {
memcpy(&((struct sockaddr_in*)&saddr)->sin_addr, &((struct sockaddr_in*)addr)->sin_addr, sizeof(struct in_addr));
((struct sockaddr_in*)&saddr)->sin_port = htons(NTP_PORT);
}
#ifdef INCLUDE_IPV6_SUPPORT
else if(addr->ss_family == AF_INET6) {
memcpy(&((struct sockaddr_in6*)&saddr)->sin6_addr, &((struct sockaddr_in6*)addr)->sin6_addr, sizeof(struct in6_addr));
((struct sockaddr_in6*)&saddr)->sin6_port = htons(NTP_PORT);
# ifdef ISC_PLATFORM_HAVESCOPEID
((struct sockaddr_in6*)&saddr)->sin6_scope_id = ((struct sockaddr_in6*)addr)->sin6_scope_id;
# endif
}
#endif
s = socket(addr->ss_family, SOCK_DGRAM, 0);
if (s == INVALID_SOCKET)
return NULL;
rtn = connect(s, (struct sockaddr *)&saddr, SOCKLEN(&saddr));
#ifndef SYS_WINNT
if (rtn < 0)
#else
if (rtn == SOCKET_ERROR)
#endif
{
closesocket(s);
return NULL;
}
rtn = getsockname(s, (struct sockaddr *)&saddr, &saddrlen);
closesocket(s);
#ifndef SYS_WINNT
if (rtn < 0)
#else
if (rtn == SOCKET_ERROR)
#endif
return NULL;
DPRINTF(4, ("findlocalinterface: kernel maps %s to %s\n", stoa(addr), stoa(&saddr)));
iface = getinterface(&saddr, flags);
if (iface != NULL && iface->ignore_packets == ISC_TRUE)
{
return NULL;
}
else
{
return iface;
}
}
static struct interface *
getinterface(struct sockaddr_storage *addr, int flags)
{
struct interface *interface = find_addr_in_list(addr);
if (interface != NULL && interface->flags & flags)
{
return NULL;
}
else
{
return interface;
}
}
static struct interface *
findlocalcastinterface(
struct sockaddr_storage *addr, int flags
)
{
struct interface *interface;
struct interface *nif = NULL;
#ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
isc_boolean_t want_linklocal;
#endif
nif = findlocalinterface(addr, 0);
if (nif) {
DPRINTF(2, ("findlocalcastinterface: kernel recommends interface #%d %s\n", nif->ifnum, nif->name));
return nif;
}
#ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
want_linklocal = ISC_FALSE;
if (addr_ismulticast(addr) && flags == INT_MULTICAST)
{
if (IN6_IS_ADDR_MC_LINKLOCAL(&((struct sockaddr_in6*)addr)->sin6_addr))
{
want_linklocal = ISC_TRUE;
}
else if (IN6_IS_ADDR_MC_SITELOCAL(&((struct sockaddr_in6*)addr)->sin6_addr))
{
want_linklocal = ISC_TRUE;
}
}
#endif
for (interface = ISC_LIST_HEAD(inter_list);
interface != NULL;
interface = ISC_LIST_NEXT(interface, link))
{
if (interface->ignore_packets == ISC_TRUE)
continue;
if (interface->flags & (INT_LOOPBACK|INT_WILDCARD))
continue;
if(interface->sin.ss_family != addr->ss_family)
continue;
if (!(interface->flags & flags))
continue;
#ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
if (flags == INT_MULTICAST && interface->sin.ss_family == AF_INET6 &&
(IN6_IS_ADDR_LINKLOCAL(&((struct sockaddr_in6*)&interface->sin)->sin6_addr))
&& want_linklocal == ISC_TRUE)
{
nif = interface;
break;
}
\
if (want_linklocal == ISC_TRUE)
continue;
#endif
if((interface->flags & flags))
{
nif = interface;
break;
}
}
#ifdef DEBUG
if (debug > 2)
{
if (nif)
printf("findlocalcastinterface: found interface #%d %s\n", nif->ifnum, nif->name);
else
printf("findlocalcastinterface: no interface found for %s flags 0x%x\n", stoa(addr), flags);
}
#endif
return (nif);
}
struct interface *
findbcastinter(
struct sockaddr_storage *addr
)
{
#if !defined(MPE) && (defined(SIOCGIFCONF) || defined(SYS_WINNT))
struct interface *interface;
DPRINTF(4, ("Finding broadcast/multicast interface for addr %s in list of addresses\n",
stoa(addr)));
interface = findlocalinterface(addr, INT_LOOPBACK|INT_WILDCARD);
if (interface != NULL)
{
DPRINTF(4, ("Found bcast-/mcast- interface index #%d %s\n", interface->ifnum, interface->name));
return interface;
}
for (interface = ISC_LIST_HEAD(inter_list);
interface != NULL;
interface = ISC_LIST_NEXT(interface, link))
{
if (interface->flags & INT_WILDCARD)
continue;
if (interface->ignore_packets == ISC_TRUE)
continue;
if(interface->sin.ss_family != addr->ss_family)
continue;
if (interface->flags & INT_LOOPBACK)
continue;
if (addr_ismulticast(addr) == ISC_TRUE && interface->flags & INT_MULTICAST)
{
#ifdef INCLUDE_IPV6_SUPPORT
if(addr->ss_family == AF_INET6) {
if(IN6_IS_ADDR_MC_LINKLOCAL(&((struct sockaddr_in6*)addr)->sin6_addr) &&
!IN6_IS_ADDR_LINKLOCAL(&((struct sockaddr_in6*)&interface->sin)->sin6_addr)) {
continue;
}
}
#endif
break;
}
if(addr->ss_family == AF_INET) {
if (SOCKCMP(&interface->bcast, addr)) {
break;
}
if ((NSRCADR(&interface->sin) &
NSRCADR(&interface->mask)) == (NSRCADR(addr) &
NSRCADR(&interface->mask)))
break;
}
#ifdef INCLUDE_IPV6_SUPPORT
else if(addr->ss_family == AF_INET6) {
if (SOCKCMP(&interface->bcast, addr)) {
break;
}
if (SOCKCMP(netof(&interface->sin), netof(addr))) {
break;
}
}
#endif
}
#endif
if (interface == NULL) {
DPRINTF(4, ("No bcast interface found for %s\n", stoa(addr)));
return ANY_INTERFACE_CHOOSE(addr);
} else {
DPRINTF(4, ("Found bcast-/mcast- interface index #%d %s\n", interface->ifnum, interface->name));
return interface;
}
}
void
io_clr_stats(void)
{
packets_dropped = 0;
packets_ignored = 0;
packets_received = 0;
packets_sent = 0;
packets_notsent = 0;
handler_calls = 0;
handler_pkts = 0;
io_timereset = current_time;
}
#ifdef REFCLOCK
int
io_addclock(
struct refclockio *rio
)
{
BLOCKIO();
rio->next = refio;
# ifdef HAVE_SIGNALED_IO
if (init_clock_sig(rio))
{
UNBLOCKIO();
return 0;
}
# elif defined(HAVE_IO_COMPLETION_PORT)
if (io_completion_port_add_clock_io(rio))
{
UNBLOCKIO();
return 0;
}
# endif
refio = rio;
add_fd_to_list(rio->fd, FD_TYPE_FILE);
UNBLOCKIO();
return 1;
}
void
io_closeclock(
struct refclockio *rio
)
{
BLOCKIO();
if (refio == rio)
{
refio = rio->next;
}
else
{
register struct refclockio *rp;
for (rp = refio; rp != NULL; rp = rp->next)
if (rp->next == rio)
{
rp->next = rio->next;
break;
}
if (rp == NULL) {
UNBLOCKIO();
return;
}
}
close_and_delete_fd_from_list(rio->fd);
UNBLOCKIO();
}
#endif
void
kill_asyncio(int startfd)
{
vsock_t *lsock;
vsock_t *next;
BLOCKIO();
lsock = ISC_LIST_HEAD(fd_list);
while (lsock != NULL) {
next = ISC_LIST_NEXT(lsock, link);
close_and_delete_fd_from_list(lsock->fd);
lsock = next;
}
UNBLOCKIO();
}
static void
add_fd_to_list(SOCKET fd, enum desc_type type) {
vsock_t *lsock = (vsock_t *)emalloc(sizeof(vsock_t));
lsock->fd = fd;
lsock->type = type;
ISC_LIST_APPEND(fd_list, lsock, link);
#ifndef HAVE_IO_COMPLETION_PORT
if (fd > maxactivefd)
maxactivefd = fd;
FD_SET( (u_int)fd, &activefds);
#endif
}
static void
close_and_delete_fd_from_list(SOCKET fd) {
vsock_t *next;
vsock_t *lsock = ISC_LIST_HEAD(fd_list);
while(lsock != NULL) {
next = ISC_LIST_NEXT(lsock, link);
if(lsock->fd == fd) {
ISC_LIST_DEQUEUE_TYPE(fd_list, lsock, link, vsock_t);
switch (lsock->type) {
case FD_TYPE_SOCKET:
#ifdef SYS_WINNT
closesocket(lsock->fd);
break;
#endif
case FD_TYPE_FILE:
(void) close(lsock->fd);
break;
default:
msyslog(LOG_ERR, "internal error - illegal descriptor type %d - EXITING", (int)lsock->type);
exit(1);
}
free(lsock);
#ifndef HAVE_IO_COMPLETION_PORT
FD_CLR( (u_int) fd, &activefds);
if (fd == maxactivefd) {
int i, newmax = 0;
for (i = 0; i < maxactivefd; i++)
if (FD_ISSET(i, &activefds))
newmax = i;
maxactivefd = newmax;
}
#endif
break;
}
lsock = next;
}
}
static void
add_addr_to_list(struct sockaddr_storage *addr, struct interface *interface){
#ifdef DEBUG
if (find_addr_in_list(addr) == NULL) {
#endif
remaddr_t *laddr = (remaddr_t *)emalloc(sizeof(remaddr_t));
memcpy(&laddr->addr, addr, sizeof(struct sockaddr_storage));
laddr->interface = interface;
ISC_LIST_APPEND(remoteaddr_list, laddr, link);
DPRINTF(4, ("Added addr %s to list of addresses\n",
stoa(addr)));
#ifdef DEBUG
} else {
DPRINTF(4, ("WARNING: Attempt to add duplicate addr %s to address list\n",
stoa(addr)));
}
#endif
}
static void
delete_addr_from_list(struct sockaddr_storage *addr) {
remaddr_t *next;
remaddr_t *laddr = ISC_LIST_HEAD(remoteaddr_list);
while(laddr != NULL) {
next = ISC_LIST_NEXT(laddr, link);
if(SOCKCMP(&laddr->addr, addr)) {
ISC_LIST_DEQUEUE_TYPE(remoteaddr_list, laddr, link, remaddr_t);
DPRINTF(4, ("Deleted addr %s from list of addresses\n",
stoa(addr)));
free(laddr);
break;
}
laddr = next;
}
}
static void
delete_interface_from_list(struct interface *iface) {
remaddr_t *next;
remaddr_t *laddr = ISC_LIST_HEAD(remoteaddr_list);
while(laddr != NULL) {
next = ISC_LIST_NEXT(laddr, link);
if (laddr->interface == iface) {
ISC_LIST_DEQUEUE_TYPE(remoteaddr_list, laddr, link, remaddr_t);
DPRINTF(4, ("Deleted addr %s for interface #%d %s from list of addresses\n",
stoa(&laddr->addr), iface->ifnum, iface->name));
free(laddr);
}
laddr = next;
}
}
static struct interface *
find_addr_in_list(struct sockaddr_storage *addr) {
remaddr_t *next;
remaddr_t *laddr = ISC_LIST_HEAD(remoteaddr_list);
DPRINTF(4, ("Searching for addr %s in list of addresses - ",
stoa(addr)));
while(laddr != NULL) {
next = ISC_LIST_NEXT(laddr, link);
if(SOCKCMP(&laddr->addr, addr)) {
DPRINTF(4, ("FOUND\n"));
return laddr->interface;
}
else
laddr = next;
}
DPRINTF(4, ("NOT FOUND\n"));
return NULL;
}
static struct interface *
find_flagged_addr_in_list(struct sockaddr_storage *addr, int flag) {
remaddr_t *next;
remaddr_t *laddr = ISC_LIST_HEAD(remoteaddr_list);
DPRINTF(4, ("Finding addr %s in list of addresses\n",
stoa(addr)));
while(laddr != NULL) {
next = ISC_LIST_NEXT(laddr, link);
if(SOCKCMP(&laddr->addr, addr) && (laddr->interface->flags & flag)) {
return laddr->interface;
break;
}
else
laddr = next;
}
return NULL;
}
#ifdef HAS_ROUTING_SOCKET
#include <net/route.h>
#ifndef UPDATE_GRACE
#define UPDATE_GRACE 2
#endif
static void
process_routing_msgs(struct asyncio_reader *reader)
{
char buffer[5120];
char *p = buffer;
int cnt;
if (disable_dynamic_updates) {
remove_asyncio_reader(reader);
delete_asyncio_reader(reader);
return;
}
cnt = read(reader->fd, buffer, sizeof(buffer));
if (cnt < 0) {
msyslog(LOG_ERR, "i/o error on routing socket %m - disabling");
remove_asyncio_reader(reader);
delete_asyncio_reader(reader);
return;
}
while ((p + sizeof(struct rt_msghdr)) <= (buffer + cnt))
{
struct rt_msghdr *rtm;
rtm = (struct rt_msghdr *)p;
if (rtm->rtm_version != RTM_VERSION) {
msyslog(LOG_ERR, "version mismatch on routing socket %m - disabling");
remove_asyncio_reader(reader);
delete_asyncio_reader(reader);
return;
}
switch (rtm->rtm_type) {
#ifdef RTM_NEWADDR
case RTM_NEWADDR:
#endif
#ifdef RTM_DELADDR
case RTM_DELADDR:
#endif
#ifdef RTM_ADD
case RTM_ADD:
#endif
#ifdef RTM_DELETE
case RTM_DELETE:
#endif
#ifdef RTM_REDIRECT
case RTM_REDIRECT:
#endif
#ifdef RTM_CHANGE
case RTM_CHANGE:
#endif
#ifdef RTM_LOSING
case RTM_LOSING:
#endif
#ifdef RTM_IFINFO
case RTM_IFINFO:
#endif
#ifdef RTM_IFANNOUNCE
case RTM_IFANNOUNCE:
#endif
DPRINTF(3, ("routing message op = %d: scheduling interface update\n", rtm->rtm_type));
timer_interfacetimeout(current_time + UPDATE_GRACE);
break;
default:
DPRINTF(4, ("routing message op = %d: ignored\n", rtm->rtm_type));
break;
}
p += rtm->rtm_msglen;
}
}
static void
init_async_notifications()
{
struct asyncio_reader *reader;
int fd = socket(PF_ROUTE, SOCK_RAW, 0);
if (fd >= 0) {
fd = move_fd(fd);
init_nonblocking_io(fd);
#if defined(HAVE_SIGNALED_IO)
init_socket_sig(fd);
#endif
reader = new_asyncio_reader();
reader->fd = fd;
reader->receiver = process_routing_msgs;
add_asyncio_reader(reader, FD_TYPE_SOCKET);
msyslog(LOG_INFO, "Listening on routing socket on fd #%d for interface updates", fd);
} else {
msyslog(LOG_ERR, "unable to open routing socket (%m) - using polled interface update");
}
}
#else
static void
init_async_notifications()
{
}
#endif