src/plugins/ct6/ct6.c - fdio/vpp - Gitiles

 /*
  * ct6.c - skeleton vpp engine plug-in
  *
  * Copyright (c) <current-year> <your-organization>
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <vnet/vnet.h>
 #include <vnet/plugin/plugin.h>
 #include <ct6/ct6.h>

 #include <vlibapi/api.h>
 #include <vlibmemory/api.h>
 #include <vpp/app/version.h>

 /* define message IDs */
 #include <ct6/ct6.api_enum.h>
 #include <ct6/ct6.api_types.h>

 #define REPLY_MSG_ID_BASE cmp->msg_id_base
 #include <vlibapi/api_helper_macros.h>

 ct6_main_t ct6_main;

 /* Action function shared between message handler and debug CLI */

 static void
 ct6_feature_init (ct6_main_t * cmp)
 {
   u32 nworkers = vlib_num_workers ();

   if (cmp->feature_initialized)
     return;

   clib_bihash_init_48_8 (&cmp->session_hash, "ct6 session table",
 			 cmp->session_hash_buckets, cmp->session_hash_memory);
   cmp->feature_initialized = 1;
   vec_validate (cmp->sessions, nworkers);
   vec_validate_init_empty (cmp->first_index, nworkers, ~0);
   vec_validate_init_empty (cmp->last_index, nworkers, ~0);
 }

 int
 ct6_in2out_enable_disable (ct6_main_t * cmp, u32 sw_if_index,
 			   int enable_disable)
 {
   vnet_sw_interface_t *sw;
   int rv = 0;

   ct6_feature_init (cmp);

   /* Utterly wrong? */
   if (pool_is_free_index (cmp->vnet_main->interface_main.sw_interfaces,
 			  sw_if_index))
     return VNET_API_ERROR_INVALID_SW_IF_INDEX;

   /* Not a physical port? */
   sw = vnet_get_sw_interface (cmp->vnet_main, sw_if_index);
   if (sw->type != VNET_SW_INTERFACE_TYPE_HARDWARE)
     return VNET_API_ERROR_INVALID_SW_IF_INDEX;

   vnet_feature_enable_disable ("interface-output", "ct6-in2out",
 			       sw_if_index, enable_disable, 0, 0);

   return rv;
 }

 int
 ct6_out2in_enable_disable (ct6_main_t * cmp, u32 sw_if_index,
 			   int enable_disable)
 {
   vnet_sw_interface_t *sw;
   int rv = 0;

   ct6_feature_init (cmp);

   /* Utterly wrong? */
   if (pool_is_free_index (cmp->vnet_main->interface_main.sw_interfaces,
 			  sw_if_index))
     return VNET_API_ERROR_INVALID_SW_IF_INDEX;

   /* Not a physical port? */
   sw = vnet_get_sw_interface (cmp->vnet_main, sw_if_index);
   if (sw->type != VNET_SW_INTERFACE_TYPE_HARDWARE)
     return VNET_API_ERROR_INVALID_SW_IF_INDEX;

   vnet_feature_enable_disable ("ip6-unicast", "ct6-out2in",
 			       sw_if_index, enable_disable, 0, 0);

   return rv;
 }

 static clib_error_t *
 set_ct6_enable_disable_command_fn (vlib_main_t * vm,
 				   unformat_input_t * input,
 				   vlib_cli_command_t * cmd)
 {
   ct6_main_t *cmp = &ct6_main;
   u32 sw_if_index = ~0;
   int enable_disable = 1;
   u32 inside = ~0;
   int rv;

   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
       if (unformat (input, "disable"))
 	enable_disable = 0;
       else if (unformat (input, "%U", unformat_vnet_sw_interface,
 			 cmp->vnet_main, &sw_if_index))
 	;
       else if (unformat (input, "inside") || unformat (input, "in"))
 	inside = 1;
       else if (unformat (input, "outside") || unformat (input, "out"))
 	inside = 0;
       else
 	break;
     }

   if (inside == ~0)
     return clib_error_return (0, "Please specify inside or outside");

   if (sw_if_index == ~0)
     return clib_error_return (0, "Please specify an interface...");

   if (inside == 1)
     rv = ct6_in2out_enable_disable (cmp, sw_if_index, enable_disable);
   else
     rv = ct6_out2in_enable_disable (cmp, sw_if_index, enable_disable);

   switch (rv)
     {
     case 0:
       break;

     case VNET_API_ERROR_INVALID_SW_IF_INDEX:
       return clib_error_return
 	(0, "Invalid interface, only works on physical ports");
       break;

     default:
       return clib_error_return (0, "ct6_enable_disable returned %d", rv);
     }
   return 0;
 }

 /* *INDENT-OFF* */
 VLIB_CLI_COMMAND (set_ct6_command, static) =
 {
   .path = "set ct6",
   .short_help =
   "set ct6 [inside|outside] <interface-name> [disable]",
   .function = set_ct6_enable_disable_command_fn,
 };
 /* *INDENT-ON* */

 /* API message handler */
 static void vl_api_ct6_enable_disable_t_handler
   (vl_api_ct6_enable_disable_t * mp)
 {
   vl_api_ct6_enable_disable_reply_t *rmp;
   ct6_main_t *cmp = &ct6_main;
   int rv;

   VALIDATE_SW_IF_INDEX (mp);

   if (mp->is_inside)
     rv = ct6_in2out_enable_disable (cmp, ntohl (mp->sw_if_index),
 				    (int) (mp->enable_disable));
   else
     rv = ct6_out2in_enable_disable (cmp, ntohl (mp->sw_if_index),
 				    (int) (mp->enable_disable));

   BAD_SW_IF_INDEX_LABEL;
   REPLY_MACRO (VL_API_CT6_ENABLE_DISABLE_REPLY);
 }

 #include <ct6/ct6.api.c>
 static clib_error_t *
 ct6_init (vlib_main_t * vm)
 {
   ct6_main_t *cmp = &ct6_main;
   clib_error_t *error = 0;

   cmp->vlib_main = vm;
   cmp->vnet_main = vnet_get_main ();

   /* Ask for a correctly-sized block of API message decode slots */
   cmp->msg_id_base = setup_message_id_table ();

   /*
    * Set default parameters...
    * 256K sessions
    * 64K buckets
    * 2 minute inactivity timer
    * 10000 concurrent sessions
    */
   cmp->session_hash_memory = 16ULL << 20;
   cmp->session_hash_buckets = 64 << 10;
   cmp->session_timeout_interval = 120.0;
   cmp->max_sessions_per_worker = 10000;

   /* ... so the packet generator can feed the in2out node ... */
   ethernet_setup_node (vm, ct6_in2out_node.index);
   return error;
 }

 VLIB_INIT_FUNCTION (ct6_init);

 /* *INDENT-OFF* */
 VNET_FEATURE_INIT (ct6out2in, static) =
 {
   .arc_name = "ip6-unicast",
   .node_name = "ct6-out2in",
   .runs_before = VNET_FEATURES ("ip6-lookup"),
 };
 /* *INDENT-ON */

 /* *INDENT-OFF* */
 VNET_FEATURE_INIT (ct6in2out, static) =
 {
   .arc_name = "interface-output",
   .node_name = "ct6-in2out",
   .runs_before = VNET_FEATURES ("interface-tx"),
 };
 /* *INDENT-ON */

 /* *INDENT-OFF* */
 VLIB_PLUGIN_REGISTER () =
 {
   .version = VPP_BUILD_VER,
   .description = "IPv6 Connection Tracker",
 };
 /* *INDENT-ON* */

 u8 *
 format_ct6_session (u8 * s, va_list * args)
 {
   ct6_main_t *cmp = va_arg (*args, ct6_main_t *);
   int i = va_arg (*args, int);
   ct6_session_t *s0 = va_arg (*args, ct6_session_t *);
   int verbose = va_arg (*args, int);
   clib_bihash_kv_48_8_t kvp0;

   if (s0 == 0)
     {
       s = format (s, "\n%6s%6s%40s%6s%40s%6s",
 		  "Sess", "Prot", "Src", "Sport", "Dst", "Dport");
       return s;
     }

   s = format (s, "\n%6d%6d%40U%6u%40U%6u",
 	      s0 - cmp->sessions[i], s0->key.proto,
 	      format_ip6_address, &s0->key.src,
 	      clib_net_to_host_u16 (s0->key.sport),
 	      format_ip6_address, &s0->key.dst,
 	      clib_net_to_host_u16 (s0->key.dport));

   clib_memcpy_fast (&kvp0, s0, sizeof (ct6_session_key_t));

   if (clib_bihash_search_48_8 (&cmp->session_hash, &kvp0, &kvp0) < 0)
     {
       s = format (s, " LOOKUP FAIL!");
     }
   else
     {
       if (kvp0.value == s0 - cmp->sessions[s0->thread_index])
 	{
 	  s = format (s, " OK");
 	  if (verbose > 1)
 	    {
 	      s = format (s, " next %d prev %d", s0->next_index,
 			  s0->prev_index);
 	      s = format (s, " hits %d expires %.2f", s0->hits, s0->expires);
 	    }
 	}
       else
 	s = format (s, " BOGUS LOOKUP RESULT!");
     }

   return s;
 }

 static clib_error_t *
 show_ct6_command_fn_command_fn (vlib_main_t * vm,
 				unformat_input_t * input,
 				vlib_cli_command_t * cmd)
 {
   ct6_main_t *cmp = &ct6_main;
   ct6_session_t *s0;
   int verbose = 0;
   u8 *s = 0;
   int i;

   if (!cmp->feature_initialized)
     return clib_error_return (0, "ip6 connection tracking not enabled...");

   if (unformat (input, "verbose %d", &verbose))
     ;
   else if (unformat (input, "verbose"))
     verbose = 1;

   for (i = 0; i < vec_len (cmp->sessions); i++)
     {
       s = format (s, "Thread %d: %d sessions\n", i,
 		  pool_elts (cmp->sessions[i]));

       if (verbose == 0)
 	continue;

       s =
 	format (s, "%U", format_ct6_session, cmp,
 		0 /* pool */ , 0 /* header */ , verbose);

       /* *INDENT-OFF* */
       pool_foreach (s0, cmp->sessions[i],
       ({
         s = format (s, "%U", format_ct6_session, cmp, i, s0, verbose);
       }));
       /* *INDENT-ON* */
     }
   vlib_cli_output (cmp->vlib_main, "%v", s);
   vec_free (s);
   return 0;
 }

 /* *INDENT-OFF* */
 VLIB_CLI_COMMAND (show_ct6_command_fn_command, static) =
 {
   .path = "show ip6 connection-tracker",
   .short_help = "show ip6 connection-tracker",
   .function = show_ct6_command_fn_command_fn,
 };
 /* *INDENT-ON* */

 static void
 increment_v6_address (ip6_address_t * a)
 {
   u64 v0, v1;

   v0 = clib_net_to_host_u64 (a->as_u64[0]);
   v1 = clib_net_to_host_u64 (a->as_u64[1]);

   v1 += 1;
   if (v1 == 0)
     v0 += 1;
   a->as_u64[0] = clib_net_to_host_u64 (v0);
   a->as_u64[1] = clib_net_to_host_u64 (v1);
 }


 static clib_error_t *
 test_ct6_command_fn_command_fn (vlib_main_t * vm,
 				unformat_input_t * input,
 				vlib_cli_command_t * cmd)
 {
   ct6_main_t *cmp = &ct6_main;
   clib_bihash_kv_48_8_t kvp0;
   ct6_session_key_t *key0;
   ct6_session_t *s0;
   u8 src[16], dst[16];
   u32 recycled = 0, created = 0;
   int i, num_sessions = 5;
   u32 midpt_index;
   u8 *s = 0;

   cmp->max_sessions_per_worker = 4;

   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
       if (unformat (input, "num-sessions %d", &num_sessions))
 	;
       else
 	if (unformat
 	    (input, "max-sessions %d", &cmp->max_sessions_per_worker))
 	;
       else
 	break;
     }

   ct6_feature_init (cmp);

   /* Set up starting src/dst addresses */
   memset (src, 0, sizeof (src));
   memset (dst, 0, sizeof (dst));

   src[0] = 0xdb;
   dst[0] = 0xbe;

   src[15] = 1;
   dst[15] = 1;

   /*
    * See if we know about this flow.
    * Key set up for the out2in path, the performant case
    */
   key0 = (ct6_session_key_t *) & kvp0;
   memset (&kvp0, 0, sizeof (kvp0));

   for (i = 0; i < num_sessions; i++)
     {
       clib_memcpy_fast (&key0->src, src, sizeof (src));
       clib_memcpy_fast (&key0->dst, dst, sizeof (dst));
       key0->as_u64[4] = 0;
       key0->as_u64[5] = 0;
       key0->sport = clib_host_to_net_u16 (1234);
       key0->dport = clib_host_to_net_u16 (4321);
       key0->proto = 17;		/* udp, fwiw */

       s0 = ct6_create_or_recycle_session
 	(cmp, &kvp0, 3.0 /* now */ , 0 /* thread index */ ,
 	 &recycled, &created);

       s = format (s, "%U (%d, %d)", format_ct6_session, cmp,
 		  0 /* thread index */ , s0, 1 /* verbose */ ,
 		  recycled, created);
       vlib_cli_output (vm, "%v", s);
       vec_free (s);
       increment_v6_address ((ip6_address_t *) src);
       recycled = 0;
       created = 0;
     }

   /* *INDENT-OFF* */
   pool_foreach (s0, cmp->sessions[0],
   ({
     s = format (s, "%U", format_ct6_session, cmp, 0, s0, 1 /* verbose */);
   }));
   /* *INDENT-ON* */

   vlib_cli_output (vm, "\nEnd state: first index %d last index %d\n%v",
 		   cmp->first_index[0], cmp->last_index[0], s);

   vec_free (s);

   midpt_index = cmp->max_sessions_per_worker / 3;

   s0 = pool_elt_at_index (cmp->sessions[0], midpt_index);
   vlib_cli_output (vm, "\nSimulate LRU hit on session %d",
 		   s0 - cmp->sessions[0]);

   ct6_update_session_hit (cmp, s0, 234.0);

   /* *INDENT-OFF* */
   pool_foreach (s0, cmp->sessions[0],
   ({
     s = format (s, "%U", format_ct6_session, cmp, 0, s0, 1 /* verbose */);
   }));
   /* *INDENT-ON* */

   vlib_cli_output (vm, "\nEnd state: first index %d last index %d\n%v",
 		   cmp->first_index[0], cmp->last_index[0], s);

   vec_free (s);

   return 0;
 }

 /* *INDENT-OFF* */
 VLIB_CLI_COMMAND (test_ct6_command_fn_command, static) =
 {
   .path = "test ip6 connection-tracker",
   .short_help = "test ip6 connection-tracker",
   .function = test_ct6_command_fn_command_fn,
 };
 /* *INDENT-ON* */

 static clib_error_t *
 ct6_config (vlib_main_t * vm, unformat_input_t * input)
 {
   ct6_main_t *cmp = &ct6_main;

   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
       if (unformat (input, "session-hash-buckets %u",
 		    &cmp->session_hash_buckets))
 	;
       else if (unformat (input, "session-hash-memory %U",
 			 unformat_memory_size, &cmp->session_hash_memory))
 	;
       else if (unformat (input, "session-timeout %f",
 			 &cmp->session_timeout_interval))
 	;
       else
 	{
 	  return clib_error_return (0, "unknown input '%U'",
 				    format_unformat_error, input);
 	}
     }
   return 0;
 }

 VLIB_CONFIG_FUNCTION (ct6_config, "ct6");

 /*
  * fd.io coding-style-patch-verification: ON
  *
  * Local Variables:
  * eval: (c-set-style "gnu")
  * End:
  */
	/*
	* ct6.c - skeleton vpp engine plug-in
	*
	* Copyright (c) <current-year> <your-organization>
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at:
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <vnet/vnet.h>
	#include <vnet/plugin/plugin.h>
	#include <ct6/ct6.h>

	#include <vlibapi/api.h>
	#include <vlibmemory/api.h>
	#include <vpp/app/version.h>

	/* define message IDs */
	#include <ct6/ct6.api_enum.h>
	#include <ct6/ct6.api_types.h>

	#define REPLY_MSG_ID_BASE cmp->msg_id_base
	#include <vlibapi/api_helper_macros.h>

	ct6_main_t ct6_main;

	/* Action function shared between message handler and debug CLI */

	static void
	ct6_feature_init (ct6_main_t * cmp)
	{
	u32 nworkers = vlib_num_workers ();

	if (cmp->feature_initialized)
	return;

	clib_bihash_init_48_8 (&cmp->session_hash, "ct6 session table",
	cmp->session_hash_buckets, cmp->session_hash_memory);
	cmp->feature_initialized = 1;
	vec_validate (cmp->sessions, nworkers);
	vec_validate_init_empty (cmp->first_index, nworkers, ~0);
	vec_validate_init_empty (cmp->last_index, nworkers, ~0);
	}

	int
	ct6_in2out_enable_disable (ct6_main_t * cmp, u32 sw_if_index,
	int enable_disable)
	{
	vnet_sw_interface_t *sw;
	int rv = 0;

	ct6_feature_init (cmp);

	/* Utterly wrong? */
	if (pool_is_free_index (cmp->vnet_main->interface_main.sw_interfaces,
	sw_if_index))
	return VNET_API_ERROR_INVALID_SW_IF_INDEX;

	/* Not a physical port? */
	sw = vnet_get_sw_interface (cmp->vnet_main, sw_if_index);
	if (sw->type != VNET_SW_INTERFACE_TYPE_HARDWARE)
	return VNET_API_ERROR_INVALID_SW_IF_INDEX;

	vnet_feature_enable_disable ("interface-output", "ct6-in2out",
	sw_if_index, enable_disable, 0, 0);

	return rv;
	}

	int
	ct6_out2in_enable_disable (ct6_main_t * cmp, u32 sw_if_index,
	int enable_disable)
	{
	vnet_sw_interface_t *sw;
	int rv = 0;

	ct6_feature_init (cmp);

	/* Utterly wrong? */
	if (pool_is_free_index (cmp->vnet_main->interface_main.sw_interfaces,
	sw_if_index))
	return VNET_API_ERROR_INVALID_SW_IF_INDEX;

	/* Not a physical port? */
	sw = vnet_get_sw_interface (cmp->vnet_main, sw_if_index);
	if (sw->type != VNET_SW_INTERFACE_TYPE_HARDWARE)
	return VNET_API_ERROR_INVALID_SW_IF_INDEX;

	vnet_feature_enable_disable ("ip6-unicast", "ct6-out2in",
	sw_if_index, enable_disable, 0, 0);

	return rv;
	}

	static clib_error_t *
	set_ct6_enable_disable_command_fn (vlib_main_t * vm,
	unformat_input_t * input,
	vlib_cli_command_t * cmd)
	{
	ct6_main_t *cmp = &ct6_main;
	u32 sw_if_index = ~0;
	int enable_disable = 1;
	u32 inside = ~0;
	int rv;

	while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
	{
	if (unformat (input, "disable"))
	enable_disable = 0;
	else if (unformat (input, "%U", unformat_vnet_sw_interface,
	cmp->vnet_main, &sw_if_index))
	;
	else if (unformat (input, "inside") \|\| unformat (input, "in"))
	inside = 1;
	else if (unformat (input, "outside") \|\| unformat (input, "out"))
	inside = 0;
	else
	break;
	}

	if (inside == ~0)
	return clib_error_return (0, "Please specify inside or outside");

	if (sw_if_index == ~0)
	return clib_error_return (0, "Please specify an interface...");

	if (inside == 1)
	rv = ct6_in2out_enable_disable (cmp, sw_if_index, enable_disable);
	else
	rv = ct6_out2in_enable_disable (cmp, sw_if_index, enable_disable);

	switch (rv)
	{
	case 0:
	break;

	case VNET_API_ERROR_INVALID_SW_IF_INDEX:
	return clib_error_return
	(0, "Invalid interface, only works on physical ports");
	break;

	default:
	return clib_error_return (0, "ct6_enable_disable returned %d", rv);
	}
	return 0;
	}

	/* INDENT-OFF */
	VLIB_CLI_COMMAND (set_ct6_command, static) =
	{
	.path = "set ct6",
	.short_help =
	"set ct6 [inside\|outside] <interface-name> [disable]",
	.function = set_ct6_enable_disable_command_fn,
	};
	/* INDENT-ON */

	/* API message handler */
	static void vl_api_ct6_enable_disable_t_handler
	(vl_api_ct6_enable_disable_t * mp)
	{
	vl_api_ct6_enable_disable_reply_t *rmp;
	ct6_main_t *cmp = &ct6_main;
	int rv;

	VALIDATE_SW_IF_INDEX (mp);

	if (mp->is_inside)
	rv = ct6_in2out_enable_disable (cmp, ntohl (mp->sw_if_index),
	(int) (mp->enable_disable));
	else
	rv = ct6_out2in_enable_disable (cmp, ntohl (mp->sw_if_index),
	(int) (mp->enable_disable));

	BAD_SW_IF_INDEX_LABEL;
	REPLY_MACRO (VL_API_CT6_ENABLE_DISABLE_REPLY);
	}

	#include <ct6/ct6.api.c>
	static clib_error_t *
	ct6_init (vlib_main_t * vm)
	{
	ct6_main_t *cmp = &ct6_main;
	clib_error_t *error = 0;

	cmp->vlib_main = vm;
	cmp->vnet_main = vnet_get_main ();

	/* Ask for a correctly-sized block of API message decode slots */
	cmp->msg_id_base = setup_message_id_table ();

	/*
	* Set default parameters...
	* 256K sessions
	* 64K buckets
	* 2 minute inactivity timer
	* 10000 concurrent sessions
	*/
	cmp->session_hash_memory = 16ULL << 20;
	cmp->session_hash_buckets = 64 << 10;
	cmp->session_timeout_interval = 120.0;
	cmp->max_sessions_per_worker = 10000;

	/* ... so the packet generator can feed the in2out node ... */
	ethernet_setup_node (vm, ct6_in2out_node.index);
	return error;
	}

	VLIB_INIT_FUNCTION (ct6_init);

	/* INDENT-OFF */
	VNET_FEATURE_INIT (ct6out2in, static) =
	{
	.arc_name = "ip6-unicast",
	.node_name = "ct6-out2in",
	.runs_before = VNET_FEATURES ("ip6-lookup"),
	};
	/* INDENT-ON /

	/* INDENT-OFF */
	VNET_FEATURE_INIT (ct6in2out, static) =
	{
	.arc_name = "interface-output",
	.node_name = "ct6-in2out",
	.runs_before = VNET_FEATURES ("interface-tx"),
	};
	/* INDENT-ON /

	/* INDENT-OFF */
	VLIB_PLUGIN_REGISTER () =
	{
	.version = VPP_BUILD_VER,
	.description = "IPv6 Connection Tracker",
	};
	/* INDENT-ON */

	u8 *
	format_ct6_session (u8 * s, va_list * args)
	{
	ct6_main_t cmp = va_arg (args, ct6_main_t *);
	int i = va_arg (*args, int);
	ct6_session_t s0 = va_arg (args, ct6_session_t *);
	int verbose = va_arg (*args, int);
	clib_bihash_kv_48_8_t kvp0;

	if (s0 == 0)
	{
	s = format (s, "\n%6s%6s%40s%6s%40s%6s",
	"Sess", "Prot", "Src", "Sport", "Dst", "Dport");
	return s;
	}

	s = format (s, "\n%6d%6d%40U%6u%40U%6u",
	s0 - cmp->sessions[i], s0->key.proto,
	format_ip6_address, &s0->key.src,
	clib_net_to_host_u16 (s0->key.sport),
	format_ip6_address, &s0->key.dst,
	clib_net_to_host_u16 (s0->key.dport));

	clib_memcpy_fast (&kvp0, s0, sizeof (ct6_session_key_t));

	if (clib_bihash_search_48_8 (&cmp->session_hash, &kvp0, &kvp0) < 0)
	{
	s = format (s, " LOOKUP FAIL!");
	}
	else
	{
	if (kvp0.value == s0 - cmp->sessions[s0->thread_index])
	{
	s = format (s, " OK");
	if (verbose > 1)
	{
	s = format (s, " next %d prev %d", s0->next_index,
	s0->prev_index);
	s = format (s, " hits %d expires %.2f", s0->hits, s0->expires);
	}
	}
	else
	s = format (s, " BOGUS LOOKUP RESULT!");
	}

	return s;
	}

	static clib_error_t *
	show_ct6_command_fn_command_fn (vlib_main_t * vm,
	unformat_input_t * input,
	vlib_cli_command_t * cmd)
	{
	ct6_main_t *cmp = &ct6_main;
	ct6_session_t *s0;
	int verbose = 0;
	u8 *s = 0;
	int i;

	if (!cmp->feature_initialized)
	return clib_error_return (0, "ip6 connection tracking not enabled...");

	if (unformat (input, "verbose %d", &verbose))
	;
	else if (unformat (input, "verbose"))
	verbose = 1;

	for (i = 0; i < vec_len (cmp->sessions); i++)
	{
	s = format (s, "Thread %d: %d sessions\n", i,
	pool_elts (cmp->sessions[i]));

	if (verbose == 0)
	continue;

	s =
	format (s, "%U", format_ct6_session, cmp,
	0 /* pool / , 0 / header */ , verbose);

	/* INDENT-OFF */
	pool_foreach (s0, cmp->sessions[i],
	({
	s = format (s, "%U", format_ct6_session, cmp, i, s0, verbose);
	}));
	/* INDENT-ON */
	}
	vlib_cli_output (cmp->vlib_main, "%v", s);
	vec_free (s);
	return 0;
	}

	/* INDENT-OFF */
	VLIB_CLI_COMMAND (show_ct6_command_fn_command, static) =
	{
	.path = "show ip6 connection-tracker",
	.short_help = "show ip6 connection-tracker",
	.function = show_ct6_command_fn_command_fn,
	};
	/* INDENT-ON */

	static void
	increment_v6_address (ip6_address_t * a)
	{
	u64 v0, v1;

	v0 = clib_net_to_host_u64 (a->as_u64[0]);
	v1 = clib_net_to_host_u64 (a->as_u64[1]);

	v1 += 1;
	if (v1 == 0)
	v0 += 1;
	a->as_u64[0] = clib_net_to_host_u64 (v0);
	a->as_u64[1] = clib_net_to_host_u64 (v1);
	}


	static clib_error_t *
	test_ct6_command_fn_command_fn (vlib_main_t * vm,
	unformat_input_t * input,
	vlib_cli_command_t * cmd)
	{
	ct6_main_t *cmp = &ct6_main;
	clib_bihash_kv_48_8_t kvp0;
	ct6_session_key_t *key0;
	ct6_session_t *s0;
	u8 src[16], dst[16];
	u32 recycled = 0, created = 0;
	int i, num_sessions = 5;
	u32 midpt_index;
	u8 *s = 0;

	cmp->max_sessions_per_worker = 4;

	while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
	{
	if (unformat (input, "num-sessions %d", &num_sessions))
	;
	else
	if (unformat
	(input, "max-sessions %d", &cmp->max_sessions_per_worker))
	;
	else
	break;
	}

	ct6_feature_init (cmp);

	/* Set up starting src/dst addresses */
	memset (src, 0, sizeof (src));
	memset (dst, 0, sizeof (dst));

	src[0] = 0xdb;
	dst[0] = 0xbe;

	src[15] = 1;
	dst[15] = 1;

	/*
	* See if we know about this flow.
	* Key set up for the out2in path, the performant case
	*/
	key0 = (ct6_session_key_t *) & kvp0;
	memset (&kvp0, 0, sizeof (kvp0));

	for (i = 0; i < num_sessions; i++)
	{
	clib_memcpy_fast (&key0->src, src, sizeof (src));
	clib_memcpy_fast (&key0->dst, dst, sizeof (dst));
	key0->as_u64[4] = 0;
	key0->as_u64[5] = 0;
	key0->sport = clib_host_to_net_u16 (1234);
	key0->dport = clib_host_to_net_u16 (4321);
	key0->proto = 17; /* udp, fwiw */

	s0 = ct6_create_or_recycle_session
	(cmp, &kvp0, 3.0 /* now / , 0 / thread index */ ,
	&recycled, &created);

	s = format (s, "%U (%d, %d)", format_ct6_session, cmp,
	0 /* thread index / , s0, 1 / verbose */ ,
	recycled, created);
	vlib_cli_output (vm, "%v", s);
	vec_free (s);
	increment_v6_address ((ip6_address_t *) src);
	recycled = 0;
	created = 0;
	}

	/* INDENT-OFF */
	pool_foreach (s0, cmp->sessions[0],
	({
	s = format (s, "%U", format_ct6_session, cmp, 0, s0, 1 /* verbose */);
	}));
	/* INDENT-ON */

	vlib_cli_output (vm, "\nEnd state: first index %d last index %d\n%v",
	cmp->first_index[0], cmp->last_index[0], s);

	vec_free (s);

	midpt_index = cmp->max_sessions_per_worker / 3;

	s0 = pool_elt_at_index (cmp->sessions[0], midpt_index);
	vlib_cli_output (vm, "\nSimulate LRU hit on session %d",
	s0 - cmp->sessions[0]);

	ct6_update_session_hit (cmp, s0, 234.0);

	/* INDENT-OFF */
	pool_foreach (s0, cmp->sessions[0],
	({
	s = format (s, "%U", format_ct6_session, cmp, 0, s0, 1 /* verbose */);
	}));
	/* INDENT-ON */

	vlib_cli_output (vm, "\nEnd state: first index %d last index %d\n%v",
	cmp->first_index[0], cmp->last_index[0], s);

	vec_free (s);

	return 0;
	}

	/* INDENT-OFF */
	VLIB_CLI_COMMAND (test_ct6_command_fn_command, static) =
	{
	.path = "test ip6 connection-tracker",
	.short_help = "test ip6 connection-tracker",
	.function = test_ct6_command_fn_command_fn,
	};
	/* INDENT-ON */

	static clib_error_t *
	ct6_config (vlib_main_t * vm, unformat_input_t * input)
	{
	ct6_main_t *cmp = &ct6_main;

	while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
	{
	if (unformat (input, "session-hash-buckets %u",
	&cmp->session_hash_buckets))
	;
	else if (unformat (input, "session-hash-memory %U",
	unformat_memory_size, &cmp->session_hash_memory))
	;
	else if (unformat (input, "session-timeout %f",
	&cmp->session_timeout_interval))
	;
	else
	{
	return clib_error_return (0, "unknown input '%U'",
	format_unformat_error, input);
	}
	}
	return 0;
	}

	VLIB_CONFIG_FUNCTION (ct6_config, "ct6");

	/*
	* fd.io coding-style-patch-verification: ON
	*
	* Local Variables:
	* eval: (c-set-style "gnu")
	* End:
	*/