fd-io-styleify pass

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

3 files changed, 1361 insertions, 1182 deletions

diff --git a/vlib-api/vlibapi/api.h b/vlib-api/vlibapi/api.h
index 3c4b68dc006..9d885c17930 100644
--- a/vlib-api/vlibapi/api.h
+++ b/vlib-api/vlibapi/api.h
@@ -1,7 +1,7 @@
 /*
  *------------------------------------------------------------------
  * api.h
- * 
+ *
  * Copyright (c) 2009-2015 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,205 +26,221 @@
 #include <vlibmemory/unix_shared_memory_queue.h>
 #include <vlib/unix/unix.h>
 
-typedef enum {
-    REGISTRATION_TYPE_FREE=0,
-    REGISTRATION_TYPE_SHMEM,
-    REGISTRATION_TYPE_SOCKET_LISTEN,
-    REGISTRATION_TYPE_SOCKET_SERVER,
-    REGISTRATION_TYPE_SOCKET_CLIENT,
+typedef enum
+{
+  REGISTRATION_TYPE_FREE = 0,
+  REGISTRATION_TYPE_SHMEM,
+  REGISTRATION_TYPE_SOCKET_LISTEN,
+  REGISTRATION_TYPE_SOCKET_SERVER,
+  REGISTRATION_TYPE_SOCKET_CLIENT,
 } vl_registration_type_t;
 
-typedef struct vl_api_registration_ {
-    vl_registration_type_t registration_type;
+typedef struct vl_api_registration_
+{
+  vl_registration_type_t registration_type;
+
+  /* Index in VLIB's brain (not shared memory). */
+  u32 vl_api_registration_pool_index;
 
-    /* Index in VLIB's brain (not shared memory). */
-    u32 vl_api_registration_pool_index;
-    
-    u8 *name;
+  u8 *name;
 
-    /*
-     * The following groups of data could be unioned, but my fingers are
-     * going to be sore enough.
-     */
+  /*
+   * The following groups of data could be unioned, but my fingers are
+   * going to be sore enough.
+   */
 
-    /* shared memory only */
-    unix_shared_memory_queue_t *vl_input_queue;
+  /* shared memory only */
+  unix_shared_memory_queue_t *vl_input_queue;
 
-    /* socket server and client */
-    u32 unix_file_index;
-    i8 * unprocessed_input;
-    u32 unprocessed_msg_length;
-    u8 * output_vector;
+  /* socket server and client */
+  u32 unix_file_index;
+  i8 *unprocessed_input;
+  u32 unprocessed_msg_length;
+  u8 *output_vector;
 
-    /* socket client only */
-    u32 server_handle;
-    u32 server_index;
+  /* socket client only */
+  u32 server_handle;
+  u32 server_index;
 
 } vl_api_registration_t;
 
 
 /* Trace configuration for a single message */
