#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "ntpd.h"
#include "ntp_stdlib.h"
#include "ntp_unixtime.h"
#include "ntp_control.h"
#include "ntp_string.h"
#include "ntp_crypto.h"
#include <stdio.h>
#if defined(VMS) && defined(VMS_LOCALUNIT)
#include "ntp_refclock.h"
#endif
#if defined(__FreeBSD__) && __FreeBSD__ >= 3
#include <sys/sysctl.h>
#endif
u_char sys_leap;
u_char sys_stratum;
s_char sys_precision;
double sys_rootdelay;
double sys_rootdispersion;
u_int32 sys_refid;
static double sys_offset;
l_fp sys_reftime;
struct peer *sys_peer;
struct peer *sys_prefer;
#ifdef AUTOKEY
u_long sys_automax;
#endif
int sys_bclient;
double sys_bdelay;
int sys_authenticate;
l_fp sys_authdelay;
static u_long sys_authdly[2];
static u_char leap_consensus;
static double sys_selerr;
static double sys_syserr;
keyid_t sys_private;
int sys_manycastserver;
u_int sys_survivors;
int peer_ntpdate;
#ifdef AUTOKEY
char *sys_hostname;
#endif
u_long sys_stattime;
u_long sys_badstratum;
u_long sys_oldversionpkt;
u_long sys_newversionpkt;
u_long sys_unknownversion;
u_long sys_badlength;
u_long sys_processed;
u_long sys_badauth;
u_long sys_limitrejected;
static double root_distance P((struct peer *));
static double clock_combine P((struct peer **, int));
static void peer_xmit P((struct peer *));
static void fast_xmit P((struct recvbuf *, int, keyid_t, int));
static void clock_update P((void));
int default_get_precision P((void));
void
transmit(
struct peer *peer
)
{
int hpoll;
hpoll = peer->hpoll;
if (peer->burst == 0) {
u_char oreach;
if (peer->cast_flags & (MDF_BCAST | MDF_MCAST)) {
hpoll = peer->minpoll;
peer->ttl = peer->ttlmax;
#ifdef AUTOKEY
} else if (peer->cast_flags & MDF_ACAST) {
if (sys_survivors < NTP_MINCLOCK && peer->ttl <
peer->ttlmax)
peer->ttl++;
hpoll = sys_poll;
#endif
} else {
if (peer->unreach < NTP_UNREACH) {
peer->unreach++;
} else if (!(peer->flags & FLAG_CONFIG)) {
unpeer(peer);
clock_select();
return;
} else {
peer_clear(peer);
hpoll++;
}
}
oreach = peer->reach;
peer->reach <<= 1;
if (peer->reach == 0) {
if (oreach != 0) {
report_event(EVNT_UNREACH, peer);
peer->timereachable = current_time;
if (!(peer->flags & FLAG_CONFIG)) {
unpeer(peer);
clock_select();
return;
} else {
peer_clear(peer);
hpoll = peer->minpoll;
}
}
if (peer->flags & FLAG_IBURST)
peer->burst = NTP_SHIFT;
} else {
if (!(peer->reach & 0x07)) {
clock_filter(peer, 0., 0., MAXDISPERSE);
clock_select();
}
if ((peer->stratum > 1 && peer->refid ==
peer->dstadr->sin.sin_addr.s_addr) ||
peer->stratum >= STRATUM_UNSPEC)
hpoll++;
else
hpoll = sys_poll;
if (peer->flags & FLAG_BURST)
peer->burst = NTP_SHIFT;
}
} else {
peer->burst--;
if (peer->burst == 0) {
if (peer->cast_flags & MDF_BCLNT) {
peer->hmode = MODE_BCLIENT;
#ifdef AUTOKEY
key_expire(peer);
#endif
}
poll_update(peer, hpoll);
clock_select();
if (mode_ntpdate) {
peer_ntpdate--;
if (peer_ntpdate > 0)
return;
NLOG(NLOG_SYNCEVENT | NLOG_SYSEVENT)
msyslog(LOG_NOTICE,
"no reply; clock not set");
printf(
"ntpd: no reply; clock not set\n");
exit(0);
}
return;
}
}
peer->outdate = current_time;
poll_update(peer, hpoll);
if (peer->hmode == MODE_BCLIENT || peer->flash & TEST4) {
return;
} else if (peer->hmode == MODE_BROADCAST) {
if (sys_peer == NULL)
return;
}
peer_xmit(peer);
}
void
receive(
struct recvbuf *rbufp
)
{
register struct peer *peer;
register struct pkt *pkt;
int hismode;
int oflags;
int restrict_mask;
int has_mac;
int authlen;
int is_authentic;
keyid_t skeyid;
struct sockaddr_in *dstadr_sin;
#ifdef AUTOKEY
keyid_t pkeyid, tkeyid;
#endif
struct peer *peer2;
int retcode = AM_NOMATCH;
ntp_monitor(rbufp);
restrict_mask = restrictions(&rbufp->recv_srcadr);
#ifdef DEBUG
if (debug > 2)
printf("receive: at %ld %s<-%s restrict %02x\n",
current_time, ntoa(&rbufp->dstadr->sin),
ntoa(&rbufp->recv_srcadr), restrict_mask);
#endif
if (restrict_mask & RES_IGNORE)
return;
pkt = &rbufp->recv_pkt;
if (PKT_VERSION(pkt->li_vn_mode) == NTP_VERSION) {
sys_newversionpkt++;
} else if (!(restrict_mask & RES_VERSION) &&
PKT_VERSION(pkt->li_vn_mode) >= NTP_OLDVERSION) {
sys_oldversionpkt++;
} else {
sys_unknownversion++;
return;
}
if (PKT_MODE(pkt->li_vn_mode) == MODE_PRIVATE) {
if (restrict_mask & RES_NOQUERY)
return;
process_private(rbufp, ((restrict_mask &
RES_NOMODIFY) == 0));
return;
}
if (PKT_MODE(pkt->li_vn_mode) == MODE_CONTROL) {
if (restrict_mask & RES_NOQUERY)
return;
process_control(rbufp, restrict_mask);
return;
}
if (rbufp->recv_length < LEN_PKT_NOMAC) {
sys_badlength++;
return;
}
hismode = (int)PKT_MODE(pkt->li_vn_mode);
if (hismode == MODE_UNSPEC) {
sys_badlength++;
return;
}
if (PKT_MODE(pkt->li_vn_mode) == MODE_BROADCAST &&
(rbufp->dstadr == any_interface || !sys_bclient))
return;
skeyid = 0;
#ifdef AUTOKEY
pkeyid = tkeyid = 0;
#endif
authlen = LEN_PKT_NOMAC;
while ((has_mac = rbufp->recv_length - authlen) > 0) {
int temp;
if (has_mac % 4 != 0 || has_mac < 0) {
sys_badlength++;
return;
}
if (has_mac == 1 * 4 || has_mac == 3 * 4 || has_mac ==
MAX_MAC_LEN) {
skeyid = ntohl(((u_int32 *)pkt)[authlen / 4]);
break;
} else if (has_mac > MAX_MAC_LEN) {
temp = ntohl(((u_int32 *)pkt)[authlen / 4]) &
0xffff;
if (temp < 4 || temp % 4 != 0) {
sys_badlength++;
return;
}
authlen += temp;
} else {
sys_badlength++;
return;
}
}
peer = findpeer(&rbufp->recv_srcadr, rbufp->dstadr, rbufp->fd,
hismode, &retcode);
is_authentic = 0;
dstadr_sin = &rbufp->dstadr->sin;
if (has_mac == 0) {
#ifdef DEBUG
if (debug)
printf("receive: at %ld %s<-%s mode %d code %d\n",
current_time, ntoa(&rbufp->dstadr->sin),
ntoa(&rbufp->recv_srcadr), hismode, retcode);
#endif
} else {
#ifdef AUTOKEY
if (skeyid > NTP_MAXKEY) {
if (hismode == MODE_BROADCAST) {
pkeyid = 0;
if (rbufp->dstadr->bcast.sin_addr.s_addr
!= 0)
dstadr_sin =
&rbufp->dstadr->bcast;
} else if (peer == NULL) {
pkeyid = session_key(
&rbufp->recv_srcadr, dstadr_sin, 0,
sys_private, 0);
} else {
pkeyid = peer->pcookie.key;
}
if (authlen > LEN_PKT_NOMAC && pkeyid != 0) {
session_key(&rbufp->recv_srcadr,
dstadr_sin, skeyid, 0, 2);
tkeyid = session_key(
&rbufp->recv_srcadr, dstadr_sin,
skeyid, pkeyid, 0);
} else {
tkeyid = session_key(
&rbufp->recv_srcadr, dstadr_sin,
skeyid, pkeyid, 2);
}
}
#endif
if (authdecrypt(skeyid, (u_int32 *)pkt, authlen,
has_mac))
is_authentic = 1;
else
sys_badauth++;
#ifdef AUTOKEY
if (skeyid > NTP_MAXKEY)
authtrust(skeyid, 0);
#endif
#ifdef DEBUG
if (debug)
printf(
"receive: at %ld %s<-%s mode %d code %d keyid %08x len %d mac %d auth %d\n",
current_time, ntoa(dstadr_sin),
ntoa(&rbufp->recv_srcadr), hismode, retcode,
skeyid, authlen, has_mac,
is_authentic);
#endif
}
switch (retcode) {
case AM_FXMIT:
if (sys_manycastserver && (rbufp->dstadr->flags &
INT_MULTICAST)) {
if (sys_peer == NULL)
return;
if (PKT_TO_STRATUM(pkt->stratum) < sys_stratum)
return;
}
if (is_authentic)
fast_xmit(rbufp, MODE_SERVER, skeyid,
restrict_mask);
else
fast_xmit(rbufp, MODE_SERVER, 0, restrict_mask);
return;
case AM_MANYCAST:
if ((restrict_mask & (RES_DONTSERVE | RES_LIMITED |
RES_NOPEER)) || (sys_authenticate &&
!is_authentic))
return;
peer2 = findmanycastpeer(rbufp);
if (peer2 == 0)
return;
peer = newpeer(&rbufp->recv_srcadr, rbufp->dstadr,
MODE_CLIENT, PKT_VERSION(pkt->li_vn_mode),
sys_minpoll, NTP_MAXDPOLL, FLAG_IBURST |
(peer2->flags & (FLAG_AUTHENABLE | FLAG_SKEY)),
MDF_UCAST, 0, skeyid);
if (peer == NULL)
return;
break;
case AM_NEWPASS:
if ((restrict_mask & (RES_DONTSERVE | RES_LIMITED |
RES_NOPEER)) || (sys_authenticate &&
!is_authentic)) {
fast_xmit(rbufp, MODE_PASSIVE, 0,
restrict_mask);
return;
}
peer = newpeer(&rbufp->recv_srcadr, rbufp->dstadr,
MODE_PASSIVE, PKT_VERSION(pkt->li_vn_mode),
sys_minpoll, NTP_MAXDPOLL, sys_authenticate ?
FLAG_AUTHENABLE : 0, MDF_UCAST, 0, skeyid);
if (peer == NULL)
return;
break;
case AM_NEWBCL:
if ((restrict_mask & (RES_DONTSERVE | RES_LIMITED |
RES_NOPEER)) || (sys_authenticate &&
!is_authentic) || !sys_bclient)
return;
peer = newpeer(&rbufp->recv_srcadr, rbufp->dstadr,
MODE_CLIENT, PKT_VERSION(pkt->li_vn_mode),
sys_minpoll, NTP_MAXDPOLL, FLAG_MCAST |
FLAG_IBURST | (sys_authenticate ?
FLAG_AUTHENABLE : 0), MDF_BCLNT, 0, skeyid);
#ifdef AUTOKEY
#ifdef PUBKEY
if (peer == NULL)
return;
if (peer->flags & FLAG_SKEY)
crypto_recv(peer, rbufp);
#endif
#endif
return;
case AM_POSSBCL:
case AM_PROCPKT:
break;
default:
#ifdef DEBUG
if (debug)
printf("receive: bad protocol %d\n", retcode);
#endif
return;
}
oflags = peer->flags;
peer->timereceived = current_time;
peer->received++;
if (!(peer->flags & FLAG_CONFIG) && has_mac) {
peer->flags |= FLAG_AUTHENABLE;
#ifdef AUTOKEY
if (skeyid > NTP_MAXKEY)
peer->flags |= FLAG_SKEY;
#endif
}
peer->flash = 0;
if (is_authentic) {
peer->flags |= FLAG_AUTHENTIC;
} else {
peer->flags &= ~FLAG_AUTHENTIC;
}
if (peer->hmode == MODE_BROADCAST &&
(restrict_mask & RES_DONTTRUST))
peer->flash |= TEST4;
if (peer->flags & FLAG_AUTHENABLE) {
if (!(peer->flags & FLAG_AUTHENTIC))
peer->flash |= TEST5;
else if (!(oflags & FLAG_AUTHENABLE))
report_event(EVNT_PEERAUTH, peer);
}
if (peer->flash) {
#ifdef DEBUG
if (debug)
printf("receive: bad auth %03x\n", peer->flash);
#endif
return;
}
#ifdef AUTOKEY
if (peer->flags & FLAG_SKEY) {
peer->flash |= TEST10;
crypto_recv(peer, rbufp);
poll_update(peer, peer->hpoll);
if (hismode == MODE_SERVER) {
if (skeyid == peer->keyid)
peer->flash &= ~TEST10;
} else if (!peer->flash & TEST10) {
peer->pkeyid = skeyid;
} else {
int i;
for (i = 0; ; i++) {
if (tkeyid == peer->pkeyid ||
tkeyid == peer->recauto.key) {
peer->flash &= ~TEST10;
peer->pkeyid = skeyid;
break;
}
if (i > peer->recauto.seq)
break;
tkeyid = session_key(
&rbufp->recv_srcadr, dstadr_sin,
tkeyid, pkeyid, 0);
}
}
#ifdef PUBKEY
if (!(peer->flags & FLAG_PROVEN))
peer->flash |= TEST11;
if (peer->flash && peer->reach) {
#ifdef DEBUG
if (debug)
printf("packet: bad autokey %03x\n",
peer->flash);
#endif
return;
}
#endif
}
#endif
process_packet(peer, pkt, &rbufp->recv_time);
}
void
process_packet(
register struct peer *peer,
register struct pkt *pkt,
l_fp *recv_ts
)
{
l_fp t10, t23;
double p_offset, p_del, p_disp;
double dtemp;
l_fp p_rec, p_xmt, p_org, p_reftime;
l_fp ci;
int pmode, pleap, pstratum;
sys_processed++;
peer->processed++;
p_del = FPTOD(NTOHS_FP(pkt->rootdelay));
p_disp = FPTOD(NTOHS_FP(pkt->rootdispersion));
NTOHL_FP(&pkt->reftime, &p_reftime);
NTOHL_FP(&pkt->rec, &p_rec);
NTOHL_FP(&pkt->xmt, &p_xmt);
if (PKT_MODE(pkt->li_vn_mode) != MODE_BROADCAST)
NTOHL_FP(&pkt->org, &p_org);
else
p_org = peer->rec;
peer->rec = *recv_ts;
pmode = PKT_MODE(pkt->li_vn_mode);
pleap = PKT_LEAP(pkt->li_vn_mode);
pstratum = PKT_TO_STRATUM(pkt->stratum);
if (L_ISHIS(&peer->org, &p_xmt))
peer->oldpkt++;
if (L_ISEQU(&peer->org, &p_xmt))
peer->flash |= TEST1;
if (pmode != MODE_BROADCAST) {
if (!L_ISEQU(&peer->xmt, &p_org))
peer->flash |= TEST2;
if (L_ISZERO(&p_rec) || L_ISZERO(&p_org))
peer->flash |= TEST3;
}
if (L_ISZERO(&p_xmt))
peer->flash |= TEST3;
peer->org = p_xmt;
if (peer->flash) {
#ifdef DEBUG
if (debug)
printf("packet: bad data %03x\n",
peer->flash);
#endif
return;
}
if (pleap == LEAP_NOTINSYNC && pstratum >= STRATUM_UNSPEC &&
memcmp(&pkt->refid, "DENY", 4) == 0) {
if (peer->leap == LEAP_NOTINSYNC) {
peer->stratum = STRATUM_UNSPEC;
peer->flash |= TEST4;
memcpy(&peer->refid, &pkt->refid, 4);
msyslog(LOG_INFO, "access denied");
} else {
msyslog(LOG_INFO, "limit reject");
}
return;
}
ci = p_xmt;
L_SUB(&ci, &p_reftime);
LFPTOD(&ci, dtemp);
if (pleap == LEAP_NOTINSYNC ||
pstratum >= STRATUM_UNSPEC || dtemp < 0)
peer->flash |= TEST6;
if (!(peer->flags & FLAG_CONFIG) && sys_peer != NULL) {
if (pstratum > sys_stratum && pmode != MODE_ACTIVE) {
peer->flash |= TEST7;
sys_badstratum++;
}
}
if (p_del < 0 || p_disp < 0 || p_del /
2 + p_disp >= MAXDISPERSE)
peer->flash |= TEST8;
if (peer->flash) {
#ifdef DEBUG
if (debug)
printf("packet: bad header %03x\n",
peer->flash);
#endif
return;
}
record_raw_stats(&peer->srcadr, &peer->dstadr->sin, &p_org,
&p_rec, &p_xmt, &peer->rec);
peer->leap = pleap;
peer->pmode = pmode;
peer->stratum = pstratum;
peer->ppoll = pkt->ppoll;
peer->precision = pkt->precision;
peer->rootdelay = p_del;
peer->rootdispersion = p_disp;
peer->refid = pkt->refid;
peer->reftime = p_reftime;
if (!(peer->reach)) {
report_event(EVNT_REACH, peer);
peer->timereachable = current_time;
}
peer->reach |= 1;
peer->unreach = 0;
poll_update(peer, peer->hpoll);
t10 = p_xmt;
L_SUB(&t10, &peer->rec);
t23 = p_rec;
L_SUB(&t23, &p_org);
ci = t10;
p_disp = clock_phi * (peer->rec.l_ui - p_org.l_ui);
if (pmode == MODE_BROADCAST) {
if (peer->flags & FLAG_MCAST) {
LFPTOD(&ci, p_offset);
peer->estbdelay = peer->offset - p_offset;
if (peer->hmode == MODE_CLIENT)
return;
peer->flags &= ~FLAG_MCAST;
}
DTOLFP(peer->estbdelay, &t10);
L_ADD(&ci, &t10);
p_del = peer->delay;
} else {
L_ADD(&ci, &t23);
L_RSHIFT(&ci);
L_SUB(&t23, &t10);
LFPTOD(&t23, p_del);
}
p_del = max(p_del, LOGTOD(sys_precision));
LFPTOD(&ci, p_offset);
if ((peer->rootdelay + p_del) / 2. + peer->rootdispersion +
p_disp >= MAXDISPERSE)
peer->flash |= TEST9;
if (peer->flash) {
#ifdef DEBUG
if (debug)
printf("packet: bad packet data %03x\n",
peer->flash);
#endif
return;
}
clock_filter(peer, p_offset, p_del, p_disp);
clock_select();
record_peer_stats(&peer->srcadr, ctlpeerstatus(peer),
peer->offset, peer->delay, peer->disp,
SQRT(peer->jitter));
}
static void
clock_update(void)
{
u_char oleap;
u_char ostratum;
if (sys_peer == NULL)
return;
if (sys_peer->pollsw == FALSE || sys_peer->burst > 0)
return;
sys_peer->pollsw = FALSE;
#ifdef DEBUG
if (debug)
printf("clock_update: at %ld assoc %d \n", current_time,
peer_associations);
#endif
oleap = sys_leap;
ostratum = sys_stratum;
switch (local_clock(sys_peer, sys_offset, sys_syserr)) {
case -1:
report_event(EVNT_SYSFAULT, (struct peer *)0);
exit(1);
case 1:
clear_all();
sys_peer = NULL;
sys_stratum = STRATUM_UNSPEC;
sys_poll = NTP_MINPOLL;
NLOG(NLOG_SYNCSTATUS)
msyslog(LOG_INFO, "synchronisation lost");
report_event(EVNT_CLOCKRESET, (struct peer *)0);
break;
default:
sys_stratum = sys_peer->stratum + 1;
if (sys_stratum == 1)
sys_refid = sys_peer->refid;
else
sys_refid = sys_peer->srcadr.sin_addr.s_addr;
sys_reftime = sys_peer->rec;
sys_rootdelay = sys_peer->rootdelay + sys_peer->delay;
sys_leap = leap_consensus;
}
if (oleap == LEAP_NOTINSYNC) {
report_event(EVNT_SYNCCHG, (struct peer *)0);
#ifdef AUTOKEY
expire_all();
#endif
}
if (ostratum != sys_stratum)
report_event(EVNT_PEERSTCHG, (struct peer *)0);
}
void
poll_update(
struct peer *peer,
int hpoll
)
{
#ifdef AUTOKEY
int oldpoll;
#endif
#ifdef AUTOKEY
oldpoll = peer->kpoll;
#endif
if (hpoll > peer->maxpoll)
peer->hpoll = peer->maxpoll;
else if (hpoll < peer->minpoll)
peer->hpoll = peer->minpoll;
else
peer->hpoll = hpoll;
if (peer->burst > 0) {
if (peer->nextdate != current_time)
return;
#ifdef REFCLOCK
else if (peer->flags & FLAG_REFCLOCK)
peer->nextdate++;
#endif
else if (peer->reach & 0x1)
peer->nextdate += RANDPOLL(BURST_INTERVAL2);
else
peer->nextdate += RANDPOLL(BURST_INTERVAL1);
} else if (peer->cast_flags & MDF_ACAST) {
if (sys_survivors < NTP_MINCLOCK)
peer->kpoll = peer->hpoll;
else
peer->kpoll = peer->hpoll + 3;
peer->nextdate = peer->outdate + RANDPOLL(peer->kpoll);
} else {
peer->kpoll = max(min(peer->ppoll, peer->hpoll),
peer->minpoll);
peer->nextdate = peer->outdate + RANDPOLL(peer->kpoll);
}
if (peer->nextdate < current_time)
peer->nextdate = current_time;
#ifdef AUTOKEY
if (peer->kpoll != oldpoll)
key_expire(peer);
#endif
#ifdef DEBUG
if (debug > 1)
printf("poll_update: at %lu %s flags %04x poll %d burst %d last %lu next %lu\n",
current_time, ntoa(&peer->srcadr), peer->flags,
peer->kpoll, peer->burst, peer->outdate,
peer->nextdate);
#endif
}
void
peer_clear(
register struct peer *peer
)
{
register int i;
u_long u_rand;
#ifdef DEBUG
if (debug)
printf("peer_clear: at %ld assoc ID %d\n", current_time,
peer->associd);
#endif
#ifdef AUTOKEY
key_expire(peer);
#ifdef PUBKEY
if (peer->keystr != NULL)
free(peer->keystr);
if (peer->pubkey.ptr != NULL)
free(peer->pubkey.ptr);
if (peer->certif.ptr != NULL)
free(peer->certif.ptr);
#endif
#endif
memset(CLEAR_TO_ZERO(peer), 0, LEN_CLEAR_TO_ZERO);
if (peer->cast_flags & MDF_BCLNT) {
peer->flags |= FLAG_MCAST;
peer->hmode = MODE_CLIENT;
}
peer->flags &= ~(FLAG_AUTOKEY | FLAG_ASSOC);
peer->estbdelay = sys_bdelay;
peer->hpoll = peer->kpoll = peer->minpoll;
peer->ppoll = peer->maxpoll;
peer->pollsw = FALSE;
peer->jitter = MAXDISPERSE;
peer->epoch = current_time;
#ifdef REFCLOCK
if (!(peer->flags & FLAG_REFCLOCK)) {
peer->leap = LEAP_NOTINSYNC;
peer->stratum = STRATUM_UNSPEC;
}
#endif
for (i = 0; i < NTP_SHIFT; i++) {
peer->filter_order[i] = i;
peer->filter_disp[i] = MAXDISPERSE;
peer->filter_epoch[i] = current_time;
}
peer->update = peer->outdate = current_time;
u_rand = RANDOM;
peer->nextdate = current_time + (u_rand & ((1 <<
BURST_INTERVAL1) - 1)) + 1;
}
void
clock_filter(
register struct peer *peer,
double sample_offset,
double sample_delay,
double sample_disp
)
{
double dst[NTP_SHIFT];
int ord[NTP_SHIFT];
register int i, j, k, m;
double dsp, jit, dtemp, etemp;
dsp = min(LOGTOD(peer->precision) + LOGTOD(sys_precision) +
sample_disp, MAXDISPERSE);
j = peer->filter_nextpt;
peer->filter_offset[j] = sample_offset;
peer->filter_delay[j] = max(0, sample_delay);
peer->filter_disp[j] = dsp;
peer->filter_epoch[j] = current_time;
j++; j %=NTP_SHIFT;
peer->filter_nextpt = j;
dtemp = clock_phi * (current_time - peer->update);
peer->update = current_time;
for (i = NTP_SHIFT - 1; i >= 0; i--) {
if (i != 0) {
peer->filter_disp[j] += dtemp;
if (peer->filter_disp[j] > MAXDISPERSE)
peer->filter_disp[j] = MAXDISPERSE;
}
if (peer->filter_disp[j] >= MAXDISPERSE)
dst[i] = MAXDISPERSE;
else if (peer->update - peer->filter_epoch[j] >
allan_xpt)
dst[i] = MAXDISTANCE + peer->filter_disp[j];
else
dst[i] = peer->filter_delay[j];
ord[i] = j;
j++; j %= NTP_SHIFT;
}
for (i = 1; i < NTP_SHIFT; i++) {
for (j = 0; j < i; j++) {
if (dst[j] > dst[i]) {
k = ord[j];
ord[j] = ord[i];
ord[i] = k;
etemp = dst[j];
dst[j] = dst[i];
dst[i] = etemp;
}
}
}
m = 0;
for (i = 0; i < NTP_SHIFT; i++) {
peer->filter_order[i] = ord[i];
if (dst[i] >= MAXDISPERSE || (m >= 2 && dst[i] >=
MAXDISTANCE))
continue;
m++;
}
jit = 0;
peer->disp = 0;
k = ord[0];
for (i = NTP_SHIFT - 1; i >= 0; i--) {
j = ord[i];
peer->disp = NTP_FWEIGHT * (peer->disp +
peer->filter_disp[j]);
if (i < m)
jit += DIFF(peer->filter_offset[j],
peer->filter_offset[k]);
}
if (m == 0)
return;
etemp = peer->offset;
peer->offset = peer->filter_offset[k];
peer->delay = peer->filter_delay[k];
if (m > 1)
jit /= m - 1;
peer->jitter = max(jit, SQUARE(LOGTOD(sys_precision)));
if (peer->filter_epoch[k] <= peer->epoch) {
#ifdef DEBUG
if (debug)
printf("clock_filter: discard %lu\n",
peer->epoch - peer->filter_epoch[k]);
#endif
return;
}
if (m > 1 && fabs(peer->offset - etemp) > SQRT(peer->jitter) *
CLOCK_SGATE && peer->filter_epoch[k] - peer->epoch <
(1 << (sys_poll + 1))) {
#ifdef DEBUG
if (debug)
printf("clock_filter: n %d popcorn spike %.6f jitter %.6f\n",
m, peer->offset, SQRT(peer->jitter));
#endif
return;
}
peer->epoch = peer->filter_epoch[k];
peer->pollsw = TRUE;
#ifdef DEBUG
if (debug)
printf(
"clock_filter: n %d off %.6f del %.6f dsp %.6f jit %.6f, age %lu\n",
m, peer->offset, peer->delay, peer->disp,
SQRT(peer->jitter), peer->update - peer->epoch);
#endif
}
void
clock_select(void)
{
register struct peer *peer;
int i, j, k, n;
int nreach, nlist, nl3;
double d, e, f;
int allow, found, sw;
double high, low;
double synch[NTP_MAXCLOCK], error[NTP_MAXCLOCK];
struct peer *osys_peer;
struct peer *typeacts = NULL;
struct peer *typelocal = NULL;
struct peer *typepps = NULL;
struct peer *typesystem = NULL;
static int list_alloc = 0;
static struct endpoint *endpoint = NULL;
static int *indx = NULL;
static struct peer **peer_list = NULL;
static u_int endpoint_size = 0;
static u_int indx_size = 0;
static u_int peer_list_size = 0;
osys_peer = sys_peer;
sys_peer = NULL;
sys_prefer = NULL;
nreach = nlist = 0;
low = 1e9;
high = -1e9;
for (n = 0; n < HASH_SIZE; n++)
nlist += peer_hash_count[n];
if (nlist > list_alloc) {
if (list_alloc > 0) {
free(endpoint);
free(indx);
free(peer_list);
}
while (list_alloc < nlist) {
list_alloc += 5;
endpoint_size += 5 * 3 * sizeof(*endpoint);
indx_size += 5 * 3 * sizeof(*indx);
peer_list_size += 5 * sizeof(*peer_list);
}
endpoint = (struct endpoint *)emalloc(endpoint_size);
indx = (int *)emalloc(indx_size);
peer_list = (struct peer **)emalloc(peer_list_size);
}
nlist = nl3 = 0;
for (n = 0; n < HASH_SIZE; n++) {
for (peer = peer_hash[n]; peer != NULL; peer =
peer->next) {
peer->flags &= ~FLAG_SYSPEER;
peer->status = CTL_PST_SEL_REJECT;
if (!peer->reach || (peer->stratum > 1 &&
peer->refid ==
peer->dstadr->sin.sin_addr.s_addr) ||
peer->stratum >= STRATUM_UNSPEC ||
(root_distance(peer) >= MAXDISTANCE + 2 *
clock_phi * ULOGTOD(sys_poll)))
continue;
if (peer->refclktype == REFCLK_LOCALCLOCK
#if defined(VMS) && defined(VMS_LOCALUNIT)
&& REFCLOCKUNIT(&peer->srcadr) != VMS_LOCALUNIT
#endif
) {
typelocal = peer;
if (!(peer->flags & FLAG_PREFER))
continue;
}
if (peer->sstclktype == CTL_SST_TS_TELEPHONE) {
typeacts = peer;
if (!(peer->flags & FLAG_PREFER))
continue;
}
nreach++;
peer->status = CTL_PST_SEL_SANE;
peer_list[nlist++] = peer;
e = peer->offset;
f = root_distance(peer);
e = e + f;
for (i = nl3 - 1; i >= 0; i--) {
if (e >= endpoint[indx[i]].val)
break;
indx[i + 3] = indx[i];
}
indx[i + 3] = nl3;
endpoint[nl3].type = 1;
endpoint[nl3++].val = e;
e = e - f;
for ( ; i >= 0; i--) {
if (e >= endpoint[indx[i]].val)
break;
indx[i + 2] = indx[i];
}
indx[i + 2] = nl3;
endpoint[nl3].type = 0;
endpoint[nl3++].val = e;
e = e - f;
for ( ; i >= 0; i--) {
if (e >= endpoint[indx[i]].val)
break;
indx[i + 1] = indx[i];
}
indx[i + 1] = nl3;
endpoint[nl3].type = -1;
endpoint[nl3++].val = e;
}
}
#ifdef DEBUG
if (debug > 2)
for (i = 0; i < nl3; i++)
printf("select: endpoint %2d %.6f\n",
endpoint[indx[i]].type,
endpoint[indx[i]].val);
#endif
i = 0;
j = nl3 - 1;
allow = nlist;
found = 0;
while (allow > 0) {
allow--;
for (n = 0; i <= j; i++) {
n += endpoint[indx[i]].type;
if (n < 0)
break;
if (endpoint[indx[i]].type == 0)
found++;
}
for (n = 0; i <= j; j--) {
n += endpoint[indx[j]].type;
if (n > 0)
break;
if (endpoint[indx[j]].type == 0)
found++;
}
if (found > allow)
break;
low = endpoint[indx[i++]].val;
high = endpoint[indx[j--]].val;
}
if ((allow << 1) >= nlist) {
if (typeacts != 0) {
typeacts->status = CTL_PST_SEL_SANE;
peer_list[0] = typeacts;
nlist = 1;
} else if (typelocal != 0) {
typelocal->status = CTL_PST_SEL_SANE;
peer_list[0] = typelocal;
nlist = 1;
} else {
if (osys_peer != NULL) {
sys_poll = NTP_MINPOLL;
NLOG(NLOG_SYNCSTATUS)
msyslog(LOG_INFO,
"synchronisation lost");
report_event(EVNT_PEERSTCHG,
(struct peer *)0);
}
sys_survivors = 0;
#ifdef AUTOKEY
resetmanycast();
#endif
return;
}
}
#ifdef DEBUG
if (debug > 2)
printf("select: low %.6f high %.6f\n", low, high);
#endif
j = 0;
for (i = 0; i < nlist; i++) {
peer = peer_list[i];
if (nlist > 1 && (low >= peer->offset || peer->offset >=
high)) {
if (!(peer->flags & FLAG_CONFIG))
unpeer(peer);
continue;
}
peer->status = CTL_PST_SEL_DISTSYSPEER;
d = root_distance(peer) + peer->stratum * MAXDISPERSE;
if (j >= NTP_MAXCLOCK) {
if (d >= synch[j - 1])
continue;
else
j--;
}
for (k = j; k > 0; k--) {
if (d >= synch[k - 1])
break;
peer_list[k] = peer_list[k - 1];
error[k] = error[k - 1];
synch[k] = synch[k - 1];
}
peer_list[k] = peer;
error[k] = peer->jitter;
synch[k] = d;
j++;
}
nlist = j;
for (i = 0; i < nlist; i++) {
peer_list[i]->status = CTL_PST_SEL_SELCAND;
#ifdef DEBUG
if (debug > 2)
printf("select: %s distance %.6f\n",
ntoa(&peer_list[i]->srcadr), synch[i]);
#endif
}
while (1) {
d = 1e9;
e = -1e9;
k = 0;
for (i = 0; i < nlist; i++) {
if (error[i] < d)
d = error[i];
f = 0;
if (nlist > 1) {
for (j = 0; j < nlist; j++)
f += DIFF(peer_list[j]->offset,
peer_list[i]->offset);
f /= nlist - 1;
}
f = max(f, SQUARE(LOGTOD(sys_precision)));
if (f * synch[i] > e) {
sys_selerr = f;
e = f * synch[i];
k = i;
}
}
#ifdef DEBUG
if (debug > 2)
printf(
"select: survivors %d select %.6f peer %.6f\n",
k, SQRT(sys_selerr), SQRT(d));
#endif
if (nlist <= NTP_MINCLOCK || sys_selerr <= d ||
peer_list[k]->flags & FLAG_PREFER)
break;
if (!(peer_list[k]->flags & FLAG_CONFIG))
unpeer(peer_list[k]);
for (j = k + 1; j < nlist; j++) {
peer_list[j - 1] = peer_list[j];
error[j - 1] = error[j];
}
nlist--;
}
#ifdef AUTOKEY
if (sys_survivors >= NTP_MINCLOCK && nlist < NTP_MINCLOCK)
resetmanycast();
#endif
sys_survivors = nlist;
#ifdef DEBUG
if (debug > 2) {
for (i = 0; i < nlist; i++)
printf(
"select: %s offset %.6f, distance %.6f poll %d\n",
ntoa(&peer_list[i]->srcadr),
peer_list[i]->offset, synch[i],
peer_list[i]->pollsw);
}
#endif
if (osys_peer == NULL && 2 * nlist < min(nreach, NTP_MINCLOCK))
return;
leap_consensus = 0;
for (i = nlist - 1; i >= 0; i--) {
peer = peer_list[i];
peer->status = CTL_PST_SEL_SYNCCAND;
peer->flags |= FLAG_SYSPEER;
poll_update(peer, peer->hpoll);
if (peer->stratum == peer_list[0]->stratum) {
leap_consensus |= peer->leap;
if (peer->refclktype == REFCLK_ATOM_PPS &&
peer->stratum < STRATUM_UNSPEC)
typepps = peer;
if (peer == osys_peer)
typesystem = peer;
if (peer->flags & FLAG_PREFER)
sys_prefer = peer;
}
}
if (sys_prefer)
sw = sys_prefer->refclktype == REFCLK_LOCALCLOCK ||
sys_prefer->sstclktype == CTL_SST_TS_TELEPHONE ||
!typepps;
else
sw = 0;
if (sw) {
sys_peer = sys_prefer;
sys_peer->status = CTL_PST_SEL_SYSPEER;
sys_offset = sys_peer->offset;
sys_syserr = sys_peer->jitter;
#ifdef DEBUG
if (debug > 1)
printf("select: prefer offset %.6f\n",
sys_offset);
#endif
} else if (typepps) {
sys_peer = typepps;
sys_peer->status = CTL_PST_SEL_PPS;
sys_offset = sys_peer->offset;
sys_syserr = sys_peer->jitter;
if (!pps_control)
NLOG(NLOG_SYSEVENT)
msyslog(LOG_INFO,
"pps sync enabled");
pps_control = current_time;
#ifdef DEBUG
if (debug > 1)
printf("select: pps offset %.6f\n",
sys_offset);
#endif
} else {
if (typesystem)
sys_peer = osys_peer;
else
sys_peer = peer_list[0];
sys_peer->status = CTL_PST_SEL_SYSPEER;
sys_offset = clock_combine(peer_list, nlist);
sys_syserr = sys_peer->jitter + sys_selerr;
#ifdef DEBUG
if (debug > 1)
printf("select: combine offset %.6f\n",
sys_offset);
#endif
}
if (osys_peer != sys_peer)
report_event(EVNT_PEERSTCHG, (struct peer *)0);
clock_update();
}
static double
clock_combine(
struct peer **peers,
int npeers
)
{
int i;
double x, y, z;
y = z = 0;
for (i = 0; i < npeers; i++) {
x = root_distance(peers[i]);
y += 1. / x;
z += peers[i]->offset / x;
}
return (z / y);
}
static double
root_distance(
struct peer *peer
)
{
return ((peer->rootdelay + peer->delay) / 2 +
peer->rootdispersion + peer->disp + clock_phi *
(current_time - peer->update) + SQRT(peer->jitter));
}
static void
peer_xmit(
struct peer *peer
)
{
struct pkt xpkt;
int sendlen, authlen;
keyid_t xkeyid;
l_fp xmt_tx;
xpkt.li_vn_mode = PKT_LI_VN_MODE(sys_leap, peer->version,
peer->hmode);
xpkt.stratum = STRATUM_TO_PKT(sys_stratum);
xpkt.ppoll = peer->hpoll;
xpkt.precision = sys_precision;
xpkt.rootdelay = HTONS_FP(DTOFP(sys_rootdelay));
xpkt.rootdispersion = HTONS_FP(DTOUFP(sys_rootdispersion));
xpkt.refid = sys_refid;
HTONL_FP(&sys_reftime, &xpkt.reftime);
HTONL_FP(&peer->org, &xpkt.org);
HTONL_FP(&peer->rec, &xpkt.rec);
sendlen = LEN_PKT_NOMAC;
if (!(peer->flags & FLAG_AUTHENABLE)) {
get_systime(&peer->xmt);
HTONL_FP(&peer->xmt, &xpkt.xmt);
sendpkt(&peer->srcadr, peer->dstadr, peer->ttl, &xpkt,
sendlen);
peer->sent++;
#ifdef DEBUG
if (debug)
printf("transmit: at %ld %s->%s mode %d\n",
current_time, ntoa(&peer->dstadr->sin),
ntoa(&peer->srcadr), peer->hmode);
#endif
return;
}
#ifdef AUTOKEY
if ((peer->flags & FLAG_SKEY)) {
u_int cmmd;
while (1) {
if (peer->keynumber == 0)
make_keylist(peer, peer->dstadr);
else
peer->keynumber--;
xkeyid = peer->keylist[peer->keynumber];
if (authistrusted(xkeyid))
break;
else
key_expire(peer);
}
peer->keyid = xkeyid;
switch (peer->hmode) {
case MODE_BROADCAST:
if (peer->flags & FLAG_ASSOC)
cmmd = CRYPTO_AUTO | CRYPTO_RESP;
else
cmmd = CRYPTO_ASSOC | CRYPTO_RESP;
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, cmmd, 0, peer->associd);
break;
case MODE_ACTIVE:
case MODE_PASSIVE:
#ifdef PUBKEY
if (peer->cmmd != 0)
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, (peer->cmmd >> 16) |
CRYPTO_RESP, peer->hcookie,
peer->associd);
if (!peer->crypto)
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, CRYPTO_ASSOC,
peer->hcookie, peer->assoc);
else if (!crypto_flags &&
peer->pcookie.tstamp == 0 && sys_leap !=
LEAP_NOTINSYNC)
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, CRYPTO_PRIV, peer->hcookie,
peer->assoc);
else if (crypto_flags && peer->pubkey.ptr ==
NULL)
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, CRYPTO_NAME, peer->hcookie,
peer->assoc);
else if (peer->crypto & CRYPTO_FLAG_CERT)
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, CRYPTO_CERT, peer->hcookie,
peer->assoc);
else if (crypto_flags && peer->crypto &
CRYPTO_FLAG_DH && sys_leap !=
LEAP_NOTINSYNC)
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, CRYPTO_DHPAR,
peer->hcookie, peer->assoc);
else if (crypto_flags && peer->pcookie.tstamp ==
0 && sys_leap != LEAP_NOTINSYNC)
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, CRYPTO_DH, peer->hcookie,
peer->assoc);
#else
if (peer->cmmd != 0)
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, (peer->cmmd >> 16) |
CRYPTO_RESP, peer->hcookie,
peer->associd);
if (peer->pcookie.tstamp == 0 && sys_leap !=
LEAP_NOTINSYNC)
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, CRYPTO_PRIV, peer->hcookie,
peer->assoc);
#endif
else if (!(peer->flags & FLAG_AUTOKEY))
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, CRYPTO_AUTO, peer->hcookie,
peer->assoc);
else if ((peer->flags & FLAG_ASSOC) &&
(peer->cmmd >> 16) != CRYPTO_AUTO)
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, CRYPTO_AUTO | CRYPTO_RESP,
peer->hcookie, peer->associd);
#ifdef PUBKEY
else if (peer->crypto & CRYPTO_FLAG_TAI)
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, CRYPTO_TAI, peer->hcookie,
peer->assoc);
#endif
peer->cmmd = 0;
break;
case MODE_CLIENT:
if (peer->cmmd != 0)
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, (peer->cmmd >> 16) |
CRYPTO_RESP, peer->hcookie,
peer->associd);
if (!peer->crypto)
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, CRYPTO_ASSOC,
peer->hcookie, peer->assoc);
#ifdef PUBKEY
else if (crypto_flags && peer->pubkey.ptr ==
NULL)
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, CRYPTO_NAME, peer->hcookie,
peer->assoc);
else if (peer->crypto & CRYPTO_FLAG_CERT)
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, CRYPTO_CERT, peer->hcookie,
peer->assoc);
#endif
else if (peer->pcookie.tstamp == 0)
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, CRYPTO_PRIV, peer->hcookie,
peer->assoc);
else if (!(peer->flags & FLAG_AUTOKEY) &&
(peer->cast_flags & MDF_BCLNT))
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, CRYPTO_AUTO, peer->hcookie,
peer->assoc);
#ifdef PUBKEY
else if (peer->crypto & CRYPTO_FLAG_TAI)
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, CRYPTO_TAI, peer->hcookie,
peer->assoc);
#endif
peer->cmmd = 0;
break;
}
if (sendlen > LEN_PKT_NOMAC)
session_key(&peer->dstadr->sin, &peer->srcadr,
xkeyid, 0, 2);
}
#endif
xkeyid = peer->keyid;
get_systime(&peer->xmt);
L_ADD(&peer->xmt, &sys_authdelay);
HTONL_FP(&peer->xmt, &xpkt.xmt);
authlen = authencrypt(xkeyid, (u_int32 *)&xpkt, sendlen);
if (authlen == 0) {
msyslog(LOG_NOTICE,
"transmit: no encryption key found");
peer->flash |= TEST4 | TEST5;
return;
}
sendlen += authlen;
#ifdef AUTOKEY
if (xkeyid > NTP_MAXKEY)
authtrust(xkeyid, 0);
#endif
get_systime(&xmt_tx);
if (sendlen > sizeof(xpkt)) {
msyslog(LOG_ERR, "buffer overflow %u", sendlen);
exit(-1);
}
sendpkt(&peer->srcadr, peer->dstadr, peer->ttl, &xpkt, sendlen);
L_SUB(&xmt_tx, &peer->xmt);
L_ADD(&xmt_tx, &sys_authdelay);
sys_authdly[1] = sys_authdly[0];
sys_authdly[0] = xmt_tx.l_uf;
if (sys_authdly[0] < sys_authdly[1])
sys_authdelay.l_uf = sys_authdly[0];
else
sys_authdelay.l_uf = sys_authdly[1];
peer->sent++;
#ifdef AUTOKEY
#ifdef DEBUG
if (debug)
printf(
"transmit: at %ld %s->%s mode %d keyid %08x len %d mac %d index %d\n",
current_time, ntoa(&peer->dstadr->sin),
ntoa(&peer->srcadr), peer->hmode, xkeyid, sendlen,
authlen, peer->keynumber);
#endif
#else
#ifdef DEBUG
if (debug)
printf(
"transmit: at %ld %s->%s mode %d keyid %08x len %d mac %d\n",
current_time, ntoa(&peer->dstadr->sin),
ntoa(&peer->srcadr), peer->hmode, xkeyid, sendlen,
authlen);
#endif
#endif
}
static void
fast_xmit(
struct recvbuf *rbufp,
int xmode,
keyid_t xkeyid,
int mask
)
{
struct pkt xpkt;
struct pkt *rpkt;
l_fp xmt_ts;
l_fp xmt_tx;
int sendlen, authlen;
rpkt = &rbufp->recv_pkt;
if (rbufp->dstadr->flags & INT_MULTICAST)
rbufp->dstadr = findinterface(&rbufp->recv_srcadr);
if (mask & (RES_DONTSERVE | RES_LIMITED)) {
if (!(mask & RES_DEMOBILIZE)) {
return;
} else {
xpkt.li_vn_mode =
PKT_LI_VN_MODE(LEAP_NOTINSYNC,
PKT_VERSION(rpkt->li_vn_mode), xmode);
xpkt.stratum = STRATUM_UNSPEC;
memcpy(&xpkt.refid, "DENY", 4);
}
} else {
xpkt.li_vn_mode = PKT_LI_VN_MODE(sys_leap,
PKT_VERSION(rpkt->li_vn_mode), xmode);
xpkt.stratum = STRATUM_TO_PKT(sys_stratum);
xpkt.refid = sys_refid;
}
xpkt.ppoll = rpkt->ppoll;
xpkt.precision = sys_precision;
xpkt.rootdelay = HTONS_FP(DTOFP(sys_rootdelay));
xpkt.rootdispersion =
HTONS_FP(DTOUFP(sys_rootdispersion));
HTONL_FP(&sys_reftime, &xpkt.reftime);
xpkt.org = rpkt->xmt;
HTONL_FP(&rbufp->recv_time, &xpkt.rec);
sendlen = LEN_PKT_NOMAC;
if (rbufp->recv_length == sendlen) {
get_systime(&xmt_ts);
HTONL_FP(&xmt_ts, &xpkt.xmt);
sendpkt(&rbufp->recv_srcadr, rbufp->dstadr, 0, &xpkt,
sendlen);
#ifdef DEBUG
if (debug)
printf("transmit: at %ld %s->%s mode %d\n",
current_time, ntoa(&rbufp->dstadr->sin),
ntoa(&rbufp->recv_srcadr), xmode);
#endif
return;
}
#ifdef AUTOKEY
if (xkeyid > NTP_MAXKEY) {
keyid_t cookie;
u_int code, associd;
code = (htonl(rpkt->exten[0]) >> 16) | CRYPTO_RESP;
cookie = session_key(&rbufp->recv_srcadr,
&rbufp->dstadr->sin, 0, sys_private, 0);
associd = htonl(rpkt->exten[1]);
if (rbufp->recv_length >= sendlen + MAX_MAC_LEN + 2 *
sizeof(u_int32)) {
session_key(&rbufp->dstadr->sin,
&rbufp->recv_srcadr, xkeyid, 0, 2);
sendlen += crypto_xmit((u_int32 *)&xpkt,
sendlen, code, cookie, associd);
} else {
session_key(&rbufp->dstadr->sin,
&rbufp->recv_srcadr, xkeyid, cookie, 2);
}
}
#endif
get_systime(&xmt_ts);
L_ADD(&xmt_ts, &sys_authdelay);
HTONL_FP(&xmt_ts, &xpkt.xmt);
authlen = authencrypt(xkeyid, (u_int32 *)&xpkt, sendlen);
sendlen += authlen;
#ifdef AUTOKEY
if (xkeyid > NTP_MAXKEY)
authtrust(xkeyid, 0);
#endif
get_systime(&xmt_tx);
if (sendlen > sizeof(xpkt)) {
msyslog(LOG_ERR, "buffer overflow %u", sendlen);
exit(-1);
}
sendpkt(&rbufp->recv_srcadr, rbufp->dstadr, 0, &xpkt, sendlen);
L_SUB(&xmt_tx, &xmt_ts);
L_ADD(&xmt_tx, &sys_authdelay);
sys_authdly[1] = sys_authdly[0];
sys_authdly[0] = xmt_tx.l_uf;
if (sys_authdly[0] < sys_authdly[1])
sys_authdelay.l_uf = sys_authdly[0];
else
sys_authdelay.l_uf = sys_authdly[1];
#ifdef DEBUG
if (debug)
printf(
"transmit: at %ld %s->%s mode %d keyid %08x len %d mac %d\n",
current_time, ntoa(&rbufp->dstadr->sin),
ntoa(&rbufp->recv_srcadr), xmode, xkeyid, sendlen,
authlen);
#endif
}
#ifdef AUTOKEY
void
key_expire(
struct peer *peer
)
{
int i;
if (peer->keylist != NULL) {
for (i = 0; i <= peer->keynumber; i++)
authtrust(peer->keylist[i], 0);
free(peer->keylist);
peer->keylist = NULL;
}
peer->keynumber = peer->sndauto.seq = 0;
#ifdef DEBUG
if (debug)
printf("key_expire: at %lu\n", current_time);
#endif
}
#endif
#define DUSECS 1000000
#define HUSECS (1 << 20)
#define MINSTEP 5
#define MAXSTEP 20000
#define MINLOOPS 5
int
default_get_precision(void)
{
struct timeval tp;
#if !defined(SYS_WINNT) && !defined(VMS) && !defined(_SEQUENT_) && \
!defined(MPE)
struct timezone tzp;
#elif defined(VMS) || defined(_SEQUENT_)
struct timezone {
int tz_minuteswest;
int tz_dsttime;
} tzp;
#endif
long last;
int i;
long diff;
long val;
long usec;
#ifdef HAVE_GETCLOCK
struct timespec ts;
#endif
#if defined(__FreeBSD__) && __FreeBSD__ >= 3
u_long freq;
size_t j;
j = sizeof freq;
i = sysctlbyname("kern.timecounter.frequency", &freq, &j , 0,
0);
if (i)
i = sysctlbyname("machdep.tsc_freq", &freq, &j , 0, 0);
if (i)
i = sysctlbyname("machdep.i586_freq", &freq, &j , 0, 0);
if (i)
i = sysctlbyname("machdep.i8254_freq", &freq, &j , 0,
0);
if (!i) {
for (i = 1; freq ; i--)
freq >>= 1;
return (i);
}
#endif
usec = 0;
val = MAXSTEP;
#ifdef HAVE_GETCLOCK
(void) getclock(TIMEOFDAY, &ts);
tp.tv_sec = ts.tv_sec;
tp.tv_usec = ts.tv_nsec / 1000;
#else
GETTIMEOFDAY(&tp, &tzp);
#endif
last = tp.tv_usec;
for (i = 0; i < MINLOOPS && usec < HUSECS;) {
#ifdef HAVE_GETCLOCK
(void) getclock(TIMEOFDAY, &ts);
tp.tv_sec = ts.tv_sec;
tp.tv_usec = ts.tv_nsec / 1000;
#else
GETTIMEOFDAY(&tp, &tzp);
#endif
diff = tp.tv_usec - last;
last = tp.tv_usec;
if (diff < 0)
diff += DUSECS;
usec += diff;
if (diff > MINSTEP) {
i++;
if (diff < val)
val = diff;
}
}
NLOG(NLOG_SYSINFO)
msyslog(LOG_INFO, "precision = %ld usec", val);
if (usec >= HUSECS)
val = MINSTEP;
diff = HUSECS;
for (i = 0; diff > val; i--)
diff >>= 1;
return (i);
}
void
init_proto(void)
{
l_fp dummy;
sys_leap = LEAP_NOTINSYNC;
sys_stratum = STRATUM_UNSPEC;
sys_precision = (s_char)default_get_precision();
sys_jitter = LOGTOD(sys_precision);
sys_rootdelay = 0;
sys_rootdispersion = 0;
sys_refid = 0;
L_CLR(&sys_reftime);
sys_peer = NULL;
sys_survivors = 0;
get_systime(&dummy);
sys_bclient = 0;
sys_bdelay = DEFBROADDELAY;
sys_authenticate = 1;
L_CLR(&sys_authdelay);
sys_authdly[0] = sys_authdly[1] = 0;
sys_stattime = 0;
sys_badstratum = 0;
sys_oldversionpkt = 0;
sys_newversionpkt = 0;
sys_badlength = 0;
sys_unknownversion = 0;
sys_processed = 0;
sys_badauth = 0;
sys_manycastserver = 0;
#ifdef AUTOKEY
sys_automax = 1 << NTP_AUTOMAX;
#endif
ntp_enable = 1;
#ifndef KERNEL_FLL_BUG
kern_enable = 1;
#endif
pps_enable = 0;
stats_control = 1;
#if defined RELIANTUNIX_CLOCK
systime_10ms_ticks = 1;
#elif defined SCO5_CLOCK
if (sys_precision >= (s_char)-10)
systime_10ms_ticks = 1;
#endif
if (systime_10ms_ticks)
msyslog(LOG_INFO, "using 10ms tick adjustments");
}
void
proto_config(
int item,
u_long value,
double dvalue
)
{
switch (item) {
case PROTO_KERNEL:
kern_enable = (int)value;
break;
case PROTO_NTP:
ntp_enable = (int)value;
break;
case PROTO_MONITOR:
if (value)
mon_start(MON_ON);
else
mon_stop(MON_ON);
break;
case PROTO_FILEGEN:
stats_control = (int)value;
break;
case PROTO_BROADCLIENT:
sys_bclient = (int)value;
if (value)
io_setbclient();
else
io_unsetbclient();
break;
case PROTO_MULTICAST_ADD:
io_multicast_add(value);
break;
case PROTO_MULTICAST_DEL:
io_multicast_del(value);
break;
case PROTO_BROADDELAY:
sys_bdelay = dvalue;
break;
case PROTO_AUTHENTICATE:
sys_authenticate = (int)value;
break;
case PROTO_PPS:
pps_enable = (int)value;
break;
#ifdef REFCLOCK
case PROTO_CAL:
cal_enable = (int)value;
break;
#endif
default:
msyslog(LOG_ERR,
"proto_config: illegal item %d, value %ld",
item, value);
break;
}
}
void
proto_clr_stats(void)
{
sys_badstratum = 0;
sys_oldversionpkt = 0;
sys_newversionpkt = 0;
sys_unknownversion = 0;
sys_badlength = 0;
sys_processed = 0;
sys_badauth = 0;
sys_stattime = current_time;
sys_limitrejected = 0;
}