Update NEWS

Add random bits below clock precision to the timestamp to make
it less predictable.

NEWS

@@ -4,13 +4,16 @@ New in version 1.27
 * Support for stronger keys via NSS or libtomcrypt library
 * Support reading leap second data from tz database
 * Support for precise clock stepping on Linux
+* Support for nanoseconds in SHM refclock
 * Make offset corrections smoother on Linux
+* Make transmit timestamps random below clock precision
 * Add corrtimeratio and maxchange directives
 * Extend tracking, sources and activity reports
 * Wait in foreground process until daemon is fully initialized
 * Fix crash with slow name resolving
 * Fix iburst with jittery sources
 * Fix offset stored in rtc data right after trimrtc
+* Fix crash and hang with RTC or manual samples
 * Don't use readonly adjtime on Linux kernels before 2.6.28 
 * Changed chronyc protocol, incompatible with older versions
 

acquire.c

@@ -256,6 +256,7 @@ probe_source(SourceRecord *src)
   union sockaddr_in46 his_addr;
   int sock_fd;
   socklen_t addrlen;
+  uint32_t ts_fuzz;
 
 #if 0
   printf("Sending probe to %s sent=%d samples=%d\n", UTI_IPToString(&src->ip_addr), src->n_probes_sent, src->n_samples);
@@ -304,8 +305,9 @@ probe_source(SourceRecord *src)
   }
 
 
+  ts_fuzz = UTI_GetNTPTsFuzz(LCL_GetSysPrecisionAsLog());
   LCL_ReadCookedTime(&cooked, NULL);
