Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/dist/ntp/ntpd/ntp_io.c

1744 lines
40 KiB
C
Raw Blame History

/* $NetBSD: ntp_io.c,v 1.2 2000/10/09 14:57:22 is Exp $ */
/*
* ntp_io.c - input/output routines for ntpd. The socket-opening code
* was shamelessly stolen from ntpd.
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#ifdef HAVE_SYS_PARAM_H
# include <sys/param.h>
#endif /* HAVE_SYS_PARAM_H */
#ifdef HAVE_SYS_TIME_H
# include <sys/time.h>
#endif
#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
#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"
#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; /* pointer to default interface */
struct interface *loopback_interface; /* point to loopback interface */
static struct interface inter_list[MAXINTERFACES];
static 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;
#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;
(void)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);
any_interface = &inter_list[0];
#ifdef DEBUG
if (debug > 2) {
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,
"cannot add multicast address %s as it is 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);
s = open_socket(sinp, 0, 1);
/* Try opening a socket for the specified class D address */
/* This works under SunOS 4.x, but not OSF1 .. :-( */
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, tos;
int on = 1, off = 0;
/* 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) {
msyslog(LOG_ERR, "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);
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;
}
}
/*
* 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 netnum;
netnum = NSRCADR(addr);
for (i = 1; i < ninterfaces; i++)
{
if (!(inter_list[i].flags & INT_BROADCAST))
continue;
if (NSRCADR(&inter_list[i].bcast) == netnum)
return &inter_list[i];
if ((NSRCADR(&inter_list[i].sin) & NSRCADR(&inter_list[i].mask))
== (netnum & NSRCADR(&inter_list[i].mask)))
return &inter_list[i];
}
#endif /* SIOCGIFCONF */
return any_interface;
}
/* 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
/*
* check if the source address is a multicast address - replace
* interface with any-interface if so.
*/
if (IN_MULTICAST(ntohl(inter->sin.sin_addr.s_addr)))
inter = any_interface;
#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, 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() fd=%d: %m", 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: fd=%d length %d from %08lx %s\n",
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 - utility used by other modules to find an interface
* given an address.
*/
struct interface *
findinterface(
struct sockaddr_in *addr
)
{
register int i;
register u_int32 saddr;
/*
* Just match the address portion.
*/
saddr = addr->sin_addr.s_addr;
for (i = 0; i < ninterfaces; i++)
{
if (inter_list[i].sin.sin_addr.s_addr == saddr)
return &inter_list[i];
}
return (struct interface *)0;
}
/*
* 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);
}
Reference in New Issue View Git Blame Copy Permalink