X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fplugins%2Fquic%2Fquic.c;h=c4ef4598c1082cbc08b11d41aee778a41e60177e;hb=01314771535ca46fdf4a07a7dcde67bb8b30e024;hp=b120a46f7e8ac884fcc17378ee39c2996f0e3740;hpb=2e4523816ca0e366a4f597a0e5fdb93fccc887a5;p=vpp.git

diff --git a/src/plugins/quic/quic.c b/src/plugins/quic/quic.c
index b120a46f7e8..c4ef4598c10 100644
--- a/src/plugins/quic/quic.c
+++ b/src/plugins/quic/quic.c
@@ -345,7 +345,7 @@ quic_acquire_crypto_context (quic_ctx_t * ctx)
     {
       QUIC_DBG (1, "Quic does not support crypto engine %d",
 		ctx->crypto_engine);
-      return VNET_API_ERROR_MISSING_CERT_KEY;
+      return SESSION_E_NOCRYPTOENG;
     }
 
   /* Check for exisiting crypto ctx */
@@ -377,7 +377,7 @@ quic_acquire_crypto_context (quic_ctx_t * ctx)
 
 error:
   quic_crypto_context_free_if_needed (crctx, ctx->c_thread_index);
-  return VNET_API_ERROR_MISSING_CERT_KEY;
+  return SESSION_E_NOCRYPTOCKP;
 }
 
 /*  Helper functions */
@@ -572,6 +572,12 @@ quic_connection_delete (quic_ctx_t * ctx)
   clib_bihash_kv_16_8_t kv;
   quicly_conn_t *conn;
 
+  if (ctx->conn == NULL)
+    {
+      QUIC_DBG (2, "Skipping redundant delete of connection %u",
+		ctx->c_c_index);
+      return;
+    }
   QUIC_DBG (2, "Deleting connection %u", ctx->c_c_index);
 
   QUIC_ASSERT (!quic_ctx_is_stream (ctx));
@@ -587,8 +593,8 @@ quic_connection_delete (quic_ctx_t * ctx)
 
   quic_disconnect_transport (ctx);
 
-  if (ctx->conn)
-    quicly_free (ctx->conn);
+  if (conn)
+    quicly_free (conn);
   session_transport_delete_notify (&ctx->connection);
 }
 
@@ -646,11 +652,11 @@ static int
 quic_send_datagram (session_t *udp_session, struct iovec *packet,
 		    quicly_address_t *dest, quicly_address_t *src)
 {
-  u32 max_enqueue;
+  u32 max_enqueue, len;
   session_dgram_hdr_t hdr;
-  u32 len, ret;
   svm_fifo_t *f;
   transport_connection_t *tc;
+  int ret;
 
   len = packet->iov_len;
   f = udp_session->tx_fifo;
@@ -683,19 +689,16 @@ quic_send_datagram (session_t *udp_session, struct iovec *packet,
       QUIC_ASSERT (dest->sa.sa_family == AF_INET6);
       struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &dest->sa;
       hdr.rmt_port = sa6->sin6_port;
-      clib_memcpy (&hdr.rmt_ip.ip6, &sa6->sin6_addr, 16);
+      clib_memcpy_fast (&hdr.rmt_ip.ip6, &sa6->sin6_addr, 16);
     }
 
-  ret = svm_fifo_enqueue (f, sizeof (hdr), (u8 *) & hdr);
-  if (ret != sizeof (hdr))
-    {
-      QUIC_ERR ("Not enough space to enqueue header");
-      return QUIC_ERROR_FULL_FIFO;
-    }
-  ret = svm_fifo_enqueue (f, len, packet->iov_base);
-  if (ret != len)
+  svm_fifo_seg_t segs[2] = { { (u8 *) &hdr, sizeof (hdr) },
+			     { packet->iov_base, len } };
+
+  ret = svm_fifo_enqueue_segments (f, segs, 2, 0 /* allow partial */);
+  if (PREDICT_FALSE (ret < 0))
     {
-      QUIC_ERR ("Not enough space to enqueue payload");
+      QUIC_ERR ("Not enough space to enqueue dgram");
       return QUIC_ERROR_FULL_FIFO;
     }
 
@@ -715,9 +718,7 @@ quic_send_packets (quic_ctx_t * ctx)
   quicly_conn_t *conn;
   size_t num_packets, i, max_packets;
   quicly_address_t dest, src;
-
-  num_packets = QUIC_SEND_PACKET_VEC_SIZE;
-
+  u32 n_sent = 0;
   int err = 0;
 
   /* We have sctx, get qctx */
@@ -731,19 +732,16 @@ quic_send_packets (quic_ctx_t * ctx)
     goto quicly_error;
 
   conn = ctx->conn;
-
   if (!conn)
     return 0;
 
-  /* TODO : quicly can assert it can send min_packets up to 2 */
-  if (quic_sendable_packet_count (udp_session) < 2)
-    goto stop_sending;
-
   do
     {
+      /* TODO : quicly can assert it can send min_packets up to 2 */
       max_packets = quic_sendable_packet_count (udp_session);
       if (max_packets < 2)
 	break;
+
       num_packets = max_packets;
       if ((err = quicly_send (conn, &dest, &src, packets, &num_packets, buf,
 			      sizeof (buf))))
@@ -757,23 +755,23 @@ quic_send_packets (quic_ctx_t * ctx)
 	    goto quicly_error;
 
 	}
+      n_sent += num_packets;
     }
   while (num_packets > 0 && num_packets == max_packets);
 
