VPP-244 - Coding style cleanup vnet/vnet/sr

Change-Id: Ibbbaeacf9816ee0e7847cd53b45f9db48bddc85b
Signed-off-by: Keith Burns (alagalah) <alagalah@gmail.com>

4 files changed, 1558 insertions, 1452 deletions

diff --git a/vnet/vnet/sr/sr.c b/vnet/vnet/sr/sr.c
index d935b458ec9..484099d51c0 100644
--- a/vnet/vnet/sr/sr.c
+++ b/vnet/vnet/sr/sr.c
@@ -23,16 +23,16 @@
 ip6_sr_main_t sr_main;
 static vlib_node_registration_t sr_local_node;
 
-void sr_fix_hmac (ip6_sr_main_t * sm, ip6_header_t * ip, 
-                         ip6_sr_header_t * sr)
+void
+sr_fix_hmac (ip6_sr_main_t * sm, ip6_header_t * ip, ip6_sr_header_t * sr)
 {
   u32 key_index;
-  static u8 * keybuf;
-  u8 * copy_target;
+  static u8 *keybuf;
+  u8 *copy_target;
   int first_segment;
   ip6_address_t *addrp;
   int i;
-  ip6_sr_hmac_key_t * hmac_key;
+  ip6_sr_hmac_key_t *hmac_key;
   u32 sig_len;
 
   key_index = sr->hmac_key;
@@ -59,8 +59,8 @@ void sr_fix_hmac (ip6_sr_main_t * sm, ip6_header_t * ip,
 
   /* octet w/ bit 0 = "clean" flag */
   vec_add2 (keybuf, copy_target, 1);
-  copy_target[0] 
-    = (sr->flags & clib_host_to_net_u16 (IP6_SR_HEADER_FLAG_CLEANUP)) 
+  copy_target[0]
+    = (sr->flags & clib_host_to_net_u16 (IP6_SR_HEADER_FLAG_CLEANUP))
     ? 0x80 : 0;
 
   /* hmac key id */
@@ -81,18 +81,19 @@ void sr_fix_hmac (ip6_sr_main_t * sm, ip6_header_t * ip,
 
   addrp++;
 
-  HMAC_CTX_init(sm->hmac_ctx);
-  if (!HMAC_Init(sm->hmac_ctx, hmac_key->shared_secret,
-                 vec_len(hmac_key->shared_secret),sm->md))
-      clib_warning ("barf1");
-  if (!HMAC_Update(sm->hmac_ctx,keybuf,vec_len(keybuf)))
-      clib_warning ("barf2");
-  if (!HMAC_Final(sm->hmac_ctx, (unsigned char *) addrp, &sig_len))
-      clib_warning ("barf3");
-  HMAC_CTX_cleanup(sm->hmac_ctx);
+  HMAC_CTX_init (sm->hmac_ctx);
+  if (!HMAC_Init (sm->hmac_ctx, hmac_key->shared_secret,
+		  vec_len (hmac_key->shared_secret), sm->md))
+    clib_warning ("barf1");
+  if (!HMAC_Update (sm->hmac_ctx, keybuf, vec_len (keybuf)))
+    clib_warning ("barf2");
+  if (!HMAC_Final (sm->hmac_ctx, (unsigned char *) addrp, &sig_len))
+    clib_warning ("barf3");
+  HMAC_CTX_cleanup (sm->hmac_ctx);
 }
 
-u8 * format_ip6_sr_header_flags (u8 * s, va_list * args)
+u8 *
+format_ip6_sr_header_flags (u8 * s, va_list * args)
 {
   u16 flags = (u16) va_arg (*args, int);
   u8 pl_flag;
@@ -100,13 +101,13 @@ u8 * format_ip6_sr_header_flags (u8 * s, va_list * args)
   int i;
 
   if (bswap_needed)
-      flags = clib_host_to_net_u16 (flags);
+    flags = clib_host_to_net_u16 (flags);
 
   if (flags & IP6_SR_HEADER_FLAG_CLEANUP)
-      s = format (s, "cleanup ");
+    s = format (s, "cleanup ");
 
   if (flags & IP6_SR_HEADER_FLAG_PROTECTED)
-      s = format (s, "reroute ");
+    s = format (s, "reroute ");
 
   s = format (s, "pl: ");
   for (i = 1; i <= 4; i++)
@@ -115,46 +116,50 @@ u8 * format_ip6_sr_header_flags (u8 * s, va_list * args)
       s = format (s, "[%d] ", i);
 
       switch (pl_flag)
-        {
-        case IP6_SR_HEADER_FLAG_PL_ELT_NOT_PRESENT:
-          s = format (s, "NotPr ");
-          break;
-        case IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE:
-          s = format (s, "InPE ");
-          break;
-        case IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE:
-          s = format (s, "EgPE ");
-          break;
-
-        case IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR:
-          s = format (s, "OrgSrc ");
-          break;
-        }
+	{
+	case IP6_SR_HEADER_FLAG_PL_ELT_NOT_PRESENT:
+	  s = format (s, "NotPr ");
+	  break;
+	case IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE:
+	  s = format (s, "InPE ");
+	  break;
+	case IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE:
+	  s = format (s, "EgPE ");
+	  break;
+
+	case IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR:
+	  s = format (s, "OrgSrc ");
+	  break;
+	}
     }
   return s;
 }
 
-u8 * format_ip6_sr_header (u8 * s, va_list * args)
+u8 *
+format_ip6_sr_header (u8 * s, va_list * args)
 {
-  ip6_sr_header_t * h = va_arg (*args, ip6_sr_header_t *);
-  ip6_address_t placeholder_addr = {{254,254,254,254,254,254,254,254,254,254,254,254,254,254,254,254}};
+  ip6_sr_header_t *h = va_arg (*args, ip6_sr_header_t *);
+  ip6_address_t placeholder_addr =
+    { {254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254,
+       254, 254}
+  };
   int print_hmac = va_arg (*args, int);
   int i, pl_index, max_segs;
-  int flags_host_byte_order = clib_net_to_host_u16(h->flags);
+  int flags_host_byte_order = clib_net_to_host_u16 (h->flags);
 
   s = format (s, "next proto %d, len %d, type %d",
-              h->protocol, (h->length<<3)+8, h->type);
+	      h->protocol, (h->length << 3) + 8, h->type);
   s = format (s, "\n      segs left %d, first_segment %d, hmac key %d",
-              h->segments_left, h->first_segment, h->hmac_key);
-  s = format (s, "\n      flags %U", format_ip6_sr_header_flags, 
-              flags_host_byte_order, 0 /* bswap needed */ );
+	      h->segments_left, h->first_segment, h->hmac_key);
+  s = format (s, "\n      flags %U", format_ip6_sr_header_flags,
+	      flags_host_byte_order, 0 /* bswap needed */ );
 
   /* 
    * Header length is in 8-byte units (minus one), so
    * divide by 2 to ascertain the number of ip6 addresses in the
    * segment list
    */
-  max_segs = (h->length>>1);
+  max_segs = (h->length >> 1);
 
   if (!print_hmac && h->hmac_key)
     max_segs -= 2;
@@ -163,26 +168,26 @@ u8 * format_ip6_sr_header (u8 * s, va_list * args)
 
   for (i = h->first_segment; i >= 1; i--)
     s = format (s, "\n  %U", format_ip6_address, h->segments + i);
-  if (ip6_address_is_equal(&placeholder_addr, h->segments))
-	s = format (s, "\n  (empty placeholder)");
+  if (ip6_address_is_equal (&placeholder_addr, h->segments))
+    s = format (s, "\n  (empty placeholder)");
   else
-	s = format (s, "\n  %U", format_ip6_address, h->segments);
+    s = format (s, "\n  %U", format_ip6_address, h->segments);
 
   s = format (s, "\n  Policy List:");
 
-  pl_index = 1;                 /* to match the RFC text */
-  for (i = (h->first_segment+1); i < max_segs; i++, pl_index++)
+  pl_index = 1;			/* to match the RFC text */
+  for (i = (h->first_segment + 1); i < max_segs; i++, pl_index++)
     {
-      char * tag;
-      char * tags[] = {" ", "InPE: ", "EgPE: ", "OrgSrc: "};
+      char *tag;
+      char *tags[] = { " ", "InPE: ", "EgPE: ", "OrgSrc: " };
 
       tag = tags[0];
-      if (pl_index >=1 && pl_index <= 4)
-        {
-          int this_pl_flag = ip6_sr_policy_list_flags 
-            (flags_host_byte_order, pl_index);
-          tag = tags[this_pl_flag];
-        }
+      if (pl_index >= 1 && pl_index <= 4)
+	{
+	  int this_pl_flag = ip6_sr_policy_list_flags
+	    (flags_host_byte_order, pl_index);
+	  tag = tags[this_pl_flag];
+	}
 
       s = format (s, "\n  %s%U", tag, format_ip6_address, h->segments + i);
     }
@@ -190,9 +195,10 @@ u8 * format_ip6_sr_header (u8 * s, va_list * args)
   return s;
 }
 
-u8 * format_ip6_sr_header_with_length (u8 * s, va_list * args)
+u8 *
+format_ip6_sr_header_with_length (u8 * s, va_list * args)
 {
-  ip6_header_t * h = va_arg (*args, ip6_header_t *);
+  ip6_header_t *h = va_arg (*args, ip6_header_t *);
   u32 max_header_bytes = va_arg (*args, u32);
   uword header_bytes;
 
@@ -201,12 +207,13 @@ u8 * format_ip6_sr_header_with_length (u8 * s, va_list * args)
     return format (s, "ip6_sr header truncated");
 
   s = format (s, "IP6: %U\n", format_ip6_header, h, max_header_bytes);
-  s = format (s, "SR: %U\n", format_ip6_sr_header, (ip6_sr_header_t *)(h+1), 
-              0 /* print_hmac */, max_header_bytes);
+  s =
+    format (s, "SR: %U\n", format_ip6_sr_header, (ip6_sr_header_t *) (h + 1),
+	    0 /* print_hmac */ , max_header_bytes);
   return s;
 }
 
-#if DPDK > 0 /* Cannot call replicate yet without DPDK */
+#if DPDK > 0			/* Cannot call replicate yet without DPDK */
 #define foreach_sr_rewrite_next                 \
 _(ERROR, "error-drop")                          \
 _(IP6_LOOKUP, "ip6-lookup")                     \
@@ -216,17 +223,19 @@ _(SR_REPLICATE,"sr-replicate")
 #define foreach_sr_rewrite_next                 \
 _(ERROR, "error-drop")                          \
 _(IP6_LOOKUP, "ip6-lookup")                     \
-_(SR_LOCAL, "sr-local")                         
+_(SR_LOCAL, "sr-local")
 #endif /* DPDK */
 
