X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fplugins%2Ftlsopenssl%2Ftls_openssl.c;h=964230f178ffa083a1bb1257a53448ea04cc5f55;hb=b85de19145a01d3acdf326c3cfa4e94b585bb59f;hp=f25ac9f580d460a4fc052615f542f66903cf3b71;hpb=3017af9ab2bc83f4b909e3858e20fbf5259ec00a;p=vpp.git

diff --git a/src/plugins/tlsopenssl/tls_openssl.c b/src/plugins/tlsopenssl/tls_openssl.c
index f25ac9f580d..964230f178f 100644
--- a/src/plugins/tlsopenssl/tls_openssl.c
+++ b/src/plugins/tlsopenssl/tls_openssl.c
@@ -26,18 +26,19 @@
 #include <vnet/tls/tls.h>
 #include <ctype.h>
 #include <tlsopenssl/tls_openssl.h>
+#include <tlsopenssl/tls_bios.h>
 
 #define MAX_CRYPTO_LEN 64
 
 openssl_main_t openssl_main;
+
 static u32
-openssl_ctx_alloc (void)
+openssl_ctx_alloc_w_thread (u32 thread_index)
 {
-  u8 thread_index = vlib_get_thread_index ();
-  openssl_main_t *tm = &openssl_main;
+  openssl_main_t *om = &openssl_main;
   openssl_ctx_t **ctx;
 
-  pool_get (tm->ctx_pool[thread_index], ctx);
+  pool_get (om->ctx_pool[thread_index], ctx);
   if (!(*ctx))
     *ctx = clib_mem_alloc (sizeof (openssl_ctx_t));
 
@@ -45,28 +46,73 @@ openssl_ctx_alloc (void)
   (*ctx)->ctx.c_thread_index = thread_index;
   (*ctx)->ctx.tls_ctx_engine = CRYPTO_ENGINE_OPENSSL;
   (*ctx)->ctx.app_session_handle = SESSION_INVALID_HANDLE;
-  (*ctx)->openssl_ctx_index = ctx - tm->ctx_pool[thread_index];
+  (*ctx)->openssl_ctx_index = ctx - om->ctx_pool[thread_index];
   return ((*ctx)->openssl_ctx_index);
 }
 
+static u32
+openssl_ctx_alloc (void)
+{
+  return openssl_ctx_alloc_w_thread (vlib_get_thread_index ());
+}
+
 static void
 openssl_ctx_free (tls_ctx_t * ctx)
 {
   openssl_ctx_t *oc = (openssl_ctx_t *) ctx;
 
-  if (SSL_is_init_finished (oc->ssl) && !ctx->is_passive_close)
-    SSL_shutdown (oc->ssl);
+  /* Cleanup ssl ctx unless migrated */
+  if (!ctx->is_migrated)
+    {
+      if (SSL_is_init_finished (oc->ssl) && !ctx->is_passive_close)
+	SSL_shutdown (oc->ssl);
 
-  SSL_free (oc->ssl);
+      SSL_free (oc->ssl);
+      vec_free (ctx->srv_hostname);
 
 #ifdef HAVE_OPENSSL_ASYNC
   openssl_evt_free (ctx->evt_index, ctx->c_thread_index);
 #endif
-  vec_free (ctx->srv_hostname);
+    }
+
   pool_put_index (openssl_main.ctx_pool[ctx->c_thread_index],
 		  oc->openssl_ctx_index);
 }
 
+static void *
+openssl_ctx_detach (tls_ctx_t *ctx)
+{
+  openssl_ctx_t *oc = (openssl_ctx_t *) ctx, *oc_copy;
+
+  oc_copy = clib_mem_alloc (sizeof (*oc_copy));
+  clib_memcpy (oc_copy, oc, sizeof (*oc));
+
+  return oc_copy;
+}
+
+static u32
+openssl_ctx_attach (u32 thread_index, void *ctx_ptr)
+{
+  openssl_main_t *om = &openssl_main;
+  session_handle_t sh;
+  openssl_ctx_t **oc;
+
+  pool_get (om->ctx_pool[thread_index], oc);
+  /* Free the old instance instead of looking for an empty spot */
+  if (*oc)
+    clib_mem_free (*oc);
+
+  *oc = ctx_ptr;
+  (*oc)->openssl_ctx_index = oc - om->ctx_pool[thread_index];
+  (*oc)->ctx.c_thread_index = thread_index;
+
+  sh = (*oc)->ctx.tls_session_handle;
+  BIO_set_data ((*oc)->rbio, uword_to_pointer (sh, void *));
+  BIO_set_data ((*oc)->wbio, uword_to_pointer (sh, void *));
+
+  return ((*oc)->openssl_ctx_index);
+}
+
 tls_ctx_t *
 openssl_ctx_get (u32 ctx_index)
 {
@@ -109,72 +155,33 @@ openssl_lctx_get (u32 lctx_index)
   return pool_elt_at_index (openssl_main.lctx_pool, lctx_index);
 }
 