-stop_sending:
   quic_set_udp_tx_evt (udp_session);
 
   QUIC_DBG (3, "%u[TX] %u[RX]", svm_fifo_max_dequeue (udp_session->tx_fifo),
 	    svm_fifo_max_dequeue (udp_session->rx_fifo));
   quic_update_timer (ctx);
-  return 0;
+  return n_sent;
 
 quicly_error:
   if (err && err != QUICLY_ERROR_PACKET_IGNORED
       && err != QUICLY_ERROR_FREE_CONNECTION)
     clib_warning ("Quic error '%U'.", quic_format_err, err);
   quic_connection_closed (ctx);
-  return 1;
+  return 0;
 }
 
 /* Quicly callbacks */
@@ -1016,6 +1014,7 @@ quic_on_stream_open (quicly_stream_open_t * self, quicly_stream_t * stream)
   sctx->stream = stream;
   sctx->c_flags |= TRANSPORT_CONNECTION_F_NO_LOOKUP;
   sctx->flags |= QUIC_F_IS_STREAM;
+  sctx->crypto_context_index = qctx->crypto_context_index;
   if (quicly_stream_is_unidirectional (stream->stream_id))
     stream_session->flags |= SESSION_F_UNIDIRECTIONAL;
 
@@ -1150,7 +1149,9 @@ quic_update_timer (quic_ctx_t * ctx)
 	}
     }
 
-  tw = &quic_main.wrk_ctx[vlib_get_thread_index ()].timer_wheel;
+  ASSERT (vlib_get_thread_index () == ctx->c_thread_index ||
+	  vlib_get_thread_index () == 0);
+  tw = &quic_main.wrk_ctx[ctx->c_thread_index].timer_wheel;
 
   QUIC_DBG (4, "Timer set to %ld (int %ld) for ctx %u", next_timeout,
 	    next_interval, ctx->c_c_index);
@@ -1254,6 +1255,7 @@ quic_connect_stream (session_t * quic_session, session_endpoint_cfg_t * sep)
   quic_increment_counter (QUIC_ERROR_OPENED_STREAM, 1);
 
   sctx->stream = stream;
+  sctx->crypto_context_index = qctx->crypto_context_index;
 
   QUIC_DBG (2, "Opened stream %d, creating session", stream->stream_id);
 
