VPP-237 Coding standards cleanup

Change-Id: I239143f920285050ad85244ece6893236195534f
Signed-off-by: Dave Barach <dave@barachs.net>

6 files changed, 1165 insertions, 1052 deletions

diff --git a/vpp/app/l2t.c b/vpp/app/l2t.c
index eb6848ff..45dd2807 100644
--- a/vpp/app/l2t.c
+++ b/vpp/app/l2t.c
@@ -28,489 +28,530 @@
 
 l2t_main_t l2t_main;
 
-/* $$$$ unused? 
+/* $$$$ unused?
  * get_interface_ethernet_address
  * paints the ethernet address for a given interface
  * into the supplied destination
  */
-void get_interface_ethernet_address (l2t_main_t *lm, 
-                                     u8 *dst, u32 sw_if_index)
+void
+get_interface_ethernet_address (l2t_main_t * lm, u8 * dst, u32 sw_if_index)
 {
-    ethernet_main_t *em = ethernet_get_main (lm->vlib_main);
-    ethernet_interface_t *ei;
-    vnet_hw_interface_t *hi;
+  ethernet_main_t *em = ethernet_get_main (lm->vlib_main);
+  ethernet_interface_t *ei;
+  vnet_hw_interface_t *hi;
 
-    hi = vnet_get_sup_hw_interface (lm->vnet_main, sw_if_index);
-    ei = pool_elt_at_index (em->interfaces, hi->hw_instance);
-    clib_memcpy (dst, ei->address, sizeof (ei->address));
+  hi = vnet_get_sup_hw_interface (lm->vnet_main, sw_if_index);
+  ei = pool_elt_at_index (em->interfaces, hi->hw_instance);
+  clib_memcpy (dst, ei->address, sizeof (ei->address));
 }
 
 /* packet trace format function */
-u8 * format_l2t_trace (u8 * s, va_list * args)
+u8 *
+format_l2t_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 *);
-  l2t_trace_t * t = va_arg (*args, l2t_trace_t *);
-    
+  l2t_trace_t *t = va_arg (*args, l2t_trace_t *);
+
   if (t->is_user_to_network)
-      s = format (s, "L2T: %U (client) -> %U (our) session %d", 
-                  format_ip6_address, &t->client_address,
-                  format_ip6_address, &t->our_address,
-                  t->session_index);
+    s = format (s, "L2T: %U (client) -> %U (our) session %d",
+		format_ip6_address, &t->client_address,
+		format_ip6_address, &t->our_address, t->session_index);
   else
-      s = format (s, "L2T: %U (our) -> %U (client) session %d)",
-                  format_ip6_address, &t->our_address,
-                  format_ip6_address, &t->client_address,
-                  t->session_index);
+    s = format (s, "L2T: %U (our) -> %U (client) session %d)",
+		format_ip6_address, &t->our_address,
+		format_ip6_address, &t->client_address, t->session_index);
   return s;
 }
 
-u8 * format_l2t_session (u8 * s, va_list * args)
+u8 *
+format_l2t_session (u8 * s, va_list * args)
 {
-  l2t_session_t * session = va_arg (*args, l2t_session_t *);
-  l2t_main_t * lm = &l2t_main;
+  l2t_session_t *session = va_arg (*args, l2t_session_t *);
+  l2t_main_t *lm = &l2t_main;
   u32 counter_index;
   vlib_counter_t v;
 
-  s = format (s, "[%d] %U (our) %U (client) vlan-id %d rx_sw_if_index %d\n", 
-              session - lm->sessions,
-              format_ip6_address, &session->our_address,
-              format_ip6_address, &session->client_address,
-              clib_net_to_host_u16(session->vlan_id), session->sw_if_index);
+  s = format (s, "[%d] %U (our) %U (client) vlan-id %d rx_sw_if_index %d\n",
+	      session - lm->sessions,
+	      format_ip6_address, &session->our_address,
+	      format_ip6_address, &session->client_address,
+	      clib_net_to_host_u16 (session->vlan_id), session->sw_if_index);
 
   s = format (s, "   local cookie %llx remote cookie %llx\n",
-              clib_net_to_host_u64 (session->local_cookie),
-              clib_net_to_host_u64 (session->remote_cookie));
+	      clib_net_to_host_u64 (session->local_cookie),
+	      clib_net_to_host_u64 (session->remote_cookie));
 
-  if (session->cookie_flags & L2TP_COOKIE_ROLLOVER_LOCAL) {
-      s = format (s, "   local rollover cookie %llx\n", 
+  if (session->cookie_flags & L2TP_COOKIE_ROLLOVER_LOCAL)
+    {
+      s = format (s, "   local rollover cookie %llx\n",
 		  clib_net_to_host_u64 (session->lcl_ro_cookie));
-  }
+    }
 
   s = format (s, "   local session-id %d remote session-id %d\n",
-              clib_net_to_host_u32 (session->local_session_id),
-              clib_net_to_host_u32 (session->remote_session_id));
+	      clib_net_to_host_u32 (session->local_session_id),
+	      clib_net_to_host_u32 (session->remote_session_id));
 
-  s = format (s, "   l2 specific sublayer %s\n", 
-              session->l2_sublayer_present ? "preset" : "absent");
+  s = format (s, "   l2 specific sublayer %s\n",
+	      session->l2_sublayer_present ? "preset" : "absent");
 
-  counter_index = 
-      session_index_to_counter_index (session - lm->sessions,
-                                      SESSION_COUNTER_USER_TO_NETWORK);
+  counter_index =
+    session_index_to_counter_index (session - lm->sessions,
+				    SESSION_COUNTER_USER_TO_NETWORK);
 
   vlib_get_combined_counter (&lm->counter_main, counter_index, &v);
   if (v.packets != 0)
-      s = format (s, "   user-to-net: %llu pkts %llu bytes\n",
-                  v.packets, v.bytes);
+    s = format (s, "   user-to-net: %llu pkts %llu bytes\n",
+		v.packets, v.bytes);
 
-  vlib_get_combined_counter (&lm->counter_main, counter_index+1, &v);
+  vlib_get_combined_counter (&lm->counter_main, counter_index + 1, &v);
 
   if (v.packets != 0)
-      s = format (s, "   net-to-user: %llu pkts %llu bytes\n",
-                  v.packets, v.bytes);
+    s = format (s, "   net-to-user: %llu pkts %llu bytes\n",
+		v.packets, v.bytes);
   return s;
 }
 
 static clib_error_t *
 show_session_summary_command_fn (vlib_main_t * vm,
-                                unformat_input_t * input,
-                                vlib_cli_command_t * cmd)
+				 unformat_input_t * input,
+				 vlib_cli_command_t * cmd)
 {
-    l2t_main_t *lm = &l2t_main;
-    
-    vlib_cli_output (vm, "%d active sessions\n", pool_elts (lm->sessions));
+  l2t_main_t *lm = &l2t_main;
 
-    return 0;
+  vlib_cli_output (vm, "%d active sessions\n", pool_elts (lm->sessions));
+
+  return 0;
 }
 
+/* *INDENT-OFF* */
 static VLIB_CLI_COMMAND (show_session_summary_command) = {
-    .path = "show session",
-    .short_help = "show session summary",
-    .function = show_session_summary_command_fn,
+  .path = "show session",
+  .short_help = "show session summary",
+  .function = show_session_summary_command_fn,
 };
+/* *INDENT-ON* */
 
 static clib_error_t *
 show_session_detail_command_fn (vlib_main_t * vm,
-                                unformat_input_t * input,
-                                vlib_cli_command_t * cmd)
+				unformat_input_t * input,
+				vlib_cli_command_t * cmd)
 {
-    l2t_session_t *session;
-    l2t_main_t *lm = &l2t_main;
+  l2t_session_t *session;
+  l2t_main_t *lm = &l2t_main;
 
-    pool_foreach (session, lm->sessions, 
-    ({
-        vlib_cli_output (vm, "%U", format_l2t_session, session);
-    }));
+  /* *INDENT-OFF* */
+  pool_foreach (session, lm->sessions,
+  ({
+    vlib_cli_output (vm, "%U", format_l2t_session, session);
+  }));
+  /* *INDENT-ON* */
 
-    return 0;
+  return 0;
 }
 
+/* *INDENT-OFF* */
 static VLIB_CLI_COMMAND (show_session_detail_command) = {
-    .path = "show session detail",
-    .short_help = "show session table detail",
-    .function = show_session_detail_command_fn,
+  .path = "show session detail",
+  .short_help = "show session table detail",
+  .function = show_session_detail_command_fn,
 };
+/* *INDENT-ON* */
 
 static clib_error_t *
 test_counters_command_fn (vlib_main_t * vm,
-                          unformat_input_t * input,
-                          vlib_cli_command_t * cmd)
+			  unformat_input_t * input, vlib_cli_command_t * cmd)
 {
-    l2t_session_t *session;
-    l2t_main_t *lm = &l2t_main;
-    u32 session_index;
-    u32 counter_index;
-    u32 nincr=0;
-
-    pool_foreach (session, lm->sessions, 
-    ({
-        session_index = session - lm->sessions;
-        counter_index = 
-            session_index_to_counter_index (session_index, 
-                                            SESSION_COUNTER_USER_TO_NETWORK);
-        vlib_increment_combined_counter (&lm->counter_main,
-                                         counter_index, 
-                                         1/*pkt*/, 1111 /*bytes*/);
-        vlib_increment_combined_counter (&lm->counter_main,
-                                         counter_index+1, 
-                                         1/*pkt*/, 2222 /*bytes*/);
-        nincr++;
-        
-    }));
-    vlib_cli_output (vm, "Incremented %d active counters\n", nincr);
-
-    return 0;
+  l2t_session_t *session;
+  l2t_main_t *lm = &l2t_main;
+  u32 session_index;
+  u32 counter_index;
+  u32 nincr = 0;
+
+  /* *INDENT-OFF* */
+  pool_foreach (session, lm->sessions,
+  ({
+    session_index = session - lm->sessions;
+    counter_index =
+      session_index_to_counter_index (session_index,
+                                      SESSION_COUNTER_USER_TO_NETWORK);
+    vlib_increment_combined_counter (&lm->counter_main,
+                                     counter_index,
+                                     1/*pkt*/, 1111 /*bytes*/);
+    vlib_increment_combined_counter (&lm->counter_main,
+                                     counter_index+1,
+                                     1/*pkt*/, 2222 /*bytes*/);
+    nincr++;
+  }));
+  /* *INDENT-ON* */
+  vlib_cli_output (vm, "Incremented %d active counters\n", nincr);
+
+  return 0;
 }
 
+/* *INDENT-OFF* */
 static VLIB_CLI_COMMAND (test_counters_command) = {
-    .path = "test counters",
-    .short_help = "increment all active counters",
-    .function = test_counters_command_fn,
+  .path = "test counters",
+  .short_help = "increment all active counters",
+  .function = test_counters_command_fn,
 };
+/* *INDENT-ON* */
 
 static clib_error_t *
 clear_counters_command_fn (vlib_main_t * vm,
-                          unformat_input_t * input,
-                          vlib_cli_command_t * cmd)
+			   unformat_input_t * input, vlib_cli_command_t * cmd)
 {
-    l2t_session_t *session;
-    l2t_main_t *lm = &l2t_main;
-    u32 session_index;
-    u32 counter_index;
-    u32 nincr=0;
-
-    pool_foreach (session, lm->sessions, 
-    ({
-        session_index = session - lm->sessions;
-        counter_index = 
-            session_index_to_counter_index (session_index, 
-                                            SESSION_COUNTER_USER_TO_NETWORK);
-        vlib_zero_combined_counter (&lm->counter_main, counter_index);
-        vlib_zero_combined_counter (&lm->counter_main, counter_index+1);
-        nincr++;
-        
-    }));
-    vlib_cli_output (vm, "Cleared %d active counters\n", nincr);
-
-    return 0;
+  l2t_session_t *session;
+  l2t_main_t *lm = &l2t_main;
+  u32 session_index;
+  u32 counter_index;
+  u32 nincr = 0;
+
+  /* *INDENT-OFF* */
+  pool_foreach (session, lm->sessions,
+  ({
+    session_index = session - lm->sessions;
+    counter_index =
+      session_index_to_counter_index (session_index,
+                                      SESSION_COUNTER_USER_TO_NETWORK);
+    vlib_zero_combined_counter (&lm->counter_main, counter_index);
+    vlib_zero_combined_counter (&lm->counter_main, counter_index+1);
+    nincr++;
+  }));
+  /* *INDENT-ON* */
+  vlib_cli_output (vm, "Cleared %d active counters\n", nincr);
+
+  return 0;
 }
 
+/* *INDENT-OFF* */
 static VLIB_CLI_COMMAND (clear_counters_command) = {
-    .path = "clear counters",
-    .short_help = "clear all active counters",
-    .function = clear_counters_command_fn,
+  .path = "clear counters",
+  .short_help = "clear all active counters",
+  .function = clear_counters_command_fn,
 };
+/* *INDENT-ON* */
 
 static clib_error_t *
 l2tp_session_add_command_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 client_address, our_address;