-static int
-openssl_read_from_bio_into_fifo (svm_fifo_t * f, BIO * bio)
-{
-  u32 enq_now, enq_max;
-  svm_fifo_chunk_t *c;
-  int read, rv;
-
-  enq_max = svm_fifo_max_enqueue_prod (f);
-  if (!enq_max)
-    return 0;
-
-  svm_fifo_fill_chunk_list (f);
-
-  enq_now = clib_min (svm_fifo_max_write_chunk (f), enq_max);
-  if (!enq_now)
-    return 0;
-
-  read = BIO_read (bio, svm_fifo_tail (f), enq_now);
-  if (read <= 0)
-    return 0;
-
-  c = svm_fifo_tail_chunk (f);
-  while ((c = c->next) && read < enq_max)
-    {
-      enq_now = clib_min (c->length, enq_max - read);
-      rv = BIO_read (bio, c->data, enq_now);
-      read += rv > 0 ? rv : 0;
-
-      if (rv < enq_now)
-	break;
-    }
-
-  svm_fifo_enqueue_nocopy (f, read);
-
-  return read;
-}
-
 static int
 openssl_read_from_ssl_into_fifo (svm_fifo_t * f, SSL * ssl)
 {
-  u32 enq_now, enq_max;
-  svm_fifo_chunk_t *c;
-  int read, rv;
+  int read, rv, n_fs, i;
+  const int n_segs = 2;
+  svm_fifo_seg_t fs[n_segs];
+  u32 max_enq;
 
-  enq_max = svm_fifo_max_enqueue_prod (f);
-  if (!enq_max)
+  max_enq = svm_fifo_max_enqueue_prod (f);
+  if (!max_enq)
     return 0;
 
-  svm_fifo_fill_chunk_list (f);
-
-  enq_now = clib_min (svm_fifo_max_write_chunk (f), enq_max);
-  if (!enq_now)
+  n_fs = svm_fifo_provision_chunks (f, fs, n_segs, max_enq);
+  if (n_fs < 0)
     return 0;
 
-  read = SSL_read (ssl, svm_fifo_tail (f), enq_now);
+  /* Return early if we can't read anything */
+  read = SSL_read (ssl, fs[0].data, fs[0].len);
   if (read <= 0)
     return 0;
 
-  c = svm_fifo_tail_chunk (f);
-  while ((c = c->next) && read < enq_max)
+  for (i = 1; i < n_fs; i++)
     {
-      enq_now = clib_min (c->length, enq_max - read);
-      rv = SSL_read (ssl, c->data, enq_now);
+      rv = SSL_read (ssl, fs[i].data, fs[i].len);
       read += rv > 0 ? rv : 0;
 
-      if (rv < enq_now)
+      if (rv < (int) fs[i].len)
 	break;
     }
 
@@ -184,90 +191,31 @@ openssl_read_from_ssl_into_fifo (svm_fifo_t * f, SSL * ssl)
 }
 
 static int
