X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fplugins%2Ftlsopenssl%2Ftls_openssl.c;h=669a503487ffdd4c7fc32e0fe9d6e17de50b44f7;hb=9f86d225ab4f3dccbf61383a75d6af7d321a204e;hp=8e5e73a6cfb59fc521d4a30910fd818d5d4c1c8d;hpb=f4a92f6a1cf6b27318b6819ad3145b4020a27779;p=vpp.git

diff --git a/src/plugins/tlsopenssl/tls_openssl.c b/src/plugins/tlsopenssl/tls_openssl.c
index 8e5e73a6cfb..669a503487f 100644
--- a/src/plugins/tlsopenssl/tls_openssl.c
+++ b/src/plugins/tlsopenssl/tls_openssl.c
@@ -110,70 +110,162 @@ openssl_lctx_get (u32 lctx_index)
 }
 
 static int
-openssl_try_handshake_read (openssl_ctx_t * oc, session_t * tls_session)
+openssl_read_from_bio_into_fifo (svm_fifo_t * f, BIO * bio, u32 enq_max)
 {
-  u32 deq_max, deq_now;
-  svm_fifo_t *f;
-  int wrote, rv;
+  svm_fifo_chunk_t *c;
+  int read, rv;
+  u32 enq_now;
 
-  f = tls_session->rx_fifo;
-  deq_max = svm_fifo_max_dequeue_cons (f);
-  if (!deq_max)
+  svm_fifo_fill_chunk_list (f);
+
+  enq_now = clib_min (svm_fifo_max_write_chunk (f), enq_max);
+  if (!enq_now)
     return 0;
 
-  deq_now = clib_min (svm_fifo_max_read_chunk (f), deq_max);
-  wrote = BIO_write (oc->wbio, svm_fifo_head (f), deq_now);
-  if (wrote <= 0)
+  read = BIO_read (bio, svm_fifo_tail (f), enq_now);
+  if (read <= 0)
     return 0;
 
-  svm_fifo_dequeue_drop (f, wrote);
-  if (wrote < deq_max)
+  c = svm_fifo_tail_chunk (f);
+  while ((c = c->next) && read < enq_max)
     {
-      deq_now = clib_min (svm_fifo_max_read_chunk (f), deq_max - wrote);
-      rv = BIO_write (oc->wbio, svm_fifo_head (f), deq_now);
-      if (rv > 0)
-	{
-	  svm_fifo_dequeue_drop (f, rv);
-	  wrote += rv;
-	}
+      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;
     }
-  return wrote;
+
+  svm_fifo_enqueue_nocopy (f, read);
+
+  return read;
 }
 
 static int
