aboutsummaryrefslogtreecommitdiffstats
path: root/src
AgeCommit message (Expand)AuthorFilesLines
2019-08-23tcp: fix byte tracker samples flushFlorin Coras2-0/+14
2019-08-23vppapitrace: add text outputOle Troan1-8/+65
2019-08-22dns: fix trivial multi-thread deadlockDave Barach3-12/+17
2019-08-22tests: move plugin tests to src/plugins/*/testDave Wallace33-0/+30164
2019-08-22dns: make the dns name resolver a pluginDave Barach16-393/+767
2019-08-22avf: properly set irq queue masksDamjan Marion1-1/+2
2019-08-22nat: handoff traffic matching for dynamic NATFilip Varga9-222/+493
2019-08-22ip: fix merge issueKlement Sekera1-2/+0
2019-08-22vlib: fix null pointer crash on strncmpSteven Luong1-2/+2
2019-08-22hsa: fix http responseBenoît Ganne1-1/+1
2019-08-22sr: fix sr_set_encap_source replyVratko Polak1-1/+1
2019-08-21vcl: fix ldp_set_app_name overflowBenoît Ganne1-5/+2
2019-08-21tcp: add option for always on event loggingFlorin Coras8-185/+371
2019-08-21avf: print queue id in packet traceDamjan Marion3-4/+6
2019-08-21dns: add basic functional "make test" caseDave Barach1-0/+4
2019-08-21dpdk: bump DPDK version to 19.08Damjan Marion3-7/+4
2019-08-21avf: fix init when num_rx_queues > num_tx_queuesDamjan Marion1-4/+4
2019-08-21tcp: default to debug disabledFlorin Coras1-1/+1
2019-08-21misc: missing ntohl for bond_slave's custom dumpSteven Luong1-2/+2
2019-08-20tls: Add C API for TLS openssl to set enginePing Yu9-10/+436
2019-08-20vppapigen: remove support for legacy typedefsPaul Vinciguerra27-120/+53
2019-08-20ip: reassembly: send packet out on correct workerKlement Sekera2-92/+287
2019-08-20vlib: create unix runtime directoryOle Troan2-8/+29
2019-08-20fix pcap_write functionJack Xu6-4/+13
2019-08-20api: Cleanup APIs interface.apiJakub Grajciar9-250/+333
2019-08-20tcp: forward conn resets through tcp-outputFlorin Coras1-32/+20
2019-08-20vppapigen: remove python2 supportPaul Vinciguerra1-28/+30
2019-08-19dns: handle multiple replies for single requestsDave Barach3-59/+121
2019-08-19hsa: move udp_echo to vpp_echoNathan Skrzypczak3-1262/+183
2019-08-19hsa: move tcp_echo to vpp_echoNathan Skrzypczak3-1420/+144
2019-08-19quic: fix rx_callback refactoringNathan Skrzypczak1-1/+1
2019-08-19vppapigen map: raise ValueError when fieldname is python keywordPaul Vinciguerra3-6/+10
2019-08-19dpdk: fix ipsec coverity warningMatthew Smith1-2/+4
2019-08-19vlib: fix vlib_buffer_main_init_numa_node memory leak.Guanghua Zhang1-3/+8
2019-08-19build: fix vpp compilation failure on ThunderX2 and AmpJianlin Lv1-1/+1
2019-08-19vppinfra: Update "show cpu" output for AArch64 chipsNitin Saxena1-15/+18
2019-08-19ip: leverage existing vlib_buffer_advanceZhiyong Yang1-6/+3
2019-08-19nsh: rewrite nsh_output_inlineZhiyong Yang1-32/+30
2019-08-19rdma: add support for MAC changesBenoît Ganne2-1/+35
2019-08-19dpdk: add TSO support in dpdk plugin.Chenmin Sun3-1/+44
2019-08-19dpdk: QAT devices update, add c4xxx and xeon d15xxJim Thompson1-1/+2
2019-08-19devices: skip checksum calculation if guest supports checksum offloadSteven Luong1-3/+7
2019-08-19rdma: add support for input feature arcsBenoît Ganne1-29/+35
2019-08-19session: add explicit reset apiFlorin Coras6-6/+72
2019-08-19tcp: set cc_algo on connection allocFlorin Coras3-6/+19
2019-08-19tcp: allow cc algos to set pacing rateFlorin Coras2-8/+15
2019-08-17gso: fix l3 and l4 header offset in case of tagged interfaceMohsin Kazmi2-0/+28
2019-08-17gso: fix the segmentation to use current_data offsetMohsin Kazmi1-15/+16
2019-08-17bonding lacp: deleting virtual interface which was enslaved may cause crashSteven Luong5-46/+66
2019-08-16acl: fix stats-segment counters validation on acl updateAndrew Yourtchenko2-8/+46
n919' href='#n919'>919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 
/*
* Copyright (c) 2017-2019 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.
* 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 <vlibmemory/api.h>
#include <vnet/session/application.h>
#include <vnet/session/application_interface.h>
#include <hs_apps/proxy.h>
#include <vnet/tcp/tcp.h>

proxy_main_t proxy_main;

#define TCP_MSS 1460

static void
proxy_do_connect (vnet_connect_args_t *a)
{
  vnet_connect (a);
  if (a->sep_ext.ext_cfg)
    clib_mem_free (a->sep_ext.ext_cfg);
}

static void
proxy_handle_connects_rpc (void *args)
{
  u32 thread_index = pointer_to_uword (args), n_connects = 0, n_pending;
  proxy_worker_t *wrk;
  u32 max_connects;

  wrk = proxy_worker_get (thread_index);

  clib_spinlock_lock (&wrk->pending_connects_lock);

  n_pending = clib_fifo_elts (wrk->pending_connects);
  max_connects = clib_min (32, n_pending);
  vec_validate (wrk->burst_connects, max_connects);

  while (n_connects < max_connects)
    clib_fifo_sub1 (wrk->pending_connects, wrk->burst_connects[n_connects++]);

  clib_spinlock_unlock (&wrk->pending_connects_lock);

  /* Do connects without locking pending_connects */
  n_connects = 0;
  while (n_connects < max_connects)
    {
      proxy_do_connect (&wrk->burst_connects[n_connects]);
      n_connects += 1;
    }

  /* More work to do, program rpc */
  if (max_connects < n_pending)
    session_send_rpc_evt_to_thread_force (
      transport_cl_thread (), proxy_handle_connects_rpc,
      uword_to_pointer ((uword) thread_index, void *));
}