-openssl_write_from_fifo_into_bio (svm_fifo_t * f, BIO * bio, u32 len)
-{
-  svm_fifo_chunk_t *c;
-  int wrote, rv;
-  u32 deq_now;
-
-  deq_now = clib_min (svm_fifo_max_read_chunk (f), len);
-  wrote = BIO_write (bio, svm_fifo_head (f), deq_now);
-  if (wrote <= 0)
-    return 0;
-
-  c = svm_fifo_head_chunk (f);
-  while ((c = c->next) && wrote < len)
-    {
-      deq_now = clib_min (c->length, len - wrote);
-      rv = BIO_write (bio, c->data, deq_now);
-      wrote += rv > 0 ? rv : 0;
-
-      if (rv < deq_now)
-	break;
-    }
-
-  svm_fifo_dequeue_drop (f, wrote);
-
-  return wrote;
-}
-
-static int
-openssl_write_from_fifo_into_ssl (svm_fifo_t * f, SSL * ssl, u32 len)
+openssl_write_from_fifo_into_ssl (svm_fifo_t *f, SSL *ssl, u32 max_len)
 {
-  svm_fifo_chunk_t *c;
-  int wrote = 0, rv;
-  u32 deq_now;
+  int wrote = 0, rv, i = 0, len;
+  u32 n_segs = 2;
+  svm_fifo_seg_t fs[n_segs];
 
-  deq_now = clib_min (svm_fifo_max_read_chunk (f), len);
-  wrote = SSL_write (ssl, svm_fifo_head (f), deq_now);
-  if (wrote <= 0)
+  len = svm_fifo_segments (f, 0, fs, &n_segs, max_len);
+  if (len <= 0)
     return 0;
 
-  c = svm_fifo_head_chunk (f);
-  while ((c = c->next) && wrote < len)
+  while (wrote < len && i < n_segs)
     {
-      deq_now = clib_min (c->length, len - wrote);
-      rv = SSL_write (ssl, c->data, deq_now);
-      wrote += rv > 0 ? rv : 0;
-
-      if (rv < deq_now)
+      rv = SSL_write (ssl, fs[i].data, fs[i].len);
+      wrote += (rv > 0) ? rv : 0;
+      if (rv < (int) fs[i].len)
 	break;
+      i++;
     }
 
-  svm_fifo_dequeue_drop (f, wrote);
+  if (wrote)
+    svm_fifo_dequeue_drop (f, wrote);
 
   return wrote;
 }
 
-static int
-openssl_try_handshake_read (openssl_ctx_t * oc, session_t * tls_session)
-{
-  svm_fifo_t *f;
-  u32 deq_max;
-
-  f = tls_session->rx_fifo;
-  deq_max = svm_fifo_max_dequeue_cons (f);
-  if (!deq_max)
-    return 0;
-
-  return openssl_write_from_fifo_into_bio (f, oc->wbio, deq_max);
-}
-
-static int
-openssl_try_handshake_write (openssl_ctx_t * oc, session_t * tls_session)
-{
-  u32 read;
-
-  if (BIO_ctrl_pending (oc->rbio) <= 0)
-    return 0;
-
-  read = openssl_read_from_bio_into_fifo (tls_session->tx_fifo, oc->rbio);
-  if (read)
-    tls_add_vpp_q_tx_evt (tls_session);
-
-  return read;
-}
-
 #ifdef HAVE_OPENSSL_ASYNC
 static int
 openssl_check_async_status (tls_ctx_t * ctx, openssl_resume_handler * handler,
@@ -317,7 +265,7 @@ openssl_handle_handshake_failure (tls_ctx_t * ctx)
       /*
        * Also handles cleanup of the pre-allocated session
        */
-      tls_notify_app_connected (ctx, /* is failed */ 1);
+      tls_notify_app_connected (ctx, SESSION_E_TLS_HANDSHAKE);
     }
 }
 
@@ -333,7 +281,7 @@ openssl_ctx_handshake_rx (tls_ctx_t * ctx, session_t * tls_session)
 	{
 	  ctx->resume = 0;
 	}
-      else if (!openssl_try_handshake_read (oc, tls_session))
+      else if (!svm_fifo_max_dequeue_cons (tls_session->rx_fifo))
 	break;
 
       rv = SSL_do_handshake (oc->ssl);
@@ -356,9 +304,7 @@ openssl_ctx_handshake_rx (tls_ctx_t * ctx, session_t * tls_session)
 	  return -1;
 	}
 
-      openssl_try_handshake_write (oc, tls_session);
-
-      if (err != SSL_ERROR_WANT_WRITE)
+      if (err != SSL_ERROR_WANT_WRITE && err != SSL_ERROR_WANT_READ)
 	break;
     }
   TLS_DBG (2, "tls state for %u is %s", oc->openssl_ctx_index,
@@ -385,19 +331,28 @@ openssl_ctx_handshake_rx (tls_ctx_t * ctx, session_t * tls_session)
 	   */
 	  if (ctx->srv_hostname)
 	    {
-	      tls_notify_app_connected (ctx, /* is failed */ 0);
+	      tls_notify_app_connected (ctx, SESSION_E_TLS_HANDSHAKE);
 	      return -1;
 	    }
 	}
