work-in-progress network API

Author: huitema

picoquic/picoqmux.h

@@ -0,0 +1 @@
+#pragma once

picoquic/picoquic.h

@@ -202,6 +202,7 @@ typedef enum {
     picoquic_state_disconnected
 } picoquic_state_enum;
 
+
 /*
  * Transport parameters, as defined by the QUIC transport specification.
  * The initial code defined the type as an enum, but the binary representation
@@ -1145,6 +1146,31 @@ int picoquic_subscribe_to_quality_update_per_path(picoquic_cnx_t* cnx, uint64_t
 void picoquic_subscribe_to_quality_update(picoquic_cnx_t* cnx, uint64_t pacing_rate_delta, uint64_t rtt_delta);
 void picoquic_default_quality_update(picoquic_quic_t* quic, uint64_t pacing_rate_delta, uint64_t rtt_delta);
 
+/* The socket creation API is used to set the socket creation function
+* in the picoquic context. That function needs to be set by the
+* packet loop when it starts. It has three parameters:
+*
+* - a calling context, specified by the socket loop.
+* - the socket address family, type and protocol.
+* - the local address, in which the socket type MUST be specified. If
+*   the IP address and port numbers are specified, the socket will
+*   be bound to these addresses.
+* - an optional remote address. If it is specified, the socket will
+*   be connected to that address, using an asynchronous version of
+*   the connect call.
+*
+* The function returns a (void *) version of the handle of the socket
+* that was created.
+*/
+
+typedef void (*picoquic_create_socket_fn)(void* create_socket_ctx,
+    int af, int type, int protocol,
+    struct sockaddr* addr_local, struct sockaddr* addr_remote, int interface_index);
+
+int picoquic_set_socket_fn(picoquic_quic_t* quic, picoquic_create_socket_fn socket_fn,
+    void* create_socket_ctx);
+
+
 /* Connection management API.
  * TODO: many of these API should be deprecated. They were created when we
  * envisaged that applications would directly manipulate which connection

picoquic/picoquic_internal.h

@@ -654,6 +654,7 @@ typedef struct st_picoquic_quic_t {
     picohash_table* table_cnx_by_net;
     picohash_table* table_cnx_by_icid;
     picohash_table* table_cnx_by_secret;
+    picohash_table* table_cnx_by_socket_id; /* used for QMux */
 
     picohash_table* table_issued_tickets;
     picoquic_issued_ticket_t* table_issued_tickets_first;