static void
proxy_program_connect (vnet_connect_args_t *a)
{
  u32 connects_thread = transport_cl_thread (), thread_index, n_pending;
  proxy_worker_t *wrk;

  thread_index = vlib_get_thread_index ();

  /* If already on first worker, handle request */
  if (thread_index == connects_thread)
    {
      proxy_do_connect (a);
      return;
    }

  /* If not on first worker, queue request */
  wrk = proxy_worker_get (thread_index);

  clib_spinlock_lock (&wrk->pending_connects_lock);

  clib_fifo_add1 (wrk->pending_connects, *a);
  n_pending = vec_len (wrk->pending_connects);

  clib_spinlock_unlock (&wrk->pending_connects_lock);

  if (n_pending == 1)
    session_send_rpc_evt_to_thread_force (
      connects_thread, proxy_handle_connects_rpc,
      uword_to_pointer ((uword) thread_index, void *));
}

static proxy_session_t *
proxy_session_alloc (void)
{
  proxy_main_t *pm = &proxy_main;
  proxy_session_t *ps;

  pool_get_zero (pm->sessions, ps);
  ps->ps_index = ps - pm->sessions;

  return ps;
}

static inline proxy_session_t *
proxy_session_get (u32 ps_index)
{
  proxy_main_t *pm = &proxy_main;

  return pool_elt_at_index (pm->sessions, ps_index);
}

static inline proxy_session_t *
proxy_session_get_if_valid (u32 ps_index)
{
  proxy_main_t *pm = &proxy_main;

  if (pool_is_free_index (pm->sessions, ps_index))
    return 0;
  return pool_elt_at_index (pm->sessions, ps_index);
}

static void
proxy_session_free (proxy_session_t *ps)
{
  proxy_main_t *pm = &proxy_main;

  if (CLIB_DEBUG > 0)
    clib_memset (ps, 0xFE, sizeof (*ps));
  pool_put (pm->sessions, ps);
}

static int
proxy_session_postponed_free_rpc (void *arg)
{
  uword ps_index = pointer_to_uword (arg);
  proxy_main_t *pm = &proxy_main;
  proxy_session_t *ps = 0;

  clib_spinlock_lock_if_init (&pm->sessions_lock);

  ps = proxy_session_get (ps_index);
  segment_manager_dealloc_fifos (ps->server_rx_fifo, ps->server_tx_fifo);
  proxy_session_free (ps);

  clib_spinlock_unlock_if_init (&pm->sessions_lock);

  return 0;
}

static void
proxy_session_postponed_free (proxy_session_t *ps)
{
  session_send_rpc_evt_to_thread (ps->po_thread_index,
				  proxy_session_postponed_free_rpc,
				  uword_to_pointer (ps->ps_index, void *));
}