-      tls_notify_app_connected (ctx, /* is failed */ 0);
+      tls_notify_app_connected (ctx, SESSION_E_NONE);
     }
   else
     {
       /* Need to check transport status */
       if (ctx->is_passive_close)
-	openssl_handle_handshake_failure (ctx);
-      else
-	tls_notify_app_accept (ctx);
+	{
+	  openssl_handle_handshake_failure (ctx);
+	  return -1;
+	}
+
+      /* Accept failed, cleanup */
+      if (tls_notify_app_accept (ctx))
+	{
+	  ctx->c_s_index = SESSION_INVALID_INDEX;
+	  tls_disconnect_transport (ctx);
+	  return -1;
+	}
     }
 
   TLS_DBG (1, "Handshake for %u complete. TLS cipher is %s",
@@ -408,141 +363,255 @@ openssl_ctx_handshake_rx (tls_ctx_t * ctx, session_t * tls_session)
 static void
 openssl_confirm_app_close (tls_ctx_t * ctx)
 {
+  openssl_ctx_t *oc = (openssl_ctx_t *) ctx;
+  SSL_shutdown (oc->ssl);
   tls_disconnect_transport (ctx);
   session_transport_closed_notify (&ctx->connection);
 }
 
-static inline int
-openssl_ctx_write (tls_ctx_t * ctx, session_t * app_session)
+static int
+openssl_ctx_write_tls (tls_ctx_t *ctx, session_t *app_session,
+		       transport_send_params_t *sp)
 {
   openssl_ctx_t *oc = (openssl_ctx_t *) ctx;
-  int wrote = 0, read, max_buf = 100 * TLS_CHUNK_SIZE, max_space;
-  u32 deq_max, to_write;
-  session_t *tls_session;
+  u32 deq_max, space, enq_buf;
+  session_t *ts;
+  int wrote = 0;
   svm_fifo_t *f;
 
+  ts = session_get_from_handle (ctx->tls_session_handle);
+  space = svm_fifo_max_enqueue_prod (ts->tx_fifo);
+  /* Leave a bit of extra space for tls ctrl data, if any needed */
+  space = clib_max ((int) space - TLSO_CTRL_BYTES, 0);
+
   f = app_session->tx_fifo;
 
   deq_max = svm_fifo_max_dequeue_cons (f);
+  deq_max = clib_min (deq_max, space);
   if (!deq_max)
     goto check_tls_fifo;
 
-  /* Figure out how much data to write */
-  max_space = max_buf - BIO_ctrl_pending (oc->rbio);
-  max_space = (max_space < 0) ? 0 : max_space;
-  to_write = clib_min (deq_max, (u32) max_space);
+  deq_max = clib_min (deq_max, sp->max_burst_size);
+
+  /* Make sure tcp's tx fifo can actually buffer all bytes to be dequeued.
+   * If under memory pressure, tls's fifo segment might not be able to
+   * allocate the chunks needed. This also avoids errors from the underlying
+   * custom bio to the ssl infra which at times can get stuck. */
+  if (svm_fifo_provision_chunks (ts->tx_fifo, 0, 0, deq_max + TLSO_CTRL_BYTES))
+    goto check_tls_fifo;
 
-  wrote = openssl_write_from_fifo_into_ssl (f, oc->ssl, to_write);
+  wrote = openssl_write_from_fifo_into_ssl (f, oc->ssl, deq_max);
   if (!wrote)
-    {
-      tls_add_vpp_q_builtin_tx_evt (app_session);
-      goto check_tls_fifo;
-    }
+    goto check_tls_fifo;
 
   if (svm_fifo_needs_deq_ntf (f, wrote))
     session_dequeue_notify (app_session);
 
-  if (svm_fifo_max_dequeue_cons (f))
-    tls_add_vpp_q_builtin_tx_evt (app_session);
-
 check_tls_fifo:
 
-  if (BIO_ctrl_pending (oc->rbio) <= 0)
-    return wrote;
+  if (PREDICT_FALSE (ctx->app_closed && BIO_ctrl_pending (oc->rbio) <= 0))
+    openssl_confirm_app_close (ctx);
+
+  /* Deschedule and wait for deq notification if fifo is almost full */
+  enq_buf = clib_min (svm_fifo_size (ts->tx_fifo) / 2, TLSO_MIN_ENQ_SPACE);
+  if (space < wrote + enq_buf)
+    {
+      svm_fifo_add_want_deq_ntf (ts->tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
+      transport_connection_deschedule (&ctx->connection);
+      sp->flags |= TRANSPORT_SND_F_DESCHED;
+    }
+  else
+    /* Request tx reschedule of the app session */
+    app_session->flags |= SESSION_F_CUSTOM_TX;
+
+  return wrote;
+}
 
-  tls_session = session_get_from_handle (ctx->tls_session_handle);
+static int
+openssl_ctx_write_dtls (tls_ctx_t *ctx, session_t *app_session,
+			transport_send_params_t *sp)
+{
+  openssl_main_t *om = &openssl_main;
+  openssl_ctx_t *oc = (openssl_ctx_t *) ctx;
+  u32 read = 0, to_deq, dgram_sz, enq_max;
+  session_dgram_pre_hdr_t hdr;
+  session_t *us;
+  int wrote, rv;
+  u8 *buf;
 
-  read = openssl_read_from_bio_into_fifo (tls_session->tx_fifo, oc->rbio);
-  if (!read)
+  us = session_get_from_handle (ctx->tls_session_handle);
+  to_deq = svm_fifo_max_dequeue_cons (app_session->tx_fifo);
+  buf = om->tx_bufs[ctx->c_thread_index];
+
+  while (to_deq > 0)
     {
-      tls_add_vpp_q_builtin_tx_evt (app_session);
-      return wrote;
+      /* Peeking only pre-header dgram because the session is connected */
+      rv = svm_fifo_peek (app_session->tx_fifo, 0, sizeof (hdr), (u8 *) &hdr);
+      ASSERT (rv == sizeof (hdr) && hdr.data_length < vec_len (buf));
+      ASSERT (to_deq >= hdr.data_length + SESSION_CONN_HDR_LEN);
+
+      dgram_sz = hdr.data_length + SESSION_CONN_HDR_LEN;
+      enq_max = dgram_sz + TLSO_CTRL_BYTES;
+      if (svm_fifo_max_enqueue_prod (us->tx_fifo) < enq_max ||
+	  svm_fifo_provision_chunks (us->tx_fifo, 0, 0, enq_max))
+	{
+	  svm_fifo_add_want_deq_ntf (us->tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
+	  transport_connection_deschedule (&ctx->connection);
+	  sp->flags |= TRANSPORT_SND_F_DESCHED;
+	  goto done;
+	}
+
+      rv = svm_fifo_peek (app_session->tx_fifo, SESSION_CONN_HDR_LEN,
+			  hdr.data_length, buf);
+      ASSERT (rv == hdr.data_length);
+      svm_fifo_dequeue_drop (app_session->tx_fifo, dgram_sz);
+
+      wrote = SSL_write (oc->ssl, buf, rv);
+      ASSERT (wrote > 0);
+
+      read += rv;
+      to_deq -= dgram_sz;
     }
 
-  tls_add_vpp_q_tx_evt (tls_session);
+done:
 
-  if (BIO_ctrl_pending (oc->rbio) > 0)
-    tls_add_vpp_q_builtin_tx_evt (app_session);
-  else if (ctx->app_closed)
+  if (svm_fifo_needs_deq_ntf (app_session->tx_fifo, read))
+    session_dequeue_notify (app_session);
+
+  if (read)
+    tls_add_vpp_q_tx_evt (us);
+
+  if (PREDICT_FALSE (ctx->app_closed &&
+		     !svm_fifo_max_enqueue_prod (us->rx_fifo)))
     openssl_confirm_app_close (ctx);
 
-  return wrote;
+  return read;
+}
+
+static inline int
+openssl_ctx_write (tls_ctx_t *ctx, session_t *app_session,
+		   transport_send_params_t *sp)
+{
+  if (ctx->tls_type == TRANSPORT_PROTO_TLS)
+    return openssl_ctx_write_tls (ctx, app_session, sp);
+  else
+    return openssl_ctx_write_dtls (ctx, app_session, sp);
 }
 
 static inline int
-openssl_ctx_read (tls_ctx_t * ctx, session_t * tls_session)
+openssl_ctx_read_tls (tls_ctx_t *ctx, session_t *tls_session)
 {
-  int read, wrote = 0, max_space, max_buf = 100 * TLS_CHUNK_SIZE;
   openssl_ctx_t *oc = (openssl_ctx_t *) ctx;
-  u32 deq_max, to_write;
   session_t *app_session;
+  int read;
   svm_fifo_t *f;
 
   if (PREDICT_FALSE (SSL_in_init (oc->ssl)))
     {
       if (openssl_ctx_handshake_rx (ctx, tls_session) < 0)
 	return 0;
-      else
-	goto check_app_fifo;
     }
 
-  f = tls_session->rx_fifo;
+  app_session = session_get_from_handle (ctx->app_session_handle);
+  f = app_session->rx_fifo;
 
-  deq_max = svm_fifo_max_dequeue_cons (f);
-  max_space = max_buf - BIO_ctrl_pending (oc->wbio);
-  max_space = max_space < 0 ? 0 : max_space;
-  to_write = clib_min (deq_max, max_space);
-  if (!to_write)
-    goto check_app_fifo;
+  read = openssl_read_from_ssl_into_fifo (f, oc->ssl);
 
-  wrote = openssl_write_from_fifo_into_bio (f, oc->wbio, to_write);
-  if (!wrote)
-    {
-      tls_add_vpp_q_builtin_rx_evt (tls_session);
-      goto check_app_fifo;
-    }
+  /* If handshake just completed, session may still be in accepting state */
+  if (read && app_session->session_state >= SESSION_STATE_READY)
+    tls_notify_app_enqueue (ctx, app_session);
 
-  if (svm_fifo_max_dequeue_cons (f))
+  if ((SSL_pending (oc->ssl) > 0) ||
+      svm_fifo_max_dequeue_cons (tls_session->rx_fifo))
     tls_add_vpp_q_builtin_rx_evt (tls_session);
 
-check_app_fifo:
+  return read;
+}
 
-  if (BIO_ctrl_pending (oc->wbio) <= 0)
-    return wrote;
+static inline int
+openssl_ctx_read_dtls (tls_ctx_t *ctx, session_t *us)
+{
+  openssl_main_t *om = &openssl_main;
+  openssl_ctx_t *oc = (openssl_ctx_t *) ctx;
+  session_dgram_hdr_t hdr;
+  session_t *app_session;
+  u32 wrote = 0;
+  int read, rv;
+  u8 *buf;
+
+  if (PREDICT_FALSE (SSL_in_init (oc->ssl)))
+    {
+      u32 us_index = us->session_index;
+      if (openssl_ctx_handshake_rx (ctx, us) < 0)
+	return 0;
+      /* Session pool might grow when allocating the app's session */
+      us = session_get (us_index, ctx->c_thread_index);
+    }
 
+  buf = om->rx_bufs[ctx->c_thread_index];
   app_session = session_get_from_handle (ctx->app_session_handle);
-  f = app_session->rx_fifo;
+  svm_fifo_fill_chunk_list (app_session->rx_fifo);
 
-  read = openssl_read_from_ssl_into_fifo (f, oc->ssl);
-  if (!read)
+  while (svm_fifo_max_dequeue_cons (us->rx_fifo) > 0)
     {
-      tls_add_vpp_q_builtin_rx_evt (tls_session);
-      return wrote;
+      if (svm_fifo_max_enqueue_prod (app_session->rx_fifo) < DTLSO_MAX_DGRAM)
+	{
+	  tls_add_vpp_q_builtin_rx_evt (us);
+	  goto done;
+	}
+
+      read = SSL_read (oc->ssl, buf, vec_len (buf));
+      if (PREDICT_FALSE (read <= 0))
+	{
+	  if (read < 0)
+	    tls_add_vpp_q_builtin_rx_evt (us);
+	  goto done;
+	}
+      wrote += read;
+
+      hdr.data_length = read;
+      hdr.data_offset = 0;
+
+      svm_fifo_seg_t segs[2] = { { (u8 *) &hdr, sizeof (hdr) },
+				 { buf, read } };
+
+      rv = svm_fifo_enqueue_segments (app_session->rx_fifo, segs, 2,
+				      0 /* allow partial */);
+      ASSERT (rv > 0);
     }
 
+done:
+
   /* If handshake just completed, session may still be in accepting state */
   if (app_session->session_state >= SESSION_STATE_READY)
     tls_notify_app_enqueue (ctx, app_session);
-  if (SSL_pending (oc->ssl) > 0)
-    tls_add_vpp_q_builtin_rx_evt (tls_session);
 
   return wrote;
 }
 
+static inline int
+openssl_ctx_read (tls_ctx_t *ctx, session_t *ts)
+{
+  if (ctx->tls_type == TRANSPORT_PROTO_TLS)
+    return openssl_ctx_read_tls (ctx, ts);
+  else
+    return openssl_ctx_read_dtls (ctx, ts);
+}
+
 static int
 openssl_ctx_init_client (tls_ctx_t * ctx)
 {
   long flags = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_COMPRESSION;
   openssl_ctx_t *oc = (openssl_ctx_t *) ctx;
   openssl_main_t *om = &openssl_main;
-  session_t *tls_session;
   const SSL_METHOD *method;
   int rv, err;
 
-  method = SSLv23_client_method ();
+  method = ctx->tls_type == TRANSPORT_PROTO_TLS ? SSLv23_client_method () :
+						  DTLS_client_method ();
   if (method == NULL)
     {
-      TLS_DBG (1, "SSLv23_method returned null");
+      TLS_DBG (1, "(D)TLS_method returned null");
       return -1;
     }
 
@@ -576,11 +645,16 @@ openssl_ctx_init_client (tls_ctx_t * ctx)
       return -1;
     }
 
-  oc->rbio = BIO_new (BIO_s_mem ());
-  oc->wbio = BIO_new (BIO_s_mem ());
-
-  BIO_set_mem_eof_return (oc->rbio, -1);
-  BIO_set_mem_eof_return (oc->wbio, -1);
+  if (ctx->tls_type == TRANSPORT_PROTO_TLS)
+    {
+      oc->rbio = BIO_new_tls (ctx->tls_session_handle);
+      oc->wbio = BIO_new_tls (ctx->tls_session_handle);
+    }
+  else
+    {
+      oc->rbio = BIO_new_dtls (ctx->tls_session_handle);
+      oc->wbio = BIO_new_dtls (ctx->tls_session_handle);
+    }
 
   SSL_set_bio (oc->ssl, oc->wbio, oc->rbio);
   SSL_set_connect_state (oc->ssl);
@@ -598,16 +672,14 @@ openssl_ctx_init_client (tls_ctx_t * ctx)
   TLS_DBG (1, "Initiating handshake for [%u]%u", ctx->c_thread_index,
 	   oc->openssl_ctx_index);
 
-  tls_session = session_get_from_handle (ctx->tls_session_handle);
-
 #ifdef HAVE_OPENSSL_ASYNC
+  session_t *tls_session = session_get_from_handle (ctx->tls_session_handle);
   vpp_tls_async_init_event (ctx, openssl_ctx_handshake_rx, tls_session);
 #endif
   while (1)
     {
       rv = SSL_do_handshake (oc->ssl);
       err = SSL_get_error (oc->ssl, rv);
-      openssl_try_handshake_write (oc, tls_session);
 #ifdef HAVE_OPENSSL_ASYNC
       if (err == SSL_ERROR_WANT_ASYNC)
 	{
@@ -652,7 +724,8 @@ openssl_start_listen (tls_ctx_t * lctx)
       return -1;
     }
 
-  method = SSLv23_method ();
+  method = lctx->tls_type == TRANSPORT_PROTO_TLS ? SSLv23_server_method () :
+						   DTLS_server_method ();
   ssl_ctx = SSL_CTX_new (method);
   if (!ssl_ctx)
     {
@@ -678,29 +751,59 @@ openssl_start_listen (tls_ctx_t * lctx)
       return -1;
     }
 
+  /* use the default OpenSSL built-in DH parameters */
+  rv = SSL_CTX_set_dh_auto (ssl_ctx, 1);
+  if (rv != 1)
+    {
+      TLS_DBG (1, "Couldn't set temp DH parameters");
+      return -1;
+    }
+
   /*
    * Set the key and cert
    */
   cert_bio = BIO_new (BIO_s_mem ());
+  if (!cert_bio)
+    {
+      clib_warning ("unable to allocate memory");
+      return -1;
+    }
   BIO_write (cert_bio, ckpair->cert, vec_len (ckpair->cert));
   srvcert = PEM_read_bio_X509 (cert_bio, NULL, NULL, NULL);
   if (!srvcert)
     {
       clib_warning ("unable to parse certificate");
-      return -1;
+      goto err;
+    }
+  rv = SSL_CTX_use_certificate (ssl_ctx, srvcert);
+  if (rv != 1)
+    {
+      clib_warning ("unable to use SSL certificate");
+      goto err;
     }
-  SSL_CTX_use_certificate (ssl_ctx, srvcert);
+
   BIO_free (cert_bio);
 
   cert_bio = BIO_new (BIO_s_mem ());
+  if (!cert_bio)
+    {
+      clib_warning ("unable to allocate memory");
+      return -1;
+    }
   BIO_write (cert_bio, ckpair->key, vec_len (ckpair->key));
   pkey = PEM_read_bio_PrivateKey (cert_bio, NULL, NULL, NULL);
   if (!pkey)
     {
       clib_warning ("unable to parse pkey");
-      return -1;
+      goto err;
     }
-  SSL_CTX_use_PrivateKey (ssl_ctx, pkey);
+  rv = SSL_CTX_use_PrivateKey (ssl_ctx, pkey);
+  if (rv != 1)
+    {
+      clib_warning ("unable to use SSL PrivateKey");
+      goto err;
+    }
+
   BIO_free (cert_bio);
 
   olc_index = openssl_listen_ctx_alloc ();
@@ -714,6 +817,10 @@ openssl_start_listen (tls_ctx_t * lctx)
 
   return 0;
 
+err:
+  if (cert_bio)
+    BIO_free (cert_bio);
+  return -1;
 }
 
 static int
@@ -740,7 +847,6 @@ openssl_ctx_init_server (tls_ctx_t * ctx)
   openssl_ctx_t *oc = (openssl_ctx_t *) ctx;
   u32 olc_index = ctx->tls_ssl_ctx;
   openssl_listen_ctx_t *olc;
-  session_t *tls_session;
   int rv, err;
 
   /* Start a new connection */
@@ -753,11 +859,16 @@ openssl_ctx_init_server (tls_ctx_t * ctx)
       return -1;
     }
 
-  oc->rbio = BIO_new (BIO_s_mem ());
-  oc->wbio = BIO_new (BIO_s_mem ());
-
-  BIO_set_mem_eof_return (oc->rbio, -1);
-  BIO_set_mem_eof_return (oc->wbio, -1);
+  if (ctx->tls_type == TRANSPORT_PROTO_TLS)
+    {
+      oc->rbio = BIO_new_tls (ctx->tls_session_handle);
+      oc->wbio = BIO_new_tls (ctx->tls_session_handle);
+    }
+  else
+    {
+      oc->rbio = BIO_new_dtls (ctx->tls_session_handle);
+      oc->wbio = BIO_new_dtls (ctx->tls_session_handle);
+    }
 
   SSL_set_bio (oc->ssl, oc->wbio, oc->rbio);
   SSL_set_accept_state (oc->ssl);
@@ -765,15 +876,14 @@ openssl_ctx_init_server (tls_ctx_t * ctx)
   TLS_DBG (1, "Initiating handshake for [%u]%u", ctx->c_thread_index,
 	   oc->openssl_ctx_index);
 
-  tls_session = session_get_from_handle (ctx->tls_session_handle);
 #ifdef HAVE_OPENSSL_ASYNC
+  session_t *tls_session = session_get_from_handle (ctx->tls_session_handle);
   vpp_tls_async_init_event (ctx, openssl_ctx_handshake_rx, tls_session);
 #endif
   while (1)
     {
       rv = SSL_do_handshake (oc->ssl);
       err = SSL_get_error (oc->ssl, rv);
-      openssl_try_handshake_write (oc, tls_session);
 #ifdef HAVE_OPENSSL_ASYNC
       if (err == SSL_ERROR_WANT_ASYNC)
 	{
@@ -835,7 +945,10 @@ openssl_app_close (tls_ctx_t * ctx)
 
 const static tls_engine_vft_t openssl_engine = {
   .ctx_alloc = openssl_ctx_alloc,
+  .ctx_alloc_w_thread = openssl_ctx_alloc_w_thread,
   .ctx_free = openssl_ctx_free,
+  .ctx_attach = openssl_ctx_attach,
+  .ctx_detach = openssl_ctx_detach,
   .ctx_get = openssl_ctx_get,
   .ctx_get_w_thread = openssl_ctx_get_w_thread,
   .ctx_init_server = openssl_ctx_init_server,
@@ -924,7 +1037,7 @@ tls_openssl_init (vlib_main_t * vm)
   vlib_thread_main_t *vtm = vlib_get_thread_main ();
   openssl_main_t *om = &openssl_main;
   clib_error_t *error = 0;
-  u32 num_threads;
+  u32 num_threads, i;
 
   error = tls_openssl_api_init (vm);
   num_threads = 1 /* main thread */  + vtm->n_threads;
@@ -939,7 +1052,13 @@ tls_openssl_init (vlib_main_t * vm)
     }
 
   vec_validate (om->ctx_pool, num_threads - 1);
-
+  vec_validate (om->rx_bufs, num_threads - 1);
+  vec_validate (om->tx_bufs, num_threads - 1);
+  for (i = 0; i < num_threads; i++)
+    {
+      vec_validate (om->rx_bufs[i], DTLSO_MAX_DGRAM);
+      vec_validate (om->tx_bufs[i], DTLSO_MAX_DGRAM);
+    }
   tls_register_engine (&openssl_engine, CRYPTO_ENGINE_OPENSSL);
 
   om->engine_init = 0;