http_static: refactor to use http transport

Type: refactor

Signed-off-by: Florin Coras <fcoras@cisco.com>
Change-Id: I66396a1879eb3c87ef64783eab82a22896413cd0

5 files changed, 276 insertions, 774 deletions

diff --git a/src/plugins/http/http.c b/src/plugins/http/http.c
index 683b2a4d135..a6a6af1f42f 100644
--- a/src/plugins/http/http.c
+++ b/src/plugins/http/http.c
@@ -19,6 +19,8 @@
 
 static http_main_t http_main;
 
+#define HTTP_FIFO_THRESH (16 << 10)
+
 const char *http_status_code_str[] = {
 #define _(c, s, str) str,
   foreach_http_status_code
@@ -126,7 +128,7 @@ http_ts_accept_callback (session_t *ts)
   session_t *ts_listener, *as, *asl;
   app_worker_t *app_wrk;
   http_conn_t *lhc, *hc;
-  u32 hc_index;
+  u32 hc_index, thresh;
   int rv;
 
   ts_listener = listen_session_get_from_handle (ts->listener_handle);
@@ -186,6 +188,13 @@ http_ts_accept_callback (session_t *ts)
       return rv;
     }
 
+  /* Avoid enqueuing small chunks of data on transport tx notifications. If
+   * the fifo is small (under 16K) we set the threshold to it's size, meaning
+   * a notification will be given when the fifo empties.
+   */
+  thresh = clib_min (svm_fifo_size (ts->tx_fifo), HTTP_FIFO_THRESH);
+  svm_fifo_set_deq_thresh (ts->tx_fifo, thresh);
+
   http_conn_timer_start (hc);
 
   return 0;
@@ -532,7 +541,7 @@ state_send_more_data (http_conn_t *hc, transport_send_params_t *sp)
       if (sent && svm_fifo_set_event (ts->tx_fifo))
 	session_send_io_evt_to_thread (ts->tx_fifo, SESSION_IO_EVT_TX);
 
-      if (svm_fifo_max_enqueue (ts->tx_fifo) < 16 << 10)
+      if (svm_fifo_max_enqueue (ts->tx_fifo) < HTTP_FIFO_THRESH)
 	{
 	  /* Deschedule http session and wait for deq notification if
 	   * underlying ts tx fifo almost full */
@@ -832,6 +841,17 @@ http_app_tx_callback (void *session, transport_send_params_t *sp)
   return 0;
 }
 
+static void
+http_transport_get_endpoint (u32 hc_index, u32 thread_index,
+			     transport_endpoint_t *tep, u8 is_lcl)
+{
+  http_conn_t *hc = http_conn_get_w_thread (hc_index, thread_index);
+  session_t *ts;
+
+  ts = session_get_from_handle (hc->h_tc_session_handle);
+  session_get_endpoint (ts, tep, is_lcl);
+}
+
 static u8 *
 format_http_connection (u8 *s, va_list *args)
 {
@@ -937,6 +957,7 @@ static const transport_proto_vft_t http_proto = {
   .custom_tx = http_app_tx_callback,
   .get_connection = http_transport_get_connection,
   .get_listener = http_transport_get_listener,
+  .get_transport_endpoint = http_transport_get_endpoint,
   .format_connection = format_http_transport_connection,
   .format_listener = format_http_transport_listener,
   .transport_options = {
diff --git a/src/plugins/http/http.h b/src/plugins/http/http.h
index a75e6bcdacb..b0eca7bf9a8 100644
--- a/src/plugins/http/http.h
+++ b/src/plugins/http/http.h
@@ -95,6 +95,7 @@ typedef enum http_content_type_
 #define foreach_http_status_code                                              \
   _ (200, OK, "200 OK")                                                       \
   _ (400, BAD_REQUEST, "400 Bad Request")                                     \
+  _ (404, NOT_FOUND, "404 Not Found")                                         \
   _ (405, METHOD_NOT_ALLOWED, "405 Method Not Allowed")                       \
   _ (500, INTERNAL_ERROR, "500 Internal Server Error")
 
diff --git a/src/plugins/http_static/http_static.c b/src/plugins/http_static/http_static.c
index 48ae593718a..4e611a6a378 100644
--- a/src/plugins/http_static/http_static.c
+++ b/src/plugins/http_static/http_static.c
@@ -47,11 +47,10 @@ static void vl_api_http_static_enable_t_handler
   mp->uri[ARRAY_LEN (mp->uri) - 1] = 0;
   mp->www_root[ARRAY_LEN (mp->www_root) - 1] = 0;
 
-  rv = http_static_server_enable_api
-    (ntohl (mp->fifo_size),
-     ntohl (mp->cache_size_limit),
-     ntohl (mp->prealloc_fifos),
-     ntohl (mp->private_segment_size), mp->www_root, mp->uri);
+  rv =
+    hss_enable_api (ntohl (mp->fifo_size), ntohl (mp->cache_size_limit),
+		    ntohl (mp->prealloc_fifos),
+		    ntohl (mp->private_segment_size), mp->www_root, mp->uri);
 
   REPLY_MACRO (VL_API_HTTP_STATIC_ENABLE_REPLY);
 }
diff --git a/src/plugins/http_static/http_static.h b/src/plugins/http_static/http_static.h
index 8ee0f92cd44..bc0d937d21a 100644
--- a/src/plugins/http_static/http_static.h
+++ b/src/plugins/http_static/http_static.h
@@ -66,18 +66,10 @@ typedef enum
 
 typedef enum
 {
-  CALLED_FROM_RX,
-  CALLED_FROM_TX,
-  CALLED_FROM_TIMER,
-} http_state_machine_called_from_t;
-
-typedef enum
-{
   HTTP_BUILTIN_METHOD_GET = 0,
   HTTP_BUILTIN_METHOD_POST,
 } http_builtin_method_type_t;
 
-
 /** \brief Application session
  */
 typedef struct
@@ -107,8 +99,6 @@ typedef struct
 
   /** File cache pool index */
   u32 cache_pool_index;
-  /** state machine called from... */
-  http_state_machine_called_from_t called_from;
 } http_session_t;
 
 /** \brief In-memory file data cache entry
@@ -136,16 +126,11 @@ typedef struct
   /** Per thread vector of session pools */
   http_session_t **sessions;
   /** Session pool reader writer lock */
-  clib_rwlock_t sessions_lock;
-  /** vpp session to http session index map */
-  u32 **session_to_http_session;
+  clib_spinlock_t cache_lock;
 
   /** Enable debug messages */
   int debug_level;
 
-  /** vpp message/event queue */
-  svm_msg_q_t **vpp_queue;
-
   /** Unified file data cache pool */
   file_data_cache_t *cache_pool;
   /** Hash table which maps file name to file data */
@@ -169,27 +154,17 @@ typedef struct
   /** root path to be served */
   u8 *www_root;
 
-  /** Server's event queue */
-  svm_queue_t *vl_input_queue;
-
-  /** API client handle */
-  u32 my_client_index;
-
   /** Application index */
   u32 app_index;
 
-  /** Process node index for event scheduling */
-  u32 node_index;
-
   /** Cert and key pair for tls */
   u32 ckpair_index;
 
-  /** Session cleanup timer wheel */
-  tw_timer_wheel_2t_1w_2048sl_t tw;
-  clib_spinlock_t tw_lock;
+  vlib_main_t *vlib_main;
 
-  /** Time base, so we can generate browser cache control http spew */
-  clib_timebase_t timebase;
+  /*
+   * Config
+   */
 
   /** Number of preallocated fifos, usually 0 */
   u32 prealloc_fifos;
@@ -199,15 +174,14 @@ typedef struct
   u32 fifo_size;
   /** The bind URI, defaults to tcp://0.0.0.0/80 */
   u8 *uri;
-  vlib_main_t *vlib_main;
-} http_static_server_main_t;
+  /** Threshold for switching to ptr data in http msgs */
+  u32 use_ptr_thresh;
+} hss_main_t;
 
-extern http_static_server_main_t http_static_server_main;
+extern hss_main_t hss_main;
 
-int http_static_server_enable_api (u32 fifo_size, u32 cache_limit,
-				   u32 prealloc_fifos,
-				   u32 private_segment_size,
-				   u8 * www_root, u8 * uri);
+int hss_enable_api (u32 fifo_size, u32 cache_limit, u32 prealloc_fifos,
+		    u32 private_segment_size, u8 *www_root, u8 *uri);
 
 void http_static_server_register_builtin_handler
   (void *fp, char *url, int type);
diff --git a/src/plugins/http_static/static_server.c b/src/plugins/http_static/static_server.c
index f2c1cfc2d66..68613470a8a 100644
--- a/src/plugins/http_static/static_server.c
+++ b/src/plugins/http_static/static_server.c
@@ -24,6 +24,7 @@
 #include <http_static/http_static.h>
 
 #include <vppinfra/bihash_template.c>
+#include <http/http.h>
 
 /** @file static_server.c
  *  Static http server, sufficient to
@@ -31,115 +32,29 @@
  */
 /*? %%clicmd:group_label Static HTTP Server %% ?*/
 
-#define HTTP_FIFO_THRESH (16 << 10)
+#define HSS_FIFO_THRESH (16 << 10)
 
-http_static_server_main_t http_static_server_main;
+hss_main_t hss_main;
 
-/** \brief Format the called-from enum
- */
-
-static u8 *
-format_state_machine_called_from (u8 * s, va_list * args)
-{
-  http_state_machine_called_from_t cf =
-    va_arg (*args, http_state_machine_called_from_t);
-  char *which = "bogus!";
-
-  switch (cf)
-    {
-    case CALLED_FROM_RX:
-      which = "from rx";
-      break;
-    case CALLED_FROM_TX:
-      which = "from tx";
-      break;
-    case CALLED_FROM_TIMER:
-      which = "from timer";
-      break;
-
-    default:
-      break;
-    }
-
-  s = format (s, "%s", which);
-  return s;
-}
-
-
-/** \brief Acquire reader lock on the sessions pools
- */
-static void
-http_static_server_sessions_reader_lock (void)
-{
-  clib_rwlock_reader_lock (&http_static_server_main.sessions_lock);
-}
-
-/** \brief Drop reader lock on the sessions pools
- */
-static void
-http_static_server_sessions_reader_unlock (void)
-{
-  clib_rwlock_reader_unlock (&http_static_server_main.sessions_lock);
-}
-
-/** \brief Acquire writer lock on the sessions pools
- */
-static void
-http_static_server_sessions_writer_lock (void)
-{
-  clib_rwlock_writer_lock (&http_static_server_main.sessions_lock);
-}
-
-/** \brief Drop writer lock on the sessions pools
- */
 static void
-http_static_server_sessions_writer_unlock (void)
+hss_cache_lock (void)
 {
-  clib_rwlock_writer_unlock (&http_static_server_main.sessions_lock);
+  clib_spinlock_lock (&hss_main.cache_lock);
 }
 
-/** \brief Start a session cleanup timer
- */
 static void
-http_static_server_session_timer_start (http_session_t * hs)
+hss_cache_unlock (void)
 {
-  http_static_server_main_t *hsm = &http_static_server_main;
-  u32 hs_handle;
-
-  /* The session layer may fire a callback at a later date... */
-  if (!pool_is_free (hsm->sessions[hs->thread_index], hs))
-    {
-      hs_handle = hs->thread_index << 24 | hs->session_index;
-      clib_spinlock_lock (&http_static_server_main.tw_lock);
-      hs->timer_handle = tw_timer_start_2t_1w_2048sl
-	(&http_static_server_main.tw, hs_handle, 0, 60);
-      clib_spinlock_unlock (&http_static_server_main.tw_lock);
-    }
+  clib_spinlock_unlock (&hss_main.cache_lock);
 }
 
-/** \brief stop a session cleanup timer
- */
-static void
-http_static_server_session_timer_stop (http_session_t * hs)
-{
-  if (hs->timer_handle == ~0)
-    return;
-  clib_spinlock_lock (&http_static_server_main.tw_lock);
-  tw_timer_stop_2t_1w_2048sl (&http_static_server_main.tw, hs->timer_handle);
-  clib_spinlock_unlock (&http_static_server_main.tw_lock);
-}
-
-/** \brief Allocate an http session
- */
 static http_session_t *
-http_static_server_session_alloc (u32 thread_index)
+hss_session_alloc (u32 thread_index)
 {
-  http_static_server_main_t *hsm = &http_static_server_main;
+  hss_main_t *hsm = &hss_main;
   http_session_t *hs;
-  pool_get_aligned_zero_numa (hsm->sessions[thread_index], hs,
-			      0 /* not aligned */ ,
-			      1 /* zero */ ,
-			      os_get_numa_index ());
+
+  pool_get_zero (hsm->sessions[thread_index], hs);
   hs->session_index = hs - hsm->sessions[thread_index];
   hs->thread_index = thread_index;
   hs->timer_handle = ~0;
@@ -147,26 +62,20 @@ http_static_server_session_alloc (u32 thread_index)
   return hs;
 }
 
-/** \brief Get an http session by index
- */
 static http_session_t *
-http_static_server_session_get (u32 thread_index, u32 hs_index)
+hss_session_get (u32 thread_index, u32 hs_index)
 {
-  http_static_server_main_t *hsm = &http_static_server_main;
+  hss_main_t *hsm = &hss_main;
   if (pool_is_free_index (hsm->sessions[thread_index], hs_index))
     return 0;
   return pool_elt_at_index (hsm->sessions[thread_index], hs_index);
 }
 
-/** \brief Free an http session
- */
 static void
-http_static_server_session_free (http_session_t * hs)
+hss_session_free (http_session_t *hs)
 {
-  http_static_server_main_t *hsm = &http_static_server_main;
+  hss_main_t *hsm = &hss_main;
 
-  /* Make sure the timer is stopped... */
-  http_static_server_session_timer_stop (hs);
   pool_put (hsm->sessions[hs->thread_index], hs);
 
   if (CLIB_DEBUG)
@@ -180,50 +89,12 @@ http_static_server_session_free (http_session_t * hs)
     }
 }
 
-/** \brief add a session to the vpp < -- > http session index map
- */
-static void
-http_static_server_session_lookup_add (u32 thread_index, u32 s_index,
-				       u32 hs_index)
-{
-  http_static_server_main_t *hsm = &http_static_server_main;
-  vec_validate (hsm->session_to_http_session[thread_index], s_index);
-  hsm->session_to_http_session[thread_index][s_index] = hs_index;
-}
-
-/** \brief Remove a session from the vpp < -- > http session index map
- */
-static void
-http_static_server_session_lookup_del (u32 thread_index, u32 s_index)
-{
-  http_static_server_main_t *hsm = &http_static_server_main;
-  hsm->session_to_http_session[thread_index][s_index] = ~0;
-}
-
-/** \brief lookup a session in the vpp < -- > http session index map
- */
-
-static http_session_t *
-http_static_server_session_lookup (u32 thread_index, u32 s_index)
-{
-  http_static_server_main_t *hsm = &http_static_server_main;
-  u32 hs_index;
-
-  if (s_index < vec_len (hsm->session_to_http_session[thread_index]))
-    {
-      hs_index = hsm->session_to_http_session[thread_index][s_index];
-      return http_static_server_session_get (thread_index, hs_index);
-    }
-  return 0;
-}
-
 /** \brief Detach cache entry from session
  */
-
 static void