-typedef enum {
+typedef enum
+{
 #define _(s,n) SR_REWRITE_NEXT_##s,
   foreach_sr_rewrite_next
 #undef _
-  SR_REWRITE_N_NEXT,
+    SR_REWRITE_N_NEXT,
 } sr_rewrite_next_t;
 
-typedef struct {
+typedef struct
+{
   ip6_address_t src, dst;
   u16 length;
   u32 next_index;
@@ -234,13 +243,14 @@ typedef struct {
   u8 sr[256];
 } sr_rewrite_trace_t;
 
-static char * sr_rewrite_error_strings[] = {
+static char *sr_rewrite_error_strings[] = {
 #define sr_error(n,s) s,
 #include "sr_error.def"
 #undef sr_error
 };
 
-typedef enum {
+typedef enum
+{
 #define sr_error(n,s) SR_REWRITE_ERROR_##n,
 #include "sr_error.def"
 #undef sr_error
@@ -248,46 +258,45 @@ typedef enum {
 } sr_rewrite_error_t;
 
 
-u8 * format_sr_rewrite_trace (u8 * s, va_list * args)
+u8 *
+format_sr_rewrite_trace (u8 * s, va_list * args)
 {
   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
-  sr_rewrite_trace_t * t = va_arg (*args, sr_rewrite_trace_t *);
-  ip6_main_t * im = &ip6_main;
-  ip6_sr_main_t * sm = &sr_main;
+  sr_rewrite_trace_t *t = va_arg (*args, sr_rewrite_trace_t *);
+  ip6_main_t *im = &ip6_main;
+  ip6_sr_main_t *sm = &sr_main;
   ip6_sr_tunnel_t *tun = pool_elt_at_index (sm->tunnels, t->tunnel_index);
-  ip6_fib_t * rx_fib, * tx_fib;
-  
-  rx_fib = find_ip6_fib_by_table_index_or_id (im, tun->rx_fib_index, 
-                                              IP6_ROUTE_FLAG_FIB_INDEX);
-
-  tx_fib = find_ip6_fib_by_table_index_or_id (im, tun->tx_fib_index, 
-                                              IP6_ROUTE_FLAG_FIB_INDEX);
-
-  s = format 
-    (s, "SR-REWRITE: next %s ip6 src %U dst %U len %u\n" 
-     "           rx-fib-id %d tx-fib-id %d\n%U", 
-     (t->next_index == SR_REWRITE_NEXT_SR_LOCAL) 
+  ip6_fib_t *rx_fib, *tx_fib;
+
+  rx_fib = find_ip6_fib_by_table_index_or_id (im, tun->rx_fib_index,
+					      IP6_ROUTE_FLAG_FIB_INDEX);
+
+  tx_fib = find_ip6_fib_by_table_index_or_id (im, tun->tx_fib_index,
+					      IP6_ROUTE_FLAG_FIB_INDEX);
+
+  s = format
+    (s, "SR-REWRITE: next %s ip6 src %U dst %U len %u\n"
+     "           rx-fib-id %d tx-fib-id %d\n%U",
+     (t->next_index == SR_REWRITE_NEXT_SR_LOCAL)
      ? "sr-local" : "ip6-lookup",
-     format_ip6_address, &t->src, 
-     format_ip6_address, &t->dst, t->length, 
-     rx_fib->table_id, tx_fib->table_id, 
-     format_ip6_sr_header, t->sr, 0 /* print_hmac */);
+     format_ip6_address, &t->src,
+     format_ip6_address, &t->dst, t->length,
+     rx_fib->table_id, tx_fib->table_id,
+     format_ip6_sr_header, t->sr, 0 /* print_hmac */ );
   return s;
 }
 
 static uword
 sr_rewrite (vlib_main_t * vm,
-                   vlib_node_runtime_t * node,
-                   vlib_frame_t * from_frame)
+	    vlib_node_runtime_t * node, vlib_frame_t * from_frame)
 {
-  u32 n_left_from, next_index, * from, * to_next;
-  ip6_main_t * im = &ip6_main;
-  ip_lookup_main_t * lm = &im->lookup_main;
-  ip6_sr_main_t * sm = &sr_main;
+  u32 n_left_from, next_index, *from, *to_next;
+  ip6_main_t *im = &ip6_main;
+  ip_lookup_main_t *lm = &im->lookup_main;
+  ip6_sr_main_t *sm = &sr_main;
   u32 (*sr_local_cb) (vlib_main_t *, vlib_node_runtime_t *,
-                      vlib_buffer_t *, ip6_header_t *, 
-                      ip6_sr_header_t *);
+		      vlib_buffer_t *, ip6_header_t *, ip6_sr_header_t *);
   sr_local_cb = sm->sr_local_cb;
 
   from = vlib_frame_vector_args (from_frame);
@@ -299,30 +308,29 @@ sr_rewrite (vlib_main_t * vm,
     {
       u32 n_left_to_next;
 
-      vlib_get_next_frame (vm, node, next_index,
-			   to_next, n_left_to_next);
+      vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 
       /* Note 2x loop disabled */
       while (0 && n_left_from >= 4 && n_left_to_next >= 2)
 	{
 	  u32 bi0, bi1;
-	  vlib_buffer_t * b0, * b1;
-          ip6_header_t * ip0, * ip1;
-          ip_adjacency_t * adj0, * adj1;
-          ip6_sr_header_t * sr0, * sr1;
-          ip6_sr_tunnel_t * t0, *t1;
+	  vlib_buffer_t *b0, *b1;
+	  ip6_header_t *ip0, *ip1;
+	  ip_adjacency_t *adj0, *adj1;
+	  ip6_sr_header_t *sr0, *sr1;
+	  ip6_sr_tunnel_t *t0, *t1;
 	  u32 next0 = SR_REWRITE_NEXT_IP6_LOOKUP;
 	  u32 next1 = SR_REWRITE_NEXT_IP6_LOOKUP;
-          u16 new_l0 = 0;
+	  u16 new_l0 = 0;
 	  u16 new_l1 = 0;
 
 	  /* Prefetch next iteration. */
 	  {
-	    vlib_buffer_t * p2, * p3;
+	    vlib_buffer_t *p2, *p3;
 
 	    p2 = vlib_get_buffer (vm, from[2]);
 	    p3 = vlib_get_buffer (vm, from[3]);
-            
+
 	    vlib_prefetch_buffer_header (p2, LOAD);
 	    vlib_prefetch_buffer_header (p3, LOAD);
 	  }
@@ -339,175 +347,175 @@ sr_rewrite (vlib_main_t * vm,
 	  b0 = vlib_get_buffer (vm, bi0);
 	  b1 = vlib_get_buffer (vm, bi1);
 
-          /* 
-           * $$$ parse through header(s) to pick the point
-           * where we punch in the SR extention header
-           */
-          
-          adj0 = ip_get_adjacency (lm, vnet_buffer(b0)->ip.adj_index[VLIB_TX]);
-          adj1 = ip_get_adjacency (lm, vnet_buffer(b1)->ip.adj_index[VLIB_TX]);
-          t0 = pool_elt_at_index (sm->tunnels, 
-                                  adj0->rewrite_header.sw_if_index);
-          t1 = pool_elt_at_index (sm->tunnels, 
-                                  adj1->rewrite_header.sw_if_index);
-
-          ASSERT (VLIB_BUFFER_PRE_DATA_SIZE
-                  >= ((word) vec_len (t0->rewrite)) + b0->current_data);
-          ASSERT (VLIB_BUFFER_PRE_DATA_SIZE
-                  >= ((word) vec_len (t1->rewrite)) + b1->current_data);
-          
-          vnet_buffer(b0)->sw_if_index[VLIB_TX] = t0->tx_fib_index;
-          vnet_buffer(b1)->sw_if_index[VLIB_TX] = t1->tx_fib_index;
-
-          ip0 = vlib_buffer_get_current (b0);
-          ip1 = vlib_buffer_get_current (b1);
-
-          /* 
-           * SR-unaware service chaining case: pkt coming back from
-           * service has the original dst address, and will already
-           * have an SR header. If so, send it to sr-local 
-           */
-          if (PREDICT_FALSE(ip0->protocol == IPPROTO_IPV6_ROUTE))
-            {
-              vlib_buffer_advance (b0, sizeof(ip0));
-              sr0 = (ip6_sr_header_t *) (ip0+1);
-              new_l0 = clib_net_to_host_u16(ip0->payload_length);
-              next0 = SR_REWRITE_NEXT_SR_LOCAL;
-            }
-          else
-            {
-              /* 
-               * Copy data before the punch-in point left by the 
-               * required amount. Assume (for the moment) that only 
-               * the main packet header needs to be copied.
-               */
-              clib_memcpy (((u8 *)ip0) - vec_len (t0->rewrite),
-                           ip0, sizeof (ip6_header_t));
-              vlib_buffer_advance (b0, - (word) vec_len(t0->rewrite));
-              ip0 = vlib_buffer_get_current (b0);
-              sr0 = (ip6_sr_header_t *) (ip0+1);
-              /* $$$ tune */
-              clib_memcpy (sr0, t0->rewrite, vec_len (t0->rewrite));
-
-              /* Fix the next header chain */
-              sr0->protocol = ip0->protocol;
-              ip0->protocol = IPPROTO_IPV6_ROUTE; /* routing extension header */
-              new_l0 = clib_net_to_host_u16(ip0->payload_length) +
-                vec_len (t0->rewrite);
-              ip0->payload_length = clib_host_to_net_u16(new_l0);
-
-              /* Copy dst address into the DA slot in the segment list */
-              clib_memcpy (sr0->segments, ip0->dst_address.as_u64,
-                           sizeof (ip6_address_t));
-              /* Rewrite the ip6 dst address with the first hop */
-              clib_memcpy (ip0->dst_address.as_u64, t0->first_hop.as_u64,
-                           sizeof (ip6_address_t));
-
-              sr_fix_hmac (sm, ip0, sr0);
-
-              next0 = sr_local_cb ? sr_local_cb (vm, node, b0, ip0, sr0) :
-                  next0;
-
-              /* 
-               * Ignore "do not rewrite" shtik in this path
-               */
-              if (PREDICT_FALSE (next0 & 0x80000000))
-              {
-                  next0 ^= 0xFFFFFFFF;
-                  if (PREDICT_FALSE(next0 == SR_REWRITE_NEXT_ERROR))
-                      b0->error = 
-                          node->errors[SR_REWRITE_ERROR_APP_CALLBACK];
-              }
-            }
-
-          if (PREDICT_FALSE(ip1->protocol == IPPROTO_IPV6_ROUTE))
-            {
-              vlib_buffer_advance (b1, sizeof(ip1));
-              sr1 = (ip6_sr_header_t *) (ip1+1);
-              new_l1 = clib_net_to_host_u16(ip1->payload_length);
-              next1 = SR_REWRITE_NEXT_SR_LOCAL;
-            }
-          else
-            {
-              clib_memcpy (((u8 *)ip0) - vec_len (t0->rewrite),
-                           ip0, sizeof (ip6_header_t));
-              vlib_buffer_advance (b1, - (word) vec_len(t1->rewrite));
-              ip1 = vlib_buffer_get_current (b1);
-              sr1 = (ip6_sr_header_t *) (ip1+1);
-              clib_memcpy (sr1, t1->rewrite, vec_len (t1->rewrite));
-
-              sr1->protocol = ip1->protocol;
-              ip1->protocol = IPPROTO_IPV6_ROUTE;
-              new_l1 = clib_net_to_host_u16(ip1->payload_length) +
-                vec_len (t1->rewrite);
-              ip1->payload_length = clib_host_to_net_u16(new_l1);
-
-              /* Copy dst address into the DA slot in the segment list */
-              clib_memcpy (sr1->segments, ip1->dst_address.as_u64,
-                           sizeof (ip6_address_t));
-              /* Rewrite the ip6 dst address with the first hop */
-              clib_memcpy (ip1->dst_address.as_u64, t1->first_hop.as_u64,
-                           sizeof (ip6_address_t));
-
-              sr_fix_hmac (sm, ip1, sr1);
-
-              next1 = sr_local_cb ? sr_local_cb (vm, node, b1, ip1, sr1) :
-                  next1;
-
-              /* 
-               * Ignore "do not rewrite" shtik in this path
-               */
-              if (PREDICT_FALSE (next1 & 0x80000000))
-              {
-                  next1 ^= 0xFFFFFFFF;
-                  if (PREDICT_FALSE(next1 == SR_REWRITE_NEXT_ERROR))
-                      b1->error = 
-                          node->errors[SR_REWRITE_ERROR_APP_CALLBACK];
-              }
-            }
-
-          if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) 
-            {
-              sr_rewrite_trace_t *tr = vlib_add_trace (vm, node, 
-                                                       b0, sizeof (*tr));
-              tr->tunnel_index = t0 - sm->tunnels;
-              clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
-                      sizeof (tr->src.as_u8));
-              clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
-                      sizeof (tr->dst.as_u8));
-              tr->length = new_l0;
-              tr->next_index = next0;
-              clib_memcpy (tr->sr, sr0, sizeof (tr->sr));
-            }
-          if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED)) 
-            {
-              sr_rewrite_trace_t *tr = vlib_add_trace (vm, node, 
-                                                       b1, sizeof (*tr));
-              tr->tunnel_index = t1 - sm->tunnels;
-              clib_memcpy (tr->src.as_u8, ip1->src_address.as_u8,
-                      sizeof (tr->src.as_u8));
-              clib_memcpy (tr->dst.as_u8, ip1->dst_address.as_u8,
-                      sizeof (tr->dst.as_u8));
-              tr->length = new_l1;
-              tr->next_index = next1;
-              clib_memcpy (tr->sr, sr1, sizeof (tr->sr));
-            }
+	  /* 
+	   * $$$ parse through header(s) to pick the point
+	   * where we punch in the SR extention header
+	   */
+
+	  adj0 =
+	    ip_get_adjacency (lm, vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
+	  adj1 =
+	    ip_get_adjacency (lm, vnet_buffer (b1)->ip.adj_index[VLIB_TX]);
+	  t0 =
+	    pool_elt_at_index (sm->tunnels, adj0->rewrite_header.sw_if_index);
+	  t1 =
+	    pool_elt_at_index (sm->tunnels, adj1->rewrite_header.sw_if_index);
+
+	  ASSERT (VLIB_BUFFER_PRE_DATA_SIZE
+		  >= ((word) vec_len (t0->rewrite)) + b0->current_data);
+	  ASSERT (VLIB_BUFFER_PRE_DATA_SIZE
+		  >= ((word) vec_len (t1->rewrite)) + b1->current_data);
+
+	  vnet_buffer (b0)->sw_if_index[VLIB_TX] = t0->tx_fib_index;
+	  vnet_buffer (b1)->sw_if_index[VLIB_TX] = t1->tx_fib_index;
+
+	  ip0 = vlib_buffer_get_current (b0);
+	  ip1 = vlib_buffer_get_current (b1);
+
+	  /* 
+	   * SR-unaware service chaining case: pkt coming back from
+	   * service has the original dst address, and will already
+	   * have an SR header. If so, send it to sr-local 
+	   */
+	  if (PREDICT_FALSE (ip0->protocol == IPPROTO_IPV6_ROUTE))
+	    {
+	      vlib_buffer_advance (b0, sizeof (ip0));
+	      sr0 = (ip6_sr_header_t *) (ip0 + 1);
+	      new_l0 = clib_net_to_host_u16 (ip0->payload_length);
+	      next0 = SR_REWRITE_NEXT_SR_LOCAL;
+	    }
+	  else
+	    {
+	      /* 
+	       * Copy data before the punch-in point left by the 
+	       * required amount. Assume (for the moment) that only 
+	       * the main packet header needs to be copied.
+	       */
+	      clib_memcpy (((u8 *) ip0) - vec_len (t0->rewrite),
+			   ip0, sizeof (ip6_header_t));
+	      vlib_buffer_advance (b0, -(word) vec_len (t0->rewrite));
+	      ip0 = vlib_buffer_get_current (b0);
+	      sr0 = (ip6_sr_header_t *) (ip0 + 1);
+	      /* $$$ tune */
+	      clib_memcpy (sr0, t0->rewrite, vec_len (t0->rewrite));
+
+	      /* Fix the next header chain */
+	      sr0->protocol = ip0->protocol;
+	      ip0->protocol = IPPROTO_IPV6_ROUTE;	/* routing extension header */
+	      new_l0 = clib_net_to_host_u16 (ip0->payload_length) +
+		vec_len (t0->rewrite);
+	      ip0->payload_length = clib_host_to_net_u16 (new_l0);
+
+	      /* Copy dst address into the DA slot in the segment list */
+	      clib_memcpy (sr0->segments, ip0->dst_address.as_u64,
+			   sizeof (ip6_address_t));
+	      /* Rewrite the ip6 dst address with the first hop */
+	      clib_memcpy (ip0->dst_address.as_u64, t0->first_hop.as_u64,
+			   sizeof (ip6_address_t));
+
+	      sr_fix_hmac (sm, ip0, sr0);
+
+	      next0 = sr_local_cb ? sr_local_cb (vm, node, b0, ip0, sr0) :
+		next0;
+
+	      /* 
+	       * Ignore "do not rewrite" shtik in this path
+	       */
+	      if (PREDICT_FALSE (next0 & 0x80000000))
+		{
+		  next0 ^= 0xFFFFFFFF;
+		  if (PREDICT_FALSE (next0 == SR_REWRITE_NEXT_ERROR))
+		    b0->error = node->errors[SR_REWRITE_ERROR_APP_CALLBACK];
+		}
+	    }
+
+	  if (PREDICT_FALSE (ip1->protocol == IPPROTO_IPV6_ROUTE))
+	    {
+	      vlib_buffer_advance (b1, sizeof (ip1));
+	      sr1 = (ip6_sr_header_t *) (ip1 + 1);
+	      new_l1 = clib_net_to_host_u16 (ip1->payload_length);
+	      next1 = SR_REWRITE_NEXT_SR_LOCAL;
+	    }
+	  else
+	    {
+	      clib_memcpy (((u8 *) ip0) - vec_len (t0->rewrite),
+			   ip0, sizeof (ip6_header_t));
+	      vlib_buffer_advance (b1, -(word) vec_len (t1->rewrite));
+	      ip1 = vlib_buffer_get_current (b1);
+	      sr1 = (ip6_sr_header_t *) (ip1 + 1);
+	      clib_memcpy (sr1, t1->rewrite, vec_len (t1->rewrite));
+
+	      sr1->protocol = ip1->protocol;
+	      ip1->protocol = IPPROTO_IPV6_ROUTE;
+	      new_l1 = clib_net_to_host_u16 (ip1->payload_length) +
+		vec_len (t1->rewrite);
+	      ip1->payload_length = clib_host_to_net_u16 (new_l1);
+
+	      /* Copy dst address into the DA slot in the segment list */
+	      clib_memcpy (sr1->segments, ip1->dst_address.as_u64,
+			   sizeof (ip6_address_t));
+	      /* Rewrite the ip6 dst address with the first hop */
+	      clib_memcpy (ip1->dst_address.as_u64, t1->first_hop.as_u64,
+			   sizeof (ip6_address_t));
+
+	      sr_fix_hmac (sm, ip1, sr1);
+
+	      next1 = sr_local_cb ? sr_local_cb (vm, node, b1, ip1, sr1) :
+		next1;
+
+	      /* 
+	       * Ignore "do not rewrite" shtik in this path
+	       */
+	      if (PREDICT_FALSE (next1 & 0x80000000))
+		{
+		  next1 ^= 0xFFFFFFFF;
+		  if (PREDICT_FALSE (next1 == SR_REWRITE_NEXT_ERROR))
+		    b1->error = node->errors[SR_REWRITE_ERROR_APP_CALLBACK];
+		}
+	    }
+
+	  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
+	    {
+	      sr_rewrite_trace_t *tr = vlib_add_trace (vm, node,
+						       b0, sizeof (*tr));
+	      tr->tunnel_index = t0 - sm->tunnels;
+	      clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
+			   sizeof (tr->src.as_u8));
+	      clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
+			   sizeof (tr->dst.as_u8));
+	      tr->length = new_l0;
+	      tr->next_index = next0;
+	      clib_memcpy (tr->sr, sr0, sizeof (tr->sr));
+	    }
+	  if (PREDICT_FALSE (b1->flags & VLIB_BUFFER_IS_TRACED))
+	    {
+	      sr_rewrite_trace_t *tr = vlib_add_trace (vm, node,
+						       b1, sizeof (*tr));
+	      tr->tunnel_index = t1 - sm->tunnels;
+	      clib_memcpy (tr->src.as_u8, ip1->src_address.as_u8,
+			   sizeof (tr->src.as_u8));
+	      clib_memcpy (tr->dst.as_u8, ip1->dst_address.as_u8,
+			   sizeof (tr->dst.as_u8));
+	      tr->length = new_l1;
+	      tr->next_index = next1;
+	      clib_memcpy (tr->sr, sr1, sizeof (tr->sr));
+	    }
 
 	  vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
 					   to_next, n_left_to_next,
 					   bi0, bi1, next0, next1);
-        }
+	}
 
       while (n_left_from > 0 && n_left_to_next > 0)
 	{
 	  u32 bi0;
-	  vlib_buffer_t * b0;
-          ip6_header_t * ip0 = 0;
-          ip_adjacency_t * adj0;
-          ip6_sr_header_t * sr0 = 0;
-          ip6_sr_tunnel_t * t0;
+	  vlib_buffer_t *b0;
+	  ip6_header_t *ip0 = 0;
+	  ip_adjacency_t *adj0;
+	  ip6_sr_header_t *sr0 = 0;
+	  ip6_sr_tunnel_t *t0;
 	  u32 next0 = SR_REWRITE_NEXT_IP6_LOOKUP;
-          u16 new_l0 = 0;
+	  u16 new_l0 = 0;
 
 	  bi0 = from[0];
 	  to_next[0] = bi0;
@@ -518,109 +526,109 @@ sr_rewrite (vlib_main_t * vm,
 
 	  b0 = vlib_get_buffer (vm, bi0);
 
-          /* 
-           * $$$ parse through header(s) to pick the point
-           * where we punch in the SR extention header
-           */
-          
-          adj0 = ip_get_adjacency (lm, vnet_buffer(b0)->ip.adj_index[VLIB_TX]);
-          t0 = pool_elt_at_index (sm->tunnels, 
-                                  adj0->rewrite_header.sw_if_index);
+	  /* 
+	   * $$$ parse through header(s) to pick the point
+	   * where we punch in the SR extention header
+	   */
 
-#if DPDK > 0 /* Cannot call replication node yet without DPDK */
+	  adj0 =
+	    ip_get_adjacency (lm, vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
+	  t0 =
+	    pool_elt_at_index (sm->tunnels, adj0->rewrite_header.sw_if_index);
+
+#if DPDK > 0			/* Cannot call replication node yet without DPDK */
 	  /* add a replication node */
-	  if(PREDICT_FALSE(t0->policy_index != ~0))
+	  if (PREDICT_FALSE (t0->policy_index != ~0))
 	    {
-	      vnet_buffer(b0)->ip.save_protocol = t0->policy_index;
-	      next0=SR_REWRITE_NEXT_SR_REPLICATE;
+	      vnet_buffer (b0)->ip.save_protocol = t0->policy_index;
+	      next0 = SR_REWRITE_NEXT_SR_REPLICATE;
 	      goto trace0;
 	    }
 #endif /* DPDK */
 
-          ASSERT (VLIB_BUFFER_PRE_DATA_SIZE
-                  >= ((word) vec_len (t0->rewrite)) + b0->current_data);
-          
-          vnet_buffer(b0)->sw_if_index[VLIB_TX] = t0->tx_fib_index;
-
-          ip0 = vlib_buffer_get_current (b0);
-
-          /* 
-           * SR-unaware service chaining case: pkt coming back from
-           * service has the original dst address, and will already
-           * have an SR header. If so, send it to sr-local 
-           */
-          if (PREDICT_FALSE(ip0->protocol == IPPROTO_IPV6_ROUTE))
-            {
-              vlib_buffer_advance (b0, sizeof(ip0));
-              sr0 = (ip6_sr_header_t *) (ip0+1);
-              new_l0 = clib_net_to_host_u16(ip0->payload_length);
-              next0 = SR_REWRITE_NEXT_SR_LOCAL;
-            }
-          else
-            {
-              /* 
-               * Copy data before the punch-in point left by the 
-               * required amount. Assume (for the moment) that only 
-               * the main packet header needs to be copied.
-               */
-              clib_memcpy (((u8 *)ip0) - vec_len (t0->rewrite),
-                           ip0, sizeof (ip6_header_t));
-              vlib_buffer_advance (b0, - (word) vec_len(t0->rewrite));
-              ip0 = vlib_buffer_get_current (b0);
-              sr0 = (ip6_sr_header_t *) (ip0+1);
-              /* $$$ tune */
-              clib_memcpy (sr0, t0->rewrite, vec_len (t0->rewrite));
-
-              /* Fix the next header chain */
-              sr0->protocol = ip0->protocol;
-              ip0->protocol = IPPROTO_IPV6_ROUTE; /* routing extension header */
-              new_l0 = clib_net_to_host_u16(ip0->payload_length) +
-                vec_len (t0->rewrite);
-              ip0->payload_length = clib_host_to_net_u16(new_l0);
-
-              /* Copy dst address into the DA slot in the segment list */
-              clib_memcpy (sr0->segments, ip0->dst_address.as_u64,
-                           sizeof (ip6_address_t));
-              /* Rewrite the ip6 dst address with the first hop */
-              clib_memcpy (ip0->dst_address.as_u64, t0->first_hop.as_u64,
-                           sizeof (ip6_address_t));
-
-              sr_fix_hmac (sm, ip0, sr0);
-
-              next0 = sr_local_cb ? sr_local_cb (vm, node, b0, ip0, sr0) :
-                  next0;
-
-              /* 
-               * Ignore "do not rewrite" shtik in this path
-               */
-              if (PREDICT_FALSE (next0 & 0x80000000))
-              {
-                  next0 ^= 0xFFFFFFFF;
-                  if (PREDICT_FALSE(next0 == SR_REWRITE_NEXT_ERROR))
-                      b0->error = 
-                          node->errors[SR_REWRITE_ERROR_APP_CALLBACK];
-              }
-            }
-
-#if DPDK > 0 /* Cannot run replicate without DPDK and only replicate uses this label */
+	  ASSERT (VLIB_BUFFER_PRE_DATA_SIZE
+		  >= ((word) vec_len (t0->rewrite)) + b0->current_data);
+
+	  vnet_buffer (b0)->sw_if_index[VLIB_TX] = t0->tx_fib_index;
+
+	  ip0 = vlib_buffer_get_current (b0);
+
+	  /* 
+	   * SR-unaware service chaining case: pkt coming back from
+	   * service has the original dst address, and will already
+	   * have an SR header. If so, send it to sr-local 
+	   */
+	  if (PREDICT_FALSE (ip0->protocol == IPPROTO_IPV6_ROUTE))
+	    {
+	      vlib_buffer_advance (b0, sizeof (ip0));
+	      sr0 = (ip6_sr_header_t *) (ip0 + 1);
+	      new_l0 = clib_net_to_host_u16 (ip0->payload_length);
+	      next0 = SR_REWRITE_NEXT_SR_LOCAL;
+	    }
+	  else
+	    {
+	      /* 
+	       * Copy data before the punch-in point left by the 
+	       * required amount. Assume (for the moment) that only 
+	       * the main packet header needs to be copied.
+	       */
+	      clib_memcpy (((u8 *) ip0) - vec_len (t0->rewrite),
+			   ip0, sizeof (ip6_header_t));
+	      vlib_buffer_advance (b0, -(word) vec_len (t0->rewrite));
+	      ip0 = vlib_buffer_get_current (b0);
+	      sr0 = (ip6_sr_header_t *) (ip0 + 1);
+	      /* $$$ tune */
+	      clib_memcpy (sr0, t0->rewrite, vec_len (t0->rewrite));
+
+	      /* Fix the next header chain */
+	      sr0->protocol = ip0->protocol;
+	      ip0->protocol = IPPROTO_IPV6_ROUTE;	/* routing extension header */
+	      new_l0 = clib_net_to_host_u16 (ip0->payload_length) +
+		vec_len (t0->rewrite);
+	      ip0->payload_length = clib_host_to_net_u16 (new_l0);
+
+	      /* Copy dst address into the DA slot in the segment list */
+	      clib_memcpy (sr0->segments, ip0->dst_address.as_u64,
+			   sizeof (ip6_address_t));
+	      /* Rewrite the ip6 dst address with the first hop */
+	      clib_memcpy (ip0->dst_address.as_u64, t0->first_hop.as_u64,
+			   sizeof (ip6_address_t));
+
+	      sr_fix_hmac (sm, ip0, sr0);
+
+	      next0 = sr_local_cb ? sr_local_cb (vm, node, b0, ip0, sr0) :
+		next0;
+
+	      /* 
+	       * Ignore "do not rewrite" shtik in this path
+	       */
+	      if (PREDICT_FALSE (next0 & 0x80000000))
+		{
+		  next0 ^= 0xFFFFFFFF;
+		  if (PREDICT_FALSE (next0 == SR_REWRITE_NEXT_ERROR))
+		    b0->error = node->errors[SR_REWRITE_ERROR_APP_CALLBACK];
+		}
+	    }
+
+#if DPDK > 0			/* Cannot run replicate without DPDK and only replicate uses this label */
 	trace0:
 #endif /* DPDK */
-          if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) 
-            {
-              sr_rewrite_trace_t *tr = vlib_add_trace (vm, node, 
-                                                       b0, sizeof (*tr));
-              tr->tunnel_index = t0 - sm->tunnels;
+	  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
+	    {
+	      sr_rewrite_trace_t *tr = vlib_add_trace (vm, node,
+						       b0, sizeof (*tr));
+	      tr->tunnel_index = t0 - sm->tunnels;
 	      if (ip0)
 		{
 		  memcpy (tr->src.as_u8, ip0->src_address.as_u8,
-                      sizeof (tr->src.as_u8));
+			  sizeof (tr->src.as_u8));
 		  memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
-                      sizeof (tr->dst.as_u8));
+			  sizeof (tr->dst.as_u8));
 		}
-              tr->length = new_l0;
-              tr->next_index = next0;
-              clib_memcpy (tr->sr, sr0, sizeof (tr->sr));
-            }
+	      tr->length = new_l0;
+	      tr->next_index = next0;
+	      clib_memcpy (tr->sr, sr0, sizeof (tr->sr));
+	    }
 
 	  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 					   to_next, n_left_to_next,
@@ -632,6 +640,7 @@ sr_rewrite (vlib_main_t * vm,
   return from_frame->n_vectors;
 }
 
+/* *INDENT-OFF* */
 VLIB_REGISTER_NODE (sr_rewrite_node) = {
   .function = sr_rewrite,
   .name = "sr-rewrite",
@@ -652,55 +661,53 @@ VLIB_REGISTER_NODE (sr_rewrite_node) = {
 #undef _
   },
 };
+/* *INDENT-ON* */
 
 VLIB_NODE_FUNCTION_MULTIARCH (sr_rewrite_node, sr_rewrite)
-
-static int ip6_delete_route_no_next_hop (ip6_address_t *dst_address_arg, 
-                                         u32 dst_address_length, 
-                                         u32 rx_table_id)
+     static int ip6_delete_route_no_next_hop (ip6_address_t * dst_address_arg,
+					      u32 dst_address_length,
+					      u32 rx_table_id)
 {
   ip6_add_del_route_args_t a;
   ip6_address_t dst_address;
-  ip6_fib_t * fib;
-  ip6_main_t * im6 = &ip6_main;
-  BVT(clib_bihash_kv) kv, value;
-  
-  fib = find_ip6_fib_by_table_index_or_id (im6, rx_table_id, 
-                                           IP6_ROUTE_FLAG_TABLE_ID);
+  ip6_fib_t *fib;
+  ip6_main_t *im6 = &ip6_main;
+  BVT (clib_bihash_kv) kv, value;
+
+  fib = find_ip6_fib_by_table_index_or_id (im6, rx_table_id,
+					   IP6_ROUTE_FLAG_TABLE_ID);
   memset (&a, 0, sizeof (a));
   a.flags |= IP4_ROUTE_FLAG_DEL;
   a.dst_address_length = dst_address_length;
 
   dst_address = *dst_address_arg;
-  
-  ip6_address_mask (&dst_address, 
-                    &im6->fib_masks[dst_address_length]);
-  
+
+  ip6_address_mask (&dst_address, &im6->fib_masks[dst_address_length]);
+
   kv.key[0] = dst_address.as_u64[0];
   kv.key[1] = dst_address.as_u64[1];
-  kv.key[2] = ((u64)((fib - im6->fibs))<<32) | dst_address_length;
-  
-  if (BV(clib_bihash_search)(&im6->ip6_lookup_table, &kv, &value) < 0)
+  kv.key[2] = ((u64) ((fib - im6->fibs)) << 32) | dst_address_length;
+
+  if (BV (clib_bihash_search) (&im6->ip6_lookup_table, &kv, &value) < 0)
     {
       clib_warning ("%U/%d not in FIB",
-                    format_ip6_address, &a.dst_address,
-                    a.dst_address_length);
+		    format_ip6_address, &a.dst_address, a.dst_address_length);
       return -10;
     }
 
   a.adj_index = value.value;
   a.dst_address = dst_address;
-  
+
   ip6_add_del_route (im6, &a);
   ip6_maybe_remap_adjacencies (im6, rx_table_id, IP6_ROUTE_FLAG_TABLE_ID);
   return 0;
 }
 
