1753 lines
40 KiB
C
1753 lines
40 KiB
C
/*
|
|
* 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 "ntp_machine.h"
|
|
#include "ntpd.h"
|
|
#include "ntp_io.h"
|
|
#include "iosignal.h"
|
|
#include "ntp_refclock.h"
|
|
#include "ntp_if.h"
|
|
#include "ntp_stdlib.h"
|
|
|
|
#include <stdio.h>
|
|
#include <signal.h>
|
|
#ifdef HAVE_SYS_PARAM_H
|
|
# include <sys/param.h>
|
|
#endif /* HAVE_SYS_PARAM_H */
|
|
#ifdef HAVE_NETINET_IN_H
|
|
# include <netinet/in.h>
|
|
#endif
|
|
#ifdef HAVE_NETINET_IN_SYSTM_H
|
|
# include <netinet/in_systm.h>
|
|
#else /* Some old linux systems at least have in_system.h instead. */
|
|
# include <netinet/in_system.h>
|
|
#endif /* HAVE_NETINET_IN_SYSTM_H */
|
|
#include <netinet/ip.h>
|
|
#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
|
|
#include <arpa/inet.h>
|
|
|
|
#if _BSDI_VERSION >= 199510
|
|
# include <ifaddrs.h>
|
|
#endif
|
|
|
|
#if defined(VMS) /* most likely UCX-specific */
|
|
|
|
#include <UCX$INETDEF.H>
|
|
|
|
/* "un*x"-compatible names for some items in UCX$INETDEF.H */
|
|
#define ifreq IFREQDEF
|
|
#define ifr_name IFR$T_NAME
|
|
#define ifr_addr IFR$R_DUMMY.IFR$T_ADDR
|
|
#define ifr_broadaddr IFR$R_DUMMY.IFR$T_BROADADDR
|
|
#define ifr_flags IFR$R_DUMMY.IFR$R_DUMMY_1_OVRL.IFR$W_FLAGS
|
|
#define IFF_UP IFR$M_IFF_UP
|
|
#define IFF_BROADCAST IFR$M_IFF_BROADCAST
|
|
#define IFF_LOOPBACK IFR$M_IFF_LOOPBACK
|
|
|
|
#endif /* VMS */
|
|
|
|
|
|
#if defined(VMS) || defined(SYS_WINNT)
|
|
/* structure used in SIOCGIFCONF request (after [KSR] OSF/1) */
|
|
struct ifconf {
|
|
int ifc_len; /* size of buffer */
|
|
union {
|
|
caddr_t ifcu_buf;
|
|
struct ifreq *ifcu_req;
|
|
} ifc_ifcu;
|
|
};
|
|
#define ifc_buf ifc_ifcu.ifcu_buf /* buffer address */
|
|
#define ifc_req ifc_ifcu.ifcu_req /* array of structures returned */
|
|
|
|
#endif /* VMS */
|
|
|
|
#if defined(USE_TTY_SIGPOLL) || defined(USE_UDP_SIGPOLL)
|
|
# if defined(SYS_AIX) && defined(_IO) /* XXX Identify AIX some other way */
|
|
# undef _IO
|
|
# endif
|
|
# include <stropts.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
|
|
*/
|
|
struct interface *any_interface; /* default interface */
|
|
struct interface *loopback_interface; /* loopback interface */
|
|
struct interface inter_list[MAXINTERFACES];
|
|
int ninterfaces;
|
|
|
|
#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
|
|
*/
|
|
fd_set activefds;
|
|
int maxactivefd;
|
|
|
|
static int create_sockets P((u_int));
|
|
static int open_socket P((struct sockaddr_in *, int, int));
|
|
static void close_socket P((int));
|
|
static void close_file P((int));
|
|
static char * fdbits P((int, fd_set *));
|
|
|
|
/*
|
|
* init_io - initialize I/O data structures and call socket creation routine
|
|
*/
|
|
void
|
|
init_io(void)
|
|
{
|
|
#ifdef SYS_WINNT
|
|
WORD wVersionRequested;
|
|
WSADATA wsaData;
|
|
init_transmitbuff();
|
|
#endif /* SYS_WINNT */
|
|
|
|
/*
|
|
* Init buffer free list and stat counters
|
|
*/
|
|
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 = 0;
|
|
|
|
#ifdef REFCLOCK
|
|
refio = 0;
|
|
#endif
|
|
|
|
#if defined(HAVE_SIGNALED_IO)
|
|
(void) set_signal();
|
|
#endif
|
|
|
|
#ifdef SYS_WINNT
|
|
wVersionRequested = MAKEWORD(1,1);
|
|
if (WSAStartup(wVersionRequested, &wsaData))
|
|
{
|
|
msyslog(LOG_ERR, "No useable winsock.dll: %m");
|
|
exit(1);
|
|
}
|
|
#endif /* SYS_WINNT */
|
|
|
|
/*
|
|
* Create the sockets
|
|
*/
|
|
BLOCKIO();
|
|
(void) create_sockets(htons(NTP_PORT));
|
|
UNBLOCKIO();
|
|
|
|
#ifdef DEBUG
|
|
if (debug)
|
|
printf("init_io: maxactivefd %d\n", maxactivefd);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* create_sockets - create a socket for each interface plus a default
|
|
* socket for when we don't know where to send
|
|
*/
|
|
static int
|
|
create_sockets(
|
|
u_int port
|
|
)
|
|
{
|
|
#if _BSDI_VERSION >= 199510
|
|
int i, j;
|
|
struct ifaddrs *ifaddrs, *ifap;
|
|
struct sockaddr_in resmask;
|
|
#if _BSDI_VERSION < 199701
|
|
struct ifaddrs *lp;
|
|
int num_if;
|
|
#endif
|
|
#else /* _BSDI_VERSION >= 199510 */
|
|
# ifdef STREAMS_TLI
|
|
struct strioctl ioc;
|
|
# endif /* STREAMS_TLI */
|
|
char buf[MAXINTERFACES*sizeof(struct ifreq)];
|
|
struct ifconf ifc;
|
|
struct ifreq ifreq, *ifr;
|
|
int n, i, j, vs, size = 0;
|
|
struct sockaddr_in resmask;
|
|
#endif /* _BSDI_VERSION >= 199510 */
|
|
|
|
#ifdef DEBUG
|
|
if (debug)
|
|
printf("create_sockets(%d)\n", ntohs( (u_short) port));
|
|
#endif
|
|
|
|
/*
|
|
* create pseudo-interface with wildcard address
|
|
*/
|
|
inter_list[0].sin.sin_family = AF_INET;
|
|
inter_list[0].sin.sin_port = port;
|
|
inter_list[0].sin.sin_addr.s_addr = htonl(INADDR_ANY);
|
|
(void) strncpy(inter_list[0].name, "wildcard",
|
|
sizeof(inter_list[0].name));
|
|
inter_list[0].mask.sin_addr.s_addr = htonl(~ (u_int32)0);
|
|
inter_list[0].received = 0;
|
|
inter_list[0].sent = 0;
|
|
inter_list[0].notsent = 0;
|
|
inter_list[0].flags = INT_BROADCAST;
|
|
any_interface = &inter_list[0];
|
|
|
|
#if _BSDI_VERSION >= 199510
|
|
#if _BSDI_VERSION >= 199701
|
|
if (getifaddrs(&ifaddrs) < 0)
|
|
{
|
|
msyslog(LOG_ERR, "getifaddrs: %m");
|
|
exit(1);
|
|
}
|
|
i = 1;
|
|
for (ifap = ifaddrs; ifap != NULL; ifap = ifap->ifa_next)
|
|
#else
|
|
if (getifaddrs(&ifaddrs, &num_if) < 0)
|
|
{
|
|
msyslog(LOG_ERR, "create_sockets: getifaddrs() failed: %m");
|
|
exit(1);
|
|
}
|
|
|
|
i = 1;
|
|
|
|
for (ifap = ifaddrs, lp = ifap + num_if; ifap < lp; ifap++)
|
|
#endif
|
|
{
|
|
struct sockaddr_in *sin;
|
|
|
|
if (!ifap->ifa_addr)
|
|
continue;
|
|
|
|
if (ifap->ifa_addr->sa_family != AF_INET)
|
|
continue;
|
|
|
|
if ((ifap->ifa_flags & IFF_UP) == 0)
|
|
continue;
|
|
|
|
if (ifap->ifa_flags & IFF_LOOPBACK) {
|
|
sin = (struct sockaddr_in *)ifap->ifa_addr;
|
|
if (ntohl(sin->sin_addr.s_addr) != 0x7f000001)
|
|
continue;
|
|
}
|
|
inter_list[i].flags = 0;
|
|
if (ifap->ifa_flags & IFF_BROADCAST)
|
|
inter_list[i].flags |= INT_BROADCAST;
|
|
strcpy(inter_list[i].name, ifap->ifa_name);
|
|
sin = (struct sockaddr_in *)ifap->ifa_addr;
|
|
inter_list[i].sin = *sin;
|
|
inter_list[i].sin.sin_port = port;
|
|
if (ifap->ifa_flags & IFF_LOOPBACK) {
|
|
inter_list[i].flags = INT_LOOPBACK;
|
|
if (loopback_interface == NULL
|
|
|| ntohl(sin->sin_addr.s_addr) != 0x7f000001)
|
|
loopback_interface = &inter_list[i];
|
|
}
|
|
if (inter_list[i].flags & INT_BROADCAST) {
|
|
sin = (struct sockaddr_in *)ifap->ifa_broadaddr;
|
|
inter_list[i].bcast = *sin;
|
|
inter_list[i].bcast.sin_port = port;
|
|
}
|
|
if (ifap->ifa_flags & (IFF_LOOPBACK|IFF_POINTOPOINT)) {
|
|
inter_list[i].mask.sin_addr.s_addr = 0xffffffff;
|
|
} else {
|
|
sin = (struct sockaddr_in *)ifap->ifa_netmask;
|
|
inter_list[i].mask = *sin;
|
|
}
|
|
inter_list[i].mask.sin_family = AF_INET;
|
|
inter_list[i].mask.sin_len = sizeof *sin;
|
|
|
|
/*
|
|
* look for an already existing source interface address. If
|
|
* the machine has multiple point to point interfaces, then
|
|
* the local address may appear more than once.
|
|
*
|
|
* A second problem exists if we have two addresses on
|
|
* the same network (via "ifconfig alias ..."). Don't
|
|
* make two xntp interfaces for the two aliases on the
|
|
* one physical interface. -wsr
|
|
*/
|
|
for (j=0; j < i; j++)
|
|
if (inter_list[j].sin.sin_addr.s_addr &
|
|
inter_list[j].mask.sin_addr.s_addr ==
|
|
inter_list[i].sin.sin_addr.s_addr &
|
|
inter_list[i].mask.sin_addr.s_addr)
|
|
{
|
|
if (inter_list[j].flags & INT_LOOPBACK)
|
|
inter_list[j] = inter_list[i];
|
|
break;
|
|
}
|
|
if (j == i)
|
|
i++;
|
|
if (i > MAXINTERFACES)
|
|
break;
|
|
}
|
|
free(ifaddrs);
|
|
#else /* _BSDI_VERSION >= 199510 */
|
|
# ifdef USE_STREAMS_DEVICE_FOR_IF_CONFIG
|
|
if ((vs = open("/dev/ip", O_RDONLY)) < 0)
|
|
{
|
|
msyslog(LOG_ERR, "create_sockets: open(/dev/ip) failed: %m");
|
|
exit(1);
|
|
}
|
|
# else /* not USE_STREAMS_DEVICE_FOR_IF_CONFIG */
|
|
if (
|
|
(vs = socket(AF_INET, SOCK_DGRAM, 0))
|
|
# ifndef SYS_WINNT
|
|
< 0
|
|
# else /* SYS_WINNT */
|
|
== INVALID_SOCKET
|
|
# endif /* SYS_WINNT */
|
|
) {
|
|
msyslog(LOG_ERR, "create_sockets: socket(AF_INET, SOCK_DGRAM) failed: %m");
|
|
exit(1);
|
|
}
|
|
# endif /* not USE_STREAMS_DEVICE_FOR_IF_CONFIG */
|
|
|
|
i = 1;
|
|
# if !defined(SYS_WINNT)
|
|
ifc.ifc_len = sizeof(buf);
|
|
# endif
|
|
# ifdef STREAMS_TLI
|
|
ioc.ic_cmd = SIOCGIFCONF;
|
|
ioc.ic_timout = 0;
|
|
ioc.ic_dp = (caddr_t)buf;
|
|
ioc.ic_len = sizeof(buf);
|
|
if(ioctl(vs, I_STR, &ioc) < 0 ||
|
|
ioc.ic_len < sizeof(struct ifreq))
|
|
{
|
|
msyslog(LOG_ERR, "create_sockets: ioctl(I_STR:SIOCGIFCONF) failed: %m - exiting");
|
|
exit(1);
|
|
}
|
|
# ifdef SIZE_RETURNED_IN_BUFFER
|
|
ifc.ifc_len = ioc.ic_len - sizeof(int);
|
|
ifc.ifc_buf = buf + sizeof(int);
|
|
# else /* not SIZE_RETURNED_IN_BUFFER */
|
|
ifc.ifc_len = ioc.ic_len;
|
|
ifc.ifc_buf = buf;
|
|
# endif /* not SIZE_RETURNED_IN_BUFFER */
|
|
|
|
# else /* not STREAMS_TLI */
|
|
ifc.ifc_len = sizeof(buf);
|
|
ifc.ifc_buf = buf;
|
|
# ifndef SYS_WINNT
|
|
if (ioctl(vs, SIOCGIFCONF, (char *)&ifc) < 0)
|
|
# else
|
|
if (WSAIoctl(vs, SIO_GET_INTERFACE_LIST, 0, 0, ifc.ifc_buf, ifc.ifc_len, &ifc.ifc_len, 0, 0) == SOCKET_ERROR)
|
|
# endif /* SYS_WINNT */
|
|
{
|
|
msyslog(LOG_ERR, "create_sockets: ioctl(SIOCGIFCONF) failed: %m - exiting");
|
|
exit(1);
|
|
}
|
|
|
|
# endif /* not STREAMS_TLI */
|
|
|
|
for(n = ifc.ifc_len, ifr = ifc.ifc_req; n > 0;
|
|
ifr = (struct ifreq *)((char *)ifr + size))
|
|
{
|
|
extern int listen_to_virtual_ips;
|
|
|
|
size = sizeof(*ifr);
|
|
|
|
# ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
|
|
if (ifr->ifr_addr.sa_len > sizeof(ifr->ifr_addr))
|
|
size += ifr->ifr_addr.sa_len - sizeof(struct sockaddr);
|
|
# endif
|
|
n -= size;
|
|
|
|
# if !defined(SYS_WINNT)
|
|
/* Exclude logical interfaces (indicated by ':' in the interface name) */
|
|
if (debug)
|
|
printf("interface <%s> ", ifr->ifr_name);
|
|
if ((listen_to_virtual_ips == 0)
|
|
&& (strchr(ifr->ifr_name, (int)':') != NULL)) {
|
|
if (debug)
|
|
printf("ignored\n");
|
|
continue;
|
|
}
|
|
if (debug)
|
|
printf("OK\n");
|
|
|
|
if (
|
|
# ifdef VMS /* VMS+UCX */
|
|
(((struct sockaddr *)&(ifr->ifr_addr))->sa_family != AF_INET)
|
|
# else
|
|
(ifr->ifr_addr.sa_family != AF_INET)
|
|
# endif /* VMS+UCX */
|
|
) {
|
|
if (debug)
|
|
printf("ignoring %s - not AF_INET\n",
|
|
ifr->ifr_name);
|
|
continue;
|
|
}
|
|
# endif /* SYS_WINNT */
|
|
ifreq = *ifr;
|
|
inter_list[i].flags = 0;
|
|
/* is it broadcast capable? */
|
|
# ifndef SYS_WINNT
|
|
# ifdef STREAMS_TLI
|
|
ioc.ic_cmd = SIOCGIFFLAGS;
|
|
ioc.ic_timout = 0;
|
|
ioc.ic_dp = (caddr_t)&ifreq;
|
|
ioc.ic_len = sizeof(struct ifreq);
|
|
if(ioctl(vs, I_STR, &ioc)) {
|
|
msyslog(LOG_ERR, "create_sockets: ioctl(I_STR:SIOCGIFFLAGS) failed: %m");
|
|
continue;
|
|
}
|
|
# else /* not STREAMS_TLI */
|
|
if (ioctl(vs, SIOCGIFFLAGS, (char *)&ifreq) < 0) {
|
|
if (errno != ENXIO)
|
|
msyslog(LOG_ERR, "create_sockets: ioctl(SIOCGIFFLAGS) failed: %m");
|
|
continue;
|
|
}
|
|
# endif /* not STREAMS_TLI */
|
|
if ((ifreq.ifr_flags & IFF_UP) == 0) {
|
|
if (debug)
|
|
printf("ignoring %s - interface not UP\n",
|
|
ifr->ifr_name);
|
|
continue;
|
|
}
|
|
inter_list[i].flags = 0;
|
|
if (ifreq.ifr_flags & IFF_BROADCAST)
|
|
inter_list[i].flags |= INT_BROADCAST;
|
|
# endif /* not SYS_WINNT */
|
|
# if !defined(SUN_3_3_STINKS)
|
|
if (
|
|
# if defined(IFF_LOCAL_LOOPBACK) /* defined(SYS_HPUX) && (SYS_HPUX < 8) */
|
|
(ifreq.ifr_flags & IFF_LOCAL_LOOPBACK)
|
|
# elif defined(IFF_LOOPBACK)
|
|
(ifreq.ifr_flags & IFF_LOOPBACK)
|
|
# else /* not IFF_LOCAL_LOOPBACK and not IFF_LOOPBACK */
|
|
/* test against 127.0.0.1 (yuck!!) */
|
|
(inter_list[i].sin.sin_addr.s_addr == inet_addr("127.0.0.1"))
|
|
# endif /* not IFF_LOCAL_LOOPBACK and not IFF_LOOPBACK */
|
|
)
|
|
{
|
|
# ifndef SYS_WINNT
|
|
inter_list[i].flags |= INT_LOOPBACK;
|
|
# endif /* not SYS_WINNT */
|
|
if (loopback_interface == 0)
|
|
{
|
|
loopback_interface = &inter_list[i];
|
|
}
|
|
}
|
|
# endif /* not SUN_3_3_STINKS */
|
|
|
|
#if 0
|
|
# ifndef SYS_WINNT
|
|
# ifdef STREAMS_TLI
|
|
ioc.ic_cmd = SIOCGIFADDR;
|
|
ioc.ic_timout = 0;
|
|
ioc.ic_dp = (caddr_t)&ifreq;
|
|
ioc.ic_len = sizeof(struct ifreq);
|
|
if (ioctl(vs, I_STR, &ioc))
|
|
{
|
|
msyslog(LOG_ERR, "create_sockets: ioctl(I_STR:SIOCGIFADDR) failed: %m");
|
|
continue;
|
|
}
|
|
# else /* not STREAMS_TLI */
|
|
if (ioctl(vs, SIOCGIFADDR, (char *)&ifreq) < 0)
|
|
{
|
|
if (errno != ENXIO)
|
|
msyslog(LOG_ERR, "create_sockets: ioctl(SIOCGIFADDR) failed: %m");
|
|
continue;
|
|
}
|
|
# endif /* not STREAMS_TLI */
|
|
# endif /* not SYS_WINNT */
|
|
#endif /* 0 */
|
|
# if defined(SYS_WINNT)
|
|
{int TODO_FillInTheNameWithSomeThingReasonble;}
|
|
# else
|
|
(void)strncpy(inter_list[i].name, ifreq.ifr_name,
|
|
sizeof(inter_list[i].name));
|
|
# endif
|
|
inter_list[i].sin = *(struct sockaddr_in *)&ifr->ifr_addr;
|
|
inter_list[i].sin.sin_family = AF_INET;
|
|
inter_list[i].sin.sin_port = port;
|
|
|
|
# if defined(SUN_3_3_STINKS)
|
|
/*
|
|
* Oh, barf! I'm too disgusted to even explain this
|
|
*/
|
|
if (SRCADR(&inter_list[i].sin) == 0x7f000001)
|
|
{
|
|
inter_list[i].flags |= INT_LOOPBACK;
|
|
if (loopback_interface == 0)
|
|
loopback_interface = &inter_list[i];
|
|
}
|
|
# endif /* SUN_3_3_STINKS */
|
|
# if !defined SYS_WINNT && !defined SYS_CYGWIN32 /* no interface flags on NT */
|
|
if (inter_list[i].flags & INT_BROADCAST) {
|
|
# ifdef STREAMS_TLI
|
|
ioc.ic_cmd = SIOCGIFBRDADDR;
|
|
ioc.ic_timout = 0;
|
|
ioc.ic_dp = (caddr_t)&ifreq;
|
|
ioc.ic_len = sizeof(struct ifreq);
|
|
if(ioctl(vs, I_STR, &ioc)) {
|
|
msyslog(LOG_ERR, "create_sockets: ioctl(I_STR:SIOCGIFBRDADDR) failed: %m");
|
|
exit(1);
|
|
}
|
|
# else /* not STREAMS_TLI */
|
|
if (ioctl(vs, SIOCGIFBRDADDR, (char *)&ifreq) < 0) {
|
|
msyslog(LOG_ERR, "create_sockets: ioctl(SIOCGIFBRDADDR) failed: %m");
|
|
exit(1);
|
|
}
|
|
# endif /* not STREAMS_TLI */
|
|
|
|
# ifndef ifr_broadaddr
|
|
inter_list[i].bcast =
|
|
*(struct sockaddr_in *)&ifreq.ifr_addr;
|
|
# else
|
|
inter_list[i].bcast =
|
|
*(struct sockaddr_in *)&ifreq.ifr_broadaddr;
|
|
# endif /* ifr_broadaddr */
|
|
inter_list[i].bcast.sin_family = AF_INET;
|
|
inter_list[i].bcast.sin_port = port;
|
|
}
|
|
|
|
# ifdef STREAMS_TLI
|
|
ioc.ic_cmd = SIOCGIFNETMASK;
|
|
ioc.ic_timout = 0;
|
|
ioc.ic_dp = (caddr_t)&ifreq;
|
|
ioc.ic_len = sizeof(struct ifreq);
|
|
if(ioctl(vs, I_STR, &ioc)) {
|
|
msyslog(LOG_ERR, "create_sockets: ioctl(I_STR:SIOCGIFNETMASK) failed: %m");
|
|
exit(1);
|
|
}
|
|
# else /* not STREAMS_TLI */
|
|
if (ioctl(vs, SIOCGIFNETMASK, (char *)&ifreq) < 0) {
|
|
msyslog(LOG_ERR, "create_sockets: ioctl(SIOCGIFNETMASK) failed: %m");
|
|
exit(1);
|
|
}
|
|
# endif /* not STREAMS_TLI */
|
|
inter_list[i].mask = *(struct sockaddr_in *)&ifreq.ifr_addr;
|
|
# else
|
|
/* winnt here */
|
|
inter_list[i].bcast = ifreq.ifr_broadaddr;
|
|
inter_list[i].bcast.sin_family = AF_INET;
|
|
inter_list[i].bcast.sin_port = port;
|
|
inter_list[i].mask = ifreq.ifr_mask;
|
|
# endif /* not SYS_WINNT */
|
|
|
|
/*
|
|
* look for an already existing source interface address. If
|
|
* the machine has multiple point to point interfaces, then
|
|
* the local address may appear more than once.
|
|
*/
|
|
for (j=0; j < i; j++)
|
|
if (inter_list[j].sin.sin_addr.s_addr ==
|
|
inter_list[i].sin.sin_addr.s_addr) {
|
|
break;
|
|
}
|
|
if (j == i)
|
|
i++;
|
|
if (i > MAXINTERFACES)
|
|
break;
|
|
}
|
|
closesocket(vs);
|
|
#endif /* _BSDI_VERSION >= 199510 */
|
|
|
|
ninterfaces = i;
|
|
maxactivefd = 0;
|
|
FD_ZERO(&activefds);
|
|
for (i = 0; i < ninterfaces; i++) {
|
|
inter_list[i].fd = open_socket(&inter_list[i].sin,
|
|
inter_list[i].flags & INT_BROADCAST, 0);
|
|
}
|
|
|
|
/*
|
|
* Now that we have opened all the sockets, turn off the reuse flag for
|
|
* security.
|
|
*/
|
|
for (i = 0; i < ninterfaces; i++) {
|
|
int off = 0;
|
|
|
|
/*
|
|
* if inter_list[ n ].fd is -1, we might have a adapter
|
|
* configured but not present
|
|
*/
|
|
if ( inter_list[ i ].fd != -1 ) {
|
|
if (setsockopt(inter_list[i].fd, SOL_SOCKET,
|
|
SO_REUSEADDR, (char *)&off,
|
|
sizeof(off))) {
|
|
msyslog(LOG_ERR, "create_sockets: setsockopt(SO_REUSEADDR,off) failed: %m");
|
|
}
|
|
}
|
|
}
|
|
|
|
#if defined(MCAST)
|
|
/*
|
|
* enable possible multicast reception on the broadcast socket
|
|
*/
|
|
inter_list[0].bcast.sin_addr.s_addr = htonl(INADDR_ANY);
|
|
inter_list[0].bcast.sin_family = AF_INET;
|
|
inter_list[0].bcast.sin_port = port;
|
|
#endif /* MCAST */
|
|
|
|
/*
|
|
* Blacklist all bound interface addresses
|
|
*/
|
|
resmask.sin_addr.s_addr = ~ (u_int32)0;
|
|
for (i = 1; i < ninterfaces; i++)
|
|
hack_restrict(RESTRICT_FLAGS, &inter_list[i].sin, &resmask,
|
|
RESM_NTPONLY|RESM_INTERFACE, RES_IGNORE);
|
|
#ifdef DEBUG
|
|
if (debug > 1) {
|
|
printf("create_sockets: ninterfaces=%d\n", ninterfaces);
|
|
for (i = 0; i < ninterfaces; i++) {
|
|
printf("interface %d: fd=%d, bfd=%d, name=%.8s, flags=0x%x\n",
|
|
i,
|
|
inter_list[i].fd,
|
|
inter_list[i].bfd,
|
|
inter_list[i].name,
|
|
inter_list[i].flags);
|
|
/* Leave these as three printf calls. */
|
|
printf(" sin=%s",
|
|
inet_ntoa((inter_list[i].sin.sin_addr)));
|
|
if (inter_list[i].flags & INT_BROADCAST)
|
|
printf(" bcast=%s,",
|
|
inet_ntoa((inter_list[i].bcast.sin_addr)));
|
|
printf(" mask=%s\n",
|
|
inet_ntoa((inter_list[i].mask.sin_addr)));
|
|
}
|
|
}
|
|
#endif
|
|
#if defined (HAVE_IO_COMPLETION_PORT)
|
|
for (i = 0; i < ninterfaces; i++) {
|
|
io_completion_port_add_socket(&inter_list[i]);
|
|
}
|
|
#endif
|
|
return ninterfaces;
|
|
}
|
|
|
|
/*
|
|
* io_setbclient - open the broadcast client sockets
|
|
*/
|
|
void
|
|
io_setbclient(void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 1; i < ninterfaces; i++) {
|
|
if (!(inter_list[i].flags & INT_BROADCAST))
|
|
continue;
|
|
|
|
if (inter_list[i].flags & INT_BCASTOPEN)
|
|
continue;
|
|
|
|
#ifdef SYS_SOLARIS
|
|
inter_list[i].bcast.sin_addr.s_addr = htonl(INADDR_ANY);
|
|
#endif
|
|
#ifdef OPEN_BCAST_SOCKET /* Was: !SYS_DOMAINOS && !SYS_LINUX */
|
|
inter_list[i].bfd = open_socket(&inter_list[i].bcast,
|
|
INT_BROADCAST, 1);
|
|
inter_list[i].flags |= INT_BCASTOPEN;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* io_multicast_add() - add multicast group address
|
|
*/
|
|
void
|
|
io_multicast_add(
|
|
u_int32 addr
|
|
)
|
|
{
|
|
#ifdef MCAST
|
|
struct ip_mreq mreq;
|
|
int i = ninterfaces; /* Use the next interface */
|
|
u_int32 haddr = ntohl(addr);
|
|
struct in_addr iaddr;
|
|
int s;
|
|
struct sockaddr_in *sinp;
|
|
|
|
iaddr.s_addr = addr;
|
|
if (!IN_CLASSD(haddr)) {
|
|
msyslog(LOG_ERR,
|
|
"multicast address %s not class D",
|
|
inet_ntoa(iaddr));
|
|
return;
|
|
}
|
|
for (i = 0; i < ninterfaces; i++) {
|
|
/* Already have this address */
|
|
if (inter_list[i].sin.sin_addr.s_addr == addr)
|
|
return;
|
|
/* found a free slot */
|
|
if (inter_list[i].sin.sin_addr.s_addr == 0 &&
|
|
inter_list[i].fd <= 0 && inter_list[i].bfd <= 0 &&
|
|
inter_list[i].flags == 0)
|
|
break;
|
|
}
|
|
sinp = &(inter_list[i].sin);
|
|
memset((char *)&mreq, 0, sizeof(mreq));
|
|
memset((char *)&inter_list[i], 0, sizeof inter_list[0]);
|
|
sinp->sin_family = AF_INET;
|
|
sinp->sin_addr = iaddr;
|
|
sinp->sin_port = htons(123);
|
|
|
|
/*
|
|
* Try opening a socket for the specified class D address. This
|
|
* works under SunOS 4.x, but not OSF1 .. :-(
|
|
*/
|
|
s = open_socket(sinp, 0, 1);
|
|
if (s < 0) {
|
|
memset((char *)&inter_list[i], 0, sizeof inter_list[0]);
|
|
i = 0;
|
|
/* HACK ! -- stuff in an address */
|
|
inter_list[i].bcast.sin_addr.s_addr = addr;
|
|
msyslog(LOG_ERR,
|
|
"...multicast address %s using wildcard socket",
|
|
inet_ntoa(iaddr));
|
|
} else {
|
|
inter_list[i].fd = s;
|
|
inter_list[i].bfd = -1;
|
|
(void) strncpy(inter_list[i].name, "multicast",
|
|
sizeof(inter_list[i].name));
|
|
inter_list[i].mask.sin_addr.s_addr = htonl(~(u_int32)0);
|
|
}
|
|
|
|
/*
|
|
* enable reception of multicast packets
|
|
*/
|
|
mreq.imr_multiaddr = iaddr;
|
|
mreq.imr_interface.s_addr = htonl(INADDR_ANY);
|
|
if (setsockopt(inter_list[i].fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
|
|
(char *)&mreq, sizeof(mreq)) == -1)
|
|
msyslog(LOG_ERR,
|
|
"setsockopt IP_ADD_MEMBERSHIP fails: %m for %x / %x (%s)",
|
|
mreq.imr_multiaddr.s_addr,
|
|
mreq.imr_interface.s_addr, inet_ntoa(iaddr));
|
|
inter_list[i].flags |= INT_MULTICAST;
|
|
if (i >= ninterfaces)
|
|
ninterfaces = i+1;
|
|
#else /* MCAST */
|
|
struct in_addr iaddr;
|
|
|
|
iaddr.s_addr = addr;
|
|
msyslog(LOG_ERR,
|
|
"cannot add multicast address %s as no MCAST support",
|
|
inet_ntoa(iaddr));
|
|
#endif /* MCAST */
|
|
}
|
|
|
|
/*
|
|
* io_unsetbclient - close the broadcast client sockets
|
|
*/
|
|
void
|
|
io_unsetbclient(void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 1; i < ninterfaces; i++)
|
|
{
|
|
if (!(inter_list[i].flags & INT_BCASTOPEN))
|
|
continue;
|
|
close_socket(inter_list[i].bfd);
|
|
inter_list[i].bfd = -1;
|
|
inter_list[i].flags &= ~INT_BCASTOPEN;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* io_multicast_del() - delete multicast group address
|
|
*/
|
|
void
|
|
io_multicast_del(
|
|
u_int32 addr
|
|
)
|
|
{
|
|
#ifdef MCAST
|
|
int i;
|
|
struct ip_mreq mreq;
|
|
u_int32 haddr = ntohl(addr);
|
|
struct sockaddr_in sinaddr;
|
|
|
|
if (!IN_CLASSD(haddr))
|
|
{
|
|
sinaddr.sin_addr.s_addr = addr;
|
|
msyslog(LOG_ERR,
|
|
"invalid multicast address %s", ntoa(&sinaddr));
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Disable reception of multicast packets
|
|
*/
|
|
mreq.imr_multiaddr.s_addr = addr;
|
|
mreq.imr_interface.s_addr = htonl(INADDR_ANY);
|
|
for (i = 0; i < ninterfaces; i++)
|
|
{
|
|
if (!(inter_list[i].flags & INT_MULTICAST))
|
|
continue;
|
|
if (!(inter_list[i].fd < 0))
|
|
continue;
|
|
if (addr != inter_list[i].sin.sin_addr.s_addr)
|
|
continue;
|
|
if (i != 0)
|
|
{
|
|
/* we have an explicit fd, so we can close it */
|
|
close_socket(inter_list[i].fd);
|
|
memset((char *)&inter_list[i], 0, sizeof inter_list[0]);
|
|
inter_list[i].fd = -1;
|
|
inter_list[i].bfd = -1;
|
|
}
|
|
else
|
|
{
|
|
/* We are sharing "any address" port :-( Don't close it! */
|
|
if (setsockopt(inter_list[i].fd, IPPROTO_IP, IP_DROP_MEMBERSHIP,
|
|
(char *)&mreq, sizeof(mreq)) == -1)
|
|
msyslog(LOG_ERR, "setsockopt IP_DROP_MEMBERSHIP fails: %m");
|
|
/* This is **WRONG** -- there may be others ! */
|
|
/* There should be a count of users ... */
|
|
inter_list[i].flags &= ~INT_MULTICAST;
|
|
}
|
|
}
|
|
#else /* not MCAST */
|
|
msyslog(LOG_ERR, "this function requires multicast kernel");
|
|
#endif /* not MCAST */
|
|
}
|
|
|
|
|
|
/*
|
|
* open_socket - open a socket, returning the file descriptor
|
|
*/
|
|
static int
|
|
open_socket(
|
|
struct sockaddr_in *addr,
|
|
int flags,
|
|
int turn_off_reuse
|
|
)
|
|
{
|
|
int fd;
|
|
int on = 1, off = 0;
|
|
#if defined(IPTOS_LOWDELAY) && defined(IPPROTO_IP) && defined(IP_TOS)
|
|
int tos;
|
|
#endif /* IPTOS_LOWDELAY && IPPROTO_IP && IP_TOS */
|
|
|
|
/* create a datagram (UDP) socket */
|
|
if ( (fd = socket(AF_INET, SOCK_DGRAM, 0))
|
|
#ifndef SYS_WINNT
|
|
< 0
|
|
#else
|
|
== INVALID_SOCKET
|
|
#endif /* SYS_WINNT */
|
|
)
|
|
{
|
|
msyslog(LOG_ERR, "socket(AF_INET, SOCK_DGRAM, 0) failed: %m");
|
|
exit(1);
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
/* set SO_REUSEADDR since we will be binding the same port
|
|
number on each interface */
|
|
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
|
|
(char *)&on, sizeof(on)))
|
|
{
|
|
msyslog(LOG_ERR, "setsockopt SO_REUSEADDR on fails: %m");
|
|
}
|
|
|
|
#if defined(IPTOS_LOWDELAY) && defined(IPPROTO_IP) && defined(IP_TOS)
|
|
/* set IP_TOS to minimize packet delay */
|
|
tos = IPTOS_LOWDELAY;
|
|
if (setsockopt(fd, IPPROTO_IP, IP_TOS, (char *) &tos, sizeof(tos)) < 0)
|
|
{
|
|
msyslog(LOG_ERR, "setsockopt IPTOS_LOWDELAY on fails: %m");
|
|
}
|
|
#endif /* IPTOS_LOWDELAY && IPPROTO_IP && IP_TOS */
|
|
|
|
/*
|
|
* bind the local address.
|
|
*/
|
|
if (bind(fd, (struct sockaddr *)addr, sizeof(*addr)) < 0) {
|
|
char buff[160];
|
|
sprintf(buff,
|
|
"bind() fd %d, family %d, port %d, addr %s, in_classd=%d flags=%d fails: %%m",
|
|
fd, addr->sin_family, (int)ntohs(addr->sin_port),
|
|
ntoa(addr),
|
|
IN_CLASSD(ntohl(addr->sin_addr.s_addr)), flags);
|
|
msyslog(LOG_ERR, buff);
|
|
closesocket(fd);
|
|
|
|
/*
|
|
* soft fail if opening a class D address
|
|
*/
|
|
if (IN_CLASSD(ntohl(addr->sin_addr.s_addr)))
|
|
return -1;
|
|
#if 0
|
|
exit(1);
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
#ifdef DEBUG
|
|
if (debug)
|
|
printf("bind() fd %d, family %d, port %d, addr %s, flags=%d\n",
|
|
fd,
|
|
addr->sin_family,
|
|
(int)ntohs(addr->sin_port),
|
|
ntoa(addr),
|
|
flags);
|
|
#endif
|
|
if (fd > maxactivefd)
|
|
maxactivefd = fd;
|
|
FD_SET(fd, &activefds);
|
|
|
|
/*
|
|
* set non-blocking,
|
|
*/
|
|
|
|
#ifdef USE_FIONBIO
|
|
/* in vxWorks we use FIONBIO, but the others are defined for old systems, so
|
|
* all hell breaks loose if we leave them defined
|
|
*/
|
|
#undef O_NONBLOCK
|
|
#undef FNDELAY
|
|
#undef O_NDELAY
|
|
#endif
|
|
|
|
#if defined(O_NONBLOCK) /* POSIX */
|
|
if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0)
|
|
{
|
|
msyslog(LOG_ERR, "fcntl(O_NONBLOCK) fails: %m");
|
|
exit(1);
|
|
/*NOTREACHED*/
|
|
}
|
|
#elif defined(FNDELAY)
|
|
if (fcntl(fd, F_SETFL, FNDELAY) < 0)
|
|
{
|
|
msyslog(LOG_ERR, "fcntl(FNDELAY) fails: %m");
|
|
exit(1);
|
|
/*NOTREACHED*/
|
|
}
|
|
#elif defined(O_NDELAY) /* generally the same as FNDELAY */
|
|
if (fcntl(fd, F_SETFL, O_NDELAY) < 0)
|
|
{
|
|
msyslog(LOG_ERR, "fcntl(O_NDELAY) fails: %m");
|
|
exit(1);
|
|
/*NOTREACHED*/
|
|
}
|
|
#elif defined(FIONBIO)
|
|
if (
|
|
# if defined(VMS)
|
|
(ioctl(fd,FIONBIO,&1) < 0)
|
|
# elif defined(SYS_WINNT)
|
|
(ioctlsocket(fd,FIONBIO,(u_long *) &on) == SOCKET_ERROR)
|
|
# else
|
|
(ioctl(fd,FIONBIO,&on) < 0)
|
|
# endif
|
|
)
|
|
{
|
|
msyslog(LOG_ERR, "ioctl(FIONBIO) fails: %m");
|
|
exit(1);
|
|
/*NOTREACHED*/
|
|
}
|
|
#elif defined(FIOSNBIO)
|
|
if (ioctl(fd,FIOSNBIO,&on) < 0)
|
|
{
|
|
msyslog(LOG_ERR, "ioctl(FIOSNBIO) fails: %m");
|
|
exit(1);
|
|
/*NOTREACHED*/
|
|
}
|
|
#else
|
|
# include "Bletch: Need non-blocking I/O!"
|
|
#endif
|
|
|
|
#ifdef HAVE_SIGNALED_IO
|
|
init_socket_sig(fd);
|
|
#endif /* not HAVE_SIGNALED_IO */
|
|
|
|
/*
|
|
* Turn off the SO_REUSEADDR socket option. It apparently
|
|
* causes heartburn on systems with multicast IP installed.
|
|
* On normal systems it only gets looked at when the address
|
|
* is being bound anyway..
|
|
*/
|
|
if (turn_off_reuse)
|
|
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
|
|
(char *)&off, sizeof(off)))
|
|
{
|
|
msyslog(LOG_ERR, "setsockopt SO_REUSEADDR off fails: %m");
|
|
}
|
|
|
|
#ifdef SO_BROADCAST
|
|
/* if this interface can support broadcast, set SO_BROADCAST */
|
|
if (flags & INT_BROADCAST)
|
|
{
|
|
if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST,
|
|
(char *)&on, sizeof(on)))
|
|
{
|
|
msyslog(LOG_ERR, "setsockopt(SO_BROADCAST): %m");
|
|
}
|
|
}
|
|
#endif /* SO_BROADCAST */
|
|
|
|
#if !defined(SYS_WINNT) && !defined(VMS)
|
|
# ifdef DEBUG
|
|
if (debug > 1)
|
|
printf("flags for fd %d: 0%o\n", fd,
|
|
fcntl(fd, F_GETFL, 0));
|
|
# endif
|
|
#endif /* SYS_WINNT || VMS */
|
|
|
|
return fd;
|
|
}
|
|
|
|
|
|
/*
|
|
* close_socket - close a socket and remove from the activefd list
|
|
*/
|
|
static void
|
|
close_socket(
|
|
int fd
|
|
)
|
|
{
|
|
int i, newmax;
|
|
|
|
(void) closesocket(fd);
|
|
FD_CLR( (u_int) fd, &activefds);
|
|
|
|
if (fd >= maxactivefd) {
|
|
newmax = 0;
|
|
for (i = 0; i < maxactivefd; i++)
|
|
if (FD_ISSET(i, &activefds))
|
|
newmax = i;
|
|
maxactivefd = newmax;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* close_file - close a file and remove from the activefd list
|
|
* added 1/31/1997 Greg Schueman for Windows NT portability
|
|
*/
|
|
static void
|
|
close_file(
|
|
int fd
|
|
)
|
|
{
|
|
int i, newmax;
|
|
|
|
(void) close(fd);
|
|
FD_CLR( (u_int) fd, &activefds);
|
|
|
|
if (fd >= maxactivefd) {
|
|
newmax = 0;
|
|
for (i = 0; i < maxactivefd; i++)
|
|
if (FD_ISSET(i, &activefds))
|
|
newmax = i;
|
|
maxactivefd = newmax;
|
|
}
|
|
}
|
|
|
|
|
|
/* XXX ELIMINATE sendpkt similar in ntpq.c, ntpdc.c, ntp_io.c, ntptrace.c */
|
|
/*
|
|
* sendpkt - send a packet to the specified destination. Maintain a
|
|
* send error cache so that only the first consecutive error for a
|
|
* destination is logged.
|
|
*/
|
|
void
|
|
sendpkt(
|
|
struct sockaddr_in *dest,
|
|
struct interface *inter,
|
|
int ttl,
|
|
struct pkt *pkt,
|
|
int len
|
|
)
|
|
{
|
|
int cc, slot;
|
|
#ifdef SYS_WINNT
|
|
DWORD err;
|
|
#endif /* SYS_WINNT */
|
|
|
|
/*
|
|
* Send error cache. Empty slots have port == 0
|
|
* Set ERRORCACHESIZE to 0 to disable
|
|
*/
|
|
struct cache {
|
|
u_short port;
|
|
struct in_addr addr;
|
|
};
|
|
|
|
#ifndef ERRORCACHESIZE
|
|
#define ERRORCACHESIZE 8
|
|
#endif
|
|
#if ERRORCACHESIZE > 0
|
|
static struct cache badaddrs[ERRORCACHESIZE];
|
|
#else
|
|
#define badaddrs ((struct cache *)0) /* Only used in empty loops! */
|
|
#endif
|
|
#ifdef DEBUG
|
|
if (debug > 1)
|
|
printf("%ssendpkt(fd=%d dst=%s, src=%s, ttl=%d, len=%d)\n",
|
|
(ttl >= 0) ? "\tMCAST\t*****" : "",
|
|
inter->fd, ntoa(dest),
|
|
ntoa(&inter->sin), ttl, len);
|
|
#endif
|
|
|
|
#ifdef MCAST
|
|
/*
|
|
* for the moment we use the bcast option to set multicast ttl
|
|
*/
|
|
if (ttl > 0 && ttl != inter->last_ttl) {
|
|
char mttl = ttl;
|
|
|
|
/*
|
|
* set the multicast ttl for outgoing packets
|
|
*/
|
|
if (setsockopt(inter->fd, IPPROTO_IP, IP_MULTICAST_TTL,
|
|
&mttl, sizeof(mttl)) == -1)
|
|
msyslog(LOG_ERR, "setsockopt IP_MULTICAST_TTL fails: %m");
|
|
else
|
|
inter->last_ttl = ttl;
|
|
}
|
|
#endif /* MCAST */
|
|
|
|
for (slot = ERRORCACHESIZE; --slot >= 0; )
|
|
if (badaddrs[slot].port == dest->sin_port &&
|
|
badaddrs[slot].addr.s_addr == dest->sin_addr.s_addr)
|
|
break;
|
|
|
|
#if defined(HAVE_IO_COMPLETION_PORT)
|
|
err = io_completion_port_sendto(inter, pkt, len, dest);
|
|
if (err != ERROR_SUCCESS)
|
|
#else
|
|
cc = sendto(inter->fd, (char *)pkt, (size_t)len, 0, (struct sockaddr *)dest,
|
|
sizeof(struct sockaddr_in));
|
|
if (cc == -1)
|
|
#endif
|
|
{
|
|
inter->notsent++;
|
|
packets_notsent++;
|
|
#if defined(HAVE_IO_COMPLETION_PORT)
|
|
if (err != WSAEWOULDBLOCK && err != WSAENOBUFS && slot < 0)
|
|
#else
|
|
if (errno != EWOULDBLOCK && errno != ENOBUFS && slot < 0)
|
|
#endif
|
|
{
|
|
/*
|
|
* Remember this, if there's an empty slot
|
|
*/
|
|
for (slot = ERRORCACHESIZE; --slot >= 0; )
|
|
if (badaddrs[slot].port == 0)
|
|
{
|
|
badaddrs[slot].port = dest->sin_port;
|
|
badaddrs[slot].addr = dest->sin_addr;
|
|
break;
|
|
}
|
|
msyslog(LOG_ERR, "sendto(%s): %m", ntoa(dest));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
inter->sent++;
|
|
packets_sent++;
|
|
/*
|
|
* He's not bad any more
|
|
*/
|
|
if (slot >= 0)
|
|
{
|
|
msyslog(LOG_INFO, "Connection re-established to %s", ntoa(dest));
|
|
badaddrs[slot].port = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if !defined(HAVE_IO_COMPLETION_PORT)
|
|
/*
|
|
* fdbits - generate ascii representation of fd_set (FAU debug support)
|
|
* HFDF format - highest fd first.
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* input_handler - receive packets asynchronously
|
|
*/
|
|
extern void
|
|
input_handler(
|
|
l_fp *cts
|
|
)
|
|
{
|
|
register int i, n;
|
|
register struct recvbuf *rb;
|
|
register int doing;
|
|
register int fd;
|
|
struct timeval tvzero;
|
|
int fromlen;
|
|
l_fp ts; /* Timestamp at BOselect() gob */
|
|
l_fp ts_e; /* Timestamp at EOselect() gob */
|
|
fd_set fds;
|
|
int select_count = 0;
|
|
static int handler_count = 0;
|
|
|
|
++handler_count;
|
|
if (handler_count != 1)
|
|
msyslog(LOG_ERR, "input_handler: handler_count is %d!", handler_count);
|
|
handler_calls++;
|
|
ts = *cts;
|
|
|
|
for (;;)
|
|
{
|
|
/*
|
|
* Do a poll to see who has data
|
|
*/
|
|
|
|
fds = activefds;
|
|
tvzero.tv_sec = tvzero.tv_usec = 0;
|
|
|
|
/*
|
|
* If we have something to do, freeze a timestamp.
|
|
* See below for the other cases (nothing (left) to do or error)
|
|
*/
|
|
while (0 < (n = select(maxactivefd+1, &fds, (fd_set *)0, (fd_set *)0, &tvzero)))
|
|
{
|
|
++select_count;
|
|
++handler_pkts;
|
|
|
|
#ifdef REFCLOCK
|
|
/*
|
|
* Check out the reference clocks first, if any
|
|
*/
|
|
if (refio != 0)
|
|
{
|
|
register struct refclockio *rp;
|
|
|
|
for (rp = refio; rp != 0 && n > 0; rp = rp->next)
|
|
{
|
|
fd = rp->fd;
|
|
if (FD_ISSET(fd, &fds))
|
|
{
|
|
n--;
|
|
if (free_recvbuffs() == 0)
|
|
{
|
|
char buf[RX_BUFF_SIZE];
|
|
|
|
(void) read(fd, buf, sizeof buf);
|
|
packets_dropped++;
|
|
goto select_again;
|
|
}
|
|
|
|
rb = get_free_recv_buffer();
|
|
|
|
i = (rp->datalen == 0
|
|
|| rp->datalen > sizeof(rb->recv_space))
|
|
? sizeof(rb->recv_space) : rp->datalen;
|
|
rb->recv_length =
|
|
read(fd, (char *)&rb->recv_space, (unsigned)i);
|
|
|
|
if (rb->recv_length == -1)
|
|
{
|
|
msyslog(LOG_ERR, "clock read fd %d: %m", fd);
|
|
freerecvbuf(rb);
|
|
goto select_again;
|
|
}
|
|
|
|
/*
|
|
* Got one. Mark how and when it got here,
|
|
* put it on the full list and do bookkeeping.
|
|
*/
|
|
rb->recv_srcclock = rp->srcclock;
|
|
rb->dstadr = 0;
|
|
rb->fd = fd;
|
|
rb->recv_time = ts;
|
|
rb->receiver = rp->clock_recv;
|
|
|
|
if (rp->io_input)
|
|
{
|
|
/*
|
|
* have direct input routine for refclocks
|
|
*/
|
|
if (rp->io_input(rb) == 0)
|
|
{
|
|
/*
|
|
* data was consumed - nothing to pass up
|
|
* into block input machine
|
|
*/
|
|
freerecvbuf(rb);
|
|
#if 1
|
|
goto select_again;
|
|
#else
|
|
continue;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
add_full_recv_buffer(rb);
|
|
|
|
rp->recvcount++;
|
|
packets_received++;
|
|
}
|
|
}
|
|
}
|
|
#endif /* REFCLOCK */
|
|
|
|
/*
|
|
* Loop through the interfaces looking for data to read.
|
|
*/
|
|
for (i = ninterfaces - 1; (i >= 0) && (n > 0); i--)
|
|
{
|
|
for (doing = 0; (doing < 2) && (n > 0); doing++)
|
|
{
|
|
if (doing == 0)
|
|
{
|
|
fd = inter_list[i].fd;
|
|
}
|
|
else
|
|
{
|
|
if (!(inter_list[i].flags & INT_BCASTOPEN))
|
|
break;
|
|
fd = inter_list[i].bfd;
|
|
}
|
|
if (fd < 0) continue;
|
|
if (FD_ISSET(fd, &fds))
|
|
{
|
|
n--;
|
|
|
|
/*
|
|
* Get a buffer and read the frame. If we
|
|
* haven't got a buffer, or this is received
|
|
* on the wild card socket, just dump the
|
|
* packet.
|
|
*/
|
|
if (
|
|
#ifdef UDP_WILDCARD_DELIVERY
|
|
/*
|
|
* these guys manage to put properly addressed
|
|
* packets into the wildcard queue
|
|
*/
|
|
(free_recvbuffs() == 0)
|
|
#else
|
|
((i == 0) || (free_recvbuffs() == 0))
|
|
#endif
|
|
)
|
|
{
|
|
char buf[RX_BUFF_SIZE];
|
|
struct sockaddr from;
|
|
|
|
fromlen = sizeof from;
|
|
(void) recvfrom(fd, buf, sizeof(buf), 0, &from, &fromlen);
|
|
#ifdef DEBUG
|
|
if (debug)
|
|
printf("%s on %d(%lu) fd=%d from %s\n",
|
|
(i) ? "drop" : "ignore",
|
|
i, free_recvbuffs(), fd,
|
|
inet_ntoa(((struct sockaddr_in *) &from)->sin_addr));
|
|
#endif
|
|
if (i == 0)
|
|
packets_ignored++;
|
|
else
|
|
packets_dropped++;
|
|
goto select_again;
|
|
}
|
|
|
|
rb = get_free_recv_buffer();
|
|
|
|
fromlen = sizeof(struct sockaddr_in);
|
|
rb->recv_length = recvfrom(fd,
|
|
(char *)&rb->recv_space,
|
|
sizeof(rb->recv_space), 0,
|
|
(struct sockaddr *)&rb->recv_srcadr,
|
|
&fromlen);
|
|
if (rb->recv_length == 0
|
|
#ifdef EWOULDBLOCK
|
|
|| errno==EWOULDBLOCK
|
|
#endif
|
|
#ifdef EAGAIN
|
|
|| errno==EAGAIN
|
|
#endif
|
|
) {
|
|
freerecvbuf(rb);
|
|
continue;
|
|
}
|
|
else if (rb->recv_length < 0)
|
|
{
|
|
msyslog(LOG_ERR, "recvfrom(%s) fd=%d: %m",
|
|
inet_ntoa(rb->recv_srcadr.sin_addr), fd);
|
|
#ifdef DEBUG
|
|
if (debug)
|
|
printf("input_handler: fd=%d dropped (bad recvfrom)\n", fd);
|
|
#endif
|
|
freerecvbuf(rb);
|
|
continue;
|
|
}
|
|
#ifdef DEBUG
|
|
if (debug > 2)
|
|
printf("input_handler: if=%d fd=%d length %d from %08lx %s\n",
|
|
i, fd, rb->recv_length,
|
|
(u_long)ntohl(rb->recv_srcadr.sin_addr.s_addr) &
|
|
0x00000000ffffffff,
|
|
inet_ntoa(rb->recv_srcadr.sin_addr));
|
|
#endif
|
|
|
|
/*
|
|
* Got one. Mark how and when it got here,
|
|
* put it on the full list and do bookkeeping.
|
|
*/
|
|
rb->dstadr = &inter_list[i];
|
|
rb->fd = fd;
|
|
rb->recv_time = ts;
|
|
rb->receiver = receive;
|
|
|
|
add_full_recv_buffer(rb);
|
|
|
|
inter_list[i].received++;
|
|
packets_received++;
|
|
goto select_again;
|
|
}
|
|
/* Check more interfaces */
|
|
}
|
|
}
|
|
select_again:;
|
|
/*
|
|
* Done everything from that select. Poll again.
|
|
*/
|
|
}
|
|
|
|
/*
|
|
* If nothing more to do, try again.
|
|
* If nothing to do, just return.
|
|
* If an error occurred, complain and return.
|
|
*/
|
|
if (n == 0)
|
|
{
|
|
if (select_count == 0) /* We really had nothing to do */
|
|
{
|
|
if (debug)
|
|
msyslog(LOG_DEBUG, "input_handler: select() returned 0");
|
|
--handler_count;
|
|
return;
|
|
}
|
|
/* We've done our work */
|
|
get_systime(&ts_e);
|
|
/*
|
|
* (ts_e - ts) is the amount of time we spent processing
|
|
* this gob of file descriptors. Log it.
|
|
*/
|
|
L_SUB(&ts_e, &ts);
|
|
if (debug > 3)
|
|
msyslog(LOG_INFO, "input_handler: Processed a gob of fd's in %s msec", lfptoms(&ts_e, 6));
|
|
|
|
/* just bail. */
|
|
--handler_count;
|
|
return;
|
|
}
|
|
else if (n == -1)
|
|
{
|
|
int err = errno;
|
|
|
|
/*
|
|
* extended FAU debugging output
|
|
*/
|
|
msyslog(LOG_ERR, "select(%d, %s, 0L, 0L, &0.000000) 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))
|
|
)
|
|
msyslog(LOG_ERR, "Bad file descriptor %d", j);
|
|
}
|
|
--handler_count;
|
|
return;
|
|
}
|
|
}
|
|
msyslog(LOG_ERR, "input_handler: fell out of infinite for(;;) loop!");
|
|
--handler_count;
|
|
return;
|
|
}
|
|
|
|
#endif
|
|
|
|
/*
|
|
* findinterface - find interface corresponding to address
|
|
*/
|
|
struct interface *
|
|
findinterface(
|
|
struct sockaddr_in *addr
|
|
)
|
|
{
|
|
int s, rtn, i;
|
|
struct sockaddr_in saddr;
|
|
int saddrlen = sizeof(saddr);
|
|
u_int32 xaddr;
|
|
|
|
/*
|
|
* This is considerably hoke. We open a socket, connect to it
|
|
* and slap a getsockname() on it. If anything breaks, as it
|
|
* probably will in some j-random knockoff, we just return the
|
|
* wildcard interface.
|
|
*/
|
|
saddr.sin_family = AF_INET;
|
|
saddr.sin_addr.s_addr = addr->sin_addr.s_addr;
|
|
saddr.sin_port = htons(2000);
|
|
s = socket(AF_INET, SOCK_DGRAM, 0);
|
|
if (s < 0)
|
|
return (any_interface);
|
|
|
|
rtn = connect(s, (struct sockaddr *)&saddr, sizeof(saddr));
|
|
if (rtn < 0)
|
|
return (any_interface);
|
|
|
|
rtn = getsockname(s, (struct sockaddr *)&saddr, &saddrlen);
|
|
if (rtn < 0)
|
|
return (any_interface);
|
|
|
|
close(s);
|
|
xaddr = NSRCADR(&saddr);
|
|
for (i = 1; i < ninterfaces; i++) {
|
|
|
|
/*
|
|
* We match the unicast address only.
|
|
*/
|
|
if (NSRCADR(&inter_list[i].sin) == xaddr)
|
|
return (&inter_list[i]);
|
|
}
|
|
return (any_interface);
|
|
}
|
|
|
|
|
|
/*
|
|
* findbcastinter - find broadcast interface corresponding to address
|
|
*/
|
|
struct interface *
|
|
findbcastinter(
|
|
struct sockaddr_in *addr
|
|
)
|
|
{
|
|
#if defined(SIOCGIFCONF) || defined(SYS_WINNT)
|
|
register int i;
|
|
register u_int32 xaddr;
|
|
|
|
xaddr = NSRCADR(addr);
|
|
for (i = 1; i < ninterfaces; i++) {
|
|
|
|
/*
|
|
* We match only those interfaces marked as
|
|
* broadcastable and either the explicit broadcast
|
|
* address or the network portion of the IP address.
|
|
* Sloppy.
|
|
*/
|
|
if (!(inter_list[i].flags & INT_BROADCAST))
|
|
continue;
|
|
if (NSRCADR(&inter_list[i].bcast) == xaddr)
|
|
return (&inter_list[i]);
|
|
if ((NSRCADR(&inter_list[i].sin) &
|
|
NSRCADR(&inter_list[i].mask)) == (xaddr &
|
|
NSRCADR(&inter_list[i].mask)))
|
|
return (&inter_list[i]);
|
|
}
|
|
#endif /* SIOCGIFCONF */
|
|
return (any_interface);
|
|
}
|
|
|
|
|
|
/*
|
|
* io_clr_stats - clear I/O module statistics
|
|
*/
|
|
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
|
|
/*
|
|
* This is a hack so that I don't have to fool with these ioctls in the
|
|
* pps driver ... we are already non-blocking and turn on SIGIO thru
|
|
* another mechanisim
|
|
*/
|
|
int
|
|
io_addclock_simple(
|
|
struct refclockio *rio
|
|
)
|
|
{
|
|
BLOCKIO();
|
|
/*
|
|
* Stuff the I/O structure in the list and mark the descriptor
|
|
* in use. There is a harmless (I hope) race condition here.
|
|
*/
|
|
rio->next = refio;
|
|
refio = rio;
|
|
|
|
if (rio->fd > maxactivefd)
|
|
maxactivefd = rio->fd;
|
|
FD_SET(rio->fd, &activefds);
|
|
UNBLOCKIO();
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* io_addclock - add a reference clock to the list and arrange that we
|
|
* get SIGIO interrupts from it.
|
|
*/
|
|
int
|
|
io_addclock(
|
|
struct refclockio *rio
|
|
)
|
|
{
|
|
BLOCKIO();
|
|
/*
|
|
* Stuff the I/O structure in the list and mark the descriptor
|
|
* in use. There is a harmless (I hope) race condition here.
|
|
*/
|
|
rio->next = refio;
|
|
refio = rio;
|
|
|
|
# ifdef HAVE_SIGNALED_IO
|
|
if (init_clock_sig(rio))
|
|
{
|
|
refio = rio->next;
|
|
UNBLOCKIO();
|
|
return 0;
|
|
}
|
|
# elif defined(HAVE_IO_COMPLETION_PORT)
|
|
if (io_completion_port_add_clock_io(rio))
|
|
{
|
|
refio = rio->next;
|
|
UNBLOCKIO();
|
|
return 0;
|
|
}
|
|
# endif
|
|
|
|
if (rio->fd > maxactivefd)
|
|
maxactivefd = rio->fd;
|
|
FD_SET(rio->fd, &activefds);
|
|
|
|
UNBLOCKIO();
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* io_closeclock - close the clock in the I/O structure given
|
|
*/
|
|
void
|
|
io_closeclock(
|
|
struct refclockio *rio
|
|
)
|
|
{
|
|
/*
|
|
* Remove structure from the list
|
|
*/
|
|
if (refio == rio)
|
|
{
|
|
refio = rio->next;
|
|
}
|
|
else
|
|
{
|
|
register struct refclockio *rp;
|
|
|
|
for (rp = refio; rp != 0; rp = rp->next)
|
|
if (rp->next == rio)
|
|
{
|
|
rp->next = rio->next;
|
|
break;
|
|
}
|
|
|
|
if (rp == 0)
|
|
{
|
|
/*
|
|
* Internal error. Report it.
|
|
*/
|
|
msyslog(LOG_ERR,
|
|
"internal error: refclockio structure not found");
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Close the descriptor.
|
|
*/
|
|
close_file(rio->fd);
|
|
}
|
|
#endif /* REFCLOCK */
|
|
|
|
void
|
|
kill_asyncio(void)
|
|
{
|
|
int i;
|
|
|
|
BLOCKIO();
|
|
for (i = 0; i <= maxactivefd; i++)
|
|
(void)close_socket(i);
|
|
}
|