-  UTI_TimevalToInt64(&cooked, &pkt.transmit_ts);
+  UTI_TimevalToInt64(&cooked, &pkt.transmit_ts, ts_fuzz);
 
   if (sendto(sock_fd, (void *) &pkt, NTP_NORMAL_PACKET_SIZE,
              0,

broadcast.c

@@ -73,7 +73,7 @@ timeout_handler(void *arbitrary)
   int leap;
   int are_we_synchronised, our_stratum;
   NTP_Leap leap_status;
-  uint32_t our_ref_id;
+  uint32_t our_ref_id, ts_fuzz;
   struct timeval our_ref_time;
   double our_root_delay, our_root_dispersion;
   struct timeval local_transmit;
@@ -107,14 +107,15 @@ timeout_handler(void *arbitrary)
   message.reference_id = htonl((NTP_int32) our_ref_id);
 
   /* Now fill in timestamps */
-  UTI_TimevalToInt64(&our_ref_time, &message.reference_ts);
+  UTI_TimevalToInt64(&our_ref_time, &message.reference_ts, 0);
   message.originate_ts.hi = 0UL;
   message.originate_ts.lo = 0UL;
   message.receive_ts.hi = 0UL;
   message.receive_ts.lo = 0UL;
 
+  ts_fuzz = UTI_GetNTPTsFuzz(message.precision);
   LCL_ReadCookedTime(&local_transmit, NULL);
-  UTI_TimevalToInt64(&local_transmit, &message.transmit_ts);
+  UTI_TimevalToInt64(&local_transmit, &message.transmit_ts, ts_fuzz);
   NIO_SendNormalPacket(&message, &d->addr);
 
   /* Requeue timeout.  Don't care if interval drifts gradually, so just do it

chrony.texi

@@ -2468,7 +2468,7 @@ Some examples of applications that can be used as SHM sources are @code{gpsd},
 @item SOCK
 Unix domain socket driver.  It is similar to the SHM driver, but uses a
 different format and uses a socket instead of shared memory.  It does not
-require polling, the offset resolution is not limited to microseconds and it
+require polling and it
 supports transmitting of PPS data.  The parameter is a path to the socket which
 will be created by @code{chronyd} and used to receive the messages.  The format
 of messages sent over the socket is described in the

client.c

@@ -127,7 +127,7 @@ read_line(void)
     }
     return( line );
 #else
-    printf(prompt);
+    printf("%s", prompt);
 #endif
   }
   if (fgets(line, sizeof(line), stdin)) {
@@ -2849,7 +2849,10 @@ main(int argc, char **argv)
 
   /* MD5 is the default authentication hash */
   auth_hash_id = HSH_GetHashId("MD5");
-  assert(auth_hash_id >= 0);
+  if (auth_hash_id < 0) {
+    fprintf(stderr, "Could not initialize MD5\n");
+    return 1;
+  }
   
   open_io(hostname, port);
 

configure

@@ -8,7 +8,7 @@
 #
 # =======================================================================
 
-rm -f config.h
+rm -f config.h config.log
 
 # This configure script determines the operating system type and version
 
@@ -43,7 +43,7 @@ test_code () {
   ldflags=$4
   code=$5
 
-  printf "Checking for $name : "
+  echo -n "Checking for $name : "
 
   (
     for h in $headers; do
@@ -54,16 +54,23 @@ test_code () {
     echo "return 0; }"
   ) > docheck.c
 
-  $MYCC $MYCFLAGS $MYCPPFLAGS $cflags -o docheck docheck.c $ldflags $MYLDFLAGS >/dev/null 2>&1
+  echo "docheck.c:" >> config.log
+  cat docheck.c >> config.log
+  echo $MYCC $MYCFLAGS $MYCPPFLAGS $cflags -o docheck docheck.c $ldflags \
+    $MYLDFLAGS >> config.log
+  $MYCC $MYCFLAGS $MYCPPFLAGS $cflags -o docheck docheck.c $ldflags \
+    $MYLDFLAGS >> config.log 2>&1
+
   if [ $? -eq 0 ]
   then
-    printf "Yes\n"
+    echo "Yes"
     result=0
   else
-    printf "No\n"
+    echo "No"
     result=1
   fi
   rm -f docheck.c docheck
+  echo >> config.log
   return $result
 }
 #}}}
@@ -354,7 +361,7 @@ else
   if test_code 'math in -lm' 'math.h' '' '-lm' "$MATHCODE"; then
     LIBS="-lm"
   else
-    printf "Can't compile/link a program which uses sqrt(), log(), pow(), bailing out\n"
+    echo "Can't compile/link a program which uses sqrt(), log(), pow(), bailing out"
     exit 1
   fi
 fi

ntp_core.c

@@ -419,7 +419,7 @@ transmit_packet(NTP_Mode my_mode, /* The mode this machine wants to be */
   /* Parameters read from reference module */
   int are_we_synchronised, our_stratum;
   NTP_Leap leap_status;
-  uint32_t our_ref_id;
+  uint32_t our_ref_id, ts_fuzz;
   struct timeval our_ref_time;
   double our_root_delay, our_root_dispersion;
 
@@ -458,7 +458,7 @@ transmit_packet(NTP_Mode my_mode, /* The mode this machine wants to be */
   message.reference_id = htonl((NTP_int32) our_ref_id);
 
   /* Now fill in timestamps */
-  UTI_TimevalToInt64(&our_ref_time, &message.reference_ts);
+  UTI_TimevalToInt64(&our_ref_time, &message.reference_ts, 0);
 
   /* Originate - this comes from the last packet the source sent us */
   message.originate_ts = *orig_ts;
@@ -467,7 +467,10 @@ transmit_packet(NTP_Mode my_mode, /* The mode this machine wants to be */
      This timestamp will have been adjusted so that it will now look to
      the source like we have been running on our latest estimate of
      frequency all along */
-  UTI_TimevalToInt64(local_rx, &message.receive_ts);
+  UTI_TimevalToInt64(local_rx, &message.receive_ts, 0);
+
+  /* Prepare random bits which will be added to the transmit timestamp. */
+  ts_fuzz = UTI_GetNTPTsFuzz(message.precision);
 
   /* Transmit - this our local time right now!  Also, we might need to
      store this for our own use later, next time we receive a message
@@ -481,7 +484,7 @@ transmit_packet(NTP_Mode my_mode, /* The mode this machine wants to be */
        take to generate the authentication data. */
     local_transmit.tv_usec += KEY_GetAuthDelay(key_id);
     UTI_NormaliseTimeval(&local_transmit);
-    UTI_TimevalToInt64(&local_transmit, &message.transmit_ts);
+    UTI_TimevalToInt64(&local_transmit, &message.transmit_ts, ts_fuzz);
 
     auth_len = KEY_GenerateAuth(key_id, (unsigned char *) &message,
         offsetof(NTP_Packet, auth_keyid),
@@ -492,7 +495,7 @@ transmit_packet(NTP_Mode my_mode, /* The mode this machine wants to be */
           sizeof (message.auth_keyid) + auth_len);
     }
   } else {
-    UTI_TimevalToInt64(&local_transmit, &message.transmit_ts);
+    UTI_TimevalToInt64(&local_transmit, &message.transmit_ts, ts_fuzz);
     NIO_SendNormalPacket(&message, where_to);
   }
 

refclock.c

@@ -452,7 +452,7 @@ RCL_AddPulse(RCL_Instance instance, struct timeval *pulse_time, double second)
   filter_add_sample(&instance->filter, &cooked_time, offset, dispersion);
   instance->leap_status = LEAP_Normal;
 
-  log_sample(instance, &cooked_time, 0, 1, second, offset, dispersion);
+  log_sample(instance, &cooked_time, 0, 1, offset + correction - instance->offset, offset, dispersion);
 
   /* for logging purposes */
   if (!instance->driver->poll)

refclock_shm.c

@@ -45,7 +45,7 @@ struct shmTime {
                 *         use values 
                 *       clear valid
                 */
-  int    count;
+  volatile int count;
   time_t clockTimeStampSec;
   int    clockTimeStampUSec;
   time_t receiveTimeStampSec;
@@ -53,8 +53,10 @@ struct shmTime {
   int    leap;
   int    precision;
   int    nsamples;
-  int    valid;
-  int    dummy[10]; 
+  volatile int valid;
+  int    clockTimeStampNSec;
+  int    receiveTimeStampNSec;
+  int    dummy[8]; 
 };
 
 static int shm_initialise(RCL_Instance instance) {
@@ -89,7 +91,7 @@ static void shm_finalise(RCL_Instance instance)
 
 static int shm_poll(RCL_Instance instance)
 {
-  struct timeval tv1, tv2;
+  struct timeval tv;
   struct shmTime t, *shm;
   double offset;
 
@@ -107,13 +109,17 @@ static int shm_poll(RCL_Instance instance)
 
   shm->valid = 0;
 
-  tv1.tv_sec = t.receiveTimeStampSec;
-  tv1.tv_usec = t.receiveTimeStampUSec;
-  tv2.tv_sec = t.clockTimeStampSec;
-  tv2.tv_usec = t.clockTimeStampUSec;
+  tv.tv_sec = t.receiveTimeStampSec;
+  tv.tv_usec = t.receiveTimeStampUSec;
 
-  UTI_DiffTimevalsToDouble(&offset, &tv2, &tv1);
-  return RCL_AddSample(instance, &tv1, offset, t.leap);
+  offset = t.clockTimeStampSec - t.receiveTimeStampSec;
+  if (t.clockTimeStampNSec / 1000 == t.clockTimeStampUSec &&
+      t.receiveTimeStampNSec / 1000 == t.receiveTimeStampUSec)
+    offset += (t.clockTimeStampNSec - t.receiveTimeStampNSec) * 1e-9;
+  else
+    offset += (t.clockTimeStampUSec - t.receiveTimeStampUSec) * 1e-6;
+
+  return RCL_AddSample(instance, &tv, offset, t.leap);
 }
 
 RefclockDriver RCL_SHM_driver = {

reference.c

@@ -314,9 +314,12 @@ update_drift_file(double freq_ppm, double skew)
   }
 
   /* Write the frequency and skew parameters in ppm */
-  fprintf(out, "%20.4f %20.4f\n", freq_ppm, 1.0e6 * skew);
-
-  fclose(out);
+  if ((fprintf(out, "%20.4f %20.4f\n", freq_ppm, 1.0e6 * skew) < 0) |
+      fclose(out)) {
+    LOG(LOGS_WARN, LOGF_Reference, "Could not write to temporary driftfile %s.tmp",
+        drift_file);
+    return;
+  }
 
   /* Clone the file attributes from the existing file if there is one. */
 

regress.c

@@ -588,7 +588,7 @@ RGR_FindBestRobustRegression
        Estimate standard deviation of b and expand range about b based
        on that. */
     sb = sqrt(s2 * W/V);
-    if (sb > 0.0) {
+    if (sb > tol) {
       incr = 3.0 * sb;
     } else {
       incr = 3.0 * tol;
@@ -598,6 +598,11 @@ RGR_FindBestRobustRegression
     bhi = b;
 
     do {
+      /* Make sure incr is significant to blo and bhi */
+      while (bhi + incr == bhi || blo - incr == blo) {
+        incr *= 2;
+      }
+
       blo -= incr;
       bhi += incr;
       
@@ -605,8 +610,8 @@ RGR_FindBestRobustRegression
       eval_robust_residual(x + start, y + start, n_points, blo, &a, &rlo);
       eval_robust_residual(x + start, y + start, n_points, bhi, &a, &rhi);
 
-    } while (rlo * rhi > 0.0); /* fn vals have same sign, i.e. root not
-                                  in interval. */
+    } while (rlo * rhi >= 0.0); /* fn vals have same sign or one is zero,
+                                   i.e. root not in interval (rlo, rhi). */
 
     /* OK, so the root for b lies in (blo, bhi). Start bisecting */
     do {
@@ -623,7 +628,7 @@ RGR_FindBestRobustRegression
       } else {
         assert(0);
       }
-    } while ((bhi - blo) > tol);
+    } while ((bhi - blo) > tol && (bmid - blo) * (bhi - bmid) > 0.0);
 
     *b0 = a;
     *b1 = bmid;

rtc_linux.c

@@ -470,10 +470,13 @@ write_coefs_to_file(int valid,time_t ref_time,double offset,double rate)
   }
 
   /* Gain rate is written out in ppm */
-  fprintf(out, "%1d %ld %.6f %.3f\n",
-          valid,ref_time, offset, 1.0e6 * rate);
-
-  fclose(out);
+  if ((fprintf(out, "%1d %ld %.6f %.3f\n",
+          valid,ref_time, offset, 1.0e6 * rate) < 0) |
+      fclose(out)) {
+    LOG(LOGS_WARN, LOGF_RtcLinux, "Could not write to temporary RTC file %s.tmp",
+        coefs_file_name);
+    return RTC_ST_BADFILE;
+  }
 
   /* Clone the file attributes from the existing file if there is one. */
 

sched.c

@@ -147,7 +147,7 @@ SCH_Initialise(void)
   LCL_AddParameterChangeHandler(handle_slew, NULL);
 
   LCL_ReadRawTime(&tv);
-  srandom(tv.tv_sec * tv.tv_usec);
+  srandom(tv.tv_sec << 16 ^ tv.tv_usec);
 
   initialised = 1;
 

util.c

@@ -459,16 +459,31 @@ UTI_AdjustTimeval(struct timeval *old_tv, struct timeval *when, struct timeval *
 
 /* ================================================== */
 
+uint32_t
+UTI_GetNTPTsFuzz(int precision)
+{
+  uint32_t fuzz;
+  int fuzz_bits;
+  
+  fuzz_bits = 32 - 1 + precision;
+  fuzz = random() % (1 << fuzz_bits);
+
+  return fuzz;
+}
+
+/* ================================================== */
+
 /* Seconds part of RFC1305 timestamp correponding to the origin of the
    struct timeval format. */
 #define JAN_1970 0x83aa7e80UL
 
 void
 UTI_TimevalToInt64(struct timeval *src,
-                   NTP_int64 *dest)
+                   NTP_int64 *dest, uint32_t fuzz)
 {
   unsigned long usec = src->tv_usec;
   unsigned long sec = src->tv_sec;
+  uint32_t lo;
 
   /* Recognize zero as a special case - it always signifies
      an 'unknown' value */
@@ -478,7 +493,12 @@ UTI_TimevalToInt64(struct timeval *src,
     dest->hi = htonl(src->tv_sec + JAN_1970);
 
     /* This formula gives an error of about 0.1us worst case */
-    dest->lo = htonl(4295 * usec - (usec>>5) - (usec>>9));
+    lo = 4295 * usec - (usec>>5) - (usec>>9);
+
+    /* Add the fuzz */
+    lo ^= fuzz;
+
+    dest->lo = htonl(lo);
   }
 }
 

util.h

@@ -88,8 +88,10 @@ extern char *UTI_TimeToLogForm(time_t t);
 /* Adjust time following a frequency/offset change */
 extern void UTI_AdjustTimeval(struct timeval *old_tv, struct timeval *when, struct timeval *new_tv, double *delta, double dfreq, double doffset);
 
+/* Get a random value to fuzz an NTP timestamp in the given precision */
+extern uint32_t UTI_GetNTPTsFuzz(int precision);
 
-extern void UTI_TimevalToInt64(struct timeval *src, NTP_int64 *dest);
+extern void UTI_TimevalToInt64(struct timeval *src, NTP_int64 *dest, uint32_t fuzz);
 
 extern void UTI_Int64ToTimeval(NTP_int64 *src, struct timeval *dest);