-static ip6_sr_hmac_key_t * 
+static ip6_sr_hmac_key_t *
 find_or_add_shared_secret (ip6_sr_main_t * sm, u8 * secret, u32 * indexp)
 {
-  uword * p;
-  ip6_sr_hmac_key_t * key = 0;
+  uword *p;
+  ip6_sr_hmac_key_t *key = 0;
   int i;
 
   p = hash_get_mem (sm->hmac_key_by_shared_secret, secret);
@@ -709,7 +716,7 @@ find_or_add_shared_secret (ip6_sr_main_t * sm, u8 * secret, u32 * indexp)
     {
       key = vec_elt_at_index (sm->hmac_keys, p[0]);
       if (indexp)
-        *indexp = p[0];
+	*indexp = p[0];
       return (key);
     }
 
@@ -722,13 +729,13 @@ find_or_add_shared_secret (ip6_sr_main_t * sm, u8 * secret, u32 * indexp)
   else
     {
       for (i = 0; i < vec_len (sm->hmac_keys); i++)
-        {
-          if (sm->hmac_keys[i].shared_secret == 0)
-            {
-              key = sm->hmac_keys + i;
-              goto found;
-            }
-        }
+	{
+	  if (sm->hmac_keys[i].shared_secret == 0)
+	    {
+	      key = sm->hmac_keys + i;
+	      goto found;
+	    }
+	}
       vec_validate (sm->hmac_keys, i);
       key = sm->hmac_keys + i;
     found:
@@ -737,8 +744,8 @@ find_or_add_shared_secret (ip6_sr_main_t * sm, u8 * secret, u32 * indexp)
 
   key->shared_secret = vec_dup (secret);
 
-  hash_set_mem (sm->hmac_key_by_shared_secret, key->shared_secret, 
-                key - sm->hmac_keys);
+  hash_set_mem (sm->hmac_key_by_shared_secret, key->shared_secret,
+		key - sm->hmac_keys);
 
   if (indexp)
     *indexp = key - sm->hmac_keys;
@@ -746,30 +753,31 @@ find_or_add_shared_secret (ip6_sr_main_t * sm, u8 * secret, u32 * indexp)
 }
 
 
-int ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a)
+int
+ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a)
 {
-  ip6_main_t * im = &ip6_main;
-  ip_lookup_main_t * lm = &im->lookup_main;
+  ip6_main_t *im = &ip6_main;
+  ip_lookup_main_t *lm = &im->lookup_main;
   ip6_sr_tunnel_key_t key;
-  ip6_sr_tunnel_t * t;
-  uword * p, * n;
-  ip6_sr_header_t * h = 0;
+  ip6_sr_tunnel_t *t;
+  uword *p, *n;
+  ip6_sr_header_t *h = 0;
   u32 header_length;
-  ip6_address_t * addrp, *this_address;
-  ip_adjacency_t adj, * ap, * add_adj = 0;
+  ip6_address_t *addrp, *this_address;
+  ip_adjacency_t adj, *ap, *add_adj = 0;
   u32 adj_index;
-  ip6_sr_main_t * sm = &sr_main;
-  u8 * key_copy;
+  ip6_sr_main_t *sm = &sr_main;
+  u8 *key_copy;
   u32 rx_fib_index, tx_fib_index;
   ip6_add_del_route_args_t aa;
   u32 hmac_key_index_u32;
   u8 hmac_key_index = 0;
-  ip6_sr_policy_t * pt;
+  ip6_sr_policy_t *pt;
   int i;
 
   /* Make sure that the rx FIB exists */
   p = hash_get (im->fib_index_by_table_id, a->rx_table_id);
-  
+
   if (p == 0)
     return -3;
 
@@ -778,7 +786,7 @@ int ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a)
 
   /* Make sure that the supplied FIB exists */
   p = hash_get (im->fib_index_by_table_id, a->tx_table_id);
-  
+
   if (p == 0)
     return -4;
 
@@ -803,34 +811,34 @@ int ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a)
 
   /* If the name is given, look it up */
   if (a->name)
-    n = hash_get_mem(sm->tunnel_index_by_name, a->name);
+    n = hash_get_mem (sm->tunnel_index_by_name, a->name);
   else
     n = 0;
 
   /* validate key/name parameters */
-  if (!a->is_del) /* adding a tunnel */
+  if (!a->is_del)		/* adding a tunnel */
     {
-      if (a->name && n) /* name given & exists already */
-        return -1;
-      if (p) /* key exists already */
-        return -1;
+      if (a->name && n)		/* name given & exists already */
+	return -1;
+      if (p)			/* key exists already */
+	return -1;
     }
-  else /* deleting a tunnel */
+  else				/* deleting a tunnel */
     {
-      if (!p) /* key doesn't exist */
-        return -2;
-      if (a->name && !n) /* name given & it doesn't exist */
-        return -2;
-
-      if (n) /* name given & found */
-        {
-          if (n[0] != p[0]) /* name and key do not point to the same thing */
-            return -2;
-        }
+      if (!p)			/* key doesn't exist */
+	return -2;
+      if (a->name && !n)	/* name given & it doesn't exist */
+	return -2;
+
+      if (n)			/* name given & found */
+	{
+	  if (n[0] != p[0])	/* name and key do not point to the same thing */
+	    return -2;
+	}
     }
 
 
-  if (a->is_del) /* delete the tunnel */
+  if (a->is_del)		/* delete the tunnel */
     {
       hash_pair_t *hp;
 
@@ -838,41 +846,41 @@ int ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a)
       t = pool_elt_at_index (sm->tunnels, p[0]);
 
       ip6_delete_route_no_next_hop (&t->key.dst, t->dst_mask_width,
-                                    a->rx_table_id);
+				    a->rx_table_id);
       vec_free (t->rewrite);
       /* Remove tunnel from any policy if associated */
       if (t->policy_index != ~0)
-        {
-          pt=pool_elt_at_index (sm->policies, t->policy_index);
-          for (i=0; i< vec_len (pt->tunnel_indices); i++)
-            {
-              if (pt->tunnel_indices[i] == t - sm->tunnels)
-                {
-                  vec_delete (pt->tunnel_indices, 1, i);
-                  goto found;
-                }
-            }
-          clib_warning ("Tunnel index %d not found in policy_index %d",
-                         t - sm->tunnels, pt - sm->policies);
-        found:
-           /* If this is last tunnel in the  policy, clean up the policy too */
-          if (vec_len (pt->tunnel_indices) == 0)
-            {
-              hash_unset_mem (sm->policy_index_by_policy_name, pt->name);
-              vec_free (pt->name);
-              pool_put (sm->policies, pt);
-            }
-        }
+	{
+	  pt = pool_elt_at_index (sm->policies, t->policy_index);
+	  for (i = 0; i < vec_len (pt->tunnel_indices); i++)
+	    {
+	      if (pt->tunnel_indices[i] == t - sm->tunnels)
+		{
+		  vec_delete (pt->tunnel_indices, 1, i);
+		  goto found;
+		}
+	    }
+	  clib_warning ("Tunnel index %d not found in policy_index %d",
+			t - sm->tunnels, pt - sm->policies);
+	found:
+	  /* If this is last tunnel in the  policy, clean up the policy too */
+	  if (vec_len (pt->tunnel_indices) == 0)
+	    {
+	      hash_unset_mem (sm->policy_index_by_policy_name, pt->name);
+	      vec_free (pt->name);
+	      pool_put (sm->policies, pt);
+	    }
+	}
 
       /* Clean up the tunnel by name */
       if (t->name)
-        {
-          hash_unset_mem (sm->tunnel_index_by_name, t->name);
-          vec_free (t->name);
-        }
+	{
+	  hash_unset_mem (sm->tunnel_index_by_name, t->name);
+	  vec_free (t->name);
+	}
       pool_put (sm->tunnels, t);
       hp = hash_get_pair (sm->tunnel_index_by_key, &key);
-      key_copy = (void *)(hp->key);
+      key_copy = (void *) (hp->key);
       hash_unset_mem (sm->tunnel_index_by_key, &key);
       vec_free (key_copy);
       return 0;
@@ -887,43 +895,43 @@ int ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a)
   t->dst_mask_width = a->dst_mask_width;
   t->rx_fib_index = rx_fib_index;
   t->tx_fib_index = tx_fib_index;
-  
+
   if (!vec_len (a->segments))
-      /* there must be at least one segment... */
-      return -4;
+    /* there must be at least one segment... */
+    return -4;
 
   /* The first specified hop goes right into the dst address */
-  clib_memcpy(&t->first_hop, &a->segments[0], sizeof (ip6_address_t));
+  clib_memcpy (&t->first_hop, &a->segments[0], sizeof (ip6_address_t));
 
   /* 
    * Create the sr header rewrite string
    * The list of segments needs an extra slot for the ultimate destination
    * which is taken from the packet we add the SRH to.
    */
-  header_length = sizeof (*h) + 
+  header_length = sizeof (*h) +
     sizeof (ip6_address_t) * (vec_len (a->segments) + 1 + vec_len (a->tags));
-  
+
   if (a->shared_secret)
     {
       /* Allocate a new key slot if we don't find the secret key */
       hmac_key_index_u32 = 0;
-      (void) find_or_add_shared_secret (sm, a->shared_secret, 
-                                        &hmac_key_index_u32);
+      (void) find_or_add_shared_secret (sm, a->shared_secret,
+					&hmac_key_index_u32);
 
       /* Hey Vinz Clortho: Gozzer is pissed.. you're out of keys! */
       if (hmac_key_index_u32 >= 256)
-        return -5;
+	return -5;
       hmac_key_index = hmac_key_index_u32;
       header_length += SHA256_DIGEST_LENGTH;
     }
 
-  vec_validate (t->rewrite, header_length-1);
+  vec_validate (t->rewrite, header_length - 1);
 
   h = (ip6_sr_header_t *) t->rewrite;
 
-  h->protocol = 0xFF; /* we don't know yet */
+  h->protocol = 0xFF;		/* we don't know yet */
 
-  h->length = (header_length/8) - 1;
+  h->length = (header_length / 8) - 1;
   h->type = ROUTING_HEADER_TYPE_SR;
 
   /* first_segment and segments_left need to have the index of the last
@@ -945,10 +953,10 @@ int ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a)
   addrp = h->segments + vec_len (a->segments);
 
   vec_foreach (this_address, a->segments)
-    {
-      clib_memcpy (addrp->as_u8, this_address->as_u8, sizeof (ip6_address_t));
-      addrp--;
-    }
+  {
+    clib_memcpy (addrp->as_u8, this_address->as_u8, sizeof (ip6_address_t));
+    addrp--;
+  }
 
   /*
    * Since the ultimate destination address is not yet known, set that slot
@@ -957,26 +965,26 @@ int ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a)
   memset (h->segments, 0xfe, sizeof (ip6_address_t));
 
   /* Paint on the tag list, not reversed */
-  addrp = h->segments + vec_len(a->segments);
+  addrp = h->segments + vec_len (a->segments);
 
   vec_foreach (this_address, a->tags)
-    {
-      clib_memcpy (addrp->as_u8, this_address->as_u8, sizeof (ip6_address_t));
-      addrp++;
-    }
+  {
+    clib_memcpy (addrp->as_u8, this_address->as_u8, sizeof (ip6_address_t));
+    addrp++;
+  }
 
   key_copy = vec_new (ip6_sr_tunnel_key_t, 1);
   clib_memcpy (key_copy, &key, sizeof (ip6_sr_tunnel_key_t));
   hash_set_mem (sm->tunnel_index_by_key, key_copy, t - sm->tunnels);
 
-  memset(&adj, 0, sizeof (adj));
+  memset (&adj, 0, sizeof (adj));
 
   /* Create an adjacency and add to v6 fib */
   adj.lookup_next_index = sm->ip6_lookup_sr_next_index;
   adj.explicit_fib_index = ~0;
-  
-  ap = ip_add_adjacency (lm, &adj, 1 /* one adj */,
-                         &adj_index);
+
+  ap = ip_add_adjacency (lm, &adj, 1 /* one adj */ ,
+			 &adj_index);
 
   /* 
    * Stick the tunnel index into the rewrite header.
@@ -990,10 +998,11 @@ int ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a)
    * at some point...
    */
   ap->rewrite_header.sw_if_index = t - sm->tunnels;
-  
+
   vec_add1 (add_adj, ap[0]);
-  
-  clib_memcpy (aa.dst_address.as_u8, a->dst_address, sizeof (aa.dst_address.as_u8));
+
+  clib_memcpy (aa.dst_address.as_u8, a->dst_address,
+	       sizeof (aa.dst_address.as_u8));
   aa.dst_address_length = a->dst_mask_width;
 
   aa.flags = (a->is_del ? IP6_ROUTE_FLAG_DEL : IP6_ROUTE_FLAG_ADD);
@@ -1007,29 +1016,30 @@ int ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a)
 
   if (a->policy_name)
     {
-      p=hash_get_mem (sm->policy_index_by_policy_name, a->policy_name);
+      p = hash_get_mem (sm->policy_index_by_policy_name, a->policy_name);
       if (p)
 	{
 	  pt = pool_elt_at_index (sm->policies, p[0]);
 	}
-      else /* no policy, lets create one */
+      else			/* no policy, lets create one */
 	{
 	  pool_get (sm->policies, pt);
-	  memset (pt, 0, sizeof(*pt));
+	  memset (pt, 0, sizeof (*pt));
 	  pt->name = format (0, "%s%c", a->policy_name, 0);
-	  hash_set_mem (sm->policy_index_by_policy_name, pt->name, pt - sm->policies);
-	  p=hash_get_mem (sm->policy_index_by_policy_name, a->policy_name);
+	  hash_set_mem (sm->policy_index_by_policy_name, pt->name,
+			pt - sm->policies);
+	  p = hash_get_mem (sm->policy_index_by_policy_name, a->policy_name);
 	}
       vec_add1 (pt->tunnel_indices, t - sm->tunnels);
       if (p == 0)
-        clib_warning ("p is NULL!");
-      t->policy_index = p ? p[0] : ~0; /* equiv. to (pt - sm->policies) */
+	clib_warning ("p is NULL!");
+      t->policy_index = p ? p[0] : ~0;	/* equiv. to (pt - sm->policies) */
     }
 
   if (a->name)
     {
       t->name = format (0, "%s%c", a->name, 0);
-      hash_set_mem(sm->tunnel_index_by_name, t->name, t - sm->tunnels);
+      hash_set_mem (sm->tunnel_index_by_name, t->name, t - sm->tunnels);
     }
 
   return 0;
@@ -1037,8 +1047,8 @@ int ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a)
 
 static clib_error_t *
 sr_add_del_tunnel_command_fn (vlib_main_t * vm,
-                              unformat_input_t * input,
-                              vlib_cli_command_t * cmd)
+			      unformat_input_t * input,
+			      vlib_cli_command_t * cmd)
 {
   int is_del = 0;
   ip6_address_t src_address;
@@ -1052,11 +1062,11 @@ sr_add_del_tunnel_command_fn (vlib_main_t * vm,
   u8 *policy_name = 0;
   u32 rx_table_id = 0;
   u32 tx_table_id = 0;
-  ip6_address_t * segments = 0;
-  ip6_address_t * this_seg;
-  ip6_address_t * tags = 0;
-  ip6_address_t * this_tag;
-  ip6_sr_add_del_tunnel_args_t _a, *a=&_a;
+  ip6_address_t *segments = 0;
+  ip6_address_t *this_seg;
+  ip6_address_t *tags = 0;
+  ip6_address_t *this_tag;
+  ip6_sr_add_del_tunnel_args_t _a, *a = &_a;
   ip6_address_t next_address, tag;
   int pl_index;
   int rv;
@@ -1064,68 +1074,68 @@ sr_add_del_tunnel_command_fn (vlib_main_t * vm,
   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
       if (unformat (input, "del"))
-        is_del = 1;
+	is_del = 1;
       else if (unformat (input, "rx-fib-id %d", &rx_table_id))
-        ;
+	;
       else if (unformat (input, "tx-fib-id %d", &tx_table_id))
-        ;
+	;
       else if (unformat (input, "src %U", unformat_ip6_address, &src_address))
-        src_address_set = 1;
+	src_address_set = 1;
       else if (unformat (input, "name %s", &name))
-        ;
+	;
       else if (unformat (input, "policy %s", &policy_name))
-        ;
-      else if (unformat (input, "dst %U/%d", 
-                         unformat_ip6_address, &dst_address,
-                         &dst_mask_width))
-        dst_address_set = 1;
+	;
+      else if (unformat (input, "dst %U/%d",
+			 unformat_ip6_address, &dst_address, &dst_mask_width))
+	dst_address_set = 1;
       else if (unformat (input, "next %U", unformat_ip6_address,
-                         &next_address))
-        {
-          vec_add2 (segments, this_seg, 1);
-          clib_memcpy (this_seg->as_u8, next_address.as_u8, sizeof (*this_seg));
-        }
-      else if (unformat (input, "tag %U", unformat_ip6_address,
-                         &tag))
-        {
-          vec_add2 (tags, this_tag, 1);
-          clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
-        }
+			 &next_address))
+	{
+	  vec_add2 (segments, this_seg, 1);
+	  clib_memcpy (this_seg->as_u8, next_address.as_u8,
+		       sizeof (*this_seg));
+	}
+      else if (unformat (input, "tag %U", unformat_ip6_address, &tag))
+	{
+	  vec_add2 (tags, this_tag, 1);
+	  clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
+	}
       else if (unformat (input, "clean"))
-        flags |= IP6_SR_HEADER_FLAG_CLEANUP;
+	flags |= IP6_SR_HEADER_FLAG_CLEANUP;
       else if (unformat (input, "protected"))
-        flags |= IP6_SR_HEADER_FLAG_PROTECTED;
+	flags |= IP6_SR_HEADER_FLAG_PROTECTED;
       else if (unformat (input, "key %s", &shared_secret))
-          /* Do not include the trailing NULL byte. Guaranteed interop issue */
-          _vec_len (shared_secret) -= 1;
+	/* Do not include the trailing NULL byte. Guaranteed interop issue */
+	_vec_len (shared_secret) -= 1;
       else if (unformat (input, "InPE %d", &pl_index))
-        {
-          if (pl_index <= 0 || pl_index > 4)
-            {
-            pl_index_range_error:
-              return clib_error_return 
-                (0, "Policy List Element Index %d out of range (1-4)", pl_index);
-              
-            }
-          flags |= IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE 
-            << ip6_sr_policy_list_shift_from_index (pl_index);
-        }
+	{
+	  if (pl_index <= 0 || pl_index > 4)
+	    {
+	    pl_index_range_error:
+	      return clib_error_return
+		(0, "Policy List Element Index %d out of range (1-4)",
+		 pl_index);
+
+	    }
+	  flags |= IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE
+	    << ip6_sr_policy_list_shift_from_index (pl_index);
+	}
       else if (unformat (input, "EgPE %d", &pl_index))
-        {
-          if (pl_index <= 0 || pl_index > 4)
-            goto pl_index_range_error;
-          flags |= IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE 
-            << ip6_sr_policy_list_shift_from_index (pl_index);
-        }
+	{
+	  if (pl_index <= 0 || pl_index > 4)
+	    goto pl_index_range_error;
+	  flags |= IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE
+	    << ip6_sr_policy_list_shift_from_index (pl_index);
+	}
       else if (unformat (input, "OrgSrc %d", &pl_index))
-        {
-          if (pl_index <= 0 || pl_index > 4)
-            goto pl_index_range_error;
-          flags |= IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR
-            << ip6_sr_policy_list_shift_from_index (pl_index);
-        }
-      else 
-        break;
+	{
+	  if (pl_index <= 0 || pl_index > 4)
+	    goto pl_index_range_error;
+	  flags |= IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR
+	    << ip6_sr_policy_list_shift_from_index (pl_index);
+	}
+      else
+	break;
     }
 
   if (!src_address_set)
@@ -1143,24 +1153,24 @@ sr_add_del_tunnel_command_fn (vlib_main_t * vm,
   a->dst_mask_width = dst_mask_width;
   a->segments = segments;
   a->tags = tags;
-  a->flags_net_byte_order = clib_host_to_net_u16(flags);
+  a->flags_net_byte_order = clib_host_to_net_u16 (flags);
   a->is_del = is_del;
   a->rx_table_id = rx_table_id;
   a->tx_table_id = tx_table_id;
   a->shared_secret = shared_secret;
 
-  if (vec_len(name))
-    a->name = name; 
+  if (vec_len (name))
+    a->name = name;
   else
     a->name = 0;
 
-  if (vec_len(policy_name))
+  if (vec_len (policy_name))
     a->policy_name = policy_name;
   else
     a->policy_name = 0;
 
   rv = ip6_sr_add_del_tunnel (a);
-  
+
   vec_free (segments);
   vec_free (tags);
   vec_free (shared_secret);
@@ -1172,28 +1182,30 @@ sr_add_del_tunnel_command_fn (vlib_main_t * vm,
 
     case -1:
       return clib_error_return (0, "SR tunnel src %U dst %U already exists",
-                                format_ip6_address, &src_address,
-                                format_ip6_address, &dst_address);
+				format_ip6_address, &src_address,
+				format_ip6_address, &dst_address);
 
     case -2:
       return clib_error_return (0, "SR tunnel src %U dst %U does not exist",
-                                format_ip6_address, &src_address,
-                                format_ip6_address, &dst_address);
-      
+				format_ip6_address, &src_address,
+				format_ip6_address, &dst_address);
+
     case -3:
