#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_leapsec.h"
#include "refidsmear.h"
#include "lib_strbuf.h"
#include <stdio.h>
#ifdef HAVE_LIBSCF_H
#include <libscf.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <os/trace.h>
#ifndef BDELAY_DEFAULT
# define BDELAY_DEFAULT (-0.050)
#endif
#define AUTH(x, y) ((x) ? (y) == AUTH_OK \
: (y) == AUTH_OK || (y) == AUTH_NONE)
#define AUTH_NONE 0
#define AUTH_OK 1
#define AUTH_ERROR 2
#define AUTH_CRYPTO 3
enum kiss_codes {
NOKISS,
RATEKISS,
DENYKISS,
RSTRKISS,
XKISS,
UNKNOWNKISS
};
enum nak_error_codes {
NONAK,
INVALIDNAK,
VALIDNAK
};
#define NTP_IBURST 6
#define RESP_DELAY 1
#define POOL_SOLICIT_WINDOW 8
typedef struct peer_select_tag {
struct peer * peer;
double synch;
double error;
double seljit;
} peer_select;
u_char sys_leap;
u_char xmt_leap;
u_char sys_stratum;
s_char sys_precision;
double sys_rootdelay;
double sys_rootdisp;
u_int32 sys_refid;
l_fp sys_reftime;
struct peer *sys_peer;
#ifdef LEAP_SMEAR
struct leap_smear_info leap_smear;
#endif
int leap_sec_in_progress;
int sys_bclient;
double sys_bdelay;
int sys_authenticate;
l_fp sys_authdelay;
double sys_offset;
double sys_mindisp = MINDISPERSE;
double sys_maxdist = MAXDISTANCE;
double sys_jitter;
u_long sys_epoch;
static double sys_clockhop;
static int leap_vote_ins;
static int leap_vote_del;
keyid_t sys_private;
int sys_manycastserver;
int ntp_mode7;
int peer_ntpdate;
int sys_survivors;
char *sys_ident = NULL;
int sys_floor = 0;
u_char sys_bcpollbstep = 0;
int sys_ceiling = STRATUM_UNSPEC - 1;
int sys_minsane = 1;
int sys_minclock = NTP_MINCLOCK;
int sys_maxclock = NTP_MAXCLOCK;
int sys_cohort = 0;
int sys_orphan = STRATUM_UNSPEC + 1;
int sys_orphwait = NTP_ORPHWAIT;
int sys_beacon = BEACON;
u_int sys_ttlmax;
u_char sys_ttl[MAX_TTL];
u_long sys_stattime;
u_long sys_received;
u_long sys_processed;
u_long sys_newversion;
u_long sys_oldversion;
u_long sys_restricted;
u_long sys_badlength;
u_long sys_badauth;
u_long sys_declined;
u_long sys_limitrejected;
u_long sys_kodsent;
int peer_clear_digest_early = 1;
int unpeer_crypto_early = 1;
int unpeer_crypto_nak_early = 1;
int unpeer_digest_early = 1;
int dynamic_interleave = DYNAMIC_INTERLEAVE;
int kiss_code_check(u_char hisleap, u_char hisstratum, u_char hismode, u_int32 refid);
enum nak_error_codes valid_NAK(struct peer *peer, struct recvbuf *rbufp, u_char hismode);
static double root_distance (struct peer *);
static void clock_combine (peer_select *, int, int);
static void peer_xmit (struct peer *);
static void fast_xmit (struct recvbuf *, int, keyid_t, int);
static void pool_xmit (struct peer *);
static void clock_update (struct peer *);
static void measure_precision(void);
static double measure_tick_fuzz(void);
static int local_refid (struct peer *);
static int peer_unfit (struct peer *);
#ifdef AUTOKEY
static int group_test (char *, char *);
#endif
#ifdef WORKER
void pool_name_resolved (int, int, void *, const char *,
const char *, const struct addrinfo *,
const struct addrinfo *);
#endif
const char * amtoa (int am);
void
set_sys_leap(
u_char new_sys_leap
)
{
sys_leap = new_sys_leap;
xmt_leap = sys_leap;
if (xmt_leap != LEAP_NOTINSYNC) {
if (leap_sec_in_progress) {
xmt_leap = LEAP_NOTINSYNC;
}
#ifdef LEAP_SMEAR
else {
if (leap_smear.enabled)
xmt_leap = LEAP_NOWARNING;
}
#endif
}
}
int
kiss_code_check(
u_char hisleap,
u_char hisstratum,
u_char hismode,
u_int32 refid
)
{
if ( hismode == MODE_SERVER
&& hisleap == LEAP_NOTINSYNC
&& hisstratum == STRATUM_UNSPEC) {
if(memcmp(&refid,"RATE", 4) == 0) {
return (RATEKISS);
} else if(memcmp(&refid,"DENY", 4) == 0) {
return (DENYKISS);
} else if(memcmp(&refid,"RSTR", 4) == 0) {
return (RSTRKISS);
} else if(memcmp(&refid,"X", 1) == 0) {
return (XKISS);
} else {
return (UNKNOWNKISS);
}
} else {
return (NOKISS);
}
}
enum nak_error_codes
valid_NAK(
struct peer *peer,
struct recvbuf *rbufp,
u_char hismode
)
{
int base_packet_length = MIN_V4_PKT_LEN;
int remainder_size;
struct pkt * rpkt;
int keyid;
l_fp p_org;
const l_fp * myorg;
if (rbufp->recv_length == base_packet_length) {
return NONAK;
}
remainder_size = rbufp->recv_length - base_packet_length;
if (remainder_size != 4) {
return NONAK;
}
if (hismode != MODE_SERVER &&
hismode != MODE_ACTIVE &&
hismode != MODE_PASSIVE
) {
return INVALIDNAK;
}
rpkt = &rbufp->recv_pkt;
keyid = ntohl(((u_int32 *)rpkt)[base_packet_length / 4]);
if (keyid != 0) {
return INVALIDNAK;
}
if (!peer || !peer->keyid || !(peer->flags & FLAG_SKEY)) {
return INVALIDNAK;
}
NTOHL_FP(&rpkt->org, &p_org);
if (peer->flip > 0)
myorg = &peer->borg;
else
myorg = &peer->aorg;
if (L_ISZERO(&p_org) ||
L_ISZERO( myorg) ||
!L_ISEQU(&p_org, myorg)) {
return INVALIDNAK;
}
return VALIDNAK;
}
void
transmit(
struct peer *peer
)
{
u_char hpoll;
hpoll = peer->hpoll;
if (peer->cast_flags & (MDF_BCAST | MDF_MCAST)) {
peer->outdate = current_time;
if (sys_leap != LEAP_NOTINSYNC)
peer_xmit(peer);
poll_update(peer, hpoll);
return;
}
if (peer->cast_flags & MDF_ACAST) {
peer->outdate = current_time;
if (peer->unreach > sys_beacon) {
peer->unreach = 0;
peer->ttl = 0;
peer_xmit(peer);
} else if ( sys_survivors < sys_minclock
|| peer_associations < sys_maxclock) {
if (peer->ttl < sys_ttlmax)
peer->ttl++;
peer_xmit(peer);
}
peer->unreach++;
poll_update(peer, hpoll);
return;
}
if (peer->cast_flags & MDF_POOL) {
peer->outdate = current_time;
if ( (peer_associations <= 2 * sys_maxclock)
&& ( peer_associations < sys_maxclock
|| sys_survivors < sys_minclock))
pool_xmit(peer);
poll_update(peer, hpoll);
return;
}
if (peer->burst == 0) {
u_char oreach;
oreach = peer->reach;
peer->outdate = current_time;
peer->unreach++;
peer->reach <<= 1;
if (!peer->reach) {
clock_filter(peer, 0., 0., MAXDISPERSE);
if (oreach) {
peer_unfit(peer);
report_event(PEVNT_UNREACH, peer, NULL);
}
if ( (peer->flags & FLAG_IBURST)
&& peer->retry == 0)
peer->retry = NTP_RETRY;
} else {
hpoll = sys_poll;
if (!(peer->flags & FLAG_PREEMPT))
peer->unreach = 0;
if ( (peer->flags & FLAG_BURST)
&& peer->retry == 0
&& !peer_unfit(peer))
peer->retry = NTP_RETRY;
}
if (peer->unreach >= NTP_UNREACH) {
hpoll++;
if (!(peer->flags & (FLAG_CONFIG | FLAG_PREEMPT))) {
report_event(PEVNT_RESTART, peer, "timeout");
peer_clear(peer, "TIME");
unpeer(peer);
return;
}
if ( (peer->flags & FLAG_PREEMPT)
&& (peer_associations > sys_maxclock)
&& score_all(peer)) {
report_event(PEVNT_RESTART, peer, "timeout");
peer_clear(peer, "TIME");
unpeer(peer);
return;
}
}
} else {
peer->burst--;
if (peer->burst == 0) {
if (mode_ntpdate) {
peer_ntpdate--;
if (peer_ntpdate == 0) {
msyslog(LOG_NOTICE,
"ntpd: no servers found");
if (!msyslog_term)
printf(
"ntpd: no servers found\n");
exit (0);
}
}
}
}
if (peer->retry > 0)
peer->retry--;
if (peer->hmode != MODE_BCLIENT)
peer_xmit(peer);
poll_update(peer, hpoll);
return;
}
const char *
amtoa(
int am
)
{
char *bp;
switch(am) {
case AM_ERR: return "AM_ERR";
case AM_NOMATCH: return "AM_NOMATCH";
case AM_PROCPKT: return "AM_PROCPKT";
case AM_BCST: return "AM_BCST";
case AM_FXMIT: return "AM_FXMIT";
case AM_MANYCAST: return "AM_MANYCAST";
case AM_NEWPASS: return "AM_NEWPASS";
case AM_NEWBCL: return "AM_NEWBCL";
case AM_POSSBCL: return "AM_POSSBCL";
default:
LIB_GETBUF(bp);
snprintf(bp, LIB_BUFLENGTH, "AM_#%d", am);
return bp;
}
}
void
receive(
struct recvbuf *rbufp
)
{
register struct peer *peer;
register struct pkt *pkt;
u_char hisversion;
u_char hisleap;
u_char hismode;
u_char hisstratum;
u_short restrict_mask;
const char *hm_str;
const char *am_str;
int kissCode = NOKISS;
int has_mac;
int authlen;
int is_authentic = AUTH_NONE;
int crypto_nak_test;
int retcode = AM_NOMATCH;
keyid_t skeyid = 0;
u_int32 opcode = 0;
sockaddr_u *dstadr_sin;
struct peer *peer2;
endpt *match_ep;
l_fp p_org;
l_fp p_rec;
l_fp p_xmt;
#ifdef AUTOKEY
char hostname[NTP_MAXSTRLEN + 1];
char *groupname = NULL;
struct autokey *ap;
int rval;
keyid_t pkeyid = 0, tkeyid = 0;
#endif
#ifdef HAVE_NTP_SIGND
static unsigned char zero_key[16];
#endif
sys_received++;
if (0 == SRCPORT(&rbufp->recv_srcadr)) {
sys_badlength++;
return;
}
restrict_mask = restrictions(&rbufp->recv_srcadr);
pkt = &rbufp->recv_pkt;
DPRINTF(2, ("receive: at %ld %s<-%s flags %x restrict %03x org %#010x.%08x xmt %#010x.%08x\n",
current_time, stoa(&rbufp->dstadr->sin),
stoa(&rbufp->recv_srcadr), rbufp->dstadr->flags,
restrict_mask, ntohl(pkt->org.l_ui), ntohl(pkt->org.l_uf),
ntohl(pkt->xmt.l_ui), ntohl(pkt->xmt.l_uf)));
hisversion = PKT_VERSION(pkt->li_vn_mode);
hisleap = PKT_LEAP(pkt->li_vn_mode);
hismode = (int)PKT_MODE(pkt->li_vn_mode);
hisstratum = PKT_TO_STRATUM(pkt->stratum);
INSIST(0 != hisstratum);
if (restrict_mask & RES_IGNORE) {
sys_restricted++;
return;
}
if (hismode == MODE_PRIVATE) {
if (!ntp_mode7 || (restrict_mask & RES_NOQUERY)) {
sys_restricted++;
return;
}
process_private(rbufp, ((restrict_mask &
RES_NOMODIFY) == 0));
return;
}
if (hismode == MODE_CONTROL) {
if (restrict_mask & RES_NOQUERY) {
sys_restricted++;
return;
}
process_control(rbufp, restrict_mask);
return;
}
if (restrict_mask & RES_DONTSERVE) {
sys_restricted++;
return;
}
if (restrict_mask & RES_FLAKE) {
if ((double)ntp_random() / 0x7fffffff < .1) {
sys_restricted++;
return;
}
}
if (hisversion == NTP_VERSION) {
sys_newversion++;
} else if ( !(restrict_mask & RES_VERSION)
&& hisversion >= NTP_OLDVERSION) {
sys_oldversion++;
} else {
sys_badlength++;
return;
}
if (hismode == MODE_UNSPEC) {
if (hisversion == NTP_OLDVERSION) {
hismode = MODE_CLIENT;
} else {
sys_badlength++;
return;
}
}
authlen = LEN_PKT_NOMAC;
has_mac = rbufp->recv_length - authlen;
while (has_mac > 0) {
u_int32 len;
#ifdef AUTOKEY
u_int32 hostlen;
struct exten *ep;
#endif
if (has_mac % 4 != 0 || has_mac < (int)MIN_MAC_LEN) {
sys_badlength++;
return;
}
if (has_mac <= (int)MAX_MAC_LEN) {
skeyid = ntohl(((u_int32 *)pkt)[authlen / 4]);
break;
} else {
opcode = ntohl(((u_int32 *)pkt)[authlen / 4]);
len = opcode & 0xffff;
if ( len % 4 != 0
|| len < 4
|| (int)len + authlen > rbufp->recv_length) {
sys_badlength++;
return;
}
#ifdef AUTOKEY
if ( (opcode & 0x3fff0000) == CRYPTO_ASSOC
&& sys_groupname != NULL) {
ep = (struct exten *)&((u_int32 *)pkt)[authlen / 4];
hostlen = ntohl(ep->vallen);
if ( hostlen >= sizeof(hostname)
|| hostlen > len -
offsetof(struct exten, pkt)) {
sys_badlength++;
return;
}
memcpy(hostname, &ep->pkt, hostlen);
hostname[hostlen] = '\0';
groupname = strchr(hostname, '@');
if (groupname == NULL) {
sys_declined++;
return;
}
groupname++;
}
#endif
authlen += len;
has_mac -= len;
}
}
if (has_mac < 0) {
sys_badlength++;
return;
}
if (restrict_mask & RES_DONTTRUST && has_mac == 0) {
sys_restricted++;
return;
}
restrict_mask = ntp_monitor(rbufp, restrict_mask);
if (restrict_mask & RES_LIMITED) {
sys_limitrejected++;
if ( !(restrict_mask & RES_KOD)
|| MODE_BROADCAST == hismode
|| MODE_SERVER == hismode) {
if (MODE_SERVER == hismode)
DPRINTF(1, ("Possibly self-induced rate limiting of MODE_SERVER from %s\n",
stoa(&rbufp->recv_srcadr)));
return;
}
if (hismode == MODE_CLIENT)
fast_xmit(rbufp, MODE_SERVER, skeyid,
restrict_mask);
else
fast_xmit(rbufp, MODE_ACTIVE, skeyid,
restrict_mask);
return;
}
restrict_mask &= ~RES_KOD;
peer = findpeer(rbufp, hismode, &retcode);
dstadr_sin = &rbufp->dstadr->sin;
NTOHL_FP(&pkt->org, &p_org);
NTOHL_FP(&pkt->rec, &p_rec);
NTOHL_FP(&pkt->xmt, &p_xmt);
hm_str = modetoa(hismode);
am_str = amtoa(retcode);
crypto_nak_test = valid_NAK(peer, rbufp, hismode);
if (crypto_nak_test == INVALIDNAK) {
report_event(PEVNT_AUTH, peer, "Invalid_NAK");
if (0 != peer) {
peer->badNAK++;
}
msyslog(LOG_ERR, "Invalid-NAK error at %ld %s<-%s",
current_time, stoa(dstadr_sin), stoa(&rbufp->recv_srcadr));
return;
}
if (has_mac == 0) {
restrict_mask &= ~RES_MSSNTP;
is_authentic = AUTH_NONE;
DPRINTF(2, ("receive: at %ld %s<-%s mode %d/%s:%s len %d org %#010x.%08x xmt %#010x.%08x NOMAC\n",
current_time, stoa(dstadr_sin),
stoa(&rbufp->recv_srcadr), hismode, hm_str, am_str,
authlen,
ntohl(pkt->org.l_ui), ntohl(pkt->org.l_uf),
ntohl(pkt->xmt.l_ui), ntohl(pkt->xmt.l_uf)));
} else if (crypto_nak_test == VALIDNAK) {
restrict_mask &= ~RES_MSSNTP;
is_authentic = AUTH_CRYPTO;
DPRINTF(2, ("receive: at %ld %s<-%s mode %d/%s:%s keyid %08x len %d auth %d org %#010x.%08x xmt %#010x.%08x MAC4\n",
current_time, stoa(dstadr_sin),
stoa(&rbufp->recv_srcadr), hismode, hm_str, am_str,
skeyid, authlen + has_mac, is_authentic,
ntohl(pkt->org.l_ui), ntohl(pkt->org.l_uf),
ntohl(pkt->xmt.l_ui), ntohl(pkt->xmt.l_uf)));
#ifdef HAVE_NTP_SIGND
} else if ( has_mac == MAX_MD5_LEN
&& (restrict_mask & RES_MSSNTP)
&& (retcode == AM_FXMIT || retcode == AM_NEWPASS)
&& (memcmp(zero_key, (char *)pkt + authlen + 4,
MAX_MD5_LEN - 4) == 0)) {
is_authentic = AUTH_NONE;
#endif
} else {
restrict_mask &= ~RES_MSSNTP;
#ifdef AUTOKEY
if (crypto_flags && skeyid > NTP_MAXKEY) {
if (has_mac < (int)MAX_MD5_LEN) {
sys_badauth++;
return;
}
if (hismode == MODE_BROADCAST) {
if ( crypto_flags
&& rbufp->dstadr ==
ANY_INTERFACE_CHOOSE(&rbufp->recv_srcadr)) {
sys_restricted++;
return;
}
pkeyid = 0;
if (!SOCK_UNSPEC(&rbufp->dstadr->bcast))
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;
}
if (authlen > (int)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 = AUTH_ERROR;
else
is_authentic = AUTH_OK;
#ifdef AUTOKEY
if (crypto_flags && skeyid > NTP_MAXKEY)
authtrust(skeyid, 0);
#endif
DPRINTF(2, ("receive: at %ld %s<-%s mode %d/%s:%s keyid %08x len %d auth %d org %#010x.%08x xmt %#010x.%08x\n",
current_time, stoa(dstadr_sin),
stoa(&rbufp->recv_srcadr), hismode, hm_str, am_str,
skeyid, authlen + has_mac, is_authentic,
ntohl(pkt->org.l_ui), ntohl(pkt->org.l_uf),
ntohl(pkt->xmt.l_ui), ntohl(pkt->xmt.l_uf)));
}
switch (retcode) {
case AM_FXMIT:
if (!(rbufp->dstadr->flags & INT_MCASTOPEN)) {
if (AUTH(restrict_mask & RES_DONTTRUST,
is_authentic)) {
fast_xmit(rbufp, MODE_SERVER, skeyid,
restrict_mask);
} else if (is_authentic == AUTH_ERROR) {
fast_xmit(rbufp, MODE_SERVER, 0,
restrict_mask);
sys_badauth++;
} else {
sys_restricted++;
}
return;
}
if (!sys_manycastserver) {
sys_restricted++;
return;
}
#ifdef AUTOKEY
if (group_test(groupname, NULL)) {
sys_declined++;
return;
}
#endif
if ( sys_leap == LEAP_NOTINSYNC
|| sys_stratum >= hisstratum
|| (!sys_cohort && sys_stratum == hisstratum + 1)
|| rbufp->dstadr->addr_refid == pkt->refid) {
sys_declined++;
return;
}
if (AUTH(restrict_mask & RES_DONTTRUST, is_authentic))
fast_xmit(rbufp, MODE_SERVER, skeyid,
restrict_mask);
return;
case AM_MANYCAST:
#ifdef AUTOKEY
if (group_test(groupname, NULL)) {
sys_declined++;
return;
}
#endif
if ((peer2 = findmanycastpeer(rbufp)) == NULL) {
sys_restricted++;
return;
}
if (!AUTH( (!(peer2->cast_flags & MDF_POOL)
&& sys_authenticate)
|| (restrict_mask & (RES_NOPEER |
RES_DONTTRUST)), is_authentic)) {
sys_restricted++;
return;
}
if ( hisleap == LEAP_NOTINSYNC
|| hisstratum < sys_floor
|| hisstratum >= sys_ceiling) {
sys_declined++;
return;
}
peer = newpeer(&rbufp->recv_srcadr, NULL, rbufp->dstadr,
MODE_CLIENT, hisversion, peer2->minpoll,
peer2->maxpoll, FLAG_PREEMPT |
(FLAG_IBURST & peer2->flags), MDF_UCAST |
MDF_UCLNT, 0, skeyid, sys_ident);
if (NULL == peer) {
sys_declined++;
return;
}
if (peer2->cast_flags & MDF_POOL)
peer2->nextdate = current_time + 1;
return;
case AM_NEWBCL:
#ifdef AUTOKEY
if (group_test(groupname, sys_ident)) {
sys_declined++;
return;
}
#endif
if (sys_bclient == 0) {
sys_restricted++;
return;
}
if (!AUTH(sys_authenticate | (restrict_mask &
(RES_NOPEER | RES_DONTTRUST)), is_authentic)) {
sys_restricted++;
return;
}
if ( hisleap == LEAP_NOTINSYNC
|| hisstratum < sys_floor
|| hisstratum >= sys_ceiling) {
sys_declined++;
return;
}
#ifdef AUTOKEY
if ( crypto_flags && skeyid > NTP_MAXKEY
&& (opcode & 0xffff0000) != (CRYPTO_ASSOC | CRYPTO_RESP)) {
sys_declined++;
return;
}
#endif
if (!(INT_MCASTOPEN & rbufp->dstadr->flags))
match_ep = rbufp->dstadr;
else
match_ep = NULL;
if (sys_bdelay > 0.0) {
#ifdef AUTOKEY
if (crypto_flags && skeyid > NTP_MAXKEY) {
sys_restricted++;
return;
}
#endif
peer = newpeer(&rbufp->recv_srcadr, NULL,
match_ep, MODE_BCLIENT, hisversion,
pkt->ppoll, pkt->ppoll, FLAG_PREEMPT,
MDF_BCLNT, 0, skeyid, sys_ident);
if (NULL == peer) {
sys_restricted++;
return;
} else {
peer->delay = sys_bdelay;
peer->bxmt = p_xmt;
}
break;
}
peer = newpeer(&rbufp->recv_srcadr, NULL, match_ep,
MODE_CLIENT, hisversion, pkt->ppoll, pkt->ppoll,
FLAG_BC_VOL | FLAG_IBURST | FLAG_PREEMPT, MDF_BCLNT,
0, skeyid, sys_ident);
if (NULL == peer) {
sys_restricted++;
return;
}
peer->bxmt = p_xmt;
#ifdef AUTOKEY
if (skeyid > NTP_MAXKEY)
crypto_recv(peer, rbufp);
#endif
return;
case AM_NEWPASS:
#ifdef AUTOKEY
if (group_test(groupname, sys_ident)) {
sys_declined++;
return;
}
#endif
if (!AUTH(sys_authenticate | (restrict_mask &
(RES_NOPEER | RES_DONTTRUST)), is_authentic)) {
if (AUTH(restrict_mask & RES_DONTTRUST,
is_authentic)) {
fast_xmit(rbufp, MODE_PASSIVE, skeyid,
restrict_mask);
return;
}
if (is_authentic == AUTH_ERROR) {
fast_xmit(rbufp, MODE_ACTIVE, 0,
restrict_mask);
sys_restricted++;
return;
}
DPRINTF(2, ("receive: at %ld refusing to mobilize passive association"
" with unknown peer %s mode %d/%s:%s keyid %08x len %d auth %d\n",
current_time, stoa(&rbufp->recv_srcadr),
hismode, hm_str, am_str, skeyid,
(authlen + has_mac), is_authentic));
sys_declined++;
return;
}
if ( hisleap != LEAP_NOTINSYNC
&& (hisstratum < sys_floor || hisstratum >= sys_ceiling)) {
sys_declined++;
return;
}
if ((peer = newpeer(&rbufp->recv_srcadr, NULL,
rbufp->dstadr, MODE_PASSIVE, hisversion, pkt->ppoll,
NTP_MAXDPOLL, 0, MDF_UCAST, 0, skeyid,
sys_ident)) == NULL) {
sys_declined++;
return;
}
break;
case AM_PROCPKT:
#ifdef AUTOKEY
if (group_test(groupname, peer->ident)) {
sys_declined++;
return;
}
#endif
if (MODE_BROADCAST == hismode) {
int bail = 0;
l_fp tdiff;
u_long deadband;
DPRINTF(2, ("receive: PROCPKT/BROADCAST: prev pkt %ld seconds ago, ppoll: %d, %d secs\n",
(current_time - peer->timelastrec),
peer->ppoll, (1 << peer->ppoll)
));
if (pkt->ppoll != peer->ppoll) {
msyslog(LOG_INFO, "receive: broadcast poll from %s changed from %ud to %ud",
stoa(&rbufp->recv_srcadr),
peer->ppoll, pkt->ppoll);
}
if (pkt->ppoll < peer->minpoll ||
pkt->ppoll > peer->maxpoll ) {
msyslog(LOG_INFO, "receive: broadcast poll of %ud from %s is out-of-range (%d to %d)!",
pkt->ppoll, stoa(&rbufp->recv_srcadr),
peer->minpoll, peer->maxpoll);
++bail;
}
deadband = (1u << pkt->ppoll);
if (FLAG_BC_VOL & peer->flags)
deadband -= 3;
if ((current_time - peer->timereceived) < deadband) {
msyslog(LOG_INFO, "receive: broadcast packet from %s arrived after %lu, not %lu seconds!",
stoa(&rbufp->recv_srcadr),
(current_time - peer->timereceived),
deadband);
++bail;
}
if (sys_bcpollbstep) {
deadband = (1u << pkt->ppoll)
* sys_bcpollbstep + 2;
} else {
deadband = 0;
}
if (L_ISZERO(&peer->bxmt)) {
tdiff.l_ui = tdiff.l_uf = 0;
} else {
tdiff = p_xmt;
L_SUB(&tdiff, &peer->bxmt);
}
if (tdiff.l_i < 0 &&
(current_time - peer->timereceived) < deadband)
{
msyslog(LOG_INFO, "receive: broadcast packet from %s contains non-monotonic timestamp: %#010x.%08x -> %#010x.%08x",
stoa(&rbufp->recv_srcadr),
peer->bxmt.l_ui, peer->bxmt.l_uf,
p_xmt.l_ui, p_xmt.l_uf
);
++bail;
}
if (bail) {
peer->timelastrec = current_time;
sys_declined++;
return;
}
}
break;
case AM_ERR:
sys_declined++;
return;
default:
sys_declined++;
return;
}
#ifdef AUTOKEY
if ( is_authentic != AUTH_CRYPTO
&& ( ((peer->flags & FLAG_SKEY) && skeyid <= NTP_MAXKEY)
|| (!(peer->flags & FLAG_SKEY) && skeyid > NTP_MAXKEY))) {
sys_badauth++;
return;
}
#endif
peer->received++;
peer->flash &= ~PKT_TEST_MASK;
if (peer->flags & FLAG_XBOGUS) {
peer->flags &= ~FLAG_XBOGUS;
peer->flash |= TEST3;
}
if (L_ISZERO(&p_xmt)) {
peer->flash |= TEST3;
if (STRATUM_UNSPEC == hisstratum) {
peer->bogusorg++;
msyslog(LOG_INFO,
"receive: Unexpected zero transmit timestamp in KoD from %s",
ntoa(&peer->srcadr));
return;
}
} else if (L_ISEQU(&peer->xmt, &p_xmt)) {
peer->flash |= TEST1;
peer->oldpkt++;
return;
} else if (hismode == MODE_BROADCAST) {
if ( 0 == hisstratum
|| STRATUM_UNSPEC <= hisstratum) {
msyslog(LOG_INFO,
"receive: Unexpected stratum (%d) in broadcast from %s",
hisstratum, ntoa(&peer->srcadr));
return;
}
} else if (STRATUM_UNSPEC == hisstratum) {
DEBUG_INSIST(!L_ISZERO(&p_xmt));
if ( L_ISZERO(&p_org)
|| L_ISZERO(&p_rec)) {
peer->bogusorg++;
msyslog(LOG_INFO,
"receive: KoD packet from %s has a zero org or rec timestamp. Ignoring.",
ntoa(&peer->srcadr));
return;
}
if ( !L_ISEQU(&p_xmt, &p_org)
|| !L_ISEQU(&p_xmt, &p_rec)) {
peer->bogusorg++;
msyslog(LOG_INFO,
"receive: KoD packet from %s has inconsistent xmt/org/rec timestamps. Ignoring.",
ntoa(&peer->srcadr));
return;
}
if (peer->flip == 0 && !L_ISEQU(&p_org, &peer->aorg)) {
peer->bogusorg++;
msyslog(LOG_INFO,
"receive: flip 0 KoD origin timestamp %#010x.%08x from %s does not match %#010x.%08x - ignoring.",
p_org.l_ui, p_org.l_uf,
ntoa(&peer->srcadr),
peer->aorg.l_ui, peer->aorg.l_uf);
return;
} else if (peer->flip == 1 && !L_ISEQU(&p_org, &peer->borg)) {
peer->bogusorg++;
msyslog(LOG_INFO,
"receive: flip 1 KoD origin timestamp %#010x.%08x from %s does not match interleave %#010x.%08x - ignoring.",
p_org.l_ui, p_org.l_uf,
ntoa(&peer->srcadr),
peer->borg.l_ui, peer->borg.l_uf);
return;
}
} else if (peer->flip == 0) {
INSIST(0 != hisstratum);
INSIST(STRATUM_UNSPEC != hisstratum);
if (0) {
} else if (L_ISZERO(&p_org)) {
const char *action;
#ifdef BUG3361
msyslog(LOG_INFO,
"receive: BUG 3361: Clearing peer->aorg ");
L_CLR(&peer->aorg);
#endif
switch (hismode) {
case UCHAR_MAX:
action = "Allow";
break;
case MODE_UNSPEC:
case MODE_ACTIVE:
case MODE_PASSIVE:
case MODE_CLIENT:
case MODE_SERVER:
case MODE_BROADCAST:
action = "Drop";
peer->bogusorg++;
peer->flash |= TEST2;
break;
default:
action = "";
INSIST(!"receive(): impossible hismode");
break;
}
msyslog(LOG_INFO,
"receive: %s 0 origin timestamp from %s@%s xmt %#010x.%08x",
action, hm_str, ntoa(&peer->srcadr),
ntohl(pkt->xmt.l_ui), ntohl(pkt->xmt.l_uf));
} else if (!L_ISEQU(&p_org, &peer->aorg)) {
peer->bogusorg++;
peer->flash |= TEST2;
msyslog(LOG_INFO,
"receive: Unexpected origin timestamp %#010x.%08x does not match aorg %#010x.%08x from %s@%s xmt %#010x.%08x",
ntohl(pkt->org.l_ui), ntohl(pkt->org.l_uf),
peer->aorg.l_ui, peer->aorg.l_uf,
hm_str, ntoa(&peer->srcadr),
ntohl(pkt->xmt.l_ui), ntohl(pkt->xmt.l_uf));
if ( !L_ISZERO(&peer->dst)
&& L_ISEQU(&p_org, &peer->dst)) {
if (dynamic_interleave) {
peer->flip = 1;
report_event(PEVNT_XLEAVE, peer, NULL);
} else {
msyslog(LOG_INFO,
"receive: Dynamic interleave from %s@%s denied",
hm_str, ntoa(&peer->srcadr));
}
}
} else {
L_CLR(&peer->aorg);
}
} else if ( L_ISZERO(&p_org)
|| L_ISZERO(&p_rec)
|| L_ISZERO(&peer->dst)) {
peer->flash |= TEST3;
} else if ( !L_ISZERO(&peer->dst)
&& !L_ISEQU(&p_org, &peer->dst)) {
peer->bogusorg++;
peer->flags |= FLAG_XBOGUS;
peer->flash |= TEST2;
return;
}
if (crypto_nak_test == VALIDNAK) {
report_event(PEVNT_AUTH, peer, "crypto_NAK");
peer->flash |= TEST5;
peer->badauth++;
if (peer->flags & FLAG_PREEMPT) {
if (unpeer_crypto_nak_early) {
unpeer(peer);
}
return;
}
#ifdef AUTOKEY
if (peer->crypto) {
peer_clear(peer, "AUTH");
}
#endif
return;
} else if (!AUTH(peer->keyid || has_mac ||
(restrict_mask & RES_DONTTRUST), is_authentic)) {
if (peer->flash & PKT_TEST_MASK) {
msyslog(LOG_INFO,
"receive: Bad auth in packet with bad timestamps from %s denied - spoof?",
ntoa(&peer->srcadr));
return;
}
report_event(PEVNT_AUTH, peer, "digest");
peer->flash |= TEST5;
peer->badauth++;
if ( has_mac
&& ( hismode == MODE_ACTIVE
|| hismode == MODE_PASSIVE))
fast_xmit(rbufp, MODE_ACTIVE, 0, restrict_mask);
if (peer->flags & FLAG_PREEMPT) {
if (unpeer_digest_early) {
unpeer(peer);
}
}
#ifdef AUTOKEY
else if (peer_clear_digest_early && peer->crypto) {
peer_clear(peer, "AUTH");
}
#endif
return;
}
if (hismode == MODE_BROADCAST) {
if ( is_authentic == AUTH_OK
|| is_authentic == AUTH_NONE) {
if (!L_ISZERO(&p_org)) {
if (!(peer->flags & FLAG_XB)) {
msyslog(LOG_INFO,
"receive: Broadcast server at %s is in interleave mode",
ntoa(&peer->srcadr));
peer->flags |= FLAG_XB;
peer->aorg = p_xmt;
peer->borg = rbufp->recv_time;
report_event(PEVNT_XLEAVE, peer, NULL);
return;
}
} else if (peer->flags & FLAG_XB) {
msyslog(LOG_INFO,
"receive: Broadcast server at %s is no longer in interleave mode",
ntoa(&peer->srcadr));
peer->flags &= ~FLAG_XB;
}
} else {
msyslog(LOG_INFO,
"receive: Bad broadcast auth (%d) from %s",
is_authentic, ntoa(&peer->srcadr));
}
peer->bxmt = p_xmt;
}
if (peer->flip == 0) {
if (hismode != MODE_BROADCAST)
peer->rec = p_xmt;
peer->dst = rbufp->recv_time;
}
peer->xmt = p_xmt;
kissCode = kiss_code_check(hisleap, hisstratum, hismode, pkt->refid);
peer->ppoll = max(peer->minpoll, pkt->ppoll);
if (kissCode == RATEKISS) {
peer->selbroken++;
report_event(PEVNT_RATE, peer, NULL);
if (pkt->ppoll > peer->minpoll)
peer->minpoll = peer->ppoll;
peer->burst = peer->retry = 0;
peer->throttle = (NTP_SHIFT + 1) * (1 << peer->minpoll);
poll_update(peer, pkt->ppoll);
return;
}
if (kissCode != NOKISS) {
peer->selbroken++;
return;
}
switch (hismode) {
case MODE_SERVER:
case MODE_BROADCAST:
case MODE_ACTIVE:
case MODE_PASSIVE:
if ( is_authentic == AUTH_OK
&& skeyid
&& skeyid <= NTP_MAXKEY
&& !authistrustedip(skeyid, &peer->srcadr)) {
report_event(PEVNT_AUTH, peer, "authIP");
peer->badauth++;
return;
}
break;
case MODE_CLIENT:
#if 0
case MODE_CONTROL:
#endif
case MODE_PRIVATE:
case MODE_BCLIENT:
break;
case MODE_UNSPEC:
default:
msyslog(LOG_INFO,
"receive: Unexpected mode (%d) in packet from %s",
hismode, ntoa(&peer->srcadr));
break;
}
peer->timereceived = current_time;
peer->timelastrec = current_time;
if (is_authentic == AUTH_OK)
peer->flags |= FLAG_AUTHENTIC;
else
peer->flags &= ~FLAG_AUTHENTIC;
#ifdef AUTOKEY
if (peer->flags & FLAG_SKEY) {
ap = (struct autokey *)peer->recval.ptr;
if (ap != NULL) {
if (ap->seq > 0)
ap->seq--;
}
peer->flash |= TEST8;
rval = crypto_recv(peer, rbufp);
if (rval == XEVNT_OK) {
peer->unreach = 0;
} else {
if (rval == XEVNT_ERR) {
report_event(PEVNT_RESTART, peer,
"crypto error");
peer_clear(peer, "CRYP");
peer->flash |= TEST9;
if (peer->flags & FLAG_PREEMPT) {
if (unpeer_crypto_early) {
unpeer(peer);
}
}
}
return;
}
if (hismode == MODE_SERVER) {
if (skeyid == peer->keyid)
peer->flash &= ~TEST8;
} else if (!(peer->flash & TEST8)) {
peer->pkeyid = skeyid;
} else if (ap != NULL) {
int i;
for (i = 0; ; i++) {
if ( tkeyid == peer->pkeyid
|| tkeyid == ap->key) {
peer->flash &= ~TEST8;
peer->pkeyid = skeyid;
ap->seq -= i;
break;
}
if (i > ap->seq) {
peer->crypto &=
~CRYPTO_FLAG_AUTO;
break;
}
tkeyid = session_key(
&rbufp->recv_srcadr, dstadr_sin,
tkeyid, pkeyid, 0);
}
if (peer->flash & TEST8)
report_event(PEVNT_AUTH, peer, "keylist");
}
if (!(peer->crypto & CRYPTO_FLAG_PROV))
peer->flash |= TEST8;
if (current_time > peer->refresh) {
report_event(PEVNT_RESTART, peer,
"crypto refresh");
peer_clear(peer, "TIME");
return;
}
}
#endif
process_packet(peer, pkt, rbufp->recv_length);
if (peer->flip != 0) {
peer->rec = p_rec;
peer->dst = rbufp->recv_time;
if (peer->nextdate - current_time < (1U << min(peer->ppoll,
peer->hpoll)) / 2)
peer->nextdate++;
else
peer->nextdate--;
}
}
void
process_packet(
register struct peer *peer,
register struct pkt *pkt,
u_int len
)
{
double t34, t21;
double p_offset, p_del, p_disp;
l_fp p_rec, p_xmt, p_org, p_reftime, ci;
u_char pmode, pleap, pversion, pstratum;
char statstr[NTP_MAXSTRLEN];
#ifdef ASSYM
int itemp;
double etemp, ftemp, td;
#endif
#if 0
sys_processed++;
peer->processed++;
#endif
p_del = FPTOD(NTOHS_FP(pkt->rootdelay));
#ifndef __clang_analyzer__
p_offset = 0;
#endif
p_disp = FPTOD(NTOHS_FP(pkt->rootdisp));
NTOHL_FP(&pkt->reftime, &p_reftime);
NTOHL_FP(&pkt->org, &p_org);
NTOHL_FP(&pkt->rec, &p_rec);
NTOHL_FP(&pkt->xmt, &p_xmt);
pmode = PKT_MODE(pkt->li_vn_mode);
pleap = PKT_LEAP(pkt->li_vn_mode);
pversion = PKT_VERSION(pkt->li_vn_mode);
pstratum = PKT_TO_STRATUM(pkt->stratum);
if ( pleap == LEAP_NOTINSYNC
|| pstratum < sys_floor || pstratum >= sys_ceiling)
peer->flash |= TEST6;
if (p_del / 2 + p_disp >= MAXDISPERSE)
peer->flash |= TEST7;
if (peer->flash & PKT_TEST_MASK) {
peer->seldisptoolarge++;
DPRINTF(1, ("packet: flash header %04x\n",
peer->flash));
return;
}
#if 1
sys_processed++;
peer->processed++;
#endif
record_raw_stats(&peer->srcadr, peer->dstadr ?
&peer->dstadr->sin : NULL,
&p_org, &p_rec, &p_xmt, &peer->dst,
pleap, pversion, pmode, pstratum, pkt->ppoll, pkt->precision,
p_del, p_disp, pkt->refid);
peer->leap = pleap;
peer->stratum = min(pstratum, STRATUM_UNSPEC);
peer->pmode = pmode;
peer->precision = pkt->precision;
peer->rootdelay = p_del;
peer->rootdisp = p_disp;
peer->refid = pkt->refid;
peer->reftime = p_reftime;
if (peer->retry > 0) {
peer->retry = 0;
if (peer->reach)
peer->burst = min(1 << (peer->hpoll -
peer->minpoll), NTP_SHIFT) - 1;
else
peer->burst = NTP_IBURST - 1;
if (peer->burst > 0)
peer->nextdate = current_time;
}
poll_update(peer, peer->hpoll);
if (!peer->reach) {
report_event(PEVNT_REACH, peer, NULL);
peer->timereachable = current_time;
}
peer->reach |= 1;
if (peer->flip != 0) {
ci = p_xmt;
L_SUB(&ci, &peer->dst);
LFPTOD(&ci, t34);
ci = p_rec;
if (peer->flip > 0)
L_SUB(&ci, &peer->borg);
else
L_SUB(&ci, &peer->aorg);
LFPTOD(&ci, t21);
p_del = t21 - t34;
p_offset = (t21 + t34) / 2.;
if (p_del < 0 || p_del > 1.) {
snprintf(statstr, sizeof(statstr),
"t21 %.6f t34 %.6f", t21, t34);
report_event(PEVNT_XERR, peer, statstr);
return;
}
} else if (peer->pmode == MODE_BROADCAST) {
if (peer->flags & FLAG_XB) {
ci = p_org;
L_SUB(&ci, &peer->aorg);
LFPTOD(&ci, t34);
ci = p_org;
L_SUB(&ci, &peer->borg);
LFPTOD(&ci, t21);
peer->aorg = p_xmt;
peer->borg = peer->dst;
if (t34 < 0 || t34 > 1.) {
if (FLAG_BC_VOL & peer->flags)
goto bcc_init_volley_fail;
snprintf(statstr, sizeof(statstr),
"offset %.6f delay %.6f", t21, t34);
report_event(PEVNT_XERR, peer, statstr);
return;
}
p_offset = t21;
peer->xleave = t34;
} else {
ci = p_xmt;
L_SUB(&ci, &peer->dst);
LFPTOD(&ci, t34);
p_offset = t34;
}
if (FLAG_BC_VOL & peer->flags) {
peer->flags &= ~FLAG_BC_VOL;
peer->delay = fabs(peer->offset - p_offset) * 2;
DPRINTF(2, ("broadcast volley: initial delay=%.6f\n",
peer->delay));
if (peer->delay > fabs(sys_bdelay)) {
bcc_init_volley_fail:
DPRINTF(2, ("%s", "broadcast volley: initial delay exceeds limit\n"));
unpeer(peer);
return;
}
}
peer->nextdate = current_time + (1u << peer->ppoll) - 2u;
p_del = peer->delay;
p_offset += p_del / 2;
} else {
ci = p_xmt;
L_SUB(&ci, &peer->dst);
LFPTOD(&ci, t34);
ci = p_rec;
L_SUB(&ci, &p_org);
LFPTOD(&ci, t21);
p_del = fabs(t21 - t34);
p_offset = (t21 + t34) / 2.;
}
p_del = max(p_del, LOGTOD(sys_precision));
p_disp = LOGTOD(sys_precision) + LOGTOD(peer->precision) +
clock_phi * p_del;
#if ASSYM
if (peer->t21_last > 0 && peer->t34_bytes > 0) {
itemp = peer->t21_bytes - peer->t21_last;
if (itemp > 25) {
etemp = t21 - peer->t21;
if (fabs(etemp) > 1e-6) {
ftemp = itemp / etemp;
if (ftemp > 1000.)
peer->r21 = ftemp;
}
}
itemp = len - peer->t34_bytes;
if (itemp > 25) {
etemp = -t34 - peer->t34;
if (fabs(etemp) > 1e-6) {
ftemp = itemp / etemp;
if (ftemp > 1000.)
peer->r34 = ftemp;
}
}
}
peer->t21 = t21;
peer->t21_last = peer->t21_bytes;
peer->t34 = -t34;
peer->t34_bytes = len;
DPRINTF(2, ("packet: t21 %.9lf %d t34 %.9lf %d\n", peer->t21,
peer->t21_bytes, peer->t34, peer->t34_bytes));
if (peer->r21 > 0 && peer->r34 > 0 && p_del > 0) {
if (peer->pmode != MODE_BROADCAST)
td = (peer->r34 / (peer->r21 + peer->r34) -
.5) * p_del;
else
td = 0;
t21 -= td;
t34 -= td;
DPRINTF(2, ("packet: del %.6lf r21 %.1lf r34 %.1lf %.6lf\n",
p_del, peer->r21 / 1e3, peer->r34 / 1e3,
td));
}
#endif
clock_filter(peer, p_offset + peer->bias, p_del, p_disp);
if ( (FLAG_BC_VOL & peer->flags)
&& MODE_CLIENT == peer->hmode
&& !(TEST11 & peer_unfit(peer))) {
#ifdef AUTOKEY
if (peer->flags & FLAG_SKEY) {
if (!(~peer->crypto & CRYPTO_FLAG_ALL))
peer->hmode = MODE_BCLIENT;
} else {
peer->hmode = MODE_BCLIENT;
}
#else
peer->hmode = MODE_BCLIENT;
#endif
}
}
static void
clock_update(
struct peer *peer
)
{
double dtemp;
l_fp now;
#ifdef HAVE_LIBSCF_H
char *fmri;
#endif
sys_peer = peer;
sys_epoch = peer->epoch;
if (sys_poll < peer->minpoll)
sys_poll = peer->minpoll;
if (sys_poll > peer->maxpoll)
sys_poll = peer->maxpoll;
poll_update(peer, sys_poll);
sys_stratum = min(peer->stratum + 1, STRATUM_UNSPEC);
if ( peer->stratum == STRATUM_REFCLOCK
|| peer->stratum == STRATUM_UNSPEC)
sys_refid = peer->refid;
else
sys_refid = addr2refid(&peer->srcadr);
dtemp = peer->rootdisp
+ peer->disp
+ sys_jitter
+ clock_phi * (current_time - peer->update)
+ fabs(sys_offset);
if (dtemp > sys_mindisp)
sys_rootdisp = dtemp;
else
sys_rootdisp = sys_mindisp;
sys_rootdelay = peer->delay + peer->rootdelay;
sys_reftime = peer->dst;
DPRINTF(1, ("clock_update: at %lu sample %lu associd %d\n",
current_time, peer->epoch, peer->associd));
switch (local_clock(peer, sys_offset)) {
case -1:
#ifdef HAVE_LIBSCF_H
if ((fmri = getenv("SMF_FMRI")) != NULL) {
if (smf_maintain_instance(fmri, 0) < 0) {
printf("smf_maintain_instance: %s\n",
scf_strerror(scf_error()));
exit(1);
}
for (;;)
pause();
}
#endif
exit (-1);
case 2:
clear_all();
set_sys_leap(LEAP_NOTINSYNC);
sys_stratum = STRATUM_UNSPEC;
memcpy(&sys_refid, "STEP", 4);
sys_rootdelay = 0;
sys_rootdisp = 0;
L_CLR(&sys_reftime);
sys_jitter = LOGTOD(sys_precision);
leapsec_reset_frame();
break;
case 1:
if (sys_leap == LEAP_NOTINSYNC) {
set_sys_leap(LEAP_NOWARNING);
#ifdef AUTOKEY
if (crypto_flags)
crypto_update();
#endif
#ifdef HAVE_WORKING_FORK
if (waitsync_fd_to_close != -1) {
close(waitsync_fd_to_close);
waitsync_fd_to_close = -1;
DPRINTF(1, ("notified parent --wait-sync is done\n"));
}
#endif
}
if (leapsec == LSPROX_NOWARN) {
if ( leap_vote_ins > leap_vote_del
&& leap_vote_ins > sys_survivors / 2) {
get_systime(&now);
leapsec_add_dyn(TRUE, now.l_ui, NULL);
}
if ( leap_vote_del > leap_vote_ins
&& leap_vote_del > sys_survivors / 2) {
get_systime(&now);
leapsec_add_dyn(FALSE, now.l_ui, NULL);
}
}
break;
default:
break;
}
}
void
poll_update(
struct peer *peer,
u_char mpoll
)
{
u_long next, utemp;
u_char hpoll;
hpoll = max(min(peer->maxpoll, mpoll), peer->minpoll);
#ifdef AUTOKEY
if ((peer->flags & FLAG_SKEY) && hpoll != peer->hpoll)
key_expire(peer);
#endif
peer->hpoll = hpoll;
utemp = current_time + max(peer->throttle - (NTP_SHIFT - 1) *
(1 << peer->minpoll), ntp_minpkt);
if (peer->burst > 0) {
if (peer->nextdate > current_time)
return;
#ifdef REFCLOCK
else if (peer->flags & FLAG_REFCLOCK)
peer->nextdate = current_time + RESP_DELAY;
#endif
else {
peer->nextdate = utemp;
}
#ifdef AUTOKEY
} else if (peer->cmmd != NULL) {
if (peer->nextdate > current_time) {
if (peer->nextdate + ntp_minpkt != utemp)
peer->nextdate = utemp;
} else {
peer->nextdate = utemp;
}
#endif
} else {
if (peer->retry > 0)
hpoll = peer->minpoll;
else if (!(peer->reach))
hpoll = peer->hpoll;
else
hpoll = min(peer->ppoll, peer->hpoll);
#ifdef REFCLOCK
if (peer->flags & FLAG_REFCLOCK)
next = 1 << hpoll;
else
#endif
next = ((0x1000UL | (ntp_random() & 0x0ff)) <<
hpoll) >> 12;
next += peer->outdate;
if (next > utemp)
peer->nextdate = next;
else
peer->nextdate = utemp;
if (peer->throttle > (1 << peer->minpoll))
peer->nextdate += ntp_minpkt;
}
DPRINTF(2, ("poll_update: at %lu %s poll %d burst %d retry %d head %d early %lu next %lu\n",
current_time, ntoa(&peer->srcadr), peer->hpoll,
peer->burst, peer->retry, peer->throttle,
utemp - current_time, peer->nextdate -
current_time));
}
void
peer_clear(
struct peer *peer,
const char *ident
)
{
u_char u;
l_fp bxmt = peer->bxmt;
#ifdef AUTOKEY
key_expire(peer);
if (peer->iffval != NULL)
BN_free(peer->iffval);
value_free(&peer->cookval);
value_free(&peer->recval);
value_free(&peer->encrypt);
value_free(&peer->sndval);
if (peer->cmmd != NULL)
free(peer->cmmd);
if (peer->subject != NULL)
free(peer->subject);
if (peer->issuer != NULL)
free(peer->issuer);
#endif
int oldburst = (peer->burst > 0);
memset(CLEAR_TO_ZERO(peer), 0, LEN_CLEAR_TO_ZERO(peer));
peer->ppoll = peer->maxpoll;
peer->hpoll = peer->minpoll;
peer->disp = MAXDISPERSE;
peer->flash = peer_unfit(peer);
peer->jitter = LOGTOD(sys_precision);
if (oldburst) {
peer->burst = NSTAGE;
}
if (peer->flags & FLAG_XLEAVE)
peer->flip = 1;
for (u = 0; u < NTP_SHIFT; u++) {
peer->filter_order[u] = u;
peer->filter_disp[u] = MAXDISPERSE;
}
#ifdef REFCLOCK
if (!(peer->flags & FLAG_REFCLOCK)) {
#endif
peer->leap = LEAP_NOTINSYNC;
peer->stratum = STRATUM_UNSPEC;
memcpy(&peer->refid, ident, 4);
#ifdef REFCLOCK
}
#endif
if (peer->hmode == MODE_BCLIENT)
peer->bxmt = bxmt;
peer->nextdate = peer->update = peer->outdate = current_time;
if (initializing) {
peer->nextdate += peer_associations;
} else if (MODE_PASSIVE == peer->hmode) {
peer->nextdate += ntp_minpkt;
} else {
peer->nextdate += ntp_random() % peer->minpoll;
}
#ifdef AUTOKEY
peer->refresh = current_time + (1 << NTP_REFRESH);
#endif
DPRINTF(1, ("peer_clear: at %ld next %ld associd %d refid %s\n",
current_time, peer->nextdate, peer->associd,
ident));
}
void
clock_filter(
struct peer *peer,
double sample_offset,
double sample_delay,
double sample_disp
)
{
double dst[NTP_SHIFT];
int ord[NTP_SHIFT];
int i, j, k, m;
double dtemp, etemp;
char tbuf[80];
if (mode_wakeup) {
if (fabs(sample_offset) > clock_max_fwd) {
step_systime(sample_offset);
msyslog(LOG_NOTICE, "wake time set %+.6f s", sample_offset);
os_trace("wake time set %+.6f s", sample_offset);
clear_all();
} else {
msyslog(LOG_DEBUG, "sample offset %+.6f s @ %s", sample_offset, ntoa(&peer->srcadr));
}
mode_wakeup = FALSE;
wake_timer = 0;
} else {
msyslog(LOG_DEBUG, "sample offset %+.6f s @ %s", sample_offset, ntoa(&peer->srcadr));
}
j = peer->filter_nextpt;
peer->filter_offset[j] = sample_offset;
peer->filter_delay[j] = sample_delay;
peer->filter_disp[j] = sample_disp;
peer->filter_epoch[j] = current_time;
j = (j + 1) % 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;
dst[i] = MAXDISPERSE;
} else if (peer->update - peer->filter_epoch[j] >
(u_long)ULOGTOD(allan_xpt)) {
dst[i] = peer->filter_delay[j] +
peer->filter_disp[j];
} else {
dst[i] = peer->filter_delay[j];
}
ord[i] = j;
j = (j + 1) % NTP_SHIFT;
}
if (freq_cnt == 0) {
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] = (u_char) ord[i];
if ( dst[i] >= MAXDISPERSE
|| (m >= 2 && dst[i] >= sys_maxdist))
continue;
m++;
}
peer->disp = peer->jitter = 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)
peer->jitter += DIFF(peer->filter_offset[j],
peer->filter_offset[k]);
}
if (m == 0) {
clock_select();
return;
}
etemp = fabs(peer->offset - peer->filter_offset[k]);
peer->offset = peer->filter_offset[k];
peer->delay = peer->filter_delay[k];
if (m > 1)
peer->jitter /= m - 1;
peer->jitter = max(SQRT(peer->jitter), LOGTOD(sys_precision));
if ( peer->disp < sys_maxdist
&& peer->filter_disp[k] < sys_maxdist
&& etemp > CLOCK_SGATE * peer->jitter
&& peer->filter_epoch[k] - peer->epoch
< 2. * ULOGTOD(peer->hpoll)) {
snprintf(tbuf, sizeof(tbuf), "%.6f s", etemp);
report_event(PEVNT_POPCORN, peer, tbuf);
return;
}
if (peer->filter_epoch[k] <= peer->epoch) {
DPRINTF(2, ("clock_filter: old sample %lu\n", current_time -
peer->filter_epoch[k]));
return;
}
peer->epoch = peer->filter_epoch[k];
record_peer_stats(&peer->srcadr, ctlpeerstatus(peer),
peer->offset, peer->delay, peer->disp, peer->jitter);
DPRINTF(1, ("clock_filter: n %d off %.6f del %.6f dsp %.6f jit %.6f\n",
m, peer->offset, peer->delay, peer->disp,
peer->jitter));
if (peer->burst == 0 || sys_leap == LEAP_NOTINSYNC)
clock_select();
}
void
clock_select(void)
{
struct peer *peer;
int i, j, k, n;
int nlist, nl2;
int allow;
int speer;
double d, e, f, g;
double high, low;
double speermet;
double orphmet = 2.0 * U_INT32_MAX;
struct endpoint endp;
struct peer *osys_peer;
struct peer *sys_prefer = NULL;
struct peer *typesystem = NULL;
struct peer *typeorphan = NULL;
#ifdef REFCLOCK
struct peer *typeacts = NULL;
struct peer *typelocal = NULL;
struct peer *typepps = NULL;
#endif
static struct endpoint *endpoint = NULL;
static int *indx = NULL;
static peer_select *peers = NULL;
static u_int endpoint_size = 0;
static u_int peers_size = 0;
static u_int indx_size = 0;
size_t octets;
osys_peer = sys_peer;
sys_survivors = 0;
#ifdef LOCKCLOCK
set_sys_leap(LEAP_NOTINSYNC);
sys_stratum = STRATUM_UNSPEC;
memcpy(&sys_refid, "DOWN", 4);
#endif
nlist = 1;
for (peer = peer_list; peer != NULL; peer = peer->p_link)
nlist++;
endpoint_size = ALIGNED_SIZE(nlist * 2 * sizeof(*endpoint));
peers_size = ALIGNED_SIZE(nlist * sizeof(*peers));
indx_size = ALIGNED_SIZE(nlist * 2 * sizeof(*indx));
octets = endpoint_size + peers_size + indx_size;
endpoint = erealloc(endpoint, octets);
peers = INC_ALIGNED_PTR(endpoint, endpoint_size);
indx = INC_ALIGNED_PTR(peers, peers_size);
nlist = nl2 = 0;
for (peer = peer_list; peer != NULL; peer = peer->p_link) {
peer->new_status = CTL_PST_SEL_REJECT;
if (peer_unfit(peer)) {
continue;
}
if (peer->stratum == sys_orphan) {
u_int32 localmet;
u_int32 peermet;
if (peer->dstadr != NULL)
localmet = ntohl(peer->dstadr->addr_refid);
else
localmet = U_INT32_MAX;
peermet = ntohl(addr2refid(&peer->srcadr));
if (peermet < localmet && peermet < orphmet) {
typeorphan = peer;
orphmet = peermet;
}
continue;
}
if (peer->stratum > sys_orphan) {
continue;
}
#ifdef REFCLOCK
if (!(peer->flags & FLAG_PREFER)) {
switch (peer->refclktype) {
case REFCLK_LOCALCLOCK:
if ( current_time > orphwait
&& typelocal == NULL)
typelocal = peer;
continue;
case REFCLK_ACTS:
if ( current_time > orphwait
&& typeacts == NULL)
typeacts = peer;
continue;
}
}
#endif
peer->new_status = CTL_PST_SEL_SANE;
f = root_distance(peer);
peers[nlist].peer = peer;
peers[nlist].error = peer->jitter;
peers[nlist].synch = f;
nlist++;
e = peer->offset;
endpoint[nl2].type = -1;
endpoint[nl2].val = e - f;
nl2++;
endpoint[nl2].type = 1;
endpoint[nl2].val = e + f;
nl2++;
}
for (i = 0; i < nl2; i++)
indx[i] = i;
for (i = 0; i < nl2; i++) {
endp = endpoint[indx[i]];
e = endp.val;
k = i;
for (j = i + 1; j < nl2; j++) {
endp = endpoint[indx[j]];
if (endp.val < e) {
e = endp.val;
k = j;
}
}
if (k != i) {
j = indx[k];
indx[k] = indx[i];
indx[i] = j;
}
}
for (i = 0; i < nl2; i++)
DPRINTF(3, ("select: endpoint %2d %.6f\n",
endpoint[indx[i]].type, endpoint[indx[i]].val));
low = 1e9;
high = -1e9;
for (allow = 0; 2 * allow < nlist; allow++) {
n = 0;
for (i = 0; i < nl2; i++) {
low = endpoint[indx[i]].val;
n -= endpoint[indx[i]].type;
if (n >= nlist - allow)
break;
}
n = 0;
for (j = nl2 - 1; j >= 0; j--) {
high = endpoint[indx[j]].val;
n += endpoint[indx[j]].type;
if (n >= nlist - allow)
break;
}
if (high > low)
break;
}
j = 0;
for (i = 0; i < nlist; i++) {
double h;
peer = peers[i].peer;
h = peers[i].synch;
if (( high <= low
|| peer->offset + h < low
|| peer->offset - h > high
) && !(peer->flags & FLAG_TRUE))
continue;
#ifdef REFCLOCK
if (peer->flags & FLAG_PPS) {
if (typepps == NULL)
typepps = peer;
if (!(peer->flags & FLAG_TSTAMP_PPS))
continue;
}
#endif
if (j != i)
peers[j] = peers[i];
j++;
}
nlist = j;
if (nlist == 0) {
peers[0].error = 0;
peers[0].synch = sys_mindisp;
#ifdef REFCLOCK
if (typeacts != NULL) {
peers[0].peer = typeacts;
nlist = 1;
} else if (typelocal != NULL) {
peers[0].peer = typelocal;
nlist = 1;
} else
#endif
if (typeorphan != NULL) {
peers[0].peer = typeorphan;
nlist = 1;
}
}
for (i = 0; i < nlist; i++) {
peers[i].peer->new_status = CTL_PST_SEL_SELCAND;
DPRINTF(2, ("select: survivor %s %f\n",
stoa(&peers[i].peer->srcadr), peers[i].synch));
}
while (1) {
d = 1e9;
e = -1e9;
g = 0;
k = 0;
for (i = 0; i < nlist; i++) {
if (peers[i].error < d)
d = peers[i].error;
peers[i].seljit = 0;
if (nlist > 1) {
f = 0;
for (j = 0; j < nlist; j++)
f += DIFF(peers[j].peer->offset,
peers[i].peer->offset);
peers[i].seljit = SQRT(f / (nlist - 1));
}
if (peers[i].seljit * peers[i].synch > e) {
g = peers[i].seljit;
e = peers[i].seljit * peers[i].synch;
k = i;
}
}
g = max(g, LOGTOD(sys_precision));
if ( nlist <= max(1, sys_minclock)
|| g <= d
|| ((FLAG_TRUE | FLAG_PREFER) & peers[k].peer->flags))
break;
DPRINTF(3, ("select: drop %s seljit %.6f jit %.6f\n",
ntoa(&peers[k].peer->srcadr), g, d));
if (nlist > sys_maxclock)
peers[k].peer->new_status = CTL_PST_SEL_EXCESS;
for (j = k + 1; j < nlist; j++)
peers[j - 1] = peers[j];
nlist--;
}
e = 1e9;
speer = 0;
leap_vote_ins = 0;
leap_vote_del = 0;
for (i = 0; i < nlist; i++) {
peer = peers[i].peer;
peer->unreach = 0;
peer->new_status = CTL_PST_SEL_SYNCCAND;
sys_survivors++;
if (peer->leap == LEAP_ADDSECOND) {
if (peer->flags & FLAG_REFCLOCK)
leap_vote_ins = nlist;
else if (leap_vote_ins < nlist)
leap_vote_ins++;
}
if (peer->leap == LEAP_DELSECOND) {
if (peer->flags & FLAG_REFCLOCK)
leap_vote_del = nlist;
else if (leap_vote_del < nlist)
leap_vote_del++;
}
if (peer->flags & FLAG_PREFER)
sys_prefer = peer;
speermet = peers[i].seljit * peers[i].synch +
peer->stratum * sys_mindisp;
if (speermet < e) {
e = speermet;
speer = i;
}
}
if (nlist > 0 && nlist >= sys_minsane) {
double x;
typesystem = peers[speer].peer;
if (osys_peer == NULL || osys_peer == typesystem) {
sys_clockhop = 0;
} else if ((x = fabs(typesystem->offset -
osys_peer->offset)) < sys_mindisp) {
if (sys_clockhop == 0)
sys_clockhop = sys_mindisp;
else
sys_clockhop *= .5;
DPRINTF(1, ("select: clockhop %d %.6f %.6f\n",
j, x, sys_clockhop));
if (fabs(x) < sys_clockhop)
typesystem = osys_peer;
else
sys_clockhop = 0;
} else {
sys_clockhop = 0;
}
}
if (typesystem != NULL) {
if (sys_prefer == NULL) {
typesystem->new_status = CTL_PST_SEL_SYSPEER;
clock_combine(peers, sys_survivors, speer);
} else {
typesystem = sys_prefer;
sys_clockhop = 0;
typesystem->new_status = CTL_PST_SEL_SYSPEER;
sys_offset = typesystem->offset;
sys_jitter = typesystem->jitter;
}
DPRINTF(1, ("select: combine offset %.9f jitter %.9f\n",
sys_offset, sys_jitter));
}
#ifdef REFCLOCK
if ( typepps != NULL
&& fabs(sys_offset) < 0.4
&& ( typepps->refclktype != REFCLK_ATOM_PPS
|| ( typepps->refclktype == REFCLK_ATOM_PPS
&& ( sys_prefer != NULL
|| (typesystem == NULL && sys_minsane == 0))))) {
typesystem = typepps;
sys_clockhop = 0;
typesystem->new_status = CTL_PST_SEL_PPS;
sys_offset = typesystem->offset;
sys_jitter = typesystem->jitter;
DPRINTF(1, ("select: pps offset %.9f jitter %.9f\n",
sys_offset, sys_jitter));
}
#endif
if (typesystem == NULL) {
if (osys_peer != NULL) {
if (sys_orphwait > 0)
orphwait = current_time + sys_orphwait;
report_event(EVNT_NOPEER, NULL, NULL);
}
sys_peer = NULL;
for (peer = peer_list; peer != NULL; peer = peer->p_link)
peer->status = peer->new_status;
return;
}
if (typesystem->epoch <= sys_epoch)
return;
if (osys_peer != typesystem)
report_event(PEVNT_NEWPEER, typesystem, NULL);
for (peer = peer_list; peer != NULL; peer = peer->p_link)
peer->status = peer->new_status;
clock_update(typesystem);
}
static void
clock_combine(
peer_select * peers,
int npeers,
int syspeer
)
{
int i;
double x, y, z, w;
y = z = w = 0;
for (i = 0; i < npeers; i++) {
DEBUG_INSIST(peers[i].peer);
x = 1. / peers[i].synch;
y += x;
z += x * peers[i].peer->offset;
w += x * DIFF(peers[i].peer->offset,
peers[syspeer].peer->offset);
}
sys_offset = z / y;
sys_jitter = SQRT(w / y + SQUARE(peers[syspeer].seljit));
}
static double
root_distance(
struct peer *peer
)
{
double dtemp;
dtemp = (peer->delay + peer->rootdelay) / 2
+ peer->disp
+ clock_phi * (current_time - peer->update)
+ peer->rootdisp
+ peer->jitter;
if (dtemp < sys_mindisp)
dtemp = sys_mindisp;
return (dtemp);
}
static void
peer_xmit(
struct peer *peer
)
{
struct pkt xpkt;
size_t sendlen, authlen;
keyid_t xkeyid = 0;
l_fp xmt_tx, xmt_ty;
if (!peer->dstadr)
return;
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.refid = sys_refid;
xpkt.rootdelay = HTONS_FP(DTOFP(sys_rootdelay));
xpkt.rootdisp = HTONS_FP(DTOUFP(sys_rootdisp));
HTONL_FP(&sys_reftime, &xpkt.reftime);
HTONL_FP(&peer->rec, &xpkt.org);
HTONL_FP(&peer->dst, &xpkt.rec);
sendlen = LEN_PKT_NOMAC;
if (
#ifdef AUTOKEY
!(peer->flags & FLAG_SKEY) &&
#endif
peer->keyid == 0) {
get_systime(&xmt_tx);
if (peer->flip == 0) {
peer->aorg = xmt_tx;
HTONL_FP(&xmt_tx, &xpkt.xmt);
} else {
if (peer->hmode == MODE_BROADCAST) {
HTONL_FP(&xmt_tx, &xpkt.xmt);
if (peer->flip > 0)
HTONL_FP(&peer->borg,
&xpkt.org);
else
HTONL_FP(&peer->aorg,
&xpkt.org);
} else {
if (peer->flip > 0)
HTONL_FP(&peer->borg,
&xpkt.xmt);
else
HTONL_FP(&peer->aorg,
&xpkt.xmt);
}
}
peer->t21_bytes = sendlen;
sendpkt(&peer->srcadr, peer->dstadr,
sys_ttl[(peer->ttl >= sys_ttlmax) ? sys_ttlmax : peer->ttl],
&xpkt, sendlen);
peer->sent++;
peer->throttle += (1 << peer->minpoll) - 2;
get_systime(&xmt_ty);
if (peer->flip != 0) {
if (peer->flip > 0)
peer->aorg = xmt_ty;
else
peer->borg = xmt_ty;
peer->flip = -peer->flip;
}
L_SUB(&xmt_ty, &xmt_tx);
LFPTOD(&xmt_ty, peer->xleave);
DPRINTF(1, ("peer_xmit: at %ld %s->%s mode %d len %zu xmt %#010x.%08x\n",
current_time,
peer->dstadr ? stoa(&peer->dstadr->sin) : "-",
stoa(&peer->srcadr), peer->hmode, sendlen,
xmt_tx.l_ui, xmt_tx.l_uf));
return;
}
#ifdef AUTOKEY
if (peer->flags & FLAG_SKEY) {
struct exten *exten;
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;
exten = NULL;
switch (peer->hmode) {
case MODE_BROADCAST:
if (peer->flags & FLAG_ASSOC)
exten = crypto_args(peer, CRYPTO_AUTO |
CRYPTO_RESP, peer->associd, NULL);
else
exten = crypto_args(peer, CRYPTO_ASSOC |
CRYPTO_RESP, peer->associd, NULL);
break;
case MODE_ACTIVE:
case MODE_PASSIVE:
if (!peer->crypto)
exten = crypto_args(peer, CRYPTO_ASSOC,
peer->associd, hostval.ptr);
else if (!(peer->crypto & CRYPTO_FLAG_CERT))
exten = crypto_args(peer, CRYPTO_CERT,
peer->associd, peer->issuer);
else if (!(peer->crypto & CRYPTO_FLAG_VRFY))
exten = crypto_args(peer,
crypto_ident(peer), peer->associd,
NULL);
else if ( sys_leap != LEAP_NOTINSYNC
&& peer->leap != LEAP_NOTINSYNC
&& !(peer->crypto & CRYPTO_FLAG_COOK))
exten = crypto_args(peer, CRYPTO_COOK,
peer->associd, NULL);
else if (!(peer->crypto & CRYPTO_FLAG_AUTO))
exten = crypto_args(peer, CRYPTO_AUTO,
peer->associd, NULL);
else if ( peer->flags & FLAG_ASSOC
&& peer->crypto & CRYPTO_FLAG_SIGN)
exten = crypto_args(peer, CRYPTO_AUTO |
CRYPTO_RESP, peer->assoc, NULL);
else if (sys_leap == LEAP_NOTINSYNC)
break;
else if (!(peer->crypto & CRYPTO_FLAG_SIGN))
exten = crypto_args(peer, CRYPTO_SIGN,
peer->associd, hostval.ptr);
else if (!(peer->crypto & CRYPTO_FLAG_LEAP))
exten = crypto_args(peer, CRYPTO_LEAP,
peer->associd, NULL);
break;
case MODE_CLIENT:
if (!peer->crypto)
exten = crypto_args(peer, CRYPTO_ASSOC,
peer->associd, hostval.ptr);
else if (!(peer->crypto & CRYPTO_FLAG_CERT))
exten = crypto_args(peer, CRYPTO_CERT,
peer->associd, peer->issuer);
else if (!(peer->crypto & CRYPTO_FLAG_VRFY))
exten = crypto_args(peer,
crypto_ident(peer), peer->associd,
NULL);
else if (!(peer->crypto & CRYPTO_FLAG_COOK))
exten = crypto_args(peer, CRYPTO_COOK,
peer->associd, NULL);
else if (!(peer->crypto & CRYPTO_FLAG_AUTO))
exten = crypto_args(peer, CRYPTO_AUTO,
peer->assoc, NULL);
else if (sys_leap == LEAP_NOTINSYNC)
break;
else if (!(peer->crypto & CRYPTO_FLAG_SIGN))
exten = crypto_args(peer, CRYPTO_SIGN,
peer->associd, hostval.ptr);
else if (!(peer->crypto & CRYPTO_FLAG_LEAP))
exten = crypto_args(peer, CRYPTO_LEAP,
peer->associd, NULL);
break;
}
if (peer->cmmd != NULL) {
u_int32 temp32;
temp32 = CRYPTO_RESP;
peer->cmmd->opcode |= htonl(temp32);
sendlen += crypto_xmit(peer, &xpkt, NULL,
sendlen, peer->cmmd, 0);
free(peer->cmmd);
peer->cmmd = NULL;
}
if (exten != NULL) {
if (exten->opcode != 0)
sendlen += crypto_xmit(peer, &xpkt,
NULL, sendlen, exten, 0);
free(exten);
}
if (sendlen > (int)LEN_PKT_NOMAC) {
session_key(&peer->dstadr->sin, &peer->srcadr,
xkeyid, 0, 2);
}
}
#endif
get_systime(&xmt_tx);
if (peer->flip == 0) {
peer->aorg = xmt_tx;
HTONL_FP(&xmt_tx, &xpkt.xmt);
} else {
if (peer->hmode == MODE_BROADCAST) {
HTONL_FP(&xmt_tx, &xpkt.xmt);
if (peer->flip > 0)
HTONL_FP(&peer->borg, &xpkt.org);
else
HTONL_FP(&peer->aorg, &xpkt.org);
} else {
if (peer->flip > 0)
HTONL_FP(&peer->borg, &xpkt.xmt);
else
HTONL_FP(&peer->aorg, &xpkt.xmt);
}
}
xkeyid = peer->keyid;
authlen = authencrypt(xkeyid, (u_int32 *)&xpkt, sendlen);
if (authlen == 0) {
report_event(PEVNT_AUTH, peer, "no key");
peer->flash |= TEST5;
peer->badauth++;
return;
}
sendlen += authlen;
#ifdef AUTOKEY
if (xkeyid > NTP_MAXKEY)
authtrust(xkeyid, 0);
#endif
if (sendlen > sizeof(xpkt)) {
msyslog(LOG_ERR, "peer_xmit: buffer overflow %zu", sendlen);
exit (-1);
}
peer->t21_bytes = sendlen;
sendpkt(&peer->srcadr, peer->dstadr,
sys_ttl[(peer->ttl >= sys_ttlmax) ? sys_ttlmax : peer->ttl],
&xpkt, sendlen);
peer->sent++;
peer->throttle += (1 << peer->minpoll) - 2;
get_systime(&xmt_ty);
if (peer->flip != 0) {
if (peer->flip > 0)
peer->aorg = xmt_ty;
else
peer->borg = xmt_ty;
peer->flip = -peer->flip;
}
L_SUB(&xmt_ty, &xmt_tx);
LFPTOD(&xmt_ty, peer->xleave);
#ifdef AUTOKEY
DPRINTF(1, ("peer_xmit: at %ld %s->%s mode %d keyid %08x len %zu index %d\n",
current_time, latoa(peer->dstadr),
ntoa(&peer->srcadr), peer->hmode, xkeyid, sendlen,
peer->keynumber));
#else
DPRINTF(1, ("peer_xmit: at %ld %s->%s mode %d keyid %08x len %zu\n",
current_time, peer->dstadr ?
ntoa(&peer->dstadr->sin) : "-",
ntoa(&peer->srcadr), peer->hmode, xkeyid, sendlen));
#endif
return;
}
#ifdef LEAP_SMEAR
static void
leap_smear_add_offs(
l_fp *t,
l_fp *t_recv
)
{
L_ADD(t, &leap_smear.offset);
return;
}
#endif
static void
fast_xmit(
struct recvbuf *rbufp,
int xmode,
keyid_t xkeyid,
int flags
)
{
struct pkt xpkt;
struct pkt *rpkt;
l_fp xmt_tx, xmt_ty;
size_t sendlen;
#ifdef AUTOKEY
u_int32 temp32;
#endif
rpkt = &rbufp->recv_pkt;
if (rbufp->dstadr->flags & INT_MCASTOPEN)
rbufp->dstadr = findinterface(&rbufp->recv_srcadr);
if (flags & RES_KOD) {
sys_kodsent++;
xpkt.li_vn_mode = PKT_LI_VN_MODE(LEAP_NOTINSYNC,
PKT_VERSION(rpkt->li_vn_mode), xmode);
xpkt.stratum = STRATUM_PKT_UNSPEC;
xpkt.ppoll = max(rpkt->ppoll, ntp_minpoll);
xpkt.precision = rpkt->precision;
memcpy(&xpkt.refid, "RATE", 4);
xpkt.rootdelay = rpkt->rootdelay;
xpkt.rootdisp = rpkt->rootdisp;
xpkt.reftime = rpkt->reftime;
xpkt.org = rpkt->xmt;
xpkt.rec = rpkt->xmt;
xpkt.xmt = rpkt->xmt;
} else {
#ifdef LEAP_SMEAR
l_fp this_ref_time;
l_fp this_recv_time;
#endif
xpkt.li_vn_mode = PKT_LI_VN_MODE(xmt_leap,
PKT_VERSION(rpkt->li_vn_mode), xmode);
xpkt.stratum = STRATUM_TO_PKT(sys_stratum);
xpkt.ppoll = max(rpkt->ppoll, ntp_minpoll);
xpkt.precision = sys_precision;
xpkt.refid = sys_refid;
xpkt.rootdelay = HTONS_FP(DTOFP(sys_rootdelay));
xpkt.rootdisp = HTONS_FP(DTOUFP(sys_rootdisp));
#ifdef LEAP_SMEAR
this_ref_time = sys_reftime;
if (leap_smear.in_progress) {
leap_smear_add_offs(&this_ref_time, NULL);
xpkt.refid = convertLFPToRefID(leap_smear.offset);
DPRINTF(2, ("fast_xmit: leap_smear.in_progress: refid %8x, smear %s\n",
ntohl(xpkt.refid),
lfptoa(&leap_smear.offset, 8)
));
}
HTONL_FP(&this_ref_time, &xpkt.reftime);
#else
HTONL_FP(&sys_reftime, &xpkt.reftime);
#endif
xpkt.org = rpkt->xmt;
#ifdef LEAP_SMEAR
this_recv_time = rbufp->recv_time;
if (leap_smear.in_progress)
leap_smear_add_offs(&this_recv_time, NULL);
HTONL_FP(&this_recv_time, &xpkt.rec);
#else
HTONL_FP(&rbufp->recv_time, &xpkt.rec);
#endif
get_systime(&xmt_tx);
#ifdef LEAP_SMEAR
if (leap_smear.in_progress)
leap_smear_add_offs(&xmt_tx, &this_recv_time);
#endif
HTONL_FP(&xmt_tx, &xpkt.xmt);
}
#ifdef HAVE_NTP_SIGND
if (flags & RES_MSSNTP) {
send_via_ntp_signd(rbufp, xmode, xkeyid, flags, &xpkt);
return;
}
#endif
sendlen = LEN_PKT_NOMAC;
if (rbufp->recv_length == sendlen) {
sendpkt(&rbufp->recv_srcadr, rbufp->dstadr, 0, &xpkt,
sendlen);
DPRINTF(1, ("fast_xmit: at %ld %s->%s mode %d len %lu\n",
current_time, stoa(&rbufp->dstadr->sin),
stoa(&rbufp->recv_srcadr), xmode,
(u_long)sendlen));
return;
}
#ifdef AUTOKEY
if (xkeyid > NTP_MAXKEY) {
keyid_t cookie;
cookie = session_key(&rbufp->recv_srcadr,
&rbufp->dstadr->sin, 0, sys_private, 0);
if ((size_t)rbufp->recv_length > sendlen + MAX_MAC_LEN) {
session_key(&rbufp->dstadr->sin,
&rbufp->recv_srcadr, xkeyid, 0, 2);
temp32 = CRYPTO_RESP;
rpkt->exten[0] |= htonl(temp32);
sendlen += crypto_xmit(NULL, &xpkt, rbufp,
sendlen, (struct exten *)rpkt->exten,
cookie);
} else {
session_key(&rbufp->dstadr->sin,
&rbufp->recv_srcadr, xkeyid, cookie, 2);
}
}
#endif
get_systime(&xmt_tx);
sendlen += authencrypt(xkeyid, (u_int32 *)&xpkt, sendlen);
#ifdef AUTOKEY
if (xkeyid > NTP_MAXKEY)
authtrust(xkeyid, 0);
#endif
sendpkt(&rbufp->recv_srcadr, rbufp->dstadr, 0, &xpkt, sendlen);
get_systime(&xmt_ty);
L_SUB(&xmt_ty, &xmt_tx);
sys_authdelay = xmt_ty;
DPRINTF(1, ("fast_xmit: at %ld %s->%s mode %d keyid %08x len %lu\n",
current_time, ntoa(&rbufp->dstadr->sin),
ntoa(&rbufp->recv_srcadr), xmode, xkeyid,
(u_long)sendlen));
}
static void
pool_xmit(
struct peer *pool
)
{
#ifdef WORKER
struct pkt xpkt;
struct addrinfo hints;
int rc;
struct interface * lcladr;
sockaddr_u * rmtadr;
int restrict_mask;
struct peer * p;
l_fp xmt_tx;
if (NULL == pool->ai) {
if (pool->addrs != NULL) {
free(pool->addrs);
pool->addrs = NULL;
}
ZERO(hints);
hints.ai_family = AF(&pool->srcadr);
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
rc = getaddrinfo_sometime(
pool->hostname,
"ntp",
&hints,
0,
&pool_name_resolved,
(void *)(intptr_t)pool->associd);
if (!rc)
DPRINTF(1, ("pool DNS lookup %s started\n",
pool->hostname));
else
msyslog(LOG_ERR,
"unable to start pool DNS %s: %m",
pool->hostname);
return;
}
do {
rmtadr = (sockaddr_u *)(void *)pool->ai->ai_addr;
pool->ai = pool->ai->ai_next;
p = findexistingpeer(rmtadr, NULL, NULL, MODE_CLIENT, 0);
} while (p != NULL && pool->ai != NULL);
if (p != NULL)
return;
restrict_mask = restrictions(rmtadr);
if (RES_FLAGS & restrict_mask)
restrict_source(rmtadr, 0,
current_time + POOL_SOLICIT_WINDOW + 1);
lcladr = findinterface(rmtadr);
memset(&xpkt, 0, sizeof(xpkt));
xpkt.li_vn_mode = PKT_LI_VN_MODE(sys_leap, pool->version,
MODE_CLIENT);
xpkt.stratum = STRATUM_TO_PKT(sys_stratum);
xpkt.ppoll = pool->hpoll;
xpkt.precision = sys_precision;
xpkt.refid = sys_refid;
xpkt.rootdelay = HTONS_FP(DTOFP(sys_rootdelay));
xpkt.rootdisp = HTONS_FP(DTOUFP(sys_rootdisp));
HTONL_FP(&sys_reftime, &xpkt.reftime);
get_systime(&xmt_tx);
pool->aorg = xmt_tx;
HTONL_FP(&xmt_tx, &xpkt.xmt);
sendpkt(rmtadr, lcladr,
sys_ttl[(pool->ttl >= sys_ttlmax) ? sys_ttlmax : pool->ttl],
&xpkt, LEN_PKT_NOMAC);
pool->sent++;
pool->throttle += (1 << pool->minpoll) - 2;
DPRINTF(1, ("pool_xmit: at %ld %s->%s pool\n",
current_time, latoa(lcladr), stoa(rmtadr)));
msyslog(LOG_INFO, "Soliciting pool server %s", stoa(rmtadr));
#endif
}
#ifdef AUTOKEY
int
group_test(
char *grp,
char *ident
)
{
if (grp == NULL)
return (0);
if (strcmp(grp, sys_groupname) == 0)
return (0);
if (ident == NULL)
return (1);
if (strcmp(grp, ident) == 0)
return (0);
return (1);
}
#endif
#ifdef WORKER
void
pool_name_resolved(
int rescode,
int gai_errno,
void * context,
const char * name,
const char * service,
const struct addrinfo * hints,
const struct addrinfo * res
)
{
struct peer * pool;
associd_t assoc;
if (rescode) {
msyslog(LOG_ERR,
"error resolving pool %s: %s (%d)",
name, gai_strerror(rescode), rescode);
return;
}
assoc = (associd_t)(intptr_t)context;
pool = findpeerbyassoc(assoc);
if (NULL == pool) {
msyslog(LOG_ERR,
"Could not find assoc %u for pool DNS %s",
assoc, name);
return;
}
DPRINTF(1, ("pool DNS %s completed\n", name));
pool->addrs = copy_addrinfo_list(res);
pool->ai = pool->addrs;
pool_xmit(pool);
}
#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;
}
value_free(&peer->sndval);
peer->keynumber = 0;
peer->flags &= ~FLAG_ASSOC;
DPRINTF(1, ("key_expire: at %lu associd %d\n", current_time,
peer->associd));
}
#endif
static int
local_refid(
struct peer * p
)
{
endpt * unicast_ep;
if (p->dstadr != NULL && !(INT_MCASTIF & p->dstadr->flags))
unicast_ep = p->dstadr;
else
unicast_ep = findinterface(&p->srcadr);
if (unicast_ep != NULL && p->refid == unicast_ep->addr_refid)
return TRUE;
else
return FALSE;
}
int
peer_unfit(
struct peer *peer
)
{
int rval = 0;
if ( peer->leap == LEAP_NOTINSYNC
|| peer->stratum < sys_floor
|| peer->stratum >= sys_ceiling) {
rval |= TEST10;
}
if ( !(peer->flags & FLAG_REFCLOCK)
&& root_distance(peer) >= sys_maxdist
+ clock_phi * ULOGTOD(peer->hpoll)) {
rval |= TEST11;
}
if (peer->stratum > 1 && local_refid(peer)) {
rval |= TEST12;
}
if (!peer->reach || (peer->flags & FLAG_NOSELECT)) {
rval |= TEST13;
}
peer->flash &= ~PEER_TEST_MASK;
peer->flash |= rval;
return (rval);
}
#define MINSTEP 20e-9
#define MAXSTEP 1
#define MINCHANGES 12
#define MAXLOOPS ((int)(1. / MINSTEP))
void
measure_precision(void)
{
set_sys_fuzz(0.);
trunc_os_clock = FALSE;
measured_tick = measure_tick_fuzz();
set_sys_tick_precision(measured_tick);
msyslog(LOG_INFO, "proto: precision = %.3f usec (%d)",
sys_tick * 1e6, sys_precision);
if (sys_fuzz < sys_tick) {
msyslog(LOG_NOTICE, "proto: fuzz beneath %.3f usec",
sys_fuzz * 1e6);
}
}
double
measure_tick_fuzz(void)
{
l_fp minstep;
l_fp val;
l_fp last;
l_fp ldiff;
double tick;
double diff;
long repeats;
long max_repeats;
int changes;
int i;
tick = MAXSTEP;
max_repeats = 0;
repeats = 0;
changes = 0;
DTOLFP(MINSTEP, &minstep);
get_systime(&last);
for (i = 0; i < MAXLOOPS && changes < MINCHANGES; i++) {
get_systime(&val);
ldiff = val;
L_SUB(&ldiff, &last);
last = val;
if (L_ISGT(&ldiff, &minstep)) {
max_repeats = max(repeats, max_repeats);
repeats = 0;
changes++;
LFPTOD(&ldiff, diff);
tick = min(diff, tick);
} else {
repeats++;
}
}
if (changes < MINCHANGES) {
msyslog(LOG_ERR, "Fatal error: precision could not be measured (MINSTEP too large?)");
exit(1);
}
if (0 == max_repeats) {
set_sys_fuzz(tick);
} else {
set_sys_fuzz(tick / max_repeats);
}
return tick;
}
void
set_sys_tick_precision(
double tick
)
{
int i;
if (tick > 1.) {
msyslog(LOG_ERR,
"unsupported tick %.3f > 1s ignored", tick);
return;
}
if (tick < measured_tick) {
msyslog(LOG_ERR,
"proto: tick %.3f less than measured tick %.3f, ignored",
tick, measured_tick);
return;
} else if (tick > measured_tick) {
trunc_os_clock = TRUE;
msyslog(LOG_NOTICE,
"proto: truncating system clock to multiples of %.9f",
tick);
}
sys_tick = tick;
for (i = 0; tick <= 1; i--)
tick *= 2;
if (tick - 1 > 1 - tick / 2)
i++;
sys_precision = (s_char)i;
}
void
init_proto(void)
{
l_fp dummy;
int i;
set_sys_leap(LEAP_NOTINSYNC);
sys_stratum = STRATUM_UNSPEC;
memcpy(&sys_refid, "INIT", 4);
sys_peer = NULL;
sys_rootdelay = 0;
sys_rootdisp = 0;
L_CLR(&sys_reftime);
sys_jitter = 0;
measure_precision();
get_systime(&dummy);
sys_survivors = 0;
sys_manycastserver = 0;
sys_bclient = 0;
sys_bdelay = BDELAY_DEFAULT;
sys_authenticate = 1;
sys_stattime = current_time;
orphwait = current_time + sys_orphwait;
proto_clr_stats();
for (i = 0; i < MAX_TTL; ++i)
sys_ttl[i] = (u_char)((i * 256) / MAX_TTL);
sys_ttlmax = (MAX_TTL - 1);
hardpps_enable = 0;
stats_control = 1;
}
void
proto_config(
int item,
u_long value,
double dvalue,
sockaddr_u *svalue
)
{
DPRINTF(2, ("proto_config: code %d value %lu dvalue %lf\n",
item, value, dvalue));
switch (item) {
case PROTO_AUTHENTICATE:
sys_authenticate = value;
break;
case PROTO_BROADCLIENT:
sys_bclient = (int)value;
if (sys_bclient == 0)
io_unsetbclient();
else
io_setbclient();
break;
#ifdef REFCLOCK
case PROTO_CAL:
cal_enable = value;
break;
#endif
case PROTO_KERNEL:
select_loop(value);
break;
case PROTO_MONITOR:
if (value)
mon_start(MON_ON);
else {
mon_stop(MON_ON);
if (mon_enabled)
msyslog(LOG_WARNING,
"restrict: 'monitor' cannot be disabled while 'limited' is enabled");
}
break;
case PROTO_NTP:
ntp_enable = value;
break;
case PROTO_MODE7:
ntp_mode7 = value;
break;
case PROTO_PPS:
hardpps_enable = value;
break;
case PROTO_FILEGEN:
stats_control = value;
break;
case PROTO_BCPOLLBSTEP:
sys_bcpollbstep = (u_char)dvalue;
break;
case PROTO_BEACON:
sys_beacon = (int)dvalue;
break;
case PROTO_BROADDELAY:
sys_bdelay = (dvalue ? dvalue : BDELAY_DEFAULT);
break;
case PROTO_CEILING:
sys_ceiling = (int)dvalue;
break;
case PROTO_COHORT:
sys_cohort = (int)dvalue;
break;
case PROTO_FLOOR:
sys_floor = (int)dvalue;
break;
case PROTO_MAXCLOCK:
sys_maxclock = (int)dvalue;
break;
case PROTO_MAXDIST:
sys_maxdist = dvalue;
break;
case PROTO_CALLDELAY:
break;
case PROTO_MINCLOCK:
sys_minclock = (int)dvalue;
break;
case PROTO_MINDISP:
sys_mindisp = dvalue;
break;
case PROTO_MINSANE:
sys_minsane = (int)dvalue;
break;
case PROTO_ORPHAN:
sys_orphan = (int)dvalue;
break;
case PROTO_ORPHWAIT:
orphwait -= sys_orphwait;
sys_orphwait = (int)dvalue;
orphwait += sys_orphwait;
break;
case PROTO_MULTICAST_ADD:
if (svalue != NULL)
io_multicast_add(svalue);
sys_bclient = 1;
break;
case PROTO_MULTICAST_DEL:
if (svalue != NULL)
io_multicast_del(svalue);
break;
case PROTO_PCEDIGEST:
peer_clear_digest_early = value;
break;
case PROTO_UECRYPTO:
unpeer_crypto_early = value;
break;
case PROTO_UECRYPTONAK:
unpeer_crypto_nak_early = value;
break;
case PROTO_UEDIGEST:
unpeer_digest_early = value;
break;
default:
msyslog(LOG_NOTICE,
"proto: unsupported option %d", item);
}
}
void
proto_clr_stats(void)
{
sys_stattime = current_time;
sys_received = 0;
sys_processed = 0;
sys_newversion = 0;
sys_oldversion = 0;
sys_declined = 0;
sys_restricted = 0;
sys_badlength = 0;
sys_badauth = 0;
sys_limitrejected = 0;
sys_kodsent = 0;
}