Re-indent clatd code with clang-format

clang-format --style file -i *.{c,h,cpp}

Bug: 118848635
Test: 1. browse over ipv6-only network
      2. atest clatd_test
      3. clang-format --style file -i *.{c,h,cpp}

Change-Id: I7389426101df7745370d0ac5c55176cd8fe2b08b

1 files changed, 117 insertions, 119 deletions

diff --git a/clatd_test.cpp b/clatd_test.cpp
index b901c30..2a10101 100644
--- a/clatd_test.cpp
+++ b/clatd_test.cpp
@@ -18,28 +18,29 @@
 
 #include <iostream>
 
-#include <stdio.h>
 #include <arpa/inet.h>
 #include <netinet/in6.h>
+#include <stdio.h>
 #include <sys/uio.h>
 
 #include <gtest/gtest.h>
 
 extern "C" {
 #include "checksum.h"
-#include "translate.h"
-#include "config.h"
 #include "clatd.h"
+#include "config.h"
+#include "translate.h"
 }
 
 // For convenience.
 #define ARRAYSIZE(x) sizeof((x)) / sizeof((x)[0])
 
 // Default translation parameters.
-static const char kIPv4LocalAddr[] = "192.0.0.4";
-static const char kIPv6LocalAddr[] = "2001:db8:0:b11::464";
+static const char kIPv4LocalAddr[]  = "192.0.0.4";
+static const char kIPv6LocalAddr[]  = "2001:db8:0:b11::464";
 static const char kIPv6PlatSubnet[] = "64:ff9b::";
 
+// clang-format off
 // Test packet portions. Defined as macros because it's easy to concatenate them to make packets.
 #define IPV4_HEADER(p, c1, c2) \
     0x45, 0x00,    0,   41,  /* Version=4, IHL=5, ToS=0x80, len=41 */     \
@@ -164,6 +165,7 @@ static const uint8_t kReassembledIPv4[] = {
     0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, 0x00, 0x01, 0x00,
     0x01
 };
+// clang-format on
 
 // Expected checksums.
 static const uint32_t kUdpPartialChecksum     = 0xd5c8;