-      return clib_error_return (0, "FIB table %d does not exist", rx_table_id);
+      return clib_error_return (0, "FIB table %d does not exist",
+				rx_table_id);
 
     case -4:
       return clib_error_return (0, "At least one segment is required");
 
     default:
       return clib_error_return (0, "BUG: ip6_sr_add_del_tunnel returns %d",
-                                rv);
+				rv);
     }
 
   return 0;
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (sr_tunnel_command, static) = {
     .path = "sr tunnel",
     .short_help = 
@@ -1202,38 +1214,38 @@ VLIB_CLI_COMMAND (sr_tunnel_command, static) = {
       "[rx-fib-id <fib_id>] [tx-fib-id <fib_id>]",
     .function = sr_add_del_tunnel_command_fn,
 };
+/* *INDENT-ON* */
 
 void
-ip6_sr_tunnel_display (vlib_main_t * vm,
-		       ip6_sr_tunnel_t * t)
+ip6_sr_tunnel_display (vlib_main_t * vm, ip6_sr_tunnel_t * t)
 {
-  ip6_main_t * im = &ip6_main;
-  ip6_sr_main_t * sm = &sr_main;
-  ip6_fib_t * rx_fib, * tx_fib;
-  ip6_sr_policy_t * pt;
+  ip6_main_t *im = &ip6_main;
+  ip6_sr_main_t *sm = &sr_main;
+  ip6_fib_t *rx_fib, *tx_fib;
+  ip6_sr_policy_t *pt;
+
+  rx_fib = find_ip6_fib_by_table_index_or_id (im, t->rx_fib_index,
+					      IP6_ROUTE_FLAG_FIB_INDEX);
 
-  rx_fib = find_ip6_fib_by_table_index_or_id (im, t->rx_fib_index, 
-                                                  IP6_ROUTE_FLAG_FIB_INDEX);
-      
-  tx_fib = find_ip6_fib_by_table_index_or_id (im, t->tx_fib_index, 
-                                                  IP6_ROUTE_FLAG_FIB_INDEX);
+  tx_fib = find_ip6_fib_by_table_index_or_id (im, t->tx_fib_index,
+					      IP6_ROUTE_FLAG_FIB_INDEX);
 
   if (t->name)
-    vlib_cli_output (vm,"sr tunnel name: %s", (char *)t->name);
+    vlib_cli_output (vm, "sr tunnel name: %s", (char *) t->name);
 
-  vlib_cli_output (vm, "src %U dst %U first hop %U", 
+  vlib_cli_output (vm, "src %U dst %U first hop %U",
 		   format_ip6_address, &t->key.src,
 		   format_ip6_address, &t->key.dst,
 		   format_ip6_address, &t->first_hop);
   vlib_cli_output (vm, "    rx-fib-id %d tx-fib-id %d",
 		   rx_fib->table_id, tx_fib->table_id);
-  vlib_cli_output (vm, "  sr: %U", format_ip6_sr_header, t->rewrite, 
-		   0 /* print_hmac */);
+  vlib_cli_output (vm, "  sr: %U", format_ip6_sr_header, t->rewrite,
+		   0 /* print_hmac */ );
 
   if (t->policy_index != ~0)
     {
-      pt=pool_elt_at_index(sm->policies, t->policy_index);
-      vlib_cli_output (vm,"sr policy: %s", (char *)pt->name);
+      pt = pool_elt_at_index (sm->policies, t->policy_index);
+      vlib_cli_output (vm, "sr policy: %s", (char *) pt->name);
     }
   vlib_cli_output (vm, "-------");
 
@@ -1242,38 +1254,40 @@ ip6_sr_tunnel_display (vlib_main_t * vm,
 
 static clib_error_t *
 show_sr_tunnel_fn (vlib_main_t * vm,
-                   unformat_input_t * input,
-                   vlib_cli_command_t * cmd)
+		   unformat_input_t * input, vlib_cli_command_t * cmd)
 {
-  static ip6_sr_tunnel_t ** tunnels;
-  ip6_sr_tunnel_t * t;
-  ip6_sr_main_t * sm = &sr_main;
+  static ip6_sr_tunnel_t **tunnels;
+  ip6_sr_tunnel_t *t;
+  ip6_sr_main_t *sm = &sr_main;
   int i;
-  uword * p = 0;
+  uword *p = 0;
   u8 *name = 0;
 
   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
-      if (unformat (input, "name %s", &name)) 
+      if (unformat (input, "name %s", &name))
 	{
-	  p=hash_get_mem (sm->tunnel_index_by_name, name);
-	  if(!p)
-	    vlib_cli_output (vm, "No SR tunnel with name: %s. Showing all.", name);
-	 }
-      else 
-        break;
+	  p = hash_get_mem (sm->tunnel_index_by_name, name);
+	  if (!p)
+	    vlib_cli_output (vm, "No SR tunnel with name: %s. Showing all.",
+			     name);
+	}
+      else
+	break;
     }
 
   vec_reset_length (tunnels);
 
-  if(!p) /* Either name parm not passed or no tunnel with that name found, show all */
+  if (!p)			/* Either name parm not passed or no tunnel with that name found, show all */
     {
+      /* *INDENT-OFF* */
   pool_foreach (t, sm->tunnels, 
   ({
     vec_add1 (tunnels, t);
   }));
+  /* *INDENT-ON* */
     }
-  else /* Just show the one tunnel by name */
+  else				/* Just show the one tunnel by name */
     vec_add1 (tunnels, &sm->tunnels[p[0]]);
 
   if (vec_len (tunnels) == 0)
@@ -1284,104 +1298,108 @@ show_sr_tunnel_fn (vlib_main_t * vm,
       t = tunnels[i];
       ip6_sr_tunnel_display (vm, t);
     }
-  
+
   return 0;
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (show_sr_tunnel_command, static) = {
     .path = "show sr tunnel",
     .short_help = "show sr tunnel [name <sr-tunnel-name>]",
     .function = show_sr_tunnel_fn,
 };
+/* *INDENT-ON* */
 
-int ip6_sr_add_del_policy (ip6_sr_add_del_policy_args_t * a)
+int
+ip6_sr_add_del_policy (ip6_sr_add_del_policy_args_t * a)
 {
-  ip6_sr_main_t * sm = &sr_main;
-  uword * p;
-  ip6_sr_tunnel_t * t = 0;
-  ip6_sr_policy_t * policy;
-  u32 * tunnel_indices = 0;
+  ip6_sr_main_t *sm = &sr_main;
+  uword *p;
+  ip6_sr_tunnel_t *t = 0;
+  ip6_sr_policy_t *policy;
+  u32 *tunnel_indices = 0;
   int i;
 
 
 
-      if (a->is_del)
-	{
-	  p=hash_get_mem (sm->policy_index_by_policy_name, a->name);
-	  if (!p)
-	    return -6; /* policy name not found */ 
+  if (a->is_del)
+    {
+      p = hash_get_mem (sm->policy_index_by_policy_name, a->name);
+      if (!p)
+	return -6;		/* policy name not found */
 
-	  policy = pool_elt_at_index(sm->policies, p[0]);
-	  
-	  vec_foreach_index (i, policy->tunnel_indices)
-	    {
-	      t = pool_elt_at_index (sm->tunnels, policy->tunnel_indices[i]);
-	      t->policy_index = ~0;
-	    }	    
-	  hash_unset_mem (sm->policy_index_by_policy_name, a->name);
-	  pool_put (sm->policies, policy);
-	  return 0;
-	}
+      policy = pool_elt_at_index (sm->policies, p[0]);
 
+      vec_foreach_index (i, policy->tunnel_indices)
+      {
+	t = pool_elt_at_index (sm->tunnels, policy->tunnel_indices[i]);
+	t->policy_index = ~0;
+      }
+      hash_unset_mem (sm->policy_index_by_policy_name, a->name);
+      pool_put (sm->policies, policy);
+      return 0;
+    }
 
-      if (!vec_len(a->tunnel_names))
-	return -3; /*tunnel name is required case */
 
-      vec_reset_length (tunnel_indices);
-      /* Check tunnel names, add tunnel_index to policy */
-      for (i=0; i < vec_len (a->tunnel_names); i++)
-	{
-	  p = hash_get_mem (sm->tunnel_index_by_name, a->tunnel_names[i]);
-	  if (!p)
-	    return -4; /* tunnel name not found case */ 
-	  
-	  t = pool_elt_at_index (sm->tunnels, p[0]); 
-	  /*
-	    No need to check t==0. -3 condition above ensures name
-	  */
-	  if (t->policy_index != ~0)
-	    return -5; /* tunnel name already associated with a policy */
-	  
-	  /* Add to tunnel indicies */
-	  vec_add1 (tunnel_indices, p[0]);
-	}
-      
-      /* Add policy to ip6_sr_main_t */
-      pool_get (sm->policies, policy);
-      policy->name = a->name; 
-      policy->tunnel_indices = tunnel_indices;
-      hash_set_mem (sm->policy_index_by_policy_name, policy->name, policy - sm->policies);
-      
-      /* Yes, this could be construed as overkill but the last thing you should do is set
-	 the policy_index on the tunnel after everything is set in ip6_sr_main_t. 
-	 If this is deemed overly cautious, could set this in the vec_len(tunnel_names) loop.
-      */
-      for (i=0; i < vec_len(policy->tunnel_indices); i++)
-	{
-	  t = pool_elt_at_index (sm->tunnels, policy->tunnel_indices[i]);
-	  t->policy_index = policy - sm->policies;
-	}
+  if (!vec_len (a->tunnel_names))
+    return -3;			/*tunnel name is required case */
 
-      return 0;
+  vec_reset_length (tunnel_indices);
+  /* Check tunnel names, add tunnel_index to policy */
+  for (i = 0; i < vec_len (a->tunnel_names); i++)
+    {
+      p = hash_get_mem (sm->tunnel_index_by_name, a->tunnel_names[i]);
+      if (!p)
+	return -4;		/* tunnel name not found case */
+
+      t = pool_elt_at_index (sm->tunnels, p[0]);
+      /*
+         No need to check t==0. -3 condition above ensures name
+       */
+      if (t->policy_index != ~0)
+	return -5;		/* tunnel name already associated with a policy */
+
+      /* Add to tunnel indicies */
+      vec_add1 (tunnel_indices, p[0]);
+    }
+
+  /* Add policy to ip6_sr_main_t */
+  pool_get (sm->policies, policy);
+  policy->name = a->name;
+  policy->tunnel_indices = tunnel_indices;
+  hash_set_mem (sm->policy_index_by_policy_name, policy->name,
+		policy - sm->policies);
+
+  /* Yes, this could be construed as overkill but the last thing you should do is set
+     the policy_index on the tunnel after everything is set in ip6_sr_main_t. 
+     If this is deemed overly cautious, could set this in the vec_len(tunnel_names) loop.
+   */
+  for (i = 0; i < vec_len (policy->tunnel_indices); i++)
+    {
+      t = pool_elt_at_index (sm->tunnels, policy->tunnel_indices[i]);
+      t->policy_index = policy - sm->policies;
+    }
+
+  return 0;
 }
 
 
 static clib_error_t *
 sr_add_del_policy_command_fn (vlib_main_t * vm,
-                              unformat_input_t * input,
-                              vlib_cli_command_t * cmd)
+			      unformat_input_t * input,
+			      vlib_cli_command_t * cmd)
 {
   int is_del = 0;
-  u8 ** tunnel_names = 0;
-  u8 * tunnel_name = 0;
-  u8 * name = 0;
-  ip6_sr_add_del_policy_args_t _a, *a=&_a;
+  u8 **tunnel_names = 0;
+  u8 *tunnel_name = 0;
+  u8 *name = 0;
+  ip6_sr_add_del_policy_args_t _a, *a = &_a;
   int rv;
 
-    while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
       if (unformat (input, "del"))
-        is_del = 1;
+	is_del = 1;
       else if (unformat (input, "name %s", &name))
 	;
       else if (unformat (input, "tunnel %s", &tunnel_name))
@@ -1392,23 +1410,23 @@ sr_add_del_policy_command_fn (vlib_main_t * vm,
 	      tunnel_name = 0;
 	    }
 	}
-      else 
-        break;
+      else
+	break;
     }
 
   if (!name)
     return clib_error_return (0, "name of SR policy required");
 
 
-  memset(a, 0, sizeof(*a));
-  
+  memset (a, 0, sizeof (*a));
+
   a->is_del = is_del;
   a->name = name;
   a->tunnel_names = tunnel_names;
 
   rv = ip6_sr_add_del_policy (a);
 
-  vec_free(tunnel_names);
+  vec_free (tunnel_names);
 
   switch (rv)
     {
@@ -1416,8 +1434,9 @@ sr_add_del_policy_command_fn (vlib_main_t * vm,
       break;
 
     case -3:
-      return clib_error_return (0, "tunnel name to associate to SR policy is required");
-      
+      return clib_error_return (0,
+				"tunnel name to associate to SR policy is required");
+
     case -4:
       return clib_error_return (0, "tunnel name not found");
 
@@ -1431,56 +1450,62 @@ sr_add_del_policy_command_fn (vlib_main_t * vm,
       return clib_error_return (0, "TODO: deleting policy name %s", name);
 
     default:
-      return clib_error_return (0, "BUG: ip6_sr_add_del_policy returns %d", rv);
-  
+      return clib_error_return (0, "BUG: ip6_sr_add_del_policy returns %d",
+				rv);
+
     }
   return 0;
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (sr_policy_command, static) = {
     .path = "sr policy",
     .short_help = 
     "sr policy [del] name <policy-name> tunnel <sr-tunnel-name> [tunnel <sr-tunnel-name>]*",
     .function = sr_add_del_policy_command_fn,
 };
+/* *INDENT-ON* */
 
 static clib_error_t *
 show_sr_policy_fn (vlib_main_t * vm,
-                   unformat_input_t * input,
-                   vlib_cli_command_t * cmd)
+		   unformat_input_t * input, vlib_cli_command_t * cmd)
 {
-  static ip6_sr_policy_t ** policies;
-  ip6_sr_policy_t * policy;
-  ip6_sr_tunnel_t * t;
-  ip6_sr_main_t * sm = &sr_main;
+  static ip6_sr_policy_t **policies;
+  ip6_sr_policy_t *policy;
+  ip6_sr_tunnel_t *t;
+  ip6_sr_main_t *sm = &sr_main;
   int i, j;
-  uword * p = 0;
-  u8 * name = 0;
+  uword *p = 0;
+  u8 *name = 0;
 
   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
-      if (unformat (input, "name %s", &name)) 
+      if (unformat (input, "name %s", &name))
 	{
-	  p=hash_get_mem (sm->policy_index_by_policy_name, name);
-	  if(!p)
-	    vlib_cli_output (vm, "policy with name %s not found. Showing all.", name);
-	 }
-      else 
-        break;
+	  p = hash_get_mem (sm->policy_index_by_policy_name, name);
+	  if (!p)
+	    vlib_cli_output (vm,
+			     "policy with name %s not found. Showing all.",
+			     name);
+	}
+      else
+	break;
     }
 
   vec_reset_length (policies);
 
-  if(!p) /* Either name parm not passed or no policy with that name found, show all */
+  if (!p)			/* Either name parm not passed or no policy with that name found, show all */
     {
+      /* *INDENT-OFF* */
   pool_foreach (policy, sm->policies, 
   ({
     vec_add1 (policies, policy);
   }));
+  /* *INDENT-ON* */
     }
-  else /* Just show the one policy by name and a summary of tunnel names */
+  else				/* Just show the one policy by name and a summary of tunnel names */
     {
-      policy = pool_elt_at_index(sm->policies, p[0]);
+      policy = pool_elt_at_index (sm->policies, p[0]);
       vec_add1 (policies, policy);
     }
 