static void
proxy_try_close_session (session_t * s, int is_active_open)
{
  proxy_main_t *pm = &proxy_main;
  proxy_session_t *ps = 0;
  vnet_disconnect_args_t _a, *a = &_a;

  clib_spinlock_lock_if_init (&pm->sessions_lock);

  ps = proxy_session_get (s->opaque);

  if (is_active_open)
    {
      a->handle = ps->vpp_active_open_handle;
      a->app_index = pm->active_open_app_index;
      vnet_disconnect_session (a);
      ps->ao_disconnected = 1;

      if (!ps->po_disconnected)
	{
	  ASSERT (ps->vpp_server_handle != SESSION_INVALID_HANDLE);
	  a->handle = ps->vpp_server_handle;
	  a->app_index = pm->server_app_index;
	  vnet_disconnect_session (a);
	  ps->po_disconnected = 1;
	}
    }
  else
    {
      a->handle = ps->vpp_server_handle;
      a->app_index = pm->server_app_index;
      vnet_disconnect_session (a);
      ps->po_disconnected = 1;

      if (!ps->ao_disconnected && !ps->active_open_establishing)
	{
	  /* Proxy session closed before active open */
	  if (ps->vpp_active_open_handle != SESSION_INVALID_HANDLE)
	    {
	      a->handle = ps->vpp_active_open_handle;
	      a->app_index = pm->active_open_app_index;
	      vnet_disconnect_session (a);
	    }
	  ps->ao_disconnected = 1;
	}
    }
  clib_spinlock_unlock_if_init (&pm->sessions_lock);
}

static void
proxy_try_delete_session (session_t * s, u8 is_active_open)
{
  proxy_main_t *pm = &proxy_main;
  proxy_session_t *ps = 0;

  clib_spinlock_lock_if_init (&pm->sessions_lock);

  ps = proxy_session_get (s->opaque);

  if (is_active_open)
    {
      ps->vpp_active_open_handle = SESSION_INVALID_HANDLE;

      /* Revert master thread index change on connect notification */
      ps->server_rx_fifo->master_thread_index = ps->po_thread_index;

      /* Passive open already cleaned up */
      if (ps->vpp_server_handle == SESSION_INVALID_HANDLE)
	{
	  ASSERT (s->rx_fifo->refcnt == 1);

	  /* The two sides of the proxy on different threads */
	  if (ps->po_thread_index != s->thread_index)
	    {
	      /* This is not the right thread to delete the fifos */
	      s->rx_fifo = 0;
	      s->tx_fifo = 0;
	      proxy_session_postponed_free (ps);
	    }
	  else
	    proxy_session_free (ps);
	}
    }
  else
    {
      ps->vpp_server_handle = SESSION_INVALID_HANDLE;

      if (ps->vpp_active_open_handle == SESSION_INVALID_HANDLE)
	{
	  if (!ps->active_open_establishing)
	    proxy_session_free (ps);
	}
    }
  clib_spinlock_unlock_if_init (&pm->sessions_lock);
}

static int
common_fifo_tuning_callback (session_t * s, svm_fifo_t * f,
			     session_ft_action_t act, u32 bytes)
{
  proxy_main_t *pm = &proxy_main;

  segment_manager_t *sm = segment_manager_get (f->segment_manager);
  fifo_segment_t *fs = segment_manager_get_segment (sm, f->segment_index);

  u8 seg_usage = fifo_segment_get_mem_usage (fs);
  u32 fifo_in_use = svm_fifo_max_dequeue_prod (f);
  u32 fifo_size = svm_fifo_size (f);
  u8 fifo_usage = fifo_in_use * 100 / fifo_size;
  u8 update_size = 0;

  ASSERT (act < SESSION_FT_ACTION_N_ACTIONS);

  if (act == SESSION_FT_ACTION_ENQUEUED)
    {
      if (seg_usage < pm->low_watermark && fifo_usage > 50)
	update_size = fifo_in_use;
      else if (seg_usage < pm->high_watermark && fifo_usage > 80)
	update_size = fifo_in_use;

      update_size = clib_min (update_size, sm->max_fifo_size - fifo_size);
      if (update_size)
	svm_fifo_set_size (f, fifo_size + update_size);
    }
  else				/* dequeued */
    {
      if (seg_usage > pm->high_watermark || fifo_usage < 20)
	update_size = bytes;
      else if (seg_usage > pm->low_watermark && fifo_usage < 50)
	update_size = (bytes / 2);

      ASSERT (fifo_size >= 4096);
      update_size = clib_min (update_size, fifo_size - 4096);
      if (update_size)
	svm_fifo_set_size (f, fifo_size - update_size);
    }

  return 0;
}

