#include <sys/socket.h>
#include <netdb.h>
#include <syslog.h>
#include <TargetConditionals.h>
static
int
my_getaddrinfo(const char* nodename,
const char *servname,
const struct addrinfo *hints,
struct addrinfo **res)
{
int rc = getaddrinfo(nodename, servname, hints, res);
if (rc == EAI_NONAME) {
syslog(LOG_INFO, "getaddrinfo('%s','%s') returned EAI_NONAME, mapping to EAI_AGAIN", nodename, servname);
return EAI_AGAIN;
}
return rc;
}
#define getaddrinfo my_getaddrinfo
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "ntp_machine.h"
#include "ntpd.h"
#include "ntp_io.h"
#include "ntp_request.h"
#include "ntp_stdlib.h"
#include "ntp_syslog.h"
#include "ntp_config.h"
#ifndef NO_INTRES
#include <stdio.h>
#include <ctype.h>
#include <signal.h>
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#include <arpa/inet.h>
#ifdef HAVE_SYS_PARAM_H
# include <sys/param.h>
#endif
#if defined(HAVE_RES_INIT) || defined(HAVE___RES_INIT)
#include <resolv.h>
#endif
#include <isc/net.h>
#include <isc/result.h>
#define STREQ(a, b) (*(a) == *(b) && strcmp((a), (b)) == 0)
struct conf_entry {
struct conf_entry *ce_next;
char *ce_name;
struct conf_peer ce_config;
int no_needed;
int type;
sockaddr_u peer_store;
};
#define ce_peeraddr ce_config.peeraddr
#define ce_peeraddr6 ce_config.peeraddr6
#define ce_hmode ce_config.hmode
#define ce_version ce_config.version
#define ce_minpoll ce_config.minpoll
#define ce_maxpoll ce_config.maxpoll
#define ce_flags ce_config.flags
#define ce_ttl ce_config.ttl
#define ce_keyid ce_config.keyid
#define ce_keystr ce_config.keystr
static struct conf_entry *confentries = NULL;
#define MINRESOLVE 2
#define MAXRESOLVE 32
#define CONFIG_TIME 2
#define ALARM_TIME 30
#define SLEEPTIME 2
#if TARGET_OS_EMBEDDED
#undef ALARM_TIME
#define ALARM_TIME 10
#endif
static volatile int config_timer = 0;
static volatile int resolve_timer = 0;
static int resolve_value;
#define SKEWTIME 0x08000000
#define TIMEOUT_SEC 2
#define TIMEOUT_USEC 0
#define TOK_HOSTNAME 0
#define TOK_NEEDED 1
#define TOK_TYPE 2
#define TOK_HMODE 3
#define TOK_VERSION 4
#define TOK_MINPOLL 5
#define TOK_MAXPOLL 6
#define TOK_FLAGS 7
#define TOK_TTL 8
#define TOK_KEYID 9
#define TOK_KEYSTR 10
#define NUMTOK 11
#define MAXLINESIZE 512
static SOCKET sockfd = INVALID_SOCKET;
keyid_t req_keyid;
int req_keytype;
size_t req_hashlen;
char *req_file;
static void checkparent (void);
static struct conf_entry *
removeentry (struct conf_entry *);
static void addentry (char *, int, int, int, int, int, int, u_int,
int, keyid_t, char *);
static int findhostaddr (struct conf_entry *);
static void openntp (void);
static int request (struct conf_peer *);
static char * nexttoken (char **);
static void readconf (FILE *, char *);
static void doconfigure (int);
struct ntp_res_t_pkt {
void *tag;
u_int32 paddr;
char name[MAXHOSTNAMELEN];
};
struct ntp_res_c_pkt {
char name[MAXHOSTNAMELEN];
u_int32 paddr;
int mode;
int version;
int minpoll;
int maxpoll;
u_int flags;
int ttl;
keyid_t keyid;
u_char keystr[MAXFILENAME];
};
static void resolver_exit (int);
static void resolver_exit (int code)
{
#ifdef SYS_WINNT
CloseHandle(ResolverEventHandle);
ResolverEventHandle = NULL;
_endthreadex(code);
#else
exit(code);
#endif
}
void
ntp_res_recv(void)
{
}
void
ntp_intres(void)
{
FILE *in;
#ifdef SYS_WINNT
DWORD rc;
#else
int rc;
struct timeval tv;
fd_set fdset;
int time_left;
#endif
#ifdef DEBUG
if (debug > 1) {
msyslog(LOG_INFO, "NTP_INTRES running");
}
#endif
if (sys_authenticate) {
if (!authistrusted(req_keyid)) {
msyslog(LOG_ERR, "invalid request keyid %08x",
req_keyid );
resolver_exit(1);
}
}
if ((in = fopen(req_file, "r")) == NULL) {
msyslog(LOG_ERR, "can't open configuration file %s: %m",
req_file);
resolver_exit(1);
}
readconf(in, req_file);
(void) fclose(in);
#ifdef DEBUG
if (!debug)
#endif
if (unlink(req_file))
msyslog(LOG_WARNING,
"unable to remove intres request file %s, %m",
req_file);
resolve_timer = 0;
resolve_value = MINRESOLVE;
config_timer = CONFIG_TIME;
for (;;) {
checkparent();
#if TARGET_OS_EMBEDDED
doconfigure(1);
#else // !TARGET_OS_EMBEDDED
if (resolve_timer == 0) {
sleep(SLEEPTIME);
doconfigure(1);
resolve_timer = resolve_value;
#ifdef DEBUG
if (debug > 2)
msyslog(LOG_INFO, "resolve_timer: 0->%d", resolve_timer);
#endif
if (resolve_value < MAXRESOLVE)
resolve_value <<= 1;
config_timer = CONFIG_TIME;
} else if (config_timer == 0) {
doconfigure(0);
config_timer = CONFIG_TIME;
#ifdef DEBUG
if (debug > 2)
msyslog(LOG_INFO, "config_timer: 0->%d", config_timer);
#endif
}
#endif // TARGET_OS_EMBEDDED
if (confentries == NULL)
resolver_exit(0);
#ifdef SYS_WINNT
rc = WaitForSingleObject(ResolverEventHandle, 1000 * ALARM_TIME);
if ( rc == WAIT_OBJECT_0 ) {
resolve_timer = 0;
continue;
}
if ( rc != WAIT_TIMEOUT )
resolver_exit(1);
#else
time_left = ALARM_TIME;
while (time_left > 0) {
tv.tv_sec = time_left;
tv.tv_usec = 0;
FD_ZERO(&fdset);
FD_SET(resolver_pipe_fd[0], &fdset);
rc = select(resolver_pipe_fd[0] + 1, &fdset, (fd_set *)0, (fd_set *)0, &tv);
if (rc == 0)
break;
if (rc > 0) {
read(resolver_pipe_fd[0], (char *)&rc, sizeof(rc));
resolve_timer = 0;
break;
}
if ( rc < 0 ) {
if (errno == EINTR) {
time_left -= (1<<EVENT_TIMEOUT);
continue;
}
msyslog(LOG_ERR, "ntp_intres: Error from select: %s",
strerror(errno));
resolver_exit(1);
}
}
#endif
if (config_timer > 0)
config_timer--;
if (resolve_timer > 0)
resolve_timer--;
}
}
#ifdef SYS_WINNT
unsigned WINAPI
ntp_intres_thread(void *UnusedThreadArg)
{
UNUSED_ARG(UnusedThreadArg);
ntp_intres();
return 0;
}
#endif
static void
checkparent(void)
{
#if !defined (SYS_WINNT) && !defined (SYS_VXWORKS)
if (getppid() == 1) {
msyslog(LOG_INFO, "parent died before we finished, exiting");
resolver_exit(0);
}
#endif
}
static struct conf_entry *
removeentry(
struct conf_entry *entry
)
{
register struct conf_entry *ce;
struct conf_entry *next_ce;
ce = confentries;
if (ce == entry)
confentries = ce->ce_next;
else
while (ce != NULL) {
if (ce->ce_next == entry) {
ce->ce_next = entry->ce_next;
break;
}
ce = ce->ce_next;
}
next_ce = entry->ce_next;
if (entry->ce_name != NULL)
free(entry->ce_name);
free(entry);
return next_ce;
}
static void
addentry(
char *name,
int no_needed,
int type,
int mode,
int version,
int minpoll,
int maxpoll,
u_int flags,
int ttl,
keyid_t keyid,
char *keystr
)
{
register struct conf_entry *ce;
#ifdef DEBUG
if (debug > 1)
msyslog(LOG_INFO,
"intres: <%s> %d %d %d %d %d %d %x %d %x %s",
name, no_needed, type, mode, version,
minpoll, maxpoll, flags, ttl, keyid, keystr);
#endif
ce = emalloc(sizeof(*ce));
ce->ce_name = estrdup(name);
ce->ce_peeraddr = 0;
#ifdef ISC_PLATFORM_HAVEIPV6
ce->ce_peeraddr6 = in6addr_any;
#endif
ZERO_SOCK(&ce->peer_store);
ce->ce_hmode = (u_char)mode;
ce->ce_version = (u_char)version;
ce->ce_minpoll = (u_char)minpoll;
ce->ce_maxpoll = (u_char)maxpoll;
ce->no_needed = no_needed;
ce->type = type;
ce->ce_flags = (u_char)flags;
ce->ce_ttl = (u_char)ttl;
ce->ce_keyid = keyid;
if (keyid) {
strlcpy((char *)ce->ce_keystr, keystr, MAXFILENAME);
} else {
strlcpy((char *)ce->ce_keystr, name, MAXFILENAME);
}
strncpy(ce->ce_keystr, keystr, sizeof(ce->ce_keystr) - 1);
ce->ce_keystr[sizeof(ce->ce_keystr) - 1] = 0;
ce->ce_next = NULL;
if (confentries == NULL) {
confentries = ce;
} else {
register struct conf_entry *cep;
for (cep = confentries; cep->ce_next != NULL;
cep = cep->ce_next)
;
cep->ce_next = ce;
}
}
static int
findhostaddr(
struct conf_entry *entry
)
{
static int eai_again_seen = 0;
struct addrinfo *addr;
struct addrinfo hints;
int again;
int error;
checkparent();
if (entry->ce_name != NULL && !SOCK_UNSPEC(&entry->peer_store)) {
msyslog(LOG_ERR, "findhostaddr: both ce_name and ce_peeraddr are defined...");
return 1;
}
if (entry->ce_name == NULL && SOCK_UNSPEC(&entry->peer_store)) {
msyslog(LOG_ERR, "findhostaddr: both ce_name and ce_peeraddr are undefined!");
return 0;
}
if (entry->ce_name) {
DPRINTF(2, ("findhostaddr: Resolving <%s>\n",
entry->ce_name));
memset(&hints, 0, sizeof(hints));
hints.ai_family = entry->type;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
if (!ipv6_works)
hints.ai_family = AF_INET;
error = getaddrinfo(entry->ce_name, NULL, &hints, &addr);
if (error == 0) {
entry->peer_store = *((sockaddr_u *)(addr->ai_addr));
if (IS_IPV4(&entry->peer_store)) {
entry->ce_peeraddr =
NSRCADR(&entry->peer_store);
entry->ce_config.v6_flag = 0;
} else {
entry->ce_peeraddr6 =
SOCK_ADDR6(&entry->peer_store);
entry->ce_config.v6_flag = 1;
}
freeaddrinfo(addr);
}
} else {
DPRINTF(2, ("findhostaddr: Resolving <%s>\n",
stoa(&entry->peer_store)));
entry->ce_name = emalloc(MAXHOSTNAMELEN);
error = getnameinfo((const struct sockaddr *)&entry->peer_store,
SOCKLEN(&entry->peer_store),
(char *)&entry->ce_name, MAXHOSTNAMELEN,
NULL, 0, 0);
}
if (0 == error) {
again = 1;
DPRINTF(2, ("findhostaddr: %s resolved.\n",
(entry->ce_name) ? "name" : "address"));
} else {
again = 0;
switch (error) {
case EAI_FAIL:
again = 1;
break;
case EAI_AGAIN:
again = 1;
eai_again_seen = 1;
break;
case EAI_NONAME:
#if defined(EAI_NODATA) && (EAI_NODATA != EAI_NONAME)
case EAI_NODATA:
#endif
msyslog(LOG_ERR, "host name not found%s%s: %s",
(EAI_NONAME == error) ? "" : " EAI_NODATA",
(eai_again_seen) ? " (permanent)" : "",
entry->ce_name);
again = !eai_again_seen;
break;
#ifdef EAI_SYSTEM
case EAI_SYSTEM:
again = 1;
DPRINTF(1, ("intres: EAI_SYSTEM errno %d (%s) means try again, right?\n",
errno, strerror(errno)));
break;
#endif
}
DPRINTF(2, ("intres: got error status of: %d\n", error));
}
return again;
}
static void
openntp(void)
{
const char *localhost = "127.0.0.1";
struct addrinfo hints;
struct addrinfo *addr;
u_long on;
int err;
if (sockfd != INVALID_SOCKET)
return;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_DGRAM;
err = getaddrinfo(localhost, "ntp", &hints, &addr);
if (err) {
#ifdef EAI_SYSTEM
if (EAI_SYSTEM == err)
msyslog(LOG_ERR, "getaddrinfo(%s) failed: %m",
localhost);
else
#endif
msyslog(LOG_ERR, "getaddrinfo(%s) failed: %s",
localhost, gai_strerror(err));
resolver_exit(1);
}
sockfd = socket(addr->ai_family, addr->ai_socktype, 0);
if (INVALID_SOCKET == sockfd) {
msyslog(LOG_ERR, "socket() failed: %m");
resolver_exit(1);
}
#ifndef SYS_WINNT
if (sockfd >= FD_SETSIZE) {
msyslog(LOG_ERR, "socket fd %d too large, FD_SETSIZE %d",
(int)sockfd, FD_SETSIZE);
resolver_exit(1);
}
# ifdef O_NONBLOCK
if (fcntl(sockfd, F_SETFL, O_NONBLOCK) == -1) {
msyslog(LOG_ERR, "fcntl(O_NONBLOCK) failed: %m");
resolver_exit(1);
}
# else
# ifdef FNDELAY
if (fcntl(sockfd, F_SETFL, FNDELAY) == -1) {
msyslog(LOG_ERR, "fcntl(FNDELAY) failed: %m");
resolver_exit(1);
}
# else
# include "Bletch: NEED NON BLOCKING IO"
# endif
# endif
(void)on;
#else
on = 1;
err = ioctlsocket(sockfd, FIONBIO, &on);
if (SOCKET_ERROR == err) {
msyslog(LOG_ERR, "ioctlsocket(FIONBIO) fails: %m");
resolver_exit(1);
}
#endif
err = connect(sockfd, addr->ai_addr, addr->ai_addrlen);
if (SOCKET_ERROR == err) {
msyslog(LOG_ERR, "openntp: connect() failed: %m");
resolver_exit(1);
}
freeaddrinfo(addr);
}
static int
request(
struct conf_peer *conf
)
{
struct sock_timeval tvout;
struct req_pkt reqpkt;
size_t req_len;
size_t total_len;
fd_set fdset;
l_fp ts;
char * pch;
char * pchEnd;
l_fp * pts;
keyid_t *pkeyid;
int n;
#ifdef SYS_WINNT
HANDLE hReadWriteEvent = NULL;
BOOL ret;
DWORD NumberOfBytesWritten, NumberOfBytesRead, dwWait;
OVERLAPPED overlap;
#endif
checkparent();
if (sockfd == INVALID_SOCKET)
openntp();
#ifdef SYS_WINNT
hReadWriteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
#endif
tvout.tv_sec = 0;
tvout.tv_usec = 0;
FD_ZERO(&fdset);
FD_SET(sockfd, &fdset);
while (select(sockfd + 1, &fdset, (fd_set *)0, (fd_set *)0, &tvout) >
0) {
recv(sockfd, (char *)&reqpkt, sizeof(reqpkt), 0);
FD_ZERO(&fdset);
FD_SET(sockfd, &fdset);
}
memset(&reqpkt, 0, sizeof(reqpkt));
reqpkt.rm_vn_mode = RM_VN_MODE(0, 0, 0);
reqpkt.auth_seq = AUTH_SEQ(1, 0);
reqpkt.implementation = IMPL_XNTPD;
reqpkt.request = REQ_CONFIG;
reqpkt.err_nitems = ERR_NITEMS(0, 1);
reqpkt.mbz_itemsize = MBZ_ITEMSIZE(sizeof(*conf));
if (sizeof(*conf) > sizeof(reqpkt.data)) {
msyslog(LOG_ERR,
"Bletch: conf_peer is too big for reqpkt.data!");
resolver_exit(1);
}
memcpy(reqpkt.data, conf, sizeof(*conf));
if (sys_authenticate && req_hashlen > 16) {
pch = reqpkt.data;
pch += (sizeof(*conf) + 3) & ~3;
pts = (void *)pch;
pkeyid = (void *)(pts + 1);
pchEnd = (void *)pkeyid;
req_len = pchEnd - (char *)&reqpkt;
pchEnd = (void *)(pkeyid + 1);
pchEnd += req_hashlen;
total_len = pchEnd - (char *)&reqpkt;
if (total_len > sizeof(reqpkt)) {
msyslog(LOG_ERR,
"intres total_len %u limit is %u (%u octet digest)\n",
total_len, sizeof(reqpkt),
req_hashlen);
resolver_exit(1);
}
} else {
pts = &reqpkt.tstamp;
pkeyid = &reqpkt.keyid;
req_len = REQ_LEN_NOMAC;
}
*pkeyid = htonl(req_keyid);
get_systime(&ts);
L_ADDUF(&ts, SKEWTIME);
HTONL_FP(&ts, pts);
if (sys_authenticate) {
n = authencrypt(req_keyid, (void *)&reqpkt, req_len);
if ((size_t)n != req_hashlen + sizeof(reqpkt.keyid)) {
msyslog(LOG_ERR,
"intres maclen %d expected %u\n",
n, req_hashlen + sizeof(reqpkt.keyid));
resolver_exit(1);
}
req_len += n;
}
#ifndef SYS_WINNT
n = send(sockfd, (char *)&reqpkt, req_len, 0);
if (n < 0) {
msyslog(LOG_ERR, "send to NTP server failed: %m");
return 0;
}
#else
overlap.Offset = overlap.OffsetHigh = (DWORD)0;
overlap.hEvent = hReadWriteEvent;
ret = WriteFile((HANDLE)sockfd, (char *)&reqpkt, req_len,
NULL, (LPOVERLAPPED)&overlap);
if ((ret == FALSE) && (GetLastError() != ERROR_IO_PENDING)) {
msyslog(LOG_ERR, "send to NTP server failed: %m");
return 0;
}
dwWait = WaitForSingleObject(hReadWriteEvent, (DWORD) TIMEOUT_SEC * 1000);
if ((dwWait == WAIT_FAILED) || (dwWait == WAIT_TIMEOUT)) {
if (dwWait == WAIT_FAILED)
msyslog(LOG_ERR, "WaitForSingleObject failed: %m");
return 0;
}
if (!GetOverlappedResult((HANDLE)sockfd, (LPOVERLAPPED)&overlap,
(LPDWORD)&NumberOfBytesWritten, FALSE)) {
msyslog(LOG_ERR, "GetOverlappedResult for WriteFile fails: %m");
return 0;
}
#endif
for (;;) {
FD_ZERO(&fdset);
FD_SET(sockfd, &fdset);
tvout.tv_sec = TIMEOUT_SEC;
tvout.tv_usec = TIMEOUT_USEC;
n = select(sockfd + 1, &fdset, (fd_set *)0,
(fd_set *)0, &tvout);
if (n < 0) {
if (errno != EINTR)
msyslog(LOG_ERR, "select() fails: %m");
return 0;
} else if (n == 0) {
#ifdef DEBUG
if (debug)
msyslog(LOG_INFO, "ntp_intres select() returned 0.");
#endif
return 0;
}
#ifndef SYS_WINNT
n = recv(sockfd, (char *)&reqpkt, sizeof(reqpkt), 0);
if (n <= 0) {
if (n < 0) {
msyslog(LOG_ERR, "recv() fails: %m");
return 0;
}
continue;
}
#else
ret = ReadFile((HANDLE)sockfd, (char *)&reqpkt, sizeof(reqpkt),
NULL, (LPOVERLAPPED)&overlap);
if ((ret == FALSE) && (GetLastError() != ERROR_IO_PENDING)) {
msyslog(LOG_ERR, "ReadFile() fails: %m");
return 0;
}
dwWait = WaitForSingleObject(hReadWriteEvent, (DWORD) TIMEOUT_SEC * 1000);
if ((dwWait == WAIT_FAILED) || (dwWait == WAIT_TIMEOUT)) {
if (dwWait == WAIT_FAILED) {
msyslog(LOG_ERR, "WaitForSingleObject for ReadFile fails: %m");
return 0;
}
continue;
}
if (!GetOverlappedResult((HANDLE)sockfd, (LPOVERLAPPED)&overlap,
(LPDWORD)&NumberOfBytesRead, FALSE)) {
msyslog(LOG_ERR, "GetOverlappedResult fails: %m");
return 0;
}
n = NumberOfBytesRead;
#endif
if (n < RESP_HEADER_SIZE) {
msyslog(LOG_ERR, "received runt response (%d octets)",
n);
continue;
}
if (!ISRESPONSE(reqpkt.rm_vn_mode)) {
#ifdef DEBUG
if (debug > 1)
msyslog(LOG_INFO, "received non-response packet");
#endif
continue;
}
if (ISMORE(reqpkt.rm_vn_mode)) {
#ifdef DEBUG
if (debug > 1)
msyslog(LOG_INFO, "received fragmented packet");
#endif
continue;
}
if ( ( (INFO_VERSION(reqpkt.rm_vn_mode) < 2)
|| (INFO_VERSION(reqpkt.rm_vn_mode) > NTP_VERSION))
|| INFO_MODE(reqpkt.rm_vn_mode) != MODE_PRIVATE) {
#ifdef DEBUG
if (debug > 1)
msyslog(LOG_INFO,
"version (%d/%d) or mode (%d/%d) incorrect",
INFO_VERSION(reqpkt.rm_vn_mode),
NTP_VERSION,
INFO_MODE(reqpkt.rm_vn_mode),
MODE_PRIVATE);
#endif
continue;
}
if (INFO_SEQ(reqpkt.auth_seq) != 0) {
#ifdef DEBUG
if (debug > 1)
msyslog(LOG_INFO,
"nonzero sequence number (%d)",
INFO_SEQ(reqpkt.auth_seq));
#endif
continue;
}
if (reqpkt.implementation != IMPL_XNTPD ||
reqpkt.request != REQ_CONFIG) {
#ifdef DEBUG
if (debug > 1)
msyslog(LOG_INFO,
"implementation (%d) or request (%d) incorrect",
reqpkt.implementation, reqpkt.request);
#endif
continue;
}
if (INFO_NITEMS(reqpkt.err_nitems) != 0 ||
INFO_MBZ(reqpkt.mbz_itemsize) != 0 ||
INFO_ITEMSIZE(reqpkt.mbz_itemsize) != 0) {
#ifdef DEBUG
if (debug > 1)
msyslog(LOG_INFO,
"nitems (%d) mbz (%d) or itemsize (%d) nonzero",
INFO_NITEMS(reqpkt.err_nitems),
INFO_MBZ(reqpkt.mbz_itemsize),
INFO_ITEMSIZE(reqpkt.mbz_itemsize));
#endif
continue;
}
n = INFO_ERR(reqpkt.err_nitems);
switch (n) {
case INFO_OKAY:
return 1;
case INFO_ERR_NODATA:
return 1;
case INFO_ERR_IMPL:
msyslog(LOG_ERR,
"ntp_intres.request: implementation mismatch");
return 0;
case INFO_ERR_REQ:
msyslog(LOG_ERR,
"ntp_intres.request: request unknown");
return 0;
case INFO_ERR_FMT:
msyslog(LOG_ERR,
"ntp_intres.request: format error");
return 0;
case INFO_ERR_AUTH:
msyslog(LOG_ERR,
"ntp_intres.request: permission denied");
return 0;
default:
msyslog(LOG_ERR,
"ntp_intres.request: unknown error code %d", n);
return 0;
}
}
}
static char *
nexttoken(
char **lptr
)
{
register char *cp;
register char *tstart;
cp = *lptr;
while (*cp == ' ' || *cp == '\t')
cp++;
if (*cp == '\n' || *cp == '\0') {
*lptr = cp;
return NULL;
}
tstart = cp++;
while (*cp != ' ' && *cp != '\t' && *cp != '\n' && *cp != '\0')
cp++;
if (*cp == '\n' || *cp == '\0')
*cp = '\0';
else
*cp++ = '\0';
*lptr = cp;
return tstart;
}
static void
readconf(
FILE *fp,
char *name
)
{
register int i;
char *token[NUMTOK];
u_long intval[NUMTOK];
u_int flags;
char buf[MAXLINESIZE];
char *bp;
while (fgets(buf, MAXLINESIZE, fp) != NULL) {
bp = buf;
for (i = 0; i < NUMTOK; i++) {
if ((token[i] = nexttoken(&bp)) == NULL) {
msyslog(LOG_ERR,
"tokenizing error in file `%s', quitting",
name);
resolver_exit(1);
}
}
for (i = 1; i < NUMTOK - 1; i++) {
if (!atouint(token[i], &intval[i])) {
msyslog(LOG_ERR,
"format error for integer token `%s', file `%s', quitting",
token[i], name);
resolver_exit(1);
}
}
#if 0
if (intval[TOK_HMODE] != MODE_ACTIVE &&
intval[TOK_HMODE] != MODE_CLIENT &&
intval[TOK_HMODE] != MODE_BROADCAST) {
msyslog(LOG_ERR, "invalid mode (%ld) in file %s",
intval[TOK_HMODE], name);
resolver_exit(1);
}
if (intval[TOK_VERSION] > NTP_VERSION ||
intval[TOK_VERSION] < NTP_OLDVERSION) {
msyslog(LOG_ERR, "invalid version (%ld) in file %s",
intval[TOK_VERSION], name);
resolver_exit(1);
}
if (intval[TOK_MINPOLL] < ntp_minpoll ||
intval[TOK_MINPOLL] > NTP_MAXPOLL) {
msyslog(LOG_ERR, "invalid MINPOLL value (%ld) in file %s",
intval[TOK_MINPOLL], name);
resolver_exit(1);
}
if (intval[TOK_MAXPOLL] < ntp_minpoll ||
intval[TOK_MAXPOLL] > NTP_MAXPOLL) {
msyslog(LOG_ERR, "invalid MAXPOLL value (%ld) in file %s",
intval[TOK_MAXPOLL], name);
resolver_exit(1);
}
if ((intval[TOK_FLAGS] & ~(FLAG_PREFER | FLAG_NOSELECT |
FLAG_BURST | FLAG_IBURST | FLAG_SKEY)) != 0) {
msyslog(LOG_ERR, "invalid flags (%ld) in file %s",
intval[TOK_FLAGS], name);
resolver_exit(1);
}
#endif
flags = 0;
if (intval[TOK_FLAGS] & FLAG_PREFER)
flags |= CONF_FLAG_PREFER;
if (intval[TOK_FLAGS] & FLAG_NOSELECT)
flags |= CONF_FLAG_NOSELECT;
if (intval[TOK_FLAGS] & FLAG_BURST)
flags |= CONF_FLAG_BURST;
if (intval[TOK_FLAGS] & FLAG_IBURST)
flags |= CONF_FLAG_IBURST;
#ifdef OPENSSL
if (intval[TOK_FLAGS] & FLAG_SKEY)
flags |= CONF_FLAG_SKEY;
#endif
addentry(token[TOK_HOSTNAME],
(int)intval[TOK_NEEDED], (int)intval[TOK_TYPE],
(int)intval[TOK_HMODE], (int)intval[TOK_VERSION],
(int)intval[TOK_MINPOLL], (int)intval[TOK_MAXPOLL],
flags, (int)intval[TOK_TTL],
intval[TOK_KEYID], token[TOK_KEYSTR]);
}
}
static void
doconfigure(
int dores
)
{
register struct conf_entry *ce;
#ifdef DEBUG
if (debug > 1)
msyslog(LOG_INFO, "Running doconfigure %s DNS",
dores ? "with" : "without" );
#endif
#if defined(HAVE_RES_INIT) || defined(HAVE___RES_INIT)
if (dores)
res_init();
#endif
ce = confentries;
while (ce != NULL) {
#ifdef DEBUG
if (debug > 1)
msyslog(LOG_INFO,
"doconfigure: <%s> has peeraddr %s",
ce->ce_name, stoa(&ce->peer_store));
#endif
if (dores && SOCK_UNSPEC(&ce->peer_store)) {
if (!findhostaddr(ce)) {
#ifndef IGNORE_DNS_ERRORS
msyslog(LOG_ERR,
"couldn't resolve `%s', giving up on it",
ce->ce_name);
ce = removeentry(ce);
continue;
#endif
} else if (!SOCK_UNSPEC(&ce->peer_store))
msyslog(LOG_INFO,
"DNS %s -> %s", ce->ce_name,
stoa(&ce->peer_store));
}
if (!SOCK_UNSPEC(&ce->peer_store)) {
if (request(&ce->ce_config)) {
ce = removeentry(ce);
continue;
}
#ifdef DEBUG
if (debug > 1) {
msyslog(LOG_INFO,
"doconfigure: request() FAILED, maybe next time.");
}
#endif
}
ce = ce->ce_next;
}
}
#else
int ntp_intres_nonempty_compilation_unit;
#endif