Merge remote-tracking branch 'github/pr/2190'

diff --git a/src/chrony.c b/src/chrony.c
index 11310b1..a5e85a8 100644 (file)
--- a/src/chrony.c
+++ b/src/chrony.c
@@ -77,6 +77,7 @@ static uint32_t g_chrony_seq_is_initialized;
 #define IPADDR_INET4 1
 #define IPADDR_INET6 2
 #define IPV6_STR_MAX_SIZE (8 * 4 + 7 + 1)
+#define MODE_REFCLOCK 2
 
 typedef enum { PKT_TYPE_CMD_REQUEST = 1, PKT_TYPE_CMD_REPLY = 2 } ePacketType;
 
@@ -185,13 +186,11 @@ typedef struct ATTRIB_PACKED {
     uint8_t ip6[16];
   } addr;
   uint16_t f_family;
+  uint16_t padding;
 } tChrony_IPAddr;
 
 typedef struct ATTRIB_PACKED {
   tChrony_IPAddr addr;
-  uint16_t
-      dummy; /* FIXME: Strange dummy space. Needed on gcc 4.8.3/clang 3.4.1 on
-                x86_64 */
   int16_t f_poll;     /* 2^f_poll = Time between polls (s) */
   uint16_t f_stratum; /* Remote clock stratum */
   uint16_t f_state;   /* 0 = RPY_SD_ST_SYNC,    1 = RPY_SD_ST_UNREACH,   2 =
@@ -212,9 +211,6 @@ typedef struct ATTRIB_PACKED {
 typedef struct ATTRIB_PACKED {
   uint32_t f_ref_id;
   tChrony_IPAddr addr;
-  uint16_t
-      dummy; /* FIXME: Strange dummy space. Needed on gcc 4.8.3/clang 3.4.1 on
-                x86_64 */
   uint32_t f_n_samples;       /* Number of measurements done   */
   uint32_t f_n_runs;          /* How many measurements to come */
   uint32_t f_span_seconds;    /* For how long we're measuring  */
@@ -229,9 +225,6 @@ typedef struct ATTRIB_PACKED {
 typedef struct ATTRIB_PACKED {
   uint32_t f_ref_id;
   tChrony_IPAddr addr;
-  uint16_t
-      dummy; /* FIXME: Strange dummy space. Needed on gcc 4.8.3/clang 3.4.1 on
-                x86_64 */
   uint16_t f_stratum;
   uint16_t f_leap_status;
   tTimeval f_ref_time;
@@ -354,6 +347,19 @@ static char *niptoha(const tChrony_IPAddr *addr, char *p_buf,
   return p_buf;
 }
 
+static void nreftostr(uint32_t nrefid, char *p_buf, size_t p_buf_size) {
+  int i, j, c;
+
+  for (i = j = 0; i < 4; i++) {
+    c = ntohl(nrefid) << i * 8 >> 24;
+    if (!isalnum(c) || j + 1 >= p_buf_size)
+      continue;
+    p_buf[j++] = c;
+  }
+  if (j < p_buf_size)
+    p_buf[j] = '\0';
+}
+
 static int chrony_set_timeout(void) {
   /* Set the socket's  timeout to g_chrony_timeout; a value of 0 signals
    * infinite timeout */
@@ -584,9 +590,10 @@ static double ntohf(tFloat p_float) {
   uint32_t uval;
 
   uval = ntohl(p_float.value);
-  exp = (uval >> FLOAT_COEF_BITS) - FLOAT_COEF_BITS;
+  exp = (uval >> FLOAT_COEF_BITS);
   if (exp >= 1 << (FLOAT_EXP_BITS - 1))
     exp -= 1 << FLOAT_EXP_BITS;
+  exp -= FLOAT_COEF_BITS;
 
   /* coef = (x << FLOAT_EXP_BITS) >> FLOAT_EXP_BITS; */
   coef = uval % (1U << FLOAT_COEF_BITS);
@@ -832,15 +839,14 @@ static int chrony_request_sources_count(unsigned int *p_count) {
   return CHRONY_RC_OK;
 }
 
-static int chrony_request_source_data(int p_src_idx, int *p_is_reachable) {
+static int chrony_request_source_data(int p_src_idx, char *src_addr,
+                                      size_t addr_size, int *p_is_reachable) {
   /* Perform Source data request for source #p_src_idx */
   int rc;
   size_t chrony_resp_size;
   tChrony_Request chrony_req;
   tChrony_Response chrony_resp;
 
-  char src_addr[IPV6_STR_MAX_SIZE] = {0};
-
   chrony_init_req(&chrony_req);
   chrony_req.body.source_data.f_index = htonl(p_src_idx);
   rc = chrony_query(REQ_SOURCE_DATA, &chrony_req, &chrony_resp,
@@ -851,7 +857,11 @@ static int chrony_request_source_data(int p_src_idx, int *p_is_reachable) {
     return rc;
   }
 
-  niptoha(&chrony_resp.body.source_data.addr, src_addr, sizeof(src_addr));
+  if (ntohs(chrony_resp.body.source_data.f_mode) == MODE_REFCLOCK)
+    nreftostr(chrony_resp.body.source_data.addr.addr.ip4, src_addr, addr_size);
+  else
+    niptoha(&chrony_resp.body.source_data.addr, src_addr, addr_size);
+
   DEBUG(PLUGIN_NAME ": Source[%d] data: .addr = %s, .poll = %u, .stratum = %u, "
                     ".state = %u, .mode = %u, .flags = %u, .reach = %u, "
                     ".latest_meas_ago = %u, .orig_latest_meas = %f, "
@@ -881,26 +891,26 @@ static int chrony_request_source_data(int p_src_idx, int *p_is_reachable) {
   chrony_push_data_valid("clock_reachability", src_addr, is_reachable,
                          ntohs(chrony_resp.body.source_data.f_reachability));
   chrony_push_data_valid("clock_last_meas", src_addr, is_reachable,
-                         ntohs(chrony_resp.body.source_data.f_since_sample));
+                         ntohl(chrony_resp.body.source_data.f_since_sample));
+  chrony_push_data_valid(
+      "time_offset", src_addr, is_reachable,
+      ntohf(chrony_resp.body.source_data.f_origin_latest_meas));
 
   return CHRONY_RC_OK;
 }
 
-static int chrony_request_source_stats(int p_src_idx,
+static int chrony_request_source_stats(int p_src_idx, const char *src_addr,
                                        const int *p_is_reachable) {
   /* Perform Source stats request for source #p_src_idx */
   int rc;
   size_t chrony_resp_size;
   tChrony_Request chrony_req;
   tChrony_Response chrony_resp;
-  double skew_ppm, frequency_error, time_offset;
-
-  char src_addr[IPV6_STR_MAX_SIZE] = {0};
+  double skew_ppm, frequency_error;
 
   if (*p_is_reachable == 0) {
     skew_ppm = 0;
     frequency_error = 0;
-    time_offset = 0;
   } else {
     chrony_init_req(&chrony_req);
     chrony_req.body.source_stats.f_index = htonl(p_src_idx);
@@ -915,9 +925,7 @@ static int chrony_request_source_stats(int p_src_idx,
 
     skew_ppm = ntohf(chrony_resp.body.source_stats.f_skew_ppm);
     frequency_error = ntohf(chrony_resp.body.source_stats.f_rtc_gain_rate_ppm);
-    time_offset = ntohf(chrony_resp.body.source_stats.f_est_offset);
 
-    niptoha(&chrony_resp.body.source_stats.addr, src_addr, sizeof(src_addr));
     DEBUG(PLUGIN_NAME
           ": Source[%d] stat: .addr = %s, .ref_id= %u, .n_samples = %u, "
           ".n_runs = %u, .span_seconds = %u, .rtc_seconds_fast = %f, "
@@ -928,7 +936,8 @@ static int chrony_request_source_stats(int p_src_idx,
           ntohl(chrony_resp.body.source_stats.f_n_runs),
           ntohl(chrony_resp.body.source_stats.f_span_seconds),
           ntohf(chrony_resp.body.source_stats.f_rtc_seconds_fast),
-          frequency_error, skew_ppm, time_offset,
+          frequency_error, skew_ppm,
+          ntohf(chrony_resp.body.source_stats.f_est_offset),
           ntohf(chrony_resp.body.source_stats.f_est_offset_err));
 
   } /* if (*is_reachable) */
@@ -937,8 +946,6 @@ static int chrony_request_source_stats(int p_src_idx,
   chrony_push_data_valid("clock_skew_ppm", src_addr, *p_is_reachable, skew_ppm);
   chrony_push_data_valid("frequency_error", src_addr, *p_is_reachable,
                          frequency_error); /* unit: ppm */
-  chrony_push_data_valid("time_offset", src_addr, *p_is_reachable,
-                         time_offset); /* unit: s */
 
   return CHRONY_RC_OK;
 }
@@ -968,12 +975,14 @@ static int chrony_read(void) {
     return rc;
 
   for (unsigned int now_src = 0; now_src < n_sources; ++now_src) {
+    char src_addr[IPV6_STR_MAX_SIZE] = {0};
     int is_reachable;
-    rc = chrony_request_source_data(now_src, &is_reachable);
+    rc = chrony_request_source_data(now_src, src_addr, sizeof(src_addr),
+                                    &is_reachable);
     if (rc != CHRONY_RC_OK)
       return rc;
 
-    rc = chrony_request_source_stats(now_src, &is_reachable);
+    rc = chrony_request_source_stats(now_src, src_addr, &is_reachable);
     if (rc != CHRONY_RC_OK)
       return rc;
   }

diff --git a/src/types.db b/src/types.db
index 0a5413b..c9838e1 100644 (file)
--- a/src/types.db
+++ b/src/types.db
@@ -26,7 +26,7 @@ clock_last_meas         value:GAUGE:0:U
 clock_last_update       value:GAUGE:U:U
 clock_mode              value:GAUGE:0:U
 clock_reachability      value:GAUGE:0:U
-clock_skew_ppm          value:GAUGE:-2:2
+clock_skew_ppm          value:GAUGE:0:1000000
 clock_state             value:GAUGE:0:U
 clock_stratum           value:GAUGE:0:U
 compression             uncompressed:DERIVE:0:U, compressed:DERIVE:0:U
@@ -92,7 +92,7 @@ filter_result           value:DERIVE:0:U
 flow                    value:GAUGE:0:U
 fork_rate               value:DERIVE:0:U
 frequency               value:GAUGE:0:U
-frequency_error         value:GAUGE:-2:2 
+frequency_error         value:GAUGE:-1000000:1000000
 frequency_offset        value:GAUGE:-1000000:1000000
 fscache_stat            value:DERIVE:0:U
 gauge                   value:GAUGE:U:U