static int
proxy_accept_callback (session_t * s)
{
  proxy_main_t *pm = &proxy_main;
  proxy_session_t *ps;

  clib_spinlock_lock_if_init (&pm->sessions_lock);

  ps = proxy_session_alloc ();
  ps->vpp_server_handle = session_handle (s);
  ps->vpp_active_open_handle = SESSION_INVALID_HANDLE;
  ps->po_thread_index = s->thread_index;

  s->opaque = ps->ps_index;

  clib_spinlock_unlock_if_init (&pm->sessions_lock);

  s->session_state = SESSION_STATE_READY;

  return 0;
}

static void
proxy_disconnect_callback (session_t * s)
{
  proxy_try_close_session (s, 0 /* is_active_open */ );
}

static void
proxy_reset_callback (session_t * s)
{
  proxy_try_close_session (s, 0 /* is_active_open */ );
}

static int
proxy_connected_callback (u32 app_index, u32 api_context,
			  session_t * s, session_error_t err)
{
  clib_warning ("called...");
  return -1;
}

static int
proxy_add_segment_callback (u32 client_index, u64 segment_handle)
{
  return 0;
}

static int
proxy_transport_needs_crypto (transport_proto_t proto)
{
  return proto == TRANSPORT_PROTO_TLS;
}

static int
proxy_rx_callback (session_t * s)
{
  proxy_main_t *pm = &proxy_main;
  u32 thread_index = vlib_get_thread_index ();
  svm_fifo_t *ao_tx_fifo;
  proxy_session_t *ps;

  ASSERT (s->thread_index == thread_index);

  clib_spinlock_lock_if_init (&pm->sessions_lock);

  ps = proxy_session_get (s->opaque);

  if (PREDICT_TRUE (ps->vpp_active_open_handle != SESSION_INVALID_HANDLE))
    {
      clib_spinlock_unlock_if_init (&pm->sessions_lock);

      ao_tx_fifo = s->rx_fifo;

      /*
       * Send event for active open tx fifo
       */
      if (svm_fifo_set_event (ao_tx_fifo))
	{
	  u32 ao_thread_index = ao_tx_fifo->master_thread_index;
	  u32 ao_session_index = ao_tx_fifo->shr->master_session_index;
	  if (session_send_io_evt_to_thread_custom (&ao_session_index,
						    ao_thread_index,
						    SESSION_IO_EVT_TX))
	    clib_warning ("failed to enqueue tx evt");
	}

      if (svm_fifo_max_enqueue (ao_tx_fifo) <= TCP_MSS)
	svm_fifo_add_want_deq_ntf (ao_tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
    }
  else
    {
      vnet_connect_args_t _a, *a = &_a;
      svm_fifo_t *tx_fifo, *rx_fifo;
      u32 max_dequeue, ps_index;
      int actual_transfer __attribute__ ((unused));

      /* maybe we were already here */
      if (ps->active_open_establishing)
	{
	  clib_spinlock_unlock_if_init (&pm->sessions_lock);
	  return 0;
	}

      rx_fifo = s->rx_fifo;
      tx_fifo = s->tx_fifo;

      ASSERT (rx_fifo->master_thread_index == thread_index);
      ASSERT (tx_fifo->master_thread_index == thread_index);

      max_dequeue = svm_fifo_max_dequeue_cons (s->rx_fifo);

      if (PREDICT_FALSE (max_dequeue == 0))
	{
	  clib_spinlock_unlock_if_init (&pm->sessions_lock);
	  return 0;
	}

      max_dequeue = clib_min (pm->rcv_buffer_size, max_dequeue);
      actual_transfer = svm_fifo_peek (rx_fifo, 0 /* relative_offset */ ,
				       max_dequeue, pm->rx_buf[thread_index]);

      /* $$$ your message in this space: parse url, etc. */

      clib_memset (a, 0, sizeof (*a));

      ps->server_rx_fifo = rx_fifo;
      ps->server_tx_fifo = tx_fifo;
      ps->active_open_establishing = 1;
      ps_index = ps->ps_index;

      clib_spinlock_unlock_if_init (&pm->sessions_lock);

      clib_memcpy (&a->sep_ext, &pm->client_sep, sizeof (pm->client_sep));
      a->api_context = ps_index;
      a->app_index = pm->active_open_app_index;

      if (proxy_transport_needs_crypto (a->sep.transport_proto))
	{
	  session_endpoint_alloc_ext_cfg (&a->sep_ext,
					  TRANSPORT_ENDPT_EXT_CFG_CRYPTO);
	  a->sep_ext.ext_cfg->crypto.ckpair_index = pm->ckpair_index;
	}

      proxy_program_connect (a);
    }

  return 0;
}

static void
proxy_force_ack (void *handlep)
{
  transport_connection_t *tc;
  session_t *s;

  s = session_get_from_handle (pointer_to_uword (handlep));
  if (session_get_transport_proto (s) != TRANSPORT_PROTO_TCP)
    return;
  tc = session_get_transport (s);
  tcp_send_ack ((tcp_connection_t *) tc);
}

static int
proxy_tx_callback (session_t * proxy_s)
{
  proxy_main_t *pm = &proxy_main;
  proxy_session_t *ps;
  u32 min_free;

  min_free = clib_min (svm_fifo_size (proxy_s->tx_fifo) >> 3, 128 << 10);
  if (svm_fifo_max_enqueue (proxy_s->tx_fifo) < min_free)
    {
      svm_fifo_add_want_deq_ntf (proxy_s->tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
      return 0;
    }

  clib_spinlock_lock_if_init (&pm->sessions_lock);

  ps = proxy_session_get (proxy_s->opaque);

  if (ps->vpp_active_open_handle == SESSION_INVALID_HANDLE)
    goto unlock;

  /* Force ack on active open side to update rcv wnd. Make sure it's done on
   * the right thread */
  void *arg = uword_to_pointer (ps->vpp_active_open_handle, void *);
  session_send_rpc_evt_to_thread (ps->server_rx_fifo->master_thread_index,
				  proxy_force_ack, arg);

unlock:
  clib_spinlock_unlock_if_init (&pm->sessions_lock);

  return 0;
}

static void
proxy_cleanup_callback (session_t * s, session_cleanup_ntf_t ntf)
{
  if (ntf == SESSION_CLEANUP_TRANSPORT)
    return;

  proxy_try_delete_session (s, 0 /* is_active_open */ );
}

static session_cb_vft_t proxy_session_cb_vft = {
  .session_accept_callback = proxy_accept_callback,
  .session_disconnect_callback = proxy_disconnect_callback,
  .session_connected_callback = proxy_connected_callback,
  .add_segment_callback = proxy_add_segment_callback,
  .builtin_app_rx_callback = proxy_rx_callback,
  .builtin_app_tx_callback = proxy_tx_callback,
  .session_reset_callback = proxy_reset_callback,
  .session_cleanup_callback = proxy_cleanup_callback,
  .fifo_tuning_callback = common_fifo_tuning_callback,
};

static int
active_open_alloc_session_fifos (session_t *s)
{
  proxy_main_t *pm = &proxy_main;
  svm_fifo_t *rxf, *txf;
  proxy_session_t *ps;

  clib_spinlock_lock_if_init (&pm->sessions_lock);

  ps = proxy_session_get (s->opaque);

  txf = ps->server_rx_fifo;
  rxf = ps->server_tx_fifo;

  /*
   * Reset the active-open tx-fifo master indices so the active-open session
   * will receive data, etc.
   */
  txf->shr->master_session_index = s->session_index;
  txf->master_thread_index = s->thread_index;

  /*
   * Account for the active-open session's use of the fifos
   * so they won't disappear until the last session which uses
   * them disappears
   */
  rxf->refcnt++;
  txf->refcnt++;

  clib_spinlock_unlock_if_init (&pm->sessions_lock);

  s->rx_fifo = rxf;
  s->tx_fifo = txf;

  return 0;
}

static int
active_open_connected_callback (u32 app_index, u32 opaque,
				session_t * s, session_error_t err)
{
  proxy_main_t *pm = &proxy_main;
  proxy_session_t *ps;
  u8 thread_index = vlib_get_thread_index ();

  /*
   * Setup proxy session handle.
   */
  clib_spinlock_lock_if_init (&pm->sessions_lock);

  ps = proxy_session_get (opaque);

  /* Connection failed */
  if (err)
    {
      vnet_disconnect_args_t _a, *a = &_a;

      a->handle = ps->vpp_server_handle;
      a->app_index = pm->server_app_index;
      vnet_disconnect_session (a);
      ps->po_disconnected = 1;
    }
  else
    {
      ps->vpp_active_open_handle = session_handle (s);
      ps->active_open_establishing = 0;
    }

  /* Passive open session was already closed! */
  if (ps->po_disconnected)
    {
      /* Setup everything for the cleanup notification */
      ps->ao_disconnected = 1;
      clib_spinlock_unlock_if_init (&pm->sessions_lock);
      return -1;
    }

  s->opaque = opaque;

  clib_spinlock_unlock_if_init (&pm->sessions_lock);

  /*
   * Send event for active open tx fifo
   */
  ASSERT (s->thread_index == thread_index);
  if (svm_fifo_set_event (s->tx_fifo))
    session_send_io_evt_to_thread (s->tx_fifo, SESSION_IO_EVT_TX);

  return 0;
}

static void
active_open_reset_callback (session_t * s)
{
  proxy_try_close_session (s, 1 /* is_active_open */ );
}

static int
active_open_create_callback (session_t * s)
{
  return 0;
}

static void
active_open_disconnect_callback (session_t * s)
{
  proxy_try_close_session (s, 1 /* is_active_open */ );
}

static int
active_open_rx_callback (session_t * s)
{
  svm_fifo_t *proxy_tx_fifo;

  proxy_tx_fifo = s->rx_fifo;

  /*
   * Send event for server tx fifo
   */
  if (svm_fifo_set_event (proxy_tx_fifo))
    {
      u8 thread_index = proxy_tx_fifo->master_thread_index;
      u32 session_index = proxy_tx_fifo->shr->master_session_index;
      return session_send_io_evt_to_thread_custom (&session_index,
						   thread_index,
						   SESSION_IO_EVT_TX);
    }

  if (svm_fifo_max_enqueue (proxy_tx_fifo) <= TCP_MSS)
    svm_fifo_add_want_deq_ntf (proxy_tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);

  return 0;
}

static int
active_open_tx_callback (session_t * ao_s)
{
  proxy_main_t *pm = &proxy_main;
  proxy_session_t *ps;
  u32 min_free;

  min_free = clib_min (svm_fifo_size (ao_s->tx_fifo) >> 3, 128 << 10);
  if (svm_fifo_max_enqueue (ao_s->tx_fifo) < min_free)
    {
      svm_fifo_add_want_deq_ntf (ao_s->tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
      return 0;
    }

  clib_spinlock_lock_if_init (&pm->sessions_lock);

  ps = proxy_session_get_if_valid (ao_s->opaque);
  if (!ps)
    goto unlock;

  if (ps->vpp_server_handle == SESSION_INVALID_HANDLE)
    goto unlock;

  /* Force ack on proxy side to update rcv wnd */
  void *arg = uword_to_pointer (ps->vpp_server_handle, void *);
  session_send_rpc_evt_to_thread (
    session_thread_from_handle (ps->vpp_server_handle), proxy_force_ack, arg);

unlock:
  clib_spinlock_unlock_if_init (&pm->sessions_lock);

  return 0;
}

static void
active_open_cleanup_callback (session_t * s, session_cleanup_ntf_t ntf)
{
  if (ntf == SESSION_CLEANUP_TRANSPORT)
    return;

  proxy_try_delete_session (s, 1 /* is_active_open */ );
}

static session_cb_vft_t active_open_clients = {
  .session_reset_callback = active_open_reset_callback,
  .session_connected_callback = active_open_connected_callback,
  .session_accept_callback = active_open_create_callback,
  .session_disconnect_callback = active_open_disconnect_callback,
  .session_cleanup_callback = active_open_cleanup_callback,
  .builtin_app_rx_callback = active_open_rx_callback,
  .builtin_app_tx_callback = active_open_tx_callback,
  .fifo_tuning_callback = common_fifo_tuning_callback,
  .proxy_alloc_session_fifos = active_open_alloc_session_fifos,
};

static int
proxy_server_attach ()
{
  proxy_main_t *pm = &proxy_main;
  u64 options[APP_OPTIONS_N_OPTIONS];
  vnet_app_attach_args_t _a, *a = &_a;

  clib_memset (a, 0, sizeof (*a));
  clib_memset (options, 0, sizeof (options));

  a->name = format (0, "proxy-server");
  a->api_client_index = pm->server_client_index;
  a->session_cb_vft = &proxy_session_cb_vft;
  a->options = options;
  a->options[APP_OPTIONS_SEGMENT_SIZE] = pm->segment_size;
  a->options[APP_OPTIONS_ADD_SEGMENT_SIZE] = pm->segment_size;
  a->options[APP_OPTIONS_RX_FIFO_SIZE] = pm->fifo_size;
  a->options[APP_OPTIONS_TX_FIFO_SIZE] = pm->fifo_size;
  a->options[APP_OPTIONS_MAX_FIFO_SIZE] = pm->max_fifo_size;
  a->options[APP_OPTIONS_HIGH_WATERMARK] = (u64) pm->high_watermark;
  a->options[APP_OPTIONS_LOW_WATERMARK] = (u64) pm->low_watermark;
  a->options[APP_OPTIONS_PRIVATE_SEGMENT_COUNT] = pm->private_segment_count;
  a->options[APP_OPTIONS_PREALLOC_FIFO_PAIRS] =
    pm->prealloc_fifos ? pm->prealloc_fifos : 0;

  a->options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;

  if (vnet_application_attach (a))
    {
      clib_warning ("failed to attach server");
      return -1;
    }
  pm->server_app_index = a->app_index;

  vec_free (a->name);
  return 0;
}

static int
active_open_attach (void)
{
  proxy_main_t *pm = &proxy_main;
  vnet_app_attach_args_t _a, *a = &_a;
  u64 options[APP_OPTIONS_N_OPTIONS];

  clib_memset (a, 0, sizeof (*a));
  clib_memset (options, 0, sizeof (options));

  a->api_client_index = pm->active_open_client_index;
  a->session_cb_vft = &active_open_clients;
  a->name = format (0, "proxy-active-open");

  options[APP_OPTIONS_ACCEPT_COOKIE] = 0x12345678;
  options[APP_OPTIONS_SEGMENT_SIZE] = 512 << 20;
  options[APP_OPTIONS_RX_FIFO_SIZE] = pm->fifo_size;
  options[APP_OPTIONS_TX_FIFO_SIZE] = pm->fifo_size;
  options[APP_OPTIONS_MAX_FIFO_SIZE] = pm->max_fifo_size;
  options[APP_OPTIONS_HIGH_WATERMARK] = (u64) pm->high_watermark;
  options[APP_OPTIONS_LOW_WATERMARK] = (u64) pm->low_watermark;
  options[APP_OPTIONS_PRIVATE_SEGMENT_COUNT] = pm->private_segment_count;
  options[APP_OPTIONS_PREALLOC_FIFO_PAIRS] =
    pm->prealloc_fifos ? pm->prealloc_fifos : 0;

  options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN
    | APP_OPTIONS_FLAGS_IS_PROXY;

  a->options = options;

  if (vnet_application_attach (a))
    return -1;

  pm->active_open_app_index = a->app_index;

  vec_free (a->name);

  return 0;
}

static int
proxy_server_listen ()
{
  proxy_main_t *pm = &proxy_main;
  vnet_listen_args_t _a, *a = &_a;
  int rv;

  clib_memset (a, 0, sizeof (*a));

  a->app_index = pm->server_app_index;
  clib_memcpy (&a->sep_ext, &pm->server_sep, sizeof (pm->server_sep));
  if (proxy_transport_needs_crypto (a->sep.transport_proto))
    {
      session_endpoint_alloc_ext_cfg (&a->sep_ext,
				      TRANSPORT_ENDPT_EXT_CFG_CRYPTO);
      a->sep_ext.ext_cfg->crypto.ckpair_index = pm->ckpair_index;
    }

  rv = vnet_listen (a);
  if (a->sep_ext.ext_cfg)
    clib_mem_free (a->sep_ext.ext_cfg);

  return rv;
}

static void
proxy_server_add_ckpair (void)
{
  vnet_app_add_cert_key_pair_args_t _ck_pair, *ck_pair = &_ck_pair;
  proxy_main_t *pm = &proxy_main;

  clib_memset (ck_pair, 0, sizeof (*ck_pair));
  ck_pair->cert = (u8 *) test_srv_crt_rsa;
  ck_pair->key = (u8 *) test_srv_key_rsa;
  ck_pair->cert_len = test_srv_crt_rsa_len;
  ck_pair->key_len = test_srv_key_rsa_len;
  vnet_app_add_cert_key_pair (ck_pair);

  pm->ckpair_index = ck_pair->index;
}

static int
proxy_server_create (vlib_main_t * vm)
{
  vlib_thread_main_t *vtm = vlib_get_thread_main ();
  proxy_main_t *pm = &proxy_main;
  u32 num_threads;
  int i;

  num_threads = 1 /* main thread */  + vtm->n_threads;
  vec_validate (pm->rx_buf, num_threads - 1);

  for (i = 0; i < num_threads; i++)
    vec_validate (pm->rx_buf[i], pm->rcv_buffer_size);

  proxy_server_add_ckpair ();

  if (proxy_server_attach ())
    {
      clib_warning ("failed to attach server app");
      return -1;
    }
  if (proxy_server_listen ())
    {
      clib_warning ("failed to start listening");
      return -1;
    }
  if (active_open_attach ())
    {
      clib_warning ("failed to attach active open app");
      return -1;
    }

  return 0;
}

static clib_error_t *
proxy_server_create_command_fn (vlib_main_t * vm, unformat_input_t * input,
				vlib_cli_command_t * cmd)
{
  unformat_input_t _line_input, *line_input = &_line_input;
  char *default_server_uri = "tcp://0.0.0.0/23";
  char *default_client_uri = "tcp://6.0.2.2/23";
  u8 *server_uri = 0, *client_uri = 0;
  proxy_main_t *pm = &proxy_main;
  clib_error_t *error = 0;
  int rv, tmp32;
  u64 tmp64;

  pm->fifo_size = 64 << 10;
  pm->max_fifo_size = 128 << 20;
  pm->high_watermark = 80;
  pm->low_watermark = 50;
  pm->rcv_buffer_size = 1024;
  pm->prealloc_fifos = 0;
  pm->private_segment_count = 0;
  pm->segment_size = 512 << 20;

  if (vlib_num_workers ())
    clib_spinlock_init (&pm->sessions_lock);

  if (!unformat_user (input, unformat_line_input, line_input))
    return 0;

  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
    {
      if (unformat (line_input, "fifo-size %U", unformat_memory_size,
		    &pm->fifo_size))
	;
      else if (unformat (line_input, "max-fifo-size %U", unformat_memory_size,
			 &pm->max_fifo_size))
	;
      else if (unformat (line_input, "high-watermark %d", &tmp32))
	pm->high_watermark = (u8) tmp32;
      else if (unformat (line_input, "low-watermark %d", &tmp32))
	pm->low_watermark = (u8) tmp32;
      else if (unformat (line_input, "rcv-buf-size %d", &pm->rcv_buffer_size))
	;
      else if (unformat (line_input, "prealloc-fifos %d", &pm->prealloc_fifos))
	;
      else if (unformat (line_input, "private-segment-count %d",
			 &pm->private_segment_count))
	;
      else if (unformat (line_input, "private-segment-size %U",
			 unformat_memory_size, &tmp64))
	{
	  pm->segment_size = tmp64;
	}
      else if (unformat (line_input, "server-uri %s", &server_uri))
	vec_add1 (server_uri, 0);
      else if (unformat (line_input, "client-uri %s", &client_uri))
	vec_add1 (client_uri, 0);
      else
	{
	  error = clib_error_return (0, "unknown input `%U'",
				     format_unformat_error, line_input);
	  goto done;
	}
    }

  if (!server_uri)
    {
      clib_warning ("No server-uri provided, Using default: %s",
		    default_server_uri);
      server_uri = format (0, "%s%c", default_server_uri, 0);
    }
  if (!client_uri)
    {
      clib_warning ("No client-uri provided, Using default: %s",
		    default_client_uri);
      client_uri = format (0, "%s%c", default_client_uri, 0);
    }

  if (parse_uri ((char *) server_uri, &pm->server_sep))
    {
      error = clib_error_return (0, "Invalid server uri %v", server_uri);
      goto done;
    }
  if (parse_uri ((char *) client_uri, &pm->client_sep))
    {
      error = clib_error_return (0, "Invalid client uri %v", client_uri);
      goto done;
    }

  session_enable_disable_args_t args = { .is_en = 1,
					 .rt_engine_type =
					   RT_BACKEND_ENGINE_RULE_TABLE };
  vnet_session_enable_disable (vm, &args);

  rv = proxy_server_create (vm);
  switch (rv)
    {
    case 0:
      break;
    default:
      error = clib_error_return (0, "server_create returned %d", rv);
    }

done:
  unformat_free (line_input);
  vec_free (client_uri);
  vec_free (server_uri);
  return error;
}

VLIB_CLI_COMMAND (proxy_create_command, static) =
{
  .path = "test proxy server",
  .short_help = "test proxy server [server-uri <tcp://ip/port>]"
      "[client-uri <tcp://ip/port>][fifo-size <nn>[k|m]]"
      "[max-fifo-size <nn>[k|m]][high-watermark <nn>]"
      "[low-watermark <nn>][rcv-buf-size <nn>][prealloc-fifos <nn>]"
      "[private-segment-size <mem>][private-segment-count <nn>]",
  .function = proxy_server_create_command_fn,
};

clib_error_t *
proxy_main_init (vlib_main_t * vm)
{
  proxy_main_t *pm = &proxy_main;
  pm->server_client_index = ~0;
  pm->active_open_client_index = ~0;

  return 0;
}

VLIB_INIT_FUNCTION (proxy_main_init);

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