-    ip6_address_t * dst_address_copy, * src_address_copy;
-    unformat_input_t _line_input, * line_input = &_line_input;
-    u32 vlan_id;
-    u32 sw_if_index = (u32)~0;
-    l2t_main_t *lm = &l2t_main;
-    l2t_session_t *s;
-    uword *p;
-    vnet_hw_interface_t * hi;
-    vnet_sw_interface_t * si;
-    u32 next_index;
-    uword vlan_and_sw_if_index_key;
-    u32 counter_index;
-    u64 local_cookie = (u64)~0, remote_cookie = (u64)~0;
-    u32 local_session_id = 1, remote_session_id = 1;
-    int our_address_set = 0, client_address_set = 0;
-    int l2_sublayer_present = 0;
-
-    /* Get a line of input. */
-    if (! unformat_user (input, unformat_line_input, line_input))
-        return 0;
-
-    while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
-        if (unformat (line_input, "client %U", 
-                      unformat_ip6_address, &client_address))
-            client_address_set = 1;
-        else if (unformat (line_input, "our %U",
-                           unformat_ip6_address, &our_address))
-            our_address_set = 1;
-        else if (unformat (line_input, "vlan %d", &vlan_id))
-            ;
-        else if (unformat (line_input, "l2-interface %U",
-                           unformat_vnet_sw_interface, 
-                           vnet_get_main(), &sw_if_index))
-            ;
-        else if (unformat (line_input, "interface %U",
-                           unformat_vnet_sw_interface, 
-                           vnet_get_main(), &sw_if_index))
-            ;
-        else if (unformat (line_input, "local-cookie %llx", &local_cookie))
-            ;
-        else if (unformat (line_input, "remote-cookie %llx", &remote_cookie))
-            ;
-        else if (unformat (line_input, "local-session-id %d", 
-                           &local_session_id))
-            ;
-        else if (unformat (line_input, "remote-session-id %d", 
-                           &remote_session_id))
-            ;
-        else if (unformat (line_input, "l2-sublayer-present"))
-            l2_sublayer_present = 1;
-        else 
-            return clib_error_return (0, "parse error: '%U'", 
-                                      format_unformat_error, line_input);
+  ip6_address_t client_address, our_address;
+  ip6_address_t *dst_address_copy, *src_address_copy;
+  unformat_input_t _line_input, *line_input = &_line_input;
+  u32 vlan_id;
+  u32 sw_if_index = (u32) ~ 0;
+  l2t_main_t *lm = &l2t_main;
+  l2t_session_t *s;
+  uword *p;
+  vnet_hw_interface_t *hi;
+  vnet_sw_interface_t *si;
+  u32 next_index;
+  uword vlan_and_sw_if_index_key;
+  u32 counter_index;
+  u64 local_cookie = (u64) ~ 0, remote_cookie = (u64) ~ 0;
+  u32 local_session_id = 1, remote_session_id = 1;
+  int our_address_set = 0, client_address_set = 0;
+  int l2_sublayer_present = 0;
+
+  /* Get a line of input. */
+  if (!unformat_user (input, unformat_line_input, line_input))
+    return 0;
+
+  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (line_input, "client %U",
+		    unformat_ip6_address, &client_address))
+	client_address_set = 1;
+      else if (unformat (line_input, "our %U",
+			 unformat_ip6_address, &our_address))
+	our_address_set = 1;
+      else if (unformat (line_input, "vlan %d", &vlan_id))
+	;
+      else if (unformat (line_input, "l2-interface %U",
+			 unformat_vnet_sw_interface,
+			 vnet_get_main (), &sw_if_index))
+	;
+      else if (unformat (line_input, "interface %U",
+			 unformat_vnet_sw_interface,
+			 vnet_get_main (), &sw_if_index))
+	;
+      else if (unformat (line_input, "local-cookie %llx", &local_cookie))
+	;
+      else if (unformat (line_input, "remote-cookie %llx", &remote_cookie))
+	;
+      else if (unformat (line_input, "local-session-id %d",
+			 &local_session_id))
+	;
+      else if (unformat (line_input, "remote-session-id %d",
+			 &remote_session_id))
+	;
+      else if (unformat (line_input, "l2-sublayer-present"))
+	l2_sublayer_present = 1;
+      else
+	return clib_error_return (0, "parse error: '%U'",
+				  format_unformat_error, line_input);
     }
 
-    unformat_free (line_input);
+  unformat_free (line_input);
 
-    if (sw_if_index == (u32)~0)
-        return clib_error_return (0, "l2-interface not specified");
-    if (our_address_set == 0)
-        return clib_error_return (0, "our address not specified");
-    if (client_address_set == 0)
-        return clib_error_return (0, "client address not specified");
+  if (sw_if_index == (u32) ~ 0)
+    return clib_error_return (0, "l2-interface not specified");
+  if (our_address_set == 0)
+    return clib_error_return (0, "our address not specified");
+  if (client_address_set == 0)
+    return clib_error_return (0, "client address not specified");
 
-    remote_session_id = clib_host_to_net_u32 (remote_session_id);
-    local_session_id  = clib_host_to_net_u32 (local_session_id);
+  remote_session_id = clib_host_to_net_u32 (remote_session_id);
+  local_session_id = clib_host_to_net_u32 (local_session_id);
 