@@ -1489,43 +1514,48 @@ show_sr_policy_fn (vlib_main_t * vm,
 
   for (i = 0; i < vec_len (policies); i++)
     {
-      policy = policies [i];
+      policy = policies[i];
 
-      if(policy->name)
-	vlib_cli_output (vm,"SR policy name: %s", (char *)policy->name);
-      for(j = 0; j < vec_len (policy->tunnel_indices); j++)
+      if (policy->name)
+	vlib_cli_output (vm, "SR policy name: %s", (char *) policy->name);
+      for (j = 0; j < vec_len (policy->tunnel_indices); j++)
 	{
 	  t = pool_elt_at_index (sm->tunnels, policy->tunnel_indices[j]);
 	  ip6_sr_tunnel_display (vm, t);
 	}
     }
-  
+
   return 0;
 
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (show_sr_policy_command, static) = {
     .path = "show sr policy",
     .short_help = "show sr policy [name <sr-policy-name>]",
     .function = show_sr_policy_fn,
 };
+/* *INDENT-ON* */
 
-int ip6_sr_add_del_multicastmap (ip6_sr_add_del_multicastmap_args_t * a)
+int
+ip6_sr_add_del_multicastmap (ip6_sr_add_del_multicastmap_args_t * a)
 {
-  uword * p;
-  ip6_main_t * im = &ip6_main;
-  ip_lookup_main_t * lm = &im->lookup_main;
-  ip6_sr_tunnel_t * t;
-  ip_adjacency_t adj, * ap, * add_adj = 0;
+  uword *p;
+  ip6_main_t *im = &ip6_main;
+  ip_lookup_main_t *lm = &im->lookup_main;
+  ip6_sr_tunnel_t *t;
+  ip_adjacency_t adj, *ap, *add_adj = 0;
   u32 adj_index;
-  ip6_sr_main_t * sm = &sr_main;
+  ip6_sr_main_t *sm = &sr_main;
   ip6_add_del_route_args_t aa;
-  ip6_sr_policy_t * pt;
+  ip6_sr_policy_t *pt;
 
   if (a->is_del)
     {
       /* clean up the adjacency */
-      p = hash_get_mem (sm->policy_index_by_multicast_address, a->multicast_address);
+      p =
+	hash_get_mem (sm->policy_index_by_multicast_address,
+		      a->multicast_address);
     }
   else
     {
@@ -1536,25 +1566,25 @@ int ip6_sr_add_del_multicastmap (ip6_sr_add_del_multicastmap_args_t * a)
   if (!p)
     return -1;
 
-  pt=pool_elt_at_index (sm->policies, p[0]);
+  pt = pool_elt_at_index (sm->policies, p[0]);
 
   /* 
      Get the first tunnel associated with policy populate the fib adjacency.
      From there, since this tunnel will have it's policy_index != ~0 it will
      be the trigger in the dual_loop to pull up the policy and make a copy-rewrite
      for each tunnel in the policy
-  */
+   */
 
   t = pool_elt_at_index (sm->tunnels, pt->tunnel_indices[0]);
 
   /* Construct a FIB entry for multicast using the rx/tx fib from the first tunnel */
-  memset(&adj, 0, sizeof (adj));
+  memset (&adj, 0, sizeof (adj));
 
   /* Create an adjacency and add to v6 fib */
   adj.lookup_next_index = sm->ip6_lookup_sr_replicate_index;
   adj.explicit_fib_index = ~0;
-  
-  ap = ip_add_adjacency (lm, &adj, 1 /* one adj */,
+
+  ap = ip_add_adjacency (lm, &adj, 1 /* one adj */ ,
 			 &adj_index);
 
   /* 
@@ -1569,10 +1599,11 @@ int ip6_sr_add_del_multicastmap (ip6_sr_add_del_multicastmap_args_t * a)
    * at some point...
    */
   ap->rewrite_header.sw_if_index = t - sm->tunnels;
-  
+
   vec_add1 (add_adj, ap[0]);
-  
-  memcpy (aa.dst_address.as_u8, a->multicast_address, sizeof (aa.dst_address.as_u8));
+
+  memcpy (aa.dst_address.as_u8, a->multicast_address,
+	  sizeof (aa.dst_address.as_u8));
   aa.dst_address_length = 128;
 
   aa.flags = (a->is_del ? IP6_ROUTE_FLAG_DEL : IP6_ROUTE_FLAG_ADD);
@@ -1584,7 +1615,7 @@ int ip6_sr_add_del_multicastmap (ip6_sr_add_del_multicastmap_args_t * a)
   ip6_add_del_route (im, &aa);
   vec_free (add_adj);
 
-  u8 * mcast_copy = 0;
+  u8 *mcast_copy = 0;
   mcast_copy = vec_new (ip6_address_t, 1);
   memcpy (mcast_copy, a->multicast_address, sizeof (ip6_address_t));
 
@@ -1596,34 +1627,37 @@ int ip6_sr_add_del_multicastmap (ip6_sr_add_del_multicastmap_args_t * a)
     }
   /* else */
 
-  hash_set_mem (sm->policy_index_by_multicast_address, mcast_copy, pt - sm->policies);
-  
+  hash_set_mem (sm->policy_index_by_multicast_address, mcast_copy,
+		pt - sm->policies);
+
 
   return 0;
 }
 
 static clib_error_t *
 sr_add_del_multicast_map_command_fn (vlib_main_t * vm,
-                              unformat_input_t * input,
-                              vlib_cli_command_t * cmd)
+				     unformat_input_t * input,
+				     vlib_cli_command_t * cmd)
 {
   int is_del = 0;
   ip6_address_t multicast_address;
-  u8 * policy_name = 0;
+  u8 *policy_name = 0;
   int multicast_address_set = 0;
-  ip6_sr_add_del_multicastmap_args_t _a, *a=&_a;
+  ip6_sr_add_del_multicastmap_args_t _a, *a = &_a;
   int rv;
 
   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
       if (unformat (input, "del"))
-        is_del = 1;
-      else if (unformat (input, "address %U", unformat_ip6_address, &multicast_address))
+	is_del = 1;
+      else
+	if (unformat
+	    (input, "address %U", unformat_ip6_address, &multicast_address))
 	multicast_address_set = 1;
       else if (unformat (input, "sr-policy %s", &policy_name))
-        ;
-      else 
-        break;
+	;
+      else
+	break;
     }
 
   if (!is_del && !policy_name)
@@ -1632,16 +1666,17 @@ sr_add_del_multicast_map_command_fn (vlib_main_t * vm,
   if (!multicast_address_set)
     return clib_error_return (0, "multicast address required");
 
-  memset(a, 0, sizeof(*a));
-  
+  memset (a, 0, sizeof (*a));
+
   a->is_del = is_del;
   a->multicast_address = &multicast_address;
   a->policy_name = policy_name;
 
-#if DPDK > 0 /*Cannot call replicate or configure multicast map yet without DPDK */
+#if DPDK > 0			/*Cannot call replicate or configure multicast map yet without DPDK */
   rv = ip6_sr_add_del_multicastmap (a);
 #else
-  return clib_error_return (0, "cannot use multicast replicate spray case without DPDK installed");
+  return clib_error_return (0,
+			    "cannot use multicast replicate spray case without DPDK installed");
 #endif /* DPDK */
 
   switch (rv)
@@ -1655,40 +1690,45 @@ sr_add_del_multicast_map_command_fn (vlib_main_t * vm,
       return clib_error_return (0, "multicast map someting ");
 
     case -3:
-      return clib_error_return (0, "tunnel name to associate to SR policy is required");
-      
+      return clib_error_return (0,
+				"tunnel name to associate to SR policy is required");
+
     case -7:
-      return clib_error_return (0, "TODO: deleting policy name %s", policy_name);
+      return clib_error_return (0, "TODO: deleting policy name %s",
+				policy_name);
 
     default:
-      return clib_error_return (0, "BUG: ip6_sr_add_del_policy returns %d", rv);
-  
+      return clib_error_return (0, "BUG: ip6_sr_add_del_policy returns %d",
+				rv);
+
     }
   return 0;
 
 }
 
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (sr_multicast_map_command, static) = {
     .path = "sr multicast-map",
     .short_help = 
     "sr multicast-map address <multicast-ip6-address> sr-policy <sr-policy-name> [del]",
     .function = sr_add_del_multicast_map_command_fn,
 };
+/* *INDENT-ON* */
 
 static clib_error_t *
 show_sr_multicast_map_fn (vlib_main_t * vm,
-                   unformat_input_t * input,
-                   vlib_cli_command_t * cmd)
+			  unformat_input_t * input, vlib_cli_command_t * cmd)
 {
-  ip6_sr_main_t * sm = &sr_main;
-  u8 * key = 0;
+  ip6_sr_main_t *sm = &sr_main;
+  u8 *key = 0;
   u32 value;
   ip6_address_t multicast_address;
-  ip6_sr_policy_t * pt ;
+  ip6_sr_policy_t *pt;
 
   /* pull all entries from the hash table into vector for display */
 
+  /* *INDENT-OFF* */
   hash_foreach_mem (key, value, sm->policy_index_by_multicast_address,
   ({
     if (!key)
@@ -1711,57 +1751,64 @@ show_sr_multicast_map_fn (vlib_main_t * vm,
       }
 
   }));
+  /* *INDENT-ON* */
 
   return 0;
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (show_sr_multicast_map_command, static) = {
     .path = "show sr multicast-map",
     .short_help = "show sr multicast-map",
     .function = show_sr_multicast_map_fn,
 };
+/* *INDENT-ON* */
 
 
 #define foreach_sr_fix_dst_addr_next            \
 _(DROP, "error-drop")
 
-typedef enum {
+typedef enum
+{
 #define _(s,n) SR_FIX_DST_ADDR_NEXT_##s,
-foreach_sr_fix_dst_addr_next
+  foreach_sr_fix_dst_addr_next
 #undef _
-  SR_FIX_DST_ADDR_N_NEXT,
+    SR_FIX_DST_ADDR_N_NEXT,
 } sr_fix_dst_addr_next_t;
 
-static char * sr_fix_dst_error_strings[] = {
+static char *sr_fix_dst_error_strings[] = {
 #define sr_fix_dst_error(n,s) s,
 #include "sr_fix_dst_error.def"
 #undef sr_fix_dst_error
 };
 
-typedef enum {
+typedef enum
+{
 #define sr_fix_dst_error(n,s) SR_FIX_DST_ERROR_##n,
 #include "sr_fix_dst_error.def"
 #undef sr_fix_dst_error
   SR_FIX_DST_N_ERROR,
 } sr_fix_dst_error_t;
 
-typedef struct {
+typedef struct
+{
   ip6_address_t src, dst;
   u32 next_index;
   u32 adj_index;
   u8 sr[256];
 } sr_fix_addr_trace_t;
 
-u8 * format_sr_fix_addr_trace (u8 * s, va_list * args)
+u8 *
+format_sr_fix_addr_trace (u8 * s, va_list * args)
 {
   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
-  sr_fix_addr_trace_t * t = va_arg (*args, sr_fix_addr_trace_t *);
-  vnet_hw_interface_t * hi = 0;
-  ip_adjacency_t * adj;
-  ip6_main_t * im = &ip6_main;
-  ip_lookup_main_t * lm = &im->lookup_main;
-  vnet_main_t * vnm = vnet_get_main();
+  sr_fix_addr_trace_t *t = va_arg (*args, sr_fix_addr_trace_t *);
+  vnet_hw_interface_t *hi = 0;
+  ip_adjacency_t *adj;
+  ip6_main_t *im = &ip6_main;
+  ip_lookup_main_t *lm = &im->lookup_main;
+  vnet_main_t *vnm = vnet_get_main ();
 
   if (t->adj_index != ~0)
     {
@@ -1769,28 +1816,28 @@ u8 * format_sr_fix_addr_trace (u8 * s, va_list * args)
       hi = vnet_get_sup_hw_interface (vnm, adj->rewrite_header.sw_if_index);
     }
 
-  s = format (s, "SR-FIX_ADDR: next %s ip6 src %U dst %U\n", 
-              (t->next_index == SR_FIX_DST_ADDR_NEXT_DROP) 
-              ? "drop" : "output",
-              format_ip6_address, &t->src, 
-              format_ip6_address, &t->dst);
+  s = format (s, "SR-FIX_ADDR: next %s ip6 src %U dst %U\n",
+	      (t->next_index == SR_FIX_DST_ADDR_NEXT_DROP)
+	      ? "drop" : "output",
+	      format_ip6_address, &t->src, format_ip6_address, &t->dst);
   if (t->next_index != SR_FIX_DST_ADDR_NEXT_DROP)
     {
-      s = format (s, "%U\n", format_ip6_sr_header, t->sr, 1 /* print_hmac */);
-      s = format (s, "   output via %s", hi ? (char *)(hi->name) 
-                  : "Invalid adj");
+      s =
+	format (s, "%U\n", format_ip6_sr_header, t->sr, 1 /* print_hmac */ );
+      s =
+	format (s, "   output via %s",
+		hi ? (char *) (hi->name) : "Invalid adj");
     }
   return s;
 }
 
 static uword
 sr_fix_dst_addr (vlib_main_t * vm,
-                   vlib_node_runtime_t * node,
-                   vlib_frame_t * from_frame)
+		 vlib_node_runtime_t * node, vlib_frame_t * from_frame)
 {
-  u32 n_left_from, next_index, * from, * to_next;
-  ip6_main_t * im = &ip6_main;
-  ip_lookup_main_t * lm = &im->lookup_main;
+  u32 n_left_from, next_index, *from, *to_next;
+  ip6_main_t *im = &ip6_main;
+  ip_lookup_main_t *lm = &im->lookup_main;
 
   from = vlib_frame_vector_args (from_frame);
   n_left_from = from_frame->n_vectors;
@@ -1801,24 +1848,23 @@ sr_fix_dst_addr (vlib_main_t * vm,
     {
       u32 n_left_to_next;
 
-      vlib_get_next_frame (vm, node, next_index,
-			   to_next, n_left_to_next);
+      vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 
 #if 0
       while (0 && n_left_from >= 4 && n_left_to_next >= 2)
 	{
 	  u32 bi0, bi1;
-	  __attribute__((unused)) vlib_buffer_t * b0, * b1;
+	  __attribute__ ((unused)) vlib_buffer_t *b0, *b1;
 	  u32 next0 = SR_FIX_DST_ADDR_NEXT_DROP;
 	  u32 next1 = SR_FIX_DST_ADDR_NEXT_DROP;
 
 	  /* Prefetch next iteration. */
 	  {
-	    vlib_buffer_t * p2, * p3;
+	    vlib_buffer_t *p2, *p3;
 
 	    p2 = vlib_get_buffer (vm, from[2]);
 	    p3 = vlib_get_buffer (vm, from[3]);
-            
+
 	    vlib_prefetch_buffer_header (p2, LOAD);
 	    vlib_prefetch_buffer_header (p3, LOAD);
 	  }
@@ -1839,19 +1885,19 @@ sr_fix_dst_addr (vlib_main_t * vm,
 	  vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
 					   to_next, n_left_to_next,
 					   bi0, bi1, next0, next1);
-        }
+	}
 #endif
 
       while (n_left_from > 0 && n_left_to_next > 0)
 	{
 	  u32 bi0;
-	  vlib_buffer_t * b0;
-          ip6_header_t * ip0;
-          ip_adjacency_t * adj0;
-          ip6_sr_header_t * sr0;
+	  vlib_buffer_t *b0;
+	  ip6_header_t *ip0;
+	  ip_adjacency_t *adj0;
+	  ip6_sr_header_t *sr0;
 	  u32 next0 = SR_FIX_DST_ADDR_NEXT_DROP;
-          ip6_address_t *new_dst0;
-          ethernet_header_t * eh0;
+	  ip6_address_t *new_dst0;
+	  ethernet_header_t *eh0;
 
 	  bi0 = from[0];
 	  to_next[0] = bi0;
@@ -1861,66 +1907,67 @@ sr_fix_dst_addr (vlib_main_t * vm,
 	  n_left_to_next -= 1;
 
 	  b0 = vlib_get_buffer (vm, bi0);
-          
-          adj0 = ip_get_adjacency (lm, vnet_buffer(b0)->ip.adj_index[VLIB_TX]);
-          next0 = adj0->mcast_group_index;
-
-          /* We should be pointing at an Ethernet header... */
-          eh0 = vlib_buffer_get_current (b0);
-          ip0 = (ip6_header_t *)(eh0+1);
-          sr0 = (ip6_sr_header_t *) (ip0+1);
-          
-          /* We'd better find an SR header... */
-          if (PREDICT_FALSE(ip0->protocol != IPPROTO_IPV6_ROUTE))
-            {
-              b0->error = node->errors[SR_FIX_DST_ERROR_NO_SR_HEADER];
-              goto do_trace0;
-            }
-          else
-            {
-              /* 
-               * We get here from sr_rewrite or sr_local, with
-               * sr->segments_left pointing at the (copy of the original) dst
-               * address. Use it, then increment sr0->segments_left.
-               */
-              
-              /* Out of segments? Turf the packet */
-              if (PREDICT_FALSE (sr0->segments_left == 0))
-                {
-                  b0->error = node->errors[SR_FIX_DST_ERROR_NO_MORE_SEGMENTS];
-                  goto do_trace0;
-                }
-              
-              /* 
-               * Rewrite the packet with the original dst address 
-               * We assume that the last segment (in processing order) contains 
-               * the original dst address. The list is reversed, so sr0->segments
-               * contains the original dst address.
-               */
-              new_dst0 = sr0->segments;
-              ip0->dst_address.as_u64[0] = new_dst0->as_u64[0];
-              ip0->dst_address.as_u64[1] = new_dst0->as_u64[1];
-            }
-          
-        do_trace0:
-
-          if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) 
-            {
-              sr_fix_addr_trace_t *t = vlib_add_trace (vm, node, 
-                                                       b0, sizeof (*t));
-              t->next_index = next0;
-              t->adj_index = ~0;
-
-              if (next0 != SR_FIX_DST_ADDR_NEXT_DROP)
-                {
-                  t->adj_index = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
-                  clib_memcpy (t->src.as_u8, ip0->src_address.as_u8,
-                          sizeof (t->src.as_u8));
-                  clib_memcpy (t->dst.as_u8, ip0->dst_address.as_u8,
-                          sizeof (t->dst.as_u8));
-                  clib_memcpy (t->sr, sr0, sizeof (t->sr));
-                }
-            }
+
+	  adj0 =
+	    ip_get_adjacency (lm, vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
+	  next0 = adj0->mcast_group_index;
+
+	  /* We should be pointing at an Ethernet header... */
+	  eh0 = vlib_buffer_get_current (b0);
+	  ip0 = (ip6_header_t *) (eh0 + 1);
+	  sr0 = (ip6_sr_header_t *) (ip0 + 1);
+
+	  /* We'd better find an SR header... */
+	  if (PREDICT_FALSE (ip0->protocol != IPPROTO_IPV6_ROUTE))
+	    {
+	      b0->error = node->errors[SR_FIX_DST_ERROR_NO_SR_HEADER];
+	      goto do_trace0;
+	    }
+	  else
+	    {
+	      /* 
+	       * We get here from sr_rewrite or sr_local, with
+	       * sr->segments_left pointing at the (copy of the original) dst
+	       * address. Use it, then increment sr0->segments_left.
+	       */
+
+	      /* Out of segments? Turf the packet */
+	      if (PREDICT_FALSE (sr0->segments_left == 0))
+		{
+		  b0->error = node->errors[SR_FIX_DST_ERROR_NO_MORE_SEGMENTS];
+		  goto do_trace0;
+		}
+
+	      /* 
+	       * Rewrite the packet with the original dst address 
+	       * We assume that the last segment (in processing order) contains 
+	       * the original dst address. The list is reversed, so sr0->segments
+	       * contains the original dst address.
+	       */
+	      new_dst0 = sr0->segments;
+	      ip0->dst_address.as_u64[0] = new_dst0->as_u64[0];
+	      ip0->dst_address.as_u64[1] = new_dst0->as_u64[1];
+	    }
+
+	do_trace0:
+
+	  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
+	    {
+	      sr_fix_addr_trace_t *t = vlib_add_trace (vm, node,
+						       b0, sizeof (*t));
+	      t->next_index = next0;
+	      t->adj_index = ~0;
+
+	      if (next0 != SR_FIX_DST_ADDR_NEXT_DROP)
+		{
+		  t->adj_index = vnet_buffer (b0)->ip.adj_index[VLIB_TX];
+		  clib_memcpy (t->src.as_u8, ip0->src_address.as_u8,
+			       sizeof (t->src.as_u8));
+		  clib_memcpy (t->dst.as_u8, ip0->dst_address.as_u8,
+			       sizeof (t->dst.as_u8));
+		  clib_memcpy (t->sr, sr0, sizeof (t->sr));
+		}
+	    }
 
 	  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 					   to_next, n_left_to_next,
@@ -1933,6 +1980,7 @@ sr_fix_dst_addr (vlib_main_t * vm,
 }
 
 
+/* *INDENT-OFF* */
 VLIB_REGISTER_NODE (sr_fix_dst_addr_node) = {
   .function = sr_fix_dst_addr,
   .name = "sr-fix-dst-addr",
@@ -1953,14 +2001,14 @@ VLIB_REGISTER_NODE (sr_fix_dst_addr_node) = {
 #undef _
   },
 };
+/* *INDENT-ON* */
 
 VLIB_NODE_FUNCTION_MULTIARCH (sr_fix_dst_addr_node, sr_fix_dst_addr)
-
-static clib_error_t * sr_init (vlib_main_t * vm)
+     static clib_error_t *sr_init (vlib_main_t * vm)
 {
-  ip6_sr_main_t * sm = &sr_main;
-  clib_error_t * error = 0;
-  vlib_node_t * ip6_lookup_node, * ip6_rewrite_node;
+  ip6_sr_main_t *sm = &sr_main;
+  clib_error_t *error = 0;
+  vlib_node_t *ip6_lookup_node, *ip6_rewrite_node;
 
   if ((error = vlib_call_init_function (vm, ip_main_init)))
     return error;
@@ -1969,49 +2017,47 @@ static clib_error_t * sr_init (vlib_main_t * vm)
     return error;
 
   sm->vlib_main = vm;
-  sm->vnet_main = vnet_get_main();
-  
+  sm->vnet_main = vnet_get_main ();
+
   vec_validate (sm->hmac_keys, 0);
   sm->hmac_keys[0].shared_secret = (u8 *) 0xdeadbeef;
 
-  sm->tunnel_index_by_key = 
+  sm->tunnel_index_by_key =
     hash_create_mem (0, sizeof (ip6_sr_tunnel_key_t), sizeof (uword));
 
-  sm->tunnel_index_by_name = 
-    hash_create_string (0, sizeof (uword));
+  sm->tunnel_index_by_name = hash_create_string (0, sizeof (uword));
 
-  sm->policy_index_by_policy_name = 
-    hash_create_string(0, sizeof (uword));
+  sm->policy_index_by_policy_name = hash_create_string (0, sizeof (uword));
 
   sm->policy_index_by_multicast_address =
     hash_create_mem (0, sizeof (ip6_address_t), sizeof (uword));
 
-  sm->hmac_key_by_shared_secret = hash_create_string (0, sizeof(uword));
+  sm->hmac_key_by_shared_secret = hash_create_string (0, sizeof (uword));
 
   ip6_register_protocol (IPPROTO_IPV6_ROUTE, sr_local_node.index);
 
-  ip6_lookup_node = vlib_get_node_by_name (vm, (u8 *)"ip6-lookup");
-  ASSERT(ip6_lookup_node);
+  ip6_lookup_node = vlib_get_node_by_name (vm, (u8 *) "ip6-lookup");
+  ASSERT (ip6_lookup_node);
+
+  ip6_rewrite_node = vlib_get_node_by_name (vm, (u8 *) "ip6-rewrite");
+  ASSERT (ip6_rewrite_node);
 
-  ip6_rewrite_node = vlib_get_node_by_name (vm, (u8 *)"ip6-rewrite");
-  ASSERT(ip6_rewrite_node);
-  
   /* Add a disposition to ip6_lookup for the sr rewrite node */
-  sm->ip6_lookup_sr_next_index = 
+  sm->ip6_lookup_sr_next_index =
     vlib_node_add_next (vm, ip6_lookup_node->index, sr_rewrite_node.index);
 
-#if DPDK > 0 /* Cannot run replicate without DPDK */
+#if DPDK > 0			/* Cannot run replicate without DPDK */
   /* Add a disposition to sr_replicate for the sr multicast replicate node */
-  sm->ip6_lookup_sr_replicate_index = 
+  sm->ip6_lookup_sr_replicate_index =
     vlib_node_add_next (vm, ip6_lookup_node->index, sr_replicate_node.index);
 #endif /* DPDK */
 
   /* Add a disposition to ip6_rewrite for the sr dst address hack node */
-  sm->ip6_rewrite_sr_next_index = 
-    vlib_node_add_next (vm, ip6_rewrite_node->index, 
-                        sr_fix_dst_addr_node.index);
+  sm->ip6_rewrite_sr_next_index =
+    vlib_node_add_next (vm, ip6_rewrite_node->index,
+			sr_fix_dst_addr_node.index);
 
-  OpenSSL_add_all_digests();
+  OpenSSL_add_all_digests ();
 
   sm->md = (void *) EVP_get_digestbyname ("sha1");
   sm->hmac_ctx = clib_mem_alloc (sizeof (HMAC_CTX));
@@ -2025,14 +2071,16 @@ VLIB_INIT_FUNCTION (sr_init);
   _ (ERROR, "error-drop")                       \
   _ (IP6_LOOKUP, "ip6-lookup")
 
-typedef enum {
+typedef enum
+{
 #define _(s,n) SR_LOCAL_NEXT_##s,
   foreach_sr_local_next
 #undef _
-  SR_LOCAL_N_NEXT,
+    SR_LOCAL_N_NEXT,
 } sr_local_next_t;
 
-typedef struct {
+typedef struct
+{
   u8 next_index;
   u8 sr_valid;
   ip6_address_t src, dst;
@@ -2040,30 +2088,33 @@ typedef struct {
   u8 sr[256];
 } sr_local_trace_t;
 
-static char * sr_local_error_strings[] = {
+static char *sr_local_error_strings[] = {
 #define sr_error(n,s) s,
 #include "sr_error.def"
 #undef sr_error
 };
 
-typedef enum {
+typedef enum
+{
 #define sr_error(n,s) SR_LOCAL_ERROR_##n,
 #include "sr_error.def"
 #undef sr_error
   SR_LOCAL_N_ERROR,
 } sr_local_error_t;
 
-u8 * format_sr_local_trace (u8 * s, va_list * args)
+u8 *
+format_sr_local_trace (u8 * s, va_list * args)
 {
   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
-  sr_local_trace_t * t = va_arg (*args, sr_local_trace_t *);
-    
-  s = format (s, "SR-LOCAL: src %U dst %U len %u next_index %d", 
-              format_ip6_address, &t->src, 
-              format_ip6_address, &t->dst, t->length, t->next_index);
+  sr_local_trace_t *t = va_arg (*args, sr_local_trace_t *);
+
+  s = format (s, "SR-LOCAL: src %U dst %U len %u next_index %d",
+	      format_ip6_address, &t->src,
+	      format_ip6_address, &t->dst, t->length, t->next_index);
   if (t->sr_valid)
-    s = format (s, "\n  %U", format_ip6_sr_header, t->sr, 1 /* print_hmac */);
+    s =
+      format (s, "\n  %U", format_ip6_sr_header, t->sr, 1 /* print_hmac */ );
   else
     s = format (s, "\n  popped SR header");
 
@@ -2073,17 +2124,17 @@ u8 * format_sr_local_trace (u8 * s, va_list * args)
 
 /* $$$$ fixme: smp, don't copy data, cache input, output (maybe) */
 
-static int sr_validate_hmac (ip6_sr_main_t * sm, ip6_header_t * ip, 
-                             ip6_sr_header_t * sr)
+static int
+sr_validate_hmac (ip6_sr_main_t * sm, ip6_header_t * ip, ip6_sr_header_t * sr)
 {
   u32 key_index;
-  static u8 * keybuf;
-  u8 * copy_target;
+  static u8 *keybuf;
+  u8 *copy_target;
   int first_segment;
   ip6_address_t *addrp;
   int i;
-  ip6_sr_hmac_key_t * hmac_key;
-  static u8 * signature;
+  ip6_sr_hmac_key_t *hmac_key;
+  static u8 *signature;
   u32 sig_len;
 
   key_index = sr->hmac_key;
@@ -2096,7 +2147,7 @@ static int sr_validate_hmac (ip6_sr_main_t * sm, ip6_header_t * ip,
   if (key_index >= vec_len (sm->hmac_keys))
     return 1;
 
-  vec_validate (signature, SHA256_DIGEST_LENGTH-1);
+  vec_validate (signature, SHA256_DIGEST_LENGTH - 1);
 
   hmac_key = sm->hmac_keys + key_index;
 
@@ -2112,8 +2163,8 @@ static int sr_validate_hmac (ip6_sr_main_t * sm, ip6_header_t * ip,
 
   /* octet w/ bit 0 = "clean" flag */
   vec_add2 (keybuf, copy_target, 1);
-  copy_target[0] 
-    = (sr->flags & clib_host_to_net_u16 (IP6_SR_HEADER_FLAG_CLEANUP)) 
+  copy_target[0]
+    = (sr->flags & clib_host_to_net_u16 (IP6_SR_HEADER_FLAG_CLEANUP))
     ? 0x80 : 0;
 
   /* hmac key id */
@@ -2133,47 +2184,45 @@ static int sr_validate_hmac (ip6_sr_main_t * sm, ip6_header_t * ip,
     }
 
   if (sm->is_debug)
-      clib_warning ("verify key index %d keybuf: %U", key_index, 
-                    format_hex_bytes, keybuf, vec_len(keybuf));
+    clib_warning ("verify key index %d keybuf: %U", key_index,
+		  format_hex_bytes, keybuf, vec_len (keybuf));
 
   /* shared secret */
 
   /* SHA1 is shorter than SHA-256 */
-  memset (signature, 0, vec_len(signature));
-
-  HMAC_CTX_init(sm->hmac_ctx);
-  if (!HMAC_Init(sm->hmac_ctx, hmac_key->shared_secret,
-                 vec_len(hmac_key->shared_secret),sm->md))
-      clib_warning ("barf1");
-  if (!HMAC_Update(sm->hmac_ctx,keybuf,vec_len(keybuf)))
-      clib_warning ("barf2");
-  if (!HMAC_Final(sm->hmac_ctx,signature,&sig_len))
-      clib_warning ("barf3");
-  HMAC_CTX_cleanup(sm->hmac_ctx);
+  memset (signature, 0, vec_len (signature));
+
+  HMAC_CTX_init (sm->hmac_ctx);
+  if (!HMAC_Init (sm->hmac_ctx, hmac_key->shared_secret,
+		  vec_len (hmac_key->shared_secret), sm->md))
+    clib_warning ("barf1");
+  if (!HMAC_Update (sm->hmac_ctx, keybuf, vec_len (keybuf)))
+    clib_warning ("barf2");
+  if (!HMAC_Final (sm->hmac_ctx, signature, &sig_len))
+    clib_warning ("barf3");
+  HMAC_CTX_cleanup (sm->hmac_ctx);
 
   if (sm->is_debug)
-      clib_warning ("computed signature len %d, value %U", sig_len, 
-                    format_hex_bytes, signature, vec_len(signature));
+    clib_warning ("computed signature len %d, value %U", sig_len,
+		  format_hex_bytes, signature, vec_len (signature));
 
   /* Point at the SHA signature in the packet */
   addrp++;
   if (sm->is_debug)
-      clib_warning ("read signature %U", format_hex_bytes, addrp, 
-                    SHA256_DIGEST_LENGTH);
+    clib_warning ("read signature %U", format_hex_bytes, addrp,
+		  SHA256_DIGEST_LENGTH);
 
   return memcmp (signature, addrp, SHA256_DIGEST_LENGTH);
 }
 
 static uword
 sr_local (vlib_main_t * vm,
-          vlib_node_runtime_t * node,
-          vlib_frame_t * from_frame)
+	  vlib_node_runtime_t * node, vlib_frame_t * from_frame)
 {
-  u32 n_left_from, next_index, * from, * to_next;
-  ip6_sr_main_t * sm = &sr_main;
+  u32 n_left_from, next_index, *from, *to_next;
+  ip6_sr_main_t *sm = &sr_main;
   u32 (*sr_local_cb) (vlib_main_t *, vlib_node_runtime_t *,
-                      vlib_buffer_t *, ip6_header_t *, 
-                      ip6_sr_header_t *);
+		      vlib_buffer_t *, ip6_header_t *, ip6_sr_header_t *);
   sr_local_cb = sm->sr_local_cb;
 
   from = vlib_frame_vector_args (from_frame);
@@ -2185,21 +2234,20 @@ sr_local (vlib_main_t * vm,
     {
       u32 n_left_to_next;
 
-      vlib_get_next_frame (vm, node, next_index,
-			   to_next, n_left_to_next);
+      vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 
       while (n_left_from >= 4 && n_left_to_next >= 2)
 	{
 	  u32 bi0, bi1;
-	  vlib_buffer_t * b0, * b1;
-          ip6_header_t * ip0, *ip1;
-          ip6_sr_header_t * sr0, *sr1;
-          ip6_address_t * new_dst0, * new_dst1;
+	  vlib_buffer_t *b0, *b1;
+	  ip6_header_t *ip0, *ip1;
+	  ip6_sr_header_t *sr0, *sr1;
+	  ip6_address_t *new_dst0, *new_dst1;
 	  u32 next0 = SR_LOCAL_NEXT_IP6_LOOKUP;
 	  u32 next1 = SR_LOCAL_NEXT_IP6_LOOKUP;
 	  /* Prefetch next iteration. */
 	  {
-	    vlib_buffer_t * p2, * p3;
+	    vlib_buffer_t *p2, *p3;
 
 	    p2 = vlib_get_buffer (vm, from[2]);
 	    p3 = vlib_get_buffer (vm, from[3]);
@@ -2207,8 +2255,8 @@ sr_local (vlib_main_t * vm,
 	    vlib_prefetch_buffer_header (p2, LOAD);
 	    vlib_prefetch_buffer_header (p3, LOAD);
 
-	    CLIB_PREFETCH (p2->data, 2*CLIB_CACHE_LINE_BYTES, LOAD);
-	    CLIB_PREFETCH (p3->data, 2*CLIB_CACHE_LINE_BYTES, LOAD);
+	    CLIB_PREFETCH (p2->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
+	    CLIB_PREFETCH (p3->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
 	  }
 
 	  bi0 = from[0];
@@ -2222,227 +2270,227 @@ sr_local (vlib_main_t * vm,
 
 
 	  b0 = vlib_get_buffer (vm, bi0);
-          ip0 = vlib_buffer_get_current (b0);
-          sr0 = (ip6_sr_header_t *)(ip0+1);
-
-          if (PREDICT_FALSE(sr0->type != ROUTING_HEADER_TYPE_SR))
-            {
-              next0 = SR_LOCAL_NEXT_ERROR;
-              b0->error = node->errors[SR_LOCAL_ERROR_BAD_ROUTING_HEADER_TYPE];
-              goto do_trace0;
-            }
-
-          /* Out of segments? Turf the packet */
-          if (PREDICT_FALSE (sr0->segments_left == 0))
-            {
-              next0 = SR_LOCAL_NEXT_ERROR;
-              b0->error = node->errors[SR_LOCAL_ERROR_NO_MORE_SEGMENTS];
-              goto do_trace0;
-            }
-
-          if (PREDICT_FALSE(sm->validate_hmac))
-            {
-              if (sr_validate_hmac (sm, ip0, sr0))
-                {
-                  next0 = SR_LOCAL_NEXT_ERROR;
-                  b0->error = node->errors[SR_LOCAL_ERROR_HMAC_INVALID];
-                  goto do_trace0;
-                }
-            }
-
-          next0 = sr_local_cb ? sr_local_cb (vm, node, b0, ip0, sr0) :
-              next0;
-
-          /* 
-           * To suppress rewrite, return ~SR_LOCAL_NEXT_xxx 
-           */
-          if (PREDICT_FALSE (next0 & 0x80000000))
-          {
-              next0 ^= 0xFFFFFFFF;
-              if (PREDICT_FALSE(next0 == SR_LOCAL_NEXT_ERROR))
-                  b0->error = 
-                  node->errors[SR_LOCAL_ERROR_APP_CALLBACK];
-            }
-          else
-            {
-              u32 segment_index0;
-
-              segment_index0 = sr0->segments_left - 1;
-              
-              /* Rewrite the packet */
-              new_dst0 = (ip6_address_t *)(sr0->segments + segment_index0);
-              ip0->dst_address.as_u64[0] = new_dst0->as_u64[0];
-              ip0->dst_address.as_u64[1] = new_dst0->as_u64[1];
-              
-              if (PREDICT_TRUE (sr0->segments_left > 0))
-                  sr0->segments_left -= 1;
-            }
-
-          /* End of the path. Clean up the SR header, or not */
-          if (PREDICT_FALSE 
-              (sr0->segments_left == 0 && 
-               (sr0->flags & clib_host_to_net_u16(IP6_SR_HEADER_FLAG_CLEANUP))))
-          {
-              u64 *copy_dst0, *copy_src0;
-              u16 new_l0;
-              /* 
-               * Copy the ip6 header right by the (real) length of the
-               * sr header. Here's another place which assumes that
-               * the sr header is the only extention header.
-               */
-              
-              ip0->protocol = sr0->protocol;
-              vlib_buffer_advance (b0, (sr0->length+1)*8);
-
-              new_l0 = clib_net_to_host_u16(ip0->payload_length) -
-                  (sr0->length+1)*8;
-              ip0->payload_length = clib_host_to_net_u16(new_l0);
-              
-              copy_src0 = (u64 *)ip0;
-              copy_dst0 = copy_src0 + (sr0->length + 1);
-
-              copy_dst0 [4] = copy_src0[4];
-              copy_dst0 [3] = copy_src0[3];
-              copy_dst0 [2] = copy_src0[2];
-              copy_dst0 [1] = copy_src0[1];
-              copy_dst0 [0] = copy_src0[0];
-              
-              sr0 = 0;
-            }
-
-        do_trace0:
-          if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) 
-            {
-              sr_local_trace_t *tr = vlib_add_trace (vm, node, 
-                                                     b0, sizeof (*tr));
-              clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
-                      sizeof (tr->src.as_u8));
-              clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
-                      sizeof (tr->dst.as_u8));
-              tr->length = vlib_buffer_length_in_chain (vm, b0);
-              tr->next_index = next0;
-              tr->sr_valid = sr0 != 0;
-              if (tr->sr_valid)
-                clib_memcpy (tr->sr, sr0, sizeof (tr->sr));
-            }
+	  ip0 = vlib_buffer_get_current (b0);
+	  sr0 = (ip6_sr_header_t *) (ip0 + 1);
+
+	  if (PREDICT_FALSE (sr0->type != ROUTING_HEADER_TYPE_SR))
+	    {
+	      next0 = SR_LOCAL_NEXT_ERROR;
+	      b0->error =
+		node->errors[SR_LOCAL_ERROR_BAD_ROUTING_HEADER_TYPE];
+	      goto do_trace0;
+	    }
+
+	  /* Out of segments? Turf the packet */
+	  if (PREDICT_FALSE (sr0->segments_left == 0))
+	    {
+	      next0 = SR_LOCAL_NEXT_ERROR;
+	      b0->error = node->errors[SR_LOCAL_ERROR_NO_MORE_SEGMENTS];
+	      goto do_trace0;
+	    }
+
+	  if (PREDICT_FALSE (sm->validate_hmac))
+	    {
+	      if (sr_validate_hmac (sm, ip0, sr0))
+		{
+		  next0 = SR_LOCAL_NEXT_ERROR;
+		  b0->error = node->errors[SR_LOCAL_ERROR_HMAC_INVALID];
+		  goto do_trace0;
+		}
+	    }
+
+	  next0 = sr_local_cb ? sr_local_cb (vm, node, b0, ip0, sr0) : next0;
+
+	  /* 
+	   * To suppress rewrite, return ~SR_LOCAL_NEXT_xxx 
+	   */
+	  if (PREDICT_FALSE (next0 & 0x80000000))
+	    {
+	      next0 ^= 0xFFFFFFFF;
+	      if (PREDICT_FALSE (next0 == SR_LOCAL_NEXT_ERROR))
+		b0->error = node->errors[SR_LOCAL_ERROR_APP_CALLBACK];
+	    }
+	  else
+	    {
+	      u32 segment_index0;
+
+	      segment_index0 = sr0->segments_left - 1;
+
+	      /* Rewrite the packet */
+	      new_dst0 = (ip6_address_t *) (sr0->segments + segment_index0);
+	      ip0->dst_address.as_u64[0] = new_dst0->as_u64[0];
+	      ip0->dst_address.as_u64[1] = new_dst0->as_u64[1];
+
+	      if (PREDICT_TRUE (sr0->segments_left > 0))
+		sr0->segments_left -= 1;
+	    }
+
+	  /* End of the path. Clean up the SR header, or not */
+	  if (PREDICT_FALSE
+	      (sr0->segments_left == 0 &&
+	       (sr0->flags &
+		clib_host_to_net_u16 (IP6_SR_HEADER_FLAG_CLEANUP))))
+	    {
+	      u64 *copy_dst0, *copy_src0;
+	      u16 new_l0;
+	      /* 
+	       * Copy the ip6 header right by the (real) length of the
+	       * sr header. Here's another place which assumes that
+	       * the sr header is the only extention header.
+	       */
+
+	      ip0->protocol = sr0->protocol;
+	      vlib_buffer_advance (b0, (sr0->length + 1) * 8);
+
+	      new_l0 = clib_net_to_host_u16 (ip0->payload_length) -
+		(sr0->length + 1) * 8;
+	      ip0->payload_length = clib_host_to_net_u16 (new_l0);
+
+	      copy_src0 = (u64 *) ip0;
+	      copy_dst0 = copy_src0 + (sr0->length + 1);
+
+	      copy_dst0[4] = copy_src0[4];
+	      copy_dst0[3] = copy_src0[3];
+	      copy_dst0[2] = copy_src0[2];
+	      copy_dst0[1] = copy_src0[1];
+	      copy_dst0[0] = copy_src0[0];
+
+	      sr0 = 0;
+	    }
+
+	do_trace0:
+	  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
+	    {
+	      sr_local_trace_t *tr = vlib_add_trace (vm, node,
+						     b0, sizeof (*tr));
+	      clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
+			   sizeof (tr->src.as_u8));
+	      clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
+			   sizeof (tr->dst.as_u8));
+	      tr->length = vlib_buffer_length_in_chain (vm, b0);
+	      tr->next_index = next0;
+	      tr->sr_valid = sr0 != 0;
+	      if (tr->sr_valid)
+		clib_memcpy (tr->sr, sr0, sizeof (tr->sr));
+	    }
 
 	  b1 = vlib_get_buffer (vm, bi1);
-          ip1 = vlib_buffer_get_current (b1);
-          sr1 = (ip6_sr_header_t *)(ip1+1);
-
-          if (PREDICT_FALSE(sr1->type != ROUTING_HEADER_TYPE_SR))
-            {
-              next1 = SR_LOCAL_NEXT_ERROR;
-              b1->error = node->errors[SR_LOCAL_ERROR_BAD_ROUTING_HEADER_TYPE];
-              goto do_trace1;
-            }
-
-          /* Out of segments? Turf the packet */
-          if (PREDICT_FALSE (sr1->segments_left == 0))
-            {
-              next1 = SR_LOCAL_NEXT_ERROR;
-              b1->error = node->errors[SR_LOCAL_ERROR_NO_MORE_SEGMENTS];
-              goto do_trace1;
-            }
-
-          if (PREDICT_FALSE(sm->validate_hmac))
-            {
-              if (sr_validate_hmac (sm, ip1, sr1))
-                {
-                  next1 = SR_LOCAL_NEXT_ERROR;
-                  b1->error = node->errors[SR_LOCAL_ERROR_HMAC_INVALID];
-                  goto do_trace1;
-                }
-            }
-
-          next1 = sr_local_cb ? sr_local_cb (vm, node, b1, ip1, sr1) :
-              next1;
-
-          /* 
-           * To suppress rewrite, return ~SR_LOCAL_NEXT_xxx 
-           */
-          if (PREDICT_FALSE (next1 & 0x80000000))
-          {
-              next1 ^= 0xFFFFFFFF;
-              if (PREDICT_FALSE(next1 == SR_LOCAL_NEXT_ERROR))
-                  b1->error = 
-                  node->errors[SR_LOCAL_ERROR_APP_CALLBACK];
-            }
-          else
-            {
-              u32 segment_index1;
-
-              segment_index1 = sr1->segments_left - 1;
-
-              /* Rewrite the packet */
-              new_dst1 = (ip6_address_t *)(sr1->segments + segment_index1);
-              ip1->dst_address.as_u64[0] = new_dst1->as_u64[0];
-              ip1->dst_address.as_u64[1] = new_dst1->as_u64[1];
-              
-              if (PREDICT_TRUE (sr1->segments_left > 0))
-                  sr1->segments_left -= 1;
-            }
-
-          /* End of the path. Clean up the SR header, or not */
-          if (PREDICT_FALSE 
-              (sr1->segments_left == 0 && 
-               (sr1->flags & clib_host_to_net_u16(IP6_SR_HEADER_FLAG_CLEANUP))))
-            {
-              u64 *copy_dst1, *copy_src1;
-              u16 new_l1;
-              /* 
-               * Copy the ip6 header right by the (real) length of the
-               * sr header. Here's another place which assumes that
-               * the sr header is the only extention header.
-               */
-              
-              ip1->protocol = sr1->protocol;
-              vlib_buffer_advance (b1, (sr1->length+1)*8);
-
-              new_l1 = clib_net_to_host_u16(ip1->payload_length) -
-                  (sr1->length+1)*8;
-              ip1->payload_length = clib_host_to_net_u16(new_l1);
-              
-              copy_src1 = (u64 *)ip1;
-              copy_dst1 = copy_src1 + (sr1->length + 1);
-
-              copy_dst1 [4] = copy_src1[4];
-              copy_dst1 [3] = copy_src1[3];
-              copy_dst1 [2] = copy_src1[2];
-              copy_dst1 [1] = copy_src1[1];
-              copy_dst1 [0] = copy_src1[0];
-              
-              sr1 = 0;
-            }
-
-        do_trace1:
-          if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED)) 
-            {
-              sr_local_trace_t *tr = vlib_add_trace (vm, node, 
-                                                     b1, sizeof (*tr));
-              clib_memcpy (tr->src.as_u8, ip1->src_address.as_u8,
-                      sizeof (tr->src.as_u8));
-              clib_memcpy (tr->dst.as_u8, ip1->dst_address.as_u8,
-                      sizeof (tr->dst.as_u8));
-              tr->length = vlib_buffer_length_in_chain (vm, b1);
-              tr->next_index = next1;
-              tr->sr_valid = sr1 != 0;
-              if (tr->sr_valid)
-                clib_memcpy (tr->sr, sr1, sizeof (tr->sr));
-            }
+	  ip1 = vlib_buffer_get_current (b1);
+	  sr1 = (ip6_sr_header_t *) (ip1 + 1);
+
+	  if (PREDICT_FALSE (sr1->type != ROUTING_HEADER_TYPE_SR))
+	    {
+	      next1 = SR_LOCAL_NEXT_ERROR;
+	      b1->error =
+		node->errors[SR_LOCAL_ERROR_BAD_ROUTING_HEADER_TYPE];
+	      goto do_trace1;
+	    }
+
+	  /* Out of segments? Turf the packet */
+	  if (PREDICT_FALSE (sr1->segments_left == 0))
+	    {
+	      next1 = SR_LOCAL_NEXT_ERROR;
+	      b1->error = node->errors[SR_LOCAL_ERROR_NO_MORE_SEGMENTS];
+	      goto do_trace1;
+	    }
+
+	  if (PREDICT_FALSE (sm->validate_hmac))
+	    {
+	      if (sr_validate_hmac (sm, ip1, sr1))
+		{
+		  next1 = SR_LOCAL_NEXT_ERROR;
+		  b1->error = node->errors[SR_LOCAL_ERROR_HMAC_INVALID];
+		  goto do_trace1;
+		}
+	    }
+
+	  next1 = sr_local_cb ? sr_local_cb (vm, node, b1, ip1, sr1) : next1;
+
+	  /* 
+	   * To suppress rewrite, return ~SR_LOCAL_NEXT_xxx 
+	   */
+	  if (PREDICT_FALSE (next1 & 0x80000000))
+	    {
+	      next1 ^= 0xFFFFFFFF;
+	      if (PREDICT_FALSE (next1 == SR_LOCAL_NEXT_ERROR))
+		b1->error = node->errors[SR_LOCAL_ERROR_APP_CALLBACK];
+	    }
+	  else
+	    {
+	      u32 segment_index1;
+
+	      segment_index1 = sr1->segments_left - 1;
+
+	      /* Rewrite the packet */
+	      new_dst1 = (ip6_address_t *) (sr1->segments + segment_index1);
+	      ip1->dst_address.as_u64[0] = new_dst1->as_u64[0];
+	      ip1->dst_address.as_u64[1] = new_dst1->as_u64[1];
+
+	      if (PREDICT_TRUE (sr1->segments_left > 0))
+		sr1->segments_left -= 1;
+	    }
+
+	  /* End of the path. Clean up the SR header, or not */
+	  if (PREDICT_FALSE
+	      (sr1->segments_left == 0 &&
+	       (sr1->flags &
+		clib_host_to_net_u16 (IP6_SR_HEADER_FLAG_CLEANUP))))
+	    {
+	      u64 *copy_dst1, *copy_src1;
+	      u16 new_l1;
+	      /* 
+	       * Copy the ip6 header right by the (real) length of the
+	       * sr header. Here's another place which assumes that
+	       * the sr header is the only extention header.
+	       */
+
+	      ip1->protocol = sr1->protocol;
+	      vlib_buffer_advance (b1, (sr1->length + 1) * 8);
+
+	      new_l1 = clib_net_to_host_u16 (ip1->payload_length) -
+		(sr1->length + 1) * 8;
+	      ip1->payload_length = clib_host_to_net_u16 (new_l1);
+
+	      copy_src1 = (u64 *) ip1;
+	      copy_dst1 = copy_src1 + (sr1->length + 1);
+
+	      copy_dst1[4] = copy_src1[4];
+	      copy_dst1[3] = copy_src1[3];
+	      copy_dst1[2] = copy_src1[2];
+	      copy_dst1[1] = copy_src1[1];
+	      copy_dst1[0] = copy_src1[0];
+
+	      sr1 = 0;
+	    }
+
+	do_trace1:
+	  if (PREDICT_FALSE (b1->flags & VLIB_BUFFER_IS_TRACED))
+	    {
+	      sr_local_trace_t *tr = vlib_add_trace (vm, node,
+						     b1, sizeof (*tr));
+	      clib_memcpy (tr->src.as_u8, ip1->src_address.as_u8,
+			   sizeof (tr->src.as_u8));
+	      clib_memcpy (tr->dst.as_u8, ip1->dst_address.as_u8,
+			   sizeof (tr->dst.as_u8));
+	      tr->length = vlib_buffer_length_in_chain (vm, b1);
+	      tr->next_index = next1;
+	      tr->sr_valid = sr1 != 0;
+	      if (tr->sr_valid)
+		clib_memcpy (tr->sr, sr1, sizeof (tr->sr));
+	    }
 
 	  vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
 					   to_next, n_left_to_next,
 					   bi0, bi1, next0, next1);
 	}
-    
+
       while (n_left_from > 0 && n_left_to_next > 0)
 	{
 	  u32 bi0;
-	  vlib_buffer_t * b0;
-          ip6_header_t * ip0 = 0;
-          ip6_sr_header_t * sr0;
-          ip6_address_t * new_dst0;
+	  vlib_buffer_t *b0;
+	  ip6_header_t *ip0 = 0;
+	  ip6_sr_header_t *sr0;
+	  ip6_address_t *new_dst0;
 	  u32 next0 = SR_LOCAL_NEXT_IP6_LOOKUP;
 
 	  bi0 = from[0];
@@ -2453,109 +2501,109 @@ sr_local (vlib_main_t * vm,
 	  n_left_to_next -= 1;
 
 	  b0 = vlib_get_buffer (vm, bi0);
-          ip0 = vlib_buffer_get_current (b0);
-          sr0 = (ip6_sr_header_t *)(ip0+1);
-
-          if (PREDICT_FALSE(sr0->type != ROUTING_HEADER_TYPE_SR))
-            {
-              next0 = SR_LOCAL_NEXT_ERROR;
-              b0->error = node->errors[SR_LOCAL_ERROR_BAD_ROUTING_HEADER_TYPE];
-              goto do_trace;
-            }
-
-          /* Out of segments? Turf the packet */
-          if (PREDICT_FALSE (sr0->segments_left == 0))
-            {
-              next0 = SR_LOCAL_NEXT_ERROR;
-              b0->error = node->errors[SR_LOCAL_ERROR_NO_MORE_SEGMENTS];
-              goto do_trace;
-            }
-
-          if (PREDICT_FALSE(sm->validate_hmac))
-            {
-              if (sr_validate_hmac (sm, ip0, sr0))
-                {
-                  next0 = SR_LOCAL_NEXT_ERROR;
-                  b0->error = node->errors[SR_LOCAL_ERROR_HMAC_INVALID];
-                  goto do_trace;
-                }
-            }
-
-          next0 = sr_local_cb ? sr_local_cb (vm, node, b0, ip0, sr0) :
-            next0;
-
-          /* 
-           * To suppress rewrite, return ~SR_LOCAL_NEXT_xxx 
-           */
-          if (PREDICT_FALSE (next0 & 0x80000000))
-            {
-              next0 ^= 0xFFFFFFFF;
-              if (PREDICT_FALSE(next0 == SR_LOCAL_NEXT_ERROR))
-                b0->error = 
-                  node->errors[SR_LOCAL_ERROR_APP_CALLBACK];
-            }
-          else
-            {
-              u32 segment_index0;
-
-              segment_index0 = sr0->segments_left - 1;
-
-              /* Rewrite the packet */
-              new_dst0 = (ip6_address_t *)(sr0->segments + segment_index0);
-              ip0->dst_address.as_u64[0] = new_dst0->as_u64[0];
-              ip0->dst_address.as_u64[1] = new_dst0->as_u64[1];
-              
-              if (PREDICT_TRUE (sr0->segments_left > 0))
-                  sr0->segments_left -= 1;
-            }
-
-          /* End of the path. Clean up the SR header, or not */
-          if (PREDICT_FALSE 
-              (sr0->segments_left == 0 && 
-               (sr0->flags & clib_host_to_net_u16(IP6_SR_HEADER_FLAG_CLEANUP))))
-            {
-              u64 *copy_dst0, *copy_src0;
-              u16 new_l0;
-              /* 
-               * Copy the ip6 header right by the (real) length of the
-               * sr header. Here's another place which assumes that
-               * the sr header is the only extention header.
-               */
-              
-              ip0->protocol = sr0->protocol;
-              vlib_buffer_advance (b0, (sr0->length+1)*8);
-
-              new_l0 = clib_net_to_host_u16(ip0->payload_length) -
-                  (sr0->length+1)*8;
-              ip0->payload_length = clib_host_to_net_u16(new_l0);
-              
-              copy_src0 = (u64 *)ip0;
-              copy_dst0 = copy_src0 + (sr0->length + 1);
-
-              copy_dst0 [4] = copy_src0[4];
-              copy_dst0 [3] = copy_src0[3];
-              copy_dst0 [2] = copy_src0[2];
-              copy_dst0 [1] = copy_src0[1];
-              copy_dst0 [0] = copy_src0[0];
-              
-              sr0 = 0;
-            }
-
-        do_trace:
-          if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) 
-            {
-              sr_local_trace_t *tr = vlib_add_trace (vm, node, 
-                                                     b0, sizeof (*tr));
-              clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
-                      sizeof (tr->src.as_u8));
-              clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
-                      sizeof (tr->dst.as_u8));
-              tr->length = vlib_buffer_length_in_chain (vm, b0);
-              tr->next_index = next0;
-              tr->sr_valid = sr0 != 0;
-              if (tr->sr_valid)
-                clib_memcpy (tr->sr, sr0, sizeof (tr->sr));
-            }
+	  ip0 = vlib_buffer_get_current (b0);
+	  sr0 = (ip6_sr_header_t *) (ip0 + 1);
+
+	  if (PREDICT_FALSE (sr0->type != ROUTING_HEADER_TYPE_SR))
+	    {
+	      next0 = SR_LOCAL_NEXT_ERROR;
+	      b0->error =
+		node->errors[SR_LOCAL_ERROR_BAD_ROUTING_HEADER_TYPE];
+	      goto do_trace;
+	    }
+
+	  /* Out of segments? Turf the packet */
+	  if (PREDICT_FALSE (sr0->segments_left == 0))
+	    {
+	      next0 = SR_LOCAL_NEXT_ERROR;
+	      b0->error = node->errors[SR_LOCAL_ERROR_NO_MORE_SEGMENTS];
+	      goto do_trace;
+	    }
+
+	  if (PREDICT_FALSE (sm->validate_hmac))
+	    {
+	      if (sr_validate_hmac (sm, ip0, sr0))
+		{
+		  next0 = SR_LOCAL_NEXT_ERROR;
+		  b0->error = node->errors[SR_LOCAL_ERROR_HMAC_INVALID];
+		  goto do_trace;
+		}
+	    }
+
+	  next0 = sr_local_cb ? sr_local_cb (vm, node, b0, ip0, sr0) : next0;
+
+	  /* 
+	   * To suppress rewrite, return ~SR_LOCAL_NEXT_xxx 
+	   */
+	  if (PREDICT_FALSE (next0 & 0x80000000))
+	    {
+	      next0 ^= 0xFFFFFFFF;
+	      if (PREDICT_FALSE (next0 == SR_LOCAL_NEXT_ERROR))
+		b0->error = node->errors[SR_LOCAL_ERROR_APP_CALLBACK];
+	    }
+	  else
+	    {
+	      u32 segment_index0;
+
+	      segment_index0 = sr0->segments_left - 1;
+
+	      /* Rewrite the packet */
+	      new_dst0 = (ip6_address_t *) (sr0->segments + segment_index0);
+	      ip0->dst_address.as_u64[0] = new_dst0->as_u64[0];
+	      ip0->dst_address.as_u64[1] = new_dst0->as_u64[1];
+
+	      if (PREDICT_TRUE (sr0->segments_left > 0))
+		sr0->segments_left -= 1;
+	    }
+
+	  /* End of the path. Clean up the SR header, or not */
+	  if (PREDICT_FALSE
+	      (sr0->segments_left == 0 &&
+	       (sr0->flags &
+		clib_host_to_net_u16 (IP6_SR_HEADER_FLAG_CLEANUP))))
+	    {
+	      u64 *copy_dst0, *copy_src0;
+	      u16 new_l0;
+	      /* 
+	       * Copy the ip6 header right by the (real) length of the
+	       * sr header. Here's another place which assumes that
+	       * the sr header is the only extention header.
+	       */
+
+	      ip0->protocol = sr0->protocol;
+	      vlib_buffer_advance (b0, (sr0->length + 1) * 8);
+
+	      new_l0 = clib_net_to_host_u16 (ip0->payload_length) -
+		(sr0->length + 1) * 8;
+	      ip0->payload_length = clib_host_to_net_u16 (new_l0);
+
+	      copy_src0 = (u64 *) ip0;
+	      copy_dst0 = copy_src0 + (sr0->length + 1);
+
+	      copy_dst0[4] = copy_src0[4];
+	      copy_dst0[3] = copy_src0[3];
+	      copy_dst0[2] = copy_src0[2];
+	      copy_dst0[1] = copy_src0[1];
+	      copy_dst0[0] = copy_src0[0];
+
+	      sr0 = 0;
+	    }
+
+	do_trace:
+	  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
+	    {
+	      sr_local_trace_t *tr = vlib_add_trace (vm, node,
+						     b0, sizeof (*tr));
+	      clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
+			   sizeof (tr->src.as_u8));
+	      clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
+			   sizeof (tr->dst.as_u8));
+	      tr->length = vlib_buffer_length_in_chain (vm, b0);
+	      tr->next_index = next0;
+	      tr->sr_valid = sr0 != 0;
+	      if (tr->sr_valid)
+		clib_memcpy (tr->sr, sr0, sizeof (tr->sr));
+	    }
 
 	  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 					   to_next, n_left_to_next,
@@ -2565,11 +2613,12 @@ sr_local (vlib_main_t * vm,
       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
     }
   vlib_node_increment_counter (vm, sr_local_node.index,
-                               SR_LOCAL_ERROR_PKTS_PROCESSED, 
-                               from_frame->n_vectors);
+			       SR_LOCAL_ERROR_PKTS_PROCESSED,
+			       from_frame->n_vectors);
   return from_frame->n_vectors;
 }
 
+/* *INDENT-OFF* */
 VLIB_REGISTER_NODE (sr_local_node, static) = {
   .function = sr_local,
   .name = "sr-local",
@@ -2589,58 +2638,56 @@ VLIB_REGISTER_NODE (sr_local_node, static) = {
 #undef _
   },
 };
+/* *INDENT-ON* */
 
 VLIB_NODE_FUNCTION_MULTIARCH (sr_local_node, sr_local)
-
-ip6_sr_main_t * sr_get_main (vlib_main_t * vm)
+     ip6_sr_main_t *sr_get_main (vlib_main_t * vm)
 {
   vlib_call_init_function (vm, sr_init);
-  ASSERT(sr_local_node.index);
+  ASSERT (sr_local_node.index);
   return &sr_main;
 }
 
 
 static clib_error_t *
 set_ip6_sr_rewrite_fn (vlib_main_t * vm,
-                       unformat_input_t * input,
-                       vlib_cli_command_t * cmd)
+		       unformat_input_t * input, vlib_cli_command_t * cmd)
 {
   ip6_address_t a;
-  ip6_main_t * im = &ip6_main;
-  ip_lookup_main_t * lm = &im->lookup_main;
+  ip6_main_t *im = &ip6_main;
+  ip_lookup_main_t *lm = &im->lookup_main;
   u32 fib_index = 0;
   u32 fib_id = 0;
   u32 adj_index;
-  uword * p;
-  ip_adjacency_t * adj;
-  vnet_hw_interface_t * hi;
+  uword *p;
+  ip_adjacency_t *adj;
+  vnet_hw_interface_t *hi;
   u32 sw_if_index;
-  ip6_sr_main_t * sm = &sr_main;
-  vnet_main_t * vnm = vnet_get_main();
+  ip6_sr_main_t *sm = &sr_main;
+  vnet_main_t *vnm = vnet_get_main ();
 
   if (!unformat (input, "%U", unformat_ip6_address, &a))
-    return clib_error_return (0, "ip6 address missing in '%U'", 
-                              format_unformat_error, input);
+    return clib_error_return (0, "ip6 address missing in '%U'",
+			      format_unformat_error, input);
 
   if (unformat (input, "rx-table-id %d", &fib_id))
     {
       p = hash_get (im->fib_index_by_table_id, fib_id);
       if (p == 0)
-        return clib_error_return (0, "fib-id %d not found");
+	return clib_error_return (0, "fib-id %d not found");
       fib_index = p[0];
     }
 
   adj_index = ip6_fib_lookup_with_table (im, fib_index, &a);
 
   if (adj_index == lm->miss_adj_index)
-    return clib_error_return (0, "no match for %U", 
-                              format_ip6_address, &a);
+    return clib_error_return (0, "no match for %U", format_ip6_address, &a);
 
   adj = ip_get_adjacency (lm, adj_index);
 
   if (adj->lookup_next_index != IP_LOOKUP_NEXT_REWRITE)
     return clib_error_return (0, "%U unresolved (not a rewrite adj)",
-                              format_ip6_address, &a);
+			      format_ip6_address, &a);
 
   adj->rewrite_header.next_index = sm->ip6_rewrite_sr_next_index;
 
@@ -2649,77 +2696,82 @@ set_ip6_sr_rewrite_fn (vlib_main_t * vm,
   adj->rewrite_header.node_index = sr_fix_dst_addr_node.index;
 
   /* $$$$$ hack... steal the mcast group index */
-  adj->mcast_group_index = 
-    vlib_node_add_next (vm, sr_fix_dst_addr_node.index, hi->output_node_index);
-  
+  adj->mcast_group_index =
+    vlib_node_add_next (vm, sr_fix_dst_addr_node.index,
+			hi->output_node_index);
+
   return 0;
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (set_ip6_sr_rewrite, static) = {
     .path = "set ip6 sr rewrite",
     .short_help = "set ip6 sr rewrite <ip6-address> [fib-id <id>]",
     .function = set_ip6_sr_rewrite_fn,
 };
+/* *INDENT-ON* */
 
-void vnet_register_sr_app_callback (void *cb)
+void
+vnet_register_sr_app_callback (void *cb)
 {
-  ip6_sr_main_t * sm = &sr_main;
- 
+  ip6_sr_main_t *sm = &sr_main;
+
   sm->sr_local_cb = cb;
 }
 
 static clib_error_t *
 test_sr_hmac_validate_fn (vlib_main_t * vm,
-                    unformat_input_t * input,
-                    vlib_cli_command_t * cmd)
+			  unformat_input_t * input, vlib_cli_command_t * cmd)
 {
-  ip6_sr_main_t * sm = &sr_main;
-  
+  ip6_sr_main_t *sm = &sr_main;
+
   if (unformat (input, "validate on"))
     sm->validate_hmac = 1;
   else if (unformat (input, "chunk-offset off"))
     sm->validate_hmac = 0;
   else
-    return clib_error_return (0, "expected validate on|off in '%U'", 
-                              format_unformat_error, input);
+    return clib_error_return (0, "expected validate on|off in '%U'",
+			      format_unformat_error, input);
 
   vlib_cli_output (vm, "hmac signature validation %s",
-                   sm->validate_hmac ? 
-                   "on" : "off");
+		   sm->validate_hmac ? "on" : "off");
   return 0;
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (test_sr_hmac_validate, static) = {
     .path = "test sr hmac",
     .short_help = "test sr hmac validate [on|off]",
     .function = test_sr_hmac_validate_fn,
 };
+/* *INDENT-ON* */
 
-i32 sr_hmac_add_del_key (ip6_sr_main_t * sm, u32 key_id, u8 * shared_secret,
-                         u8 is_del)
+i32
+sr_hmac_add_del_key (ip6_sr_main_t * sm, u32 key_id, u8 * shared_secret,
+		     u8 is_del)
 {
   u32 index;
-  ip6_sr_hmac_key_t * key;
+  ip6_sr_hmac_key_t *key;
 
   if (is_del == 0)
     {
       /* Specific key in use? Fail. */
       if (key_id && vec_len (sm->hmac_keys) > key_id
-          && sm->hmac_keys[key_id].shared_secret)
-        return -2;
-      
+	  && sm->hmac_keys[key_id].shared_secret)
+	return -2;
+
       index = key_id;
       key = find_or_add_shared_secret (sm, shared_secret, &index);
-      ASSERT(index == key_id);
+      ASSERT (index == key_id);
       return 0;
     }
 
   /* delete */
 
-  if (key_id)                   /* delete by key ID */
+  if (key_id)			/* delete by key ID */
     {
       if (vec_len (sm->hmac_keys) <= key_id)
-        return -3;
+	return -3;
 
       key = sm->hmac_keys + key_id;
 
@@ -2727,7 +2779,7 @@ i32 sr_hmac_add_del_key (ip6_sr_main_t * sm, u32 key_id, u8 * shared_secret,
       vec_free (key->shared_secret);
       return 0;
     }
-  
+
   index = 0;
   key = find_or_add_shared_secret (sm, shared_secret, &index);
   hash_unset_mem (sm->hmac_key_by_shared_secret, key->shared_secret);
@@ -2738,29 +2790,28 @@ i32 sr_hmac_add_del_key (ip6_sr_main_t * sm, u32 key_id, u8 * shared_secret,
 
 static clib_error_t *
 sr_hmac_add_del_key_fn (vlib_main_t * vm,
-                        unformat_input_t * input,
-                        vlib_cli_command_t * cmd)
+			unformat_input_t * input, vlib_cli_command_t * cmd)
 {
-  ip6_sr_main_t * sm = &sr_main;
+  ip6_sr_main_t *sm = &sr_main;
   u8 is_del = 0;
   u32 key_id = 0;
   u8 key_id_set = 0;
-  u8 * shared_secret = 0;
+  u8 *shared_secret = 0;
   i32 rv;
-  
+
   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
       if (unformat (input, "del"))
-        is_del = 1;
+	is_del = 1;
       else if (unformat (input, "id %d", &key_id))
-          key_id_set = 1;
+	key_id_set = 1;
       else if (unformat (input, "key %s", &shared_secret))
-        {
-          /* Do not include the trailing NULL byte. Guaranteed interop issue */
-          _vec_len (shared_secret) -= 1;
-        }
-      else 
-        break;
+	{
+	  /* Do not include the trailing NULL byte. Guaranteed interop issue */
+	  _vec_len (shared_secret) -= 1;
+	}
+      else
+	break;
     }
 
   if (is_del == 0 && shared_secret == 0)
@@ -2779,65 +2830,76 @@ sr_hmac_add_del_key_fn (vlib_main_t * vm,
       break;
 
     default:
-      return clib_error_return (0, "sr_hmac_add_del_key returned %d", 
-                                rv);
+      return clib_error_return (0, "sr_hmac_add_del_key returned %d", rv);
     }
 
   return 0;
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (sr_hmac, static) = {
     .path = "sr hmac",
     .short_help = "sr hmac [del] id <nn> key <str>",
     .function = sr_hmac_add_del_key_fn,
 };
+/* *INDENT-ON* */
 
 
 static clib_error_t *
 show_sr_hmac_fn (vlib_main_t * vm,
-                 unformat_input_t * input,
-                 vlib_cli_command_t * cmd)
+		 unformat_input_t * input, vlib_cli_command_t * cmd)
 {
-  ip6_sr_main_t * sm = &sr_main;
+  ip6_sr_main_t *sm = &sr_main;
   int i;
 
   for (i = 1; i < vec_len (sm->hmac_keys); i++)
     {
       if (sm->hmac_keys[i].shared_secret)
-          vlib_cli_output (vm, "[%d]: %v", i, sm->hmac_keys[i].shared_secret);
+	vlib_cli_output (vm, "[%d]: %v", i, sm->hmac_keys[i].shared_secret);
     }
 
   return 0;
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (show_sr_hmac, static) = {
     .path = "show sr hmac",
     .short_help = "show sr hmac", 
     .function = show_sr_hmac_fn,
 };
+/* *INDENT-ON* */
 
 static clib_error_t *
 test_sr_debug_fn (vlib_main_t * vm,
-                    unformat_input_t * input,
-                    vlib_cli_command_t * cmd)
+		  unformat_input_t * input, vlib_cli_command_t * cmd)
 {
-  ip6_sr_main_t * sm = &sr_main;
-  
+  ip6_sr_main_t *sm = &sr_main;
+
   if (unformat (input, "on"))
     sm->is_debug = 1;
   else if (unformat (input, "off"))
     sm->is_debug = 0;
   else
-    return clib_error_return (0, "expected on|off in '%U'", 
-                              format_unformat_error, input);
+    return clib_error_return (0, "expected on|off in '%U'",
+			      format_unformat_error, input);
 
   vlib_cli_output (vm, "debug trace now %s", sm->is_debug ? "on" : "off");
 
   return 0;
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (test_sr_debug, static) = {
     .path = "test sr debug",
     .short_help = "test sr debug on|off",
     .function = test_sr_debug_fn,
 };
+/* *INDENT-ON* */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/vnet/vnet/sr/sr.h b/vnet/vnet/sr/sr.h
index 448d29318ce..66135f744aa 100644
--- a/vnet/vnet/sr/sr.h
+++ b/vnet/vnet/sr/sr.h
@@ -28,17 +28,19 @@
 #include <openssl/opensslv.h>
 #include <openssl/hmac.h>
 
-typedef struct {
+typedef struct
+{
   ip6_address_t src;
   ip6_address_t dst;
 } ip6_sr_tunnel_key_t;
 
-typedef struct {
+typedef struct
+{
   /* src, dst address */
   ip6_sr_tunnel_key_t key;
 
   /* optional tunnel name */
-  u8 * name;
+  u8 *name;
 
   /* mask width for FIB entry */
   u32 dst_mask_width;
@@ -51,18 +53,20 @@ typedef struct {
   u32 tx_fib_index;
 
   /* The actual ip6 sr header */
-  u8 * rewrite;
+  u8 *rewrite;
 
   /* Indicates that this tunnel is part of a policy comprising
      of multiple tunnels. */
   u32 policy_index;
 } ip6_sr_tunnel_t;
 
-typedef struct {
-  u8 * shared_secret;
+typedef struct
+{
+  u8 *shared_secret;
 } ip6_sr_hmac_key_t;
 
-typedef struct {
+typedef struct
+{
   /* Key (header imposition case) */
   ip6_address_t *src_address;
   ip6_address_t *dst_address;
@@ -71,12 +75,12 @@ typedef struct {
   u32 tx_table_id;
 
   /* optional name argument - for referencing SR tunnel/policy by name */
-  u8 * name;
+  u8 *name;
 
   /* optional policy name */
-  u8 * policy_name;
+  u8 *policy_name;
 
-  /* segment list, when inserting an ip6 SR header*/
+  /* segment list, when inserting an ip6 SR header */
   ip6_address_t *segments;
 
   /* 
@@ -84,9 +88,9 @@ typedef struct {
    * past last_seg
    */
   ip6_address_t *tags;
-     
+
   /* Shared secret => generate SHA-256 HMAC security fields */
-  u8 * shared_secret;
+  u8 *shared_secret;
 
   /* Flags, e.g. cleanup, policy-list flags */
   u16 flags_net_byte_order;
@@ -95,70 +99,74 @@ typedef struct {
   u8 is_del;
 } ip6_sr_add_del_tunnel_args_t;
 
-typedef struct {
+typedef struct
+{
   /* policy name */
-  u8 * name;
+  u8 *name;
 
   /* tunnel names */
-  u8 ** tunnel_names;
+  u8 **tunnel_names;
 
   /* Delete the policy? */
   u8 is_del;
 } ip6_sr_add_del_policy_args_t;
 
 
-typedef struct {
+typedef struct
+{
   /* name of policy */
-  u8 * name;
-  
+  u8 *name;
+
   /* vector to SR tunnel index */
-  u32 * tunnel_indices;
+  u32 *tunnel_indices;
 
 } ip6_sr_policy_t;
 
-typedef struct {
+typedef struct
+{
   /* multicast IP6 address */
   ip6_address_t *multicast_address;
 
   /* name of policy to map to */
-  u8 * policy_name;
+  u8 *policy_name;
 
   /* Delete the mapping */
   u8 is_del;
 
 } ip6_sr_add_del_multicastmap_args_t;
 
-typedef struct {
+typedef struct
+{
   /* pool of tunnel instances, sr entry only */
   ip6_sr_tunnel_t *tunnels;
 
   /* find an sr "tunnel" by its outer-IP src/dst */
-  uword * tunnel_index_by_key;
+  uword *tunnel_index_by_key;
 
   /* find an sr "tunnel" by its name */
-  uword * tunnel_index_by_name;
+  uword *tunnel_index_by_name;
 
   /* policy pool */
-  ip6_sr_policy_t * policies;
+  ip6_sr_policy_t *policies;
 
   /* find a policy by name */
-  uword * policy_index_by_policy_name;
+  uword *policy_index_by_policy_name;
 
   /* multicast address to policy mapping */
-  uword * policy_index_by_multicast_address;
+  uword *policy_index_by_multicast_address;
 
   /* ip6-lookup next index for imposition FIB entries */
   u32 ip6_lookup_sr_next_index;
 
   /* hmac key id by shared secret */
-  uword * hmac_key_by_shared_secret;
+  uword *hmac_key_by_shared_secret;
 
   /* ip6-rewrite next index for reinstalling the original dst address */
   u32 ip6_rewrite_sr_next_index;
 
   /* ip6-replicate next index for multicast tunnel */
   u32 ip6_lookup_sr_replicate_index;
-  
+
   /* application API callback */
   void *sr_local_cb;
 
@@ -166,18 +174,18 @@ typedef struct {
   u8 validate_hmac;
 
   /* pool of hmac keys */
-  ip6_sr_hmac_key_t * hmac_keys;
+  ip6_sr_hmac_key_t *hmac_keys;
 
   /* Openssl vbls */
-  EVP_MD * md;
-  HMAC_CTX * hmac_ctx;
+  EVP_MD *md;
+  HMAC_CTX *hmac_ctx;
 
   /* enable debug spew */
   u8 is_debug;
 
   /* convenience */
-  vlib_main_t * vlib_main;
-  vnet_main_t * vnet_main;
+  vlib_main_t *vlib_main;
+  vnet_main_t *vnet_main;
 } ip6_sr_main_t;
 
 ip6_sr_main_t sr_main;
@@ -197,7 +205,15 @@ int ip6_sr_add_del_multicastmap (ip6_sr_add_del_multicastmap_args_t * a);
 
 void vnet_register_sr_app_callback (void *cb);
 
-void sr_fix_hmac (ip6_sr_main_t * sm, ip6_header_t * ip, 
+void sr_fix_hmac (ip6_sr_main_t * sm, ip6_header_t * ip,
 		  ip6_sr_header_t * sr);
 
 #endif /* included_vnet_sr_h */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/vnet/vnet/sr/sr_packet.h b/vnet/vnet/sr/sr_packet.h
index f9672e8025b..5d8fee2f6b2 100644
--- a/vnet/vnet/sr/sr_packet.h
+++ b/vnet/vnet/sr/sr_packet.h
@@ -169,7 +169,8 @@
 
 #define ROUTING_HEADER_TYPE_SR    4
 
-typedef struct {
+typedef struct
+{
   /* Protocol for next header. */
   u8 protocol;
   /*
@@ -202,10 +203,10 @@ typedef struct {
   /* values 0x4 - 0x7 are reserved */
   u16 flags;
   u8 hmac_key;
-  
+
   /* The segment + policy list elts */
   ip6_address_t segments[0];
-} __attribute__((packed)) ip6_sr_header_t; 
+} __attribute__ ((packed)) ip6_sr_header_t;
 
 static inline int
 ip6_sr_policy_list_shift_from_index (int pl_index)
@@ -214,7 +215,7 @@ ip6_sr_policy_list_shift_from_index (int pl_index)
 }
 
 /* pl_index is one-origined, to match the text above */
-static inline int 
+static inline int
 ip6_sr_policy_list_flags (u16 flags_host_byte_order, int pl_index)
 {
   int shift;
@@ -229,3 +230,11 @@ ip6_sr_policy_list_flags (u16 flags_host_byte_order, int pl_index)
 }
 
 #endif /* included_vnet_sr_packet_h */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/vnet/vnet/sr/sr_replicate.c b/vnet/vnet/sr/sr_replicate.c
index f059ce95fb3..f5a71a311c4 100644
--- a/vnet/vnet/sr/sr_replicate.c
+++ b/vnet/vnet/sr/sr_replicate.c
@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-#if DPDK > 0 /* Cannot run replicate without DPDK */
+#if DPDK > 0			/* Cannot run replicate without DPDK */
 #include <vlib/vlib.h>
 #include <vnet/vnet.h>
 #include <vnet/pg/pg.h>
@@ -28,16 +28,18 @@
 #include <vppinfra/error.h>
 #include <vppinfra/elog.h>
 
-typedef struct {
+typedef struct
+{
   /* convenience */
-  vlib_main_t * vlib_main;
-  vnet_main_t * vnet_main;
+  vlib_main_t *vlib_main;
+  vnet_main_t *vnet_main;
 } sr_replicate_main_t;
 
 sr_replicate_main_t sr_replicate_main;
 
 
-typedef struct {
+typedef struct
+{
   ip6_address_t src, dst;
   u16 length;
   u32 next_index;
@@ -46,21 +48,22 @@ typedef struct {
 } sr_replicate_trace_t;
 
 /* packet trace format function */
-static u8 * format_sr_replicate_trace (u8 * s, va_list * args)
+static u8 *
+format_sr_replicate_trace (u8 * s, va_list * args)
 {
   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
-  sr_replicate_trace_t * t = va_arg (*args, sr_replicate_trace_t *);
-  ip6_main_t * im = &ip6_main;
-  ip6_sr_main_t * sm = &sr_main;
+  sr_replicate_trace_t *t = va_arg (*args, sr_replicate_trace_t *);
+  ip6_main_t *im = &ip6_main;
+  ip6_sr_main_t *sm = &sr_main;
   ip6_sr_tunnel_t *tun = pool_elt_at_index (sm->tunnels, t->tunnel_index);
-  ip6_fib_t * rx_fib, * tx_fib;
+  ip6_fib_t *rx_fib, *tx_fib;
 
   rx_fib = find_ip6_fib_by_table_index_or_id (im, tun->rx_fib_index,
-                                              IP6_ROUTE_FLAG_FIB_INDEX);
+					      IP6_ROUTE_FLAG_FIB_INDEX);
 
   tx_fib = find_ip6_fib_by_table_index_or_id (im, tun->tx_fib_index,
-                                              IP6_ROUTE_FLAG_FIB_INDEX);
+					      IP6_ROUTE_FLAG_FIB_INDEX);
 
   s = format
     (s, "SR-REPLICATE: next %s ip6 src %U dst %U len %u\n"
@@ -69,7 +72,7 @@ static u8 * format_sr_replicate_trace (u8 * s, va_list * args)
      format_ip6_address, &t->src,
      format_ip6_address, &t->dst, t->length,
      rx_fib->table_id, tx_fib->table_id,
-     format_ip6_sr_header, t->sr, 0 /* print_hmac */);
+     format_ip6_sr_header, t->sr, 0 /* print_hmac */ );
   return s;
 
 }
@@ -80,37 +83,38 @@ _(NO_BUFFERS, "error allocating buffers for replicas") \
 _(NO_REPLICAS, "no replicas were needed") \
 _(NO_BUFFER_DROPS, "sr no buffer drops")
 
-typedef enum {
+typedef enum
+{
 #define _(sym,str) SR_REPLICATE_ERROR_##sym,
   foreach_sr_replicate_error
 #undef _
-  SR_REPLICATE_N_ERROR,
+    SR_REPLICATE_N_ERROR,
 } sr_replicate_error_t;
 
-static char * sr_replicate_error_strings[] = {
+static char *sr_replicate_error_strings[] = {
 #define _(sym,string) string,
   foreach_sr_replicate_error
 #undef _
 };
 
-typedef enum {
+typedef enum
+{
   SR_REPLICATE_NEXT_IP6_LOOKUP,
   SR_REPLICATE_N_NEXT,
 } sr_replicate_next_t;
 
 static uword
 sr_replicate_node_fn (vlib_main_t * vm,
-		  vlib_node_runtime_t * node,
-		  vlib_frame_t * frame)
+		      vlib_node_runtime_t * node, vlib_frame_t * frame)
 {
-  u32 n_left_from, * from, * to_next;
+  u32 n_left_from, *from, *to_next;
   sr_replicate_next_t next_index;
   int pkts_replicated = 0;
-  ip6_sr_main_t * sm = &sr_main;
+  ip6_sr_main_t *sm = &sr_main;
   int no_buffer_drops = 0;
-  vlib_buffer_free_list_t * fl;
-  unsigned socket_id = rte_socket_id();
-  vlib_buffer_main_t * bm = vm->buffer_main;
+  vlib_buffer_free_list_t *fl;
+  unsigned socket_id = rte_socket_id ();
+  vlib_buffer_main_t *bm = vm->buffer_main;
 
   from = vlib_frame_vector_args (frame);
   n_left_from = frame->n_vectors;
@@ -122,19 +126,18 @@ sr_replicate_node_fn (vlib_main_t * vm,
     {
       u32 n_left_to_next;
 
-      vlib_get_next_frame (vm, node, next_index,
-			   to_next, n_left_to_next);
+      vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 
       while (n_left_from > 0 && n_left_to_next > 0)
 	{
-          u32 bi0, hdr_bi0;
-	  vlib_buffer_t * b0, * orig_b0;
-	  struct rte_mbuf * orig_mb0 = 0, * hdr_mb0 = 0, * clone0 = 0;
-	  struct rte_mbuf ** hdr_vec = 0, ** rte_mbuf_vec = 0;
-	  ip6_sr_policy_t * pol0 = 0;
-	  ip6_sr_tunnel_t * t0 = 0;
-	  ip6_sr_header_t * hdr_sr0 = 0;
-	  ip6_header_t * ip0 = 0, * hdr_ip0 = 0;
+	  u32 bi0, hdr_bi0;
+	  vlib_buffer_t *b0, *orig_b0;
+	  struct rte_mbuf *orig_mb0 = 0, *hdr_mb0 = 0, *clone0 = 0;
+	  struct rte_mbuf **hdr_vec = 0, **rte_mbuf_vec = 0;
+	  ip6_sr_policy_t *pol0 = 0;
+	  ip6_sr_tunnel_t *t0 = 0;
+	  ip6_sr_header_t *hdr_sr0 = 0;
+	  ip6_header_t *ip0 = 0, *hdr_ip0 = 0;
 	  int num_replicas = 0;
 	  int i;
 
@@ -143,71 +146,72 @@ sr_replicate_node_fn (vlib_main_t * vm,
 	  b0 = vlib_get_buffer (vm, bi0);
 	  orig_b0 = b0;
 
-          pol0 = pool_elt_at_index (sm->policies,
-                                    vnet_buffer(b0)->ip.save_protocol);
+	  pol0 = pool_elt_at_index (sm->policies,
+				    vnet_buffer (b0)->ip.save_protocol);
 
-          ip0 = vlib_buffer_get_current (b0);
-          /* Skip forward to the punch-in point */
-          vlib_buffer_advance (b0, sizeof(*ip0));
+	  ip0 = vlib_buffer_get_current (b0);
+	  /* Skip forward to the punch-in point */
+	  vlib_buffer_advance (b0, sizeof (*ip0));
 
-          orig_mb0 = rte_mbuf_from_vlib_buffer (b0);
+	  orig_mb0 = rte_mbuf_from_vlib_buffer (b0);
 
 	  i16 delta0 = vlib_buffer_length_in_chain (vm, orig_b0)
-            - (i16) orig_mb0->pkt_len;
+	    - (i16) orig_mb0->pkt_len;
 
-	  u16 new_data_len0 = (u16)((i16) orig_mb0->data_len + delta0);
-	  u16 new_pkt_len0  = (u16)((i16) orig_mb0->pkt_len + delta0);
+	  u16 new_data_len0 = (u16) ((i16) orig_mb0->data_len + delta0);
+	  u16 new_pkt_len0 = (u16) ((i16) orig_mb0->pkt_len + delta0);
 
 	  orig_mb0->data_len = new_data_len0;
 	  orig_mb0->pkt_len = new_pkt_len0;
-	  orig_mb0->data_off = (u16)(RTE_PKTMBUF_HEADROOM + b0->current_data);
+	  orig_mb0->data_off =
+	    (u16) (RTE_PKTMBUF_HEADROOM + b0->current_data);
 
 	  /*
-	    Before entering loop determine if we can allocate:
-	    - all the new HEADER RTE_MBUFs and assign them to a vector
-	    - all the clones
+	     Before entering loop determine if we can allocate:
+	     - all the new HEADER RTE_MBUFs and assign them to a vector
+	     - all the clones
 
-	    if successful, then iterate over vectors of resources
+	     if successful, then iterate over vectors of resources
 
 	   */
 	  num_replicas = vec_len (pol0->tunnel_indices);
 
-          if (PREDICT_FALSE(num_replicas == 0))
-            {
-              b0->error = node->errors[SR_REPLICATE_ERROR_NO_REPLICAS];
-              goto do_trace0;
-            }
+	  if (PREDICT_FALSE (num_replicas == 0))
+	    {
+	      b0->error = node->errors[SR_REPLICATE_ERROR_NO_REPLICAS];
+	      goto do_trace0;
+	    }
 
 	  vec_reset_length (hdr_vec);
 	  vec_reset_length (rte_mbuf_vec);
 
-	  for (i=0; i < num_replicas; i++)
+	  for (i = 0; i < num_replicas; i++)
 	    {
-              hdr_mb0 = rte_pktmbuf_alloc(bm->pktmbuf_pools[socket_id]);
+	      hdr_mb0 = rte_pktmbuf_alloc (bm->pktmbuf_pools[socket_id]);
 
-	      if (i < (num_replicas - 1) )
+	      if (i < (num_replicas - 1))
 		/* Not the last tunnel to process */
 		clone0 = rte_pktmbuf_clone
-		    (orig_mb0, bm->pktmbuf_pools[socket_id]);
+		  (orig_mb0, bm->pktmbuf_pools[socket_id]);
 	      else
-		  /* Last tunnel to process, use original MB */
+		/* Last tunnel to process, use original MB */
 		clone0 = orig_mb0;
-	      
-	      
-	      if (PREDICT_FALSE( !clone0 || !hdr_mb0 ))
+
+
+	      if (PREDICT_FALSE (!clone0 || !hdr_mb0))
 		{
 		  b0->error = node->errors[SR_REPLICATE_ERROR_NO_BUFFERS];
-		  
-		  vec_foreach_index (i, rte_mbuf_vec) 
-		    { 
-		      rte_pktmbuf_free(rte_mbuf_vec[i]); 
-		    } 
+
+		  vec_foreach_index (i, rte_mbuf_vec)
+		  {
+		    rte_pktmbuf_free (rte_mbuf_vec[i]);
+		  }
 		  vec_free (rte_mbuf_vec);
-		  
-		  vec_foreach_index (i, hdr_vec) 
-		    { 
-		      rte_pktmbuf_free(hdr_vec[i]); 
-		    } 
+
+		  vec_foreach_index (i, hdr_vec)
+		  {
+		    rte_pktmbuf_free (hdr_vec[i]);
+		  }
 		  vec_free (hdr_vec);
 
 		  goto do_trace0;
@@ -218,68 +222,72 @@ sr_replicate_node_fn (vlib_main_t * vm,
 
 	    }
 
-	  for (i=0; i < num_replicas; i++)
+	  for (i = 0; i < num_replicas; i++)
 	    {
-              vlib_buffer_t * hdr_b0;
+	      vlib_buffer_t *hdr_b0;
 
 	      t0 = vec_elt_at_index (sm->tunnels, pol0->tunnel_indices[i]);
 
 	      /* Our replicas */
-              hdr_mb0 = hdr_vec[i];
+	      hdr_mb0 = hdr_vec[i];
 	      clone0 = rte_mbuf_vec[i];
 
-              hdr_mb0->data_len = sizeof (*ip0) + vec_len (t0->rewrite);
-              hdr_mb0->pkt_len = hdr_mb0->data_len +
-                  vlib_buffer_length_in_chain (vm, orig_b0);
+	      hdr_mb0->data_len = sizeof (*ip0) + vec_len (t0->rewrite);
+	      hdr_mb0->pkt_len = hdr_mb0->data_len +
+		vlib_buffer_length_in_chain (vm, orig_b0);
 
-              hdr_b0 = vlib_buffer_from_rte_mbuf (hdr_mb0);
+	      hdr_b0 = vlib_buffer_from_rte_mbuf (hdr_mb0);
 
-              vlib_buffer_init_for_free_list (hdr_b0, fl);
+	      vlib_buffer_init_for_free_list (hdr_b0, fl);
 
-              memcpy (hdr_b0->data, ip0, sizeof (*ip0));
-              memcpy (hdr_b0->data + sizeof (*ip0), t0->rewrite,
-                      vec_len (t0->rewrite));
+	      memcpy (hdr_b0->data, ip0, sizeof (*ip0));
+	      memcpy (hdr_b0->data + sizeof (*ip0), t0->rewrite,
+		      vec_len (t0->rewrite));
 
-              hdr_b0->current_data = 0;
-              hdr_b0->current_length = sizeof (*ip0) + vec_len (t0->rewrite);
-              hdr_b0->flags = orig_b0->flags | VLIB_BUFFER_NEXT_PRESENT;
+	      hdr_b0->current_data = 0;
+	      hdr_b0->current_length = sizeof (*ip0) + vec_len (t0->rewrite);
+	      hdr_b0->flags = orig_b0->flags | VLIB_BUFFER_NEXT_PRESENT;
 
 
-              hdr_b0->total_length_not_including_first_buffer =
-                hdr_mb0->pkt_len - hdr_b0->current_length;
+	      hdr_b0->total_length_not_including_first_buffer =
+		hdr_mb0->pkt_len - hdr_b0->current_length;
 
-              hdr_ip0 = (ip6_header_t *) hdr_b0->data;
-              hdr_ip0->payload_length = clib_host_to_net_u16(hdr_mb0->data_len);
-              hdr_sr0 = (ip6_sr_header_t *) (hdr_ip0+1);
-              hdr_sr0->protocol = hdr_ip0->protocol;
-              hdr_ip0->protocol = 43;
+	      hdr_ip0 = (ip6_header_t *) hdr_b0->data;
+	      hdr_ip0->payload_length =
+		clib_host_to_net_u16 (hdr_mb0->data_len);
+	      hdr_sr0 = (ip6_sr_header_t *) (hdr_ip0 + 1);
+	      hdr_sr0->protocol = hdr_ip0->protocol;
+	      hdr_ip0->protocol = 43;
 
 	      /* Rewrite the ip6 dst address */
 	      hdr_ip0->dst_address.as_u64[0] = t0->first_hop.as_u64[0];
 	      hdr_ip0->dst_address.as_u64[1] = t0->first_hop.as_u64[1];
 
-              sr_fix_hmac (sm, hdr_ip0, hdr_sr0);
+	      sr_fix_hmac (sm, hdr_ip0, hdr_sr0);
 
-              /* prepend new header to invariant piece */
-              hdr_mb0->next = clone0;
-	      hdr_b0->next_buffer = vlib_get_buffer_index (vm, vlib_buffer_from_rte_mbuf (clone0));
+	      /* prepend new header to invariant piece */
+	      hdr_mb0->next = clone0;
+	      hdr_b0->next_buffer =
+		vlib_get_buffer_index (vm,
+				       vlib_buffer_from_rte_mbuf (clone0));
 
-              /* update header's fields */
-              hdr_mb0->pkt_len = (uint16_t)(hdr_mb0->data_len + clone0->pkt_len);
-              hdr_mb0->nb_segs = (uint8_t)(clone0->nb_segs + 1);
+	      /* update header's fields */
+	      hdr_mb0->pkt_len =
+		(uint16_t) (hdr_mb0->data_len + clone0->pkt_len);
+	      hdr_mb0->nb_segs = (uint8_t) (clone0->nb_segs + 1);
 
-              /* copy metadata from source packet*/
-              hdr_mb0->port = clone0->port;
-              hdr_mb0->vlan_tci = clone0->vlan_tci;
-              hdr_mb0->vlan_tci_outer = clone0->vlan_tci_outer;
-              hdr_mb0->tx_offload = clone0->tx_offload;
-              hdr_mb0->hash = clone0->hash;
+	      /* copy metadata from source packet */
+	      hdr_mb0->port = clone0->port;
+	      hdr_mb0->vlan_tci = clone0->vlan_tci;
+	      hdr_mb0->vlan_tci_outer = clone0->vlan_tci_outer;
+	      hdr_mb0->tx_offload = clone0->tx_offload;
+	      hdr_mb0->hash = clone0->hash;
 
-              hdr_mb0->ol_flags = clone0->ol_flags;
+	      hdr_mb0->ol_flags = clone0->ol_flags;
 
-              __rte_mbuf_sanity_check(hdr_mb0, 1);
+	      __rte_mbuf_sanity_check (hdr_mb0, 1);
 
-              hdr_bi0 = vlib_get_buffer_index (vm, hdr_b0);
+	      hdr_bi0 = vlib_get_buffer_index (vm, hdr_b0);
 
 	      to_next[0] = hdr_bi0;
 	      to_next += 1;
@@ -299,25 +307,25 @@ sr_replicate_node_fn (vlib_main_t * vm,
 	  n_left_from -= 1;
 
 	do_trace0:
-          if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
-            {
-              sr_replicate_trace_t *tr = vlib_add_trace (vm, node,
-                                                       b0, sizeof (*tr));
-              tr->tunnel_index = t0 - sm->tunnels;
-              tr->length = 0;
+	  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
+	    {
+	      sr_replicate_trace_t *tr = vlib_add_trace (vm, node,
+							 b0, sizeof (*tr));
+	      tr->tunnel_index = t0 - sm->tunnels;
+	      tr->length = 0;
 	      if (hdr_ip0)
 		{
 		  memcpy (tr->src.as_u8, hdr_ip0->src_address.as_u8,
-                      sizeof (tr->src.as_u8));
+			  sizeof (tr->src.as_u8));
 		  memcpy (tr->dst.as_u8, hdr_ip0->dst_address.as_u8,
-                      sizeof (tr->dst.as_u8));
-                  if (hdr_ip0->payload_length)
-                      tr->length = clib_net_to_host_u16
-                          (hdr_ip0->payload_length);
+			  sizeof (tr->dst.as_u8));
+		  if (hdr_ip0->payload_length)
+		    tr->length = clib_net_to_host_u16
+		      (hdr_ip0->payload_length);
 		}
-              tr->next_index = next_index;
-              memcpy (tr->sr, hdr_sr0, sizeof (tr->sr));
-            }
+	      tr->next_index = next_index;
+	      memcpy (tr->sr, hdr_sr0, sizeof (tr->sr));
+	    }
 
 	}
 
@@ -325,14 +333,17 @@ sr_replicate_node_fn (vlib_main_t * vm,
     }
 
   vlib_node_increment_counter (vm, sr_replicate_node.index,
-                               SR_REPLICATE_ERROR_REPLICATED, pkts_replicated);
+			       SR_REPLICATE_ERROR_REPLICATED,
+			       pkts_replicated);
 
   vlib_node_increment_counter (vm, sr_replicate_node.index,
-                               SR_REPLICATE_ERROR_NO_BUFFER_DROPS, no_buffer_drops);
+			       SR_REPLICATE_ERROR_NO_BUFFER_DROPS,
+			       no_buffer_drops);
 
   return frame->n_vectors;
 }
 
+/* *INDENT-OFF* */
 VLIB_REGISTER_NODE (sr_replicate_node) = {
   .function = sr_replicate_node_fn,
   .name = "sr-replicate",
@@ -349,19 +360,27 @@ VLIB_REGISTER_NODE (sr_replicate_node) = {
         [SR_REPLICATE_NEXT_IP6_LOOKUP] = "ip6-lookup",
   },
 };
+/* *INDENT-ON* */
 
 VLIB_NODE_FUNCTION_MULTIARCH (sr_replicate_node, sr_replicate_node_fn)
-
-clib_error_t *sr_replicate_init (vlib_main_t *vm)
+     clib_error_t *sr_replicate_init (vlib_main_t * vm)
 {
   sr_replicate_main_t *msm = &sr_replicate_main;
 
   msm->vlib_main = vm;
-  msm->vnet_main = vnet_get_main();
+  msm->vnet_main = vnet_get_main ();
 
   return 0;
 }
 
-VLIB_INIT_FUNCTION(sr_replicate_init);
+VLIB_INIT_FUNCTION (sr_replicate_init);
 
 #endif /* DPDK */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */