[Git][NTPsec/ntpsec][master] De-globalled system variables.

Ian Bruene gitlab at mg.gitlab.com
Sun May 20 19:50:43 UTC 2018


Ian Bruene pushed to branch master at NTPsec / ntpsec


Commits:
6a50a53f by Ian Bruene at 2018-05-20T19:44:21Z
De-globalled system variables.

- - - - -


12 changed files:

- include/ntpd.h
- ntpd/ntp_control.c
- ntpd/ntp_loopfilter.c
- ntpd/ntp_peer.c
- ntpd/ntp_proto.c
- ntpd/ntp_refclock.c
- ntpd/ntp_timer.c
- ntpd/refclock_generic.c
- ntpd/refclock_local.c
- ntpd/refclock_modem.c
- ntpd/refclock_nmea.c
- ntpd/refclock_pps.c


Changes:

=====================================
include/ntpd.h
=====================================
--- a/include/ntpd.h
+++ b/include/ntpd.h
@@ -317,16 +317,19 @@ extern int	peer_associations;	/* mobilized associations */
  * System variables are declared here.	See Section 3.2 of the
  * specification.
  */
-extern uint8_t	sys_leap;		/* system leap indicator */
-extern uint8_t	sys_stratum;		/* system stratum */
-extern int8_t	sys_precision;		/* local clock precision */
-extern double	sys_rootdelay;		/* roundtrip delay to primary source */
-extern double	sys_rootdisp;		/* dispersion to primary source */
-extern double	sys_rootdist;		/* distance to primary source */
-extern uint32_t	sys_refid;		/* reference id */
-extern l_fp	sys_reftime;		/* last update time */
-extern struct peer *sys_peer;		/* current peer */
-extern int	sys_maxclock;		/* maximum candidates */
+int	sys_maxclock;		/* maximum candidates */
+struct system_variables {
+    uint8_t	sys_leap;		/* system leap indicator */
+    uint8_t	sys_stratum;		/* system stratum */
+    int8_t	sys_precision;		/* local clock precision */
+    double	sys_rootdelay;		/* roundtrip delay to primary source */
+    double	sys_rootdisp;		/* dispersion to primary source */
+    double	sys_rootdist;		/* distance to primary source */
+    uint32_t	sys_refid;		/* reference id */
+    l_fp	sys_reftime;		/* last update time */
+    struct peer *sys_peer;		/* current peer */
+};
+extern struct system_variables sys_vars;
 
 /*
  * Nonspecified system state variables.


=====================================
ntpd/ntp_control.c
=====================================
--- a/ntpd/ntp_control.c
+++ b/ntpd/ntp_control.c
@@ -820,7 +820,7 @@ process_control(
 	 * Pull enough data from the packet to make intelligent
 	 * responses
 	 */