-    switch (lm->lookup_type) {
+  switch (lm->lookup_type)
+    {
     case L2T_LOOKUP_SRC_ADDRESS:
-        p = hash_get_mem (lm->session_by_src_address, &client_address);
-        if (p) 
-            return clib_error_return 
-                (0, "Session w/ client address %U already exists",
-                 format_ip6_address, &client_address);
-        break;
-        
+      p = hash_get_mem (lm->session_by_src_address, &client_address);
+      if (p)
+	return clib_error_return
+	  (0, "Session w/ client address %U already exists",
+	   format_ip6_address, &client_address);
+      break;
+
     case L2T_LOOKUP_DST_ADDRESS:
-        p = hash_get_mem (lm->session_by_dst_address, &our_address);
-        if (p) 
-            return clib_error_return 
-                (0, "Session w/ our address %U already exists",
-                 format_ip6_address, &our_address);
-        break;
+      p = hash_get_mem (lm->session_by_dst_address, &our_address);
+      if (p)
+	return clib_error_return
+	  (0, "Session w/ our address %U already exists",
+	   format_ip6_address, &our_address);
+      break;
 
     case L2T_LOOKUP_SESSION_ID:
-        p = hash_get (lm->session_by_session_id, local_session_id);
-        if (p) 
-            return clib_error_return 
-                (0, 
-                 "Session w/ local session id %d already exists",
-                 clib_net_to_host_u32 (local_session_id));
-        break;
+      p = hash_get (lm->session_by_session_id, local_session_id);
+      if (p)
+	return clib_error_return
+	  (0,
+	   "Session w/ local session id %d already exists",
+	   clib_net_to_host_u32 (local_session_id));
+      break;
 
     default:
-        ASSERT(0);
+      ASSERT (0);
     }
-    
-    pool_get (lm->sessions, s);
-    memset (s, 0, sizeof (*s));
-    clib_memcpy (&s->our_address, &our_address, sizeof (s->our_address));
-    clib_memcpy (&s->client_address, &client_address, sizeof (s->client_address));
-    s->sw_if_index = sw_if_index;
-    s->vlan_id = clib_host_to_net_u16 (vlan_id);
-    s->local_cookie = clib_host_to_net_u64 (local_cookie);
-    l2tp_session_set_remote_cookie (s, remote_cookie);
-    s->local_session_id = local_session_id;
-    s->remote_session_id = remote_session_id;
-    s->l2_sublayer_present = l2_sublayer_present;
-    
-    hi = vnet_get_sup_hw_interface (lm->vnet_main, sw_if_index);
-    si = vnet_get_sup_sw_interface (lm->vnet_main, sw_if_index);
-
-    next_index = vlib_node_add_next (vm, l2t_ip6_node.index,
-                                     hi->output_node_index);
-    s->l2_output_next_index = next_index;
-    s->l2_output_sw_if_index = si->sw_if_index;
-
-    /* Setup hash table entries */
-    switch (lm->lookup_type) {
+
+  pool_get (lm->sessions, s);
+  memset (s, 0, sizeof (*s));
+  clib_memcpy (&s->our_address, &our_address, sizeof (s->our_address));
+  clib_memcpy (&s->client_address, &client_address,
+	       sizeof (s->client_address));
+  s->sw_if_index = sw_if_index;
+  s->vlan_id = clib_host_to_net_u16 (vlan_id);
+  s->local_cookie = clib_host_to_net_u64 (local_cookie);
+  l2tp_session_set_remote_cookie (s, remote_cookie);
+  s->local_session_id = local_session_id;
+  s->remote_session_id = remote_session_id;
+  s->l2_sublayer_present = l2_sublayer_present;
+
+  hi = vnet_get_sup_hw_interface (lm->vnet_main, sw_if_index);
+  si = vnet_get_sup_sw_interface (lm->vnet_main, sw_if_index);
+
+  next_index = vlib_node_add_next (vm, l2t_ip6_node.index,
+				   hi->output_node_index);
+  s->l2_output_next_index = next_index;
+  s->l2_output_sw_if_index = si->sw_if_index;
+
+  /* Setup hash table entries */
+  switch (lm->lookup_type)
+    {
     case L2T_LOOKUP_SRC_ADDRESS:
-        src_address_copy = clib_mem_alloc (sizeof (*src_address_copy));
-        clib_memcpy (src_address_copy, &client_address, sizeof (*src_address_copy));
-        hash_set_mem (lm->session_by_src_address, src_address_copy, 
-                      s - lm->sessions);
-        break;
+      src_address_copy = clib_mem_alloc (sizeof (*src_address_copy));
+      clib_memcpy (src_address_copy, &client_address,
+		   sizeof (*src_address_copy));
+      hash_set_mem (lm->session_by_src_address, src_address_copy,
+		    s - lm->sessions);
+      break;
     case L2T_LOOKUP_DST_ADDRESS:
-        dst_address_copy = clib_mem_alloc (sizeof (*dst_address_copy));
-        clib_memcpy (dst_address_copy, &our_address, sizeof (*dst_address_copy));
-        hash_set_mem (lm->session_by_dst_address, dst_address_copy, 
-                      s - lm->sessions);
-        break;
+      dst_address_copy = clib_mem_alloc (sizeof (*dst_address_copy));
+      clib_memcpy (dst_address_copy, &our_address,
+		   sizeof (*dst_address_copy));
+      hash_set_mem (lm->session_by_dst_address, dst_address_copy,
+		    s - lm->sessions);
+      break;
     case L2T_LOOKUP_SESSION_ID:
-        hash_set (lm->session_by_session_id, local_session_id, 
-                  s - lm->sessions);
-        break;
+      hash_set (lm->session_by_session_id, local_session_id,
+		s - lm->sessions);
+      break;
 
     default:
-        ASSERT(0);
+      ASSERT (0);
     }
 
-    vlan_and_sw_if_index_key = ((uword)(s->vlan_id)<<32) | sw_if_index;
-    hash_set (lm->session_by_vlan_and_rx_sw_if_index,
-              vlan_and_sw_if_index_key, s - lm->sessions);
-    
-    /* validate counters */
-    counter_index = 
-        session_index_to_counter_index (s - lm->sessions,
-                                        SESSION_COUNTER_USER_TO_NETWORK);
-    vlib_validate_counter (&lm->counter_main, counter_index);
-    vlib_validate_counter (&lm->counter_main, counter_index+1);
-        
-    /* Set promiscuous mode on the l2 interface */
-    ethernet_set_flags (lm->vnet_main, hi->hw_if_index, 
-                        ETHERNET_INTERFACE_FLAG_ACCEPT_ALL);
-    vnet_hw_interface_rx_redirect_to_node (lm->vnet_main, hi->hw_if_index,
-                                           l2t_l2_node.index);
-    return 0;
+  vlan_and_sw_if_index_key = ((uword) (s->vlan_id) << 32) | sw_if_index;
+  hash_set (lm->session_by_vlan_and_rx_sw_if_index,
+	    vlan_and_sw_if_index_key, s - lm->sessions);
+
+  /* validate counters */
+  counter_index =
+    session_index_to_counter_index (s - lm->sessions,
+				    SESSION_COUNTER_USER_TO_NETWORK);
+  vlib_validate_counter (&lm->counter_main, counter_index);
+  vlib_validate_counter (&lm->counter_main, counter_index + 1);
+
+  /* Set promiscuous mode on the l2 interface */
+  ethernet_set_flags (lm->vnet_main, hi->hw_if_index,
+		      ETHERNET_INTERFACE_FLAG_ACCEPT_ALL);
+  vnet_hw_interface_rx_redirect_to_node (lm->vnet_main, hi->hw_if_index,
+					 l2t_l2_node.index);
+  return 0;
 }
 
+/* *INDENT-OFF* */
 static VLIB_CLI_COMMAND (l2tp_session_add_command) = {
-    .path = "l2tp session add",
-    .short_help = 
-    "l2tp session add client <ip6> our <ip6> vlan <id> local-cookie <hex> remote-cookie <hex> local-session <dec> remote-session <dec> l2-interface <int>",
-    .function = l2tp_session_add_command_fn,
+  .path = "l2tp session add",
+  .short_help =
+  "l2tp session add client <ip6> our <ip6> vlan <id> local-cookie <hex> remote-cookie <hex> local-session <dec> remote-session <dec> l2-interface <int>",
+  .function = l2tp_session_add_command_fn,
 };
+/* *INDENT-ON* */
 
 static clib_error_t *
 l2tp_session_del_command_fn (vlib_main_t * vm,
-                             unformat_input_t * input,
-                             vlib_cli_command_t * cmd)
+			     unformat_input_t * input,
+			     vlib_cli_command_t * cmd)
 {
-    l2t_main_t *lm = &l2t_main;
-    u32 session_index;
-    l2t_session_t *s;
-    hash_pair_t * hp;
-    void *key;
-    uword vlan_and_sw_if_index_key;
-
-    if (!unformat (input, "%d", &session_index)) 
-        return clib_error_return (0, "missing session index: '%U'", 
-                                  format_unformat_error, input);
-        
-    if (pool_is_free_index (lm->sessions, session_index))
-        return clib_error_return (0, "session %d not in use", session_index);
-
-    s = pool_elt_at_index (lm->sessions, session_index);
-
-    switch (lm->lookup_type) {
+  l2t_main_t *lm = &l2t_main;
+  u32 session_index;
+  l2t_session_t *s;
+  hash_pair_t *hp;
+  void *key;
+  uword vlan_and_sw_if_index_key;
+
+  if (!unformat (input, "%d", &session_index))
+    return clib_error_return (0, "missing session index: '%U'",
+			      format_unformat_error, input);
+
+  if (pool_is_free_index (lm->sessions, session_index))
+    return clib_error_return (0, "session %d not in use", session_index);
+
+  s = pool_elt_at_index (lm->sessions, session_index);
+
+  switch (lm->lookup_type)
+    {
     case L2T_LOOKUP_SRC_ADDRESS:
-        hp = hash_get_pair_mem (lm->session_by_src_address, &s->client_address);
-        if (hp) {
-            key = (void *)(hp->key);
-            hash_unset_mem (lm->session_by_src_address, &s->client_address);
-            clib_mem_free (key);
-        } else
-            clib_warning ("session %d src address key %U AWOL", 
-                          s - lm->sessions, 
-                          format_ip6_address, &s->client_address);
-        break;
+      hp = hash_get_pair_mem (lm->session_by_src_address, &s->client_address);
+      if (hp)
+	{
+	  key = (void *) (hp->key);
+	  hash_unset_mem (lm->session_by_src_address, &s->client_address);
+	  clib_mem_free (key);
+	}
+      else
+	clib_warning ("session %d src address key %U AWOL",
+		      s - lm->sessions,
+		      format_ip6_address, &s->client_address);
+      break;
 
     case L2T_LOOKUP_DST_ADDRESS:
-        hp = hash_get_pair_mem (lm->session_by_dst_address, &s->our_address);
-        if (hp) {
-            key = (void *)(hp->key);
-            hash_unset_mem (lm->session_by_dst_address, &s->our_address);
-            clib_mem_free (key);
-        } else
-            clib_warning ("session %d dst address key %U AWOL", 
-                          s - lm->sessions, 
-                          format_ip6_address, &s->our_address);
-        break;
+      hp = hash_get_pair_mem (lm->session_by_dst_address, &s->our_address);
+      if (hp)
+	{
+	  key = (void *) (hp->key);
+	  hash_unset_mem (lm->session_by_dst_address, &s->our_address);
+	  clib_mem_free (key);
+	}
+      else
+	clib_warning ("session %d dst address key %U AWOL",
+		      s - lm->sessions, format_ip6_address, &s->our_address);
+      break;
 
     case L2T_LOOKUP_SESSION_ID:
-        hash_unset (lm->session_by_session_id, s->local_session_id);
-        break;
-        
+      hash_unset (lm->session_by_session_id, s->local_session_id);
+      break;
+
     default:
-        ASSERT(0);
+      ASSERT (0);
     }
-        
-    vlan_and_sw_if_index_key = ((uword)(s->vlan_id)<<32) | s->sw_if_index;
 
-    hash_unset (lm->session_by_vlan_and_rx_sw_if_index, vlan_and_sw_if_index_key);
-        
-    pool_put (lm->sessions, s);
-    return 0;
+  vlan_and_sw_if_index_key = ((uword) (s->vlan_id) << 32) | s->sw_if_index;
+
+  hash_unset (lm->session_by_vlan_and_rx_sw_if_index,
+	      vlan_and_sw_if_index_key);
+
+  pool_put (lm->sessions, s);
+  return 0;
 }
 
+/* *INDENT-OFF* */
 static VLIB_CLI_COMMAND (l2tp_session_del_command) = {
-    .path = "l2tp session delete",
-    .short_help = 
-    "l2tp session delete <session-id>",
-    .function = l2tp_session_del_command_fn,
+  .path = "l2tp session delete",
+  .short_help =
+  "l2tp session delete <session-id>",
+  .function = l2tp_session_del_command_fn,
 };
+/* *INDENT-ON* */
 
 static clib_error_t *
 l2tp_session_cookie_command_fn (vlib_main_t * vm,
 				unformat_input_t * input,
 				vlib_cli_command_t * cmd)
 {
-    l2t_main_t *lm = &l2t_main;
-    u32 session_index;
-    l2t_session_t *s;
-    u64 lcl_ro_cookie = (u64)~0, rem_ro_cookie = (u64)~0;
-    u8 cookie_flags = 0;
-
-    if (!unformat (input, "%d", &session_index)) 
-        return clib_error_return (0, "missing session index: '%U'", 
-                                  format_unformat_error, input);
-        
-    if (pool_is_free_index (lm->sessions, session_index))
-        return clib_error_return (0, "session %d not in use", session_index);
-
-    s = pool_elt_at_index (lm->sessions, session_index);
-
-    if (unformat (input, "commit")) {
-	if (!s->cookie_flags) {
-	    return clib_error_return (0,
-				      "no rollover cookie ready to commit");
-	} else {
-	    l2tp_session_cookie_commit (s);
-	    return 0;
+  l2t_main_t *lm = &l2t_main;
+  u32 session_index;
+  l2t_session_t *s;
+  u64 lcl_ro_cookie = (u64) ~ 0, rem_ro_cookie = (u64) ~ 0;
+  u8 cookie_flags = 0;
+
+  if (!unformat (input, "%d", &session_index))
+    return clib_error_return (0, "missing session index: '%U'",
+			      format_unformat_error, input);
+
+  if (pool_is_free_index (lm->sessions, session_index))
+    return clib_error_return (0, "session %d not in use", session_index);
+
+  s = pool_elt_at_index (lm->sessions, session_index);
+
+  if (unformat (input, "commit"))
+    {
+      if (!s->cookie_flags)
+	{
+	  return clib_error_return (0, "no rollover cookie ready to commit");
+	}
+      else
+	{
+	  l2tp_session_cookie_commit (s);
+	  return 0;
 	}
     }
-    if (!unformat (input, "rollover"))
-	return clib_error_return (0, "missing 'commit|rollover': '%U'", 
-                                  format_unformat_error, input);
-    if (unformat (input, "local %llx", &lcl_ro_cookie)) {
-	cookie_flags |= L2TP_COOKIE_ROLLOVER_LOCAL;
-	l2tp_session_set_local_rollover_cookie (s, lcl_ro_cookie);
+  if (!unformat (input, "rollover"))
+    return clib_error_return (0, "missing 'commit|rollover': '%U'",
+			      format_unformat_error, input);
+  if (unformat (input, "local %llx", &lcl_ro_cookie))
+    {
+      cookie_flags |= L2TP_COOKIE_ROLLOVER_LOCAL;
+      l2tp_session_set_local_rollover_cookie (s, lcl_ro_cookie);
     }
-    if (unformat (input, "remote %llx", &rem_ro_cookie)) {
-	cookie_flags |= L2TP_COOKIE_ROLLOVER_REMOTE;
-	l2tp_session_set_remote_cookie (s, rem_ro_cookie);
+  if (unformat (input, "remote %llx", &rem_ro_cookie))
+    {
+      cookie_flags |= L2TP_COOKIE_ROLLOVER_REMOTE;
+      l2tp_session_set_remote_cookie (s, rem_ro_cookie);
     }
-    if (!cookie_flags)
-	return clib_error_return (0, "no rollover cookie specified");
+  if (!cookie_flags)
+    return clib_error_return (0, "no rollover cookie specified");
 
-    return 0;
+  return 0;
 }
 
+/* *INDENT-OFF* */
 static VLIB_CLI_COMMAND (l2tp_session_cookie_command) = {
-    .path = "l2tp session cookie",
-    .short_help = 
-    "l2tp session cookie <session id> commit|rollover [local <hex>] [remote <hex>]",
-    .function = l2tp_session_cookie_command_fn,
+  .path = "l2tp session cookie",
+  .short_help =
+  "l2tp session cookie <session id> commit|rollover [local <hex>] [remote <hex>]",
+  .function = l2tp_session_cookie_command_fn,
 };
+/* *INDENT-ON* */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/vpp/app/l2t_ip6.c b/vpp/app/l2t_ip6.c
index 8a1e23a9..ff680734 100644
--- a/vpp/app/l2t_ip6.c
+++ b/vpp/app/l2t_ip6.c
@@ -35,233 +35,237 @@ l2t_main_t l2t_main;
 #define foreach_l2t_ip6_error                                   \
 _(USER_TO_NETWORK, "User (v6) to L2 network pkts")              \
 _(SESSION_ID_MISMATCH, "l2tpv3 local session id mismatches")    \
-_(COOKIE_MISMATCH, "l2tpv3 local cookie mismatches")  
+_(COOKIE_MISMATCH, "l2tpv3 local cookie mismatches")
 
-static char * l2t_ip6_error_strings[] = {
+static char *l2t_ip6_error_strings[] = {
 #define _(sym,string) string,
   foreach_l2t_ip6_error
 #undef _
 };
 
-typedef enum {
+typedef enum
+{
 #define _(sym,str) L2T_IP6_ERROR_##sym,
-    foreach_l2t_ip6_error
+  foreach_l2t_ip6_error
 #undef _
     L2T_IP6_N_ERROR,
 } l2t_ip6_error_t;
 
 /*
- * Packets go to ip6-input when they don't match a mapping, 
+ * Packets go to ip6-input when they don't match a mapping,
  * example: v6 neighbor discovery. They go to ip4-input
  * when they do match, and are decapsulated.
  */
-typedef enum { 
-    L2T_IP6_NEXT_DROP,
-    L2T_IP6_NEXT_IP6_INPUT,
-    L2T_IP6_N_NEXT,
-    /* Pseudo next, fixed in last_stage */
-    L2T_IP6_NEXT_OUTPUT = L2T_IP6_N_NEXT,
+typedef enum
+{
+  L2T_IP6_NEXT_DROP,
+  L2T_IP6_NEXT_IP6_INPUT,
+  L2T_IP6_N_NEXT,
+  /* Pseudo next, fixed in last_stage */
+  L2T_IP6_NEXT_OUTPUT = L2T_IP6_N_NEXT,
 } l2t_ip6_next_t;
 
 vlib_node_registration_t l2t_ip6_node;
 
 #define NSTAGES 3
 
-static inline void stage0 (vlib_main_t * vm,
-                           vlib_node_runtime_t * node,
-                           u32 buffer_index)
+static inline void
+stage0 (vlib_main_t * vm, vlib_node_runtime_t * node, u32 buffer_index)
 {
-    vlib_buffer_t *b = vlib_get_buffer (vm, buffer_index);
-    vlib_prefetch_buffer_header (b, STORE);
-    /* l2tpv3 header is a long way away, need 2 cache lines */
-    CLIB_PREFETCH (b->data, 2*CLIB_CACHE_LINE_BYTES, STORE);
+  vlib_buffer_t *b = vlib_get_buffer (vm, buffer_index);
+  vlib_prefetch_buffer_header (b, STORE);
+  /* l2tpv3 header is a long way away, need 2 cache lines */
+  CLIB_PREFETCH (b->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
 }
 
-static inline void stage1 (vlib_main_t * vm,
-                           vlib_node_runtime_t * node,
-                           u32 bi)
+static inline void
+stage1 (vlib_main_t * vm, vlib_node_runtime_t * node, u32 bi)
 {
-    vlib_buffer_t *b = vlib_get_buffer (vm, bi);
-    l2t_main_t *lm = &l2t_main;
-    ip6_header_t * ip6 = vlib_buffer_get_current (b);
-    u32 session_index;
-    uword *p;
-    l2tpv3_header_t * l2t;
-
-    /* Not L2tpv3 (0x73, 0t115)? Use the normal path. */
-    if (PREDICT_FALSE(ip6->protocol != 0x73)) {
-        vnet_buffer(b)->l2t.next_index = L2T_IP6_NEXT_IP6_INPUT;
-        return;
+  vlib_buffer_t *b = vlib_get_buffer (vm, bi);
+  l2t_main_t *lm = &l2t_main;
+  ip6_header_t *ip6 = vlib_buffer_get_current (b);
+  u32 session_index;
+  uword *p;
+  l2tpv3_header_t *l2t;
+
+  /* Not L2tpv3 (0x73, 0t115)? Use the normal path. */
+  if (PREDICT_FALSE (ip6->protocol != 0x73))
+    {
+      vnet_buffer (b)->l2t.next_index = L2T_IP6_NEXT_IP6_INPUT;
+      return;
     }
 
-    /* Make up your minds, people... */
-    switch (lm->lookup_type) {
+  /* Make up your minds, people... */
+  switch (lm->lookup_type)
+    {
     case L2T_LOOKUP_SRC_ADDRESS:
-        p = hash_get_mem (lm->session_by_src_address, &ip6->src_address);
-        break;
+      p = hash_get_mem (lm->session_by_src_address, &ip6->src_address);
+      break;
     case L2T_LOOKUP_DST_ADDRESS:
-        p = hash_get_mem (lm->session_by_dst_address, &ip6->dst_address);
-        break;
+      p = hash_get_mem (lm->session_by_dst_address, &ip6->dst_address);
+      break;
     case L2T_LOOKUP_SESSION_ID:
-        l2t = (l2tpv3_header_t*)(ip6+1);
-        p = hash_get (lm->session_by_session_id, l2t->session_id);
-        break;
+      l2t = (l2tpv3_header_t *) (ip6 + 1);
+      p = hash_get (lm->session_by_session_id, l2t->session_id);
+      break;
     default:
-        ASSERT(0);
+      ASSERT (0);
     }
 
-    if (PREDICT_FALSE(p == 0)) {
-        vnet_buffer(b)->l2t.next_index = L2T_IP6_NEXT_IP6_INPUT;
-        return;
-    } else {
-        session_index = p[0];
+  if (PREDICT_FALSE (p == 0))
+    {
+      vnet_buffer (b)->l2t.next_index = L2T_IP6_NEXT_IP6_INPUT;
+      return;
+    }
+  else
+    {
+      session_index = p[0];
     }
 
-    /* Remember mapping index, prefetch the mini counter */
-    vnet_buffer(b)->l2t.next_index = L2T_IP6_NEXT_OUTPUT;
-    vnet_buffer(b)->l2t.session_index = session_index;
+  /* Remember mapping index, prefetch the mini counter */
+  vnet_buffer (b)->l2t.next_index = L2T_IP6_NEXT_OUTPUT;
+  vnet_buffer (b)->l2t.session_index = session_index;
 
-    /* Each mapping has 2 x (pkt, byte) counters, hence the shift */
-    CLIB_PREFETCH(lm->counter_main.mini + (p[0]<<1), CLIB_CACHE_LINE_BYTES,
-                  STORE);
+  /* Each mapping has 2 x (pkt, byte) counters, hence the shift */
+  CLIB_PREFETCH (lm->counter_main.mini + (p[0] << 1), CLIB_CACHE_LINE_BYTES,
+		 STORE);
 }
 
-static inline u32 last_stage (vlib_main_t *vm, vlib_node_runtime_t *node,
-                              u32 bi)
+static inline u32
+last_stage (vlib_main_t * vm, vlib_node_runtime_t * node, u32 bi)
 {
-    vlib_buffer_t *b = vlib_get_buffer (vm, bi);
-    l2t_main_t *lm = &l2t_main;
-    ip6_header_t * ip6 = vlib_buffer_get_current (b);
-    vlib_node_t *n = vlib_get_node (vm, l2t_ip6_node.index);
-    u32 node_counter_base_index = n->error_heap_index;
-    vlib_error_main_t * em = &vm->error_main;
-    ethernet_header_t * l2_payload;
-    l2tpv3_header_t * l2t;      /* original l2 header */
-    ethernet_vlan_header_t * vh; /* synthesized 802.1q vlan header */
-    u32 counter_index;
-    l2t_session_t * session;
-    u16 payload_ethertype;
-    u8 dst_mac_address[6];
-    u8 src_mac_address[6];
-    u8 *vlan_header_pos;
-    
-    /* Other-than-output pkt? We're done... */
-    if (vnet_buffer(b)->l2t.next_index != L2T_IP6_NEXT_OUTPUT) 
-        return vnet_buffer(b)->l2t.next_index;
-
-    em->counters[node_counter_base_index + L2T_IP6_ERROR_USER_TO_NETWORK] += 1;
-    
-    counter_index = 
-        session_index_to_counter_index (vnet_buffer(b)->l2t.session_index,
-                                        SESSION_COUNTER_USER_TO_NETWORK);
-
-    /* per-mapping byte stats include the ethernet header */
-    vlib_increment_combined_counter (&lm->counter_main, counter_index,
-                                     1 /* packet_increment */,
-                                     vlib_buffer_length_in_chain (vm, b) +
-                                     sizeof (ethernet_header_t));
-    
-    session = pool_elt_at_index (lm->sessions, 
-                                 vnet_buffer(b)->l2t.session_index);
-
-    /* build the 802.1q encaps. Advance past ip6 and l2tpv3 hds */
-    vlib_buffer_advance (b, sizeof (*ip6));
-    l2t = vlib_buffer_get_current (b);
-    
-    /* $$$ wonder if we really need these checks... */
-    if (PREDICT_FALSE(l2t->session_id != session->local_session_id)) {
-	  b->error = lm->ip6_error_node->
-              errors[L2T_IP6_ERROR_SESSION_ID_MISMATCH];
-          return L2T_IP6_NEXT_DROP;
+  vlib_buffer_t *b = vlib_get_buffer (vm, bi);
+  l2t_main_t *lm = &l2t_main;
+  ip6_header_t *ip6 = vlib_buffer_get_current (b);
+  vlib_node_t *n = vlib_get_node (vm, l2t_ip6_node.index);
+  u32 node_counter_base_index = n->error_heap_index;
+  vlib_error_main_t *em = &vm->error_main;
+  ethernet_header_t *l2_payload;
+  l2tpv3_header_t *l2t;		/* original l2 header */
+  ethernet_vlan_header_t *vh;	/* synthesized 802.1q vlan header */
+  u32 counter_index;
+  l2t_session_t *session;
+  u16 payload_ethertype;
+  u8 dst_mac_address[6];
+  u8 src_mac_address[6];
+  u8 *vlan_header_pos;
+
+  /* Other-than-output pkt? We're done... */
+  if (vnet_buffer (b)->l2t.next_index != L2T_IP6_NEXT_OUTPUT)
+    return vnet_buffer (b)->l2t.next_index;
+
+  em->counters[node_counter_base_index + L2T_IP6_ERROR_USER_TO_NETWORK] += 1;
+
+  counter_index =
+    session_index_to_counter_index (vnet_buffer (b)->l2t.session_index,
+				    SESSION_COUNTER_USER_TO_NETWORK);
+
+  /* per-mapping byte stats include the ethernet header */
+  vlib_increment_combined_counter (&lm->counter_main, counter_index,
+				   1 /* packet_increment */ ,
+				   vlib_buffer_length_in_chain (vm, b) +
+				   sizeof (ethernet_header_t));
+
+  session = pool_elt_at_index (lm->sessions,
+			       vnet_buffer (b)->l2t.session_index);
+
+  /* build the 802.1q encaps. Advance past ip6 and l2tpv3 hds */
+  vlib_buffer_advance (b, sizeof (*ip6));
+  l2t = vlib_buffer_get_current (b);
+
+  /* $$$ wonder if we really need these checks... */
+  if (PREDICT_FALSE (l2t->session_id != session->local_session_id))
+    {
+      b->error =
+	lm->ip6_error_node->errors[L2T_IP6_ERROR_SESSION_ID_MISMATCH];
+      return L2T_IP6_NEXT_DROP;
     }
 
-    if (PREDICT_FALSE(!((l2t->cookie == session->local_cookie) || 
-			((session->cookie_flags & L2TP_COOKIE_ROLLOVER_LOCAL) &&
-			 (l2t->cookie == session->lcl_ro_cookie))))) {
-	  b->error = lm->ip6_error_node->
-              errors[L2T_IP6_ERROR_COOKIE_MISMATCH];
-          return L2T_IP6_NEXT_DROP;
+  if (PREDICT_FALSE (!((l2t->cookie == session->local_cookie) ||
+		       ((session->cookie_flags & L2TP_COOKIE_ROLLOVER_LOCAL)
+			&& (l2t->cookie == session->lcl_ro_cookie)))))
+    {
+      b->error = lm->ip6_error_node->errors[L2T_IP6_ERROR_COOKIE_MISMATCH];
+      return L2T_IP6_NEXT_DROP;
     }
 
-    vnet_buffer(b)->sw_if_index[VLIB_TX] = session->l2_output_sw_if_index;
+  vnet_buffer (b)->sw_if_index[VLIB_TX] = session->l2_output_sw_if_index;
 
-    vlib_buffer_advance (b, sizeof (*l2t));
+  vlib_buffer_advance (b, sizeof (*l2t));
 
-    /* point at currrent l2 hdr */
-    l2_payload = vlib_buffer_get_current (b);
+  /* point at currrent l2 hdr */
+  l2_payload = vlib_buffer_get_current (b);
 
-    /* $$$$ rework for speed */
+  /* $$$$ rework for speed */
 
-    /* Save type */
-    payload_ethertype = l2_payload->type;
+  /* Save type */
+  payload_ethertype = l2_payload->type;
 
-    /* Save src/dst MAC addresses */
+  /* Save src/dst MAC addresses */
 #define _(i)  dst_mac_address[i] = l2_payload->dst_address[i];
-    _(0) _(1) _(2) _(3) _(4) _(5);
+  _(0) _(1) _(2) _(3) _(4) _(5);
 #undef _
 #define _(i)  src_mac_address[i] = l2_payload->src_address[i];
-    _(0) _(1) _(2) _(3) _(4) _(5);
+  _(0) _(1) _(2) _(3) _(4) _(5);
 #undef _
 
-    /* Punch in space for 802.1q tag */
-    vlib_buffer_advance (b, -4);
-    l2_payload = vlib_buffer_get_current (b);
+  /* Punch in space for 802.1q tag */
+  vlib_buffer_advance (b, -4);
+  l2_payload = vlib_buffer_get_current (b);
 
-    /* Restore MAC addresses */
+  /* Restore MAC addresses */
 #define _(i)  l2_payload->dst_address[i] = dst_mac_address[i];
-    _(0) _(1) _(2) _(3) _(4) _(5);
+  _(0) _(1) _(2) _(3) _(4) _(5);
 #undef _
 #define _(i)  l2_payload->src_address[i] = src_mac_address[i];
-    _(0) _(1) _(2) _(3) _(4) _(5);
+  _(0) _(1) _(2) _(3) _(4) _(5);
 #undef _
-    /* Set (outer) ethertype to 802.1q vlan */
-    l2_payload->type = clib_host_to_net_u16 (0x8100);
-    vlan_header_pos = (u8 *)(l2_payload+1);
+  /* Set (outer) ethertype to 802.1q vlan */
+  l2_payload->type = clib_host_to_net_u16 (0x8100);
+  vlan_header_pos = (u8 *) (l2_payload + 1);
 #if 0
-    vlan_header_pos = session->l2_sublayer_present ? 
-        vlan_header_pos : vlan_header_pos - 4;
+  vlan_header_pos = session->l2_sublayer_present ?
+    vlan_header_pos : vlan_header_pos - 4;
 #endif
-    vh = (ethernet_vlan_header_t *)vlan_header_pos;
-    vh->priority_cfi_and_id = session->vlan_id;
-    vh->type = payload_ethertype;
-
-    if (PREDICT_FALSE(b->flags & VLIB_BUFFER_IS_TRACED)) {
-        l2t_trace_t *t = vlib_add_trace (vm, node, b, sizeof (*t));
-        t->is_user_to_network = 1;
-        t->our_address.as_u64[0] = 
-            ip6->dst_address.as_u64[0];
-        t->our_address.as_u64[1] = 
-            ip6->dst_address.as_u64[1];
-        t->client_address.as_u64[0] = 
-            ip6->src_address.as_u64[0];
-        t->client_address.as_u64[1] = 
-            ip6->src_address.as_u64[1];
-        t->session_index = vnet_buffer(b)->l2t.session_index;
-        t->vlan_id_host_byte_order = clib_net_to_host_u16 (session->vlan_id);
+  vh = (ethernet_vlan_header_t *) vlan_header_pos;
+  vh->priority_cfi_and_id = session->vlan_id;
+  vh->type = payload_ethertype;
+
+  if (PREDICT_FALSE (b->flags & VLIB_BUFFER_IS_TRACED))
+    {
+      l2t_trace_t *t = vlib_add_trace (vm, node, b, sizeof (*t));
+      t->is_user_to_network = 1;
+      t->our_address.as_u64[0] = ip6->dst_address.as_u64[0];
+      t->our_address.as_u64[1] = ip6->dst_address.as_u64[1];
+      t->client_address.as_u64[0] = ip6->src_address.as_u64[0];
+      t->client_address.as_u64[1] = ip6->src_address.as_u64[1];
+      t->session_index = vnet_buffer (b)->l2t.session_index;
+      t->vlan_id_host_byte_order = clib_net_to_host_u16 (session->vlan_id);
     }
 
-    return session->l2_output_next_index;
+  return session->l2_output_next_index;
 }
 
 #include <vnet/pipeline.h>
 
-static uword ip6_l2t_node_fn (vlib_main_t * vm,
-                              vlib_node_runtime_t * node,
-                              vlib_frame_t * frame)
+static uword
+ip6_l2t_node_fn (vlib_main_t * vm,
+		 vlib_node_runtime_t * node, vlib_frame_t * frame)
 {
-    l2t_main_t *lm = &l2t_main;
-    lm->ip6_error_node = vlib_node_get_runtime (vm, l2t_ip6_node.index);
+  l2t_main_t *lm = &l2t_main;
+  lm->ip6_error_node = vlib_node_get_runtime (vm, l2t_ip6_node.index);
 
-    return dispatch_pipeline (vm, node, frame);
+  return dispatch_pipeline (vm, node, frame);
 }
 
+/* *INDENT-OFF* */
 static VLIB_REGISTER_NODE (sw6_ip6_node) = {
   .function = ip6_l2t_node_fn,
   .name = "ip6-l2t-input",
   .vector_size = sizeof (u32),
   .format_trace = format_l2t_trace,
   .type = VLIB_NODE_TYPE_INTERNAL,
-  
+
   .n_errors = ARRAY_LEN(l2t_ip6_error_strings),
   .error_strings = l2t_ip6_error_strings,
 
@@ -269,61 +273,71 @@ static VLIB_REGISTER_NODE (sw6_ip6_node) = {
 
   /* edit / add dispositions here */
   .next_nodes = {
-        [L2T_IP6_NEXT_IP6_INPUT] = "ip6-input",
-        [L2T_IP6_NEXT_DROP] = "error-drop",
+    [L2T_IP6_NEXT_IP6_INPUT] = "ip6-input",
+    [L2T_IP6_NEXT_DROP] = "error-drop",
   },
 };
+/* *INDENT-ON* */
 
-VLIB_NODE_FUNCTION_MULTIARCH (sw6_ip6_node, ip6_l2t_node_fn)
-
+VLIB_NODE_FUNCTION_MULTIARCH (sw6_ip6_node, ip6_l2t_node_fn);
 static clib_error_t *
 l2tp_config (vlib_main_t * vm, unformat_input_t * input)
 {
-    l2t_main_t *lm = &l2t_main;
-    
-    while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
-        if (unformat (input, "lookup-v6-src"))
-            lm->lookup_type = L2T_LOOKUP_SRC_ADDRESS;
-        else if (unformat (input, "lookup-v6-dst"))
-            lm->lookup_type = L2T_LOOKUP_DST_ADDRESS;
-        else if (unformat (input, "lookup-session-id"))
-            lm->lookup_type = L2T_LOOKUP_SESSION_ID;
-        else return clib_error_return (0, "unknown input `%U'",
-                                       format_unformat_error, input);
+  l2t_main_t *lm = &l2t_main;
+
+  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (input, "lookup-v6-src"))
+	lm->lookup_type = L2T_LOOKUP_SRC_ADDRESS;
+      else if (unformat (input, "lookup-v6-dst"))
+	lm->lookup_type = L2T_LOOKUP_DST_ADDRESS;
+      else if (unformat (input, "lookup-session-id"))
+	lm->lookup_type = L2T_LOOKUP_SESSION_ID;
+      else
+	return clib_error_return (0, "unknown input `%U'",
+				  format_unformat_error, input);
     }
-    return 0;
+  return 0;
 }
 
 VLIB_CONFIG_FUNCTION (l2tp_config, "l2tp");
 
 clib_error_t *
-l2t_ip6_init (vlib_main_t *vm)
+l2t_ip6_init (vlib_main_t * vm)
 {
-    l2t_main_t *lm = &l2t_main;
-
-    lm->vnet_main = vnet_get_main();
-    lm->vlib_main = vm;
-    lm->lookup_type = L2T_LOOKUP_DST_ADDRESS;
-
-    lm->session_by_src_address = hash_create_mem 
-        (0, sizeof (ip6_address_t) /* key bytes */,
-         sizeof (u32) /* value bytes */);
-    lm->session_by_dst_address = hash_create_mem 
-        (0, sizeof (ip6_address_t) /* key bytes */,
-         sizeof (u32) /* value bytes */);
-    lm->session_by_session_id = hash_create (0, sizeof (uword));
-
-    lm->session_by_vlan_and_rx_sw_if_index = hash_create (0, sizeof (uword));
-    
+  l2t_main_t *lm = &l2t_main;
+
+  lm->vnet_main = vnet_get_main ();
+  lm->vlib_main = vm;
+  lm->lookup_type = L2T_LOOKUP_DST_ADDRESS;
+
+  lm->session_by_src_address = hash_create_mem
+    (0, sizeof (ip6_address_t) /* key bytes */ ,
+     sizeof (u32) /* value bytes */ );
+  lm->session_by_dst_address = hash_create_mem
+    (0, sizeof (ip6_address_t) /* key bytes */ ,
+     sizeof (u32) /* value bytes */ );
+  lm->session_by_session_id = hash_create (0, sizeof (uword));
+
+  lm->session_by_vlan_and_rx_sw_if_index = hash_create (0, sizeof (uword));
+
 #if DPDK == 0
-    vice_set_next_node (VICE_RX_NEXT_IP6_INPUT, "ip6-l2t-input");
-    ixgev_set_next_node (IXGEV_RX_NEXT_IP6_INPUT, "ip6-l2t-input");
-    ixge_set_next_node (IXGE_RX_NEXT_IP6_INPUT, "ip6-l2t-input");
-    ige_set_next_node (IGE_RX_NEXT_IP6_INPUT, "ip6-l2t-input");
+  vice_set_next_node (VICE_RX_NEXT_IP6_INPUT, "ip6-l2t-input");
+  ixgev_set_next_node (IXGEV_RX_NEXT_IP6_INPUT, "ip6-l2t-input");
+  ixge_set_next_node (IXGE_RX_NEXT_IP6_INPUT, "ip6-l2t-input");
+  ige_set_next_node (IGE_RX_NEXT_IP6_INPUT, "ip6-l2t-input");
 #else
-    dpdk_set_next_node (DPDK_RX_NEXT_IP6_INPUT, "ip6-l2t-input");
+  dpdk_set_next_node (DPDK_RX_NEXT_IP6_INPUT, "ip6-l2t-input");
 #endif
-    return 0;
+  return 0;
 }
 
 VLIB_INIT_FUNCTION (l2t_ip6_init);
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/vpp/app/l2t_l2.c b/vpp/app/l2t_l2.c
index f6385a5a..07d30d9a 100644
--- a/vpp/app/l2t_l2.c
+++ b/vpp/app/l2t_l2.c
@@ -32,17 +32,18 @@ l2t_main_t l2t_main;
 
 /* Statistics (not really errors) */
 #define foreach_l2t_l2_error                       \
-_(NETWORK_TO_USER, "L2 network to user (ip6) pkts")  
+_(NETWORK_TO_USER, "L2 network to user (ip6) pkts")
 
-static char * l2t_l2_error_strings[] = {
+static char *l2t_l2_error_strings[] = {
 #define _(sym,string) string,
   foreach_l2t_l2_error
 #undef _
 };
 
-typedef enum {
+typedef enum
+{
 #define _(sym,str) L2T_L2_ERROR_##sym,
-    foreach_l2t_l2_error
+  foreach_l2t_l2_error
 #undef _
     L2T_L2_N_ERROR,
 } l2t_l2_error_t;
@@ -50,193 +51,197 @@ typedef enum {
 /*
  * Packets go to ethernet-input when they don't match a mapping
  */
-typedef enum { 
-    L2T_L2_NEXT_DROP,
-    L2T_L2_NEXT_ETHERNET_INPUT,
-    L2T_L2_NEXT_IP6_LOOKUP,
-    L2T_L2_N_NEXT,
+typedef enum
+{
+  L2T_L2_NEXT_DROP,
+  L2T_L2_NEXT_ETHERNET_INPUT,
+  L2T_L2_NEXT_IP6_LOOKUP,
+  L2T_L2_N_NEXT,
 } l2t_l2_next_t;
 
 vlib_node_registration_t l2t_l2_node;
 
 #define NSTAGES 3
 
-static inline void stage0 (vlib_main_t * vm,
-                           vlib_node_runtime_t * node,
-                           u32 buffer_index)
+static inline void
+stage0 (vlib_main_t * vm, vlib_node_runtime_t * node, u32 buffer_index)
 {
-    vlib_buffer_t *b = vlib_get_buffer (vm, buffer_index);
-    vlib_prefetch_buffer_header (b, STORE);
-    CLIB_PREFETCH (b->data, 2*CLIB_CACHE_LINE_BYTES, STORE);
+  vlib_buffer_t *b = vlib_get_buffer (vm, buffer_index);
+  vlib_prefetch_buffer_header (b, STORE);
+  CLIB_PREFETCH (b->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
 }
 
-static inline void stage1 (vlib_main_t * vm,
-                           vlib_node_runtime_t * node,
-                           u32 bi)
+static inline void
+stage1 (vlib_main_t * vm, vlib_node_runtime_t * node, u32 bi)
 {
-    vlib_buffer_t *b = vlib_get_buffer (vm, bi);
-    l2t_main_t *lm = &l2t_main;
-    ethernet_header_t * eh;
-    ethernet_vlan_header_t *vh;
-    u32 session_index;
-    uword *p;
-    uword vlan_and_sw_if_index_key;
-
-    /* just in case, needed to test with the tun/tap device */
-    vlib_buffer_reset(b);
-
-    eh = vlib_buffer_get_current (b);
-
-    /* Not a VLAN pkt? send to ethernet-input... */
-    if (PREDICT_FALSE(eh->type != clib_host_to_net_u16 (0x8100))) {
-        vnet_buffer(b)->l2t.next_index = L2T_L2_NEXT_ETHERNET_INPUT;
-        return;
+  vlib_buffer_t *b = vlib_get_buffer (vm, bi);
+  l2t_main_t *lm = &l2t_main;
+  ethernet_header_t *eh;
+  ethernet_vlan_header_t *vh;
+  u32 session_index;
+  uword *p;
+  uword vlan_and_sw_if_index_key;
+
+  /* just in case, needed to test with the tun/tap device */
+  vlib_buffer_reset (b);
+
+  eh = vlib_buffer_get_current (b);
+
+  /* Not a VLAN pkt? send to ethernet-input... */
+  if (PREDICT_FALSE (eh->type != clib_host_to_net_u16 (0x8100)))
+    {
+      vnet_buffer (b)->l2t.next_index = L2T_L2_NEXT_ETHERNET_INPUT;
+      return;
     }
-    vh = (ethernet_vlan_header_t *)(eh+1);
+  vh = (ethernet_vlan_header_t *) (eh + 1);
 
-    /* look up session */
-    vlan_and_sw_if_index_key = ((uword)(vh->priority_cfi_and_id)<<32) 
-        | vnet_buffer(b)->sw_if_index[VLIB_RX];
+  /* look up session */
+  vlan_and_sw_if_index_key = ((uword) (vh->priority_cfi_and_id) << 32)
+    | vnet_buffer (b)->sw_if_index[VLIB_RX];
 
-    p = hash_get (lm->session_by_vlan_and_rx_sw_if_index, 
-                  vlan_and_sw_if_index_key);
+  p = hash_get (lm->session_by_vlan_and_rx_sw_if_index,
+		vlan_and_sw_if_index_key);
 
-    if (PREDICT_FALSE(p == 0)) {
-        /* $$$ drop here if not for our MAC? */
-        vnet_buffer(b)->l2t.next_index = L2T_L2_NEXT_ETHERNET_INPUT;
-        return;
-    } else {
-        session_index = p[0];
+  if (PREDICT_FALSE (p == 0))
+    {
+      /* $$$ drop here if not for our MAC? */
+      vnet_buffer (b)->l2t.next_index = L2T_L2_NEXT_ETHERNET_INPUT;
+      return;
+    }
+  else
+    {
+      session_index = p[0];
     }
 
-    /* Remember mapping index, prefetch the mini counter */
-    vnet_buffer(b)->l2t.next_index = L2T_L2_NEXT_IP6_LOOKUP;
-    vnet_buffer(b)->l2t.session_index = session_index;
+  /* Remember mapping index, prefetch the mini counter */
+  vnet_buffer (b)->l2t.next_index = L2T_L2_NEXT_IP6_LOOKUP;
+  vnet_buffer (b)->l2t.session_index = session_index;
 
-    /* Each mapping has 2 x (pkt, byte) counters, hence the shift */
-    CLIB_PREFETCH(lm->counter_main.mini + (p[0]<<1), CLIB_CACHE_LINE_BYTES,
-                  STORE);
+  /* Each mapping has 2 x (pkt, byte) counters, hence the shift */
+  CLIB_PREFETCH (lm->counter_main.mini + (p[0] << 1), CLIB_CACHE_LINE_BYTES,
+		 STORE);
 }
 
-static inline u32 last_stage (vlib_main_t *vm, vlib_node_runtime_t *node,
-                              u32 bi)
+static inline u32
+last_stage (vlib_main_t * vm, vlib_node_runtime_t * node, u32 bi)
 {
-    vlib_buffer_t *b = vlib_get_buffer (vm, bi);
-    l2t_main_t *lm = &l2t_main;
-    ethernet_header_t * eh = vlib_buffer_get_current (b);
-    vlib_node_t *n = vlib_get_node (vm, l2t_l2_node.index);
-    u32 node_counter_base_index = n->error_heap_index;
-    vlib_error_main_t * em = &vm->error_main;
-    l2tpv3_header_t * l2t;      /* l2 header */
-    ethernet_vlan_header_t * vh; /* 802.1q vlan header */
-    u32 counter_index;
-    l2t_session_t *s;
-    ip6_header_t *ip6;
-    u16 payload_ethertype;
-    u8 dst_mac_address[6];
-    u8 src_mac_address[6];
-    u16 payload_length;
-    i32 backup;
-    
-    /* Other-than-output pkt? We're done... */
-    if (vnet_buffer(b)->l2t.next_index != L2T_L2_NEXT_IP6_LOOKUP)
-        return vnet_buffer(b)->l2t.next_index;
-
-    vh = (ethernet_vlan_header_t *)(eh+1);
-
-    em->counters[node_counter_base_index + L2T_L2_ERROR_NETWORK_TO_USER] += 1;
-    
-    counter_index = 
-        session_index_to_counter_index (vnet_buffer(b)->l2t.session_index,
-                                        SESSION_COUNTER_NETWORK_TO_USER);
-    
-    /* per-mapping byte stats include the ethernet header */
-    vlib_increment_combined_counter (&lm->counter_main, counter_index,
-                                     1 /* packet_increment */,
-                                     vlib_buffer_length_in_chain (vm, b) +
-                                     sizeof (ethernet_header_t));
-    
-    s = pool_elt_at_index (lm->sessions, vnet_buffer(b)->l2t.session_index);
-
-    /* Save src/dst MAC addresses */
+  vlib_buffer_t *b = vlib_get_buffer (vm, bi);
+  l2t_main_t *lm = &l2t_main;
+  ethernet_header_t *eh = vlib_buffer_get_current (b);
+  vlib_node_t *n = vlib_get_node (vm, l2t_l2_node.index);
+  u32 node_counter_base_index = n->error_heap_index;
+  vlib_error_main_t *em = &vm->error_main;
+  l2tpv3_header_t *l2t;		/* l2 header */
+  ethernet_vlan_header_t *vh;	/* 802.1q vlan header */
+  u32 counter_index;
+  l2t_session_t *s;
+  ip6_header_t *ip6;
+  u16 payload_ethertype;
+  u8 dst_mac_address[6];
+  u8 src_mac_address[6];
+  u16 payload_length;
+  i32 backup;
+
+  /* Other-than-output pkt? We're done... */
+  if (vnet_buffer (b)->l2t.next_index != L2T_L2_NEXT_IP6_LOOKUP)
+    return vnet_buffer (b)->l2t.next_index;
+
+  vh = (ethernet_vlan_header_t *) (eh + 1);
+
+  em->counters[node_counter_base_index + L2T_L2_ERROR_NETWORK_TO_USER] += 1;
+
+  counter_index =
+    session_index_to_counter_index (vnet_buffer (b)->l2t.session_index,
+				    SESSION_COUNTER_NETWORK_TO_USER);
+
+  /* per-mapping byte stats include the ethernet header */
+  vlib_increment_combined_counter (&lm->counter_main, counter_index,
+				   1 /* packet_increment */ ,
+				   vlib_buffer_length_in_chain (vm, b) +
+				   sizeof (ethernet_header_t));
+
+  s = pool_elt_at_index (lm->sessions, vnet_buffer (b)->l2t.session_index);
+
+  /* Save src/dst MAC addresses */
 #define _(i)  dst_mac_address[i] = eh->dst_address[i];
-    _(0) _(1) _(2) _(3) _(4) _(5);
+  _(0) _(1) _(2) _(3) _(4) _(5);
 #undef _
 #define _(i)  src_mac_address[i] = eh->src_address[i];
-    _(0) _(1) _(2) _(3) _(4) _(5);
+  _(0) _(1) _(2) _(3) _(4) _(5);
 #undef _
-    
-    payload_ethertype = vh->type;
 
-    /* Splice out the 802.1q vlan tag */
-    vlib_buffer_advance (b, 4);
-    eh = vlib_buffer_get_current (b);
+  payload_ethertype = vh->type;
+
+  /* Splice out the 802.1q vlan tag */
+  vlib_buffer_advance (b, 4);
+  eh = vlib_buffer_get_current (b);
 
-    /* restore src/dst MAC addresses */
+  /* restore src/dst MAC addresses */
 #define _(i)   eh->dst_address[i] = dst_mac_address[i];
-    _(0) _(1) _(2) _(3) _(4) _(5);
+  _(0) _(1) _(2) _(3) _(4) _(5);
 #undef _
 #define _(i)  eh->src_address[i] = src_mac_address[i];
-    _(0) _(1) _(2) _(3) _(4) _(5);
+  _(0) _(1) _(2) _(3) _(4) _(5);
 #undef _
-    eh->type = payload_ethertype;
-    
-    /* Paint on an l2tpv3 hdr */
-    backup = sizeof(*l2t);
+  eh->type = payload_ethertype;
+
+  /* Paint on an l2tpv3 hdr */
+  backup = sizeof (*l2t);
 #if 0
-    /* back up 4 bytes less if no l2 sublayer */
-    backup -= s->l2_sublayer_present ? 0 : 4;
+  /* back up 4 bytes less if no l2 sublayer */
+  backup -= s->l2_sublayer_present ? 0 : 4;
 #endif
-    
-    vlib_buffer_advance (b, -backup);
-    l2t = vlib_buffer_get_current (b);
 
-    l2t->session_id = s->remote_session_id;
-    l2t->cookie = s->remote_cookie;
+  vlib_buffer_advance (b, -backup);
+  l2t = vlib_buffer_get_current (b);
+
+  l2t->session_id = s->remote_session_id;
+  l2t->cookie = s->remote_cookie;
 
 #if 0
-    if (s->l2_sublayer_present)
-        l2t->l2_specific_sublayer = 0;
+  if (s->l2_sublayer_present)
+    l2t->l2_specific_sublayer = 0;
 #endif
 
-    /* Paint on an ip6 header */
-    vlib_buffer_advance (b, -(sizeof (*ip6)));
-    ip6 = vlib_buffer_get_current (b);
+  /* Paint on an ip6 header */
+  vlib_buffer_advance (b, -(sizeof (*ip6)));
+  ip6 = vlib_buffer_get_current (b);
 
-    ip6->ip_version_traffic_class_and_flow_label = 
-        clib_host_to_net_u32 (0x6<<28);
+  ip6->ip_version_traffic_class_and_flow_label =
+    clib_host_to_net_u32 (0x6 << 28);
 
-    /* calculate ip6 payload length */
-    payload_length = vlib_buffer_length_in_chain (vm, b);
-    payload_length -= sizeof (*ip6);
+  /* calculate ip6 payload length */
+  payload_length = vlib_buffer_length_in_chain (vm, b);
+  payload_length -= sizeof (*ip6);
 
-    ip6->payload_length = clib_host_to_net_u16 (payload_length);
-    ip6->protocol = 0x73; /* l2tpv3 */
-    ip6->hop_limit = 0xff;
-    ip6->src_address.as_u64[0] = s->our_address.as_u64[0];
-    ip6->src_address.as_u64[1] = s->our_address.as_u64[1];
-    ip6->dst_address.as_u64[0] = s->client_address.as_u64[0];
-    ip6->dst_address.as_u64[1] = s->client_address.as_u64[1];
+  ip6->payload_length = clib_host_to_net_u16 (payload_length);
+  ip6->protocol = 0x73;		/* l2tpv3 */
+  ip6->hop_limit = 0xff;
+  ip6->src_address.as_u64[0] = s->our_address.as_u64[0];
+  ip6->src_address.as_u64[1] = s->our_address.as_u64[1];
+  ip6->dst_address.as_u64[0] = s->client_address.as_u64[0];
+  ip6->dst_address.as_u64[1] = s->client_address.as_u64[1];
 
-    return L2T_L2_NEXT_IP6_LOOKUP;
+  return L2T_L2_NEXT_IP6_LOOKUP;
 }
 
 #include <vnet/pipeline.h>
 
-static uword l2t_l2_node_fn (vlib_main_t * vm,
-                             vlib_node_runtime_t * node,
-                             vlib_frame_t * frame)
+static uword
+l2t_l2_node_fn (vlib_main_t * vm,
+		vlib_node_runtime_t * node, vlib_frame_t * frame)
 {
-    return dispatch_pipeline (vm, node, frame);
+  return dispatch_pipeline (vm, node, frame);
 }
 
+/* *INDENT-OFF* */
 VLIB_REGISTER_NODE (l2t_l2_node) = {
   .function = l2t_l2_node_fn,
   .name = "l2t-l2-input",
   .vector_size = sizeof (u32),
   .format_trace = format_l2t_trace,
   .type = VLIB_NODE_TYPE_INTERNAL,
-  
+
   .n_errors = ARRAY_LEN(l2t_l2_error_strings),
   .error_strings = l2t_l2_error_strings,
 
@@ -244,11 +249,19 @@ VLIB_REGISTER_NODE (l2t_l2_node) = {
 
   /* edit / add dispositions here */
   .next_nodes = {
-        [L2T_L2_NEXT_IP6_LOOKUP] = "ip6-lookup",
-        [L2T_L2_NEXT_ETHERNET_INPUT] = "ethernet-input",
-        [L2T_L2_NEXT_DROP] = "error-drop",
+    [L2T_L2_NEXT_IP6_LOOKUP] = "ip6-lookup",
+    [L2T_L2_NEXT_ETHERNET_INPUT] = "ethernet-input",
+    [L2T_L2_NEXT_DROP] = "error-drop",
   },
 };
+/* *INDENT-ON* */
 
-VLIB_NODE_FUNCTION_MULTIARCH (l2t_l2_node, l2t_l2_node_fn)
+VLIB_NODE_FUNCTION_MULTIARCH (l2t_l2_node, l2t_l2_node_fn);
 
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/vpp/app/sticky_hash.c b/vpp/app/sticky_hash.c
index d6d35512..05d681f4 100644
--- a/vpp/app/sticky_hash.c
+++ b/vpp/app/sticky_hash.c
@@ -23,55 +23,59 @@
 #include <vnet/ip/ip6_packet.h>
 #include <vppinfra/error.h>
 
-typedef struct {
+typedef struct
+{
   u32 fwd_entry_index;
   u32 rev_entry_index;
   /* Not strictly needed, for show command */
   u32 fib_index;
 } sticky_hash_session_t;
 
-typedef struct {
+typedef struct
+{
   u32 cached_next_index;
 
   /* next index added to l2_classify */
   u32 fwd_miss_next_index;
 
   /* session pool */
-  sticky_hash_session_t * sessions;
+  sticky_hash_session_t *sessions;
 
   /* Forward and reverse data session setup buffers */
   u8 fdata[3 * sizeof (u32x4)];
   u8 rdata[3 * sizeof (u32x4)];
 
   /* convenience variables */
-  vlib_main_t * vlib_main;
-  vnet_main_t * vnet_main;
-  vnet_classify_main_t * vnet_classify_main;
-  l2_classify_main_t * l2_classify_main;
-} sticky_hash_main_t;
-
-typedef struct {
-  /* $$$$ fill in with per-pkt trace data */ 
+  vlib_main_t *vlib_main;
+  vnet_main_t *vnet_main;
+  vnet_classify_main_t *vnet_classify_main;
+  l2_classify_main_t *l2_classify_main;
+}
+sticky_hash_main_t;
+
+typedef struct
+{
+  /* $$$$ fill in with per-pkt trace data */
   u32 next_index;
   u32 sw_if_index;
 } sticky_hash_miss_trace_t;
 
 /* packet trace format function */
-static u8 * format_sticky_hash_miss_trace (u8 * s, va_list * args)
+static u8 *
+format_sticky_hash_miss_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 *);
-  sticky_hash_miss_trace_t * t = va_arg (*args, sticky_hash_miss_trace_t *);
-  
-  s = format (s, "STICKY_HASH_MISS: sw_if_index %d",
-      t->sw_if_index);
+  sticky_hash_miss_trace_t *t = va_arg (*args, sticky_hash_miss_trace_t *);
+
+  s = format (s, "STICKY_HASH_MISS: sw_if_index %d", t->sw_if_index);
   return s;
 }
 
-typedef CLIB_PACKED(struct {
-  ethernet_header_t eh;
-  ip4_header_t ip;
-}) classify_data_or_mask_t;
+typedef CLIB_PACKED (struct
+		     {
+		     ethernet_header_t eh; ip4_header_t ip;
+		     }) classify_data_or_mask_t;
 
 sticky_hash_main_t sticky_hash_main;
 
@@ -80,22 +84,23 @@ vlib_node_registration_t sticky_hash_miss_node;
 #define foreach_sticky_hash_miss_error \
 _(MISSES, "forward flow classify misses")
 
-typedef enum {
+typedef enum
+{
 #define _(sym,str) STICKY_HASH_MISS_ERROR_##sym,
   foreach_sticky_hash_miss_error
 #undef _
-  STICKY_HASH_MISS_N_ERROR,
+    STICKY_HASH_MISS_N_ERROR,
 } sticky_hash_miss_error_t;
 
-static char * sticky_hash_miss_error_strings[] = {
+static char *sticky_hash_miss_error_strings[] = {
 #define _(sym,string) string,
   foreach_sticky_hash_miss_error
 #undef _
 };
 
-/* 
+/*
  * To drop a pkt and increment one of the previous counters:
- * 
+ *
  * set b0->error = error_node->errors[STICKY_HASH_MISS_ERROR_EXAMPLE];
  * set next0 to a disposition index bound to "error-drop".
  *
@@ -105,27 +110,27 @@ static char * sticky_hash_miss_error_strings[] = {
  *  u32 node_counter_base_index = n->error_heap_index;
  *  vlib_error_main_t * em = &vm->error_main;
  *  em->counters[node_counter_base_index + STICKY_HASH_MISS_ERROR_EXAMPLE] += 1;
- * 
+ *
  */
 
-typedef enum {
+typedef enum
+{
   STICKY_HASH_MISS_NEXT_IP4_INPUT,
   STICKY_HASH_MISS_N_NEXT,
 } sticky_hash_miss_next_t;
 
 static uword
 sticky_hash_miss_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;
   sticky_hash_miss_next_t next_index;
-  sticky_hash_main_t * mp = &sticky_hash_main;
+  sticky_hash_main_t *mp = &sticky_hash_main;
   vlib_node_t *n = vlib_get_node (vm, sticky_hash_miss_node.index);
   u32 node_counter_base_index = n->error_heap_index;
-  vlib_error_main_t * em = &vm->error_main;
-  vnet_classify_main_t * cm = mp->vnet_classify_main;
-  ip4_main_t * im = &ip4_main;
+  vlib_error_main_t *em = &vm->error_main;
+  vnet_classify_main_t *cm = mp->vnet_classify_main;
+  ip4_main_t *im = &ip4_main;
 
   from = vlib_frame_vector_args (frame);
   n_left_from = frame->n_vectors;
@@ -135,25 +140,24 @@ sticky_hash_miss_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;
-	  vlib_buffer_t * b0;
-          u32 next0;
-          u32 sw_if_index0;
-          u32 fib_index0, ft_index0, rt_index0;
-          vnet_classify_table_3_t * ft0, * rt0;
-          vnet_classify_entry_3_t * fe0, * re0;
-          classify_data_or_mask_t * h0;
-          u8 was_found0;
-          ip4_fib_t * fib0;
-          sticky_hash_session_t * s;
-          u32 tmp;
-          
-          /* speculatively enqueue b0 to the current next frame */
+	  u32 bi0;
+	  vlib_buffer_t *b0;
+	  u32 next0;
+	  u32 sw_if_index0;
+	  u32 fib_index0, ft_index0, rt_index0;
+	  vnet_classify_table_3_t *ft0, *rt0;
+	  vnet_classify_entry_3_t *fe0, *re0;
+	  classify_data_or_mask_t *h0;
+	  u8 was_found0;
+	  ip4_fib_t *fib0;
+	  sticky_hash_session_t *s;
+	  u32 tmp;
+
+	  /* speculatively enqueue b0 to the current next frame */
 	  bi0 = from[0];
 	  to_next[0] = bi0;
 	  from += 1;
@@ -163,69 +167,71 @@ sticky_hash_miss_node_fn (vlib_main_t * vm,
 
 	  b0 = vlib_get_buffer (vm, bi0);
 
-          sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX];
-          next0 = mp->cached_next_index;
-
-          h0 = vlib_buffer_get_current (b0);
-
-          /* Add forward and reverse entries for this flow */
-          clib_memcpy (mp->fdata, h0, sizeof (mp->fdata));
-          clib_memcpy (mp->rdata, h0, sizeof (mp->rdata));
-
-          h0 = (classify_data_or_mask_t *)(mp->rdata);
-
-          /* swap src + dst addresses to form reverse data */
-          tmp = h0->ip.src_address.as_u32;
-          h0->ip.src_address.as_u32 = h0->ip.dst_address.as_u32;
-          h0->ip.dst_address.as_u32 = tmp;
-
-          /* dig up fwd + rev tables */
-          fib_index0 = vec_elt (im->fib_index_by_sw_if_index, sw_if_index0);
-          fib0 = vec_elt_at_index (im->fibs, fib_index0);  
-
-          ft_index0 = fib0->fwd_classify_table_index;
-          rt_index0 = fib0->rev_classify_table_index;
-          
-          ft0 = (vnet_classify_table_3_t *)
-              pool_elt_at_index (cm->tables, ft_index0);
-          rt0 = (vnet_classify_table_3_t *)
-              pool_elt_at_index (cm->tables, rt_index0);
-
-          fe0 = vnet_classify_find_or_add_entry_3 (ft0, mp->fdata, &was_found0);
-          fe0->next_index = L2_CLASSIFY_NEXT_IP4_INPUT;
-          fe0->advance = sizeof (ethernet_header_t);
-          
-          re0 = vnet_classify_find_or_add_entry_3 (rt0, mp->rdata, 0);
-          re0->next_index = L2_CLASSIFY_NEXT_IP4_INPUT; /* $$$ FIXME */
-          re0->advance = sizeof (ethernet_header_t);
-
-          /* Note: we could get a whole vector of misses for the same sess */
-          if (was_found0 == 0)
-            {
-              pool_get (mp->sessions, s);
-              
-              fe0->opaque_index = s - mp->sessions;
-              re0->opaque_index = s - mp->sessions;
-              
-              s->fwd_entry_index = fe0 - ft0->entries;
-              s->rev_entry_index = re0 - rt0->entries;
-              s->fib_index = fib_index0;
-            }
-
-          if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) 
-                            && (b0->flags & VLIB_BUFFER_IS_TRACED))) {
-            sticky_hash_miss_trace_t *t = 
-               vlib_add_trace (vm, node, b0, sizeof (*t));
-            t->sw_if_index = sw_if_index0;
-            t->next_index = next0;
-            }
-            
-          em->counters[node_counter_base_index + STICKY_HASH_MISS_ERROR_MISSES]
-            += 1;
-
-          vlib_buffer_advance (b0, sizeof (ethernet_header_t));
-
-          /* verify speculative enqueue, maybe switch current next frame */
+	  sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
+	  next0 = mp->cached_next_index;
+
+	  h0 = vlib_buffer_get_current (b0);
+
+	  /* Add forward and reverse entries for this flow */
+	  clib_memcpy (mp->fdata, h0, sizeof (mp->fdata));
+	  clib_memcpy (mp->rdata, h0, sizeof (mp->rdata));
+
+	  h0 = (classify_data_or_mask_t *) (mp->rdata);
+
+	  /* swap src + dst addresses to form reverse data */
+	  tmp = h0->ip.src_address.as_u32;
+	  h0->ip.src_address.as_u32 = h0->ip.dst_address.as_u32;
+	  h0->ip.dst_address.as_u32 = tmp;
+
+	  /* dig up fwd + rev tables */
+	  fib_index0 = vec_elt (im->fib_index_by_sw_if_index, sw_if_index0);
+	  fib0 = vec_elt_at_index (im->fibs, fib_index0);
+
+	  ft_index0 = fib0->fwd_classify_table_index;
+	  rt_index0 = fib0->rev_classify_table_index;
+
+	  ft0 = (vnet_classify_table_3_t *)
+	    pool_elt_at_index (cm->tables, ft_index0);
+	  rt0 = (vnet_classify_table_3_t *)
+	    pool_elt_at_index (cm->tables, rt_index0);
+
+	  fe0 =
+	    vnet_classify_find_or_add_entry_3 (ft0, mp->fdata, &was_found0);
+	  fe0->next_index = L2_CLASSIFY_NEXT_IP4_INPUT;
+	  fe0->advance = sizeof (ethernet_header_t);
+
+	  re0 = vnet_classify_find_or_add_entry_3 (rt0, mp->rdata, 0);
+	  re0->next_index = L2_CLASSIFY_NEXT_IP4_INPUT;	/* $$$ FIXME */
+	  re0->advance = sizeof (ethernet_header_t);
+
+	  /* Note: we could get a whole vector of misses for the same sess */
+	  if (was_found0 == 0)
+	    {
+	      pool_get (mp->sessions, s);
+
+	      fe0->opaque_index = s - mp->sessions;
+	      re0->opaque_index = s - mp->sessions;
+
+	      s->fwd_entry_index = fe0 - ft0->entries;
+	      s->rev_entry_index = re0 - rt0->entries;
+	      s->fib_index = fib_index0;
+	    }
+
+	  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
+			     && (b0->flags & VLIB_BUFFER_IS_TRACED)))
+	    {
+	      sticky_hash_miss_trace_t *t =
+		vlib_add_trace (vm, node, b0, sizeof (*t));
+	      t->sw_if_index = sw_if_index0;
+	      t->next_index = next0;
+	    }
+
+	  em->counters[node_counter_base_index +
+		       STICKY_HASH_MISS_ERROR_MISSES] += 1;
+
+	  vlib_buffer_advance (b0, sizeof (ethernet_header_t));
+
+	  /* verify speculative enqueue, maybe switch current next frame */
 	  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 					   to_next, n_left_to_next,
 					   bi0, next0);
@@ -237,13 +243,14 @@ sticky_hash_miss_node_fn (vlib_main_t * vm,
   return frame->n_vectors;
 }
 
+/* *INDENT-OFF* */
 VLIB_REGISTER_NODE (sticky_hash_miss_node) = {
   .function = sticky_hash_miss_node_fn,
   .name = "sticky-hash-miss",
   .vector_size = sizeof (u32),
   .format_trace = format_sticky_hash_miss_trace,
   .type = VLIB_NODE_TYPE_INTERNAL,
-  
+
   .n_errors = ARRAY_LEN(sticky_hash_miss_error_strings),
   .error_strings = sticky_hash_miss_error_strings,
 
@@ -251,16 +258,18 @@ VLIB_REGISTER_NODE (sticky_hash_miss_node) = {
 
   /* edit / add dispositions here */
   .next_nodes = {
-        [STICKY_HASH_MISS_NEXT_IP4_INPUT] = "ip4-input",
+    [STICKY_HASH_MISS_NEXT_IP4_INPUT] = "ip4-input",
   },
 };
+/* *INDENT-ON* */
 
-clib_error_t *sticky_hash_miss_init (vlib_main_t *vm)
+clib_error_t *
+sticky_hash_miss_init (vlib_main_t * vm)
 {
-  sticky_hash_main_t * mp = &sticky_hash_main;
-    
+  sticky_hash_main_t *mp = &sticky_hash_main;
+
   mp->vlib_main = vm;
-  mp->vnet_main = vnet_get_main();
+  mp->vnet_main = vnet_get_main ();
   mp->vnet_classify_main = &vnet_classify_main;
   mp->l2_classify_main = &l2_classify_main;
 
@@ -269,87 +278,86 @@ clib_error_t *sticky_hash_miss_init (vlib_main_t *vm)
 
 VLIB_INIT_FUNCTION (sticky_hash_miss_init);
 
-static int ip4_sticky_hash_enable_disable 
-(sticky_hash_main_t * mp,
- u32 fwd_sw_if_index, u8 * fwd_mask, 
- u32 rev_sw_if_index, u8 * rev_mask, 
- u32 nbuckets, int enable_disable)
+static int ip4_sticky_hash_enable_disable
+  (sticky_hash_main_t * mp,
+   u32 fwd_sw_if_index, u8 * fwd_mask,
+   u32 rev_sw_if_index, u8 * rev_mask, u32 nbuckets, int enable_disable)
 {
-  ip4_main_t * im = &ip4_main;
+  ip4_main_t *im = &ip4_main;
   u32 fib_index;
-  ip4_fib_t * fib;
-  vnet_classify_main_t * cm = mp->vnet_classify_main;
-  l2_classify_main_t * l2cm = mp->l2_classify_main;
-  vnet_classify_table_3_t * ft, * rt;
-  
+  ip4_fib_t *fib;
+  vnet_classify_main_t *cm = mp->vnet_classify_main;
+  l2_classify_main_t *l2cm = mp->l2_classify_main;
+  vnet_classify_table_3_t *ft, *rt;
+
   fib_index = vec_elt (im->fib_index_by_sw_if_index, fwd_sw_if_index);
-  fib = vec_elt_at_index (im->fibs, fib_index);  
-  
+  fib = vec_elt_at_index (im->fibs, fib_index);
+
   if (fib->fwd_classify_table_index == ~0)
     {
       /* Set up forward table */
-      ft = (vnet_classify_table_3_t *) 
-        vnet_classify_new_table (cm, fwd_mask, nbuckets, 
-                                 0 /* skip */, 3 /* match */);
-      fib->fwd_classify_table_index 
-        = ft - (vnet_classify_table_3_t *) cm->tables;
-      mp->fwd_miss_next_index = 
-        vlib_node_add_next (mp->vlib_main, l2_classify_node.index,
-                            sticky_hash_miss_node.index);
+      ft = (vnet_classify_table_3_t *)
+	vnet_classify_new_table (cm, fwd_mask, nbuckets,
+				 0 /* skip */ , 3 /* match */ );
+      fib->fwd_classify_table_index
+	= ft - (vnet_classify_table_3_t *) cm->tables;
+      mp->fwd_miss_next_index =
+	vlib_node_add_next (mp->vlib_main, l2_classify_node.index,
+			    sticky_hash_miss_node.index);
       ft->miss_next_index = mp->fwd_miss_next_index;
 
       /* Set up reverse table */
-      rt = (vnet_classify_table_3_t *) 
-        vnet_classify_new_table (cm, rev_mask, nbuckets,
-                                 0 /* skip */, 3 /* match */);
-      fib->rev_classify_table_index 
-        = rt - (vnet_classify_table_3_t *) cm->tables;
+      rt = (vnet_classify_table_3_t *)
+	vnet_classify_new_table (cm, rev_mask, nbuckets,
+				 0 /* skip */ , 3 /* match */ );
+      fib->rev_classify_table_index
+	= rt - (vnet_classify_table_3_t *) cm->tables;
     }
 
-  vec_validate 
-    (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4], 
+  vec_validate
+    (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4],
      fwd_sw_if_index);
-  
-  vec_validate 
-    (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6], 
+
+  vec_validate
+    (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6],
      fwd_sw_if_index);
-  
-  vec_validate 
-    (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER], 
+
+  vec_validate
+    (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER],
      fwd_sw_if_index);
-  
+
   l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4]
     [fwd_sw_if_index] = fib->fwd_classify_table_index;
 
   l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6]
     [fwd_sw_if_index] = ~0;
-  
+
   l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER]
     [fwd_sw_if_index] = ~0;
-  
 
-  vec_validate 
-    (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4], 
+
+  vec_validate
+    (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4],
      rev_sw_if_index);
-  
-  vec_validate 
-    (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6], 
+
+  vec_validate
+    (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6],
      rev_sw_if_index);
-  
-  vec_validate 
-    (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER], 
+
+  vec_validate
+    (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER],
      rev_sw_if_index);
 
-  
+
   l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4]
     [rev_sw_if_index] = fib->rev_classify_table_index;
-  
+
   l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6]
     [rev_sw_if_index] = ~0;
-  
+
   l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER]
     [rev_sw_if_index] = ~0;
-  
+
   vnet_l2_classify_enable_disable (fwd_sw_if_index, enable_disable);
   vnet_l2_classify_enable_disable (rev_sw_if_index, enable_disable);
   return 0;
@@ -357,33 +365,37 @@ static int ip4_sticky_hash_enable_disable
 
 static clib_error_t *
 ip4_sticky_hash_init_command_fn (vlib_main_t * vm,
-                                 unformat_input_t * input,
-                                 vlib_cli_command_t * cmd)
+				 unformat_input_t * input,
+				 vlib_cli_command_t * cmd)
 {
   u32 fwd_sw_if_index = ~0, rev_sw_if_index = ~0;
   int enable_disable = 1;
   u32 nbuckets = 2;
   int rv;
-  sticky_hash_main_t * mp = &sticky_hash_main;
+  sticky_hash_main_t *mp = &sticky_hash_main;
   classify_data_or_mask_t fwd_mask, rev_mask;
-  u8 * fm = 0, * rm = 0;
-  
-  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
-    if (unformat (input, "fwd %U", unformat_vnet_sw_interface, mp->vnet_main,
-                  &fwd_sw_if_index))
-      ;
-    if (unformat (input, "rev %U", unformat_vnet_sw_interface, mp->vnet_main,
-                  &rev_sw_if_index))
-      ;
-    else if (unformat (input, "nbuckets %d", &nbuckets))
-      ;
-    else if (unformat (input, "disable"))
-      enable_disable = 0;
-
-    else break;
-  }
+  u8 *fm = 0, *rm = 0;
+
+  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat
+	  (input, "fwd %U", unformat_vnet_sw_interface, mp->vnet_main,
+	   &fwd_sw_if_index))
+	;
+      if (unformat
+	  (input, "rev %U", unformat_vnet_sw_interface, mp->vnet_main,
+	   &rev_sw_if_index))
+	;
+      else if (unformat (input, "nbuckets %d", &nbuckets))
+	;
+      else if (unformat (input, "disable"))
+	enable_disable = 0;
+
+      else
+	break;
+    }
 
-  nbuckets = 1<<max_log2(nbuckets);
+  nbuckets = 1 << max_log2 (nbuckets);
 
   if (fwd_sw_if_index == ~0)
     return clib_error_return (0, "fwd interface not set");
@@ -391,27 +403,27 @@ ip4_sticky_hash_init_command_fn (vlib_main_t * vm,
   if (rev_sw_if_index == ~0)
     return clib_error_return (0, "rev interface not set");
 
-  if (!is_pow2(nbuckets))
+  if (!is_pow2 (nbuckets))
     return clib_error_return (0, "nbuckets %d not a power of 2", nbuckets);
-  
-  ASSERT(sizeof(fwd_mask) <= 3 * sizeof (u32x4));
+
+  ASSERT (sizeof (fwd_mask) <= 3 * sizeof (u32x4));
 
   /* Mask on src/dst address, depending on direction */
-  memset(&fwd_mask, 0, sizeof (fwd_mask));
+  memset (&fwd_mask, 0, sizeof (fwd_mask));
   memset (&fwd_mask.ip.src_address, 0xff, 4);
 
-  memset(&rev_mask, 0, sizeof (rev_mask));
+  memset (&rev_mask, 0, sizeof (rev_mask));
   memset (&rev_mask.ip.dst_address, 0xff, 4);
 
-  vec_validate (fm, 3 * sizeof(u32x4) - 1);
-  vec_validate (rm, 3 * sizeof(u32x4) - 1);
+  vec_validate (fm, 3 * sizeof (u32x4) - 1);
+  vec_validate (rm, 3 * sizeof (u32x4) - 1);
 
   clib_memcpy (fm, &fwd_mask, sizeof (fwd_mask));
   clib_memcpy (rm, &rev_mask, sizeof (rev_mask));
-  
-  rv = ip4_sticky_hash_enable_disable (mp, fwd_sw_if_index, fm, 
-                                       rev_sw_if_index, rm,
-                                       nbuckets, enable_disable);
+
+  rv = ip4_sticky_hash_enable_disable (mp, fwd_sw_if_index, fm,
+				       rev_sw_if_index, rm,
+				       nbuckets, enable_disable);
 
   vec_free (fm);
   vec_free (rm);
@@ -421,63 +433,66 @@ ip4_sticky_hash_init_command_fn (vlib_main_t * vm,
       return 0;
 
     default:
-      return clib_error_return (0, "ip4_sticky_hash_enable_disable returned %d",
-                                rv);
+      return clib_error_return (0,
+				"ip4_sticky_hash_enable_disable returned %d",
+				rv);
     }
 
   return 0;
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (sticky_hash_init_command, static) = {
-    .path = "ip sticky classify",
-    .short_help = "ip sticky classify fwd <intfc> rev <intfc> " 
-    "[nbuckets <nn>][disable]",
-    .function = ip4_sticky_hash_init_command_fn,
+  .path = "ip sticky classify",
+  .short_help = "ip sticky classify fwd <intfc> rev <intfc> "
+  "[nbuckets <nn>][disable]",
+  .function = ip4_sticky_hash_init_command_fn,
 };
+/* *INDENT-ON* */
 
 
-u8 * format_sticky_hash_session (u8 * s, va_list * args)
+u8 *
+format_sticky_hash_session (u8 * s, va_list * args)
 {
-  sticky_hash_main_t * mp = va_arg(*args, sticky_hash_main_t *);
-  sticky_hash_session_t * session = va_arg(*args, sticky_hash_session_t *);
-  vnet_classify_table_3_t * t;
-  vnet_classify_entry_3_t * e;
-  ip4_main_t * im = &ip4_main;
-  vnet_classify_main_t * cm = mp->vnet_classify_main;
-  ip4_fib_t * fib;
-  classify_data_or_mask_t * match;
+  sticky_hash_main_t *mp = va_arg (*args, sticky_hash_main_t *);
+  sticky_hash_session_t *session = va_arg (*args, sticky_hash_session_t *);
+  vnet_classify_table_3_t *t;
+  vnet_classify_entry_3_t *e;
+  ip4_main_t *im = &ip4_main;
+  vnet_classify_main_t *cm = mp->vnet_classify_main;
+  ip4_fib_t *fib;
+  classify_data_or_mask_t *match;
 
   fib = vec_elt_at_index (im->fibs, session->fib_index);
 
-  t = (vnet_classify_table_3_t *) 
+  t = (vnet_classify_table_3_t *)
     pool_elt_at_index (cm->tables, fib->fwd_classify_table_index);
   e = pool_elt_at_index (t->entries, session->fwd_entry_index);
-  match = (classify_data_or_mask_t *)(e->key);
-
-  s = format 
-      (s, 
-       "[%6d] fwd src %U next index %d session %d fib %d\n"
-       "         hits %lld last-heard %.6f\n",
-       e - t->entries, 
-       format_ip4_address, &match->ip.src_address,
-       e->next_index, e->opaque_index, fib->table_id,
-       e->hits, e->last_heard);
-  
+  match = (classify_data_or_mask_t *) (e->key);
+
+  s = format
+    (s,
+     "[%6d] fwd src %U next index %d session %d fib %d\n"
+     "         hits %lld last-heard %.6f\n",
+     e - t->entries,
+     format_ip4_address, &match->ip.src_address,
+     e->next_index, e->opaque_index, fib->table_id, e->hits, e->last_heard);
+
   if (e->opaque_index != session - mp->sessions)
     s = format (s, "WARNING: forward session index mismatch!\n");
 
   t = (vnet_classify_table_3_t *)
     pool_elt_at_index (cm->tables, fib->rev_classify_table_index);
   e = pool_elt_at_index (t->entries, session->rev_entry_index);
-  match = (classify_data_or_mask_t *)(e->key);
-  
-  s = format 
-      (s, 
-       "[%6d] rev dst %U next index %d session %d\n"
-       "         hits %lld last-heard %.6f\n",
-       e - t->entries, 
-       format_ip4_address, &match->ip.dst_address,
-       e->next_index, e->opaque_index, e->hits, e->last_heard);
+  match = (classify_data_or_mask_t *) (e->key);
+
+  s = format
+    (s,
+     "[%6d] rev dst %U next index %d session %d\n"
+     "         hits %lld last-heard %.6f\n",
+     e - t->entries,
+     format_ip4_address, &match->ip.dst_address,
+     e->next_index, e->opaque_index, e->hits, e->last_heard);
 
   if (e->opaque_index != session - mp->sessions)
     s = format (s, "WARNING: reverse session index mismatch!\n");
@@ -488,67 +503,79 @@ u8 * format_sticky_hash_session (u8 * s, va_list * args)
 
 static clib_error_t *
 show_ip4_sticky_hash_command_fn (vlib_main_t * vm,
-                                 unformat_input_t * input,
-                                 vlib_cli_command_t * cmd)
+				 unformat_input_t * input,
+				 vlib_cli_command_t * cmd)
 {
-  sticky_hash_main_t * mp = &sticky_hash_main;
-  sticky_hash_session_t * s;
+  sticky_hash_main_t *mp = &sticky_hash_main;
+  sticky_hash_session_t *s;
   int verbose = 0;
   int dump_classifier_tables = 0;
-  ip4_fib_t * fib;
-  ip4_main_t * im4 = &ip4_main;
-  vnet_classify_main_t * cm = mp->vnet_classify_main;
-  
-  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
-    if (unformat (input, "verbose"))
-      verbose = 1;
-    else if (unformat (input, "dump-tables")
-             || unformat (input, "dump-classifier-tables"))
-      dump_classifier_tables = 1;
-    else
-      break;
-  }
+  ip4_fib_t *fib;
+  ip4_main_t *im4 = &ip4_main;
+  vnet_classify_main_t *cm = mp->vnet_classify_main;
+
+  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (input, "verbose"))
+	verbose = 1;
+      else if (unformat (input, "dump-tables")
+	       || unformat (input, "dump-classifier-tables"))
+	dump_classifier_tables = 1;
+      else
+	break;
+    }
 
   if (pool_elts (mp->sessions) == 0)
     vlib_cli_output (vm, "No ip sticky hash sessions");
-  
 
-  vlib_cli_output (vm, "%d active sessions\n",
-                   pool_elts (mp->sessions));
+
+  vlib_cli_output (vm, "%d active sessions\n", pool_elts (mp->sessions));
 
   vec_foreach (fib, im4->fibs)
-    {
-      if (fib->fwd_classify_table_index != ~0)
-          vlib_cli_output (vm, "fib %d fwd table: \n%U", 
-                           fib->table_id, 
-                           format_classify_table, 
-                           cm,
-                           pool_elt_at_index 
-                           (cm->tables, fib->fwd_classify_table_index),
-                           dump_classifier_tables);
-      if (fib->rev_classify_table_index != ~0)
-          vlib_cli_output (vm, "fib %d rev table: \n%U", 
-                           fib->table_id, 
-                           format_classify_table, 
-                           cm,
-                           pool_elt_at_index 
-                           (cm->tables, fib->rev_classify_table_index),
-                           dump_classifier_tables);
-    }
+  {
+    if (fib->fwd_classify_table_index != ~0)
+      vlib_cli_output (vm, "fib %d fwd table: \n%U",
+		       fib->table_id,
+		       format_classify_table,
+		       cm,
+		       pool_elt_at_index
+		       (cm->tables, fib->fwd_classify_table_index),
+		       dump_classifier_tables);
+    if (fib->rev_classify_table_index != ~0)
+      vlib_cli_output (vm, "fib %d rev table: \n%U",
+		       fib->table_id,
+		       format_classify_table,
+		       cm,
+		       pool_elt_at_index
+		       (cm->tables, fib->rev_classify_table_index),
+		       dump_classifier_tables);
+  }
 
   if (verbose)
     {
-      pool_foreach (s, mp->sessions, 
+      /* *INDENT-OFF* */
+      pool_foreach (s, mp->sessions,
       ({
         vlib_cli_output (vm, "%U", format_sticky_hash_session, mp, s);
       }));
+      /* *INDENT-ON* */
     }
   return 0;
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (show_sticky_hash_command, static) = {
-    .path = "show sticky classify",
-    .short_help = "Display sticky classifier tables", 
-    .function = show_ip4_sticky_hash_command_fn,
+  .path = "show sticky classify",
+  .short_help = "Display sticky classifier tables",
+  .function = show_ip4_sticky_hash_command_fn,
 };
+/* *INDENT-ON* */
 
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/vpp/app/version.c b/vpp/app/version.c
index 9a278d02..cf442df3 100644
--- a/vpp/app/version.c
+++ b/vpp/app/version.c
@@ -22,31 +22,29 @@
 #include <vnet/devices/dpdk/dpdk.h>
 #endif /* DPDK */
 
-static char * vpe_version_string = 
-    "vpp v" VPP_BUILD_VER 
-    " built by " VPP_BUILD_USER 
-    " on " VPP_BUILD_HOST 
-    " at " VPP_BUILD_DATE;
+static char *vpe_version_string =
+  "vpp v" VPP_BUILD_VER
+  " built by " VPP_BUILD_USER " on " VPP_BUILD_HOST " at " VPP_BUILD_DATE;
 
-static char * vpe_compiler =
+static char *vpe_compiler =
 #if defined(__INTEL_COMPILER)
 #define __(x) #x
 #define _(x) __(x)
-	"icc " _(__INTEL_COMPILER) " (" __VERSION__ ")";
+  "icc " _(__INTEL_COMPILER) " (" __VERSION__ ")";
 #undef _
 #undef __
 #elif defined(__clang__)
-	"Clang/LLVM " __clang_version__;
+  "Clang/LLVM " __clang_version__;
 #elif defined (__GNUC__)
-	"GCC " __VERSION__;
+  "GCC " __VERSION__;
 #else
-	"unknown compiler";
+  "unknown compiler";
 #endif
 
 static clib_error_t *
 show_vpe_version_command_fn (vlib_main_t * vm,
-		 unformat_input_t * input,
-		 vlib_cli_command_t * cmd)
+			     unformat_input_t * input,
+			     vlib_cli_command_t * cmd)
 {
   if (unformat (input, "verbose"))
     {
@@ -60,9 +58,9 @@ show_vpe_version_command_fn (vlib_main_t * vm,
       _("CPU model name", "%U", format_cpu_model_name);
       _("CPU microarchitecture", "%U", format_cpu_uarch);
       _("CPU flags", "%U", format_cpu_flags);
-      _("Current PID", "%d", getpid());
+      _("Current PID", "%d", getpid ());
 #if DPDK > 0
-      _("DPDK Version", "%s", rte_version());
+      _("DPDK Version", "%s", rte_version ());
       _("DPDK EAL init args", "%s", dpdk_config_main.eal_init_args_str);
 #endif
 #undef _
@@ -72,22 +70,36 @@ show_vpe_version_command_fn (vlib_main_t * vm,
   return 0;
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (show_vpe_version_command, static) = {
   .path = "show version",
   .short_help = "show version information",
   .function = show_vpe_version_command_fn,
 };
+/* *INDENT-ON* */
 
-char * vpe_api_get_build_directory (void) 
+char *
+vpe_api_get_build_directory (void)
 {
   return VPP_BUILD_TOPDIR;
 }
 
-char * vpe_api_get_version (void) 
+char *
+vpe_api_get_version (void)
 {
   return VPP_BUILD_VER;
 }
-char * vpe_api_get_build_date (void) 
+
+char *
+vpe_api_get_build_date (void)
 {
   return VPP_BUILD_DATE;
 }
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/vpp/app/vpe_cli.c b/vpp/app/vpe_cli.c
index b9f717bd..b9f79688 100644
--- a/vpp/app/vpe_cli.c
+++ b/vpp/app/vpe_cli.c
@@ -15,92 +15,98 @@
 #include <vnet/ip/ip.h>
 #include <vnet/ethernet/ethernet.h>
 
-typedef struct {
-    u8 mac_addr[6];
+typedef struct
+{
+  u8 mac_addr[6];
 } mac_addr_t;
 
 static clib_error_t *
 virtual_ip_cmd_fn_command_fn (vlib_main_t * vm,
-		 unformat_input_t * input,
-		 vlib_cli_command_t * cmd)
+			      unformat_input_t * input,
+			      vlib_cli_command_t * cmd)
 {
-    unformat_input_t _line_input, * line_input = &_line_input;
-    vnet_main_t * vnm = vnet_get_main();
-    ip4_main_t * im = &ip4_main;
-    ip_lookup_main_t * lm = &im->lookup_main;
-    ip4_address_t ip_addr, next_hop;
-    u8 mac_addr[6];
-    mac_addr_t *mac_addrs = 0;
-    u32 sw_if_index;
-    u32 i, f;
+  unformat_input_t _line_input, *line_input = &_line_input;
+  vnet_main_t *vnm = vnet_get_main ();
+  ip4_main_t *im = &ip4_main;
+  ip_lookup_main_t *lm = &im->lookup_main;
+  ip4_address_t ip_addr, next_hop;
+  u8 mac_addr[6];
+  mac_addr_t *mac_addrs = 0;
+  u32 sw_if_index;
+  u32 i, f;
 
-    /* Get a line of input. */
-    if (! unformat_user (input, unformat_line_input, line_input))
-        return 0;
+  /* Get a line of input. */
+  if (!unformat_user (input, unformat_line_input, line_input))
+    return 0;
 
-    if (!unformat(line_input, "%U %U", 
-                  unformat_ip4_address, &ip_addr,
-                  unformat_vnet_sw_interface, vnm, &sw_if_index))
-        goto barf;
+  if (!unformat (line_input, "%U %U",
+		 unformat_ip4_address, &ip_addr,
+		 unformat_vnet_sw_interface, vnm, &sw_if_index))
+    goto barf;
 
-    while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
-	if (unformat (line_input, "mac %U", 
-                      unformat_ethernet_address, 
-                      &mac_addr))
-        {
-            mac_addr_t *ma;
-            vec_add2 (mac_addrs, ma, 1);
-            clib_memcpy(ma, mac_addr, sizeof (mac_addr));
-        } else {
-        barf:
-	    return clib_error_return (0, "unknown input `%U'",
-				      format_unformat_error, input);
-        }
+  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (line_input, "mac %U",
+		    unformat_ethernet_address, &mac_addr))
+	{
+	  mac_addr_t *ma;
+	  vec_add2 (mac_addrs, ma, 1);
+	  clib_memcpy (ma, mac_addr, sizeof (mac_addr));
+	}
+      else
+	{
+	barf:
+	  return clib_error_return (0, "unknown input `%U'",
+				    format_unformat_error, input);
+	}
     }
-    if (vec_len (mac_addrs) == 0)
-        goto barf;
+  if (vec_len (mac_addrs) == 0)
+    goto barf;
+
+  /* Create / delete special interface route /32's */
+  next_hop.as_u32 = 0;
+
+  for (i = 0; i < vec_len (mac_addrs); i++)
+    {
+      ip_adjacency_t adj;
+      u32 adj_index;
+
+      memset (&adj, 0, sizeof (adj));
+      adj.lookup_next_index = IP_LOOKUP_NEXT_REWRITE;
 
-    /* Create / delete special interface route /32's */
-    next_hop.as_u32 = 0;
+      vnet_rewrite_for_sw_interface (vnm, VNET_L3_PACKET_TYPE_IP4, sw_if_index, ip4_rewrite_node.index, &mac_addrs[i],	/* destination address */
+				     &adj.rewrite_header,
+				     sizeof (adj.rewrite_data));
 
-    for (i = 0; i < vec_len(mac_addrs); i++) {
-        ip_adjacency_t adj;
-        u32 adj_index;
-        
-        memset(&adj, 0, sizeof(adj));
-        adj.lookup_next_index = IP_LOOKUP_NEXT_REWRITE;
-        
-        vnet_rewrite_for_sw_interface
-            (vnm,
-             VNET_L3_PACKET_TYPE_IP4,
-             sw_if_index,
-             ip4_rewrite_node.index,
-             &mac_addrs[i],     /* destination address */
-             &adj.rewrite_header,
-             sizeof (adj.rewrite_data));
+      ip_add_adjacency (lm, &adj, 1 /* one adj */ ,
+			&adj_index);
 
-        ip_add_adjacency (lm, &adj, 1 /* one adj */,
-                          &adj_index);
-        
-        f = (i + 1 < vec_len(mac_addrs)) ? IP4_ROUTE_FLAG_NOT_LAST_IN_GROUP : 0;
-        ip4_add_del_route_next_hop (im,
-                                    IP4_ROUTE_FLAG_ADD | f,
-                                    &ip_addr,
-                                    32 /* insert /32's */,
-                                    &next_hop,
-                                    sw_if_index,
-                                    1 /* weight */, 
-                                    adj_index, 
-                                    (u32)~0 /* explicit fib index */);
+      f =
+	(i + 1 < vec_len (mac_addrs)) ? IP4_ROUTE_FLAG_NOT_LAST_IN_GROUP : 0;
+      ip4_add_del_route_next_hop (im, IP4_ROUTE_FLAG_ADD | f, &ip_addr,
+				  32 /* insert /32's */ ,
+				  &next_hop, sw_if_index, 1 /* weight */ ,
+				  adj_index,
+				  (u32) ~ 0 /* explicit fib index */ );
     }
 
-    vec_free (mac_addrs);
+  vec_free (mac_addrs);
 
-    return 0;
+  return 0;
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (virtual_ip_cmd_fn_command, static) = {
-    .path = "ip virtual",
-    .short_help = "ip virtual <addr> <interface> [mac <Mi>]+",
-    .function = virtual_ip_cmd_fn_command_fn,
+  .path = "ip virtual",
+  .short_help = "ip virtual <addr> <interface> [mac <Mi>]+",
+  .function = virtual_ip_cmd_fn_command_fn,
 };
+/* *INDENT-ON* */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */