* tests/libntp/test_caltontp needs -lpthread. Harlan Stenn.
* br-flock: --enable-local-libevent. Harlan Stenn.
* scripts/lib/NTP/Util.pm: stratum output is version-dependent. Harlan Stenn.
+* Get rid of the NTP_ prefix on our assertion macros. Harlan Stenn.
---
(4.2.8p3) 2015/06/29 Released by Harlan Stenn <stenn@ntp.org>
* We initially used NTP_REQUIRE() instead of REQUIRE() etc, but that
* is unneccesarily verbose, as libisc use of REQUIRE() etc shows.
*/
-#define NTP_REQUIRE(x) REQUIRE(x)
-#define NTP_INSIST(x) INSIST(x)
-#define NTP_INVARIANT(x) INVARIANT(x)
-#define NTP_ENSURE(x) ENSURE(x)
# ifdef DEBUG
#define DEBUG_REQUIRE(x) REQUIRE(x)
\
for (pentry = (listhead); \
pentry != NULL; \
- pentry = pentry->nextlink){ \
- NTP_INSIST(pentry != pentry->nextlink); \
- NTP_INSIST((listhead) != pentry->nextlink); \
+ pentry = pentry->nextlink) { \
+ INSIST(pentry != pentry->nextlink); \
+ INSIST((listhead) != pentry->nextlink); \
} \
} while (FALSE)
int isneg;
static const char *digits = "0123456789";
- NTP_REQUIRE(str != NULL);
+ REQUIRE(str != NULL);
isneg = 0;
dec_i = dec_f = 0;
ntpcal_split split;
- NTP_INSIST(NULL != jt);
+ INSIST(NULL != jt);
/*
* Unfold ntp time around current time into NTP domain. Split
int32_t eraday; /* CE Rata Die number */
vint64 ntptime;/* resulting NTP time */
- NTP_INSIST(jt != NULL);
+ REQUIRE(jt != NULL);
- NTP_REQUIRE(jt->month <= 13); /* permit month 0..13! */
- NTP_REQUIRE(jt->monthday <= 32);
- NTP_REQUIRE(jt->yearday <= 366);
- NTP_REQUIRE(jt->hour <= 24);
- NTP_REQUIRE(jt->minute <= MINSPERHR);
- NTP_REQUIRE(jt->second <= SECSPERMIN);
+ REQUIRE(jt->month <= 13); /* permit month 0..13! */
+ REQUIRE(jt->monthday <= 32);
+ REQUIRE(jt->yearday <= 366);
+ REQUIRE(jt->hour <= 24);
+ REQUIRE(jt->minute <= MINSPERHR);
+ REQUIRE(jt->second <= SECSPERMIN);
/*
* First convert the date to he corresponding RataDie
char *np;
char name[80];
- NTP_REQUIRE(num != NULL);
- NTP_REQUIRE(strlen(num) < sizeof(name));
+ REQUIRE(num != NULL);
+ REQUIRE(strlen(num) < sizeof(name));
port_str = NULL;
if ('[' != num[0]) {
err = getaddrinfo(cp, "ntp", &hints, &ai);
if (err != 0)
return 0;
- NTP_INSIST(ai->ai_addrlen <= sizeof(*netnum));
+ INSIST(ai->ai_addrlen <= sizeof(*netnum));
ZERO(*netnum);
memcpy(netnum, ai->ai_addr, ai->ai_addrlen);
freeaddrinfo(ai);
size_t octets;
#endif /* POSIX */
- NTP_REQUIRE(fname != NULL);
+ REQUIRE(fname != NULL);
log_fname = fname;
/*
size_t servsize;
time_t now;
- NTP_REQUIRE(NULL != node);
+ REQUIRE(NULL != node);
if (NULL != hints) {
- NTP_REQUIRE(0 == hints->ai_addrlen);
- NTP_REQUIRE(NULL == hints->ai_addr);
- NTP_REQUIRE(NULL == hints->ai_canonname);
- NTP_REQUIRE(NULL == hints->ai_next);
+ REQUIRE(0 == hints->ai_addrlen);
+ REQUIRE(NULL == hints->ai_addr);
+ REQUIRE(NULL == hints->ai_canonname);
+ REQUIRE(NULL == hints->ai_next);
}
idx = get_dnschild_ctx();
ai = ai_res;
while (NULL != ai) {
- NTP_INSIST(ai->ai_addrlen <= sizeof(sockaddr_u));
+ INSIST(ai->ai_addrlen <= sizeof(sockaddr_u));
memcpy(cp, ai->ai_addr, ai->ai_addrlen);
cp += sizeof(sockaddr_u);
ai[i].ai_canonname += (size_t)canon_start;
}
- NTP_ENSURE((char *)psau == canon_start);
+ ENSURE((char *)psau == canon_start);
if (!gai_resp->ai_count)
ai = NULL;
dnschild_ctx * child_ctx;
time_t time_now;
- NTP_REQUIRE(hostoctets);
- NTP_REQUIRE(hostoctets + servoctets < 1024);
+ REQUIRE(hostoctets);
+ REQUIRE(hostoctets + servoctets < 1024);
idx = get_dnschild_ctx();
child_ctx = dnschild_contexts[idx];
* large allocations. We only need room for the host
* and service names.
*/
- NTP_REQUIRE(octets < sizeof(host));
+ REQUIRE(octets < sizeof(host));
service = host + gni_req->hostoctets;
worker_ctx = get_worker_context(c, gni_req->dns_idx);
cp += gni_resp->servoctets;
}
- NTP_INSIST((size_t)(cp - (char *)resp) == resp_octets);
- NTP_INSIST(resp_octets - sizeof(*resp) == gni_resp->octets);
+ INSIST((size_t)(cp - (char *)resp) == resp_octets);
+ INSIST(resp_octets - sizeof(*resp) == gni_resp->octets);
rc = queue_blocking_response(c, resp, resp_octets, req);
if (rc)
}
++ai_cpy;
}
- NTP_ENSURE(pcanon == ((char *)dst + octets));
+ ENSURE(pcanon == ((char *)dst + octets));
return dst;
}
return NULL; /* That's truly pathological! */
/* 'tm' surely not NULL here! */
- NTP_INSIST(tm != NULL);
+ INSIST(tm != NULL);
if (folds != 0) {
tm->tm_year += folds * SOLAR_CYCLE_YEARS;
if (tm->tm_year <= 0 || tm->tm_year >= 200)
create_buffers(RECV_INC);
buffer = get_free_recv_buffer();
}
- NTP_ENSURE(buffer != NULL);
+ ENSURE(buffer != NULL);
return (buffer);
}
#endif
static SOCKET socket_boundary = -1;
SOCKET newfd;
- NTP_REQUIRE((int)fd >= 0);
+ REQUIRE((int)fd >= 0);
/*
* check whether boundary has be set up
socket_boundary));
} while (socket_boundary > 0);
#else
- NTP_REQUIRE((int)fd >= 0);
+ ENSURE((int)fd >= 0);
#endif /* !defined(SYS_WINNT) && defined(F_DUPFD) */
return fd;
}
if (a_info)
goto forward_fail;
- NTP_INSIST(alist != NULL);
+ INSIST(alist != NULL);
for (ai = alist; ai != NULL; ai = ai->ai_next) {
/*
{
address_node *my_node;
- NTP_REQUIRE(NULL != addr);
- NTP_REQUIRE(AF_INET == type ||
- AF_INET6 == type || AF_UNSPEC == type);
+ REQUIRE(NULL != addr);
+ REQUIRE(AF_INET == type || AF_INET6 == type || AF_UNSPEC == type);
my_node = emalloc_zero(sizeof(*my_node));
my_node->address = addr;
my_node->type = (u_short)type;
{
if (NULL == my_node)
return;
- NTP_REQUIRE(NULL != my_node->address);
+ REQUIRE(NULL != my_node->address);
free(my_node->address);
free(my_node);
{
nic_rule_node *my_node;
- NTP_REQUIRE(match_class != 0 || if_name != NULL);
+ REQUIRE(match_class != 0 || if_name != NULL);
my_node = emalloc_zero(sizeof(*my_node));
my_node->match_class = match_class;
enum gnn_type a_type /* ignored */
)
{
- NTP_REQUIRE(AF_UNSPEC == AF(addr) ||
- AF_INET == AF(addr) ||
- AF_INET6 == AF(addr));
+ REQUIRE(AF_UNSPEC == AF(addr) ||
+ AF_INET == AF(addr) ||
+ AF_INET6 == AF(addr));
if (!is_ip_address(num, AF(addr), addr))
return 0;
memcpy(buffer, tag, tl);
cp = buffer + tl;
if (len > 0) {
- NTP_INSIST(tl + 3 + len <= sizeof(buffer));
+ INSIST(tl + 3 + len <= sizeof(buffer));
*cp++ = '=';
*cp++ = '"';
memcpy(cp, data, len);
memcpy(buffer, tag, tl);
cp = buffer + tl;
if (len > 0) {
- NTP_INSIST(tl + 1 + len <= sizeof(buffer));
+ INSIST(tl + 1 + len <= sizeof(buffer));
*cp++ = '=';
memcpy(cp, data, len);
cp += len;
while (*cq != '\0')
*cp++ = *cq++;
*cp++ = '=';
- NTP_INSIST((size_t)(cp - buffer) < sizeof(buffer));
+ INSIST((size_t)(cp - buffer) < sizeof(buffer));
snprintf(cp, sizeof(buffer) - (cp - buffer), use_f ? "%.*f" : "%.*g",
precision, d);
cp += strlen(cp);
*cp++ = *cq++;
*cp++ = '=';
- NTP_INSIST((cp - buffer) < (int)sizeof(buffer));
+ INSIST((cp - buffer) < (int)sizeof(buffer));
snprintf(cp, sizeof(buffer) - (cp - buffer), "%lu", uval);
cp += strlen(cp);
ctl_putdata(buffer, (unsigned)( cp - buffer ), 0);
pcal->hour,
pcal->minute
);
- NTP_INSIST(numch < sizeof(buffer));
+ INSIST(numch < sizeof(buffer));
ctl_putdata(buffer, numch, 0);
return;
tm = gmtime(&fstamp);
if (NULL == tm)
return;
- NTP_INSIST((cp - buffer) < (int)sizeof(buffer));
+ INSIST((cp - buffer) < (int)sizeof(buffer));
snprintf(cp, sizeof(buffer) - (cp - buffer),
"%04d%02d%02d%02d%02d", tm->tm_year + 1900,
tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min);
*cp++ = *cq++;
*cp++ = '=';
- NTP_INSIST((cp - buffer) < (int)sizeof(buffer));
+ INSIST((cp - buffer) < (int)sizeof(buffer));
snprintf(cp, sizeof(buffer) - (cp - buffer), "0x%lx", uval);
cp += strlen(cp);
ctl_putdata(buffer,(unsigned)( cp - buffer ), 0);
*cp++ = *cq++;
*cp++ = '=';
- NTP_INSIST((cp - buffer) < (int)sizeof(buffer));
+ INSIST((cp - buffer) < (int)sizeof(buffer));
snprintf(cp, sizeof(buffer) - (cp - buffer), "%ld", ival);
cp += strlen(cp);
ctl_putdata(buffer, (unsigned)( cp - buffer ), 0);
*cp++ = *cq++;
*cp++ = '=';
- NTP_INSIST((size_t)(cp - buffer) < sizeof(buffer));
+ INSIST((size_t)(cp - buffer) < sizeof(buffer));
snprintf(cp, sizeof(buffer) - (cp - buffer), "0x%08x.%08x",
(u_int)ts->l_ui, (u_int)ts->l_uf);
cp += strlen(cp);
cq = numtoa(addr32);
else
cq = stoa(addr);
- NTP_INSIST((cp - buffer) < (int)sizeof(buffer));
+ INSIST((cp - buffer) < (int)sizeof(buffer));
snprintf(cp, sizeof(buffer) - (cp - buffer), "%s", cq);
cp += strlen(cp);
ctl_putdata(buffer, (unsigned)(cp - buffer), 0);
if (i == 0)
i = NTP_SHIFT;
i--;
- NTP_INSIST((cp - buffer) < (int)sizeof(buffer));
+ INSIST((cp - buffer) < (int)sizeof(buffer));
snprintf(cp, sizeof(buffer) - (cp - buffer),
" %.2f", arr[i] * 1e3);
cp += strlen(cp);
ctl_error(CERR_UNKNOWNVAR);
return;
}
- NTP_INSIST(v->code < COUNTOF(wants));
+ INSIST(v->code < COUNTOF(wants));
wants[v->code] = 1;
gotvar = 1;
}
gotvar = 0;
while (NULL != (v = ctl_getitem(sys_var, &valuep))) {
if (!(EOV & v->flags)) {
- NTP_INSIST(v->code < wants_count);
+ INSIST(v->code < wants_count);
wants[v->code] = 1;
gotvar = 1;
} else {
v = ctl_getitem(ext_sys_var, &valuep);
- NTP_INSIST(v != NULL);
+ INSIST(v != NULL);
if (EOV & v->flags) {
ctl_error(CERR_UNKNOWNVAR);
free(wants);
return;
}
n = v->code + CS_MAXCODE + 1;
- NTP_INSIST(n < wants_count);
+ INSIST(n < wants_count);
wants[n] = 1;
gotvar = 1;
}
gotvar = TRUE;
} else {
v = ctl_getitem(kv, &valuep);
- NTP_INSIST(NULL != v);
+ INSIST(NULL != v);
if (EOV & v->flags) {
ctl_error(CERR_UNKNOWNVAR);
free(wants);
for (i = 1; i <= CS_VARLIST; i++)
ctl_putsys(i);
} else {
- NTP_INSIST(peer != NULL);
+ INSIST(peer != NULL);
rpkt.associd = htons(peer->associd);
rpkt.status = htons(ctlpeerstatus(peer));
while (!(EOV & (k++)->flags))
c++;
- NTP_ENSURE(c <= USHRT_MAX);
+ ENSURE(c <= USHRT_MAX);
return (u_short)c;
}
EVP_SignUpdate(&ctx, (u_char *)vp, 12);
EVP_SignUpdate(&ctx, vp->ptr, sizeof(struct autokey));
if (EVP_SignFinal(&ctx, vp->sig, &len, sign_pkey)) {
- NTP_INSIST(len <= sign_siglen);
+ INSIST(len <= sign_siglen);
vp->siglen = htonl(len);
peer->flags |= FLAG_ASSOC;
}
EVP_SignUpdate(&ctx, (u_char *)&vp->tstamp, 12);
EVP_SignUpdate(&ctx, vp->ptr, vallen);
if (EVP_SignFinal(&ctx, vp->sig, &vallen, sign_pkey)) {
- NTP_INSIST(vallen <= sign_siglen);
+ INSIST(vallen <= sign_siglen);
vp->siglen = htonl(vallen);
}
return (XEVNT_OK);
EVP_SignUpdate(&ctx, (u_char *)&pubkey, 12);
EVP_SignUpdate(&ctx, pubkey.ptr, ntohl(pubkey.vallen));
if (EVP_SignFinal(&ctx, pubkey.sig, &len, sign_pkey)) {
- NTP_INSIST(len <= sign_siglen);
+ INSIST(len <= sign_siglen);
pubkey.siglen = htonl(len);
}
}
EVP_SignUpdate(&ctx, cp->cert.ptr,
ntohl(cp->cert.vallen));
if (EVP_SignFinal(&ctx, cp->cert.sig, &len, sign_pkey)) {
- NTP_INSIST(len <= sign_siglen);
+ INSIST(len <= sign_siglen);
cp->cert.siglen = htonl(len);
}
}
EVP_SignUpdate(&ctx, (u_char *)&tai_leap, 12);
EVP_SignUpdate(&ctx, tai_leap.ptr, len);
if (EVP_SignFinal(&ctx, tai_leap.sig, &len, sign_pkey)) {
- NTP_INSIST(len <= sign_siglen);
+ INSIST(len <= sign_siglen);
tai_leap.siglen = htonl(len);
}
crypto_flags |= CRYPTO_FLAG_TAI;
* 100. Dontcha love ASN.1? Better than MIL-188.
*/
len = asn1time->length;
- NTP_REQUIRE(len < sizeof(v));
+ REQUIRE(len < sizeof(v));
(void)strncpy(v, (char *)(asn1time->data), len);
- NTP_REQUIRE(len >= 13);
+ REQUIRE(len >= 13);
temp = strtoul(v+len-3, NULL, 10);
pjd->second = temp;
v[len-3] = '\0';
EVP_SignUpdate(&ctx, (u_char *)&vp->tstamp, 12);
EVP_SignUpdate(&ctx, vp->ptr, len);
if (EVP_SignFinal(&ctx, vp->sig, &len, sign_pkey)) {
- NTP_INSIST(len <= sign_siglen);
+ INSIST(len <= sign_siglen);
vp->siglen = htonl(len);
}
return (XEVNT_OK);
EVP_SignUpdate(&ctx, (u_char *)&vp->tstamp, 12);
EVP_SignUpdate(&ctx, vp->ptr, vallen);
if (EVP_SignFinal(&ctx, vp->sig, &vallen, sign_pkey)) {
- NTP_INSIST(vallen <= sign_siglen);
+ INSIST(vallen <= sign_siglen);
vp->siglen = htonl(vallen);
}
return (XEVNT_OK);
EVP_SignUpdate(&ctx, (u_char *)&vp->tstamp, 12);
EVP_SignUpdate(&ctx, vp->ptr, len);
if (EVP_SignFinal(&ctx, vp->sig, &len, sign_pkey)) {
- NTP_INSIST(len <= sign_siglen);
+ INSIST(len <= sign_siglen);
vp->siglen = htonl(len);
}
return (XEVNT_OK);
EVP_SignUpdate(&ctx, (u_char *)&vp->tstamp, 12);
EVP_SignUpdate(&ctx, vp->ptr, len);
if (EVP_SignFinal(&ctx, vp->sig, &len, sign_pkey)) {
- NTP_INSIST(len <= sign_siglen);
+ INSIST(len <= sign_siglen);
vp->siglen = htonl(len);
}
return (XEVNT_OK);
EVP_SignUpdate(&ctx, (u_char *)&vp->tstamp, 12);
EVP_SignUpdate(&ctx, vp->ptr, len);
if (EVP_SignFinal(&ctx, vp->sig, &len, sign_pkey)) {
- NTP_INSIST(len <= sign_siglen);
+ INSIST(len <= sign_siglen);
vp->siglen = htonl(len);
}
return (XEVNT_OK);
EVP_SignUpdate(&ctx, (u_char *)&vp->tstamp, 12);
EVP_SignUpdate(&ctx, vp->ptr, len);
if (EVP_SignFinal(&ctx, vp->sig, &len, sign_pkey)) {
- NTP_INSIST(len <= sign_siglen);
+ INSIST(len <= sign_siglen);
vp->siglen = htonl(len);
}
return (XEVNT_OK);
EVP_SignUpdate(&ctx, (u_char *)vp, 12);
EVP_SignUpdate(&ctx, vp->ptr, len);
if (EVP_SignFinal(&ctx, vp->sig, &len, sign_pkey)) {
- NTP_INSIST(len <= sign_siglen);
+ INSIST(len <= sign_siglen);
vp->siglen = htonl(len);
}
}
maxactivefd = i;
break;
}
- NTP_INSIST(fd != maxactivefd);
+ INSIST(fd != maxactivefd);
}
}
}
const u_int32 * pm;
size_t loops;
- NTP_REQUIRE(AF(a) == AF(a_mask));
- NTP_REQUIRE(AF(b) == AF(b_mask));
+ REQUIRE(AF(a) == AF(a_mask));
+ REQUIRE(AF(b) == AF(b_mask));
/*
* With address and mask families verified to match, comparing
* the masks also validates the address's families match.
char tmpbuf[128];
char *pch;
- NTP_REQUIRE(host != NULL);
- NTP_REQUIRE(addr != NULL);
+ REQUIRE(host != NULL);
+ REQUIRE(addr != NULL);
ZERO_SOCK(addr);
rule->action = action;
if (MATCH_IFNAME == match_type) {
- NTP_REQUIRE(NULL != if_name);
+ REQUIRE(NULL != if_name);
rule->if_name = estrdup(if_name);
} else if (MATCH_IFADDR == match_type) {
- NTP_REQUIRE(NULL != if_name);
+ REQUIRE(NULL != if_name);
/* set rule->addr */
is_ip = is_ip_address(if_name, AF_UNSPEC, &rule->addr);
- NTP_REQUIRE(is_ip);
+ REQUIRE(is_ip);
} else
- NTP_REQUIRE(NULL == if_name);
+ REQUIRE(NULL == if_name);
LINK_SLIST(nic_rule_list, rule, next);
}
t = "ERROR"; /* quiet uninit warning */
DPRINTF(1, ("fatal: unknown nic_rule_action %d\n",
action));
- NTP_ENSURE(0);
+ ENSURE(0);
break;
case ACTION_LISTEN:
u_int off6 = 0;
#endif
- NTP_REQUIRE(AF(maddr) == AF(&iface->sin));
+ REQUIRE(AF(maddr) == AF(&iface->sin));
switch (AF(&iface->sin)) {
continue;
/* Only IPv4 addresses are valid for broadcast */
- NTP_REQUIRE(IS_IPV4(&interf->sin));
+ REQUIRE(IS_IPV4(&interf->sin));
/* Do we already have the broadcast address open? */
if (interf->flags & INT_BCASTOPEN) {
int a1_greater;
int i;
- NTP_REQUIRE(AF(a1) == AF(a2));
+ REQUIRE(AF(a1) == AF(a2));
ZERO_SOCK(dist);
AF(dist) = AF(a1);
{
int i;
- NTP_REQUIRE(AF(d1) == AF(d2));
+ REQUIRE(AF(d1) == AF(d2));
if (IS_IPV4(d1)) {
if (SRCADR(d1) < SRCADR(d2))
hash = MON_HASH(&mon->rmtadr);
UNLINK_SLIST(punlinked, mon_hash[hash], mon, hash_next,
mon_entry);
- NTP_ENSURE(punlinked == mon);
+ ENSURE(punlinked == mon);
}
/*
* For now only pool associations have a hostname.
*/
- NTP_INSIST(NULL == hostname || (MDF_POOL & cast_flags));
+ INSIST(NULL == hostname || (MDF_POOL & cast_flags));
/*
* First search from the beginning for an association with given
if (NULL == peer)
return;
- NTP_INSIST(peer->procptr != NULL);
+ INSIST(peer->procptr != NULL);
pp = peer->procptr;
/*
LINK_SLIST(resfree4, res, link);
res = (void *)((char *)res - cb);
}
- NTP_INSIST(rl == res);
+ INSIST(rl == res);
/* allocate the first */
return res;
}
LINK_SLIST(resfree6, res, link);
res = (void *)((char *)res - cb);
}
- NTP_INSIST(rl == res);
+ INSIST(rl == res);
/* allocate the first */
return res;
}
else
plisthead = &restrictlist4;
UNLINK_SLIST(unlinked, *plisthead, res, link, restrict_u);
- NTP_INSIST(unlinked == res);
+ INSIST(unlinked == res);
if (v6) {
zero_mem(res, V6_SIZEOF_RESTRICT_U);
for (res = restrictlist6; res != NULL; res = next) {
next = res->link;
- NTP_INSIST(next != res);
+ INSIST(next != res);
if (res->expire &&
res->expire <= current_time)
free_res(res, v6);
op, stoa(resaddr), stoa(resmask), mflags, flags));
if (NULL == resaddr) {
- NTP_REQUIRE(NULL == resmask);
- NTP_REQUIRE(RESTRICT_FLAGS == op);
+ REQUIRE(NULL == resmask);
+ REQUIRE(RESTRICT_FLAGS == op);
restrict_source_flags = flags;
restrict_source_mflags = mflags;
restrict_source_enabled = 1;
&match.u.v6.mask);
} else /* not IPv4 nor IPv6 */
- NTP_REQUIRE(0);
+ REQUIRE(0);
match.flags = flags;
match.mflags = mflags;
break;
default: /* unknown op */
- NTP_INSIST(0);
+ INSIST(0);
break;
}
IS_MCAST(addr) || ISREFCLOCKADR(addr))
return;
- NTP_REQUIRE(AF_INET == AF(addr) || AF_INET6 == AF(addr));
+ REQUIRE(AF_INET == AF(addr) || AF_INET6 == AF(addr));
SET_HOSTMASK(&onesmask, AF(addr));
if (farewell) {
LENHOSTNAME, NULL, 0, 0);
return 1;
} else if (getaddrinfo(hname, "ntp", &hints, &ai) == 0) {
- NTP_INSIST(sizeof(*num) >= ai->ai_addrlen);
+ INSIST(sizeof(*num) >= ai->ai_addrlen);
memcpy(num, ai->ai_addr, ai->ai_addrlen);
if (fullhost != NULL) {
if (ai->ai_canonname != NULL)
}
UNLINK_DLIST(mon, mlink);
UNLINK_SLIST(unlinked, hash_table[hash], mon, hlink, mru);
- NTP_INSIST(unlinked == mon);
+ INSIST(unlinked == mon);
mru_dupes++;
TRACE(2, ("(updated from %08x.%08x) ", mon->last.l_ui,
mon->last.l_uf));
mru_count = 0;
INIT_DLIST(mru_list, mlink);
cb = NTP_HASH_SIZE * sizeof(*hash_table);
- NTP_INSIST(NULL == hash_table);
+ INSIST(NULL == hash_table);
hash_table = emalloc_zero(cb);
c_mru_l_rc = FALSE;
ri);
while (ri--) {
recent = HEAD_DLIST(mru_list, mlink);
- NTP_INSIST(recent != NULL);
+ INSIST(recent != NULL);
if (debug)
fprintf(stderr,
"tossing prior entry %s to resync\n",
hash = NTP_HASH_ADDR(&recent->addr);
UNLINK_SLIST(unlinked, hash_table[hash],
recent, hlink, mru);
- NTP_INSIST(unlinked == recent);
+ INSIST(unlinked == recent);
free(recent);
mru_count--;
}
if (have_now)
list_complete = TRUE;
if (list_complete) {
- NTP_INSIST(0 == ri || have_addr_older);
+ INSIST(0 == ri || have_addr_older);
}
if (mrulist_interrupted) {
printf("mrulist retrieval interrupted by operator.\n"
ppentry = sorted;
if (MRUSORT_R_DEF != order) {
ITER_DLIST_BEGIN(mru_list, recent, mlink, mru)
- NTP_INSIST(ppentry < sorted + mru_count);
+ INSIST(ppentry < sorted + mru_count);
*ppentry = recent;
ppentry++;
ITER_DLIST_END()
} else {
REV_ITER_DLIST_BEGIN(mru_list, recent, mlink, mru)
- NTP_INSIST(ppentry < sorted + mru_count);
+ INSIST(ppentry < sorted + mru_count);
*ppentry = recent;
ppentry++;
REV_ITER_DLIST_END()
}
if (NULL == hnds[unit].h) {
- NTP_ENSURE(0 == hnds[unit].opens);
+ INSIST(0 == hnds[unit].opens);
LIB_GETBUF(windev);
snprintf(windev, LIB_BUFLENGTH, "\\\\.\\COM%d", unit);
TRACE(1, ("windows device %s\n", windev));
FT_ULL ft4;
FT_ULL ft5;
- NTP_REQUIRE(NomPerfCtrFreq != 0);
+ REQUIRE(NomPerfCtrFreq != 0);
QueryPerformanceCounter(&ft1.li);
ft2.ull = get_pcc();
* room, then append to the table array.
*/
if (hi >= ActiveWaitHandles) {
- NTP_INSIST(ActiveWaitHandles < COUNTOF(WaitHandles));
+ INSIST(ActiveWaitHandles < COUNTOF(WaitHandles));
WaitHandles[ActiveWaitHandles] = sem;
ActiveWaitHandles++;
}
buff = lpo->recv_buf;
dev = lpo->devCtx;
- NTP_INSIST(rio == lpo->rio);
+ INSIST(rio == lpo->rio);
#ifdef DEBUG
if (~(EV_RXFLAG | EV_RLSD | EV_RXCHAR) & lpo->com_events) {
/* get & validate context and buffer. */
rio = lpo->rio;
buff = lpo->recv_buf;
- NTP_INSIST((ULONG_PTR)rio == key);
+ INSIST((ULONG_PTR)rio == key);
/* Offload to worker pool */
if (!QueueUserWorkItem(&OnSerialReadWorker, lpo, WT_EXECUTEDEFAULT)) {
/* get & validate context and buffer. */
rio = lpo->rio;
buff = lpo->recv_buf;
- NTP_INSIST((ULONG_PTR)rio == key);
+ INSIST((ULONG_PTR)rio == key);
/* ignore 0 bytes read. */
if (lpo->byteCount > 0) {
recvbuf_t * newbuff;
struct interface * inter = (struct interface *)key;
- NTP_REQUIRE(NULL != lpo);
- NTP_REQUIRE(NULL != lpo->recv_buf);
+ REQUIRE(NULL != lpo);
+ REQUIRE(NULL != lpo->recv_buf);
/* check and bail out if operation failed */
if (!IoResultCheck(lpo->errCode, lpo,
* If we keep it add some info to the structure
*/
if (buff->recv_length && !inter->ignore_packets) {
- NTP_INSIST(buff->recv_srcadr_len <=
- sizeof(buff->recv_srcadr));
+ INSIST(buff->recv_srcadr_len <= sizeof(buff->recv_srcadr));
buff->receiver = &receive;
buff->dstadr = inter;
packets_received++;
projects / thirdparty / ntp.git / commitdiff