-http_static_server_detach_cache_entry (http_session_t * hs)
+hss_detach_cache_entry (http_session_t *hs)
 {
-  http_static_server_main_t *hsm = &http_static_server_main;
+  hss_main_t *hsm = &hss_main;
   file_data_cache_t *ep;
 
   /*
@@ -251,129 +122,18 @@ http_static_server_detach_cache_entry (http_session_t * hs)
 /** \brief Disconnect a session
  */
 static void
-http_static_server_session_disconnect (http_session_t * hs)
+hss_session_disconnect_transport (http_session_t *hs)
 {
   vnet_disconnect_args_t _a = { 0 }, *a = &_a;
   a->handle = hs->vpp_session_handle;
-  a->app_index = http_static_server_main.app_index;
+  a->app_index = hss_main.app_index;
   vnet_disconnect_session (a);
 }
 
-/* *INDENT-OFF* */
-/** \brief http error boilerplate
- */
-static const char *http_error_template =
-    "HTTP/1.1 %s\r\n"
-    "Date: %U GMT\r\n"
-    "Content-Type: text/html\r\n"
-    "Connection: close\r\n"
-    "Pragma: no-cache\r\n"
-    "Content-Length: 0\r\n\r\n";
-
-/** \brief http response boilerplate
- */
-static const char *http_response_template =
-    "Date: %U GMT\r\n"
-    "Expires: %U GMT\r\n"
-    "Server: VPP Static\r\n"
-    "Content-Type: %s\r\n"
-    "Content-Length: %d\r\n\r\n";
-
-/* *INDENT-ON* */
-
-/** \brief send http data
-    @param hs - http session
-    @param data - the data vector to transmit
-    @param length - length of data
-    @param offset - transmit offset for this operation
-    @return offset for next transmit operation, may be unchanged w/ full fifo
-*/
-
-static u32
-static_send_data (http_session_t * hs, u8 * data, u32 length, u32 offset)
-{
-  u32 bytes_to_send;
-  http_static_server_main_t *hsm = &http_static_server_main;
-
-  bytes_to_send = length - offset;
-
-  while (bytes_to_send > 0)
-    {
-      int actual_transfer;
-
-      actual_transfer = svm_fifo_enqueue (
-	hs->tx_fifo, clib_min (bytes_to_send, 4 << 20), data + offset);
-
-      /* Made any progress? */
-      if (actual_transfer <= 0)
-	{
-	  if (hsm->debug_level > 0 && bytes_to_send > 0)
-	    clib_warning ("WARNING: still %d bytes to send", bytes_to_send);
-	  return offset;
-	}
-      else
-	{
-	  offset += actual_transfer;
-	  bytes_to_send -= actual_transfer;
-
-	  if (hsm->debug_level && bytes_to_send > 0)
-	    clib_warning ("WARNING: still %d bytes to send", bytes_to_send);
-
-	  if (svm_fifo_set_event (hs->tx_fifo))
-	    session_send_io_evt_to_thread (hs->tx_fifo,
-					   SESSION_IO_EVT_TX_FLUSH);
-	  return offset;
-	}
-    }
-  /* NOTREACHED */
-  return ~0;
-}
-
-/** \brief Send an http error string
-    @param hs - the http session
-    @param str - the error string, e.g. "404 Not Found"
-*/
-static void
-send_error (http_session_t * hs, char *str)
-{
-  http_static_server_main_t *hsm = &http_static_server_main;
-  u8 *data;
-  f64 now;
-
-  now = clib_timebase_now (&hsm->timebase);
-  data = format (0, http_error_template, str, format_clib_timebase_time, now);
-  static_send_data (hs, data, vec_len (data), 0);
-  vec_free (data);
-}
-
-/** \brief Retrieve data from the application layer
- */
-static int
-session_rx_request (http_session_t * hs)
-{
-  u32 max_dequeue, cursize;
-  int n_read;
-
-  cursize = vec_len (hs->rx_buf);
-  max_dequeue = svm_fifo_max_dequeue (hs->rx_fifo);
-  if (PREDICT_FALSE (max_dequeue == 0))
-    return -1;
-
-  vec_validate (hs->rx_buf, cursize + max_dequeue - 1);
-  n_read = app_recv_stream_raw (hs->rx_fifo, hs->rx_buf + cursize,
-				max_dequeue, 0, 0 /* peek */ );
-  ASSERT (n_read == max_dequeue);
-  if (svm_fifo_is_empty (hs->rx_fifo))
-    svm_fifo_unset_event (hs->rx_fifo);
-
-  _vec_len (hs->rx_buf) = cursize + n_read;
-  return 0;
-}
-
 /** \brief Sanity-check the forward and reverse LRU lists
  */
 static inline void
-lru_validate (http_static_server_main_t * hsm)
+lru_validate (hss_main_t *hsm)
 {
 #if CLIB_DEBUG > 0
   f64 last_timestamp;
@@ -418,7 +178,7 @@ lru_validate (http_static_server_main_t * hsm)
 /** \brief Remove a data cache entry from the LRU lists
  */
 static inline void
-lru_remove (http_static_server_main_t * hsm, file_data_cache_t * ep)
+lru_remove (hss_main_t *hsm, file_data_cache_t *ep)
 {
   file_data_cache_t *next_ep, *prev_ep;
   u32 ep_index;
@@ -450,9 +210,8 @@ lru_remove (http_static_server_main_t * hsm, file_data_cache_t * ep)
 
 /** \brief Add an entry to the LRU lists, tag w/ supplied timestamp
  */
-
 static inline void
-lru_add (http_static_server_main_t * hsm, file_data_cache_t * ep, f64 now)
+lru_add (hss_main_t *hsm, file_data_cache_t *ep, f64 now)
 {
   file_data_cache_t *next_ep;
   u32 ep_index;
@@ -487,46 +246,19 @@ lru_add (http_static_server_main_t * hsm, file_data_cache_t * ep, f64 now)
 
 /** \brief Remove and re-add a cache entry from/to the LRU lists
  */
-
 static inline void
-lru_update (http_static_server_main_t * hsm, file_data_cache_t * ep, f64 now)
+lru_update (hss_main_t *hsm, file_data_cache_t *ep, f64 now)
 {
   lru_remove (hsm, ep);
   lru_add (hsm, ep, now);
 }
 
-/** \brief Session-layer (main) data rx callback.
-    Parse the http request, and reply to it.
-    Future extensions might include POST processing, active content, etc.
-*/
-
-/* svm_fifo_add_want_deq_ntf (tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF_IF_FULL)
-get shoulder-tap when transport dequeues something, set in
-xmit routine. */
-
-/** \brief closed state - should never really get here
- */
-static int
-state_closed (session_t * s, http_session_t * hs,
-	      http_state_machine_called_from_t cf)
-{
-  clib_warning ("WARNING: http session %d, called from %U",
-		hs->session_index, format_state_machine_called_from, cf);
-  return -1;
-}
-
-static void
-close_session (http_session_t * hs)
-{
-  http_static_server_session_disconnect (hs);
-}
-
 /** \brief Register a builtin GET or POST handler
  */
 __clib_export void http_static_server_register_builtin_handler
   (void *fp, char *url, int request_type)
 {
-  http_static_server_main_t *hsm = &http_static_server_main;
+  hss_main_t *hsm = &hss_main;
   uword *p, *builtin_table;
 
   builtin_table = (request_type == HTTP_BUILTIN_METHOD_GET)
@@ -554,92 +286,70 @@ __clib_export void http_static_server_register_builtin_handler
     hsm->post_url_handlers = builtin_table;
 }
 
-static int
-v_find_index (u8 * vec, char *str)
+static void
+start_send_data (http_session_t *hs, http_status_code_t status)
 {
-  int start_index;
-  u32 slen = (u32) strnlen_s_inline (str, 8);
-  u32 vlen = vec_len (vec);
+  http_msg_t msg;
+  session_t *ts;
+  int rv;
 
-  ASSERT (slen > 0);
+  ts = session_get (hs->vpp_session_index, hs->thread_index);
 
-  if (vlen <= slen)
-    return -1;
+  msg.type = HTTP_MSG_REPLY;
+  msg.code = status;
+  msg.content_type = HTTP_CONTENT_TEXT_HTML;
+  msg.data.len = vec_len (hs->data);
 
-  for (start_index = 0; start_index < (vlen - slen); start_index++)
+  if (vec_len (hs->data) > hss_main.use_ptr_thresh)
     {
-      if (!memcmp (vec, str, slen))
-	return start_index;
-    }
+      msg.data.type = HTTP_MSG_DATA_PTR;
+      rv = svm_fifo_enqueue (ts->tx_fifo, sizeof (msg), (u8 *) &msg);
+      ASSERT (rv == sizeof (msg));
 
-  return -1;
-}
+      uword data = pointer_to_uword (hs->data);
+      rv = svm_fifo_enqueue (ts->tx_fifo, sizeof (data), (u8 *) &data);
+      ASSERT (rv == sizeof (sizeof (data)));
 
-/** \brief established state - waiting for GET, POST, etc.
- */
-static int
-state_established (session_t * s, http_session_t * hs,
-		   http_state_machine_called_from_t cf)
-{
-  http_static_server_main_t *hsm = &http_static_server_main;
-  u8 *request = 0;
-  u8 *path;
-  int i, rv;
-  struct stat _sb, *sb = &_sb;
-  clib_error_t *error;
-  u8 request_type = HTTP_BUILTIN_METHOD_GET;
-  u8 save_byte = 0;
-  uword *p, *builtin_table;
+      goto done;
+    }
 
-  /* Read data from the sessison layer */
-  rv = session_rx_request (hs);
+  msg.data.type = HTTP_MSG_DATA_INLINE;
 
-  /* No data? Odd, but stay in this state and await further instructions */
-  if (rv)
-    return 0;
+  rv = svm_fifo_enqueue (ts->tx_fifo, sizeof (msg), (u8 *) &msg);
+  ASSERT (rv == sizeof (msg));
 
-  /* Process the client request */
-  request = hs->rx_buf;
-  if (vec_len (request) < 8)
-    {
-      send_error (hs, "400 Bad Request");
-      close_session (hs);
-      return -1;
-    }
+  if (!msg.data.len)
+    goto done;
 
-  if ((i = v_find_index (request, "GET ")) >= 0)
-    goto find_end;
-  else if ((i = v_find_index (request, "POST ")) >= 0)
+  rv = svm_fifo_enqueue (ts->tx_fifo, vec_len (hs->data), hs->data);
+
+  if (rv != vec_len (hs->data))
     {
-      request_type = HTTP_BUILTIN_METHOD_POST;
-      goto find_end;
+      hs->data_offset = rv;
+      svm_fifo_add_want_deq_ntf (ts->tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
     }
 
-  if (hsm->debug_level > 1)
-    clib_warning ("Unknown http method");
-
-  send_error (hs, "405 Method Not Allowed");
-  close_session (hs);
-  return -1;
+done:
 
-find_end:
+  if (svm_fifo_set_event (ts->tx_fifo))
+    session_send_io_evt_to_thread (ts->tx_fifo, SESSION_IO_EVT_TX);
+}
 
-  /* Lose "GET " or "POST " */
-  vec_delete (request, i + 5 + request_type, 0);
+static int
+find_data (http_session_t *hs, http_req_method_t rt, u8 *request)
+{
+  hss_main_t *hsm = &hss_main;
+  u8 *path;
+  struct stat _sb, *sb = &_sb;
+  clib_error_t *error;
+  u8 request_type = HTTP_BUILTIN_METHOD_GET;
+  uword *p, *builtin_table;
+  http_status_code_t sc = HTTP_STATUS_OK;
 
-  /* Temporarily drop in a NULL byte for lookup purposes */
-  for (i = 0; i < vec_len (request); i++)
-    {
-      if (request[i] == ' ' || request[i] == '?')
-	{
-	  save_byte = request[i];
-	  request[i] = 0;
-	  break;
-	}
-    }
+  request_type = rt == HTTP_REQ_GET ? request_type : HTTP_BUILTIN_METHOD_POST;
 
   /*
-   * Now we can construct the file to open
+   * Construct the file to open
    * Browsers are capable of sporadically including a leading '/'
    */
   if (request[0] == '/')
@@ -657,9 +367,6 @@ find_end:
 
   p = hash_get_mem (builtin_table, request);
 
-  if (save_byte != 0)
-    request[i] = save_byte;
-
   if (p)
     {
       int rv;
@@ -672,22 +379,10 @@ find_end:
 	  clib_warning ("builtin handler %llx hit on %s '%s' but failed!",
 			p[0], (request_type == HTTP_BUILTIN_METHOD_GET) ?
 			"GET" : "POST", request);
-	  send_error (hs, "404 Not Found");
-	  close_session (hs);
-	  return -1;
+
+	  sc = HTTP_STATUS_NOT_FOUND;
 	}
-      vec_reset_length (hs->rx_buf);
-      goto send_ok;
-    }
-  vec_reset_length (hs->rx_buf);
-  /* poison request, it's not valid anymore */
-  request = 0;
-  /* The static server itself doesn't do POSTs */
-  if (request_type == HTTP_BUILTIN_METHOD_POST)
-    {
-      send_error (hs, "404 Not Found");
-      close_session (hs);
-      return -1;
+      goto done;
     }
 
   /* Try to find the file. 2x special cases to find index.html */
@@ -711,10 +406,8 @@ find_end:
 	      || sb->st_size < 20	/* file too small */
 	      || (sb->st_mode & S_IFMT) != S_IFREG /* not a regular file */ )
 	    {
-	      vec_free (path);
-	      send_error (hs, "404 Not Found");
-	      close_session (hs);
-	      return -1;
+	      sc = HTTP_STATUS_NOT_FOUND;
+	      goto done;
 	    }
 	  else
 	    {
@@ -723,6 +416,7 @@ find_end:
 	      u16 local_port;
 	      int print_port = 0;
 	      u8 *port_str = 0;
+	      session_t *ts;
 
 	      /*
 	       * To make this bit work correctly, we need to know our local
@@ -732,11 +426,12 @@ find_end:
 
 	      vec_delete (path, vec_len (hsm->www_root) - 1, 0);
 
-	      session_get_endpoint (s, &endpoint, 1 /* is_local */ );
+	      ts = session_get (hs->vpp_session_index, hs->thread_index);
+	      session_get_endpoint (ts, &endpoint, 1 /* is_local */);
 
 	      local_port = clib_net_to_host_u16 (endpoint.port);
 
-	      proto = session_type_transport_proto (s->session_type);
+	      proto = session_type_transport_proto (ts->session_type);
 
 	      if ((proto == TRANSPORT_PROTO_TCP && local_port != 80)
 		  || (proto == TRANSPORT_PROTO_TLS && local_port != 443))
@@ -756,13 +451,8 @@ find_end:
 
 	      vec_free (port_str);
 
-	      static_send_data (hs, redirect, vec_len (redirect), 0);
-	      hs->session_state = HTTP_STATE_CLOSED;
-	      hs->path = 0;
-	      vec_free (redirect);
-	      vec_free (path);
-	      close_session (hs);
-	      return -1;
+	      hs->data = redirect;
+	      goto done;
 	    }
 	}
     }