@@ -185,9 +187,9 @@ int is_ipv6_fragment(struct ip6_hdr *ip6, size_t len) {
   if (ip6->ip6_nxt != IPPROTO_FRAGMENT) {
     return 0;
   }
-  struct ip6_frag *frag = (struct ip6_frag *) (ip6 + 1);
+  struct ip6_frag *frag = (struct ip6_frag *)(ip6 + 1);
   return len >= sizeof(*ip6) + sizeof(*frag) &&
-          (frag->ip6f_offlg & (IP6F_OFF_MASK | IP6F_MORE_FRAG));
+         (frag->ip6f_offlg & (IP6F_OFF_MASK | IP6F_MORE_FRAG));
 }
 
 int ipv4_fragment_offset(struct iphdr *ip) {
@@ -200,50 +202,50 @@ int ipv6_fragment_offset(struct ip6_frag *frag) {
 
 void check_packet(const uint8_t *packet, size_t len, const char *msg) {
   void *payload;
-  size_t payload_length = 0;
+  size_t payload_length    = 0;
   uint32_t pseudo_checksum = 0;
-  uint8_t protocol = 0;
-  int version = ip_version(packet);
+  uint8_t protocol         = 0;
+  int version              = ip_version(packet);
   switch (version) {
     case 4: {
-      struct iphdr *ip = (struct iphdr *) packet;
+      struct iphdr *ip = (struct iphdr *)packet;
       ASSERT_GE(len, sizeof(*ip)) << msg << ": IPv4 packet shorter than IPv4 header\n";
       EXPECT_EQ(5, ip->ihl) << msg << ": Unsupported IP header length\n";
       EXPECT_EQ(len, ntohs(ip->tot_len)) << msg << ": Incorrect IPv4 length\n";
       EXPECT_EQ(0, ip_checksum(ip, sizeof(*ip))) << msg << ": Incorrect IP checksum\n";
       protocol = ip->protocol;
-      payload = ip + 1;
+      payload  = ip + 1;
       if (!is_ipv4_fragment(ip)) {
-        payload_length = len - sizeof(*ip);
+        payload_length  = len - sizeof(*ip);
         pseudo_checksum = ipv4_pseudo_header_checksum(ip, payload_length);
       }
       ASSERT_TRUE(protocol == IPPROTO_TCP || protocol == IPPROTO_UDP || protocol == IPPROTO_ICMP)
-          << msg << ": Unsupported IPv4 protocol " << protocol << "\n";
+        << msg << ": Unsupported IPv4 protocol " << protocol << "\n";
       break;
     }
     case 6: {
-      struct ip6_hdr *ip6 = (struct ip6_hdr *) packet;
+      struct ip6_hdr *ip6 = (struct ip6_hdr *)packet;
       ASSERT_GE(len, sizeof(*ip6)) << msg << ": IPv6 packet shorter than IPv6 header\n";
       EXPECT_EQ(len - sizeof(*ip6), htons(ip6->ip6_plen)) << msg << ": Incorrect IPv6 length\n";
 
       if (ip6->ip6_nxt == IPPROTO_FRAGMENT) {
-        struct ip6_frag *frag = (struct ip6_frag *) (ip6 + 1);
+        struct ip6_frag *frag = (struct ip6_frag *)(ip6 + 1);
         ASSERT_GE(len, sizeof(*ip6) + sizeof(*frag))
-            << msg << ": IPv6 fragment: short fragment header\n";
+          << msg << ": IPv6 fragment: short fragment header\n";
         protocol = frag->ip6f_nxt;
-        payload = frag + 1;
+        payload  = frag + 1;
         // Even though the packet has a Fragment header, it might not be a fragment.
         if (!is_ipv6_fragment(ip6, len)) {
           payload_length = len - sizeof(*ip6) - sizeof(*frag);
         }
       } else {
         // Since there are no extension headers except Fragment, this must be the payload.
-        protocol = ip6->ip6_nxt;
-        payload = ip6 + 1;
+        protocol       = ip6->ip6_nxt;
+        payload        = ip6 + 1;
         payload_length = len - sizeof(*ip6);
       }
       ASSERT_TRUE(protocol == IPPROTO_TCP || protocol == IPPROTO_UDP || protocol == IPPROTO_ICMPV6)
-          << msg << ": Unsupported IPv6 next header " << protocol;
+        << msg << ": Unsupported IPv6 next header " << protocol;
       if (payload_length) {
         pseudo_checksum = ipv6_pseudo_header_checksum(ip6, payload_length, protocol);
       }
@@ -257,7 +259,7 @@ void check_packet(const uint8_t *packet, size_t len, const char *msg) {
   // If we understand the payload, verify the checksum.
   if (payload_length) {
     uint16_t checksum;
-    switch(protocol) {
+    switch (protocol) {
       case IPPROTO_UDP:
       case IPPROTO_TCP:
       case IPPROTO_ICMPV6:
@@ -274,7 +276,7 @@ void check_packet(const uint8_t *packet, size_t len, const char *msg) {
   }
 
   if (protocol == IPPROTO_UDP) {
-    struct udphdr *udp = (struct udphdr *) payload;
+    struct udphdr *udp = (struct udphdr *)payload;
     EXPECT_NE(0, udp->check) << msg << ": UDP checksum 0 should be 0xffff";
     // If this is not a fragment, check the UDP length field.
     if (payload_length) {
@@ -285,15 +287,15 @@ void check_packet(const uint8_t *packet, size_t len, const char *msg) {
 
 void reassemble_packet(const uint8_t **fragments, const size_t lengths[], int numpackets,
                        uint8_t *reassembled, size_t *reassembled_len, const char *msg) {
-  struct iphdr *ip = NULL;
+  struct iphdr *ip    = NULL;
   struct ip6_hdr *ip6 = NULL;
-  size_t  total_length, pos = 0;
+  size_t total_length, pos = 0;
   uint8_t protocol = 0;
-  uint8_t version = ip_version(fragments[0]);
+  uint8_t version  = ip_version(fragments[0]);
 
   for (int i = 0; i < numpackets; i++) {
     const uint8_t *packet = fragments[i];
-    int len = lengths[i];
+    int len               = lengths[i];
     int headersize, payload_offset;
 
     ASSERT_EQ(ip_version(packet), version) << msg << ": Inconsistent fragment versions\n";
@@ -301,32 +303,32 @@ void reassemble_packet(const uint8_t **fragments, const size_t lengths[], int nu
 
     switch (version) {
       case 4: {
-        struct iphdr *ip_orig = (struct iphdr *) packet;
-        headersize = sizeof(*ip_orig);
+        struct iphdr *ip_orig = (struct iphdr *)packet;
+        headersize            = sizeof(*ip_orig);
         ASSERT_TRUE(is_ipv4_fragment(ip_orig))
-            << msg << ": IPv4 fragment #" << i + 1 << " not a fragment\n";
-        ASSERT_EQ(pos, ipv4_fragment_offset(ip_orig) * 8 + ((i != 0) ? sizeof(*ip): 0))
-            << msg << ": IPv4 fragment #" << i + 1 << ": inconsistent offset\n";
+          << msg << ": IPv4 fragment #" << i + 1 << " not a fragment\n";
+        ASSERT_EQ(pos, ipv4_fragment_offset(ip_orig) * 8 + ((i != 0) ? sizeof(*ip) : 0))
+          << msg << ": IPv4 fragment #" << i + 1 << ": inconsistent offset\n";
 
-        headersize = sizeof(*ip_orig);
+        headersize     = sizeof(*ip_orig);
         payload_offset = headersize;
         if (pos == 0) {
-          ip = (struct iphdr *) reassembled;
+          ip = (struct iphdr *)reassembled;
         }
         break;
       }
       case 6: {
-        struct ip6_hdr *ip6_orig = (struct ip6_hdr *) packet;
-        struct ip6_frag *frag = (struct ip6_frag *) (ip6_orig + 1);
+        struct ip6_hdr *ip6_orig = (struct ip6_hdr *)packet;
+        struct ip6_frag *frag    = (struct ip6_frag *)(ip6_orig + 1);
         ASSERT_TRUE(is_ipv6_fragment(ip6_orig, len))
-            << msg << ": IPv6 fragment #" << i + 1 << " not a fragment\n";
-        ASSERT_EQ(pos, ipv6_fragment_offset(frag) * 8 + ((i != 0) ? sizeof(*ip6): 0))
-            << msg << ": IPv6 fragment #" << i + 1 << ": inconsistent offset\n";
+          << msg << ": IPv6 fragment #" << i + 1 << " not a fragment\n";
+        ASSERT_EQ(pos, ipv6_fragment_offset(frag) * 8 + ((i != 0) ? sizeof(*ip6) : 0))
+          << msg << ": IPv6 fragment #" << i + 1 << ": inconsistent offset\n";
 
-        headersize = sizeof(*ip6_orig);
+        headersize     = sizeof(*ip6_orig);
         payload_offset = sizeof(*ip6_orig) + sizeof(*frag);
         if (pos == 0) {
-          ip6 = (struct ip6_hdr *) reassembled;
+          ip6      = (struct ip6_hdr *)reassembled;
           protocol = frag->ip6f_nxt;
         }
         break;
@@ -337,7 +339,7 @@ void reassemble_packet(const uint8_t **fragments, const size_t lengths[], int nu
 
     // If this is the first fragment, copy the header.
     if (pos == 0) {
-      ASSERT_LT(headersize, (int) *reassembled_len) << msg << ": Reassembly buffer too small\n";
+      ASSERT_LT(headersize, (int)*reassembled_len) << msg << ": Reassembly buffer too small\n";
       memcpy(reassembled, packet, headersize);
       total_length = headersize;
       pos += headersize;
@@ -351,21 +353,20 @@ void reassemble_packet(const uint8_t **fragments, const size_t lengths[], int nu
     pos += payload_length;
   }
 
-
   // Fix up the reassembled headers to reflect fragmentation and length (and IPv4 checksum).
   ASSERT_EQ(total_length, pos) << msg << ": Reassembled packet length incorrect\n";
   if (ip) {
     ip->frag_off &= ~htons(IP_MF);
     ip->tot_len = htons(total_length);
-    ip->check = 0;
-    ip->check = ip_checksum(ip, sizeof(*ip));
+    ip->check   = 0;
+    ip->check   = ip_checksum(ip, sizeof(*ip));
     ASSERT_FALSE(is_ipv4_fragment(ip)) << msg << ": reassembled IPv4 packet is a fragment!\n";
   }
   if (ip6) {
-    ip6->ip6_nxt = protocol;
+    ip6->ip6_nxt  = protocol;
     ip6->ip6_plen = htons(total_length - sizeof(*ip6));
     ASSERT_FALSE(is_ipv6_fragment(ip6, ip6->ip6_plen))
-        << msg << ": reassembled IPv6 packet is a fragment!\n";
+      << msg << ": reassembled IPv6 packet is a fragment!\n";
   }
 
   *reassembled_len = total_length;
@@ -383,8 +384,8 @@ void check_data_matches(const void *expected, const void *actual, size_t len, co
         snprintf(actual_hexdump + pos, hexdump_len - pos, "\n   ");
         pos += 4;
       }
-      snprintf(expected_hexdump + pos, hexdump_len - pos, " %02x", ((uint8_t *) expected)[i]);
-      snprintf(actual_hexdump + pos, hexdump_len - pos, " %02x", ((uint8_t *) actual)[i]);
+      snprintf(expected_hexdump + pos, hexdump_len - pos, " %02x", ((uint8_t *)expected)[i]);
+      snprintf(actual_hexdump + pos, hexdump_len - pos, " %02x", ((uint8_t *)actual)[i]);
       pos += 3;
     }
     FAIL() << msg << ": Data doesn't match"
@@ -393,27 +394,27 @@ void check_data_matches(const void *expected, const void *actual, size_t len, co
   }
 }
 
-void fix_udp_checksum(uint8_t* packet) {
+void fix_udp_checksum(uint8_t *packet) {
   uint32_t pseudo_checksum;
   uint8_t version = ip_version(packet);
   struct udphdr *udp;
   switch (version) {
     case 4: {
-      struct iphdr *ip = (struct iphdr *) packet;
-      udp = (struct udphdr *) (ip + 1);
-      pseudo_checksum = ipv4_pseudo_header_checksum(ip, ntohs(udp->len));
+      struct iphdr *ip = (struct iphdr *)packet;
+      udp              = (struct udphdr *)(ip + 1);
+      pseudo_checksum  = ipv4_pseudo_header_checksum(ip, ntohs(udp->len));
       break;
     }
     case 6: {
-      struct ip6_hdr *ip6 = (struct ip6_hdr *) packet;
-      udp = (struct udphdr *) (ip6 + 1);
-      pseudo_checksum = ipv6_pseudo_header_checksum(ip6, ntohs(udp->len), IPPROTO_UDP);
+      struct ip6_hdr *ip6 = (struct ip6_hdr *)packet;
+      udp                 = (struct udphdr *)(ip6 + 1);
+      pseudo_checksum     = ipv6_pseudo_header_checksum(ip6, ntohs(udp->len), IPPROTO_UDP);
       break;
     }
     default:
       FAIL() << "unsupported IP version" << version << "\n";
       return;
-    }
+  }
 
   udp->check = 0;
   udp->check = ip_checksum_finish(ip_checksum_add(pseudo_checksum, udp, ntohs(udp->len)));
@@ -422,9 +423,7 @@ void fix_udp_checksum(uint8_t* packet) {
 // Testing stub for send_rawv6. The real version uses sendmsg() with a
 // destination IPv6 address, and attempting to call that on our test socketpair
 // fd results in EINVAL.
-extern "C" void send_rawv6(int fd, clat_packet out, int iov_len) {
-    writev(fd, out, iov_len);
-}
+extern "C" void send_rawv6(int fd, clat_packet out, int iov_len) { writev(fd, out, iov_len); }
 
 void do_translate_packet(const uint8_t *original, size_t original_len, uint8_t *out, size_t *outlen,
                          const char *msg) {
@@ -443,13 +442,13 @@ void do_translate_packet(const uint8_t *original, size_t original_len, uint8_t *
   switch (version) {
     case 4:
       expected_proto = htons(ETH_P_IPV6);
-      read_fd = fds[1];
-      write_fd = fds[0];
+      read_fd        = fds[1];
+      write_fd       = fds[0];
       break;
     case 6:
       expected_proto = htons(ETH_P_IP);
-      read_fd = fds[0];
-      write_fd = fds[1];
+      read_fd        = fds[0];
+      write_fd       = fds[1];
       break;
     default:
       FAIL() << msg << ": Unsupported IP version " << version << "\n";
@@ -464,11 +463,12 @@ void do_translate_packet(const uint8_t *original, size_t original_len, uint8_t *
     struct tun_pi new_tun_header;
     struct iovec iov[] = {
       { &new_tun_header, sizeof(new_tun_header) },
-      { out, *outlen }
+      { out, *outlen },
     };
+
     int len = readv(read_fd, iov, 2);
-    if (len > (int) sizeof(new_tun_header)) {
-      ASSERT_LT((size_t) len, *outlen) << msg << ": Translated packet buffer too small\n";
+    if (len > (int)sizeof(new_tun_header)) {
+      ASSERT_LT((size_t)len, *outlen) << msg << ": Translated packet buffer too small\n";
       EXPECT_EQ(expected_proto, new_tun_header.proto) << msg << "Unexpected tun proto\n";
       *outlen = len - sizeof(new_tun_header);
       check_packet(out, *outlen, msg);
@@ -483,8 +483,8 @@ void do_translate_packet(const uint8_t *original, size_t original_len, uint8_t *
   }
 }
 
-void check_translated_packet(const uint8_t *original, size_t original_len,
-                             const uint8_t *expected, size_t expected_len, const char *msg) {
+void check_translated_packet(const uint8_t *original, size_t original_len, const uint8_t *expected,
+                             size_t expected_len, const char *msg) {
   uint8_t translated[MAXMTU];
   size_t translated_len = sizeof(translated);
   do_translate_packet(original, original_len, translated, &translated_len, msg);
@@ -499,8 +499,8 @@ void check_fragment_translation(const uint8_t *original[], const size_t original
     // Check that each of the fragments translates as expected.
     char frag_msg[512];
     snprintf(frag_msg, sizeof(frag_msg), "%s: fragment #%d", msg, i + 1);
-    check_translated_packet(original[i], original_lengths[i],
-                            expected[i], expected_lengths[i], frag_msg);
+    check_translated_packet(original[i], original_lengths[i], expected[i], expected_lengths[i],
+                            frag_msg);
   }
 
   // Sanity check that reassembling the original and translated fragments produces valid packets.
@@ -524,17 +524,17 @@ int get_transport_checksum(const uint8_t *packet) {
   int version = ip_version(packet);
   switch (version) {
     case 4:
-      ip = (struct iphdr *) packet;
+      ip = (struct iphdr *)packet;
       if (is_ipv4_fragment(ip)) {
-          return -1;
+        return -1;
       }
       protocol = ip->protocol;
-      payload = ip + 1;
+      payload  = ip + 1;
       break;
     case 6:
-      ip6 = (struct ip6_hdr *) packet;
+      ip6      = (struct ip6_hdr *)packet;
       protocol = ip6->ip6_nxt;
-      payload = ip6 + 1;
+      payload  = ip6 + 1;
       break;
     default:
       return -1;
@@ -542,10 +542,10 @@ int get_transport_checksum(const uint8_t *packet) {
 
   switch (protocol) {
     case IPPROTO_UDP:
-      return ((struct udphdr *) payload)->check;
+      return ((struct udphdr *)payload)->check;
 
     case IPPROTO_TCP:
-      return ((struct tcphdr *) payload)->check;
+      return ((struct tcphdr *)payload)->check;
 
     case IPPROTO_FRAGMENT:
     default:
@@ -561,7 +561,7 @@ class ClatdTest : public ::testing::Test {
     inet_pton(AF_INET, kIPv4LocalAddr, &Global_Clatd_Config.ipv4_local_subnet);
     inet_pton(AF_INET6, kIPv6PlatSubnet, &Global_Clatd_Config.plat_subnet);
     inet_pton(AF_INET6, kIPv6LocalAddr, &Global_Clatd_Config.ipv6_local_subnet);
-    Global_Clatd_Config.ipv6_host_id = in6addr_any;
+    Global_Clatd_Config.ipv6_host_id    = in6addr_any;
     Global_Clatd_Config.use_dynamic_iid = 1;
   }
 };
@@ -597,7 +597,7 @@ TEST_F(ClatdTest, TestIPv6PrefixEqual) {
 int count_onebits(const void *data, size_t size) {
   int onebits = 0;
   for (size_t pos = 0; pos < size; pos++) {
-    uint8_t *byte = ((uint8_t*) data) + pos;
+    uint8_t *byte = ((uint8_t *)data) + pos;
     for (int shift = 0; shift < 8; shift++) {
       onebits += (*byte >> shift) & 1;
     }
@@ -611,7 +611,7 @@ TEST_F(ClatdTest, TestCountOnebits) {
   ASSERT_EQ(1, count_onebits(&i, sizeof(i)));
   i <<= 61;
   ASSERT_EQ(1, count_onebits(&i, sizeof(i)));
-  i |= ((uint64_t) 1 << 33);
+  i |= ((uint64_t)1 << 33);
   ASSERT_EQ(2, count_onebits(&i, sizeof(i)));
   i = 0xf1000202020000f0;
   ASSERT_EQ(5 + 1 + 1 + 1 + 4, count_onebits(&i, sizeof(i)));
@@ -637,10 +637,10 @@ TEST_F(ClatdTest, TestGenIIDRandom) {
   Global_Clatd_Config.ipv6_host_id = in6addr_any;
 
   // Generate a boatload of random IIDs.
-  int onebits = 0;
+  int onebits       = 0;
   uint64_t prev_iid = 0;
   for (int i = 0; i < 100000; i++) {
-    struct in6_addr myaddr =  interface_ipv6;
+    struct in6_addr myaddr = interface_ipv6;
 
     config_generate_local_ipv6_subnet(&myaddr);
 
@@ -648,7 +648,7 @@ TEST_F(ClatdTest, TestGenIIDRandom) {
     EXPECT_TRUE(ipv6_prefix_equal(&interface_ipv6, &myaddr));
 
     // Check that consecutive IIDs are not the same.
-    uint64_t iid = * (uint64_t*) (&myaddr.s6_addr[8]);
+    uint64_t iid = *(uint64_t *)(&myaddr.s6_addr[8]);
     ASSERT_TRUE(iid != prev_iid)
         << "Two consecutive random IIDs are the same: "
         << std::showbase << std::hex
@@ -657,7 +657,7 @@ TEST_F(ClatdTest, TestGenIIDRandom) {
 
     // Check that the IID is checksum-neutral with the NAT64 prefix and the
     // local prefix.
-    struct in_addr *ipv4addr = &Global_Clatd_Config.ipv4_local_subnet;
+    struct in_addr *ipv4addr     = &Global_Clatd_Config.ipv4_local_subnet;
     struct in6_addr *plat_subnet = &Global_Clatd_Config.plat_subnet;
 
     uint16_t c1 = ip_checksum_finish(ip_checksum_add(0, ipv4addr, sizeof(*ipv4addr)));
@@ -732,7 +732,7 @@ TEST_F(ClatdTest, SelectIPv4Address) {
   // Now try using the real function which sees if IP addresses are free using bind().
   // Assume that the machine running the test has the address 127.0.0.1, but not 8.8.8.8.
   config_is_ipv4_address_free = orig_config_is_ipv4_address_free;
-  addr.s_addr = inet_addr("8.8.8.8");
+  addr.s_addr                 = inet_addr("8.8.8.8");
   EXPECT_EQ(inet_addr("8.8.8.8"), config_select_ipv4_address(&addr, 29));
 
   addr.s_addr = inet_addr("127.0.0.1");
@@ -753,13 +753,13 @@ TEST_F(ClatdTest, DataSanitycheck) {
   // Sanity checks check_packet.
   struct udphdr *udp;
   uint8_t v4_udp_packet[] = { IPV4_UDP_HEADER UDP_HEADER PAYLOAD };
-  udp = (struct udphdr *) (v4_udp_packet + sizeof(struct iphdr));
+  udp                     = (struct udphdr *)(v4_udp_packet + sizeof(struct iphdr));
   fix_udp_checksum(v4_udp_packet);
   ASSERT_EQ(kUdpV4Checksum, udp->check) << "UDP/IPv4 packet checksum sanity check\n";
   check_packet(v4_udp_packet, sizeof(v4_udp_packet), "UDP/IPv4 packet sanity check");
 
   uint8_t v6_udp_packet[] = { IPV6_UDP_HEADER UDP_HEADER PAYLOAD };
-  udp = (struct udphdr *) (v6_udp_packet + sizeof(struct ip6_hdr));
+  udp                     = (struct udphdr *)(v6_udp_packet + sizeof(struct ip6_hdr));
   fix_udp_checksum(v6_udp_packet);
   ASSERT_EQ(kUdpV6Checksum, udp->check) << "UDP/IPv6 packet checksum sanity check\n";
   check_packet(v6_udp_packet, sizeof(v6_udp_packet), "UDP/IPv6 packet sanity check");
@@ -773,53 +773,53 @@ TEST_F(ClatdTest, DataSanitycheck) {
   // Sanity checks reassemble_packet.
   uint8_t reassembled[MAXMTU];
   size_t total_length = sizeof(reassembled);
-  reassemble_packet(kIPv4Fragments, kIPv4FragLengths, ARRAYSIZE(kIPv4Fragments),
-                    reassembled, &total_length, "Reassembly sanity check");
+  reassemble_packet(kIPv4Fragments, kIPv4FragLengths, ARRAYSIZE(kIPv4Fragments), reassembled,
+                    &total_length, "Reassembly sanity check");
   check_packet(reassembled, total_length, "IPv4 Reassembled packet is valid");
   ASSERT_EQ(sizeof(kReassembledIPv4), total_length) << "IPv4 reassembly sanity check: length\n";
-  ASSERT_TRUE(!is_ipv4_fragment((struct iphdr *) reassembled))
-      << "Sanity check: reassembled packet is a fragment!\n";
+  ASSERT_TRUE(!is_ipv4_fragment((struct iphdr *)reassembled))
+    << "Sanity check: reassembled packet is a fragment!\n";
   check_data_matches(kReassembledIPv4, reassembled, total_length, "IPv4 reassembly sanity check");
 
   total_length = sizeof(reassembled);
-  reassemble_packet(kIPv6Fragments, kIPv6FragLengths, ARRAYSIZE(kIPv6Fragments),
-                    reassembled, &total_length, "IPv6 reassembly sanity check");
-  ASSERT_TRUE(!is_ipv6_fragment((struct ip6_hdr *) reassembled, total_length))
-      << "Sanity check: reassembled packet is a fragment!\n";
+  reassemble_packet(kIPv6Fragments, kIPv6FragLengths, ARRAYSIZE(kIPv6Fragments), reassembled,
+                    &total_length, "IPv6 reassembly sanity check");
+  ASSERT_TRUE(!is_ipv6_fragment((struct ip6_hdr *)reassembled, total_length))
+    << "Sanity check: reassembled packet is a fragment!\n";
   check_packet(reassembled, total_length, "IPv6 Reassembled packet is valid");
 }
 
 TEST_F(ClatdTest, PseudoChecksum) {
   uint32_t pseudo_checksum;
 
-  uint8_t v4_header[] = { IPV4_UDP_HEADER };
+  uint8_t v4_header[]        = { IPV4_UDP_HEADER };
   uint8_t v4_pseudo_header[] = { IPV4_PSEUDOHEADER(v4_header, UDP_LEN) };
-  pseudo_checksum = ipv4_pseudo_header_checksum((struct iphdr *) v4_header, UDP_LEN);
+  pseudo_checksum            = ipv4_pseudo_header_checksum((struct iphdr *)v4_header, UDP_LEN);
   EXPECT_EQ(ip_checksum_finish(pseudo_checksum),
             ip_checksum(v4_pseudo_header, sizeof(v4_pseudo_header)))
-            << "ipv4_pseudo_header_checksum incorrect\n";
+    << "ipv4_pseudo_header_checksum incorrect\n";
 
-  uint8_t v6_header[] = { IPV6_UDP_HEADER };
+  uint8_t v6_header[]        = { IPV6_UDP_HEADER };
   uint8_t v6_pseudo_header[] = { IPV6_PSEUDOHEADER(v6_header, IPPROTO_UDP, UDP_LEN) };
-  pseudo_checksum = ipv6_pseudo_header_checksum((struct ip6_hdr *) v6_header, UDP_LEN, IPPROTO_UDP);
+  pseudo_checksum = ipv6_pseudo_header_checksum((struct ip6_hdr *)v6_header, UDP_LEN, IPPROTO_UDP);
   EXPECT_EQ(ip_checksum_finish(pseudo_checksum),
             ip_checksum(v6_pseudo_header, sizeof(v6_pseudo_header)))
-            << "ipv6_pseudo_header_checksum incorrect\n";
+    << "ipv6_pseudo_header_checksum incorrect\n";
 }
 
 TEST_F(ClatdTest, TransportChecksum) {
-  uint8_t udphdr[] = { UDP_HEADER };
+  uint8_t udphdr[]  = { UDP_HEADER };
   uint8_t payload[] = { PAYLOAD };
   EXPECT_EQ(kUdpPartialChecksum, ip_checksum_add(0, udphdr, sizeof(udphdr)))
-            << "UDP partial checksum\n";
+    << "UDP partial checksum\n";
   EXPECT_EQ(kPayloadPartialChecksum, ip_checksum_add(0, payload, sizeof(payload)))
-            << "Payload partial checksum\n";
+    << "Payload partial checksum\n";
 
-  uint8_t ip[] = { IPV4_UDP_HEADER };
-  uint8_t ip6[] = { IPV6_UDP_HEADER };
-  uint32_t ipv4_pseudo_sum = ipv4_pseudo_header_checksum((struct iphdr *) ip, UDP_LEN);
-  uint32_t ipv6_pseudo_sum = ipv6_pseudo_header_checksum((struct ip6_hdr *) ip6, UDP_LEN,
-                                                         IPPROTO_UDP);
+  uint8_t ip[]             = { IPV4_UDP_HEADER };
+  uint8_t ip6[]            = { IPV6_UDP_HEADER };
+  uint32_t ipv4_pseudo_sum = ipv4_pseudo_header_checksum((struct iphdr *)ip, UDP_LEN);
+  uint32_t ipv6_pseudo_sum =
+    ipv6_pseudo_header_checksum((struct ip6_hdr *)ip6, UDP_LEN, IPPROTO_UDP);
 
   EXPECT_EQ(0x3ad0U, ipv4_pseudo_sum) << "IPv4 pseudo-checksum sanity check\n";
   EXPECT_EQ(0x2644bU, ipv6_pseudo_sum) << "IPv6 pseudo-checksum sanity check\n";
@@ -886,12 +886,10 @@ TEST_F(ClatdTest, Translate) {
 }
 
 TEST_F(ClatdTest, Fragmentation) {
-  check_fragment_translation(kIPv4Fragments, kIPv4FragLengths,
-                             kIPv6Fragments, kIPv6FragLengths,
+  check_fragment_translation(kIPv4Fragments, kIPv4FragLengths, kIPv6Fragments, kIPv6FragLengths,
                              ARRAYSIZE(kIPv4Fragments), "IPv4->IPv6 fragment translation");
 
-  check_fragment_translation(kIPv6Fragments, kIPv6FragLengths,
-                             kIPv4Fragments, kIPv4FragLengths,
+  check_fragment_translation(kIPv6Fragments, kIPv6FragLengths, kIPv4Fragments, kIPv4FragLengths,
                              ARRAYSIZE(kIPv6Fragments), "IPv6->IPv4 fragment translation");
 }
 
@@ -902,12 +900,12 @@ void check_translate_checksum_neutral(const uint8_t *original, size_t original_l
   do_translate_packet(original, original_len, translated, &translated_len, msg);
   EXPECT_EQ(expected_len, translated_len) << msg << ": Translated packet length incorrect\n";
   // do_translate_packet already checks packets for validity and verifies the checksum.
-  int original_check = get_transport_checksum(original);
+  int original_check   = get_transport_checksum(original);
   int translated_check = get_transport_checksum(translated);
   ASSERT_NE(-1, original_check);
   ASSERT_NE(-1, translated_check);
   ASSERT_EQ(original_check, translated_check)
-      << "Not checksum neutral: original and translated checksums differ\n";
+    << "Not checksum neutral: original and translated checksums differ\n";
 }
 
 TEST_F(ClatdTest, TranslateChecksumNeutral) {
@@ -916,8 +914,8 @@ TEST_F(ClatdTest, TranslateChecksumNeutral) {
   ASSERT_TRUE(inet_pton(AF_INET6, "2001:db8:1:2:f076:ae99:124e:aa54",
                         &Global_Clatd_Config.ipv6_local_subnet));
   config_generate_local_ipv6_subnet(&Global_Clatd_Config.ipv6_local_subnet);
-  ASSERT_NE((uint32_t) 0x00000464, Global_Clatd_Config.ipv6_local_subnet.s6_addr32[3]);
-  ASSERT_NE((uint32_t) 0, Global_Clatd_Config.ipv6_local_subnet.s6_addr32[3]);
+  ASSERT_NE((uint32_t)0x00000464, Global_Clatd_Config.ipv6_local_subnet.s6_addr32[3]);
+  ASSERT_NE((uint32_t)0, Global_Clatd_Config.ipv6_local_subnet.s6_addr32[3]);
 
   // Check that translating UDP packets is checksum-neutral. First, IPv4.
   uint8_t udp_ipv4[] = { IPV4_UDP_HEADER UDP_HEADER PAYLOAD };
@@ -928,7 +926,7 @@ TEST_F(ClatdTest, TranslateChecksumNeutral) {
   // Now try IPv6.
   uint8_t udp_ipv6[] = { IPV6_UDP_HEADER UDP_HEADER PAYLOAD };
   // The test packet uses the static IID, not the random IID. Fix up the source address.
-  struct ip6_hdr *ip6 = (struct ip6_hdr *) udp_ipv6;
+  struct ip6_hdr *ip6 = (struct ip6_hdr *)udp_ipv6;
   memcpy(&ip6->ip6_src, &Global_Clatd_Config.ipv6_local_subnet, sizeof(ip6->ip6_src));
   fix_udp_checksum(udp_ipv6);
   check_translate_checksum_neutral(udp_ipv4, sizeof(udp_ipv4), sizeof(udp_ipv4) + 20,