/*
 * 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;
}

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,
};

/* 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);

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

VNET_FEATURE_INIT (ct6in2out, static) = {
  .arc_name = "interface-output",
  .node_name = "ct6-in2out",
  .runs_before = VNET_FEATURES ("interface-output-arc-end"),
};

VLIB_PLUGIN_REGISTER () =
{
  .version = VPP_BUILD_VER,
  .description = "IPv6 Connection Tracker",
};

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);

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

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,
};

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;
    }

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

  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);

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

  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;
}

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,
};

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:
 */