-	rpkt.li_vn_mode = PKT_LI_VN_MODE(sys_leap, res_version,
+	rpkt.li_vn_mode = PKT_LI_VN_MODE(sys_vars.sys_leap, res_version,
 					 MODE_CONTROL);
 	res_opcode = pkt->r_m_e_op;
 	rpkt.sequence = pkt->sequence;
@@ -963,15 +963,15 @@ ctlsysstatus(void)
 
 	this_clock = CTL_SST_TS_UNSPEC;
 #ifdef REFCLOCK
-	if (sys_peer != NULL) {
-		if (CTL_SST_TS_UNSPEC != sys_peer->sstclktype)
-			this_clock = sys_peer->sstclktype;
+	if (sys_vars.sys_peer != NULL) {
+		if (CTL_SST_TS_UNSPEC != sys_vars.sys_peer->sstclktype)
+			this_clock = sys_vars.sys_peer->sstclktype;
 	}
 #else /* REFCLOCK */
-	if (sys_peer != 0)
+	if (sys_vars.sys_peer != 0)
 		this_clock = CTL_SST_TS_NTP;
 #endif /* REFCLOCK */
-	return CTL_SYS_STATUS(sys_leap, this_clock, ctl_sys_num_events,
+	return CTL_SYS_STATUS(sys_vars.sys_leap, this_clock, ctl_sys_num_events,
 			      ctl_sys_last_event);
 }
 
@@ -1483,35 +1483,35 @@ ctl_putsys(
 	switch (varid) {
 
 	case CS_LEAP:
-		ctl_putuint(sys_var[CS_LEAP].text, sys_leap);
+		ctl_putuint(sys_var[CS_LEAP].text, sys_vars.sys_leap);
 		break;
 
 	case CS_STRATUM:
-		ctl_putuint(sys_var[CS_STRATUM].text, sys_stratum);
+		ctl_putuint(sys_var[CS_STRATUM].text, sys_vars.sys_stratum);
 		break;
 
 	case CS_PRECISION:
-		ctl_putint(sys_var[CS_PRECISION].text, sys_precision);
+		ctl_putint(sys_var[CS_PRECISION].text, sys_vars.sys_precision);
 		break;
 
 	case CS_ROOTDELAY:
-		ctl_putdbl(sys_var[CS_ROOTDELAY].text, sys_rootdelay * MS_PER_S);
+		ctl_putdbl(sys_var[CS_ROOTDELAY].text, sys_vars.sys_rootdelay * MS_PER_S);
 		break;
 
 	case CS_ROOTDISPERSION:
 		ctl_putdbl(sys_var[CS_ROOTDISPERSION].text,
-			   sys_rootdisp * MS_PER_S);
+			   sys_vars.sys_rootdisp * MS_PER_S);
 		break;
 
 	case CS_REFID:
-		if (sys_stratum > 1 && sys_stratum < STRATUM_UNSPEC)
-			ctl_putadr(sys_var[varid].text, sys_refid, NULL);
+		if (sys_vars.sys_stratum > 1 && sys_vars.sys_stratum < STRATUM_UNSPEC)
+			ctl_putadr(sys_var[varid].text, sys_vars.sys_refid, NULL);
 		else
-			ctl_putrefid(sys_var[varid].text, sys_refid);
+			ctl_putrefid(sys_var[varid].text, sys_vars.sys_refid);
 		break;
 
 	case CS_REFTIME:
-		ctl_putts(sys_var[CS_REFTIME].text, &sys_reftime);
+		ctl_putts(sys_var[CS_REFTIME].text, &sys_vars.sys_reftime);
 		break;
 
 	case CS_POLL:
@@ -1519,16 +1519,16 @@ ctl_putsys(
 		break;
 
 	case CS_PEERID:
-		if (sys_peer == NULL)
+		if (sys_vars.sys_peer == NULL)
 			ctl_putuint(sys_var[CS_PEERID].text, 0);
 		else
 			ctl_putuint(sys_var[CS_PEERID].text,
-				    sys_peer->associd);
+				    sys_vars.sys_peer->associd);
 		break;
 
 	case CS_PEERADR:
-		if (sys_peer != NULL && sys_peer->dstadr != NULL)
-			ss = sockporttoa(&sys_peer->srcadr);
+		if (sys_vars.sys_peer != NULL && sys_vars.sys_peer->dstadr != NULL)
+			ss = sockporttoa(&sys_vars.sys_peer->srcadr);
 		else
 			ss = "0.0.0.0:0";
 		ctl_putunqstr(sys_var[CS_PEERADR].text, ss, strlen(ss));
@@ -1536,8 +1536,8 @@ ctl_putsys(
 
 	case CS_PEERMODE: {
 		uint64_t u;
-		u = (sys_peer != NULL)
-			? sys_peer->hmode
+		u = (sys_vars.sys_peer != NULL)
+			? sys_vars.sys_peer->hmode
 			: MODE_UNSPEC;
 		ctl_putuint(sys_var[CS_PEERMODE].text, u);
 		break;
@@ -2037,7 +2037,7 @@ ctl_putsys(
 
 	case CS_ROOTDISTANCE:
 		ctl_putdbl(sys_var[CS_ROOTDISTANCE].text,
-			   sys_rootdist * MS_PER_S);
+			   sys_vars.sys_rootdist * MS_PER_S);
 		break;
 
         default:
@@ -4083,9 +4083,9 @@ read_clockstatus(
 		 * Find a clock for this jerk.	If the system peer
 		 * is a clock use it, else search peer_list for one.
 		 */
-		if (sys_peer != NULL && (FLAG_REFCLOCK &
-		    sys_peer->cfg.flags))
-			peer = sys_peer;
+		if (sys_vars.sys_peer != NULL && (FLAG_REFCLOCK &
+		    sys_vars.sys_peer->cfg.flags))
+			peer = sys_vars.sys_peer;
 		else
 			for (peer = peer_list;
 			     peer != NULL;


=====================================
ntpd/ntp_loopfilter.c
=====================================
--- a/ntpd/ntp_loopfilter.c
+++ b/ntpd/ntp_loopfilter.c
@@ -224,7 +224,7 @@ init_loopfilter(void)
 	 * Initialize state variables.
 	 */
 	sys_poll = ntp_minpoll;
-	clock_jitter = LOGTOD(sys_precision);
+	clock_jitter = LOGTOD(sys_vars.sys_precision);
 	freq_cnt = (int)clock_minstep;
 }
 
@@ -636,7 +636,7 @@ local_clock(
 			step_systime(fp_offset, ntp_set_tod);
 			reinit_timer();
 			tc_counter = 0;
-			clock_jitter = LOGTOD(sys_precision);
+			clock_jitter = LOGTOD(sys_vars.sys_precision);
 			rval = 2;
 			if (state == EVNT_NSET) {
 				rstclock(EVNT_FREQ, 0);
@@ -772,8 +772,8 @@ local_clock(
 				ntv.constant = 0;
 
 			ntv.esterror = (long)(clock_jitter * US_PER_S);
-			ntv.maxerror = (long)((sys_rootdelay / 2 +
-			    sys_rootdisp) * US_PER_S);
+			ntv.maxerror = (long)((sys_vars.sys_rootdelay / 2 +
+			    sys_vars.sys_rootdisp) * US_PER_S);
 			ntv.status = STA_PLL;
 
 			/*
@@ -792,9 +792,9 @@ local_clock(
 						pll_status,
 						ntv.status);
 			}
-			if (sys_leap == LEAP_ADDSECOND)
+			if (sys_vars.sys_leap == LEAP_ADDSECOND)
 				ntv.status |= STA_INS;
-			else if (sys_leap == LEAP_DELSECOND) ntv.status |= STA_DEL;
+			else if (sys_vars.sys_leap == LEAP_DELSECOND) ntv.status |= STA_DEL;
 		}
 
 		/*
@@ -933,7 +933,7 @@ adj_host_clock(
 	 * would be counterproductive. During the startup clamp period, the
 	 * time constant is clamped at 2.
 	 */
-	sys_rootdisp += clock_phi;
+	sys_vars.sys_rootdisp += clock_phi;
 #ifndef ENABLE_LOCKCLOCK
 	if (!ntp_enable || mode_ntpdate)
 		return;


=====================================
ntpd/ntp_peer.c
=====================================
--- a/ntpd/ntp_peer.c
+++ b/ntpd/ntp_peer.c
@@ -656,7 +656,7 @@ newpeer(
 	if ((MDF_BCAST & cast_flags) && peer->dstadr != NULL)
 		enable_broadcast(peer->dstadr, srcadr);
 
-	peer->precision = sys_precision;
+	peer->precision = sys_vars.sys_precision;
 	peer->hpoll = peer->cfg.minpoll;
 	if (cast_flags & MDF_POOL)
 		peer_clear(peer, "POOL", initializing1);


=====================================
ntpd/ntp_proto.c
=====================================
--- a/ntpd/ntp_proto.c
+++ b/ntpd/ntp_proto.c
@@ -97,16 +97,8 @@ typedef struct peer_select_tag {
  * System variables are declared here. Unless specified otherwise, all
  * times are in seconds.
  */
-uint8_t	sys_leap;		/* system leap indicator */
+struct system_variables sys_vars;
 static uint8_t	xmt_leap;		/* leap indicator sent in client requests */
-uint8_t	sys_stratum;		/* system stratum */
-int8_t	sys_precision;		/* local clock precision (log2 s) */
-double	sys_rootdelay;		/* roundtrip delay to primary source */
-double	sys_rootdisp;		/* dispersion to primary source */
-double	sys_rootdist;		/* only used fror Mode 6 export */
-uint32_t sys_refid;		/* reference id (network byte order) */
-l_fp	sys_reftime;		/* last update time */
-struct	peer *sys_peer;		/* current peer */
 
 #ifdef ENABLE_LEAP_SMEAR
 struct leap_smear_info leap_smear;
@@ -173,8 +165,8 @@ static	double	root_distance	(struct peer *);
 
 void
 set_sys_leap(unsigned char new_sys_leap) {
-	sys_leap = new_sys_leap;
-	xmt_leap = sys_leap;
+	sys_vars.sys_leap = new_sys_leap;
+	xmt_leap = sys_vars.sys_leap;
 
 	/*
 	 * Under certain conditions we send faked leap bits to clients, so
@@ -589,7 +581,7 @@ handle_procpkt(
 	    -scalbn((double)(peer->org - rbufp->pkt.rec), -32);
 	const double theta = (t21 + t34) / 2.;
 	const double delta = fabs(t21 - t34);
-	const double epsilon = LOGTOD(sys_precision) +
+	const double epsilon = LOGTOD(sys_vars.sys_precision) +
 	    LOGTOD(peer->precision) +
 	    clock_phi * delta;
 
@@ -828,7 +820,7 @@ transmit(
 	 */
 	if (peer->cast_flags & MDF_BCAST) {
 		peer->outdate = current_time;
-		if (sys_leap != LEAP_NOTINSYNC)
+		if (sys_vars.sys_leap != LEAP_NOTINSYNC)
 			peer_xmit(peer);
 		poll_update(peer, hpoll);
 		return;
@@ -986,19 +978,19 @@ clock_update(
 	 * Update the system state variables. We do this very carefully,
 	 * as the poll interval might need to be clamped differently.
 	 */
-	sys_peer = peer;
+	sys_vars.sys_peer = peer;
 	sys_epoch = peer->epoch;
 	if (sys_poll < peer->cfg.minpoll)
 		sys_poll = peer->cfg.minpoll;
 	if (sys_poll > peer->cfg.maxpoll)
 		sys_poll = peer->cfg.maxpoll;
 	poll_update(peer, sys_poll);
-	sys_stratum = min(peer->stratum + 1, STRATUM_UNSPEC);
+	sys_vars.sys_stratum = min(peer->stratum + 1, STRATUM_UNSPEC);
 	if (peer->stratum == STRATUM_REFCLOCK ||
 	    peer->stratum == STRATUM_UNSPEC)
-		sys_refid = peer->refid;
+		sys_vars.sys_refid = peer->refid;
 	else
-		sys_refid = addr2refid(&peer->srcadr);
+		sys_vars.sys_refid = addr2refid(&peer->srcadr);
 	/*
 	 * Root Dispersion (E) is defined (in RFC 5905) as:
 	 *
@@ -1024,11 +1016,11 @@ clock_update(
 		+ fabs(sys_offset);
 
 	if (dtemp > sys_mindisp)
-		sys_rootdisp = dtemp;
+		sys_vars.sys_rootdisp = dtemp;
 	else
-		sys_rootdisp = sys_mindisp;
-	sys_rootdelay = peer->delay + peer->rootdelay;
-	sys_reftime = peer->dst;
+		sys_vars.sys_rootdisp = sys_mindisp;
+	sys_vars.sys_rootdelay = peer->delay + peer->rootdelay;
+	sys_vars.sys_reftime = peer->dst;
 
 	DPRINT(1, ("clock_update: at %u sample %u associd %d\n",
 		   current_time, peer->epoch, peer->associd));
@@ -1070,12 +1062,12 @@ clock_update(
 	case 2:
 		clear_all();
 		set_sys_leap(LEAP_NOTINSYNC);
-		sys_stratum = STRATUM_UNSPEC;
-		memcpy(&sys_refid, "STEP", REFIDLEN);
-		sys_rootdelay = 0;
-		sys_rootdisp = 0;
-		sys_reftime = 0;
-		sys_jitter = LOGTOD(sys_precision);
+		sys_vars.sys_stratum = STRATUM_UNSPEC;
+		memcpy(&sys_vars.sys_refid, "STEP", REFIDLEN);
+		sys_vars.sys_rootdelay = 0;
+		sys_vars.sys_rootdisp = 0;
+		sys_vars.sys_reftime = 0;
+		sys_jitter = LOGTOD(sys_vars.sys_precision);
 		leapsec_reset_frame();
 		break;
 
@@ -1089,7 +1081,7 @@ clock_update(
 		 * leap bits. If crypto, the timer will goose the setup
 		 * process.
 		 */
-		if (sys_leap == LEAP_NOTINSYNC) {
+		if (sys_vars.sys_leap == LEAP_NOTINSYNC) {
 			set_sys_leap(LEAP_NOWARNING);
 			/*
 			 * If our parent process is waiting for the
@@ -1250,7 +1242,7 @@ peer_clear(
 	peer->hpoll = peer->cfg.minpoll;
 	peer->disp = sys_maxdisp;
 	peer->flash = peer_unfit(peer);
-	peer->jitter = LOGTOD(sys_precision);
+	peer->jitter = LOGTOD(sys_vars.sys_precision);
 
 	for (u = 0; u < NTP_SHIFT; u++) {
 		peer->filter_order[u] = u;
@@ -1474,7 +1466,7 @@ clock_filter(
 	DPRINT(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)
+	if (peer->burst == 0 || sys_vars.sys_leap == LEAP_NOTINSYNC)
 		clock_select();
 }
 
@@ -1522,12 +1514,12 @@ clock_select(void)
 	 * Initialize and create endpoint, index and peer lists big
 	 * enough to handle all associations.
 	 */
-	osys_peer = sys_peer;
+	osys_peer = sys_vars.sys_peer;
 	sys_survivors = 0;
 #ifdef ENABLE_LOCKCLOCK
 	set_sys_leap(LEAP_NOTINSYNC);
-	sys_stratum = STRATUM_UNSPEC;
-	memcpy(&sys_refid, "DOWN", REFIDLEN);
+	sys_vars.sys_stratum = STRATUM_UNSPEC;
+	memcpy(&sys_vars.sys_refid, "DOWN", REFIDLEN);
 #endif /* ENABLE_LOCKCLOCK */
 
 	/*
@@ -1948,7 +1940,7 @@ clock_select(void)
 			typesystem->new_status = CTL_PST_SEL_SYSPEER;
 			sys_offset = typesystem->offset;
 			sys_jitter = typesystem->jitter;
-			sys_rootdist = root_distance(typesystem);
+			sys_vars.sys_rootdist = root_distance(typesystem);
 		}
 		DPRINT(1, ("select: combine offset %.9f jitter %.9f\n",
 			   sys_offset, sys_jitter));
@@ -1970,7 +1962,7 @@ clock_select(void)
 		typesystem->new_status = CTL_PST_SEL_PPS;
 		sys_offset = typesystem->offset;
 		sys_jitter = typesystem->jitter;
-		sys_rootdist = root_distance(typesystem);
+		sys_vars.sys_rootdist = root_distance(typesystem);
 		DPRINT(1, ("select: pps offset %.9f jitter %.9f\n",
 			   sys_offset, sys_jitter));
 	} else if ( typepps &&
@@ -1991,7 +1983,7 @@ clock_select(void)
 			    orphwait = current_time + (unsigned long)sys_orphwait;
 			report_event(EVNT_NOPEER, NULL, NULL);
 		}
-		sys_peer = NULL;
+		sys_vars.sys_peer = NULL;
 		for (peer = peer_list; peer != NULL; peer = peer->p_link)
 			peer->status = peer->new_status;
 		return;
@@ -2035,7 +2027,7 @@ clock_combine(
 	}
 	sys_offset = z / y;
 	sys_jitter = SQRT(w / y + SQUARE(peers[syspeer].seljit));
-	sys_rootdist = peers[syspeer].synch;
+	sys_vars.sys_rootdist = peers[syspeer].synch;
 }
 
 
@@ -2069,7 +2061,7 @@ root_distance(
 	 */
 	dtemp = (peer->delay + peer->rootdelay) / 2
 		+ LOGTOD(peer->precision)
-		  + LOGTOD(sys_precision)
+		  + LOGTOD(sys_vars.sys_precision)
 		  + clock_phi * (current_time - peer->update)
 		+ peer->rootdisp
 		+ peer->jitter;
@@ -2102,15 +2094,15 @@ peer_xmit(
 	if (!peer->dstadr)	/* drop peers without interface */
 		return;
 
-	xpkt.li_vn_mode = PKT_LI_VN_MODE(sys_leap, peer->cfg.version,
+	xpkt.li_vn_mode = PKT_LI_VN_MODE(sys_vars.sys_leap, peer->cfg.version,
 	    peer->hmode);
-	xpkt.stratum = STRATUM_TO_PKT(sys_stratum);
+	xpkt.stratum = STRATUM_TO_PKT(sys_vars.sys_stratum);
 	xpkt.ppoll = peer->hpoll;
-	xpkt.precision = sys_precision;
-	xpkt.refid = sys_refid;
-	xpkt.rootdelay = HTONS_FP(DTOUFP(sys_rootdelay));
-	xpkt.rootdisp =	 HTONS_FP(DTOUFP(sys_rootdisp));
-	xpkt.reftime = htonl_fp(sys_reftime);
+	xpkt.precision = sys_vars.sys_precision;
+	xpkt.refid = sys_vars.sys_refid;
+	xpkt.rootdelay = HTONS_FP(DTOUFP(sys_vars.sys_rootdelay));
+	xpkt.rootdisp =	 HTONS_FP(DTOUFP(sys_vars.sys_rootdisp));
+	xpkt.reftime = htonl_fp(sys_vars.sys_reftime);
 	xpkt.org = htonl_fp(peer->xmt);
 	xpkt.rec = htonl_fp(peer->dst);
 
@@ -2257,17 +2249,17 @@ fast_xmit(
 		 * reftime to make sure the reftime isn't later than
 		 * the transmit/receive times.
 		 */
-		xpkt.li_vn_mode = PKT_LI_VN_MODE(sys_leap,
+		xpkt.li_vn_mode = PKT_LI_VN_MODE(sys_vars.sys_leap,
 		    PKT_VERSION(rbufp->pkt.li_vn_mode), xmode);
-		xpkt.stratum = STRATUM_TO_PKT(sys_stratum);
+		xpkt.stratum = STRATUM_TO_PKT(sys_vars.sys_stratum);
 		xpkt.ppoll = max(rbufp->pkt.ppoll, ntp_minpoll);
-		xpkt.precision = sys_precision;
-		xpkt.refid = sys_refid;
-		xpkt.rootdelay = HTONS_FP(DTOUFP(sys_rootdelay));
-		xpkt.rootdisp = HTONS_FP(DTOUFP(sys_rootdisp));
+		xpkt.precision = sys_vars.sys_precision;
+		xpkt.refid = sys_vars.sys_refid;
+		xpkt.rootdelay = HTONS_FP(DTOUFP(sys_vars.sys_rootdelay));
+		xpkt.rootdisp = HTONS_FP(DTOUFP(sys_vars.sys_rootdisp));
 
 #ifdef ENABLE_LEAP_SMEAR
-		this_ref_time = sys_reftime;
+		this_ref_time = sys_vars.sys_reftime;
 		if (leap_smear.in_progress) {
 			leap_smear_add_offs(&this_ref_time, NULL);
 			xpkt.refid = convertLFPToRefID(leap_smear.offset);
@@ -2278,7 +2270,7 @@ fast_xmit(
 		}
 		xpkt.reftime = htonl_fp(this_ref_time);
 #else
-		xpkt.reftime = htonl_fp(sys_reftime);
+		xpkt.reftime = htonl_fp(sys_vars.sys_reftime);
 #endif
 
 		xpkt.org.l_ui = htonl(rbufp->pkt.xmt >> 32);
@@ -2633,7 +2625,7 @@ measure_precision(const bool verbose)
 	set_sys_tick_precision(measured_tick);
 	if (verbose) {
 		msyslog(LOG_INFO, "INIT: precision = %.3f usec (%d)",
-			sys_tick * US_PER_S, sys_precision);
+			sys_tick * US_PER_S, sys_vars.sys_precision);
 		if (sys_fuzz < sys_tick) {
 			msyslog(LOG_NOTICE, "INIT: fuzz beneath %.3f usec",
 				sys_fuzz * US_PER_S);
@@ -2732,7 +2724,7 @@ set_sys_tick_precision(
 	if (tick - 1 > 1 - tick / 2)
 		i++;
 
-	sys_precision = (int8_t)i;
+	sys_vars.sys_precision = (int8_t)i;
 }
 
 
@@ -2748,13 +2740,13 @@ init_proto(const bool verbose)
 	 * Fill in the sys_* stuff.  Default is don't listen to
 	 * broadcasting, require authentication.
 	 */
-	sys_leap = LEAP_NOTINSYNC;
-	sys_stratum = STRATUM_UNSPEC;
-	memcpy(&sys_refid, "INIT", REFIDLEN);
-	sys_peer = NULL;
-	sys_rootdelay = 0;
-	sys_rootdisp = 0;
-	sys_reftime = 0;
+	sys_vars.sys_leap = LEAP_NOTINSYNC;
+	sys_vars.sys_stratum = STRATUM_UNSPEC;
+	memcpy(&sys_vars.sys_refid, "INIT", REFIDLEN);
+	sys_vars.sys_peer = NULL;
+	sys_vars.sys_rootdelay = 0;
+	sys_vars.sys_rootdisp = 0;
+	sys_vars.sys_reftime = 0;
 	sys_jitter = 0;
 	measure_precision(verbose);
 	get_systime(&dummy);


=====================================
ntpd/ntp_refclock.c
=====================================
--- a/ntpd/ntp_refclock.c
+++ b/ntpd/ntp_refclock.c
@@ -539,9 +539,9 @@ refclock_receive(
 		return;
 
 	clock_filter(peer, pp->offset, 0., pp->jitter);
-	if (cal_enable && fabs(last_offset) < sys_mindisp && sys_peer !=
+	if (cal_enable && fabs(last_offset) < sys_mindisp && sys_vars.sys_peer !=
 	    NULL) {
-		if (sys_peer->is_pps_driver &&
+		if (sys_vars.sys_peer->is_pps_driver &&
 		    !peer->is_pps_driver)
 			pp->fudgetime1 -= pp->offset * FUDGEFAC;
 	}
@@ -1027,7 +1027,7 @@ refclock_catcher(
 	if (ap->handle == 0)
 		return PPS_SETUP;
 
-	if (ap->pps_params.mode == 0 && sys_leap != LEAP_NOTINSYNC) {
+	if (ap->pps_params.mode == 0 && sys_vars.sys_leap != LEAP_NOTINSYNC) {
 		if (refclock_params(pp->sloppyclockflag, ap) < 1)
 			return PPS_SETUP;
 	}


=====================================
ntpd/ntp_timer.c
=====================================
--- a/ntpd/ntp_timer.c
+++ b/ntpd/ntp_timer.c
@@ -228,19 +228,19 @@ timer(void)
 	 * synchronization source is an orphan. It shows offset zero and
 	 * reference ID the loopback address.
 	 */
-	if (sys_orphan < STRATUM_UNSPEC && sys_peer == NULL &&
+	if (sys_orphan < STRATUM_UNSPEC && sys_vars.sys_peer == NULL &&
 	    current_time > orphwait) {
-		if (sys_leap == LEAP_NOTINSYNC) {
-			sys_leap = LEAP_NOWARNING;
+		if (sys_vars.sys_leap == LEAP_NOTINSYNC) {
+			sys_vars.sys_leap = LEAP_NOWARNING;
 		}
-		sys_stratum = (uint8_t)sys_orphan;
-		if (sys_stratum > 1)
-			sys_refid = htonl(LOOPBACKADR);
+		sys_vars.sys_stratum = (uint8_t)sys_orphan;
+		if (sys_vars.sys_stratum > 1)
+			sys_vars.sys_refid = htonl(LOOPBACKADR);
 		else
-			memcpy(&sys_refid, "LOOP", REFIDLEN);
+			memcpy(&sys_vars.sys_refid, "LOOP", REFIDLEN);
 		sys_offset = 0;
-		sys_rootdelay = 0;
-		sys_rootdisp = 0;
+		sys_vars.sys_rootdelay = 0;
+		sys_vars.sys_rootdisp = 0;
 	}
 
 	time(&now);
@@ -250,15 +250,15 @@ timer(void)
 	 * is imminent or every 8th second.
 	 */
 	if (leapsec > LSPROX_NOWARN || 0 == (current_time & 7))
-		check_leapsec(now, (sys_leap == LEAP_NOTINSYNC));
-	if (sys_leap != LEAP_NOTINSYNC) {
+		check_leapsec(now, (sys_vars.sys_leap == LEAP_NOTINSYNC));
+	if (sys_vars.sys_leap != LEAP_NOTINSYNC) {
 		if (leapsec >= LSPROX_ANNOUNCE && leapdif) {
 			if (leapdif > 0)
-				sys_leap = LEAP_ADDSECOND;
+				sys_vars.sys_leap = LEAP_ADDSECOND;
 			else
-				sys_leap = LEAP_DELSECOND;
+				sys_vars.sys_leap = LEAP_DELSECOND;
 		} else {
-			sys_leap = LEAP_NOWARNING;
+			sys_vars.sys_leap = LEAP_NOWARNING;
 		}
 	}
 
@@ -351,7 +351,7 @@ check_leap_sec_in_progress( const leap_result_t *lsdata ) {
 
 	/* if changed we may have to update the leap status sent to clients */
 	if (leap_sec_in_progress != prv_leap_sec_in_progress)
-		set_sys_leap(sys_leap);
+		set_sys_leap(sys_vars.sys_leap);
 }
 
 static void
@@ -492,7 +492,7 @@ check_leapsec(
 		if (  leapsec < LSPROX_SCHEDULE
 		   && lsprox >= LSPROX_SCHEDULE) {
 			if (lsdata.dynamic)
-				report_event(PEVNT_ARMED, sys_peer, NULL);
+				report_event(PEVNT_ARMED, sys_vars.sys_peer, NULL);
 			else
 				report_event(EVNT_ARMED, NULL, NULL);
 		}


=====================================
ntpd/refclock_generic.c
=====================================
--- a/ntpd/refclock_generic.c
+++ b/ntpd/refclock_generic.c
@@ -2604,7 +2604,7 @@ parse_start(
 
 	peer->rootdelay       = parse->parse_type->cl_rootdelay;
 	peer->sstclktype      = parse->parse_type->cl_type;
-	peer->precision       = sys_precision;
+	peer->precision       = sys_vars.sys_precision;
 
 	peer->stratum         = STRATUM_REFCLOCK;
 


=====================================
ntpd/refclock_local.c
=====================================
--- a/ntpd/refclock_local.c
+++ b/ntpd/refclock_local.c
@@ -100,7 +100,7 @@ local_start(
 	/*
 	 * Initialize miscellaneous variables
 	 */
-	peer->precision = sys_precision;
+	peer->precision = sys_vars.sys_precision;
 	pp->leap = LEAP_NOTINSYNC;
 	peer->stratum = STRATUM;
 	pp->stratum = STRATUM;
@@ -138,7 +138,7 @@ local_poll(
 	/*
 	 * Do no evil unless the house is dark or lit with our own lamp.
 	 */
-	if (!(sys_peer == NULL || sys_peer == peer))
+	if (!(sys_vars.sys_peer == NULL || sys_vars.sys_peer == peer))
 		return;
 
 	pp = peer->procptr;


=====================================
ntpd/refclock_modem.c
=====================================
--- a/ntpd/refclock_modem.c
+++ b/ntpd/refclock_modem.c
@@ -678,7 +678,7 @@ modem_poll(
 	 * as either no peers are available or this peer is selected.
 	 */
 	case MODE_BACKUP:
-		if (!(sys_peer == NULL || sys_peer == peer))
+		if (!(sys_vars.sys_peer == NULL || sys_vars.sys_peer == peer))
 			return;
 
 		break;


=====================================
ntpd/refclock_nmea.c
=====================================
--- a/ntpd/refclock_nmea.c
+++ b/ntpd/refclock_nmea.c
@@ -761,7 +761,7 @@ refclock_ppsrelate(
 	*rd_fudge = pp_fudge;
 
 	/* if whole system out-of-sync, do not try to PLL */
-	if (sys_leap == LEAP_NOTINSYNC)
+	if (sys_vars.sys_leap == LEAP_NOTINSYNC)
 		return PPS_RELATE_EDGE; /* cannot PLL with pps code */
 
 	/* check against reftime if PPS PLL can be used */


=====================================
ntpd/refclock_pps.c
=====================================
--- a/ntpd/refclock_pps.c
+++ b/ntpd/refclock_pps.c
@@ -240,7 +240,7 @@ pps_poll(
 	 * Don't wiggle the clock until some other driver has numbered
 	 * the seconds.
 	 */
-	if (sys_leap == LEAP_NOTINSYNC) {
+	if (sys_vars.sys_leap == LEAP_NOTINSYNC) {
 		pp->codeproc = pp->coderecv;  // xxx ??
 		up->pcount = up->scount = up->kcount = up->rcount = 0;
 		return;



View it on GitLab: https://gitlab.com/NTPsec/ntpsec/commit/6a50a53fb6dd1a87e3d0bd3769f9d15abc0535b3

-- 
View it on GitLab: https://gitlab.com/NTPsec/ntpsec/commit/6a50a53fb6dd1a87e3d0bd3769f9d15abc0535b3
You're receiving this email because of your account on gitlab.com.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.ntpsec.org/pipermail/vc/attachments/20180520/d19b77a8/attachment.html>


More information about the vc mailing list