@@ -782,6 +472,8 @@ find_end:
 	  if (hsm->debug_level > 1)
 	    clib_warning ("lookup '%s' returned %lld", kv.key, kv.value);
 
+	  hss_cache_lock ();
+
 	  /* found the data.. */
 	  dp = pool_elt_at_index (hsm->cache_pool, kv.value);
 	  hs->data = dp->data;
@@ -792,9 +484,13 @@ find_end:
 	  if (hsm->debug_level > 1)
 	    clib_warning ("index %d refcnt now %d", hs->cache_pool_index,
 			  dp->inuse);
+
+	  hss_cache_unlock ();
 	}
       else
 	{
+	  hss_cache_lock ();
+
 	  if (hsm->debug_level > 1)
 	    clib_warning ("lookup '%s' failed", kv.key, kv.value);
 	  /* Need to recycle one (or more cache) entries? */
@@ -844,13 +540,12 @@ find_end:
 	    {
 	      clib_warning ("Error reading '%s'", hs->path);
 	      clib_error_report (error);
-	      vec_free (hs->path);
-	      close_session (hs);
-	      return -1;
+	      sc = HTTP_STATUS_INTERNAL_ERROR;
+	      hss_cache_unlock ();
+	      goto done;
 	    }
 	  /* Create a cache entry for it */
-	  pool_get (hsm->cache_pool, dp);
-	  memset (dp, 0, sizeof (*dp));
+	  pool_get_zero (hsm->cache_pool, dp);
 	  dp->filename = vec_dup (hs->path);
 	  dp->data = hs->data;
 	  hs->cache_pool_index = dp - hsm->cache_pool;
@@ -871,187 +566,103 @@ find_end:
 	      clib_warning ("BUG: add failed!");
 	    }
 	  hsm->cache_size += vec_len (dp->data);