@@ -1304,14 +1306,21 @@ static int
 quic_connect_connection (session_endpoint_cfg_t * sep)
 {
   vnet_connect_args_t _cargs, *cargs = &_cargs;
+  transport_endpt_crypto_cfg_t *ccfg;
   quic_main_t *qm = &quic_main;
+  u32 ctx_index, thread_index;
   quic_ctx_t *ctx;
   app_worker_t *app_wrk;
   application_t *app;
-  u32 ctx_index;
-  u32 thread_index = vlib_get_thread_index ();
   int error;
 
+  if (!sep->ext_cfg)
+    return SESSION_E_NOEXTCFG;
+
+  /* Use pool on thread 1 if we have workers because of UDP */
+  thread_index = vlib_num_workers () ? 1 : 0;
+  ccfg = &sep->ext_cfg->crypto;
+
   clib_memset (cargs, 0, sizeof (*cargs));
   ctx_index = quic_ctx_alloc (thread_index);
   ctx = quic_ctx_get (ctx_index, thread_index);
@@ -1323,15 +1332,15 @@ quic_connect_connection (session_endpoint_cfg_t * sep)
   ctx->conn_state = QUIC_CONN_STATE_HANDSHAKE;
   ctx->client_opaque = sep->opaque;
   ctx->c_flags |= TRANSPORT_CONNECTION_F_NO_LOOKUP;
-  if (sep->hostname)
-    ctx->srv_hostname = format (0, "%v", sep->hostname);
+  if (ccfg->hostname[0])
+    ctx->srv_hostname = format (0, "%s", ccfg->hostname);
   else
     /*  needed by quic for crypto + determining client / server */
     ctx->srv_hostname = format (0, "%U", format_ip46_address,
 				&sep->ip, sep->is_ip4);
   vec_terminate_c_string (ctx->srv_hostname);
 
-  clib_memcpy (&cargs->sep, sep, sizeof (session_endpoint_cfg_t));
+  clib_memcpy (&cargs->sep_ext, sep, sizeof (session_endpoint_cfg_t));
   cargs->sep.transport_proto = TRANSPORT_PROTO_UDP;
   cargs->app_index = qm->app_index;
   cargs->api_context = ctx_index;
@@ -1342,8 +1351,8 @@ quic_connect_connection (session_endpoint_cfg_t * sep)
   cargs->sep_ext.ns_index = app->ns_index;
   cargs->sep_ext.transport_flags = TRANSPORT_CFG_F_CONNECTED;
 
-  ctx->crypto_engine = sep->crypto_engine;
-  ctx->ckpair_index = sep->ckpair_index;
+  ctx->crypto_engine = ccfg->crypto_engine;
+  ctx->ckpair_index = ccfg->ckpair_index;
   if ((error = quic_acquire_crypto_context (ctx)))
     return error;
 
@@ -1435,6 +1444,7 @@ static u32
 quic_start_listen (u32 quic_listen_session_index, transport_endpoint_t * tep)
 {
   vnet_listen_args_t _bargs, *args = &_bargs;
+  transport_endpt_crypto_cfg_t *ccfg;
   quic_main_t *qm = &quic_main;
   session_handle_t udp_handle;
   session_endpoint_cfg_t *sep;
@@ -1447,10 +1457,11 @@ quic_start_listen (u32 quic_listen_session_index, transport_endpoint_t * tep)
   int rv;
 
   sep = (session_endpoint_cfg_t *) tep;
+  if (!sep->ext_cfg)
+    return SESSION_E_NOEXTCFG;
+
+  ccfg = &sep->ext_cfg->crypto;
   app_wrk = app_worker_get (sep->app_wrk_index);
-  /* We need to call this because we call app_worker_init_connected in
-   * quic_accept_stream, which assumes the connect segment manager exists */
-  app_worker_alloc_connects_segment_manager (app_wrk);
   app = application_get (app_wrk->app_index);
   QUIC_DBG (2, "Called quic_start_listen for app %d", app_wrk->app_index);
 
@@ -1483,10 +1494,10 @@ quic_start_listen (u32 quic_listen_session_index, transport_endpoint_t * tep)
   lctx->parent_app_id = app_wrk->app_index;
   lctx->udp_session_handle = udp_handle;
   lctx->c_s_index = quic_listen_session_index;
-  lctx->crypto_engine = sep->crypto_engine;
-  lctx->ckpair_index = sep->ckpair_index;
-  if (quic_acquire_crypto_context (lctx))
-    return -1;
+  lctx->crypto_engine = ccfg->crypto_engine;
+  lctx->ckpair_index = ccfg->ckpair_index;
+  if ((rv = quic_acquire_crypto_context (lctx)))
+    return rv;
 
   QUIC_DBG (2, "Listening UDP session 0x%lx",
 	    session_handle (udp_listen_session));
@@ -1785,11 +1796,15 @@ quic_udp_session_connected_callback (u32 quic_app_index, u32 ctx_index,
   app_worker_t *app_wrk;
   quicly_conn_t *conn;
   quic_ctx_t *ctx;
-  u32 thread_index = vlib_get_thread_index ();
+  u32 thread_index;
   int ret;
   quicly_context_t *quicly_ctx;
 
-
+  /* Allocate session on whatever thread udp used, i.e., probably first
+   * worker, although this may be main thread. If it is main, it's done
+   * with a worker barrier */
+  thread_index = udp_session->thread_index;
+  ASSERT (thread_index == 0 || thread_index == 1);
   ctx = quic_ctx_get (ctx_index, thread_index);
   if (err)
     {
@@ -1803,9 +1818,6 @@ quic_udp_session_connected_callback (u32 quic_app_index, u32 ctx_index,
       return 0;
     }
 
-  ctx->c_thread_index = thread_index;
-  ctx->c_c_index = ctx_index;
-
   QUIC_DBG (2, "New ctx [%u]%x", thread_index, (ctx) ? ctx_index : ~0);
 
   ctx->udp_session_handle = session_handle (udp_session);
@@ -1833,11 +1845,7 @@ quic_udp_session_connected_callback (u32 quic_app_index, u32 ctx_index,
   QUIC_DBG (2, "Registering conn with id %lu %lu", kv.key[0], kv.key[1]);
   clib_bihash_add_del_16_8 (&quic_main.connection_hash, &kv, 1 /* is_add */ );
 
-  /*  UDP stack quirk? preemptively transfer connection if that happens */
-  if (udp_session->thread_index != thread_index)
-    quic_transfer_connection (ctx_index, udp_session->thread_index);
-  else
-    quic_send_packets (ctx);
+  quic_send_packets (ctx);
 
   return ret;
 }
@@ -1982,7 +1990,7 @@ quic_custom_tx_callback (void *s, transport_send_params_t * sp)
   if (!quicly_sendstate_is_open (&stream->sendstate))
     {
       QUIC_ERR ("Warning: tried to send on closed stream");
-      return -1;
+      return 0;
     }
 
   stream_data = (quic_stream_data_t *) stream->data;
@@ -1999,8 +2007,7 @@ quic_custom_tx_callback (void *s, transport_send_params_t * sp)
   QUIC_ASSERT (!rv);
 
 tx_end:
-  quic_send_packets (ctx);
-  return 0;
+  return quic_send_packets (ctx);
 }
 
 /*
@@ -2649,18 +2656,17 @@ quic_get_counter_value (u32 event_code)
   em = &vm->error_main;
   n = vlib_get_node (vm, quic_input_node.index);
   code = event_code;
-  /* *INDENT-OFF* */
-  foreach_vlib_main(({
-    em = &this_vlib_main->error_main;
-    i = n->error_heap_index + code;
-    c = em->counters[i];
-
-    if (i < vec_len (em->counters_last_clear))
-       c -= em->counters_last_clear[i];
-    sum += c;
-    index++;
-  }));
-  /* *INDENT-ON* */
+  foreach_vlib_main ()
+    {
+      em = &this_vlib_main->error_main;
+      i = n->error_heap_index + code;
+      c = em->counters[i];
+
+      if (i < vec_len (em->counters_last_clear))
+	c -= em->counters_last_clear[i];
+      sum += c;
+      index++;
+    }
   return sum;
 }