Merge branch 'master' into long-random-hash

Author: huitema

UnitTest1/unittest1.cpp

@@ -2042,6 +2042,55 @@ namespace UnitTest1
             Assert::AreEqual(ret, 0);
         }
 
+        TEST_METHOD(cc_ns_asym)
+        {
+            int ret = cc_ns_asym_test();
+
+            Assert::AreEqual(ret, 0);
+        }
+
+        TEST_METHOD(cc_ns_blackhole)
+        {
+            int ret = cc_ns_blackhole_test();
+
+            Assert::AreEqual(ret, 0);
+        }
+
+        TEST_METHOD(cc_ns_drop_and_back)
+        {
+            int ret = cc_ns_drop_and_back_test();
+
+            Assert::AreEqual(ret, 0);
+        }
+
+        TEST_METHOD(cc_ns_low_and_up)
+        {
+            int ret = cc_ns_low_and_up_test();
+
+            Assert::AreEqual(ret, 0);
+        }
+
+        TEST_METHOD(cc_ns_wifi_fade)
+        {
+            int ret = cc_ns_wifi_fade_test();
+
+            Assert::AreEqual(ret, 0);
+        }
+
+        TEST_METHOD(cc_ns_wifi_suspension)
+        {
+            int ret = cc_ns_wifi_suspension_test();
+
+            Assert::AreEqual(ret, 0);
+        }
+
+        TEST_METHOD(cc_ns_varylink)
+        {
+            int ret = cc_ns_varylink_test();
+
+            Assert::AreEqual(ret, 0);
+        }
+
         TEST_METHOD(fastcc)
         {
             int ret = fastcc_test();

doc/socket_loop.md

@@ -38,7 +38,7 @@ int picoquic_packet_loop_v2(picoquic_quic_t* quic,
 ```
 
 The loop will execute,
-calling the Picoquic Netowrking API functions `picoquic_prepare_next_packet_ex`
+calling the Picoquic Networking API functions `picoquic_prepare_next_packet_ex`
 to ask the stack whether packets are ready to be sent and
 `picoquic_incoming_packet_ex` when packets are received from the network.
 
@@ -101,8 +101,8 @@ It exposes a series of callback events:
   it wants to be called for a time check before the loops waits for timers or incoming packets.
 * `picoquic_packet_loop_after_receive`: Called after packets have been received, enabling the application
   to perform picoquic API calls triggered by the received data.
-* `picoquic_packet_loop_after_send`: Called after packets have been received, enabling the application
-  to perform picoquic API calls triggered by the received data.
+* `picoquic_packet_loop_after_send`: Called after packets have been sent, enabling the application
+  to perform picoquic API calls triggered by the sent data.
 * `picoquic_packet_loop_port_update`: Provides a "loopback" socket address corresponding to the main
   socket. Can be used to learn the port number associated with that socket.
 * `picoquic_packet_loop_time_check`: Called before the packet loop starts waiting for a new packet or a

doc/usage.md

@@ -10,12 +10,12 @@ On Linux after building, the following executables are available in the project
 ## HTTP Client and Server Usage
 * client: ./picoquicdemo servername serverportnumber HTTPpath
   * downloaded files will be in current directory. use -o for another folder 
-  * exemple: ./picoquicdemo -o ../received 192.0.2.1 4433 index.html
+  * example: ./picoquicdemo -o ../received 192.0.2.1 4433 index.html
 * server: ./picoquicdemo -p portnumber
   * -p argument tells the program that it is acting as a server
   * HTML root folder is current directory by default. use -w for another folder
   * keys and certs are specified by -k and -c. See -h for more details.
-  * exemple: ./picoquicdemo -w ../htmlroot -p 4433
+  * example: ./picoquicdemo -w ../htmlroot -p 4433
 * additional useful information for HTTP usage is available at:
   * [Without DNS Names Or Certs](https://github.com/private-octopus/picoquic/wiki/Testing-without-DNS-names-or-Certificates)
   * [Certs Using Lets Encrypt](https://github.com/private-octopus/picoquic/wiki/Import-key-and-cert-on-server-from-Let's-encrypt)

picohttp/democlient.c

@@ -633,6 +633,9 @@ int picoquic_demo_client_callback(picoquic_cnx_t* cnx,
 
         break;
     }
+    case picoquic_callback_next_path_allowed:
+        /* This event should be handled according to the application's requirements */
+        break;
     default:
         /* unexpected */
         break;

picohttp/democlient.h

@@ -88,6 +88,10 @@ typedef struct st_picoquic_demo_client_callback_ctx_t {
     int no_print;
     int connection_ready;
     int connection_closed;
+
+    /* Context extension for handling asynchronous creation of paths */
+    void (*handle_path_allowed)(picoquic_cnx_t* cnx, void* ctx);
+    void* path_allowed_context;
 } picoquic_demo_callback_ctx_t;
 
 picoquic_alpn_enum picoquic_parse_alpn(char const * alpn);

picohttp_t/picohttp_t.c

@@ -110,7 +110,14 @@ static const picoquic_test_def_t test_table[] = {
     { "quicperf_overflow", quicperf_overflow_test },
     { "cc_compete_cubic2", cc_compete_cubic2_test },
     { "cc_compete_prague2", cc_compete_prague2_test },
-    { "cc_compete_d_cubic", cc_compete_d_cubic_test }
+    { "cc_compete_d_cubic", cc_compete_d_cubic_test },
+    { "cc_ns_asym", cc_ns_asym_test },
+    { "cc_ns_blackhole", cc_ns_blackhole_test },
+    { "cc_ns_drop_and_back", cc_ns_drop_and_back_test },
+    { "cc_ns_low_and_up", cc_ns_low_and_up_test },
+    { "cc_ns_wifi_fade", cc_ns_wifi_fade_test },
+    { "cc_ns_wifi_suspension", cc_ns_wifi_suspension_test },
+    { "cc_ns_varylink", cc_ns_varylink_test }
 };
 
 static size_t const nb_tests = sizeof(test_table) / sizeof(picoquic_test_def_t);

picoquic/frames.c

@@ -498,10 +498,13 @@ const uint8_t* picoquic_decode_new_connection_id_frame(picoquic_cnx_t* cnx, cons
         else {
             uint64_t transport_error = picoquic_add_remote_cnxid_to_stash(cnx, remote_cnxid_stash, retire_before,
                 sequence, cid_length, cnxid_bytes, secret_bytes, NULL);
-            if (transport_error == 0 && remote_cnxid_stash->retire_cnxid_before < retire_before) {
-                /* retire the now deprecated CIDs */
-                remote_cnxid_stash->retire_cnxid_before = retire_before;
-                transport_error = picoquic_remove_not_before_cid(cnx, unique_path_id, retire_before, current_time);
+            if (transport_error == 0) {
+                picoquic_test_and_signal_new_path_allowed(cnx);
+                if (remote_cnxid_stash->retire_cnxid_before < retire_before) {
+                    /* retire the now deprecated CIDs */
+                    remote_cnxid_stash->retire_cnxid_before = retire_before;
+                    transport_error = picoquic_remove_not_before_cid(cnx, unique_path_id, retire_before, current_time);
+                }
             }
             if (transport_error != 0) {
                 picoquic_connection_error(cnx, transport_error,

picoquic/picoquic.h

@@ -104,6 +104,12 @@ extern "C" {
 #define PICOQUIC_ERROR_PATH_ID_INVALID (PICOQUIC_ERROR_CLASS + 60)
 #define PICOQUIC_ERROR_RETRY_NEEDED (PICOQUIC_ERROR_CLASS + 61)
 #define PICOQUIC_ERROR_SERVER_BUSY (PICOQUIC_ERROR_CLASS + 62)
+#define PICOQUIC_ERROR_PATH_DUPLICATE (PICOQUIC_ERROR_CLASS + 63)
+#define PICOQUIC_ERROR_PATH_ID_BLOCKED (PICOQUIC_ERROR_CLASS + 64)
+#define PICOQUIC_ERROR_PATH_CID_BLOCKED (PICOQUIC_ERROR_CLASS + 65)
+#define PICOQUIC_ERROR_PATH_ADDRESS_FAMILY (PICOQUIC_ERROR_CLASS + 66)
+#define PICOQUIC_ERROR_PATH_NOT_READY (PICOQUIC_ERROR_CLASS + 67)
+#define PICOQUIC_ERROR_PATH_LIMIT_EXCEEDED (PICOQUIC_ERROR_CLASS + 68)
 
 /*
  * Protocol errors defined in the QUIC spec
@@ -274,7 +280,8 @@ typedef enum {
     picoquic_callback_path_deleted, /* An existing path has been deleted */
     picoquic_callback_path_quality_changed, /* Some path quality parameters have changed */
     picoquic_callback_path_address_observed, /* The peer has reported an address for the path */
-    picoquic_callback_app_wakeup /* wakeup timer set by application has expired */
+    picoquic_callback_app_wakeup, /* wakeup timer set by application has expired */
+    picoquic_callback_next_path_allowed /* There are enough path_id and connection ID available for the next path */
 } picoquic_call_back_event_t;
 
 typedef struct st_picoquic_tp_prefered_address_t {
@@ -858,6 +865,47 @@ void picoquic_set_rejected_version(picoquic_cnx_t* cnx, uint32_t rejected_versio
  * Like all user-level networking API, the "probe new path" API assumes that the
  * port numbers in the socket addresses structures are expressed in network order.
  * 
+ * If an error occurs during a call to picoquic_probe_new_path_ex,
+ * the function returns an error code describing the issue:
+ * 
+ *   PICOQUIC_ERROR_PATH_DUPLICATE: there is already an existing path with
+ *   the same 4 tuple. This error only happens if the multipath extensions
+ *   are not negotiated, because the multipath extensions allow creation of
+ *   multiple paths with the same 4 tuple.
+ * 
+ *   PICOQUIC_ERROR_PATH_ID_BLOCKED: when using the multipath extension,
+ *   the peers manage a max_path_id value. The code cannot create a new path
+ *   if the path_id would exceed the limit negotiated with the peer. Applications
+ *   encountering that error code should wait until the peer has increased the limit.
+ *   They may want to signal the issue to the peer by queuing a PATHS_BLOCKED frame.
+ * 
+ *   PICOQUIC_ERROR_PATH_CID_BLOCKED: when using the multipath extension,
+ *   the peers use NEW_PATH_CONNECTION_ID frame to provide CIDs associated with each
+ *   valid path_id. The error occurs when the peer has not yet provided CIDs for the
+ *   next path_id. Applications encountering the error should wait until the peer
+ *   provides CID for the path. They may want to signal the issue to the peer by
+ *   queuing a PATH_CIDS_BLOCKED frame.
+ * 
+ *   PICOQUIC_ERROR_PATH_ADDRESS_FAMILY: API error. The application is trying
+ *   to use a four tuple with different address family for source and destination.
+ * 
+ *   PICOQUIC_ERROR_PATH_NOT_READY: API error. The application is trying to create
+ *   paths before the connection handshake is complete. The application should wait
+ *   until it is notified that the connection is ready.
+ * 
+ *   PICOQUIC_ERROR_PATH_LIMIT_EXCEEDED: The application is trying to create more
+ *   simultaneous paths than allowed. It will need to close one of the existing paths
+ *   before creating a new one.
+ * 
+ * The errors PICOQUIC_ERROR_PATH_ID_BLOCKED, PICOQUIC_ERROR_PATH_CID_BLOCKED.
+ * PICOQUIC_ERROR_PATH_NOT_READY and PICOQUIC_ERROR_PATH_LIMIT_EXCEEDED are transient.
+ * The application can use the `picoquic_check_new_path_allowed` API to check whether
+ * a new path may be created. This function will return 1 if the path creation
+ * can be attempted immediately, 0 otherwise. If the return code is 0, the stack
+ * will issue a callback `picoquic_callback_next_path_ready` when the transient
+ * issues are resolved and `picoquic_probe_new_path_ex` could be called
+ * again.
+ * 
  * Path event callbacks can be enabled by calling "picoquic_enable_path_callbacks".
  * This can be set as the default for new connections by calling
  * "picoquic_enable_path_callbacks_default". If enabled, the folling events
@@ -893,10 +941,9 @@ void picoquic_set_rejected_version(picoquic_cnx_t* cnx, uint32_t rejected_versio
  * maintain path data in an app specific context, it will use a call to
  * "picoquic_set_app_path_ctx" to document it. The path created during
  * the connection setup has the unique_path_id 0.
- 
- * 
+ *
  * If an error occurs, such as reference to an obsolete unique path id,
- * all the functions return -1.
+ * all the path management functions return -1.
  * 
  * The call to "refresh the connection ID" will trigger a renewal of the connection
  * ID used for sending packets on that path. This API is mostly used in test
@@ -918,6 +965,8 @@ int picoquic_abandon_path(picoquic_cnx_t* cnx, uint64_t unique_path_id,
 int picoquic_refresh_path_connection_id(picoquic_cnx_t* cnx, uint64_t unique_path_id);
 int picoquic_set_stream_path_affinity(picoquic_cnx_t* cnx, uint64_t stream_id, uint64_t unique_path_id);
 int picoquic_set_path_status(picoquic_cnx_t* cnx, uint64_t unique_path_id, picoquic_path_status_enum status);
+int picoquic_subscribe_new_path_allowed(picoquic_cnx_t* cnx, int* is_already_allowed);
+
 /* The get path addr API provides the IP addresses used by a specific path.
 * The "local" argument determines whether the APi returns the local address
 * (local == 1), the address of the peer (local == 2) or the address observed by the peer (local == 3).

picoquic/picoquic_internal.h

@@ -1313,6 +1313,8 @@ typedef struct st_picoquic_cnx_t {
     unsigned int is_forced_probe_up_required : 1; /* application wants "probe up" if CC requests it */
     unsigned int is_address_discovery_provider : 1; /* send the address discovery extension */
     unsigned int is_address_discovery_receiver : 1; /* receive the address discovery extension */
+    unsigned int is_subscribed_to_path_allowed : 1; /* application wants to be advised if it is now possible to create a path */
+    unsigned int is_notified_that_path_is_allowed : 1; /* application wants to be advised if it is now possible to create a path */
 
     /* PMTUD policy */
     picoquic_pmtud_policy_enum pmtud_policy;
@@ -2043,6 +2045,8 @@ const uint8_t* picoquic_skip_path_abandon_frame(const uint8_t* bytes, const uint
 const uint8_t* picoquic_skip_path_available_or_standby_frame(const uint8_t* bytes, const uint8_t* bytes_max);
 int picoquic_queue_path_available_or_standby_frame(
     picoquic_cnx_t* cnx, picoquic_path_t* path_x, picoquic_path_status_enum status);
+/* Internal only API, notify that next path is now allowed. */
+void picoquic_test_and_signal_new_path_allowed(picoquic_cnx_t* cnx);
 
 int picoquic_decode_closing_frames(picoquic_cnx_t* cnx, uint8_t* bytes, size_t bytes_max, int* closing_received);
 

picoquic/picoquic_utils.h

@@ -297,6 +297,8 @@ typedef struct st_picoquictest_sim_link_t {
     /* Variable for multipath simulation */
     int is_switched_off;
     int is_unreachable;
+    /* variable for simulating suspension */
+    int is_suspended;
 } picoquictest_sim_link_t;
 
 picoquictest_sim_link_t* picoquictest_sim_link_create(double data_rate_in_gps,