-openssl_try_handshake_write (openssl_ctx_t * oc, session_t * tls_session)
+openssl_read_from_ssl_into_fifo (svm_fifo_t * f, SSL * ssl)
 {
-  u32 enq_max, deq_now;
-  svm_fifo_t *f;
+  u32 enq_now, enq_max;
+  svm_fifo_chunk_t *c;
   int read, rv;
 
-  if (BIO_ctrl_pending (oc->rbio) <= 0)
-    return 0;
-
-  f = tls_session->tx_fifo;
   enq_max = svm_fifo_max_enqueue_prod (f);
   if (!enq_max)
     return 0;
 
-  deq_now = clib_min (svm_fifo_max_write_chunk (f), enq_max);
-  read = BIO_read (oc->rbio, svm_fifo_tail (f), deq_now);
+  svm_fifo_fill_chunk_list (f);
+
+  enq_now = clib_min (svm_fifo_max_write_chunk (f), enq_max);
+  if (!enq_now)
+    return 0;
+
+  read = SSL_read (ssl, 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 = SSL_read (ssl, c->data, enq_now);
+      read += rv > 0 ? rv : 0;
+
+      if (rv < enq_now)
+	break;
+    }
+
   svm_fifo_enqueue_nocopy (f, read);
-  tls_add_vpp_q_tx_evt (tls_session);
 
-  if (read < enq_max)
+  return read;
+}
+
+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 (svm_fifo_max_write_chunk (f), enq_max - read);
-      rv = BIO_read (oc->rbio, svm_fifo_tail (f), deq_now);
-      if (rv > 0)
-	{
-	  svm_fifo_enqueue_nocopy (f, rv);
-	  read += rv;
-	}
+      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)
+{
+  svm_fifo_chunk_t *c;
+  int wrote = 0, rv;
+  u32 deq_now;
+
+  deq_now = clib_min (svm_fifo_max_read_chunk (f), len);
+  wrote = SSL_write (ssl, 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 = SSL_write (ssl, 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_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, enq_max;
+
+  if (BIO_ctrl_pending (oc->rbio) <= 0)
+    return 0;
+
+  enq_max = svm_fifo_max_enqueue_prod (tls_session->tx_fifo);
+  if (!enq_max)
+    return 0;
+
+  read = openssl_read_from_bio_into_fifo (tls_session->tx_fifo, oc->rbio,
+					  enq_max);
+  if (read)
+    tls_add_vpp_q_tx_evt (tls_session);
+
   return read;
 }
 
@@ -204,22 +296,29 @@ openssl_check_async_status (tls_ctx_t * ctx, openssl_resume_handler * handler,
 static void
 openssl_handle_handshake_failure (tls_ctx_t * ctx)
 {
+  session_t *app_session;
+
   if (SSL_is_server (((openssl_ctx_t *) ctx)->ssl))
     {
       /*
        * Cleanup pre-allocated app session and close transport
        */
-      session_free (session_get (ctx->c_s_index, ctx->c_thread_index));
-      ctx->no_app_session = 1;
-      ctx->c_s_index = SESSION_INVALID_INDEX;
-      tls_disconnect_transport (ctx);
+      app_session =
+	session_get_if_valid (ctx->c_s_index, ctx->c_thread_index);
+      if (app_session)
+	{
+	  session_free (app_session);
+	  ctx->no_app_session = 1;
+	  ctx->c_s_index = SESSION_INVALID_INDEX;
+	  tls_disconnect_transport (ctx);
+	}
     }
   else
     {
       /*
        * 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);
     }
 }
 
@@ -287,15 +386,19 @@ 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
     {
-      tls_notify_app_accept (ctx);
+      /* Need to check transport status */
+      if (ctx->is_passive_close)
+	openssl_handle_handshake_failure (ctx);
+      else
+	tls_notify_app_accept (ctx);
     }
 
   TLS_DBG (1, "Handshake for %u complete. TLS cipher is %s",
@@ -311,84 +414,68 @@ openssl_confirm_app_close (tls_ctx_t * ctx)
 }
 
 static inline int
-openssl_ctx_write (tls_ctx_t * ctx, session_t * app_session)
+openssl_ctx_write (tls_ctx_t * ctx, session_t * app_session,
+		   transport_send_params_t * sp)
 {
   openssl_ctx_t *oc = (openssl_ctx_t *) ctx;
-  int wrote = 0, rv, read, max_buf = 100 * TLS_CHUNK_SIZE, max_space;
-  u32 enq_max, deq_max, deq_now, to_write;
+  int wrote = 0, read, max_buf = 4 * TLS_CHUNK_SIZE, max_space, n_pending;
+  u32 deq_max, to_write, enq_max;
   session_t *tls_session;
   svm_fifo_t *f;
 
   f = app_session->tx_fifo;
+
   deq_max = svm_fifo_max_dequeue_cons (f);
   if (!deq_max)
     goto check_tls_fifo;
 
+  deq_max = clib_min (deq_max, sp->max_burst_size);
+
+  /* Figure out how much data to write */
   max_space = max_buf - BIO_ctrl_pending (oc->rbio);
   max_space = (max_space < 0) ? 0 : max_space;
-  deq_now = clib_min (deq_max, (u32) max_space);
-  to_write = clib_min (svm_fifo_max_read_chunk (f), deq_now);
-  wrote = SSL_write (oc->ssl, svm_fifo_head (f), to_write);
-  if (wrote <= 0)
-    {
-      tls_add_vpp_q_builtin_tx_evt (app_session);
-      goto check_tls_fifo;
-    }
-  svm_fifo_dequeue_drop (app_session->tx_fifo, wrote);
-  if (wrote < deq_now)
-    {
-      to_write = clib_min (svm_fifo_max_read_chunk (f), deq_now - wrote);
-      rv = SSL_write (oc->ssl, svm_fifo_head (f), to_write);
-      if (rv > 0)
-	{
-	  svm_fifo_dequeue_drop (app_session->tx_fifo, rv);
-	  wrote += rv;
-	}
-    }
+  to_write = clib_min (deq_max, (u32) max_space);
 
-  if (svm_fifo_needs_deq_ntf (app_session->tx_fifo, wrote))
-    session_dequeue_notify (app_session);
+  wrote = openssl_write_from_fifo_into_ssl (f, oc->ssl, to_write);
+  if (!wrote)
+    goto check_tls_fifo;
 
-  if (wrote < deq_max)
-    tls_add_vpp_q_builtin_tx_evt (app_session);
+  if (svm_fifo_needs_deq_ntf (f, wrote))
+    session_dequeue_notify (app_session);
 
 check_tls_fifo:
 
-  if (BIO_ctrl_pending (oc->rbio) <= 0)
+  if ((n_pending = BIO_ctrl_pending (oc->rbio)) <= 0)
     return wrote;
 
   tls_session = session_get_from_handle (ctx->tls_session_handle);
-  f = tls_session->tx_fifo;
-  enq_max = svm_fifo_max_enqueue_prod (f);
+
+  enq_max = svm_fifo_max_enqueue_prod (tls_session->tx_fifo);
   if (!enq_max)
-    {
-      tls_add_vpp_q_builtin_tx_evt (app_session);
-      return wrote;
-    }
+    goto maybe_reschedule;
 
-  deq_now = clib_min (svm_fifo_max_write_chunk (f), enq_max);
-  read = BIO_read (oc->rbio, svm_fifo_tail (f), deq_now);
-  if (read <= 0)
-    {
-      tls_add_vpp_q_builtin_tx_evt (app_session);
-      return wrote;
-    }
+  read = openssl_read_from_bio_into_fifo (tls_session->tx_fifo, oc->rbio,
+					  enq_max);
+  if (!read)
+    goto maybe_reschedule;
 
-  svm_fifo_enqueue_nocopy (f, read);
   tls_add_vpp_q_tx_evt (tls_session);
 
-  if (read < enq_max && BIO_ctrl_pending (oc->rbio) > 0)
+  if (PREDICT_FALSE (ctx->app_closed && !BIO_ctrl_pending (oc->rbio)))
+    openssl_confirm_app_close (ctx);
+
+maybe_reschedule:
+
+  if (!svm_fifo_max_enqueue_prod (tls_session->tx_fifo))
     {
-      deq_now = clib_min (svm_fifo_max_write_chunk (f), enq_max - read);
-      read = BIO_read (oc->rbio, svm_fifo_tail (f), deq_now);
-      if (read > 0)
-	svm_fifo_enqueue_nocopy (f, read);
+      svm_fifo_add_want_deq_ntf (tls_session->tx_fifo,
+				 SVM_FIFO_WANT_DEQ_NOTIF);
+      transport_connection_deschedule (&ctx->connection);
+      sp->flags |= TRANSPORT_SND_F_DESCHED;
     }
-
-  if (BIO_ctrl_pending (oc->rbio) > 0)
-    tls_add_vpp_q_builtin_tx_evt (app_session);
-  else if (ctx->app_closed)
-    openssl_confirm_app_close (ctx);
+  else
+    /* Request tx reschedule of the app session */
+    app_session->flags |= SESSION_F_CUSTOM_TX;
 
   return wrote;
 }
@@ -396,9 +483,9 @@ check_tls_fifo:
 static inline int
 openssl_ctx_read (tls_ctx_t * ctx, session_t * tls_session)
 {
-  int read, wrote = 0, max_space, max_buf = 100 * TLS_CHUNK_SIZE, rv;
+  int read, wrote = 0, max_space, max_buf = 4 * TLS_CHUNK_SIZE;
   openssl_ctx_t *oc = (openssl_ctx_t *) ctx;
-  u32 deq_max, enq_max, deq_now, to_read;
+  u32 deq_max, to_write;
   session_t *app_session;
   svm_fifo_t *f;
 
@@ -411,31 +498,21 @@ openssl_ctx_read (tls_ctx_t * ctx, session_t * tls_session)
     }
 
   f = tls_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;
-  deq_now = clib_min (deq_max, max_space);
-  if (!deq_now)
+  to_write = clib_min (deq_max, max_space);
+  if (!to_write)
     goto check_app_fifo;
 
-  to_read = clib_min (svm_fifo_max_read_chunk (f), deq_now);
-  wrote = BIO_write (oc->wbio, svm_fifo_head (f), to_read);
-  if (wrote <= 0)
+  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;
     }
-  svm_fifo_dequeue_drop (f, wrote);
-  if (wrote < deq_now)
-    {
-      to_read = clib_min (svm_fifo_max_read_chunk (f), deq_now - wrote);
-      rv = BIO_write (oc->wbio, svm_fifo_head (f), to_read);
-      if (rv > 0)
-	{
-	  svm_fifo_dequeue_drop (f, rv);
-	  wrote += rv;
-	}
-    }
+
   if (svm_fifo_max_dequeue_cons (f))
     tls_add_vpp_q_builtin_rx_evt (tls_session);
 
@@ -446,28 +523,13 @@ check_app_fifo:
 
   app_session = session_get_from_handle (ctx->app_session_handle);
   f = app_session->rx_fifo;
-  enq_max = svm_fifo_max_enqueue_prod (f);
-  if (!enq_max)
-    {
-      tls_add_vpp_q_builtin_rx_evt (tls_session);
-      return wrote;
-    }
 
-  deq_now = clib_min (svm_fifo_max_write_chunk (f), enq_max);
-  read = SSL_read (oc->ssl, svm_fifo_tail (f), deq_now);
-  if (read <= 0)
+  read = openssl_read_from_ssl_into_fifo (f, oc->ssl);
+  if (!read)
     {
       tls_add_vpp_q_builtin_rx_evt (tls_session);
       return wrote;
     }
-  svm_fifo_enqueue_nocopy (f, read);
-  if (read < enq_max && SSL_pending (oc->ssl) > 0)
-    {
-      deq_now = clib_min (svm_fifo_max_write_chunk (f), enq_max - read);
-      read = SSL_read (oc->ssl, svm_fifo_tail (f), deq_now);
-      if (read > 0)
-	svm_fifo_enqueue_nocopy (f, read);
-    }
 
   /* If handshake just completed, session may still be in accepting state */
   if (app_session->session_state >= SESSION_STATE_READY)
@@ -752,6 +814,11 @@ openssl_handshake_is_over (tls_ctx_t * ctx)
 static int
 openssl_transport_close (tls_ctx_t * ctx)
 {
+#ifdef HAVE_OPENSSL_ASYNC
+  if (vpp_openssl_is_inflight (ctx))
+    return 0;
+#endif
+
   if (!openssl_handshake_is_over (ctx))
     {
       openssl_handle_handshake_failure (ctx);