Reorganize ntp5 code

Author: beevik

ntp.go

@@ -390,7 +390,7 @@ type TimescaleOffset struct {
 // correction value (i.e., OriginDelay or ReturnDelay) is not representable.
 // This occurs when a correction exceeds the maximum value representable by
 // NTP's correction timestamp format.
-var DelayUnrepresentable = time.Duration(math.MaxInt64)
+var DelayUnrepresentable = time.Duration(math.MinInt64)
 
 // The Correction struct contains delay correction information provided by
 // network switches and routers along the path between the client and the

ntp4_test.go

@@ -16,17 +16,17 @@ import (
 
 func logResponseV4(t *testing.T, r *Response) {
 	now := time.Now()
+	t.Logf("[%s]     Version: %d", host, r.Version)
 	t.Logf("[%s] ClockOffset: %s", host, r.ClockOffset)
+	t.Logf("[%s]         RTT: %s", host, r.RTT)
 	t.Logf("[%s]  SystemTime: %s", host, fmtTime(now))
 	t.Logf("[%s]   ~TrueTime: %s", host, fmtTime(now.Add(r.ClockOffset)))
 	t.Logf("[%s]    XmitTime: %s", host, fmtTime(r.Time))
-	t.Logf("[%s]     Version: %d", host, r.Version)
 	t.Logf("[%s]     Stratum: %d", host, r.Stratum)
 	t.Logf("[%s]        Leap: %s", host, fmtLeapIndicator(r.Leap))
 	t.Logf("[%s]       Flags: %s", host, fmtResponseFlags(r.Flags))
 	t.Logf("[%s]       RefID: %s (0x%08x)", host, r.ReferenceString(), r.ReferenceID)
 	t.Logf("[%s]     RefTime: %s", host, fmtTime(r.ReferenceTime))
-	t.Logf("[%s]         RTT: %s", host, r.RTT)
 	t.Logf("[%s]        Poll: %s", host, r.Poll)
 	t.Logf("[%s]   Precision: %s", host, r.Precision)
 	t.Logf("[%s]   RootDelay: %s", host, r.RootDelay)

ntp5.go

@@ -258,12 +258,20 @@ func queryV5(conn net.Conn, opt *QueryOptions) (*Response, error) {
 	if err != nil {
 		return nil, err
 	}
+	recvBuf = recvBuf[:n]
 
 	// Keep track of the time the response message was received.
 	clientRecvTime := opt.GetSystemTime()
 
+	// Allow package extensions to process the response message.
+	for i := len(opt.Extensions) - 1; i >= 0; i-- {
+		err = opt.Extensions[i].ProcessResponse(recvBuf)
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	// Parse the response message.
-	recvBuf = recvBuf[:n]
 	m, err := parseV5Response(recvBuf)
 	if err != nil {
 		return nil, err
@@ -280,29 +288,22 @@ func queryV5(conn net.Conn, opt *QueryOptions) (*Response, error) {
 		return nil, ErrServerResponseMismatch
 	}
 
-	// Prepare the response struct.
-	r := &Response{
-		Version: 5,
-	}
-
-	// Check for an authentication NAK.
-	if m.Flags&flagAuthNAK != 0 {
-		r.authErr = ErrAuthNAK
-	}
-
-	// Convert timestamps.
+	// Convert timestamps to times.
 	serverRecvTime := timestamp(m.ReceiveTime).Time(m.Era)
 	serverXmitTime := timestamp(m.TransmitTime).Time(m.Era)
 
-	// Start filling in response fields.
-	r.Time = serverXmitTime
-	r.Precision = toInterval(m.Precision)
-	r.Stratum = m.Stratum
-	r.Leap = m.getLeap()
-	r.Poll = toInterval(m.Poll)
-	r.Timescale = Timescale(m.Timescale)
-	r.Era = m.Era
-	r.ServerCookie = m.ServerCookie
+	// Prepare the response struct.
+	r := &Response{
+		Time:         serverXmitTime,
+		Precision:    toInterval(m.Precision),
+		Version:      5,
+		Stratum:      m.Stratum,
+		Timescale:    Timescale(m.Timescale),
+		Era:          m.Era,
+		Leap:         m.getLeap(),
+		Poll:         toInterval(m.Poll),
+		ServerCookie: m.ServerCookie,
+	}
 
 	// Determine response flags.
 	if m.Flags&flagSynchronized != 0 {
@@ -312,36 +313,24 @@ func queryV5(conn net.Conn, opt *QueryOptions) (*Response, error) {
 		r.Flags |= FlagInterleaved
 	}
 
-	// Assign brief timestamp and correction variables for readability (will
-	// be optimized away).
+	// Check for an authentication NAK.
+	if m.Flags&flagAuthNAK != 0 {
+		r.authErr = ErrAuthNAK
+	}
+
+	// Assign brief timestamp variables for readability (will be optimized
+	// away).
 	t1 := clientXmitTime
 	t2 := serverRecvTime
 	t3 := serverXmitTime
 	t4 := clientRecvTime
-	c0 := r.Correction.OriginDelay
-	c1 := r.Correction.ReturnDelay
-
-	// Handle unrepresentable or negative delay corrections by ignoring them.
-	validCorrection := true
-	if c0 == DelayUnrepresentable || c1 == DelayUnrepresentable || c0 < 0 || c1 < 0 {
-		validCorrection = false
-	}
 
 	// Calculate the uncorrected clock offset.
 	r.ClockOffset = (t2.Sub(t1) + t3.Sub(t4)) / 2
 
 	// Calculate the uncorrected round-trip time.
 	r.RTT = max(t4.Sub(t1)-t3.Sub(t2), 0)
 
-	// If valid correction values are present, adjust the offset and RTT.
-	if validCorrection {
-		rtt := r.RTT - time.Duration(float64(c0+c1)*(1.0-maxFrequencyError))
-		if rtt >= 0 {
-			r.RTT = rtt
-			r.ClockOffset += (c1 - c0) / 2
-		}
-	}
-
 	// Calculate root dispersion and distance.
 	r.RootDelay = m.RootDelay.Duration()
 	r.RootDispersion = m.RootDisp.Duration()
@@ -399,6 +388,15 @@ func queryV5(conn net.Conn, opt *QueryOptions) (*Response, error) {
 			r.Correction.OriginPathID = binary.BigEndian.Uint16(body[8:10])
 			r.Correction.ReturnDelay = timeCorrectionV5(binary.BigEndian.Uint64(body[12:20])).Duration()
 			r.Correction.ReturnPathID = binary.BigEndian.Uint16(body[20:22])
+			c0 := r.Correction.OriginDelay
+			c1 := r.Correction.ReturnDelay
+			if c0 >= 0 && c1 >= 0 {
+				rtt := r.RTT - time.Duration(float64(c0+c1)*(1.0-maxFrequencyError))
+				if rtt >= 0 {
+					r.RTT = rtt
+					r.ClockOffset += (c1 - c0) / 2
+				}
+			}
 
 		case extRefTimestamp:
 			if len(body) != 8 {
@@ -435,14 +433,6 @@ func queryV5(conn net.Conn, opt *QueryOptions) (*Response, error) {
 		curr = recvBuf[offset:]
 	}
 
-	// Allow package extensions to process the response.
-	for i := len(opt.Extensions) - 1; i >= 0; i-- {
-		err = opt.Extensions[i].ProcessResponse(recvBuf)
-		if err != nil {
-			return nil, err
-		}
-	}
-
 	return r, r.authErr
 }
 

ntp5_test.go

@@ -20,11 +20,12 @@ import (
 
 func logResponseV5(t *testing.T, r *Response) {
 	now := time.Now()
+	t.Logf("[%s]     Version: %d", host, r.Version)
 	t.Logf("[%s] ClockOffset: %s", host, r.ClockOffset)
+	t.Logf("[%s]         RTT: %s", host, r.RTT)
 	t.Logf("[%s]  SystemTime: %s", host, fmtTime(now))
 	t.Logf("[%s]   ~TrueTime: %s", host, fmtTime(now.Add(r.ClockOffset)))
 	t.Logf("[%s]    XmitTime: %s", host, fmtTime(r.Time))
-	t.Logf("[%s]     Version: %d", host, r.Version)
 	t.Logf("[%s]     Stratum: %d", host, r.Stratum)
 	t.Logf("[%s]        Leap: %s", host, fmtLeapIndicator(r.Leap))
 	t.Logf("[%s]       Flags: %s", host, fmtResponseFlags(r.Flags))
@@ -36,7 +37,6 @@ func logResponseV5(t *testing.T, r *Response) {
 	t.Logf("[%s]  MonoOffset: %s", host, r.MonotonicOffset)
 	t.Logf("[%s]   MonoEpoch: %s", host, fmtEpoch(r.MonotonicEpochID))
 	t.Logf("[%s]   Supported: %v", host, r.SupportedVersions)
-	t.Logf("[%s]         RTT: %s", host, r.RTT)
 	t.Logf("[%s]        Poll: %s", host, r.Poll)
 	t.Logf("[%s]  CorrDelay0: %s", host, r.Correction.OriginDelay)
 	t.Logf("[%s]   CorrPath0: 0x%08x", host, r.Correction.OriginPathID)