+
+	  hss_cache_unlock ();
 	}
       hs->data_offset = 0;
     }
-  /* send 200 OK first */
-send_ok:
-  static_send_data (hs, (u8 *) "HTTP/1.1 200 OK\r\n", 17, 0);
-  hs->session_state = HTTP_STATE_OK_SENT;
-  return 1;
+
+done:
+
+  return sc;
 }
 
 static int
-state_send_more_data (session_t * s, http_session_t * hs,
-		      http_state_machine_called_from_t cf)
+hss_ts_rx_callback (session_t *ts)
 {
+  http_session_t *hs;
+  u8 *request = 0;
+  http_msg_t msg;
+  int rv;
+  http_status_code_t sc;
 
-  /* Start sending data */
-  hs->data_offset = static_send_data (hs, hs->data, vec_len (hs->data),
-				      hs->data_offset);
+  hs = hss_session_get (ts->thread_index, ts->opaque);
 
-  /* Did we finish? */
-  if (hs->data_offset < vec_len (hs->data))
+  /* Read the http message header */
+  rv = svm_fifo_dequeue (ts->rx_fifo, sizeof (msg), (u8 *) &msg);
+  ASSERT (rv == sizeof (msg));
+
+  if (msg.type != HTTP_MSG_REQUEST ||
+      (msg.method_type != HTTP_REQ_GET && msg.method_type != HTTP_REQ_POST))
     {
-      /* No: ask for a shoulder-tap when the tx fifo has space */
-      svm_fifo_add_want_deq_ntf (hs->tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
-      hs->session_state = HTTP_STATE_SEND_MORE_DATA;
+      hs->data = 0;
+      start_send_data (hs, HTTP_STATUS_METHOD_NOT_ALLOWED);
       return 0;
     }
-  /* Finished with this transaction, back to HTTP_STATE_ESTABLISHED */
 
-  /* Let go of the file cache entry */
-  http_static_server_detach_cache_entry (hs);
-  hs->session_state = HTTP_STATE_ESTABLISHED;
-  return 0;
-}
+  /* Read request */
+  vec_validate (request, msg.data.len - 1);
+  rv = svm_fifo_dequeue (ts->rx_fifo, msg.data.len, request);
+  ASSERT (rv == msg.data.len);
 
-static int
-state_sent_ok (session_t * s, http_session_t * hs,
-	       http_state_machine_called_from_t cf)
-{
-  http_static_server_main_t *hsm = &http_static_server_main;
-  char *suffix;
-  char *http_type;
-  u8 *http_response;
-  f64 now;
-  u32 offset;
-
-  /* What kind of dog food are we serving? */
-  suffix = (char *) (hs->path + vec_len (hs->path) - 1);
-  while ((u8 *) suffix >= hs->path && *suffix != '.')
-    suffix--;
-  suffix++;
-  http_type = "text/html";
-  if (!clib_strcmp (suffix, "css"))
-    http_type = "text/css";
-  else if (!clib_strcmp (suffix, "js"))
-    http_type = "text/javascript";
-  else if (!clib_strcmp (suffix, "json"))
-    http_type = "application/json";
+  /* Find and send data */
+  sc = find_data (hs, msg.method_type, request);
+  start_send_data (hs, sc);
 
-  if (hs->data == 0)
-    {
-      clib_warning ("BUG: hs->data not set for session %d",
-		    hs->session_index);
-      close_session (hs);
-      return 0;
-    }
-
-  /*
-   * Send an http response, which needs the current time,
-   * the expiration time, and the data length
-   */
-  now = clib_timebase_now (&hsm->timebase);
-  http_response = format (0, http_response_template,
-			  /* Date */
-			  format_clib_timebase_time, now,
-			  /* Expires */
-			  format_clib_timebase_time, now + 600.0,
-			  http_type, vec_len (hs->data));
-  offset = static_send_data (hs, http_response, vec_len (http_response), 0);
-  if (offset != vec_len (http_response))
-    {
-      clib_warning ("BUG: couldn't send response header!");
-      close_session (hs);
-      return 0;
-    }
-  vec_free (http_response);
+  vec_free (request);
+  if (!hs->data)
+    hss_session_disconnect_transport (hs);
 
-  /* Send data from the beginning... */
-  hs->data_offset = 0;
-  hs->session_state = HTTP_STATE_SEND_MORE_DATA;
-  return 1;
+  return 0;
 }
 
-static void *state_funcs[HTTP_STATE_N_STATES] = {
-  state_closed,
-  /* Waiting for GET, POST, etc. */
-  state_established,
-  /* Sent OK */
-  state_sent_ok,
-  /* Send more data */
-  state_send_more_data,
-};
-
-static inline int
-http_static_server_rx_tx_callback (session_t * s,
-				   http_state_machine_called_from_t cf)
+static int
+hss_ts_tx_callback (session_t *ts)
 {
   http_session_t *hs;
-  int (*fp) (session_t *, http_session_t *, http_state_machine_called_from_t);
+  u32 to_send;
   int rv;
 
-  /* Acquire a reader lock on the session table */
-  http_static_server_sessions_reader_lock ();
-  hs = http_static_server_session_lookup (s->thread_index, s->session_index);
+  hs = hss_session_get (ts->thread_index, ts->opaque);
+  if (!hs || !hs->data)
+    return 0;
 
-  if (!hs)
+  to_send = vec_len (hs->data) - hs->data_offset;
+  rv = svm_fifo_enqueue (ts->tx_fifo, to_send, hs->data + hs->data_offset);
+
+  if (rv <= 0)
     {
-      clib_warning ("No http session for thread %d session_index %d",
-		    s->thread_index, s->session_index);
-      http_static_server_sessions_reader_unlock ();
+      svm_fifo_add_want_deq_ntf (ts->tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
       return 0;
     }
 
-  /* Execute state machine for this session */
-  do
+  if (rv < to_send)
     {
-      fp = state_funcs[hs->session_state];
-      rv = (*fp) (s, hs, cf);
-      if (rv < 0)
-	goto session_closed;
+      hs->data_offset += rv;
+      svm_fifo_add_want_deq_ntf (ts->tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
     }
-  while (rv);
 
-  /* Reset the session expiration timer */
-  http_static_server_session_timer_stop (hs);
-  http_static_server_session_timer_start (hs);
+  if (svm_fifo_set_event (ts->tx_fifo))
+    session_send_io_evt_to_thread (ts->tx_fifo, SESSION_IO_EVT_TX);
 
-session_closed:
-  http_static_server_sessions_reader_unlock ();
   return 0;
 }
 
-static int
-http_static_server_rx_callback (session_t * s)
-{
-  return http_static_server_rx_tx_callback (s, CALLED_FROM_RX);
-}
-
-static int
-http_static_server_tx_callback (session_t * s)
-{
-  return http_static_server_rx_tx_callback (s, CALLED_FROM_TX);
-}
-
-
 /** \brief Session accept callback
  */
-
 static int
-http_static_server_session_accept_callback (session_t * s)
+hss_ts_accept_callback (session_t *ts)
 {
-  http_static_server_main_t *hsm = &http_static_server_main;
   http_session_t *hs;
   u32 thresh;
 
-  hsm->vpp_queue[s->thread_index] =
-    session_main_get_vpp_event_queue (s->thread_index);
+  hs = hss_session_alloc (ts->thread_index);
 
-  http_static_server_sessions_writer_lock ();
-
-  hs = http_static_server_session_alloc (s->thread_index);
-  http_static_server_session_lookup_add (s->thread_index, s->session_index,
-					 hs->session_index);
-  hs->rx_fifo = s->rx_fifo;
-  hs->tx_fifo = s->tx_fifo;
-  hs->vpp_session_index = s->session_index;
-  hs->vpp_session_handle = session_handle (s);
+  hs->rx_fifo = ts->rx_fifo;
+  hs->tx_fifo = ts->tx_fifo;
+  hs->vpp_session_index = ts->session_index;
+  hs->vpp_session_handle = session_handle (ts);
   hs->session_state = HTTP_STATE_ESTABLISHED;
-  http_static_server_session_timer_start (hs);
-
-  http_static_server_sessions_writer_unlock ();
 
   /* The application sets a threshold for it's fifo to get notified when
    * additional data can be enqueued. We want to keep the TX fifo reasonably
@@ -1061,99 +672,83 @@ http_static_server_session_accept_callback (session_t * s)
    * the threshold to it's size, meaning a notification will be given when the
    * fifo empties.
    */
-  thresh = clib_min (svm_fifo_size (hs->tx_fifo), HTTP_FIFO_THRESH);
-  svm_fifo_set_deq_thresh (hs->tx_fifo, thresh);
+  thresh = clib_min (svm_fifo_size (ts->tx_fifo), HSS_FIFO_THRESH);
+  svm_fifo_set_deq_thresh (ts->tx_fifo, thresh);
 
-  s->session_state = SESSION_STATE_READY;
+  ts->opaque = hs->session_index;
+  ts->session_state = SESSION_STATE_READY;
   return 0;
 }
 
-/** \brief Session disconnect callback
- */
-
 static void
-http_static_server_session_disconnect_callback (session_t * s)
+hss_ts_disconnect_callback (session_t *ts)
 {
-  http_static_server_main_t *hsm = &http_static_server_main;
+  hss_main_t *hsm = &hss_main;
   vnet_disconnect_args_t _a = { 0 }, *a = &_a;
 
-  a->handle = session_handle (s);
+  a->handle = session_handle (ts);
   a->app_index = hsm->app_index;
   vnet_disconnect_session (a);
 }
 
-/** \brief Session reset callback
- */
-
 static void
-http_static_server_session_reset_callback (session_t * s)
+hss_ts_reset_callback (session_t *ts)
 {
-  http_static_server_main_t *hsm = &http_static_server_main;
+  hss_main_t *hsm = &hss_main;
   vnet_disconnect_args_t _a = { 0 }, *a = &_a;
 
-  a->handle = session_handle (s);
+  a->handle = session_handle (ts);
   a->app_index = hsm->app_index;
   vnet_disconnect_session (a);
 }
 
 static int
-http_static_server_session_connected_callback (u32 app_index, u32 api_context,
-					       session_t * s,
-					       session_error_t err)
+hss_ts_connected_callback (u32 app_index, u32 api_context, session_t *ts,
+			   session_error_t err)
 {
   clib_warning ("called...");
   return -1;
 }
 
 static int
-http_static_server_add_segment_callback (u32 client_index, u64 segment_handle)
+hss_add_segment_callback (u32 client_index, u64 segment_handle)
 {
   return 0;
 }
 
 static void
-http_static_session_cleanup (session_t * s, session_cleanup_ntf_t ntf)
+hss_ts_cleanup (session_t *s, session_cleanup_ntf_t ntf)
 {
   http_session_t *hs;
 
   if (ntf == SESSION_CLEANUP_TRANSPORT)
     return;
 
-  http_static_server_sessions_writer_lock ();
-
-  hs = http_static_server_session_lookup (s->thread_index, s->session_index);
+  hs = hss_session_get (s->thread_index, s->opaque);
   if (!hs)
-    goto done;
+    return;
 
-  http_static_server_detach_cache_entry (hs);
-  http_static_server_session_lookup_del (hs->thread_index,
-					 hs->vpp_session_index);
+  hss_detach_cache_entry (hs);
   vec_free (hs->rx_buf);
-  http_static_server_session_free (hs);
-
-done:
-  http_static_server_sessions_writer_unlock ();
+  hss_session_free (hs);
 }
 
-/** \brief Session-layer virtual function table
- */
-static session_cb_vft_t http_static_server_session_cb_vft = {
-  .session_accept_callback = http_static_server_session_accept_callback,
-  .session_disconnect_callback =
-    http_static_server_session_disconnect_callback,
-  .session_connected_callback = http_static_server_session_connected_callback,
-  .add_segment_callback = http_static_server_add_segment_callback,
-  .builtin_app_rx_callback = http_static_server_rx_callback,
-  .builtin_app_tx_callback = http_static_server_tx_callback,
-  .session_reset_callback = http_static_server_session_reset_callback,
-  .session_cleanup_callback = http_static_session_cleanup,
+static session_cb_vft_t hss_cb_vft = {
+  .session_accept_callback = hss_ts_accept_callback,
+  .session_disconnect_callback = hss_ts_disconnect_callback,
+  .session_connected_callback = hss_ts_connected_callback,
+  .add_segment_callback = hss_add_segment_callback,
+  .builtin_app_rx_callback = hss_ts_rx_callback,
+  .builtin_app_tx_callback = hss_ts_tx_callback,
+  .session_reset_callback = hss_ts_reset_callback,
+  .session_cleanup_callback = hss_ts_cleanup,
 };
 
 static int
 http_static_server_attach ()
 {
   vnet_app_add_cert_key_pair_args_t _ck_pair, *ck_pair = &_ck_pair;
-  http_static_server_main_t *hsm = &http_static_server_main;
+  hss_main_t *hsm = &hss_main;
   u64 options[APP_OPTIONS_N_OPTIONS];
   vnet_app_attach_args_t _a, *a = &_a;
   u32 segment_size = 128 << 20;
@@ -1166,7 +761,7 @@ http_static_server_attach ()
 
   a->api_client_index = ~0;
   a->name = format (0, "test_http_static_server");
-  a->session_cb_vft = &http_static_server_session_cb_vft;
+  a->session_cb_vft = &hss_cb_vft;
   a->options = options;
   a->options[APP_OPTIONS_SEGMENT_SIZE] = segment_size;
   a->options[APP_OPTIONS_ADD_SEGMENT_SIZE] = segment_size;
@@ -1199,19 +794,20 @@ http_static_server_attach ()
 }
 
 static int
-http_static_transport_needs_crypto (transport_proto_t proto)
+hss_transport_needs_crypto (transport_proto_t proto)
 {
   return proto == TRANSPORT_PROTO_TLS || proto == TRANSPORT_PROTO_DTLS ||
 	 proto == TRANSPORT_PROTO_QUIC;
 }
 
 static int
-http_static_server_listen ()
+hss_listen (void)
 {
-  http_static_server_main_t *hsm = &http_static_server_main;
+  hss_main_t *hsm = &hss_main;
   session_endpoint_cfg_t sep = SESSION_ENDPOINT_CFG_NULL;
   vnet_listen_args_t _a, *a = &_a;
   char *uri = "tcp://0.0.0.0/80";
+  u8 need_crypto;
   int rv;
 
   clib_memset (a, 0, sizeof (*a));
@@ -1223,8 +819,12 @@ http_static_server_listen ()
   if (parse_uri (uri, &sep))
     return -1;
 
+  need_crypto = hss_transport_needs_crypto (a->sep_ext.transport_proto);
+
+  sep.transport_proto = TRANSPORT_PROTO_HTTP;
   clib_memcpy (&a->sep_ext, &sep, sizeof (sep));
-  if (http_static_transport_needs_crypto (a->sep_ext.transport_proto))
+
+  if (need_crypto)
     {
       session_endpoint_alloc_ext_cfg (&a->sep_ext,
 				      TRANSPORT_ENDPT_EXT_CFG_CRYPTO);
@@ -1232,107 +832,31 @@ http_static_server_listen ()
     }
 
   rv = vnet_listen (a);
-  if (a->sep_ext.ext_cfg)
-    clib_mem_free (a->sep_ext.ext_cfg);
-  return rv;
-}
-
-static void
-http_static_server_session_close_cb (void *hs_handlep)
-{
-  http_static_server_main_t *hsm = &http_static_server_main;
-  http_session_t *hs;
-  uword hs_handle;
-  hs_handle = pointer_to_uword (hs_handlep);
-  hs =
-    http_static_server_session_get (hs_handle >> 24, hs_handle & 0x00FFFFFF);
-
-  if (hsm->debug_level > 1)
-    clib_warning ("terminate thread %d index %d hs %llx",
-		  hs_handle >> 24, hs_handle & 0x00FFFFFF, hs);
-  if (!hs)
-    return;
-  hs->timer_handle = ~0;
-  http_static_server_session_disconnect (hs);
-}
 
-/** \brief Expired session timer-wheel callback
- */
-static void
-http_expired_timers_dispatch (u32 * expired_timers)
-{
-  u32 hs_handle;
-  int i;
-
-  for (i = 0; i < vec_len (expired_timers); i++)
-    {
-      /* Get session handle. The first bit is the timer id */
-      hs_handle = expired_timers[i] & 0x7FFFFFFF;
-      session_send_rpc_evt_to_thread (hs_handle >> 24,
-				      http_static_server_session_close_cb,
-				      uword_to_pointer (hs_handle, void *));
-    }
-}
-
-/** \brief Timer-wheel expiration process
- */
-static uword
-http_static_server_process (vlib_main_t * vm, vlib_node_runtime_t * rt,
-			    vlib_frame_t * f)
-{
-  http_static_server_main_t *hsm = &http_static_server_main;
-  f64 now, timeout = 1.0;
-  uword *event_data = 0;
-  uword __clib_unused event_type;
-
-  while (1)
-    {
-      vlib_process_wait_for_event_or_clock (vm, timeout);
-      now = vlib_time_now (vm);
-      event_type = vlib_process_get_events (vm, (uword **) & event_data);
-
-      /* expire timers */
-      clib_spinlock_lock (&http_static_server_main.tw_lock);
-      tw_timer_expire_timers_2t_1w_2048sl (&hsm->tw, now);
-      clib_spinlock_unlock (&http_static_server_main.tw_lock);
+  if (need_crypto)
+    clib_mem_free (a->sep_ext.ext_cfg);
 
-      vec_reset_length (event_data);
-    }
-  return 0;
+  return rv;
 }
 
-/* *INDENT-OFF* */
-VLIB_REGISTER_NODE (http_static_server_process_node) =
-{
-  .function = http_static_server_process,
-  .type = VLIB_NODE_TYPE_PROCESS,
-  .name = "static-http-server-process",
-  .state = VLIB_NODE_STATE_DISABLED,
-};
-/* *INDENT-ON* */
-
 static int
-http_static_server_create (vlib_main_t * vm)
+hss_create (vlib_main_t *vm)
 {
   vlib_thread_main_t *vtm = vlib_get_thread_main ();
-  http_static_server_main_t *hsm = &http_static_server_main;
+  hss_main_t *hsm = &hss_main;
   u32 num_threads;
-  vlib_node_t *n;
 
   num_threads = 1 /* main thread */  + vtm->n_threads;
-  vec_validate (hsm->vpp_queue, num_threads - 1);
   vec_validate (hsm->sessions, num_threads - 1);
-  vec_validate (hsm->session_to_http_session, num_threads - 1);
 
-  clib_rwlock_init (&hsm->sessions_lock);
-  clib_spinlock_init (&hsm->tw_lock);
+  clib_spinlock_init (&hsm->cache_lock);
 
   if (http_static_server_attach ())
     {
       clib_warning ("failed to attach server");
       return -1;
     }
-  if (http_static_server_listen ())
+  if (hss_listen ())
     {
       clib_warning ("failed to start listening");
       return -1;
@@ -1344,26 +868,16 @@ http_static_server_create (vlib_main_t * vm)
   hsm->get_url_handlers = hash_create_string (0, sizeof (uword));
   hsm->post_url_handlers = hash_create_string (0, sizeof (uword));
 
-  /* Init timer wheel and process */
-  tw_timer_wheel_init_2t_1w_2048sl (&hsm->tw, http_expired_timers_dispatch,
-				    1.0 /* timer interval */ , ~0);
-  vlib_node_set_state (vm, http_static_server_process_node.index,
-		       VLIB_NODE_STATE_POLLING);
-  n = vlib_get_node (vm, http_static_server_process_node.index);
-  vlib_start_process (vm, n->runtime_index);
-
   return 0;
 }
 
 /** \brief API helper function for vl_api_http_static_enable_t messages
  */
 int
-http_static_server_enable_api (u32 fifo_size, u32 cache_limit,
-			       u32 prealloc_fifos,
-			       u32 private_segment_size,
-			       u8 * www_root, u8 * uri)
+hss_enable_api (u32 fifo_size, u32 cache_limit, u32 prealloc_fifos,
+		u32 private_segment_size, u8 *www_root, u8 *uri)
 {
-  http_static_server_main_t *hsm = &http_static_server_main;
+  hss_main_t *hsm = &hss_main;
   int rv;
 
   hsm->fifo_size = fifo_size;
@@ -1376,12 +890,12 @@ http_static_server_enable_api (u32 fifo_size, u32 cache_limit,
   if (vec_len (hsm->www_root) < 2)
     return VNET_API_ERROR_INVALID_VALUE;
 
-  if (hsm->my_client_index != ~0)
+  if (hsm->app_index != ~0)
     return VNET_API_ERROR_APP_ALREADY_ATTACHED;
 
   vnet_session_enable_disable (hsm->vlib_main, 1 /* turn on TCP, etc. */ );
 
-  rv = http_static_server_create (hsm->vlib_main);
+  rv = hss_create (hsm->vlib_main);
   switch (rv)
     {
     case 0:
@@ -1395,11 +909,10 @@ http_static_server_enable_api (u32 fifo_size, u32 cache_limit,
 }
 
 static clib_error_t *
-http_static_server_create_command_fn (vlib_main_t * vm,
-				      unformat_input_t * input,
-				      vlib_cli_command_t * cmd)
+hss_create_command_fn (vlib_main_t *vm, unformat_input_t *input,
+		       vlib_cli_command_t *cmd)
 {
-  http_static_server_main_t *hsm = &http_static_server_main;
+  hss_main_t *hsm = &hss_main;
   unformat_input_t _line_input, *line_input = &_line_input;
   u64 seg_size;
   u8 *www_root = 0;
@@ -1451,6 +964,9 @@ http_static_server_create_command_fn (vlib_main_t * vm,
 	;
       else if (unformat (line_input, "debug"))
 	hsm->debug_level = 1;
+      else if (unformat (line_input, "ptr-thresh %U", unformat_memory_size,
+			 &hsm->use_ptr_thresh))
+	;
       else
 	return clib_error_return (0, "unknown input `%U'",
 				  format_unformat_error, line_input);
@@ -1463,7 +979,7 @@ http_static_server_create_command_fn (vlib_main_t * vm,
       return clib_error_return (0, "Must specify www-root <path>");
     }
 
-  if (hsm->my_client_index != (u32) ~ 0)
+  if (hsm->app_index != (u32) ~0)
     {
       vec_free (www_root);
       return clib_error_return (0, "http server already running...");
@@ -1473,7 +989,7 @@ http_static_server_create_command_fn (vlib_main_t * vm,
 
   vnet_session_enable_disable (vm, 1 /* turn on TCP, etc. */ );
 
-  rv = http_static_server_create (vm);
+  rv = hss_create (vm);
   switch (rv)
     {
     case 0:
@@ -1498,20 +1014,20 @@ http_static_server_create_command_fn (vlib_main_t * vm,
  *   [private-segment-size <nnMG>] [fifo-size <nbytes>] [uri <uri>]}
 ?*/
 /* *INDENT-OFF* */
-VLIB_CLI_COMMAND (http_static_server_create_command, static) =
-{
+VLIB_CLI_COMMAND (hss_create_command, static) = {
   .path = "http static server",
-  .short_help = "http static server www-root <path> [prealloc-fifos <nn>]\n"
-  "[private-segment-size <nnMG>] [fifo-size <nbytes>] [uri <uri>]\n"
-  "[debug [nn]]\n",
-  .function = http_static_server_create_command_fn,
+  .short_help =
+    "http static server www-root <path> [prealloc-fifos <nn>]\n"
+    "[private-segment-size <nnMG>] [fifo-size <nbytes>] [uri <uri>]\n"
+    "[ptr-thresh <nn>][debug [nn]]\n",
+  .function = hss_create_command_fn,
 };
 /* *INDENT-ON* */
 
 /** \brief format a file cache entry
  */
 u8 *
-format_hsm_cache_entry (u8 * s, va_list * args)
+format_hss_cache_entry (u8 *s, va_list *args)
 {
   file_data_cache_t *ep = va_arg (*args, file_data_cache_t *);
   f64 now = va_arg (*args, f64);
@@ -1528,7 +1044,7 @@ format_hsm_cache_entry (u8 * s, va_list * args)
 }
 
 u8 *
-format_http_session_state (u8 * s, va_list * args)
+format_hss_session_state (u8 *s, va_list *args)
 {
   http_session_state_t state = va_arg (*args, http_session_state_t);
   char *state_string = "bogus!";
@@ -1555,13 +1071,13 @@ format_http_session_state (u8 * s, va_list * args)
 }
 
 u8 *
-format_http_session (u8 * s, va_list * args)
+format_hss_session (u8 *s, va_list *args)
 {
   http_session_t *hs = va_arg (*args, http_session_t *);
   int verbose = va_arg (*args, int);
 
-  s = format (s, "[%d]: state %U", hs->session_index,
-	      format_http_session_state, hs->session_state);
+  s = format (s, "[%d]: state %U", hs->session_index, format_hss_session_state,
+	      hs->session_state);
   if (verbose > 0)
     {
       s = format (s, "\n path %s, data length %u, data_offset %u",
@@ -1572,11 +1088,10 @@ format_http_session (u8 * s, va_list * args)
 }
 
 static clib_error_t *
-http_show_static_server_command_fn (vlib_main_t * vm,
-				    unformat_input_t * input,
-				    vlib_cli_command_t * cmd)
+hss_show_command_fn (vlib_main_t *vm, unformat_input_t *input,
+		     vlib_cli_command_t *cmd)
 {
-  http_static_server_main_t *hsm = &http_static_server_main;
+  hss_main_t *hsm = &hss_main;
   file_data_cache_t *ep, **entries = 0;
   int verbose = 0;
   int show_cache = 0;
@@ -1618,14 +1133,13 @@ http_show_static_server_command_fn (vlib_main_t * vm,
 
       now = vlib_time_now (vm);
 
-      vlib_cli_output (vm, "%U", format_hsm_cache_entry, 0 /* header */ ,
-		       now);
+      vlib_cli_output (vm, "%U", format_hss_cache_entry, 0 /* header */, now);
 
       for (index = hsm->first_index; index != ~0;)
 	{
 	  ep = pool_elt_at_index (hsm->cache_pool, index);
 	  index = ep->next_index;
-	  vlib_cli_output (vm, "%U", format_hsm_cache_entry, ep, now);
+	  vlib_cli_output (vm, "%U", format_hss_cache_entry, ep, now);
 	}
 
       vlib_cli_output (vm, "%40s%12lld", "Total Size", hsm->cache_size);
@@ -1639,7 +1153,7 @@ http_show_static_server_command_fn (vlib_main_t * vm,
       http_session_t *hs;
       int i, j;
 
-      http_static_server_sessions_reader_lock ();
+      hss_cache_lock ();
 
       for (i = 0; i < vec_len (hsm->sessions); i++)
 	{
@@ -1652,14 +1166,14 @@ http_show_static_server_command_fn (vlib_main_t * vm,
 
 	  for (j = 0; j < vec_len (session_indices); j++)
 	    {
-	      vlib_cli_output (vm, "%U", format_http_session,
-			       pool_elt_at_index
-			       (hsm->sessions[i], session_indices[j]),
-			       verbose);
+	      vlib_cli_output (
+		vm, "%U", format_hss_session,
+		pool_elt_at_index (hsm->sessions[i], session_indices[j]),
+		verbose);
 	    }
 	  vec_reset_length (session_indices);
 	}
-      http_static_server_sessions_reader_unlock ();
+      hss_cache_unlock ();
       vec_free (session_indices);
     }
   return 0;
@@ -1676,20 +1190,18 @@ http_show_static_server_command_fn (vlib_main_t * vm,
  * @cliexcmd{show http static server sessions cache [verbose [nn]]}
 ?*/
 /* *INDENT-OFF* */
-VLIB_CLI_COMMAND (http_show_static_server_command, static) =
-{
+VLIB_CLI_COMMAND (hss_show_command, static) = {
   .path = "show http static server",
   .short_help = "show http static server sessions cache [verbose [<nn>]]",
-  .function = http_show_static_server_command_fn,
+  .function = hss_show_command_fn,
 };
 /* *INDENT-ON* */
 
 static clib_error_t *
-http_clear_static_cache_command_fn (vlib_main_t * vm,
-				    unformat_input_t * input,
-				    vlib_cli_command_t * cmd)
+hss_clear_cache_command_fn (vlib_main_t *vm, unformat_input_t *input,
+			    vlib_cli_command_t *cmd)
 {
-  http_static_server_main_t *hsm = &http_static_server_main;
+  hss_main_t *hsm = &hss_main;
   file_data_cache_t *dp;
   u32 free_index;
   u32 busy_items = 0;
@@ -1698,7 +1210,7 @@ http_clear_static_cache_command_fn (vlib_main_t * vm,
   if (hsm->www_root == 0)
     return clib_error_return (0, "Static server disabled");
 
-  http_static_server_sessions_reader_lock ();
+  hss_cache_lock ();
 
   /* Walk the LRU list to find active entries */
   free_index = hsm->last_index;
@@ -1731,7 +1243,7 @@ http_clear_static_cache_command_fn (vlib_main_t * vm,
       pool_put (hsm->cache_pool, dp);
       free_index = hsm->last_index;
     }
-  http_static_server_sessions_reader_unlock ();
+  hss_cache_unlock ();
   if (busy_items > 0)
     vlib_cli_output (vm, "Note: %d busy items still in cache...", busy_items);
   else
@@ -1751,31 +1263,26 @@ http_clear_static_cache_command_fn (vlib_main_t * vm,
  * @cliexcmd{clear http static cache}
 ?*/
 /* *INDENT-OFF* */
-VLIB_CLI_COMMAND (clear_http_static_cache_command, static) =
-{
+VLIB_CLI_COMMAND (clear_hss_cache_command, static) = {
   .path = "clear http static cache",
   .short_help = "clear http static cache",
-  .function = http_clear_static_cache_command_fn,
+  .function = hss_clear_cache_command_fn,
 };
 /* *INDENT-ON* */
 
 static clib_error_t *
-http_static_server_main_init (vlib_main_t * vm)
+hss_main_init (vlib_main_t *vm)
 {
-  http_static_server_main_t *hsm = &http_static_server_main;
+  hss_main_t *hsm = &hss_main;
 
-  hsm->my_client_index = ~0;
+  hsm->app_index = ~0;
   hsm->vlib_main = vm;
   hsm->first_index = hsm->last_index = ~0;
 
-  clib_timebase_init (&hsm->timebase, 0 /* GMT */ ,
-		      CLIB_TIMEBASE_DAYLIGHT_NONE,
-		      &vm->clib_time /* share the system clock */ );
-
   return 0;
 }
 
-VLIB_INIT_FUNCTION (http_static_server_main_init);
+VLIB_INIT_FUNCTION (hss_main_init);
 
 /*
  * fd.io coding-style-patch-verification: ON