quic: quic_app_rx_callback refactor.

Add quic_process_one_rx_packet() function

Type: refactor

Change-Id: Iecaec3f7fed9f95a25ea55d0251626beb79181fd
Signed-off-by: Mathias Raoul <mathias.raoul@gmail.com>

1 files changed, 167 insertions, 117 deletions

diff --git a/src/plugins/quic/quic.c b/src/plugins/quic/quic.c
index 92da8fd7f97..8abb850084d 100644
--- a/src/plugins/quic/quic.c
+++ b/src/plugins/quic/quic.c
@@ -1746,38 +1746,6 @@ quic_find_packet_ctx (u32 * ctx_thread, u32 * ctx_index,
 }
 
 static int
-quic_receive (quic_ctx_t * ctx, quicly_conn_t * conn,
-	      quicly_decoded_packet_t packet)
-{
-  int rv;
-  u32 ctx_id = ctx->c_c_index;
-  u32 thread_index = ctx->c_thread_index;
-  /* TODO : QUICLY_ERROR_PACKET_IGNORED sould be handled */
-  rv = quicly_receive (conn, &packet);
-  if (rv)
-    {
-      QUIC_DBG (2, "quicly_receive errored %U", quic_format_err, rv);
-      return 0;
-    }
-  /* ctx pointer may change if a new stream is opened */
-  ctx = quic_ctx_get (ctx_id, thread_index);
-  /* Conn may be set to null if the connection is terminated */
-  if (ctx->conn && ctx->conn_state == QUIC_CONN_STATE_HANDSHAKE)
-    {
-      if (quicly_connection_is_ready (conn))
-	{
-	  ctx->conn_state = QUIC_CONN_STATE_READY;
-	  if (quicly_is_client (conn))
-	    {
-	      quic_on_client_connected (ctx);
-	      ctx = quic_ctx_get (ctx_id, thread_index);
-	    }
-	}
-    }
-  return quic_send_packets (ctx);
-}
-
-static int
 quic_create_quic_session (quic_ctx_t * ctx)
 {
   session_t *quic_session;
@@ -1890,30 +1858,169 @@ quic_reset_connection (u64 udp_session_handle,
   return rv;
 }
 
-static int
-quic_app_rx_callback (session_t * udp_session)
+typedef struct quic_rx_packet_ctx_
 {
-  /*  Read data from UDP rx_fifo and pass it to the quicly conn. */
   quicly_decoded_packet_t packet;
+  u8 data[QUIC_MAX_PACKET_SIZE];
+  u32 ctx_index;
+  u32 thread_index;
+} quic_rx_packet_ctx_t;
+
+static void
+check_quic_client_connected (struct quic_rx_packet_ctx_ *quic_rx_ctx)
+{
+  /* ctx pointer may change if a new stream is opened */
+  quic_ctx_t *ctx = quic_ctx_get (quic_rx_ctx->ctx_index,
+				  quic_rx_ctx->thread_index);
+  /* Conn may be set to null if the connection is terminated */
+  if (ctx->conn && ctx->conn_state == QUIC_CONN_STATE_HANDSHAKE)
+    {
+      if (quicly_connection_is_ready (ctx->conn))
+	{
+	  ctx->conn_state = QUIC_CONN_STATE_READY;
+	  if (quicly_is_client (ctx->conn))
+	    {
+	      quic_on_client_connected (ctx);
+	    }
+	}
+    }
+
+}
+
+static int
+quic_process_one_rx_packet (u64 udp_session_handle,
+			    quicly_context_t * quicly_ctx, svm_fifo_t * f,
+			    u32 * fifo_offset, u32 * max_packet, u32 packet_n,
+			    quic_rx_packet_ctx_t * packet_ctx)
+{
   session_dgram_hdr_t ph;
-  application_t *app;
   quic_ctx_t *ctx = NULL;
-  svm_fifo_t *f;
   size_t plen;
   struct sockaddr_in6 sa6;
   struct sockaddr *sa = (struct sockaddr *) &sa6;
   socklen_t salen;
-  u32 max_deq, full_len, ctx_index = UINT32_MAX, ctx_thread = UINT32_MAX, ret;
-  u8 *data;
-  int err;
+  u32 full_len, ret;
+  int err, rv = 0;
+  packet_ctx->thread_index = UINT32_MAX;
+  packet_ctx->ctx_index = UINT32_MAX;
+  u32 thread_index = vlib_get_thread_index ();
   u32 *opening_ctx_pool, *ctx_index_ptr;
+  u32 cur_deq = svm_fifo_max_dequeue (f) - *fifo_offset;
+
+  if (cur_deq == 0)
+    {
+      *max_packet = packet_n + 1;
+      return 0;
+    }
+
+  if (cur_deq < SESSION_CONN_HDR_LEN)
+    {
+      QUIC_DBG (1, "Not enough data for even a header in RX");
+      return 1;
+    }
+  ret = svm_fifo_peek (f, *fifo_offset, SESSION_CONN_HDR_LEN, (u8 *) & ph);
+  if (ret != SESSION_CONN_HDR_LEN)
+    {
+      QUIC_DBG (1, "Not enough data for header in RX");
+      return 1;
+    }
+  ASSERT (ph.data_offset == 0);
+  full_len = ph.data_length + SESSION_CONN_HDR_LEN;
+  if (full_len > cur_deq)
+    {
+      QUIC_DBG (1, "Not enough data in fifo RX");
+      return 1;
+    }
+
+  /* Quicly can read len bytes from the fifo at offset:
+   * ph.data_offset + SESSION_CONN_HDR_LEN */
+  ret =
+    svm_fifo_peek (f, SESSION_CONN_HDR_LEN + *fifo_offset, ph.data_length,
+		   packet_ctx->data);
+  if (ret != ph.data_length)
+    {
+      QUIC_DBG (1, "Not enough data peeked in RX");
+      return 1;
+    }
+
+  rv = 0;
+  quic_build_sockaddr (sa, &salen, &ph.rmt_ip, ph.rmt_port, ph.is_ip4);
+  quicly_ctx = quic_get_quicly_ctx_from_udp (udp_session_handle);
+  plen =
+    quicly_decode_packet (quicly_ctx, &packet_ctx->packet, packet_ctx->data,
+			  ph.data_length);
+
+  if (plen == SIZE_MAX)
+    {
+      *fifo_offset += SESSION_CONN_HDR_LEN + ph.data_length;
+      return 1;
+    }
+
+  err =
+    quic_find_packet_ctx (&packet_ctx->thread_index, &packet_ctx->ctx_index,
+			  sa, salen, &packet_ctx->packet, thread_index);
+  if (err == 0)
+    {
+      ctx = quic_ctx_get (packet_ctx->ctx_index, thread_index);
+      rv = quicly_receive (ctx->conn, &packet_ctx->packet);
+      if (rv)
+	QUIC_DBG (1, "quicly_receive return error %d", rv);
+    }
+  else if (packet_ctx->ctx_index != UINT32_MAX)
+    {
+      /*  Connection found but on wrong thread, ask move */
+      *max_packet = packet_n + 1;
+      return 0;
+    }
+  else if ((packet_ctx->packet.octets.base[0] & QUICLY_PACKET_TYPE_BITMASK) ==
+	   QUICLY_PACKET_TYPE_INITIAL)
+    {
+      /*  Try to find matching "opening" ctx */
+      opening_ctx_pool = quic_main.wrk_ctx[thread_index].opening_ctx_pool;
+
+	/* *INDENT-OFF* */
+	pool_foreach (ctx_index_ptr, opening_ctx_pool,
+	({
+	  ctx = quic_ctx_get (*ctx_index_ptr, thread_index);
+	  if (ctx->udp_session_handle == udp_session_handle)
+	    {
+	      /*  Right ctx found, create conn & remove from pool */
+	      quic_create_connection(*ctx_index_ptr, sa, salen, packet_ctx->packet);
+	      pool_put (opening_ctx_pool, ctx_index_ptr);
+	      *max_packet = packet_n + 1;
+	      packet_ctx->thread_index = thread_index;
+	      packet_ctx->ctx_index = *ctx_index_ptr;
+	      goto updateOffset;
+	    }
+	}));
+	/* *INDENT-ON* */
+    }
+  else
+    {
+      quic_reset_connection (udp_session_handle, sa, salen,
+			     packet_ctx->packet);
+    }
+
+updateOffset:
+  *fifo_offset += SESSION_CONN_HDR_LEN + ph.data_length;
+  return 0;
+}
+
+static int
+quic_app_rx_callback (session_t * udp_session)
+{
+  /*  Read data from UDP rx_fifo and pass it to the quicly conn. */
+  application_t *app;
+  quic_ctx_t *ctx = NULL;
+  svm_fifo_t *f;
+  u32 max_deq;
   u32 app_index = udp_session->opaque;
   u64 udp_session_handle = session_handle (udp_session);
   int rv = 0;
+  app = application_get_if_valid (app_index);
   u32 thread_index = vlib_get_thread_index ();
-  quicly_context_t *quicly_ctx;
+  quic_rx_packet_ctx_t packets_ctx[16];
 
-  app = application_get_if_valid (app_index);
   if (!app)
     {
       QUIC_DBG (1, "Got RX on detached app");
@@ -1927,89 +2034,32 @@ quic_app_rx_callback (session_t * udp_session)
       f = udp_session->rx_fifo;
       max_deq = svm_fifo_max_dequeue (f);
       if (max_deq == 0)
-	return 0;
-
-      if (max_deq < SESSION_CONN_HDR_LEN)
-	{
-	  QUIC_DBG (1, "Not enough data for even a header in RX");
-	  return 1;
-	}
-      ret = svm_fifo_peek (f, 0, SESSION_CONN_HDR_LEN, (u8 *) & ph);
-      if (ret != SESSION_CONN_HDR_LEN)
 	{
-	  QUIC_DBG (1, "Not enough data for header in RX");
-	  return 1;
-	}
-      ASSERT (ph.data_offset == 0);
-      full_len = ph.data_length + SESSION_CONN_HDR_LEN;
-      if (full_len > max_deq)
-	{
-	  QUIC_DBG (1, "Not enough data in fifo RX");
-	  return 1;
+	  return 0;
 	}
 
-      /* Quicly can read len bytes from the fifo at offset:
-       * ph.data_offset + SESSION_CONN_HDR_LEN */
-      data = malloc (ph.data_length);
-      ret = svm_fifo_peek (f, SESSION_CONN_HDR_LEN, ph.data_length, data);
-      if (ret != ph.data_length)
+      u32 fifo_offset = 0;
+      u32 max_packets = 16;
+      for (int i = 0; i < max_packets; i++)
 	{
-	  QUIC_DBG (1, "Not enough data peeked in RX");
-	  free (data);
-	  return 1;
+	  quic_process_one_rx_packet (udp_session_handle,
+				      (quicly_context_t *) app->quicly_ctx, f,
+				      &fifo_offset, &max_packets, i,
+				      &packets_ctx[i]);
 	}
 
-      rv = 0;
-      quic_build_sockaddr (sa, &salen, &ph.rmt_ip, ph.rmt_port, ph.is_ip4);
-
-      quicly_ctx = quic_get_quicly_ctx_from_udp (udp_session_handle);
-      plen = quicly_decode_packet (quicly_ctx, &packet, data, ph.data_length);
-      if (plen != SIZE_MAX)
+      for (int i = 0; i < max_packets; i++)
 	{
-
-	  err = quic_find_packet_ctx (&ctx_thread, &ctx_index, sa, salen,
-				      &packet, thread_index);
-	  if (err == 0)
-	    {
-	      ctx = quic_ctx_get (ctx_index, thread_index);
-	      quic_receive (ctx, ctx->conn, packet);
-	    }
-	  else if (ctx_index != UINT32_MAX)
-	    {
-	      /* Connection found but on wrong thread, just wait for
-	       * session_migrate_callback to be called */
-	      return 0;
-	    }
-	  else if ((packet.octets.base[0] & QUICLY_PACKET_TYPE_BITMASK) ==
-		   QUICLY_PACKET_TYPE_INITIAL)
-	    {
-	      /*  Try to find matching "opening" ctx */
-	      opening_ctx_pool =
-		quic_main.wrk_ctx[thread_index].opening_ctx_pool;
-
-              /* *INDENT-OFF* */
-              pool_foreach (ctx_index_ptr, opening_ctx_pool,
-              ({
-                ctx = quic_ctx_get (*ctx_index_ptr, thread_index);
-                if (ctx->udp_session_handle == udp_session_handle)
-                  {
-                    /*  Right ctx found, create conn & remove from pool */
-                    quic_create_connection (*ctx_index_ptr, sa, salen, packet);
-                    pool_put (opening_ctx_pool, ctx_index_ptr);
-                    goto ctx_search_done;
-                  }
-              }));
-              /* *INDENT-ON* */
-
-	    }
-	  else
-	    {
-	      quic_reset_connection (udp_session_handle, sa, salen, packet);
-	    }
+	  if (packets_ctx[i].thread_index != thread_index)
+	    continue;
+
+	  ctx =
+	    quic_ctx_get (packets_ctx[i].ctx_index,
+			  packets_ctx[i].thread_index);
+	  check_quic_client_connected (&packets_ctx[i]);
+	  quic_send_packets (ctx);
 	}
-    ctx_search_done:
-      svm_fifo_dequeue_drop (f, full_len);
-      free (data);
+      svm_fifo_dequeue_drop (f, fifo_offset);
     }
   while (1);
   return rv;