Clang

diff --git a/general-utilities.c b/general-utilities.c
index a7a5bafafb72a332b2a6bdc00d98753e1986eae5..6f024d5afe9b3c7ff9a8d82b5d6c18ad2cf004fc 100644 (file)
--- a/general-utilities.c
+++ b/general-utilities.c
@@ -27,11 +27,11 @@ void hcton64(uint64_t num, uint8_t *p) {
   numc = numc >> 32;
   uint32_t num_32 = numc;
   uint32_t rev = htonl(num_32);
-  memcpy(p,&rev,sizeof(uint32_t));
+  memcpy(p, &rev, sizeof(uint32_t));
   num_32 = num & 0xffffffff;
   p = p + 4;
   rev = htonl(num_32);
-  memcpy(p,&rev,sizeof(uint32_t));
+  memcpy(p, &rev, sizeof(uint32_t));
 }
 
 uint32_t nctohl(const uint8_t *p) { // read 4 characters from *p and do ntohl on them

diff --git a/general-utilities.h b/general-utilities.h
index 1b627dabb988c2035523d121aad7dc0e37d59aff..d8f180e29a572963d0e47b3efda6cb3a5f9cb723 100644 (file)
--- a/general-utilities.h
+++ b/general-utilities.h
@@ -36,7 +36,8 @@
 #endif
 
 void hcton64(uint64_t num, uint8_t *p);
-uint32_t nctohl(const uint8_t *p); // read 4 characters from *p and do ntohl on them, avoiding aliasing
+uint32_t
+nctohl(const uint8_t *p); // read 4 characters from *p and do ntohl on them, avoiding aliasing
 uint16_t nctohs(const uint8_t *p);
 uint64_t timespec_to_ns(struct timespec *tn);
 uint64_t get_time_now();

diff --git a/nqptp-clock-sources.h b/nqptp-clock-sources.h
index dbca11f6088de3f9528b8d4920345f712f1d3d46..52b64862807ebe763ba980160683bc75cf13c431 100644 (file)
--- a/nqptp-clock-sources.h
+++ b/nqptp-clock-sources.h
@@ -23,11 +23,7 @@
 #include "nqptp.h"
 
 // transaction tracking
-enum stage {
-  waiting_for_sync,
-  sync_seen,
-  follow_up_seen
-};
+enum stage { waiting_for_sync, sync_seen, follow_up_seen };
 
 typedef enum {
   clock_is_valid,

diff --git a/nqptp-message-handlers.c b/nqptp-message-handlers.c
index 2097cda4ccee26d4977781f4ef3db119f7c1aec6..75fbceafd9c5f13e7486718bf3dd895b608a0e6a 100644 (file)
--- a/nqptp-message-handlers.c
+++ b/nqptp-message-handlers.c
@@ -16,15 +16,15 @@
  *
  * Commercial licensing is also available.
  */
-#include <string.h>
 #include <errno.h>
+#include <string.h>
 #include <unistd.h>
 
+#include "debug.h"
+#include "general-utilities.h"
 #include "nqptp-message-handlers.h"
 #include "nqptp-ptp-definitions.h"
 #include "nqptp-utilities.h"
-#include "debug.h"
-#include "general-utilities.h"
 
 void update_master_old(clock_source_private_data *clock_private_info) {
   int old_master = -1;
@@ -288,7 +288,8 @@ void handle_announce(char *buf, ssize_t recv_len, clock_source_private_data *clo
 }
 
 void handle_sync(char *buf, __attribute__((unused)) ssize_t recv_len,
-                 clock_source_private_data *clock_private_info, uint64_t reception_time, SOCKADDR *from_sock_addr, int socket_number) {
+                 clock_source_private_data *clock_private_info, uint64_t reception_time,
+                 SOCKADDR *from_sock_addr, int socket_number) {
   struct ptp_sync_message *msg = (struct ptp_sync_message *)buf;
   // this is just to see if anything interesting comes in the SYNC package
   // a non-zero origin timestamp
@@ -357,14 +358,14 @@ void handle_sync(char *buf, __attribute__((unused)) ssize_t recv_len,
       struct ptp_delay_req_message m;
       memset(&m, 0, sizeof(m));
       m.header.transportSpecificAndMessageID = 0x11; // Table 19, pp 125, 1 byte field
-      m.header.reservedAndVersionPTP = 0x02; // 1 byte field
+      m.header.reservedAndVersionPTP = 0x02;         // 1 byte field
       m.header.messageLength = htons(44);
       m.header.flags = htons(0x608);
       m.header.sourcePortID = htons(1);
       m.header.controlOtherMessage = 5; // 1 byte field
       m.header.sequenceId = htons(clock_private_info->sequence_number);
       uint64_t sid = get_self_clock_id();
-      memcpy(&m.header.clockIdentity,&sid,sizeof(uint64_t));
+      memcpy(&m.header.clockIdentity, &sid, sizeof(uint64_t));
       struct msghdr header;
       struct iovec io;
       memset(&header, 0, sizeof(header));
@@ -377,10 +378,10 @@ void handle_sync(char *buf, __attribute__((unused)) ssize_t recv_len,
       header.msg_iovlen = 1;
       clock_private_info->t3 = get_time_now(); // in case nothing better works
       if ((sendmsg(socket_number, &header, 0)) == -1) {
-        //debug(1, "Error in sendmsg [errno = %d] to socket %d.", errno, socket_number);
-        //debug_print_buffer(1,(char *)&m, sizeof(m));
+        // debug(1, "Error in sendmsg [errno = %d] to socket %d.", errno, socket_number);
+        // debug_print_buffer(1,(char *)&m, sizeof(m));
       } else {
-        //debug(1, "Success in sendmsg to socket %d.", socket_number);
+        // debug(1, "Success in sendmsg to socket %d.", socket_number);
       }
     }
   }
@@ -408,7 +409,6 @@ void handle_follow_up(char *buf, __attribute__((unused)) ssize_t recv_len,
     preciseOriginTimestamp = preciseOriginTimestamp * 1000000000L;
     preciseOriginTimestamp = preciseOriginTimestamp + nanoseconds;
 
-
     // this result is called "t1" in the IEEE spec.
 
     clock_private_info->t1 = preciseOriginTimestamp;
@@ -418,7 +418,6 @@ void handle_follow_up(char *buf, __attribute__((unused)) ssize_t recv_len,
 
     clock_private_info->current_stage = follow_up_seen;
 
-
   } else {
     debug(3,
           "Follow_Up %u expecting to be in state sync_seen (%u). Stage error -- "
@@ -429,8 +428,7 @@ void handle_follow_up(char *buf, __attribute__((unused)) ssize_t recv_len,
 }
 
 void handle_delay_resp(char *buf, __attribute__((unused)) ssize_t recv_len,
-                      clock_source_private_data *clock_private_info,
-                      uint64_t reception_time) {
+                       clock_source_private_data *clock_private_info, uint64_t reception_time) {
   struct ptp_delay_resp_message *msg = (struct ptp_delay_resp_message *)buf;
 
   if ((clock_private_info->current_stage == follow_up_seen) &&
@@ -453,74 +451,76 @@ void handle_delay_resp(char *buf, __attribute__((unused)) ssize_t recv_len,
     // this is t4 in the IEEE doc and should be close to t1
     // on some systems, it is identical to t1.
 
-    //uint64_t delay_req_turnaround_time = reception_time - clock_private_info->t3;
+    // uint64_t delay_req_turnaround_time = reception_time - clock_private_info->t3;
     uint64_t t4t1diff = receiveTimestamp - clock_private_info->t1;
-    //uint64_t t3t2diff = clock_private_info->t3 - clock_private_info->t2;
-    //debug(1,"t4t1diff: %f, delay_req_turnaround_time: %f, t3t2diff: %f.", t4t1diff * 0.000000001, delay_req_turnaround_time * 0.000000001, t3t2diff * 0.000000001);
-
+    // uint64_t t3t2diff = clock_private_info->t3 - clock_private_info->t2;
+    // debug(1,"t4t1diff: %f, delay_req_turnaround_time: %f, t3t2diff: %f.", t4t1diff * 0.000000001,
+    // delay_req_turnaround_time * 0.000000001, t3t2diff * 0.000000001);
 
     if (t4t1diff < 20000000) {
-        // update the shared clock information
-    uint64_t offset = clock_private_info->t1 - clock_private_info->t2;
-
-    // update our sample information
-
-    clock_private_info->samples[clock_private_info->next_sample_goes_here].local =
-        clock_private_info->t2; // this is when the Sync message arrived.
-    clock_private_info->samples[clock_private_info->next_sample_goes_here].local_to_remote_offset =
-        offset;
-    clock_private_info->samples[clock_private_info->next_sample_goes_here].sequence_number =
-        clock_private_info->sequence_number;
-
-    // if this is the very first...
-    if (clock_private_info->vacant_samples == MAX_TIMING_SAMPLES) {
-      clock_private_info->previous_offset = offset;
-      clock_private_info->previous_estimated_offset = offset;
-    }
+      // update the shared clock information
+      uint64_t offset = clock_private_info->t1 - clock_private_info->t2;
+
+      // update our sample information
+
+      clock_private_info->samples[clock_private_info->next_sample_goes_here].local =
+          clock_private_info->t2; // this is when the Sync message arrived.
+      clock_private_info->samples[clock_private_info->next_sample_goes_here]
+          .local_to_remote_offset = offset;
+      clock_private_info->samples[clock_private_info->next_sample_goes_here].sequence_number =
+          clock_private_info->sequence_number;
+
+      // if this is the very first...
+      if (clock_private_info->vacant_samples == MAX_TIMING_SAMPLES) {
+        clock_private_info->previous_offset = offset;
+        clock_private_info->previous_estimated_offset = offset;
+      }
 
-    if (clock_private_info->vacant_samples > 0)
-      clock_private_info->vacant_samples--;
+      if (clock_private_info->vacant_samples > 0)
+        clock_private_info->vacant_samples--;
 
-    int sample_count = MAX_TIMING_SAMPLES - clock_private_info->vacant_samples;
-    int64_t divergence = 0;
-    uint64_t estimated_offset = offset;
+      int sample_count = MAX_TIMING_SAMPLES - clock_private_info->vacant_samples;
+      int64_t divergence = 0;
+      uint64_t estimated_offset = offset;
 
+      if (sample_count > 1) {
+        int e;
+        long double offsets = 0;
+        for (e = 0; e < sample_count; e++) {
+          uint64_t ho = clock_private_info->samples[e].local_to_remote_offset;
 
-    if (sample_count > 1) {
-      int e;
-      long double offsets = 0;
-      for (e = 0; e < sample_count; e++) {
-        uint64_t ho = clock_private_info->samples[e].local_to_remote_offset;
+          offsets = offsets + 1.0 * ho;
+        }
 
-        offsets = offsets + 1.0 * ho;
+        offsets = offsets / sample_count;
+        estimated_offset = (uint64_t)offsets;
       }
 
-      offsets = offsets / sample_count;
-      estimated_offset = (uint64_t)offsets;
-    }
+      clock_private_info->previous_estimated_offset = estimated_offset;
 
-    clock_private_info->previous_estimated_offset = estimated_offset;
+      clock_private_info->clock_id = packet_clock_id;
+      clock_private_info->flags |= (1 << clock_is_valid);
+      clock_private_info->local_time = clock_private_info->t2;
+      clock_private_info->local_to_source_time_offset = estimated_offset;
 
-    clock_private_info->clock_id = packet_clock_id;
-    clock_private_info->flags |= (1 << clock_is_valid);
-    clock_private_info->local_time = clock_private_info->t2;
-    clock_private_info->local_to_source_time_offset = estimated_offset;
-
-    if ((clock_private_info->flags & (1 << clock_is_master)) != 0) {
-      update_master_clock_info(clock_private_info->clock_id, clock_private_info->local_time,
-                               clock_private_info->local_to_source_time_offset);
-    }
+      if ((clock_private_info->flags & (1 << clock_is_master)) != 0) {
+        update_master_clock_info(clock_private_info->clock_id, clock_private_info->local_time,
+                                 clock_private_info->local_to_source_time_offset);
+      }
 
-    clock_private_info->next_sample_goes_here++;
+      clock_private_info->next_sample_goes_here++;
 
-    // if we have need to wrap.
-    if (clock_private_info->next_sample_goes_here == MAX_TIMING_SAMPLES)
-      clock_private_info->next_sample_goes_here = 0;
+      // if we have need to wrap.
+      if (clock_private_info->next_sample_goes_here == MAX_TIMING_SAMPLES)
+        clock_private_info->next_sample_goes_here = 0;
     } else {
-      debug(2,"Dropping an apparently slow timing exchange with a disparity of %f milliseconds on clock: %" PRIx64 ".", t4t1diff * 0.000001, clock_private_info->clock_id);
+      debug(2,
+            "Dropping an apparently slow timing exchange with a disparity of %f milliseconds on "
+            "clock: %" PRIx64 ".",
+            t4t1diff * 0.000001, clock_private_info->clock_id);
     }
 
-   } else {
+  } else {
     debug(3,
           "Delay_Resp %u expecting to be in state follow_up_seen (%u). Stage error -- "
           "current state is %u, sequence %u. Ignoring it. %s",

diff --git a/nqptp-message-handlers.h b/nqptp-message-handlers.h
index 5f67e02367808e78d3fa2b129d4d078b40f9e597..f7daf75b3771b41cabae84ae0f5e34e645a33822 100644 (file)
--- a/nqptp-message-handlers.h
+++ b/nqptp-message-handlers.h
@@ -34,7 +34,7 @@ void handle_follow_up(char *buf, ssize_t recv_len, clock_source_private_data *cl
                       uint64_t reception_time);
 
 void handle_delay_resp(char *buf, ssize_t recv_len, clock_source_private_data *clock_private_info,
-                      uint64_t reception_time);
+                       uint64_t reception_time);
 
 void handle_control_port_messages(char *buf, ssize_t recv_len,
                                   clock_source_private_data *clock_private_info);

diff --git a/nqptp-utilities.c b/nqptp-utilities.c
index ad51fa5acf62a715b58f52b8ea6f325998118458..86a76c47c34a3e474601495f4873830aa8491c95 100644 (file)
--- a/nqptp-utilities.c
+++ b/nqptp-utilities.c
@@ -18,8 +18,8 @@
  */
 
 #include "nqptp-utilities.h"
-#include "nqptp-ptp-definitions.h"
 #include "general-utilities.h"
+#include "nqptp-ptp-definitions.h"
 #include <errno.h>
 #include <fcntl.h>
 #include <ifaddrs.h>
@@ -209,12 +209,11 @@ uint64_t get_self_clock_id() {
   return result;
 }
 
-
 void send_delay_req_message(int socket_number, SOCKADDR *from_sock_addr, uint16_t seqno) {
   struct ptp_delay_req_message m;
   memset(&m, 0, sizeof(m));
   m.header.transportSpecificAndMessageID = 0x11; // Table 19, pp 125, 1 byte field
-  m.header.reservedAndVersionPTP = 0x02; // 1 byte field
+  m.header.reservedAndVersionPTP = 0x02;         // 1 byte field
   m.header.messageLength = htons(44);
   m.header.flags = htons(0x608);
   m.header.sourcePortID = htons(1);
@@ -222,7 +221,7 @@ void send_delay_req_message(int socket_number, SOCKADDR *from_sock_addr, uint16_
   m.header.sequenceId = htons(seqno);
   m.header.logMessagePeriod = 0x7f; // Table 24, pp 128
   uint64_t sid = get_self_clock_id();
-  memcpy(&m.header.clockIdentity,&sid,sizeof(uint64_t));
+  memcpy(&m.header.clockIdentity, &sid, sizeof(uint64_t));
   struct msghdr header;
   struct iovec io;
   memset(&header, 0, sizeof(header));
@@ -237,7 +236,6 @@ void send_delay_req_message(int socket_number, SOCKADDR *from_sock_addr, uint16_
   if ((sendmsg(socket_number, &header, 0)) == -1) {
     debug(1, "Error in sendmsg [errno = %d]", errno);
   } else {
-    debug_print_buffer(1,&m, sizeof(m));
+    debug_print_buffer(1, &m, sizeof(m));
   }
 }
-

diff --git a/nqptp.c b/nqptp.c
index 119902e5dfd487b4421266ee5a5661d0f269caaa..6798339316cb6c468f20bfdf39a79633cfc3cccf 100644 (file)
--- a/nqptp.c
+++ b/nqptp.c
@@ -74,7 +74,7 @@ int epoll_fd;
 void update_master_clock_info(uint64_t master_clock_id, uint64_t local_time,
                               uint64_t local_to_master_offset) {
   if (shared_memory->master_clock_id != master_clock_id)
-    debug(1, "Master clock is: %" PRIx64".", master_clock_id);
+    debug(1, "Master clock is: %" PRIx64 ".", master_clock_id);
   int rc = pthread_mutex_lock(&shared_memory->shm_mutex);
   if (rc != 0)
     warn("Can't acquire mutex to update master clock!");
@@ -358,7 +358,8 @@ int main(void) {
                   handle_announce(buf, recv_len, &clocks_private[the_clock], reception_time);
                   break;
                 case Sync: { // if it's a sync
-                  handle_sync(buf, recv_len, &clocks_private[the_clock], reception_time, &from_sock_addr, socket_number);
+                  handle_sync(buf, recv_len, &clocks_private[the_clock], reception_time,
+                              &from_sock_addr, socket_number);
                 } break;
                 case Follow_Up: {
                   handle_follow_up(buf, recv_len, &clocks_private[the_clock], reception_time);