-typedef struct {
-    int size;
-    int trace_enable;
-    int replay_enable;
+typedef struct
+{
+  int size;
+  int trace_enable;
+  int replay_enable;
 } trace_cfg_t;
 
 /*
  * API recording
  */
-typedef struct {
-    u8 endian;
-    u8 enabled;
-    u8 wrapped;
-    u8 pad;
-    u32 nitems;
-    u32 curindex;
-    u8 **traces;
+typedef struct
+{
+  u8 endian;
+  u8 enabled;
+  u8 wrapped;
+  u8 pad;
+  u32 nitems;
+  u32 curindex;
+  u8 **traces;
 } vl_api_trace_t;
 
-typedef CLIB_PACKED (struct {
-    u8 endian;
-    u8 wrapped;
-    u32 nitems;
-}) vl_api_trace_file_header_t;
+typedef CLIB_PACKED (struct
+		     {
+		     u8 endian; u8 wrapped;
+		     u32 nitems;
+		     }) vl_api_trace_file_header_t;
 
-typedef enum {
-    VL_API_TRACE_TX,
-    VL_API_TRACE_RX,
+typedef enum
+{
+  VL_API_TRACE_TX,
+  VL_API_TRACE_RX,
 } vl_api_trace_which_t;
 
 #define VL_API_LITTLE_ENDIAN 0x00
 #define VL_API_BIG_ENDIAN 0x01
 
-typedef struct {
-    u8 * name;
-    u16 first_msg_id;
-    u16 last_msg_id;
+typedef struct
+{
+  u8 *name;
+  u16 first_msg_id;
+  u16 last_msg_id;
 } vl_api_msg_range_t;
 
-typedef struct {
-    void (**msg_handlers)(void *);
-    int  (**pd_msg_handlers)(void *, int);
-    void (**msg_cleanup_handlers)(void *);
-    void (**msg_endian_handlers)(void *);
-    void (**msg_print_handlers)(void *, void *);
-    char **msg_names;
-    u8 *message_bounce;
-    u8 *is_mp_safe;
-    struct ring_alloc_ *arings;
-    u32 ring_misses;
-    u32 missing_clients;
-    vl_api_trace_t *rx_trace;
-    vl_api_trace_t *tx_trace;
-    int msg_print_flag;
-    trace_cfg_t *api_trace_cfg;
-    int our_pid;
-    svm_region_t *vlib_rp;
-    svm_region_t **mapped_shmem_regions;
-    struct vl_shmem_hdr_ *shmem_hdr;
-    vl_api_registration_t **vl_clients;
-
-    /* For plugin msg allocator */
-    u16 first_available_msg_id;
-
-    /* message range by name hash */
-    uword * msg_range_by_name;
-
-    /* vector of message ranges */
-    vl_api_msg_range_t *msg_ranges;
-
-    /* gid for the api shared memory region */
-    int api_gid;
-    int api_uid;
-
-    /* Client-only data structures */
-    unix_shared_memory_queue_t *vl_input_queue;
-
-    /*
-     * All VLIB-side message handlers use my_client_index to identify 
-     * the queue / client. This works in sim replay.
-     */
-    int my_client_index;
-    /*
-     * This is the (shared VM) address of the registration,
-     * don't use it to id the connection since it can't possibly
-     * work in simulator replay.
-     */
-    vl_api_registration_t *my_registration;
-
-    i32 vlib_signal;
-
-    char *region_name;
-    char *root_path;
+typedef struct
+{
+  void (**msg_handlers) (void *);
+  int (**pd_msg_handlers) (void *, int);
+  void (**msg_cleanup_handlers) (void *);
+  void (**msg_endian_handlers) (void *);
+  void (**msg_print_handlers) (void *, void *);
+  char **msg_names;
+  u8 *message_bounce;
+  u8 *is_mp_safe;
+  struct ring_alloc_ *arings;
+  u32 ring_misses;
+  u32 missing_clients;
+  vl_api_trace_t *rx_trace;
+  vl_api_trace_t *tx_trace;
+  int msg_print_flag;
+  trace_cfg_t *api_trace_cfg;
+  int our_pid;
+  svm_region_t *vlib_rp;
+  svm_region_t **mapped_shmem_regions;
+  struct vl_shmem_hdr_ *shmem_hdr;
+  vl_api_registration_t **vl_clients;
+
+  /* For plugin msg allocator */
+  u16 first_available_msg_id;
+
+  /* message range by name hash */
+  uword *msg_range_by_name;
+
+  /* vector of message ranges */
+  vl_api_msg_range_t *msg_ranges;
+
+  /* gid for the api shared memory region */
+  int api_gid;
+  int api_uid;
+
+  /* Client-only data structures */
+  unix_shared_memory_queue_t *vl_input_queue;
+
+  /*
+   * All VLIB-side message handlers use my_client_index to identify
+   * the queue / client. This works in sim replay.
+   */
+  int my_client_index;
+  /*
+   * This is the (shared VM) address of the registration,
+   * don't use it to id the connection since it can't possibly
+   * work in simulator replay.
+   */
+  vl_api_registration_t *my_registration;
+
+  i32 vlib_signal;
+
+  char *region_name;
+  char *root_path;
 } api_main_t;
 
 api_main_t api_main;
 
-typedef struct {
-    int id;
-    char *name;
-    void *handler;
-    void *cleanup;
-    void *endian;
-    void *print;
-    int size;
-    int traced;
-    int replay;
-    int message_bounce;
-    int is_mp_safe;
+typedef struct
+{
+  int id;
+  char *name;
+  void *handler;
+  void *cleanup;
+  void *endian;
+  void *print;
+  int size;
+  int traced;
+  int replay;
+  int message_bounce;
+  int is_mp_safe;
 } vl_msg_api_msg_config_t;
 
 /* api_shared.c prototypes */
-int vl_msg_api_rx_trace_enabled(api_main_t *am);
-int vl_msg_api_tx_trace_enabled(api_main_t *am);
-void vl_msg_api_trace(api_main_t *am, vl_api_trace_t *tp, void *msg);
-int vl_msg_api_trace_onoff(api_main_t *am, vl_api_trace_which_t which, 
-                           int onoff);
-int vl_msg_api_trace_free(api_main_t *am, vl_api_trace_which_t which);
-int vl_msg_api_trace_save(api_main_t *am, 
-                          vl_api_trace_which_t which, FILE *fp);
-int vl_msg_api_trace_configure(api_main_t *am, vl_api_trace_which_t which, 
-                               u32 nitems);
-void vl_msg_api_handler_with_vm_node (api_main_t *am, 
-                                      void *the_msg, vlib_main_t *vm, 
-                                      vlib_node_runtime_t *node);
+int vl_msg_api_rx_trace_enabled (api_main_t * am);
+int vl_msg_api_tx_trace_enabled (api_main_t * am);
+void vl_msg_api_trace (api_main_t * am, vl_api_trace_t * tp, void *msg);
+int vl_msg_api_trace_onoff (api_main_t * am, vl_api_trace_which_t which,
+			    int onoff);
+int vl_msg_api_trace_free (api_main_t * am, vl_api_trace_which_t which);
+int vl_msg_api_trace_save (api_main_t * am,
+			   vl_api_trace_which_t which, FILE * fp);
+int vl_msg_api_trace_configure (api_main_t * am, vl_api_trace_which_t which,
+				u32 nitems);
+void vl_msg_api_handler_with_vm_node (api_main_t * am,
+				      void *the_msg, vlib_main_t * vm,
+				      vlib_node_runtime_t * node);
 void vl_msg_api_handler (void *the_msg);
 void vl_msg_api_handler_no_free (void *the_msg);
 void vl_msg_api_handler_no_trace_no_free (void *the_msg);
 void vl_msg_api_trace_only (void *the_msg);
 void vl_msg_api_cleanup_handler (void *the_msg);
-void vl_msg_api_replay_handler(void *the_msg);
-void vl_msg_api_socket_handler(void *the_msg);
-void vl_msg_api_set_handlers(int msg_id, char *msg_name, 
-                             void *handler, 
-                             void *cleanup,
-                             void *endian,
-                             void *print,
-                             int msg_size, int traced);
+void vl_msg_api_replay_handler (void *the_msg);
+void vl_msg_api_socket_handler (void *the_msg);
+void vl_msg_api_set_handlers (int msg_id, char *msg_name,
+			      void *handler,
+			      void *cleanup,
+			      void *endian,
+			      void *print, int msg_size, int traced);
 void vl_msg_api_config (vl_msg_api_msg_config_t *);
-void vl_msg_api_set_cleanup_handler(int msg_id, void *fp);
-void vl_msg_api_queue_handler(unix_shared_memory_queue_t *q);
-vl_api_trace_t *vl_msg_api_trace_get(api_main_t *am, 
-                                     vl_api_trace_which_t which);
+void vl_msg_api_set_cleanup_handler (int msg_id, void *fp);
+void vl_msg_api_queue_handler (unix_shared_memory_queue_t * q);
+vl_api_trace_t *vl_msg_api_trace_get (api_main_t * am,
+				      vl_api_trace_which_t which);
 
 void vl_msg_api_free (void *);
 void vl_noop_handler (void *mp);
-clib_error_t *vl_api_init (vlib_main_t *vm);
-void vl_msg_api_increment_missing_client_counter(void);
+clib_error_t *vl_api_init (vlib_main_t * vm);
+void vl_msg_api_increment_missing_client_counter (void);
 void vl_msg_api_post_mortem_dump (void);
-void vl_msg_api_register_pd_handler (void *handler, u16 msg_id_host_byte_order);
+void vl_msg_api_register_pd_handler (void *handler,
+				     u16 msg_id_host_byte_order);
 int vl_msg_api_pd_handler (void *mp, int rv);
 
 void vl_msg_api_set_first_available_msg_id (u16 first_avail);
-u16 vl_msg_api_get_msg_ids (char * name, int n);
+u16 vl_msg_api_get_msg_ids (char *name, int n);
 
 /* node_serialize.c prototypes */
-u8 * vlib_node_serialize (vlib_node_main_t *nm, u8 * vector,
-                          u32 max_threads, int include_nexts, 
-                          int include_stats);
-vlib_node_t ** vlib_node_unserialize (u8 * vector);
+u8 *vlib_node_serialize (vlib_node_main_t * nm, u8 * vector,
+			 u32 max_threads, int include_nexts,
+			 int include_stats);
+vlib_node_t **vlib_node_unserialize (u8 * vector);
 
 #define VLIB_API_INIT_FUNCTION(x) VLIB_DECLARE_INIT_FUNCTION(x,api_init)
 
 #endif /* included_api_h */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/vlib-api/vlibapi/api_shared.c b/vlib-api/vlibapi/api_shared.c
index 0600e621a4e..18b189e1837 100644
--- a/vlib-api/vlibapi/api_shared.c
+++ b/vlib-api/vlibapi/api_shared.c
@@ -1,8 +1,8 @@
-/* 
+/*
  *------------------------------------------------------------------
  * api_shared.c - API message handling, common code for both clients
  * and the vlib process itself.
- * 
+ *
  *
  * Copyright (c) 2009 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -37,349 +37,394 @@
 
 api_main_t api_main;
 
-void vl_msg_api_barrier_sync(void) __attribute__((weak));
-void vl_msg_api_barrier_sync(void) { }
+void vl_msg_api_barrier_sync (void) __attribute__ ((weak));
+void
+vl_msg_api_barrier_sync (void)
+{
+}
 
-void vl_msg_api_barrier_release(void) __attribute__((weak));
-void vl_msg_api_barrier_release(void) { }
+void vl_msg_api_barrier_release (void) __attribute__ ((weak));
+void
+vl_msg_api_barrier_release (void)
+{
+}
 
-void vl_msg_api_increment_missing_client_counter(void)
+void
+vl_msg_api_increment_missing_client_counter (void)
 {
-    api_main_t * am = &api_main;
-    am->missing_clients++;
+  api_main_t *am = &api_main;
+  am->missing_clients++;
 }
 
-typedef enum {
-    DUMP, 
-    CUSTOM_DUMP,
-    REPLAY,
-    INITIALIZERS,
+typedef enum
+{
+  DUMP,
+  CUSTOM_DUMP,
+  REPLAY,
+  INITIALIZERS,
 } vl_api_replay_t;
 
-int vl_msg_api_rx_trace_enabled(api_main_t *am)
+int
+vl_msg_api_rx_trace_enabled (api_main_t * am)
 {
-    return (am->rx_trace && am->rx_trace->enabled);
+  return (am->rx_trace && am->rx_trace->enabled);
 }
 
-int vl_msg_api_tx_trace_enabled(api_main_t *am)
+int
+vl_msg_api_tx_trace_enabled (api_main_t * am)
 {
-    return (am->tx_trace && am->tx_trace->enabled);
+  return (am->tx_trace && am->tx_trace->enabled);
 }
 
 /*
  * vl_msg_api_trace
  */
-void vl_msg_api_trace(api_main_t *am, vl_api_trace_t *tp, void *msg)
+void
+vl_msg_api_trace (api_main_t * am, vl_api_trace_t * tp, void *msg)
 {
-    u8 **this_trace;
-    u8 **old_trace;
-    u8 *msg_copy;
-    trace_cfg_t *cfgp;
-    u16 msg_id = ntohs(*((u16 *)msg));
+  u8 **this_trace;
+  u8 **old_trace;
+  u8 *msg_copy;
+  trace_cfg_t *cfgp;
+  u16 msg_id = ntohs (*((u16 *) msg));
 
-    cfgp = am->api_trace_cfg + msg_id;
+  cfgp = am->api_trace_cfg + msg_id;
 
-    if (!cfgp || !cfgp->trace_enable)
-        return;
+  if (!cfgp || !cfgp->trace_enable)
+    return;
 
-    msg_copy = 0;
+  msg_copy = 0;
 
-    if (tp->nitems == 0) {
-        clib_warning ("tp->nitems is 0");
-        return;
+  if (tp->nitems == 0)
+    {
+      clib_warning ("tp->nitems is 0");
+      return;
     }
 
-    if (vec_len(tp->traces) < tp->nitems) {
-        vec_add1(tp->traces, 0);
-        this_trace = tp->traces + vec_len(tp->traces) - 1;
-    } else {
-        tp->wrapped = 1;
-        old_trace = tp->traces + tp->curindex++;
-        if (tp->curindex == tp->nitems)
-            tp->curindex = 0;
-        vec_free(*old_trace);
-        this_trace = old_trace;
+  if (vec_len (tp->traces) < tp->nitems)
+    {
+      vec_add1 (tp->traces, 0);
+      this_trace = tp->traces + vec_len (tp->traces) - 1;
+    }
+  else
+    {
+      tp->wrapped = 1;
+      old_trace = tp->traces + tp->curindex++;
+      if (tp->curindex == tp->nitems)
+	tp->curindex = 0;
+      vec_free (*old_trace);
+      this_trace = old_trace;
     }
 
-    vec_validate(msg_copy, cfgp->size - 1);
-    clib_memcpy(msg_copy, msg, cfgp->size);
-    *this_trace = msg_copy;
+  vec_validate (msg_copy, cfgp->size - 1);
+  clib_memcpy (msg_copy, msg, cfgp->size);
+  *this_trace = msg_copy;
 }
 
-int vl_msg_api_trace_onoff(api_main_t *am, vl_api_trace_which_t which, 
-                           int onoff)
+int
+vl_msg_api_trace_onoff (api_main_t * am, vl_api_trace_which_t which,
+			int onoff)
 {
-    vl_api_trace_t *tp;
-    int rv;
+  vl_api_trace_t *tp;
+  int rv;
 
-    switch(which)
+  switch (which)
     {
     case VL_API_TRACE_TX:
-        tp = am->tx_trace;
-        if (tp == 0) {
-            vl_msg_api_trace_configure (am, which, 1024);
-            tp = am->tx_trace;
-        }
-        break;
-        
+      tp = am->tx_trace;
+      if (tp == 0)
+	{
+	  vl_msg_api_trace_configure (am, which, 1024);
+	  tp = am->tx_trace;
+	}
+      break;
+
     case VL_API_TRACE_RX:
-        tp = am->rx_trace;
-        if (tp == 0) {
-            vl_msg_api_trace_configure (am, which, 1024);
-            tp = am->rx_trace;
-        }
-        break;
-        
+      tp = am->rx_trace;
+      if (tp == 0)
+	{
+	  vl_msg_api_trace_configure (am, which, 1024);
+	  tp = am->rx_trace;
+	}
+      break;
+
     default:
-        /* duh? */
-        return -1;
+      /* duh? */
+      return -1;
     }
 
-    /* Configured? */
-    if (tp == 0 || tp->nitems == 0)
-        return -1;
+  /* Configured? */
+  if (tp == 0 || tp->nitems == 0)
+    return -1;
 
-    rv = tp->enabled;
-    tp->enabled = onoff;
+  rv = tp->enabled;
+  tp->enabled = onoff;
 
-    return rv;
+  return rv;
 }
 
-int vl_msg_api_trace_free(api_main_t *am, vl_api_trace_which_t which)
+int
+vl_msg_api_trace_free (api_main_t * am, vl_api_trace_which_t which)
 {
-    vl_api_trace_t *tp;
-    int i;
+  vl_api_trace_t *tp;
+  int i;
 
-    switch(which)
+  switch (which)
     {
     case VL_API_TRACE_TX:
-        tp = am->tx_trace;
-        break;
-        
+      tp = am->tx_trace;
+      break;
+
     case VL_API_TRACE_RX:
-        tp = am->rx_trace;
-        break;
-        
+      tp = am->rx_trace;
+      break;
+
     default:
-        /* duh? */
-        return -1;
+      /* duh? */
+      return -1;
     }
 
-    /* Configured? */
-    if (!tp || tp->nitems == 0)
-        return -1;
+  /* Configured? */
+  if (!tp || tp->nitems == 0)
+    return -1;
 
-    tp->curindex = 0;
-    tp->wrapped = 0;
+  tp->curindex = 0;
+  tp->wrapped = 0;
 
-    for (i = 0; i < vec_len(tp->traces); i++) {
-        vec_free(tp->traces[i]);
+  for (i = 0; i < vec_len (tp->traces); i++)
+    {
+      vec_free (tp->traces[i]);
     }
-    vec_free(tp->traces);
+  vec_free (tp->traces);
 
-    return 0;
+  return 0;
 }
 
-int vl_msg_api_trace_save(api_main_t *am, 
-                          vl_api_trace_which_t which, FILE *fp)
+int
+vl_msg_api_trace_save (api_main_t * am, vl_api_trace_which_t which, FILE * fp)
 {
-    vl_api_trace_t *tp;
-    vl_api_trace_file_header_t fh;
-    int i;
-    u8 *msg;
+  vl_api_trace_t *tp;
+  vl_api_trace_file_header_t fh;
+  int i;
+  u8 *msg;
 
-    switch(which)
+  switch (which)
     {
     case VL_API_TRACE_TX:
-        tp = am->tx_trace;
-        break;
-        
+      tp = am->tx_trace;
+      break;
+
     case VL_API_TRACE_RX:
-        tp = am->rx_trace;
-        break;
-        
+      tp = am->rx_trace;
+      break;
+
     default:
-        /* duh? */
-        return -1;
+      /* duh? */
+      return -1;
     }
 
-    /* Configured, data present? */
-    if (tp == 0 || tp->nitems == 0 || vec_len(tp->traces) == 0)
-        return -1;
+  /* Configured, data present? */
+  if (tp == 0 || tp->nitems == 0 || vec_len (tp->traces) == 0)
+    return -1;
 
-    /* "Dare to be stupid" check */
-    if (fp == 0) {
-        return -2;
+  /* "Dare to be stupid" check */
+  if (fp == 0)
+    {
+      return -2;
     }
 
-    /* Write the file header */
-    fh.nitems = vec_len(tp->traces);
-    fh.endian = tp->endian;
-    fh.wrapped = tp->wrapped;
+  /* Write the file header */
+  fh.nitems = vec_len (tp->traces);
+  fh.endian = tp->endian;
+  fh.wrapped = tp->wrapped;
 
-    if (fwrite(&fh, sizeof(fh), 1, fp) != 1) {
-        return (-10);
+  if (fwrite (&fh, sizeof (fh), 1, fp) != 1)
+    {
+      return (-10);
     }
 
-    /* No-wrap case */
-    if (tp->wrapped == 0) {
-        /*
-         * Note: vec_len return 0 when fed a NULL pointer.
-         * Unfortunately, the static analysis tool doesn't
-         * figure it out, hence the suppressed warnings.
-         * What a great use of my time. 
-         */
-        for (i = 0; i < vec_len(tp->traces); i++) {
-            /*sa_ignore NO_NULL_CHK*/
-            msg = tp->traces[i];
-            /*
-             * This retarded check required to pass
-             * [sic] SA-checking. 
-             */
-            if (!msg)
-                continue;
-            if (fwrite(msg, 1, vec_len(msg), fp) != vec_len(msg)) {
-                return (-11);
-            }
-        }
-    } else {                    
-        /* Wrap case: write oldest -> end of buffer */
-        for (i = tp->curindex; i < vec_len(tp->traces); i++) {
-            msg = tp->traces[i];
-            /*
-             * This retarded check required to pass
-             * [sic] SA-checking 
-             */
-            if (!msg)
-                continue;
-
-            if (fwrite(msg, 1, vec_len(msg), fp) != vec_len(msg)) {
-                return (-12);
-            }
-        }
-        /* write beginning of buffer -> oldest-1 */
-        for (i = 0; i < tp->curindex; i++) {
-            /*sa_ignore NO_NULL_CHK*/
-            msg = tp->traces[i];
-            /*
-             * This retarded check required to pass
-             * [sic] SA-checking 
-             */
-            if (!msg)
-                continue;
-
-            if (fwrite(msg, 1, vec_len(msg), fp) != vec_len(msg)) {
-                return (-13);
-            }
-        }
+  /* No-wrap case */
+  if (tp->wrapped == 0)
+    {
+      /*
+       * Note: vec_len return 0 when fed a NULL pointer.
+       * Unfortunately, the static analysis tool doesn't
+       * figure it out, hence the suppressed warnings.
+       * What a great use of my time.
+       */
+      for (i = 0; i < vec_len (tp->traces); i++)
+	{
+	  /*sa_ignore NO_NULL_CHK */
+	  msg = tp->traces[i];
+	  /*
+	   * This retarded check required to pass
+	   * [sic] SA-checking.
+	   */
+	  if (!msg)
+	    continue;
+	  if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
+	    {
+	      return (-11);
+	    }
+	}
     }
-    return 0;
+  else
+    {
+      /* Wrap case: write oldest -> end of buffer */
+      for (i = tp->curindex; i < vec_len (tp->traces); i++)
+	{
+	  msg = tp->traces[i];
+	  /*
+	   * This retarded check required to pass
+	   * [sic] SA-checking
+	   */
+	  if (!msg)
+	    continue;
+
+	  if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
+	    {
+	      return (-12);
+	    }
+	}
+      /* write beginning of buffer -> oldest-1 */
+      for (i = 0; i < tp->curindex; i++)
+	{
+	  /*sa_ignore NO_NULL_CHK */
+	  msg = tp->traces[i];
+	  /*
+	   * This retarded check required to pass
+	   * [sic] SA-checking
+	   */
+	  if (!msg)
+	    continue;
+
+	  if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
+	    {
+	      return (-13);
+	    }
+	}
+    }
+  return 0;
 }
 
-int vl_msg_api_trace_configure(api_main_t *am, vl_api_trace_which_t which, 
-                               u32 nitems)
+int
+vl_msg_api_trace_configure (api_main_t * am, vl_api_trace_which_t which,
+			    u32 nitems)
 {
-    vl_api_trace_t *tp;
-    int was_on = 0;
+  vl_api_trace_t *tp;
+  int was_on = 0;
 
-    switch(which)
+  switch (which)
     {
     case VL_API_TRACE_TX:
-        tp = am->tx_trace;
-        if (tp == 0) {
-            vec_validate(am->tx_trace, 0);
-            tp = am->tx_trace;
-        }
-        break;
-        
+      tp = am->tx_trace;
+      if (tp == 0)
+	{
+	  vec_validate (am->tx_trace, 0);
+	  tp = am->tx_trace;
+	}
+      break;
+
     case VL_API_TRACE_RX:
-        tp = am->rx_trace;
-        if (tp == 0) {
-            vec_validate(am->rx_trace, 0);
-            tp = am->rx_trace;
-        }
+      tp = am->rx_trace;
+      if (tp == 0)
+	{
+	  vec_validate (am->rx_trace, 0);
+	  tp = am->rx_trace;
+	}
 
-        break;
+      break;
 
     default:
-        return -1;
+      return -1;
 
     }
 
-    if (tp->enabled) {
-        was_on = vl_msg_api_trace_onoff(am, which, 0);
+  if (tp->enabled)
+    {
+      was_on = vl_msg_api_trace_onoff (am, which, 0);
     }
-    if (tp->traces) {
-        vl_msg_api_trace_free(am, which);
+  if (tp->traces)
+    {
+      vl_msg_api_trace_free (am, which);
     }
 
-    memset(tp, 0, sizeof(*tp));
+  memset (tp, 0, sizeof (*tp));
 
-    if (clib_arch_is_big_endian) {
-        tp->endian = VL_API_BIG_ENDIAN;
-    } else {
-        tp->endian = VL_API_LITTLE_ENDIAN;
+  if (clib_arch_is_big_endian)
+    {
+      tp->endian = VL_API_BIG_ENDIAN;
+    }
+  else
+    {
+      tp->endian = VL_API_LITTLE_ENDIAN;
     }
 
-    tp->nitems = nitems;
-    if (was_on) {
-        (void)vl_msg_api_trace_onoff(am, which, was_on);
+  tp->nitems = nitems;
+  if (was_on)
+    {
+      (void) vl_msg_api_trace_onoff (am, which, was_on);
     }
-    return 0;
+  return 0;
 }
 
-always_inline void msg_handler_internal (api_main_t *am, 
-					 void *the_msg, 
-					 int trace_it,
-					 int do_it, 
-					 int free_it)
+always_inline void
+msg_handler_internal (api_main_t * am,
+		      void *the_msg, int trace_it, int do_it, int free_it)
 {
-    u16 id = ntohs(*((u16 *)the_msg));
-    u8 *(*print_fp)(void *, void *);
-
-    if (id < vec_len(am->msg_handlers) && 
-        am->msg_handlers[id]) {
-        if (trace_it)
-            vl_msg_api_trace(am, am->rx_trace, the_msg);
-        
-        if (am->msg_print_flag) {
-            fformat (stdout, "[%d]: %s\n", id, 
-                     am->msg_names[id]);
-            print_fp = (void *)am->msg_print_handlers[id];
-            if (print_fp == 0) {
-                fformat(stdout, "  [no registered print fn]\n");
-            } else {
-                (*print_fp)(the_msg, stdout);
-            }
-        }
-
-        if (do_it) {
-            if (!am->is_mp_safe[id])
-                vl_msg_api_barrier_sync();
-            (*am->msg_handlers[id])(the_msg);
-            if (!am->is_mp_safe[id])
-                vl_msg_api_barrier_release();
-        }
-    } else {
-        clib_warning("no handler for msg id %d", id);
+  u16 id = ntohs (*((u16 *) the_msg));
+  u8 *(*print_fp) (void *, void *);
+
+  if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
+    {
+      if (trace_it)
+	vl_msg_api_trace (am, am->rx_trace, the_msg);
+
+      if (am->msg_print_flag)
+	{
+	  fformat (stdout, "[%d]: %s\n", id, am->msg_names[id]);
+	  print_fp = (void *) am->msg_print_handlers[id];
+	  if (print_fp == 0)
+	    {
+	      fformat (stdout, "  [no registered print fn]\n");
+	    }
+	  else
+	    {
+	      (*print_fp) (the_msg, stdout);
+	    }
+	}
+
+      if (do_it)
+	{
+	  if (!am->is_mp_safe[id])
+	    vl_msg_api_barrier_sync ();
+	  (*am->msg_handlers[id]) (the_msg);
+	  if (!am->is_mp_safe[id])
+	    vl_msg_api_barrier_release ();
+	}
+    }
+  else
+    {
+      clib_warning ("no handler for msg id %d", id);
     }
 
-    if (free_it) 
-        vl_msg_api_free(the_msg);
+  if (free_it)
+    vl_msg_api_free (the_msg);
 }
 
 /* set to 1 if you want before/after message handler event logging */
 #define ELOG_API_MESSAGE_HANDLERS 0
 
 #if ELOG_API_MESSAGE_HANDLERS > 0
-static u32 elog_id_for_msg_name (vlib_main_t * vm, char *msg_name)
+static u32
+elog_id_for_msg_name (vlib_main_t * vm, char *msg_name)
 {
-  uword * p, r;
-  static uword * h;
+  uword *p, r;
+  static uword *h;
   u8 *name_copy;
 
-  if (! h)
-      h = hash_create_string (0, sizeof (uword));
+  if (!h)
+    h = hash_create_string (0, sizeof (uword));
 
   p = hash_get_mem (h, msg_name);
   if (p)
@@ -395,155 +440,181 @@ static u32 elog_id_for_msg_name (vlib_main_t * vm, char *msg_name)
 #endif
 
 /* This is only to be called from a vlib/vnet app */
-void vl_msg_api_handler_with_vm_node (api_main_t *am, 
-                                      void *the_msg, vlib_main_t *vm, 
-                                      vlib_node_runtime_t *node)
+void
+vl_msg_api_handler_with_vm_node (api_main_t * am,
+				 void *the_msg, vlib_main_t * vm,
+				 vlib_node_runtime_t * node)
 {
-  u16 id = ntohs(*((u16 *)the_msg));
-  u8 *(*handler)(void *, void *, void *);
-    
+  u16 id = ntohs (*((u16 *) the_msg));
+  u8 *(*handler) (void *, void *, void *);
+
 #if ELOG_API_MESSAGE_HANDLERS > 0
-    {
-      ELOG_TYPE_DECLARE (e) = {
+  {
+    /* *INDENT-OFF* */
+    ELOG_TYPE_DECLARE (e) =
+      {
         .format = "api-msg: %s",
         .format_args = "T4",
       };
-      struct { u32 c; } * ed;
-      ed = ELOG_DATA (&vm->elog_main, e);
-      if (id < vec_len (am->msg_names))
-        ed->c = elog_id_for_msg_name (vm, am->msg_names[id]);
-      else
-        ed->c = elog_id_for_msg_name (vm, "BOGUS");
-    }
-#endif    
-
-  if (id < vec_len(am->msg_handlers) && 
-      am->msg_handlers[id]) {
-    handler = (void *)am->msg_handlers[id];
-
-    if (am->rx_trace && am->rx_trace->enabled)
-      vl_msg_api_trace(am, am->rx_trace, the_msg);
-
-    if (!am->is_mp_safe[id])
-      vl_msg_api_barrier_sync();
-    (*handler)(the_msg, vm, node);
-    if (!am->is_mp_safe[id])
-      vl_msg_api_barrier_release();
-  } else {
-    clib_warning("no hander for msg id %d", id);
+    /* *INDENT-ON* */
+    struct
+    {
+      u32 c;
+    } *ed;
+    ed = ELOG_DATA (&vm->elog_main, e);
+    if (id < vec_len (am->msg_names))
+      ed->c = elog_id_for_msg_name (vm, am->msg_names[id]);
+    else
+      ed->c = elog_id_for_msg_name (vm, "BOGUS");
   }
-  /* 
+#endif
+
+  if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
+    {
+      handler = (void *) am->msg_handlers[id];
+
+      if (am->rx_trace && am->rx_trace->enabled)
+	vl_msg_api_trace (am, am->rx_trace, the_msg);
+
+      if (!am->is_mp_safe[id])
+	vl_msg_api_barrier_sync ();
+      (*handler) (the_msg, vm, node);
+      if (!am->is_mp_safe[id])
+	vl_msg_api_barrier_release ();
+    }
+  else
+    {
+      clib_warning ("no hander for msg id %d", id);
+    }
+
+  /*
    * Special-case, so we can e.g. bounce messages off the vnet
    * main thread without copying them...
    */
   if (!(am->message_bounce[id]))
-    vl_msg_api_free(the_msg);
+    vl_msg_api_free (the_msg);
 
 #if ELOG_API_MESSAGE_HANDLERS > 0
+  {
+  /* *INDENT-OFF* */
+  ELOG_TYPE_DECLARE (e) = {
+    .format = "api-msg-done: %s",
+    .format_args = "T4",
+  };
+  /* *INDENT-ON* */
+
+    struct
     {
-      ELOG_TYPE_DECLARE (e) = {
-        .format = "api-msg-done: %s",
-        .format_args = "T4",
-      };
-      struct { u32 c; } * ed;
-      ed = ELOG_DATA (&vm->elog_main, e);
-      if (id < vec_len (am->msg_names))
-        ed->c = elog_id_for_msg_name (vm, am->msg_names[id]);
-      else
-        ed->c = elog_id_for_msg_name (vm, "BOGUS");
-    }
+      u32 c;
+    } *ed;
+    ed = ELOG_DATA (&vm->elog_main, e);
+    if (id < vec_len (am->msg_names))
+      ed->c = elog_id_for_msg_name (vm, am->msg_names[id]);
+    else
+      ed->c = elog_id_for_msg_name (vm, "BOGUS");
+  }
 #endif
 }
 
-void vl_msg_api_handler (void *the_msg)
+void
+vl_msg_api_handler (void *the_msg)
 {
-    api_main_t *am = &api_main;
+  api_main_t *am = &api_main;
 
-    msg_handler_internal (am, the_msg, 
-                          (am->rx_trace 
-                           && am->rx_trace->enabled) /* trace_it */, 
-                          1 /* do_it */, 1 /* free_it */);
+  msg_handler_internal (am, the_msg,
+			(am->rx_trace
+			 && am->rx_trace->enabled) /* trace_it */ ,
+			1 /* do_it */ , 1 /* free_it */ );
 }
 
-void vl_msg_api_handler_no_free (void *the_msg)
+void
+vl_msg_api_handler_no_free (void *the_msg)
 {
-    api_main_t *am = &api_main;
-    msg_handler_internal (am, the_msg, 
-                          (am->rx_trace 
-                           && am->rx_trace->enabled) /* trace_it */, 
-                          1 /* do_it */, 0 /* free_it */);
+  api_main_t *am = &api_main;
+  msg_handler_internal (am, the_msg,
+			(am->rx_trace
+			 && am->rx_trace->enabled) /* trace_it */ ,
+			1 /* do_it */ , 0 /* free_it */ );
 }
 
-void vl_msg_api_handler_no_trace_no_free (void *the_msg)
+void
+vl_msg_api_handler_no_trace_no_free (void *the_msg)
 {
-    api_main_t *am = &api_main;
-    msg_handler_internal (am, the_msg, 0/* trace_it */, 1 /* do_it */, 
-                          0 /* free_it */);
+  api_main_t *am = &api_main;
+  msg_handler_internal (am, the_msg, 0 /* trace_it */ , 1 /* do_it */ ,
+			0 /* free_it */ );
 }
 
 /*
  * Add a trace record to the API message trace buffer, if
  * API message tracing is enabled. Handy for adding sufficient
  * data to the trace to reproduce autonomous state, as opposed to
- * state downloaded via control-plane API messages. Example: the NAT 
+ * state downloaded via control-plane API messages. Example: the NAT
  * application creates database entries based on packet traffic, not
  * control-plane messages.
  *
  */
-void vl_msg_api_trace_only (void *the_msg)
+void
+vl_msg_api_trace_only (void *the_msg)
 {
-    api_main_t *am = &api_main;
+  api_main_t *am = &api_main;
 
-    msg_handler_internal (am, the_msg, 
-                          (am->rx_trace 
-                           && am->rx_trace->enabled) /* trace_it */,
-                          0 /* do_it */, 0 /* free_it */);
+  msg_handler_internal (am, the_msg,
+			(am->rx_trace
+			 && am->rx_trace->enabled) /* trace_it */ ,
+			0 /* do_it */ , 0 /* free_it */ );
 }
 
-void vl_msg_api_cleanup_handler (void *the_msg)
+void
+vl_msg_api_cleanup_handler (void *the_msg)
 {
-    api_main_t *am = &api_main;
-    u16 id = ntohs(*((u16 *)the_msg));
+  api_main_t *am = &api_main;
+  u16 id = ntohs (*((u16 *) the_msg));
 
-    if (PREDICT_FALSE(id >= vec_len(am->msg_cleanup_handlers))) {
-        clib_warning ("_vl_msg_id too large: %d\n", id);
-        return;
+  if (PREDICT_FALSE (id >= vec_len (am->msg_cleanup_handlers)))
+    {
+      clib_warning ("_vl_msg_id too large: %d\n", id);
+      return;
     }
-    if (am->msg_cleanup_handlers[id])
-        (*am->msg_cleanup_handlers[id])(the_msg);
+  if (am->msg_cleanup_handlers[id])
+    (*am->msg_cleanup_handlers[id]) (the_msg);
 
-    vl_msg_api_free(the_msg);
+  vl_msg_api_free (the_msg);
 }
 
 /*
  * vl_msg_api_replay_handler
  */
-void vl_msg_api_replay_handler(void *the_msg)
+void
+vl_msg_api_replay_handler (void *the_msg)
 {
-    api_main_t *am = &api_main;
+  api_main_t *am = &api_main;
 
-    u16 id = ntohs(*((u16 *)the_msg));
+  u16 id = ntohs (*((u16 *) the_msg));
 
-    if (PREDICT_FALSE(id >= vec_len(am->msg_handlers))) {
-        clib_warning ("_vl_msg_id too large: %d\n", id);
-        return;
+  if (PREDICT_FALSE (id >= vec_len (am->msg_handlers)))
+    {
+      clib_warning ("_vl_msg_id too large: %d\n", id);
+      return;
     }
-    /* do NOT trace the message... */
-    if (am->msg_handlers[id])
-        (*am->msg_handlers[id])(the_msg);
-    /* do NOT free the message buffer... */
+  /* do NOT trace the message... */
+  if (am->msg_handlers[id])
+    (*am->msg_handlers[id]) (the_msg);
+  /* do NOT free the message buffer... */
 }
+
 /*
  * vl_msg_api_socket_handler
  */
-void vl_msg_api_socket_handler(void *the_msg)
+void
+vl_msg_api_socket_handler (void *the_msg)
 {
-    api_main_t *am = &api_main;
+  api_main_t *am = &api_main;
 
-    msg_handler_internal (am, the_msg, 
-                          (am->rx_trace 
-                           && am->rx_trace->enabled) /* trace_it */,
-                          1 /* do_it */, 0 /* free_it */);
+  msg_handler_internal (am, the_msg,
+			(am->rx_trace
+			 && am->rx_trace->enabled) /* trace_it */ ,
+			1 /* do_it */ , 0 /* free_it */ );
 }
 
 #define foreach_msg_api_vector                  \
@@ -556,592 +627,675 @@ _(api_trace_cfg)				\
 _(message_bounce)				\
 _(is_mp_safe)
 
-void vl_msg_api_config (vl_msg_api_msg_config_t *c)
+void
+vl_msg_api_config (vl_msg_api_msg_config_t * c)
 {
-    api_main_t *am = &api_main;
+  api_main_t *am = &api_main;
 
-    ASSERT(c->id > 0);
+  ASSERT (c->id > 0);
 
 #define _(a) vec_validate (am->a, c->id);
-    foreach_msg_api_vector;
+  foreach_msg_api_vector;
 #undef _
 
-    am->msg_names[c->id] = c->name;
-    am->msg_handlers[c->id] = c->handler;
-    am->msg_cleanup_handlers[c->id] = c->cleanup;
-    am->msg_endian_handlers[c->id] = c->endian;
-    am->msg_print_handlers[c->id] = c->print;
-    am->message_bounce[c->id] = c->message_bounce;
-    am->is_mp_safe[c->id] = c->is_mp_safe;
-
-    am->api_trace_cfg[c->id].size = c->size;
-    am->api_trace_cfg[c->id].trace_enable = c->traced;
-    am->api_trace_cfg[c->id].replay_enable = c->replay;
+  am->msg_names[c->id] = c->name;
+  am->msg_handlers[c->id] = c->handler;
+  am->msg_cleanup_handlers[c->id] = c->cleanup;
+  am->msg_endian_handlers[c->id] = c->endian;
+  am->msg_print_handlers[c->id] = c->print;
+  am->message_bounce[c->id] = c->message_bounce;
+  am->is_mp_safe[c->id] = c->is_mp_safe;
+
+  am->api_trace_cfg[c->id].size = c->size;
+  am->api_trace_cfg[c->id].trace_enable = c->traced;
+  am->api_trace_cfg[c->id].replay_enable = c->replay;
 }
 
-/* 
+/*
  * vl_msg_api_set_handlers
  * preserve the old API for a while
  */
-void vl_msg_api_set_handlers(int id, char *name, void *handler, void *cleanup,
-                             void *endian, void *print, int size, int traced)
+void
+vl_msg_api_set_handlers (int id, char *name, void *handler, void *cleanup,
+			 void *endian, void *print, int size, int traced)
 {
-    vl_msg_api_msg_config_t cfg;
-    vl_msg_api_msg_config_t *c = &cfg;
-
-    c->id = id;
-    c->name = name;
-    c->handler = handler;
-    c->cleanup = cleanup;
-    c->endian = endian;
-    c->print = print;
-    c->size = size;
-    c->traced = traced;
-    c->replay = 1;
-    c->message_bounce = 0;
-    c->is_mp_safe = 0;
-    vl_msg_api_config (c);
+  vl_msg_api_msg_config_t cfg;
+  vl_msg_api_msg_config_t *c = &cfg;
+
+  c->id = id;
+  c->name = name;
+  c->handler = handler;
+  c->cleanup = cleanup;
+  c->endian = endian;
+  c->print = print;
+  c->size = size;
+  c->traced = traced;
+  c->replay = 1;
+  c->message_bounce = 0;
+  c->is_mp_safe = 0;
+  vl_msg_api_config (c);
 }
 
-void vl_msg_api_set_cleanup_handler(int msg_id, void *fp)
+void
+vl_msg_api_set_cleanup_handler (int msg_id, void *fp)
 {
-    api_main_t *am = &api_main;
-    ASSERT(msg_id > 0);
+  api_main_t *am = &api_main;
+  ASSERT (msg_id > 0);
 
-    vec_validate(am->msg_cleanup_handlers, msg_id);
-    am->msg_cleanup_handlers[msg_id] = fp;
+  vec_validate (am->msg_cleanup_handlers, msg_id);
+  am->msg_cleanup_handlers[msg_id] = fp;
 }
 
-void vl_msg_api_queue_handler(unix_shared_memory_queue_t *q)
+void
+vl_msg_api_queue_handler (unix_shared_memory_queue_t * q)
 {
-    uword msg;
+  uword msg;
 
-    while (!unix_shared_memory_queue_sub(q, (u8 *)&msg, 0))
-        vl_msg_api_handler((void *)msg);
+  while (!unix_shared_memory_queue_sub (q, (u8 *) & msg, 0))
+    vl_msg_api_handler ((void *) msg);
 }
 
-vl_api_trace_t *vl_msg_api_trace_get(api_main_t *am, vl_api_trace_which_t which)
+vl_api_trace_t *
+vl_msg_api_trace_get (api_main_t * am, vl_api_trace_which_t which)
 {
-    switch(which)
+  switch (which)
     {
     case VL_API_TRACE_RX:
-        return am->rx_trace;
+      return am->rx_trace;
     case VL_API_TRACE_TX:
-        return am->tx_trace;
+      return am->tx_trace;
     default:
-        return 0;
+      return 0;
     }
 }
 
-void vl_noop_handler (void *mp) { }
+void
+vl_noop_handler (void *mp)
+{
+}
 
 clib_error_t *
-vl_api_init (vlib_main_t *vm)
+vl_api_init (vlib_main_t * vm)
 {
-    static u8 once;
-    api_main_t *am = &api_main;
-
-    if (once)
-        return 0;
-    
-    once = 1;
-
-    am->region_name = "/unset";
-    /* 
-     * Eventually passed to fchown, -1 => "current user" 
-     * instead of 0 => "root". A very fine disctinction at best.
-     */
-    if (am->api_uid == 0)
-        am->api_uid = -1;
-    if (am->api_gid == 0)
-        am->api_gid = -1;
-
-    return (0);
+  static u8 once;
+  api_main_t *am = &api_main;
+
+  if (once)
+    return 0;
+
+  once = 1;
+
+  am->region_name = "/unset";
+  /*
+   * Eventually passed to fchown, -1 => "current user"
+   * instead of 0 => "root". A very fine disctinction at best.
+   */
+  if (am->api_uid == 0)
+    am->api_uid = -1;
+  if (am->api_gid == 0)
+    am->api_gid = -1;
+
+  return (0);
 }
 
-void vl_msg_api_custom_dump_configure (api_main_t *am) __attribute__((weak));
-void vl_msg_api_custom_dump_configure (api_main_t *am) { }
+void vl_msg_api_custom_dump_configure (api_main_t * am)
+  __attribute__ ((weak));
+void
+vl_msg_api_custom_dump_configure (api_main_t * am)
+{
+}
 
 VLIB_INIT_FUNCTION (vl_api_init);
 
-static void vl_msg_api_process_file (vlib_main_t *vm, u8 *filename, 
-                                     u32 first_index, u32 last_index, 
-                                     vl_api_replay_t which)
+static void
+vl_msg_api_process_file (vlib_main_t * vm, u8 * filename,
+			 u32 first_index, u32 last_index,
+			 vl_api_replay_t which)
 {
-    vl_api_trace_file_header_t * hp;
-    int i, fd;
-    struct stat statb;
-    size_t file_size;
-    u8 *msg;
-    u8 endian_swap_needed = 0;
-    api_main_t * am = &api_main;
-    static u8 *tmpbuf;
-    u32 nitems;
-    void **saved_print_handlers = 0;
-
-    fd = open ((char *) filename, O_RDONLY);
-
-    if (fd < 0) {
-        vlib_cli_output (vm, "Couldn't open %s\n", filename);
-        return;
+  vl_api_trace_file_header_t *hp;
+  int i, fd;
+  struct stat statb;
+  size_t file_size;
+  u8 *msg;
+  u8 endian_swap_needed = 0;
+  api_main_t *am = &api_main;
+  static u8 *tmpbuf;
+  u32 nitems;
+  void **saved_print_handlers = 0;
+
+  fd = open ((char *) filename, O_RDONLY);
+
+  if (fd < 0)
+    {
+      vlib_cli_output (vm, "Couldn't open %s\n", filename);
+      return;
     }
 
-    if (fstat(fd, &statb) < 0) {
-        vlib_cli_output (vm, "Couldn't stat %s\n", filename);
-        return;
+  if (fstat (fd, &statb) < 0)
+    {
+      vlib_cli_output (vm, "Couldn't stat %s\n", filename);
+      return;
     }
 
-    if (! (statb.st_mode & S_IFREG) || (statb.st_size < sizeof (*hp))) {
-        vlib_cli_output (vm, "File not plausible: %s\n", filename);
-        return;
+  if (!(statb.st_mode & S_IFREG) || (statb.st_size < sizeof (*hp)))
+    {
+      vlib_cli_output (vm, "File not plausible: %s\n", filename);
+      return;
     }
 
-    file_size = statb.st_size;
-    file_size = (file_size + 4095) & ~(4096);
+  file_size = statb.st_size;
+  file_size = (file_size + 4095) & ~(4096);
 
-    hp = mmap (0, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
+  hp = mmap (0, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
 
-    if (hp == (vl_api_trace_file_header_t *)MAP_FAILED) {
-        vlib_cli_output (vm, "mmap failed: %s\n", filename);
-        close(fd);
-        return;
+  if (hp == (vl_api_trace_file_header_t *) MAP_FAILED)
+    {
+      vlib_cli_output (vm, "mmap failed: %s\n", filename);
+      close (fd);
+      return;
     }
-    close(fd);
-
-    if ((clib_arch_is_little_endian && hp->endian == VL_API_BIG_ENDIAN)
-        || (clib_arch_is_big_endian && hp->endian == VL_API_LITTLE_ENDIAN))
-        endian_swap_needed = 1;
-    
-    if (endian_swap_needed)
-        nitems = ntohl(hp->nitems);
-    else
-        nitems = hp->nitems;
+  close (fd);
+
+  if ((clib_arch_is_little_endian && hp->endian == VL_API_BIG_ENDIAN)
+      || (clib_arch_is_big_endian && hp->endian == VL_API_LITTLE_ENDIAN))
+    endian_swap_needed = 1;
+
+  if (endian_swap_needed)
+    nitems = ntohl (hp->nitems);
+  else
+    nitems = hp->nitems;
 
-    if (last_index == (u32) ~0) {
-        last_index = nitems - 1;
+  if (last_index == (u32) ~ 0)
+    {
+      last_index = nitems - 1;
     }
-    
-    if (first_index >= nitems || last_index >= nitems) {
-        vlib_cli_output (vm, "Range (%d, %d) outside file range (0, %d)\n",
-                         first_index, last_index, nitems-1);
-        return;
+
+  if (first_index >= nitems || last_index >= nitems)
+    {
+      vlib_cli_output (vm, "Range (%d, %d) outside file range (0, %d)\n",
+		       first_index, last_index, nitems - 1);
+      return;
     }
-    if (hp->wrapped)
-        vlib_cli_output (vm, 
-                         "Note: wrapped/incomplete trace, results may vary\n");
-    
-    if (which == CUSTOM_DUMP) {
-        saved_print_handlers = (void **) vec_dup (am->msg_print_handlers);
-        vl_msg_api_custom_dump_configure (am);
+  if (hp->wrapped)
+    vlib_cli_output (vm,
+		     "Note: wrapped/incomplete trace, results may vary\n");
+
+  if (which == CUSTOM_DUMP)
+    {
+      saved_print_handlers = (void **) vec_dup (am->msg_print_handlers);
+      vl_msg_api_custom_dump_configure (am);
     }
 
 
-    msg = (u8 *)(hp+1);
-    
-    for (i = 0; i < first_index; i++) {
-        trace_cfg_t *cfgp;
-        int size;
-        u16 msg_id;
-        
-        if (clib_arch_is_little_endian)
-            msg_id = ntohs(*((u16 *)msg));
-        else
-            msg_id = *((u16 *)msg);
-        
-        cfgp = am->api_trace_cfg + msg_id;
-        if (!cfgp) {
-            vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
-            return;
-        }
-        size = cfgp->size;
-        msg += size;
+  msg = (u8 *) (hp + 1);
+
+  for (i = 0; i < first_index; i++)
+    {
+      trace_cfg_t *cfgp;
+      int size;
+      u16 msg_id;
+
+      if (clib_arch_is_little_endian)
+	msg_id = ntohs (*((u16 *) msg));
+      else
+	msg_id = *((u16 *) msg);
+
+      cfgp = am->api_trace_cfg + msg_id;
+      if (!cfgp)
+	{
+	  vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
+	  return;
+	}
+      size = cfgp->size;
+      msg += size;
     }
-    
-    for (; i <= last_index; i++) {
-        trace_cfg_t *cfgp;
-        u16 *msg_idp;
-        u16 msg_id;
-        int size;
-        
-        if (which == DUMP)
-            vlib_cli_output (vm, "---------- trace %d -----------\n", i);
-
-        if (clib_arch_is_little_endian)
-            msg_id = ntohs(*((u16 *)msg));
-        else
-            msg_id = *((u16 *)msg);
-        
-        cfgp = am->api_trace_cfg + msg_id;
-        if (!cfgp) {
-            vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
-            return;
-        }
-        size = cfgp->size;
-
-        /* Copy the buffer (from the read-only mmap'ed file) */
-        vec_validate (tmpbuf, size-1 + sizeof(uword));
-        clib_memcpy (tmpbuf+sizeof(uword), msg, size);
-        memset (tmpbuf, 0xf, sizeof(uword));
-
-        /* 
-         * Endian swap if needed. All msg data is supposed to be 
-         * in network byte order. All msg handlers are supposed to
-         * know that. The generic message dumpers don't know that.
-         * One could fix apigen, I suppose.
-         */
-        if ((which == DUMP && clib_arch_is_little_endian) 
-            || endian_swap_needed) {
-            void (*endian_fp)(void *);
-            if (msg_id >= vec_len (am->msg_endian_handlers)
-                || (am->msg_endian_handlers[msg_id] == 0)) {
-                vlib_cli_output (vm, "Ugh: msg id %d no endian swap\n", msg_id);
-                return;
-            }
-            endian_fp = am->msg_endian_handlers[msg_id];
-            (*endian_fp)(tmpbuf+sizeof(uword));
-        }
-
-        /* msg_id always in network byte order */
-        if (clib_arch_is_little_endian) {
-            msg_idp = (u16 *)(tmpbuf+sizeof(uword));
-            *msg_idp = msg_id;
-        }
-
-        switch (which) {
-        case CUSTOM_DUMP:
-        case DUMP:
-            if (msg_id < vec_len(am->msg_print_handlers) &&
-                am->msg_print_handlers [msg_id]) {
-                u8 *(*print_fp)(void *, void *);
-                
-                print_fp = (void *)am->msg_print_handlers[msg_id];
-                (*print_fp)(tmpbuf+sizeof(uword), vm);
-            } else {
-                vlib_cli_output (vm, "Skipping msg id %d: no print fcn\n",
-                                 msg_id);
-                break;
-            }
-            break;
-
-        case INITIALIZERS:
-            if (msg_id < vec_len(am->msg_print_handlers) &&
-                am->msg_print_handlers [msg_id]) {
-                u8 * s;
-                int j;
-                u8 *(*print_fp)(void *, void *);
-
-                print_fp = (void *)am->msg_print_handlers[msg_id];
-                
-                vlib_cli_output (vm, "/*");
-                
-                (*print_fp)(tmpbuf+sizeof(uword), vm);
-                vlib_cli_output (vm, "*/\n");
-                
-                s = format (0, "static u8 * vl_api_%s_%d[%d] = {",
-                            am->msg_names[msg_id], i, 
-                            am->api_trace_cfg[msg_id].size);
-                
-                for (j = 0; j < am->api_trace_cfg[msg_id].size; j++) {
-                    if ((j & 7) == 0)
-                        s = format (s, "\n    ");    
-                    s = format (s, "0x%02x,", tmpbuf[sizeof(uword)+j]);
-                }
-                s = format (s, "\n};\n%c", 0);
-                vlib_cli_output (vm, (char *)s);
-                vec_free(s);
-            }
-            break;
-                
-        case REPLAY:
-            if (msg_id < vec_len(am->msg_print_handlers) &&
-                am->msg_print_handlers [msg_id] && cfgp->replay_enable) {
-                void (*handler)(void *);
-                
-                handler = (void *)am->msg_handlers[msg_id];
-
-                if (!am->is_mp_safe[msg_id])
-                    vl_msg_api_barrier_sync();
-                (*handler)(tmpbuf+sizeof(uword));
-                if (!am->is_mp_safe[msg_id])
-                    vl_msg_api_barrier_release();
-            } else {
-                if (cfgp->replay_enable)
-                    vlib_cli_output (vm, "Skipping msg id %d: no handler\n",
-                                     msg_id);
-                break;
-            }
-            break;
-        }
-
-        _vec_len(tmpbuf) = 0;
-        msg += size;
+
+  for (; i <= last_index; i++)
+    {
+      trace_cfg_t *cfgp;
+      u16 *msg_idp;
+      u16 msg_id;
+      int size;
+
+      if (which == DUMP)
+	vlib_cli_output (vm, "---------- trace %d -----------\n", i);
+
+      if (clib_arch_is_little_endian)
+	msg_id = ntohs (*((u16 *) msg));
+      else
+	msg_id = *((u16 *) msg);
+
+      cfgp = am->api_trace_cfg + msg_id;
+      if (!cfgp)
+	{
+	  vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
+	  return;
+	}
+      size = cfgp->size;
+
+      /* Copy the buffer (from the read-only mmap'ed file) */
+      vec_validate (tmpbuf, size - 1 + sizeof (uword));
+      clib_memcpy (tmpbuf + sizeof (uword), msg, size);
+      memset (tmpbuf, 0xf, sizeof (uword));
+
+      /*
+       * Endian swap if needed. All msg data is supposed to be
+       * in network byte order. All msg handlers are supposed to
+       * know that. The generic message dumpers don't know that.
+       * One could fix apigen, I suppose.
+       */
+      if ((which == DUMP && clib_arch_is_little_endian) || endian_swap_needed)
+	{
+	  void (*endian_fp) (void *);
+	  if (msg_id >= vec_len (am->msg_endian_handlers)
+	      || (am->msg_endian_handlers[msg_id] == 0))
+	    {
+	      vlib_cli_output (vm, "Ugh: msg id %d no endian swap\n", msg_id);
+	      return;
+	    }
+	  endian_fp = am->msg_endian_handlers[msg_id];
+	  (*endian_fp) (tmpbuf + sizeof (uword));
+	}
+
+      /* msg_id always in network byte order */
+      if (clib_arch_is_little_endian)
+	{
+	  msg_idp = (u16 *) (tmpbuf + sizeof (uword));
+	  *msg_idp = msg_id;
+	}
+
+      switch (which)
+	{
+	case CUSTOM_DUMP:
+	case DUMP:
+	  if (msg_id < vec_len (am->msg_print_handlers) &&
+	      am->msg_print_handlers[msg_id])
+	    {
+	      u8 *(*print_fp) (void *, void *);
+
+	      print_fp = (void *) am->msg_print_handlers[msg_id];
+	      (*print_fp) (tmpbuf + sizeof (uword), vm);
+	    }
+	  else
+	    {
+	      vlib_cli_output (vm, "Skipping msg id %d: no print fcn\n",
+			       msg_id);
+	      break;
+	    }
+	  break;
+
+	case INITIALIZERS:
+	  if (msg_id < vec_len (am->msg_print_handlers) &&
+	      am->msg_print_handlers[msg_id])
+	    {
+	      u8 *s;
+	      int j;
+	      u8 *(*print_fp) (void *, void *);
+
+	      print_fp = (void *) am->msg_print_handlers[msg_id];
+
+	      vlib_cli_output (vm, "/*");
+
+	      (*print_fp) (tmpbuf + sizeof (uword), vm);
+	      vlib_cli_output (vm, "*/\n");
+
+	      s = format (0, "static u8 * vl_api_%s_%d[%d] = {",
+			  am->msg_names[msg_id], i,
+			  am->api_trace_cfg[msg_id].size);
+
+	      for (j = 0; j < am->api_trace_cfg[msg_id].size; j++)
+		{
+		  if ((j & 7) == 0)
+		    s = format (s, "\n    ");
+		  s = format (s, "0x%02x,", tmpbuf[sizeof (uword) + j]);
+		}
+	      s = format (s, "\n};\n%c", 0);
+	      vlib_cli_output (vm, (char *) s);
+	      vec_free (s);
+	    }
+	  break;
+
+	case REPLAY:
+	  if (msg_id < vec_len (am->msg_print_handlers) &&
+	      am->msg_print_handlers[msg_id] && cfgp->replay_enable)
+	    {
+	      void (*handler) (void *);
+
+	      handler = (void *) am->msg_handlers[msg_id];
+
+	      if (!am->is_mp_safe[msg_id])
+		vl_msg_api_barrier_sync ();
+	      (*handler) (tmpbuf + sizeof (uword));
+	      if (!am->is_mp_safe[msg_id])
+		vl_msg_api_barrier_release ();
+	    }
+	  else
+	    {
+	      if (cfgp->replay_enable)
+		vlib_cli_output (vm, "Skipping msg id %d: no handler\n",
+				 msg_id);
+	      break;
+	    }
+	  break;
+	}
+
+      _vec_len (tmpbuf) = 0;
+      msg += size;
     }
-    
-    if (saved_print_handlers) {
-        clib_memcpy (am->msg_print_handlers, saved_print_handlers, 
-                vec_len(am->msg_print_handlers) * sizeof (void *));
-        vec_free (saved_print_handlers);
+
+  if (saved_print_handlers)
+    {
+      clib_memcpy (am->msg_print_handlers, saved_print_handlers,
+		   vec_len (am->msg_print_handlers) * sizeof (void *));
+      vec_free (saved_print_handlers);
     }
 
-    munmap (hp, file_size);
+  munmap (hp, file_size);
 }
 
-u8 * format_vl_msg_api_trace_status (u8 * s, va_list * args)
+u8 *
+format_vl_msg_api_trace_status (u8 * s, va_list * args)
 {
-    api_main_t * am = va_arg (*args, api_main_t *);
-    vl_api_trace_which_t which = va_arg (*args, vl_api_trace_which_t);
-    vl_api_trace_t *tp;
-    char *trace_name;
+  api_main_t *am = va_arg (*args, api_main_t *);
+  vl_api_trace_which_t which = va_arg (*args, vl_api_trace_which_t);
+  vl_api_trace_t *tp;
+  char *trace_name;
 
-    switch(which)
+  switch (which)
     {
     case VL_API_TRACE_TX:
-        tp = am->tx_trace;
-        trace_name = "TX trace";
-        break;
-        
+      tp = am->tx_trace;
+      trace_name = "TX trace";
+      break;
+
     case VL_API_TRACE_RX:
-        tp = am->rx_trace;
-        trace_name = "RX trace";
-        break;
+      tp = am->rx_trace;
+      trace_name = "RX trace";
+      break;
 
     default:
-        abort();
+      abort ();
     }
 
-    if (tp == 0) {
-        s = format (s, "%s: not yet configured.\n", trace_name);
-        return s;
+  if (tp == 0)
+    {
+      s = format (s, "%s: not yet configured.\n", trace_name);
+      return s;
     }
 
-    s = format (s, "%s: used %d of %d items, %s enabled, %s wrapped\n",
-                trace_name, vec_len (tp->traces), tp->nitems, 
-                tp->enabled ? "is" : "is not",
-                tp->wrapped ? "has" : "has not");
-    return s;
+  s = format (s, "%s: used %d of %d items, %s enabled, %s wrapped\n",
+	      trace_name, vec_len (tp->traces), tp->nitems,
+	      tp->enabled ? "is" : "is not", tp->wrapped ? "has" : "has not");
+  return s;
 }
 
 static u8 post_mortem_dump_enabled;
 
 static clib_error_t *
 api_trace_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 nitems = 256<<10;
-    api_main_t * am = &api_main;
-    vl_api_trace_which_t which = VL_API_TRACE_RX;
-    u8 *filename;
-    u32 first = 0;
-    u32 last = (u32)~0;
-    FILE *fp;
-    int rv;
-
-    while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
-        if (unformat (input, "on") || unformat (input, "enable")) {
-            if (unformat (input, "nitems %d", &nitems))
-                ;
-            vl_msg_api_trace_configure (am, which, nitems);
-            vl_msg_api_trace_onoff (am, which, 1 /* on */);
-        } else if (unformat (input, "off")) {
-            vl_msg_api_trace_onoff (am, which, 0);
-        } else if (unformat (input, "save %s", &filename)) {
-            u8 * chroot_filename;
-            if (strstr((char *)filename, "..") 
-                || index((char *)filename, '/'))
-            {
-                vlib_cli_output (vm, "illegal characters in filename '%s'", 
-                                 filename);
-                return 0;
-            }
-
-            chroot_filename = format (0, "/tmp/%s%c", filename, 0);
-
-            vec_free(filename);
-            
-            fp = fopen ((char *)chroot_filename, "w");
-            if (fp == NULL) {
-                vlib_cli_output (vm, "Couldn't create %s\n", chroot_filename);
-                return 0;
-            }
-            rv = vl_msg_api_trace_save (am, which, fp);
-            fclose (fp);
-            if (rv < 0)
-                vlib_cli_output (vm, "ERROR: %d", rv);
-            else
-                vlib_cli_output (vm, "API trace saved to %s\n", 
-                                 chroot_filename);
-            vec_free (chroot_filename);
-        } else if (unformat (input, "dump %s", &filename)) {
-            vl_msg_api_process_file (vm, filename, first, last, DUMP);
-        } else if (unformat (input, "custom-dump %s", &filename)) {
-            vl_msg_api_process_file (vm, filename, first, last, CUSTOM_DUMP);
-        } else if (unformat (input, "replay %s", &filename)) {
-            vl_msg_api_process_file (vm, filename, first, last, REPLAY);
-        } else if (unformat (input, "initializers %s", &filename)) {
-            vl_msg_api_process_file (vm, filename, first, last, INITIALIZERS);
-        } else if (unformat (input, "tx")) {
-            which = VL_API_TRACE_TX;
-        } else if (unformat (input, "first %d", &first)) {
-            ;
-        } else if (unformat (input, "last %d", &last)) {
-            ;
-        } else if (unformat (input, "status")) {
-            vlib_cli_output (vm, "%U", format_vl_msg_api_trace_status,
-                             am, which);
-        } else if (unformat (input, "free")) {
-            vl_msg_api_trace_onoff (am, which, 0);
-            vl_msg_api_trace_free (am, which);
-        } else if (unformat (input, "post-mortem-on"))
-            post_mortem_dump_enabled = 1;
-        else if (unformat (input, "post-mortem-off"))        
-            post_mortem_dump_enabled = 0;
-        else
-            return clib_error_return (0, "unknown input `%U'",
-                                      format_unformat_error, input);
+  u32 nitems = 256 << 10;
+  api_main_t *am = &api_main;
+  vl_api_trace_which_t which = VL_API_TRACE_RX;
+  u8 *filename;
+  u32 first = 0;
+  u32 last = (u32) ~ 0;
+  FILE *fp;
+  int rv;
+
+  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (input, "on") || unformat (input, "enable"))
+	{
+	  if (unformat (input, "nitems %d", &nitems))
+	    ;
+	  vl_msg_api_trace_configure (am, which, nitems);
+	  vl_msg_api_trace_onoff (am, which, 1 /* on */ );
+	}
+      else if (unformat (input, "off"))
+	{
+	  vl_msg_api_trace_onoff (am, which, 0);
+	}
+      else if (unformat (input, "save %s", &filename))
+	{
+	  u8 *chroot_filename;
+	  if (strstr ((char *) filename, "..")
+	      || index ((char *) filename, '/'))
+	    {
+	      vlib_cli_output (vm, "illegal characters in filename '%s'",
+			       filename);
+	      return 0;
+	    }
+
+	  chroot_filename = format (0, "/tmp/%s%c", filename, 0);
+
+	  vec_free (filename);
+
+	  fp = fopen ((char *) chroot_filename, "w");
+	  if (fp == NULL)
+	    {
+	      vlib_cli_output (vm, "Couldn't create %s\n", chroot_filename);
+	      return 0;
+	    }
+	  rv = vl_msg_api_trace_save (am, which, fp);
+	  fclose (fp);
+	  if (rv < 0)
+	    vlib_cli_output (vm, "ERROR: %d", rv);
+	  else
+	    vlib_cli_output (vm, "API trace saved to %s\n", chroot_filename);
+	  vec_free (chroot_filename);
+	}
+      else if (unformat (input, "dump %s", &filename))
+	{
+	  vl_msg_api_process_file (vm, filename, first, last, DUMP);
+	}
+      else if (unformat (input, "custom-dump %s", &filename))
+	{
+	  vl_msg_api_process_file (vm, filename, first, last, CUSTOM_DUMP);
+	}
+      else if (unformat (input, "replay %s", &filename))
+	{
+	  vl_msg_api_process_file (vm, filename, first, last, REPLAY);
+	}
+      else if (unformat (input, "initializers %s", &filename))
+	{
+	  vl_msg_api_process_file (vm, filename, first, last, INITIALIZERS);
+	}
+      else if (unformat (input, "tx"))
+	{
+	  which = VL_API_TRACE_TX;
+	}
+      else if (unformat (input, "first %d", &first))
+	{
+	  ;
+	}
+      else if (unformat (input, "last %d", &last))
+	{
+	  ;
+	}
+      else if (unformat (input, "status"))
+	{
+	  vlib_cli_output (vm, "%U", format_vl_msg_api_trace_status,
+			   am, which);
+	}
+      else if (unformat (input, "free"))
+	{
+	  vl_msg_api_trace_onoff (am, which, 0);
+	  vl_msg_api_trace_free (am, which);
+	}
+      else if (unformat (input, "post-mortem-on"))
+	post_mortem_dump_enabled = 1;
+      else if (unformat (input, "post-mortem-off"))
+	post_mortem_dump_enabled = 0;
+      else
+	return clib_error_return (0, "unknown input `%U'",
+				  format_unformat_error, input);
     }
-    return 0;
+  return 0;
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (api_trace_command, static) = {
     .path = "api trace",
-    .short_help = 
+    .short_help =
     "api trace [on|off][dump|save|replay <file>][status][free][post-mortem-on]",
     .function = api_trace_command_fn,
 };
+/* *INDENT-ON* */
 
 static clib_error_t *
 api_config_fn (vlib_main_t * vm, unformat_input_t * input)
 {
-    u32 nitems = 256<<10;
-    vl_api_trace_which_t which = VL_API_TRACE_RX;
-    api_main_t * am = &api_main;
-
-    while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
-        if (unformat (input, "on") || unformat (input, "enable")) {
-            if (unformat (input, "nitems %d", &nitems))
-                ;
-            vl_msg_api_trace_configure (am, which, nitems);
-            vl_msg_api_trace_onoff (am, which, 1 /* on */);
-            post_mortem_dump_enabled = 1;
-        } else
-            return clib_error_return (0, "unknown input `%U'",
-                                      format_unformat_error, input);
+  u32 nitems = 256 << 10;
+  vl_api_trace_which_t which = VL_API_TRACE_RX;
+  api_main_t *am = &api_main;
+
+  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (input, "on") || unformat (input, "enable"))
+	{
+	  if (unformat (input, "nitems %d", &nitems))
+	    ;
+	  vl_msg_api_trace_configure (am, which, nitems);
+	  vl_msg_api_trace_onoff (am, which, 1 /* on */ );
+	  post_mortem_dump_enabled = 1;
+	}
+      else
+	return clib_error_return (0, "unknown input `%U'",
+				  format_unformat_error, input);
     }
-    return 0;
+  return 0;
 }
 
 VLIB_CONFIG_FUNCTION (api_config_fn, "api-trace");
 
-void vl_msg_api_post_mortem_dump (void)
+void
+vl_msg_api_post_mortem_dump (void)
 {
-    api_main_t * am = &api_main;
-    FILE *fp;
-    char filename[64];
-    int rv;
-
-    if (post_mortem_dump_enabled == 0)
-        return;
-
-    snprintf (filename, sizeof(filename), "/tmp/api_post_mortem.%d",
-              getpid());
-
-    fp = fopen (filename, "w");
-    if (fp == NULL) {
-        rv = write (2, "Couldn't create ", 16);
-        rv = write (2, filename, strlen(filename));
-        rv = write (2, "\n", 1);
-        return;
+  api_main_t *am = &api_main;
+  FILE *fp;
+  char filename[64];
+  int rv;
+
+  if (post_mortem_dump_enabled == 0)
+    return;
+
+  snprintf (filename, sizeof (filename), "/tmp/api_post_mortem.%d",
+	    getpid ());
+
+  fp = fopen (filename, "w");
+  if (fp == NULL)
+    {
+      rv = write (2, "Couldn't create ", 16);
+      rv = write (2, filename, strlen (filename));
+      rv = write (2, "\n", 1);
+      return;
     }
-    rv = vl_msg_api_trace_save (am, VL_API_TRACE_RX, fp);
-    fclose (fp);
-    if (rv < 0) {
-        rv = write (2, "Failed to save post-mortem API trace to ", 40);
-        rv = write (2, filename, strlen(filename));
-        rv = write (2, "\n", 1);
+  rv = vl_msg_api_trace_save (am, VL_API_TRACE_RX, fp);
+  fclose (fp);
+  if (rv < 0)
+    {
+      rv = write (2, "Failed to save post-mortem API trace to ", 40);
+      rv = write (2, filename, strlen (filename));
+      rv = write (2, "\n", 1);
     }
-    
+
 }
 
 /* Layered message handling support */
 
-void vl_msg_api_register_pd_handler (void *fp, u16 msg_id_host_byte_order)
+void
+vl_msg_api_register_pd_handler (void *fp, u16 msg_id_host_byte_order)
 {
-    api_main_t * am = &api_main;
-
-    /* Mild idiot proofing */
-    if (msg_id_host_byte_order > 10000)
-        clib_warning ("msg_id_host_byte_order endian issue? %d arg vs %d",
-                      msg_id_host_byte_order, 
-                      clib_net_to_host_u16 (msg_id_host_byte_order));
-    vec_validate (am->pd_msg_handlers, msg_id_host_byte_order);
-    am->pd_msg_handlers[msg_id_host_byte_order] = fp;
+  api_main_t *am = &api_main;
+
+  /* Mild idiot proofing */
+  if (msg_id_host_byte_order > 10000)
+    clib_warning ("msg_id_host_byte_order endian issue? %d arg vs %d",
+		  msg_id_host_byte_order,
+		  clib_net_to_host_u16 (msg_id_host_byte_order));
+  vec_validate (am->pd_msg_handlers, msg_id_host_byte_order);
+  am->pd_msg_handlers[msg_id_host_byte_order] = fp;
 }
 
-int vl_msg_api_pd_handler (void *mp, int rv)
+int
+vl_msg_api_pd_handler (void *mp, int rv)
 {
-    api_main_t * am = &api_main;
-    int (*fp)(void *, int);
-    u16 msg_id;
+  api_main_t *am = &api_main;
+  int (*fp) (void *, int);
+  u16 msg_id;
 
-    if (clib_arch_is_little_endian)
-        msg_id = clib_net_to_host_u16(*((u16 *)mp));
-    else
-        msg_id = *((u16 *)mp);
-    
-    if (msg_id >= vec_len (am->pd_msg_handlers)
-        || am->pd_msg_handlers[msg_id] == 0)
-        return rv;
-
-    fp = am->pd_msg_handlers [msg_id];
-    rv = (*fp)(mp, rv);
+  if (clib_arch_is_little_endian)
+    msg_id = clib_net_to_host_u16 (*((u16 *) mp));
+  else
+    msg_id = *((u16 *) mp);
+
+  if (msg_id >= vec_len (am->pd_msg_handlers)
+      || am->pd_msg_handlers[msg_id] == 0)
     return rv;
+
+  fp = am->pd_msg_handlers[msg_id];
+  rv = (*fp) (mp, rv);
+  return rv;
 }
 
-void vl_msg_api_set_first_available_msg_id (u16 first_avail)
+void
+vl_msg_api_set_first_available_msg_id (u16 first_avail)
 {
-    api_main_t * am = &api_main;
-    
-    am->first_available_msg_id = first_avail;
+  api_main_t *am = &api_main;
+
+  am->first_available_msg_id = first_avail;
 }
 
-u16 vl_msg_api_get_msg_ids (char * name, int n)
+u16
+vl_msg_api_get_msg_ids (char *name, int n)
 {
-    api_main_t * am = &api_main;
-    u8 * name_copy;
-    vl_api_msg_range_t * rp;
-    uword * p;
-    u16 rv;
-
-    if (am->msg_range_by_name == 0)
-        am->msg_range_by_name = hash_create_string (0, sizeof(uword));
-
-    name_copy = format (0, "%s%c", name, 0);
-    
-    p = hash_get_mem (am->msg_range_by_name, name_copy);
-    if (p) {
-        clib_warning ("WARNING: duplicate message range registration for '%s'",
-                      name_copy);
-        vec_free(name_copy);
-        return ((u16) ~0);
+  api_main_t *am = &api_main;
+  u8 *name_copy;
+  vl_api_msg_range_t *rp;
+  uword *p;
+  u16 rv;
+
+  if (am->msg_range_by_name == 0)
+    am->msg_range_by_name = hash_create_string (0, sizeof (uword));
+
+  name_copy = format (0, "%s%c", name, 0);
+
+  p = hash_get_mem (am->msg_range_by_name, name_copy);
+  if (p)
+    {
+      clib_warning ("WARNING: duplicate message range registration for '%s'",
+		    name_copy);
+      vec_free (name_copy);
+      return ((u16) ~ 0);
     }
 
-    if (n < 0 || n > 1024) {
-        clib_warning 
-            ("WARNING: bad number of message-IDs (%d) requested by '%s'",
-             n, name_copy);
-        vec_free(name_copy);
-        return ((u16) ~0);
+  if (n < 0 || n > 1024)
+    {
+      clib_warning
+	("WARNING: bad number of message-IDs (%d) requested by '%s'",
+	 n, name_copy);
+      vec_free (name_copy);
+      return ((u16) ~ 0);
     }
 
-    vec_add2 (am->msg_ranges, rp, 1);
+  vec_add2 (am->msg_ranges, rp, 1);
 
-    rv = rp->first_msg_id = am->first_available_msg_id;
-    am->first_available_msg_id += n;
-    rp->last_msg_id = am->first_available_msg_id - 1;
-    rp->name = name_copy;
+  rv = rp->first_msg_id = am->first_available_msg_id;
+  am->first_available_msg_id += n;
+  rp->last_msg_id = am->first_available_msg_id - 1;
+  rp->name = name_copy;
 
-    hash_set_mem (am->msg_range_by_name, name_copy, rp - am->msg_ranges);
+  hash_set_mem (am->msg_range_by_name, name_copy, rp - am->msg_ranges);
 
-    return rv;
+  return rv;
 }
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/vlib-api/vlibapi/node_serialize.c b/vlib-api/vlibapi/node_serialize.c
index 907ed4cdf8b..5eb530264e0 100644
--- a/vlib-api/vlibapi/node_serialize.c
+++ b/vlib-api/vlibapi/node_serialize.c
@@ -16,8 +16,8 @@
 
 #include <vppinfra/serialize.h>
 
-extern void vl_msg_api_barrier_sync(void);
-extern void vl_msg_api_barrier_release(void);
+extern void vl_msg_api_barrier_sync (void);
+extern void vl_msg_api_barrier_release (void);
 
 /* serialized representation of state strings */
 
@@ -31,68 +31,68 @@ _(STATE_POLLING, "polling")                     \
 _(STATE_INTERRUPT_WAIT, "interrupt wait")       \
 _(STATE_INTERNAL, "internal")
 
-typedef enum {
+typedef enum
+{
 #define _(a,b) a,
   foreach_state_string_code
 #undef _
 } state_string_enum_t;
 
-static char *state_strings[] = 
-  {
+static char *state_strings[] = {
 #define _(a,b) b,
-    foreach_state_string_code
+  foreach_state_string_code
 #undef _
-  };
+};
 
-/* 
+/*
  * Serialize a vlib_node_main_t. Appends the result to vector.
  * Pass 0 to create a new vector, use vec_reset_length(vector)
  * to recycle a vector / avoid memory allocation, etc.
  * Switch heaps before/after to serialize into API client shared memory.
  */
 
-u8 * vlib_node_serialize (vlib_node_main_t *nm, u8 * vector,
-                          u32 max_threads, int include_nexts, 
-                          int include_stats)
+u8 *
+vlib_node_serialize (vlib_node_main_t * nm, u8 * vector,
+		     u32 max_threads, int include_nexts, int include_stats)
 {
-  serialize_main_t _sm, *sm=&_sm;
-  vlib_main_t * vm = vlib_get_main();
-  vlib_node_t * n;
-  static vlib_node_t *** node_dups;
-  vlib_node_t ** nodes;
-  static vlib_main_t ** stat_vms;
+  serialize_main_t _sm, *sm = &_sm;
+  vlib_main_t *vm = vlib_get_main ();
+  vlib_node_t *n;
+  static vlib_node_t ***node_dups;
+  vlib_node_t **nodes;
+  static vlib_main_t **stat_vms;
   vlib_main_t *stat_vm;
-  u8 * namep;
+  u8 *namep;
   u32 name_bytes;
   uword i, j, k;
   u64 l, v, c, d;
   state_string_enum_t state_code;
   u32 threads_to_serialize;
-  
-  vec_reset_length(node_dups);
 
-  if (vec_len(stat_vms) == 0)
+  vec_reset_length (node_dups);
+
+  if (vec_len (stat_vms) == 0)
     {
-      if (vec_len(vlib_mains) == 0)
-        vec_add1 (stat_vms, vm);
+      if (vec_len (vlib_mains) == 0)
+	vec_add1 (stat_vms, vm);
       else
-        {
-          for (i = 0; i < vec_len (vlib_mains); i++)
-            {
-              stat_vm = vlib_mains[i];
-              if (stat_vm)
-                vec_add1 (stat_vms, stat_vm);
-            }
-        }
+	{
+	  for (i = 0; i < vec_len (vlib_mains); i++)
+	    {
+	      stat_vm = vlib_mains[i];
+	      if (stat_vm)
+		vec_add1 (stat_vms, stat_vm);
+	    }
+	}
     }
 
   threads_to_serialize = clib_min (max_threads, vec_len (stat_vms));
 
-  /* 
+  /*
    * Barrier sync across stats scraping.
    * Otherwise, the counts will be grossly inaccurate.
    */
-  vl_msg_api_barrier_sync();
+  vl_msg_api_barrier_sync ();
 
   for (j = 0; j < threads_to_serialize; j++)
     {
@@ -100,134 +100,135 @@ u8 * vlib_node_serialize (vlib_node_main_t *nm, u8 * vector,
       nm = &stat_vm->node_main;
 
       if (include_stats)
-      {
-          for (i = 0; i < vec_len (nm->nodes); i++)
-          {
-              n = nm->nodes[i];
-              vlib_node_sync_stats (stat_vm, n);
-          }
-      }
+	{
+	  for (i = 0; i < vec_len (nm->nodes); i++)
+	    {
+	      n = nm->nodes[i];
+	      vlib_node_sync_stats (stat_vm, n);
+	    }
+	}
 
       nodes = vec_dup (nm->nodes);
-      
-      vec_add1(node_dups, nodes);
+
+      vec_add1 (node_dups, nodes);
     }
-  vl_msg_api_barrier_release();
-  
+  vl_msg_api_barrier_release ();
+
   serialize_open_vector (sm, vector);
 
-  serialize_likely_small_unsigned_integer (sm, vec_len(stat_vms));
-  
+  serialize_likely_small_unsigned_integer (sm, vec_len (stat_vms));
+
   for (j = 0; j < vec_len (stat_vms); j++)
     {
       stat_vm = stat_vms[j];
       nodes = node_dups[j];
 
-      serialize_likely_small_unsigned_integer (sm, vec_len(nodes));
+      serialize_likely_small_unsigned_integer (sm, vec_len (nodes));
 
       for (i = 0; i < vec_len (nodes); i++)
-        {
-          n = nodes[i];
-
-          l = n->stats_total.clocks - n->stats_last_clear.clocks;
-          v = n->stats_total.vectors - n->stats_last_clear.vectors;
-          c = n->stats_total.calls - n->stats_last_clear.calls;
-          d = n->stats_total.suspends 
-            - n->stats_last_clear.suspends;
-
-          state_code = STATE_INTERNAL;
-
-          if (n->type == VLIB_NODE_TYPE_PROCESS)
-            {
-              vlib_process_t * p = vlib_get_process_from_node (vm, n);
-
-              switch (p->flags 
-                      & (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
-                         | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT))
-                {
-                default:
-                  if (! (p->flags & VLIB_PROCESS_IS_RUNNING))
-                    state_code = STATE_DONE;
-                  break;
-                      
-                case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK:
-                  state_code = STATE_TIME_WAIT;
-                  break;
-
-                case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT:
-                  state_code = STATE_EVENT_WAIT;
-                  break;
-                      
-                case (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT
-                      | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK):
-                  state_code = STATE_ANY_WAIT;
-                  break;
-                }
-            }      
-          else if (n->type != VLIB_NODE_TYPE_INTERNAL)
-            {
-              state_code = STATE_POLLING;
-              if (n->state == VLIB_NODE_STATE_DISABLED)
-                state_code = STATE_DISABLED;
-              else if (n->state == VLIB_NODE_STATE_INTERRUPT)
-                state_code = STATE_INTERRUPT_WAIT;
-            }
-
-          /* See unserialize_cstring */
-          name_bytes = vec_len (n->name);
-          serialize_likely_small_unsigned_integer(sm, name_bytes);
-          namep = serialize_get (sm, name_bytes);
-          memcpy (namep, n->name, name_bytes);
-
-          serialize_likely_small_unsigned_integer (sm, (u64)state_code);
-          serialize_likely_small_unsigned_integer (sm, n->type);
-
-          if (include_nexts)
-            {
-              serialize_likely_small_unsigned_integer 
-                (sm, vec_len(n->next_nodes));
-              for (k = 0; k < vec_len (n->next_nodes); k++)
-                serialize_likely_small_unsigned_integer (sm, n->next_nodes[k]);
-            }
-          else
-            serialize_likely_small_unsigned_integer (sm, 0);
-  
-          if (include_stats)
-            {
-              /* stats present */
-              serialize_likely_small_unsigned_integer (sm, 1);
-              /* total clocks */
-              serialize_integer(sm, l, 8);
-              /* Total calls */
-              serialize_integer(sm, c, 8);
-              /* Total vectors */
-              serialize_integer(sm, v, 8);
-              /* Total suspends */
-              serialize_integer(sm, d, 8);
-            }
-          else /* no stats */
-            serialize_likely_small_unsigned_integer (sm, 0);
-        }
+	{
+	  n = nodes[i];
+
+	  l = n->stats_total.clocks - n->stats_last_clear.clocks;
+	  v = n->stats_total.vectors - n->stats_last_clear.vectors;
+	  c = n->stats_total.calls - n->stats_last_clear.calls;
+	  d = n->stats_total.suspends - n->stats_last_clear.suspends;
+
+	  state_code = STATE_INTERNAL;
+
+	  if (n->type == VLIB_NODE_TYPE_PROCESS)
+	    {
+	      vlib_process_t *p = vlib_get_process_from_node (vm, n);
+
+	      switch (p->flags
+		      & (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
+			 | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT))
+		{
+		default:
+		  if (!(p->flags & VLIB_PROCESS_IS_RUNNING))
+		    state_code = STATE_DONE;
+		  break;
+
+		case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK:
+		  state_code = STATE_TIME_WAIT;
+		  break;
+
+		case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT:
+		  state_code = STATE_EVENT_WAIT;
+		  break;
+
+		case (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK):
+		  state_code =
+		    STATE_ANY_WAIT;
+		  break;
+		}
+	    }
+	  else if (n->type != VLIB_NODE_TYPE_INTERNAL)
+	    {
+	      state_code = STATE_POLLING;
+	      if (n->state == VLIB_NODE_STATE_DISABLED)
+		state_code = STATE_DISABLED;
+	      else if (n->state == VLIB_NODE_STATE_INTERRUPT)
+		state_code = STATE_INTERRUPT_WAIT;
+	    }
+
+	  /* See unserialize_cstring */
+	  name_bytes = vec_len (n->name);
+	  serialize_likely_small_unsigned_integer (sm, name_bytes);
+	  namep = serialize_get (sm, name_bytes);
+	  memcpy (namep, n->name, name_bytes);
+
+	  serialize_likely_small_unsigned_integer (sm, (u64) state_code);
+	  serialize_likely_small_unsigned_integer (sm, n->type);
+
+	  if (include_nexts)
+	    {
+	      serialize_likely_small_unsigned_integer
+		(sm, vec_len (n->next_nodes));
+	      for (k = 0; k < vec_len (n->next_nodes); k++)
+		serialize_likely_small_unsigned_integer (sm,
+							 n->next_nodes[k]);
+	    }
+	  else
+	    serialize_likely_small_unsigned_integer (sm, 0);
+
+	  if (include_stats)
+	    {
+	      /* stats present */
+	      serialize_likely_small_unsigned_integer (sm, 1);
+	      /* total clocks */
+	      serialize_integer (sm, l, 8);
+	      /* Total calls */
+	      serialize_integer (sm, c, 8);
+	      /* Total vectors */
+	      serialize_integer (sm, v, 8);
+	      /* Total suspends */
+	      serialize_integer (sm, d, 8);
+	    }
+	  else			/* no stats */
+	    serialize_likely_small_unsigned_integer (sm, 0);
+	}
       vec_free (nodes);
     }
   return (serialize_close_vector (sm));
 }
 
-vlib_node_t *** vlib_node_unserialize (u8 * vector)
+vlib_node_t ***
+vlib_node_unserialize (u8 * vector)
 {
-  serialize_main_t _sm, *sm=&_sm;
+  serialize_main_t _sm, *sm = &_sm;
   u32 nnodes, nnexts;
   u32 nstat_vms;
-  vlib_node_t * node;
-  vlib_node_t ** nodes;
-  vlib_node_t *** nodes_by_thread = 0;
+  vlib_node_t *node;
+  vlib_node_t **nodes;
+  vlib_node_t ***nodes_by_thread = 0;
   int i, j, k;
   u64 l, v, c, d;
   state_string_enum_t state_code;
   int stats_present;
 
   serialize_open_vector (sm, vector);
-  
+
   nstat_vms = unserialize_likely_small_unsigned_integer (sm);
 
   vec_validate (nodes_by_thread, nstat_vms - 1);
@@ -238,85 +239,84 @@ vlib_node_t *** vlib_node_unserialize (u8 * vector)
       nnodes = unserialize_likely_small_unsigned_integer (sm);
 
       nodes = 0;
-      vec_validate (nodes, nnodes-1);
+      vec_validate (nodes, nnodes - 1);
       vec_add1 (nodes_by_thread, nodes);
 
       for (j = 0; j < nnodes; j++)
-        {
-          node = 0;
-          vec_validate (node,0);
-          nodes[j] = node;
-
-          unserialize_cstring (sm, (char **)&(node->name));
-          state_code = unserialize_likely_small_unsigned_integer (sm);
-          node->state_string = (u8 *) state_strings[state_code];
-
-          node->type = 
-            unserialize_likely_small_unsigned_integer (sm);
-          nnexts = unserialize_likely_small_unsigned_integer (sm);
-          if (nnexts > 0)
-            vec_validate (node->next_nodes, nnexts-1);
-          for (k = 0; k < nnexts; k++)
-            node->next_nodes[k] =
-                unserialize_likely_small_unsigned_integer (sm);
-
-          stats_present = unserialize_likely_small_unsigned_integer (sm);
-
-          if (stats_present)
-            {
-              /* total clocks */
-              unserialize_integer (sm, &l, 8);
-              node->stats_total.clocks = l;
-              node->stats_last_clear.clocks = 0;
-              
-              /* Total calls */
-              unserialize_integer (sm, &c, 8);
-              node->stats_total.calls = c;
-              
-              /* Total vectors */
-              unserialize_integer (sm, &v, 8);
-              node->stats_total.vectors = v;
-              
-              /* Total suspends */
-              unserialize_integer (sm, &d, 8);
-              node->stats_total.suspends = d;
-            }
-        }
+	{
+	  node = 0;
+	  vec_validate (node, 0);
+	  nodes[j] = node;
+
+	  unserialize_cstring (sm, (char **) &(node->name));
+	  state_code = unserialize_likely_small_unsigned_integer (sm);
+	  node->state_string = (u8 *) state_strings[state_code];
+
+	  node->type = unserialize_likely_small_unsigned_integer (sm);
+	  nnexts = unserialize_likely_small_unsigned_integer (sm);
+	  if (nnexts > 0)
+	    vec_validate (node->next_nodes, nnexts - 1);
+	  for (k = 0; k < nnexts; k++)
+	    node->next_nodes[k] =
+	      unserialize_likely_small_unsigned_integer (sm);
+
+	  stats_present = unserialize_likely_small_unsigned_integer (sm);
+
+	  if (stats_present)
+	    {
+	      /* total clocks */
+	      unserialize_integer (sm, &l, 8);
+	      node->stats_total.clocks = l;
+	      node->stats_last_clear.clocks = 0;
+
+	      /* Total calls */
+	      unserialize_integer (sm, &c, 8);
+	      node->stats_total.calls = c;
+
+	      /* Total vectors */
+	      unserialize_integer (sm, &v, 8);
+	      node->stats_total.vectors = v;
+
+	      /* Total suspends */
+	      unserialize_integer (sm, &d, 8);
+	      node->stats_total.suspends = d;
+	    }
+	}
     }
-  return nodes_by_thread;    
+  return nodes_by_thread;
 }
 
 #if CLIB_DEBUG > 0
 
 static clib_error_t *
 test_node_serialize_command_fn (vlib_main_t * vm,
-		 unformat_input_t * input,
-		 vlib_cli_command_t * cmd)
+				unformat_input_t * input,
+				vlib_cli_command_t * cmd)
 {
-  vlib_node_main_t * nm = &vm->node_main;
-  u8 * vector = 0;
-  vlib_node_t *** nodes_by_thread;
-  vlib_node_t ** nodes;
-  vlib_node_t * node;
-  vlib_node_t * next_node;
+  vlib_node_main_t *nm = &vm->node_main;
+  u8 *vector = 0;
+  vlib_node_t ***nodes_by_thread;
+  vlib_node_t **nodes;
+  vlib_node_t *node;
+  vlib_node_t *next_node;
   int i, j, k;
-  u32 max_threads = (u32) ~0;
+  u32 max_threads = (u32) ~ 0;
   int include_nexts = 0;
-  int include_stats = 0; 
+  int include_stats = 0;
 
-  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) 
+  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
       if (unformat (input, "max-threads %d", &max_threads))
-        ;
+	;
       else if (unformat (input, "stats"))
-        include_stats = 1;
+	include_stats = 1;
       else if (unformat (input, "nexts"))
-        include_nexts = 1;
+	include_nexts = 1;
       else
-        break;
+	break;
     }
 
-  /* 
+  /*
    * Keep the number of memcpy ops to a minimum (e.g. 1).
    * The current size of the serialized vector is
    * slightly under 4K.
@@ -324,65 +324,74 @@ test_node_serialize_command_fn (vlib_main_t * vm,
   vec_validate (vector, 16383);
   vec_reset_length (vector);
 
-  vector = vlib_node_serialize (nm, vector, max_threads, 
-                                include_nexts, include_stats);
+  vector = vlib_node_serialize (nm, vector, max_threads,
+				include_nexts, include_stats);
 
-  vlib_cli_output (vm, "result vector %d bytes", vec_len(vector));
+  vlib_cli_output (vm, "result vector %d bytes", vec_len (vector));
 
   nodes_by_thread = vlib_node_unserialize (vector);
 
   vec_free (vector);
-  
-  for (i = 0; i < vec_len(nodes_by_thread); i++) 
+
+  for (i = 0; i < vec_len (nodes_by_thread); i++)
     {
       nodes = nodes_by_thread[i];
 
       vlib_cli_output (vm, "thread %d", i);
 
-      for (j = 0; j < vec_len(nodes); j++)
-        {
-          node = nodes[j];
-
-          vlib_cli_output (vm, "[%d] %s state %s", j, node->name,
-                           node->state_string);
-
-          vlib_cli_output 
-            (vm, "    clocks %lld calls %lld suspends"
-             " %lld vectors %lld",
-             node->stats_total.clocks,
-             node->stats_total.calls,
-             node->stats_total.suspends,
-             node->stats_total.vectors);
-
-          for (k = 0; k < vec_len (node->next_nodes); k++)
-            {
-              if (node->next_nodes[k] != ~0)
-                next_node = nodes[node->next_nodes[k]];
-              vlib_cli_output (vm, "  [%d] %s", k, next_node->name);
-            }
-        }
-  }
-
-  for (j = 0; j < vec_len(nodes_by_thread); j++)
+      for (j = 0; j < vec_len (nodes); j++)
+	{
+	  node = nodes[j];
+
+	  vlib_cli_output (vm, "[%d] %s state %s", j, node->name,
+			   node->state_string);
+
+	  vlib_cli_output
+	    (vm, "    clocks %lld calls %lld suspends"
+	     " %lld vectors %lld",
+	     node->stats_total.clocks,
+	     node->stats_total.calls,
+	     node->stats_total.suspends, node->stats_total.vectors);
+
+	  for (k = 0; k < vec_len (node->next_nodes); k++)
+	    {
+	      if (node->next_nodes[k] != ~0)
+		next_node = nodes[node->next_nodes[k]];
+	      vlib_cli_output (vm, "  [%d] %s", k, next_node->name);
+	    }
+	}
+    }
+
+  for (j = 0; j < vec_len (nodes_by_thread); j++)
     {
       nodes = nodes_by_thread[j];
 
-      for (i = 0; i < vec_len(nodes); i++) 
-        {
-          vec_free (nodes[i]->name);
-          vec_free (nodes[i]->next_nodes);
-          vec_free (nodes[i]);
-        }
-      vec_free(nodes);
+      for (i = 0; i < vec_len (nodes); i++)
+	{
+	  vec_free (nodes[i]->name);
+	  vec_free (nodes[i]->next_nodes);
+	  vec_free (nodes[i]);
+	}
+      vec_free (nodes);
     }
   vec_free (nodes_by_thread);
 
   return 0;
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (test_node_serialize_node, static) = {
     .path = "test node serialize",
     .short_help = "test node serialize [max-threads NN] nexts stats",
     .function = test_node_serialize_command_fn,
 };
+/* *INDENT-ON* */
 #endif
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */