/* Sync to peers every N secs */
-#define INTERVAL_QUERY_NORMAL 30
-#define INTERVAL_QUERY_PATHETIC 60
-#define INTERVAL_QUERY_AGRESSIVE 5
+#define INTERVAL_QUERY_NORMAL 30
+#define INTERVAL_QUERY_PATHETIC 60
+#define INTERVAL_QUERY_AGRESSIVE 5
/* Bad if *less than* TRUSTLEVEL_BADPEER */
-#define TRUSTLEVEL_BADPEER 6
-#define TRUSTLEVEL_PATHETIC 2
-#define TRUSTLEVEL_AGRESSIVE 8
-#define TRUSTLEVEL_MAX 10
+#define TRUSTLEVEL_BADPEER 6
+#define TRUSTLEVEL_PATHETIC 2
+#define TRUSTLEVEL_AGRESSIVE 8
+#define TRUSTLEVEL_MAX 10
-#define QSCALE_OFF_MIN 0.05
-#define QSCALE_OFF_MAX 0.50
+#define QSCALE_OFF_MIN 0.05
+#define QSCALE_OFF_MAX 0.50
/* Single query might take n secs max */
-#define QUERYTIME_MAX 15
+#define QUERYTIME_MAX 15
/* Min offset for settime at start. "man ntpd" says it's 128 ms */
-#define STEPTIME_MIN_OFFSET 0.128
+#define STEPTIME_MIN_OFFSET 0.128
typedef struct {
uint32_t int_partl;
} ntp_msg_t;
enum {
- NTP_VERSION = 4,
- NTP_MAXSTRATUM = 15,
+ NTP_VERSION = 4,
+ NTP_MAXSTRATUM = 15,
/* Leap Second Codes (high order two bits of m_status) */
- LI_NOWARNING = (0 << 6), /* no warning */
- LI_PLUSSEC = (1 << 6), /* add a second (61 seconds) */
- LI_MINUSSEC = (2 << 6), /* minus a second (59 seconds) */
- LI_ALARM = (3 << 6), /* alarm condition */
+ LI_NOWARNING = (0 << 6), /* no warning */
+ LI_PLUSSEC = (1 << 6), /* add a second (61 seconds) */
+ LI_MINUSSEC = (2 << 6), /* minus a second (59 seconds) */
+ LI_ALARM = (3 << 6), /* alarm condition */
/* Status Masks */
- MODE_MASK = (7 << 0),
- VERSION_MASK = (7 << 3),
- VERSION_SHIFT = 3,
- LI_MASK = (3 << 6),
+ MODE_MASK = (7 << 0),
+ VERSION_MASK = (7 << 3),
+ VERSION_SHIFT = 3,
+ LI_MASK = (3 << 6),
/* Mode values */
- MODE_RES0 = 0, /* reserved */
- MODE_SYM_ACT = 1, /* symmetric active */
- MODE_SYM_PAS = 2, /* symmetric passive */
- MODE_CLIENT = 3, /* client */
- MODE_SERVER = 4, /* server */
- MODE_BROADCAST = 5, /* broadcast */
- MODE_RES1 = 6, /* reserved for NTP control message */
- MODE_RES2 = 7, /* reserved for private use */
+ MODE_RES0 = 0, /* reserved */
+ MODE_SYM_ACT = 1, /* symmetric active */
+ MODE_SYM_PAS = 2, /* symmetric passive */
+ MODE_CLIENT = 3, /* client */
+ MODE_SERVER = 4, /* server */
+ MODE_BROADCAST = 5, /* broadcast */
+ MODE_RES1 = 6, /* reserved for NTP control message */
+ MODE_RES2 = 7, /* reserved for private use */
};
#define OFFSET_1900_1970 2208988800UL /* 1970 - 1900 in seconds */
typedef struct {
- double o_offset;
- double o_delay;
- //UNUSED: double o_error;
- time_t o_rcvd;
- uint32_t o_refid4;
- uint8_t o_leap;
- uint8_t o_stratum;
- uint8_t o_good;
-} ntp_offset_t;
-
-#define OFFSET_ARRAY_SIZE 8
+ double d_offset;
+ double d_delay;
+ //UNUSED: double d_error;
+ time_t d_rcvd;
+ uint32_t d_refid4;
+ uint8_t d_leap;
+ uint8_t d_stratum;
+ uint8_t d_good;
+} ntp_datapoint_t;
+
+#define NUM_DATAPOINTS 8
typedef struct {
- len_and_sockaddr *lsa;
- char *dotted;
- /* When to send new query (if fd == -1)
- * or when receive times out (if fd >= 0): */
- time_t next_action_time;
- int fd;
- uint8_t shift;
- uint8_t trustlevel;
- ntp_msg_t msg;
- double xmttime;
- ntp_offset_t update;
- ntp_offset_t reply[OFFSET_ARRAY_SIZE];
+ len_and_sockaddr *p_lsa;
+ char *p_dotted;
+ /* When to send new query (if p_fd == -1)
+ * or when receive times out (if p_fd >= 0): */
+ time_t next_action_time;
+ int p_fd;
+ uint8_t p_datapoint_idx;
+ uint8_t trustlevel;
+ ntp_msg_t msg;
+ double p_xmttime;
+ ntp_datapoint_t update;
+ ntp_datapoint_t p_datapoint[NUM_DATAPOINTS];
} ntp_peer_t;
enum {
struct globals {
- double rootdelay;
- double reftime;
- llist_t *ntp_peers;
+ double rootdelay;
+ double reftime;
+ llist_t *ntp_peers;
#if ENABLE_FEATURE_NTPD_SERVER
- int listen_fd;
+ int listen_fd;
#endif
- unsigned verbose;
- unsigned peer_cnt;
- unsigned scale;
- uint32_t refid;
- uint32_t refid4;
- uint8_t synced;
- uint8_t leap;
+ unsigned verbose;
+ unsigned peer_cnt;
+ unsigned scale;
+ uint32_t refid;
+ uint32_t refid4;
+ uint8_t synced;
+ uint8_t leap;
#define G_precision -6
-// int8_t precision;
- uint8_t stratum;
- uint8_t time_is_stepped;
- uint8_t first_adj_done;
+// int8_t precision;
+ uint8_t stratum;
+ uint8_t time_was_stepped;
+ uint8_t first_adj_done;
};
#define G (*ptr_to_globals)
ntp_peer_t *p;
p = xzalloc(sizeof(*p));
- p->lsa = xhost2sockaddr(s, 123);
- p->dotted = xmalloc_sockaddr2dotted_noport(&p->lsa->u.sa);
- p->fd = -1;
+ p->p_lsa = xhost2sockaddr(s, 123);
+ p->p_dotted = xmalloc_sockaddr2dotted_noport(&p->p_lsa->u.sa);
+ p->p_fd = -1;
p->msg.m_status = MODE_CLIENT | (NTP_VERSION << 3);
p->trustlevel = TRUSTLEVEL_PATHETIC;
p->next_action_time = time(NULL); /* = set_next(p, 0); */
// Uncomment this and use strace to see it in action:
#define PROBE_LOCAL_ADDR // { len_and_sockaddr lsa; lsa.len = LSA_SIZEOF_SA; getsockname(p->query.fd, &lsa.u.sa, &lsa.len); }
- if (p->fd == -1) {
+ if (p->p_fd == -1) {
int fd, family;
len_and_sockaddr *local_lsa;
- family = p->lsa->u.sa.sa_family;
- p->fd = fd = xsocket_type(&local_lsa, family, SOCK_DGRAM);
+ family = p->p_lsa->u.sa.sa_family;
+ p->p_fd = fd = xsocket_type(&local_lsa, family, SOCK_DGRAM);
/* local_lsa has "null" address and port 0 now.
* bind() ensures we have a *particular port* selected by kernel
- * and remembered in p->fd, thus later recv(p->fd)
+ * and remembered in p->p_fd, thus later recv(p->p_fd)
* receives only packets sent to this port.
*/
PROBE_LOCAL_ADDR
*/
p->msg.m_xmttime.int_partl = random();
p->msg.m_xmttime.fractionl = random();
- p->xmttime = gettime1900d();
+ p->p_xmttime = gettime1900d();
- if (do_sendto(p->fd, /*from:*/ NULL, /*to:*/ &p->lsa->u.sa, /*addrlen:*/ p->lsa->len,
+ if (do_sendto(p->p_fd, /*from:*/ NULL, /*to:*/ &p->p_lsa->u.sa, /*addrlen:*/ p->p_lsa->len,
&p->msg, NTP_MSGSIZE_NOAUTH) == -1
) {
- close(p->fd);
- p->fd = -1;
+ close(p->p_fd);
+ p->p_fd = -1;
set_next(p, INTERVAL_QUERY_PATHETIC);
return -1;
}
if (G.verbose)
- bb_error_msg("sent query to %s", p->dotted);
+ bb_error_msg("sent query to %s", p->p_dotted);
set_next(p, QUERYTIME_MAX);
return 0;
char buf[80];
time_t tval;
- if (G.time_is_stepped)
+ if (G.time_was_stepped)
goto bail;
- G.time_is_stepped = 1;
+ G.time_was_stepped = 1;
/* if the offset is small, don't step, slew (later) */
if (offset < STEPTIME_MIN_OFFSET && offset > -STEPTIME_MIN_OFFSET)
{
const ntp_peer_t *const *a = aa;
const ntp_peer_t *const *b = bb;
- if ((*a)->update.o_offset < (*b)->update.o_offset)
+ if ((*a)->update.d_offset < (*b)->update.d_offset)
return -1;
- return ((*a)->update.o_offset > (*b)->update.o_offset);
+ return ((*a)->update.d_offset > (*b)->update.d_offset);
}
static unsigned
updated_scale(double offset)
ntp_peer_t *p = (ntp_peer_t *) item->data;
if (p->trustlevel < TRUSTLEVEL_BADPEER)
continue;
- if (!p->update.o_good) {
+ if (!p->update.d_good) {
free(peers);
return;
}
middle = goodpeer_cnt / 2;
if (middle != 0 && (goodpeer_cnt & 1) == 0) {
- offset_median = (peers[middle-1]->update.o_offset + peers[middle]->update.o_offset) / 2;
- G.rootdelay = (peers[middle-1]->update.o_delay + peers[middle]->update.o_delay) / 2;
- G.stratum = 1 + MAX(peers[middle-1]->update.o_stratum, peers[middle]->update.o_stratum);
+ offset_median = (peers[middle-1]->update.d_offset + peers[middle]->update.d_offset) / 2;
+ G.rootdelay = (peers[middle-1]->update.d_delay + peers[middle]->update.d_delay) / 2;
+ G.stratum = 1 + MAX(peers[middle-1]->update.d_stratum, peers[middle]->update.d_stratum);
} else {
- offset_median = peers[middle]->update.o_offset;
- G.rootdelay = peers[middle]->update.o_delay;
- G.stratum = 1 + peers[middle]->update.o_stratum;
+ offset_median = peers[middle]->update.d_offset;
+ G.rootdelay = peers[middle]->update.d_delay;
+ G.stratum = 1 + peers[middle]->update.d_stratum;
}
- G.leap = peers[middle]->update.o_leap;
- G.refid4 = peers[middle]->update.o_refid4;
+ G.leap = peers[middle]->update.d_leap;
+ G.refid4 = peers[middle]->update.d_refid4;
G.refid =
#if ENABLE_FEATURE_IPV6
- peers[middle]->lsa->u.sa.sa_family != AF_INET ?
+ peers[middle]->p_lsa->u.sa.sa_family != AF_INET ?
G.refid4 :
#endif
- peers[middle]->lsa->u.sin.sin_addr.s_addr;
+ peers[middle]->p_lsa->u.sin.sin_addr.s_addr;
free(peers);
}
//TODO: if (offset_median > BIG) step_time(offset_median)?
clear_good:
for (item = G.ntp_peers; item != NULL; item = item->link) {
ntp_peer_t *p = (ntp_peer_t *) item->data;
- p->update.o_good = 0;
+ p->update.d_good = 0;
}
}
update_peer_data(ntp_peer_t *p)
{
/* Clock filter.
- * Find the offset which arrived with the lowest delay.
+ * Find the datapoint with the lowest delay.
* Use that as the peer update.
* Invalidate it and all older ones.
*/
int best = -1;
int good = 0;
- for (i = 0; i < OFFSET_ARRAY_SIZE; i++) {
- if (p->reply[i].o_good) {
+ for (i = 0; i < NUM_DATAPOINTS; i++) {
+ if (p->p_datapoint[i].d_good) {
good++;
- if (best < 0 || p->reply[i].o_delay < p->reply[best].o_delay)
+ if (best < 0 || p->p_datapoint[i].d_delay < p->p_datapoint[best].d_delay)
best = i;
}
}
- if (good < 8) //FIXME: was it meant to be OFFSET_ARRAY_SIZE, not 8?
+ if (good < 8) //FIXME: was it meant to be NUM_DATAPOINTS, not 8?
return;
- memcpy(&p->update, &p->reply[best], sizeof(p->update));
+ memcpy(&p->update, &p->p_datapoint[best], sizeof(p->update));
slew_time();
- for (i = 0; i < OFFSET_ARRAY_SIZE; i++)
- if (p->reply[i].o_rcvd <= p->reply[best].o_rcvd)
- p->reply[i].o_good = 0;
+ for (i = 0; i < NUM_DATAPOINTS; i++)
+ if (p->p_datapoint[i].d_rcvd <= p->p_datapoint[best].d_rcvd)
+ p->p_datapoint[i].d_good = 0;
}
static unsigned
static void
recv_and_process_peer_pkt(ntp_peer_t *p)
{
- ssize_t size;
- ntp_msg_t msg;
- double T1, T2, T3, T4;
- unsigned interval;
- ntp_offset_t *offset;
+ ssize_t size;
+ ntp_msg_t msg;
+ double T1, T2, T3, T4;
+ unsigned interval;
+ ntp_datapoint_t *datapoint;
/* We can recvfrom here and check from.IP, but some multihomed
* ntp servers reply from their *other IP*.
* TODO: maybe we should check at least what we can: from.port == 123?
*/
- size = recv(p->fd, &msg, sizeof(msg), MSG_DONTWAIT);
+ size = recv(p->p_fd, &msg, sizeof(msg), MSG_DONTWAIT);
if (size == -1) {
- bb_perror_msg("recv(%s) error", p->dotted);
+ bb_perror_msg("recv(%s) error", p->p_dotted);
if (errno == EHOSTUNREACH || errno == EHOSTDOWN
|| errno == ENETUNREACH || errno == ENETDOWN
|| errno == ECONNREFUSED || errno == EADDRNOTAVAIL
}
if (size != NTP_MSGSIZE_NOAUTH && size != NTP_MSGSIZE) {
- bb_error_msg("malformed packet received from %s", p->dotted);
+ bb_error_msg("malformed packet received from %s", p->p_dotted);
goto bail;
}
// "DENY", "RSTR" - peer does not like us at all
// "RATE" - peer is overloaded, reduce polling freq
interval = error_interval();
- bb_error_msg("reply from %s: not synced, next query in %us", p->dotted, interval);
+ bb_error_msg("reply from %s: not synced, next query in %us", p->p_dotted, interval);
goto close_sock;
}
/*
* From RFC 2030 (with a correction to the delay math):
*
- * Timestamp Name ID When Generated
- * ------------------------------------------------------------
- * Originate Timestamp T1 time request sent by client
- * Receive Timestamp T2 time request received by server
- * Transmit Timestamp T3 time reply sent by server
- * Destination Timestamp T4 time reply received by client
+ * Timestamp Name ID When Generated
+ * ------------------------------------------------------------
+ * Originate Timestamp T1 time request sent by client
+ * Receive Timestamp T2 time request received by server
+ * Transmit Timestamp T3 time reply sent by server
+ * Destination Timestamp T4 time reply received by client
*
- * The roundtrip delay d and local clock offset t are defined as
+ * The roundtrip delay and local clock offset are defined as
*
- * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2.
+ * delay = (T4 - T1) - (T3 - T2); offset = ((T2 - T1) + (T3 - T4)) / 2
*/
T4 = gettime1900d();
- T1 = p->xmttime;
+ T1 = p->p_xmttime;
T2 = lfp_to_d(msg.m_rectime);
T3 = lfp_to_d(msg.m_xmttime);
- offset = &p->reply[p->shift];
+ datapoint = &p->p_datapoint[p->p_datapoint_idx];
- offset->o_offset = ((T2 - T1) + (T3 - T4)) / 2;
- offset->o_delay = (T4 - T1) - (T3 - T2);
- if (offset->o_delay < 0) {
- bb_error_msg("reply from %s: negative delay %f", p->dotted, offset->o_delay);
+ datapoint->d_offset = ((T2 - T1) + (T3 - T4)) / 2;
+ datapoint->d_delay = (T4 - T1) - (T3 - T2);
+ if (datapoint->d_delay < 0) {
+ bb_error_msg("reply from %s: negative delay %f", p->p_dotted, datapoint->d_delay);
interval = error_interval();
set_next(p, interval);
goto close_sock;
}
- //UNUSED: offset->o_error = (T2 - T1) - (T3 - T4);
- offset->o_rcvd = (time_t)(T4 - OFFSET_1900_1970); /* = time(NULL); */
- offset->o_good = 1;
-
- offset->o_leap = (msg.m_status & LI_MASK);
- //UNUSED: offset->o_precision = msg.m_precision;
- //UNUSED: offset->o_rootdelay = sfp_to_d(msg.m_rootdelay);
- //UNUSED: offset->o_rootdispersion = sfp_to_d(msg.m_dispersion);
- //UNUSED: offset->o_refid = ntohl(msg.m_refid);
- offset->o_refid4 = msg.m_xmttime.fractionl;
- //UNUSED: offset->o_reftime = lfp_to_d(msg.m_reftime);
- //UNUSED: offset->o_poll = msg.m_ppoll;
- offset->o_stratum = msg.m_stratum;
+ //UNUSED: datapoint->d_error = (T2 - T1) - (T3 - T4);
+ datapoint->d_rcvd = (time_t)(T4 - OFFSET_1900_1970); /* = time(NULL); */
+ datapoint->d_good = 1;
+
+ datapoint->d_leap = (msg.m_status & LI_MASK);
+ //UNUSED: datapoint->o_precision = msg.m_precision;
+ //UNUSED: datapoint->o_rootdelay = sfp_to_d(msg.m_rootdelay);
+ //UNUSED: datapoint->o_rootdispersion = sfp_to_d(msg.m_dispersion);
+ //UNUSED: datapoint->d_refid = ntohl(msg.m_refid);
+ datapoint->d_refid4 = msg.m_xmttime.fractionl;
+ //UNUSED: datapoint->o_reftime = lfp_to_d(msg.m_reftime);
+ //UNUSED: datapoint->o_poll = msg.m_ppoll;
+ datapoint->d_stratum = msg.m_stratum;
if (p->trustlevel < TRUSTLEVEL_PATHETIC)
interval = scale_interval(INTERVAL_QUERY_PATHETIC);
if (p->trustlevel < TRUSTLEVEL_MAX) {
p->trustlevel++;
if (p->trustlevel == TRUSTLEVEL_BADPEER)
- bb_error_msg("peer %s now valid", p->dotted);
+ bb_error_msg("peer %s now valid", p->p_dotted);
}
if (G.verbose)
- bb_error_msg("reply from %s: offset %f delay %f, next query in %us", p->dotted,
- offset->o_offset, offset->o_delay, interval);
+ bb_error_msg("reply from %s: offset %f delay %f, next query in %us", p->p_dotted,
+ datapoint->d_offset, datapoint->d_delay, interval);
update_peer_data(p);
//TODO: do it after all peers had a chance to return at least one reply?
- step_time_once(offset->o_offset);
+ step_time_once(datapoint->d_offset);
- p->shift++;
- if (p->shift >= OFFSET_ARRAY_SIZE)
- p->shift = 0;
+ p->p_datapoint_idx++;
+ if (p->p_datapoint_idx >= NUM_DATAPOINTS)
+ p->p_datapoint_idx = 0;
close_sock:
/* We do not expect any more packets from this peer for now.
* Closing the socket informs kernel about it.
* We open a new socket when we send a new query.
*/
- close(p->fd);
- p->fd = -1;
+ close(p->p_fd);
+ p->p_fd = -1;
bail:
return;
}
if (!(opts & (OPT_p|OPT_l)))
bb_show_usage();
if (opts & OPT_x) /* disable stepping, only slew is allowed */
- G.time_is_stepped = 1;
+ G.time_was_stepped = 1;
while (peers)
add_peers(llist_pop(&peers));
if (!(opts & OPT_n)) {
clock_getres(CLOCK_REALTIME, &tp);
tp.tv_sec = 0;
tp.tv_nsec = 10000000;
- b = 1000000000 / tp.tv_nsec; /* convert to Hz */
+ b = 1000000000 / tp.tv_nsec; /* convert to Hz */
# else
b = 100; /* b = 1000000000/10000000 = 100 */
# endif
/* Overflow-safe "if (p->next_action_time <= cur_time) ..." */
if ((int)(cur_time - p->next_action_time) >= 0) {
- if (p->fd == -1) {
+ if (p->p_fd == -1) {
/* Time to send new req */
trial_cnt++;
if (send_query_to_peer(p) == 0)
sent_cnt++;
} else {
/* Timed out waiting for reply */
- close(p->fd);
- p->fd = -1;
+ close(p->p_fd);
+ p->p_fd = -1;
timeout = error_interval();
bb_error_msg("timed out waiting for %s, "
- "next query in %us", p->dotted, timeout);
+ "next query in %us", p->p_dotted, timeout);
if (p->trustlevel >= TRUSTLEVEL_BADPEER) {
p->trustlevel /= 2;
if (p->trustlevel < TRUSTLEVEL_BADPEER)
- bb_error_msg("peer %s now invalid", p->dotted);
+ bb_error_msg("peer %s now invalid", p->p_dotted);
}
set_next(p, timeout);
}
if (p->next_action_time < nextaction)
nextaction = p->next_action_time;
- if (p->fd >= 0) {
+ if (p->p_fd >= 0) {
/* Wait for reply from this peer */
- pfd[i].fd = p->fd;
+ pfd[i].fd = p->p_fd;
pfd[i].events = POLLIN;
idx2peer[i] = p;
i++;
projects / oweals / busybox.git / commitdiff