@@ -697,6 +698,10 @@ typedef struct st_picoquic_quic_t {
     uint64_t rtt_update_delta;
     uint64_t pacing_rate_update_delta;
 
+    /* Creation of additional socket, if authorized by packet loop. */
+    picoquic_create_socket_fn create_socket_fn;
+    void* create_socket_ctx;
+
     /* Logging APIS */
     void* F_log;
     char* binlog_dir;
@@ -1395,6 +1400,9 @@ typedef struct st_picoquic_cnx_t {
     picoquic_ack_context_t ack_ctx[picoquic_nb_packet_context];
     /* Sequence number of the next observed address frame */
     uint64_t observed_number;
+    /* Handling of QMUX socket */
+    void* qmux_socket_id;
+    picohash_item registered_socket_id_item;
     /* Handling of the QMux QX_PING frame */
     uint64_t qx_acked_last; /* last qx_ping query of the peer acked */
     uint64_t qx_query_last; /* sequence of last qx_ping query from the peer */

picoquic/qmux.c

@@ -641,7 +641,7 @@ int picoqmux_prepare_packet(picoquic_cnx_t* cnx, uint64_t current_time, uint8_t*
 }
 
 /*  Prepare the next packets to send in the current buffer */
-int picoqmux_prepare_packets(picoquic_cnx_t* cnx, uint64_t current_time, uint8_t* send_buffer, size_t send_buffer_max, size_t* send_length, uint64_t* next_wake_time)
+int picoqmux_prepare_cnx_packets(picoquic_cnx_t* cnx, uint64_t current_time, uint8_t* send_buffer, size_t send_buffer_max, size_t* send_length, uint64_t* next_wake_time)
 {
     int ret = 0;
     *send_length = 0;
@@ -837,7 +837,7 @@ int picoqmux_decode_frames(picoquic_cnx_t* cnx, picoquic_path_t* path_x, const u
     return bytes != NULL ? 0 : PICOQUIC_ERROR_DETECTED;
 }
 
-int picoqmux_incoming_packet(picoquic_cnx_t* cnx, uint64_t current_time, 
+int picoqmux_incoming_cnx_packet(picoquic_cnx_t* cnx, uint64_t current_time, 
     const uint8_t* receive_buffer, size_t receive_length, uint64_t* next_wake_time)
 {
     int ret = 0;
@@ -852,3 +852,167 @@ int picoqmux_incoming_packet(picoquic_cnx_t* cnx, uint64_t current_time,
     }
     return ret;
 }
+
+/* Connection context:
+ * The link between a QMUX connection context and a socket_id is
+ * tracked in the table "table_cnx_by_socket_id". This is a hash table
+ * in the QUIC context, with the "socket_id" used as the key.
+ * 
+ * The socket_id in NULL when the connection is created.
+ * It is added to the context via the call to picoqmux_set_cnx_socket,
+ * and removed from the context when the connection is deleted, or
+ * if the socket_id for the connection is reset to a NULL value.
+ * (TODO: synchronize QUIC context and socket loop.)
+ */
+
+static uint64_t picoquic_socket_id_hash(const void* key, const uint8_t* hash_seed)
+{
+    uint64_t h;
+    uint8_t bytes[sizeof(void*)];
+    const picoquic_cnx_t* cnx = (const picoquic_cnx_t*)key;
+    /* Using siphash, because CNX ID and IP address are chosen by third parties*/
+    h = picohash_siphash(&cnx->qmux_socket_id, (uint32_t)sizeof(void*), hash_seed);
+    return h;
+}
+
+static int picoquic_socket_id_compare(const void* key1, const void* key2)
+{
+    const picoquic_cnx_t* cnx1 = (const picoquic_cnx_t*)key1;
+    const picoquic_cnx_t* cnx2 = (const picoquic_cnx_t*)key2;
+    int ret = cnx1->qmux_socket_id == cnx2->qmux_socket_id;
+
+    return ret;
+}
+
+static picohash_item* picoquic_socket_id_to_item(const void* key)
+{
+    picoquic_cnx_t* cnx = (picoquic_cnx_t*)key;
+
+    return &cnx->registered_socket_id_item;
+}
+
+int picoquic_register_socket_id(picoquic_quic_t* quic, picoquic_cnx_t* cnx, void* socket_id)
+{
+    int ret = 0;
+    picoquic_cnx_t dummy_cnx = { 0 };
+    picohash_item* item;
+
+    dummy_cnx.qmux_socket_id = socket_id;
+    item = picohash_retrieve(quic->table_cnx_by_socket_id, &dummy_cnx);
+    if (item != NULL) {
+        ret = -1;
+    }
+    else {
+        cnx->qmux_socket_id = socket_id;
+        ret = picohash_insert(quic->table_cnx_by_socket_id, cnx);
+    }
+
+    return ret;
+}
+
+void picoquic_unregister_socket_id(picoquic_cnx_t* cnx)
+{
+    if (cnx->qmux_socket_id != NULL) {
+        picohash_item* item = picohash_retrieve(cnx->quic->table_cnx_by_socket_id, cnx);
+        if (item != NULL) {
+            picohash_delete_item(cnx->quic->table_cnx_by_socket_id, item, 0);
+        }
+        cnx->qmux_socket_id = NULL;
+        memset(&cnx->registered_socket_id_item, 0, sizeof(cnx->registered_socket_id_item));
+    }
+}
+
+
+/* Initiation of a QUIC context to make it QMUX ready.
+ */
+int picoqmux_set_context(picoquic_quic_t* quic)
+{
+    int ret = 0;
+
+    if ((quic->table_cnx_by_icid = picohash_create_ex((size_t)quic->max_number_connections,
+        picoquic_socket_id_hash, picoquic_socket_id_compare, picoquic_socket_id_to_item, quic->hash_seed)) == NULL) {
+        ret = -1; 
+    }
+
+    return ret;
+}
+
+int picoqmux_start_sockets(picoquic_quic_t* quic)
+{
+    /* Go through the list of pending qmux connections and start the
+     * required sockets */
+}
+
+int picoqmux_clear_context(picoquic_quic_t* quic)
+{
+    /* Terminate the pending sockets */
+    /* Terminate the active sockets */
+    /* Clear the socket_id table */
+}
+
+/*
+* QMux outgoing connection creation.
+* When creating a QMUx connection, the code needs to create an additional
+* TCP socket in the "socket loop" context.
+*
+* We want to preserve the possibility of using different variations of the
+* socket loop code. We do that by adding a call from the socket loop
+* to the QUIC context to set the "socket create" function and context.
+*
+* The socket create function allows for creation of new sockets from the
+* QUIC context. The main parameter is a socket address to which the
+* connection should be connected. (Questions: should there be an option
+* to bind the address to a specific local address before setting the
+* connect call? Should there be an option to create an extra UDP socket,
+* or just TCP?)
+*
+* This code assumes that the socket loop is created already. We need a special
+* logic to manage "pending" connections created before the socket loop
+* starts. Probably a queue of pending connection, which will be moved
+* to active connections as soon as sockets can be created.
+*/
+
+int picoqmux_create_cnx(picoquic_cnx_t* cnx)
+{
+    int ret = 0;
+    if (cnx->quic->create_socket_fn == NULL) {
+        /* queue to the qmux pending list */
+    }
+    else {
+        /* create the required socket */
+        /* set the other qmux parameters */
+        /* register the socket */
+    }
+    return 0;
+}
+
+
+/*
+* QMux input call, from the socket loop.
+*/
+int picoqmux_incoming_cnx_packet(picoquic_quic_t* quic, uint64_t socket_id,
+    uint64_t current_time, const uint8_t* receive_buffer, size_t receive_length)
+{
+    /* Find the connection based on the socket ID.
+    * Possibly, create a connection if this is a new socket?
+     */
+
+     /* submit the data to the connection context. */
+
+     /* return an error if this socket should be closed. */
+}
+
+/*
+* QMux prepare call, from the socket loop.
+*/
+int picoqmux_prepare_packet(picoquic_quic_t* quic, uint64_t socket_id, uint64_t current_time,
+    uint8_t* send_buffer, size_t send_buffer_max, size_t* send_length)
+{
+    /* Find the connection based on the socket ID.
+    * Possibly, create a connection if this is a new socket?
+    */
+
+    /* obtain the data from connection context. */
+
+    /* return an error if this socket should be closed. */
+}

picoquic/quicctx.c

@@ -2766,6 +2766,16 @@ void picoquic_default_quality_update(picoquic_quic_t* quic, uint64_t pacing_rate
     quic->rtt_update_delta = rtt_delta;
 }
 
+
+/* Setting the socket creation function */
+
+int picoquic_set_socket_fn(picoquic_quic_t* quic, picoquic_create_socket_fn socket_fn, void* create_socket_ctx)
+{
+    return 0;
+}
+
+/* management of path */
+
 int picoquic_refresh_path_connection_id(picoquic_cnx_t* cnx, uint64_t unique_path_id)
 {
     int ret = -1;

picoquictest/qmux_test.c

@@ -43,8 +43,8 @@
 #include "picoquic_qlog.h"
 
 int picoqmux_init(picoquic_cnx_t* cnx);
-int picoqmux_prepare_packet(picoquic_cnx_t* cnx, uint64_t current_time, uint8_t* send_buffer, size_t send_buffer_max, size_t* send_length, uint64_t* next_wake_time);
-int picoqmux_incoming_packet(picoquic_cnx_t* cnx, uint64_t current_time,
+int picoqmux_prepare_cnx_packets(picoquic_cnx_t* cnx, uint64_t current_time, uint8_t* send_buffer, size_t send_buffer_max, size_t* send_length, uint64_t* next_wake_time);
+int picoqmux_incoming_cnx_packet(picoquic_cnx_t* cnx, uint64_t current_time,
     const uint8_t* receive_buffer, size_t receive_length, uint64_t* next_wake_time);
 int picoqmux_has_sent_tp(picoquic_cnx_t* cnx);
 int picoqmux_has_received_tp(picoquic_cnx_t* cnx);
@@ -85,7 +85,7 @@ int qmux_send_test(void)
     }
     if (ret == 0) {
         /* prepare the packet */
-        ret = picoqmux_prepare_packet(cnx, 0, buffer, sizeof(buffer), &send_length, &next_wake_time);
+        ret = picoqmux_prepare_cnx_packets(cnx, 0, buffer, sizeof(buffer), &send_length, &next_wake_time);
 
         if (send_length != sizeof(qmux_test_packet) ||
             memcmp(buffer, qmux_test_packet, send_length) != 0) {
@@ -199,7 +199,7 @@ int qmux_send_tp_test(void)
 
     if (ret == 0) {
         /* prepare the packet */
-        ret = picoqmux_prepare_packet(cnx, 0, buffer, sizeof(buffer), &send_length, &next_wake_time);
+        ret = picoqmux_prepare_cnx_packets(cnx, 0, buffer, sizeof(buffer), &send_length, &next_wake_time);
 
         if (send_length != sizeof(qmux_test_tp_packet) ||
             memcmp(buffer, qmux_test_tp_packet, send_length) != 0) {
@@ -241,7 +241,7 @@ int qmux_receive_test_one(int client_mode, int is_tp_received, int is_tp_sent,
     picoquic_set_callback(cnx, qmux_test_callback, &qtc);
     if (ret == 0) {
         /* prepare a packet */
-        int r_ret = picoqmux_incoming_packet(cnx, 12345,
+        int r_ret = picoqmux_incoming_cnx_packet(cnx, 12345,
             msg, length, &next_wake_time);
 
         if (r_ret == 0) {
@@ -436,7 +436,7 @@ int qmux_send_qx_ping_r_test(void)
         picoqmux_update_state_on_tp_sent(cnx);
         picoqmux_update_state_on_tp_received(cnx);
         /* prepare the packet */
-        ret = picoqmux_prepare_packet(cnx, 0, buffer, sizeof(buffer), &send_length, &next_wake_time);
+        ret = picoqmux_prepare_cnx_packets(cnx, 0, buffer, sizeof(buffer), &send_length, &next_wake_time);
 
         if (send_length != sizeof(qmux_qx_ping_r_packet) ||
             memcmp(buffer, qmux_qx_ping_r_packet, send_length) != 0) {
@@ -466,7 +466,7 @@ int qmux_send_cnx_close_test(void)
         /* Simulate that the local application requests disconnect */
         picoquic_close(cnx, 0);
         /* prepare the packet */
-        ret = picoqmux_prepare_packet(cnx, 0, buffer, sizeof(buffer), &send_length, &next_wake_time);
+        ret = picoqmux_prepare_cnx_packets(cnx, 0, buffer, sizeof(buffer), &send_length, &next_wake_time);
 
         if (send_length != sizeof(qmux_app_close_packet) ||
             memcmp(buffer, qmux_app_close_packet, send_length) != 0 ||
@@ -479,3 +479,22 @@ int qmux_send_cnx_close_test(void)
 
     return ret;
 }
+
+/*
+* Network simulation tests.
+* The simulations have to use an interface between the picoquic stack and the
+* network. This is logically split between:
+* - socket loop functions that wait for new TCP and new TCP data
+*   or permission to send.
+* - Qmux function that accumulate a segment of data per connection.
+* We assume that the Qmux function are implemented as a Qmux extension to the
+* picoquic_quic_t context. We need functions to:
+* - create a Qmux context: extension of picoquic_quic_t with new API.
+* - create a Qmux connection: chained to the Qmux context, create a
+*   tcp socket through an asynchronous call to the socket loop.
+* - receive data from a socket.
+* - request permission to write on a socket.
+* - get polled for writing on the socket if data is granted.
+* - ask the socket loop to close a socket.
+* - get notified that a socket is closed.
+*/