Merge remote-tracking branch 'upstream/master'

CMakeLists.txt

@@ -8,7 +8,7 @@ else()
 endif()
 
 project(picoquic
-        VERSION 1.1.16.0
+        VERSION 1.1.16.1
         DESCRIPTION "picoquic library"
         LANGUAGES C CXX)
 

UnitTest1/unittest1.cpp

@@ -1607,6 +1607,20 @@ namespace UnitTest1
             Assert::AreEqual(ret, 0);
         }
 
+        TEST_METHOD(idle_server)
+        {
+            int ret = idle_server_test();
+
+            Assert::AreEqual(ret, 0);
+        }
+
+        TEST_METHOD(idle_timeout)
+        {
+            int ret = idle_timeout_test();
+
+            Assert::AreEqual(ret, 0);
+        }
+
         TEST_METHOD(ready_to_send)
         {
             int ret = ready_to_send_test();

picohttp_t/picohttp_t.c

@@ -80,8 +80,10 @@ static const picoquic_test_def_t test_table[] = {
     { "h09_multi_file_preemptive", h09_multi_file_preemptive_test },
     { "h3zero_settings", h3zero_settings_test },
     { "http_stress", http_stress_test },
+#if 0
     { "http_corrupt", http_corrupt_test},
     { "http_corrupt_rdpn", http_corrupt_rdpn_test},
+#endif
     { "http_drop", http_drop_test},
     { "picowt_baton_basic", picowt_baton_basic_test },
     { "picowt_baton_error", picowt_baton_error_test },

picoquic/picoquic.h

@@ -40,7 +40,7 @@
 extern "C" {
 #endif
 
-#define PICOQUIC_VERSION "1.1.16.0"
+#define PICOQUIC_VERSION "1.1.16.1"
 #define PICOQUIC_ERROR_CLASS 0x400
 #define PICOQUIC_ERROR_DUPLICATE (PICOQUIC_ERROR_CLASS + 1)
 #define PICOQUIC_ERROR_AEAD_CHECK (PICOQUIC_ERROR_CLASS + 3)
@@ -287,7 +287,7 @@ typedef struct st_picoquic_tp_t {
     uint64_t initial_max_data;
     uint64_t initial_max_stream_id_bidir;
     uint64_t initial_max_stream_id_unidir;
-    uint64_t idle_timeout;
+    uint64_t max_idle_timeout;
     uint32_t max_packet_size;
     uint32_t max_ack_delay; /* stored in in microseconds for convenience */
     uint32_t active_connection_id_limit;
@@ -652,8 +652,33 @@ void picoquic_set_cwin_min(picoquic_quic_t* quic, uint64_t cwin_min);
 */
 void picoquic_set_max_data_control(picoquic_quic_t* quic, uint64_t max_data);
 
+/*
+* Idle timeout and handshake timeout
+* 
+* The max idle timeout determines how long to wait for sign of activity from
+* the peer before giving up on a connection. It is set by default to 
+* PICOQUIC_MICROSEC_HANDSHAKE_MAX, coverted in milliseconds (30 seconds).
+* It can be set per quic context using `picoquic_set_default_idle_timeout`,
+* before creating new connections in that context. The value is expressed
+* in milliseconds, with zero meaning "infinity". The value used for the
+* connection is the lowest of the value proposed by the client and the server,
+* as specified in RFC 9000.
+* 
+* The handshake timeout determines how long to wait for the completion
+* of a connection. It can be specified per QUIC context using
+* `picoquic_set_default_handshake_timeout`. The value is expressed
+* in microseconds, with `0` meaning unspecified.
+* 
+* If the handshake timeout is not specified, the wait time is determined by the
+* value of the default idle timeout specified for the QUIC context. If that
+* value is zero, the system uses the value of PICOQUIC_MICROSEC_HANDSHAKE_MAX,
+* i.e., 30 seconds.
+*/
+
 /* Set the idle timeout parameter for the context. Value is in milliseconds. */
-void picoquic_set_default_idle_timeout(picoquic_quic_t* quic, uint64_t idle_timeout);
+void picoquic_set_default_idle_timeout(picoquic_quic_t* quic, uint64_t idle_timeout_ms);
+/* Set the default handshake timeout parameter for the context.*/
+void picoquic_set_default_handshake_timeout(picoquic_quic_t* quic, uint64_t handshake_timeout_us);
 
 /* Set the length of a crypto epoch -- force rotation after that many packets sent */
 void picoquic_set_default_crypto_epoch_length(picoquic_quic_t* quic, uint64_t crypto_epoch_length_max);

picoquic/picoquic_internal.h

@@ -634,7 +634,7 @@ typedef struct st_picoquic_quic_t {
     picoquic_spinbit_version_enum default_spin_policy;
     picoquic_lossbit_version_enum default_lossbit_policy;
     uint32_t default_multipath_option;
-    uint64_t default_idle_timeout;
+    uint64_t default_handshake_timeout;
     uint64_t crypto_epoch_length_max; /* Default packet interval between key rotations */
     uint32_t max_simultaneous_logs;
     uint32_t current_number_of_open_logs;

picoquic/quicctx.c

@@ -841,10 +841,14 @@ void picoquic_set_max_data_control(picoquic_quic_t* quic, uint64_t max_data)
     }
 }
 
-void picoquic_set_default_idle_timeout(picoquic_quic_t* quic, uint64_t idle_timeout)
+void picoquic_set_default_idle_timeout(picoquic_quic_t* quic, uint64_t idle_timeout_ms)
 {
-    quic->default_idle_timeout = idle_timeout;
-    quic->default_tp.idle_timeout = idle_timeout;
+    quic->default_tp.max_idle_timeout = idle_timeout_ms;
+}
+
+void picoquic_set_default_handshake_timeout(picoquic_quic_t* quic, uint64_t handshake_timeout_us)
+{
+    quic->default_handshake_timeout = handshake_timeout_us;
 }
 
 void picoquic_set_default_crypto_epoch_length(picoquic_quic_t* quic, uint64_t crypto_epoch_length_max)
@@ -1230,7 +1234,7 @@ void picoquic_init_transport_parameters(picoquic_tp_t* tp, int client_mode)
     tp->initial_max_data = 0x100000;
     tp->initial_max_stream_id_bidir = 512;
     tp->initial_max_stream_id_unidir = 512;
-    tp->idle_timeout = PICOQUIC_MICROSEC_HANDSHAKE_MAX/1000;
+    tp->max_idle_timeout = PICOQUIC_MICROSEC_HANDSHAKE_MAX/1000;
     tp->max_packet_size = PICOQUIC_PRACTICAL_MAX_MTU;
     tp->max_datagram_frame_size = 0;
     tp->ack_delay_exponent = 3;
@@ -4561,7 +4565,7 @@ void picoquic_enable_keep_alive(picoquic_cnx_t* cnx, uint64_t interval)
         uint64_t idle_timeout = cnx->idle_timeout;
         if (idle_timeout == 0) {
             /* Idle timeout is only initialized after parameters are negotiated  */
-            idle_timeout = cnx->local_parameters.idle_timeout * 1000ull;
+            idle_timeout = cnx->local_parameters.max_idle_timeout * 1000ull;
         }
         /* Ensure at least 3 PTO*/
         if (idle_timeout < 3 * cnx->path[0]->retransmit_timer) {

picoquic/sender.c

@@ -3861,8 +3861,11 @@ static int picoquic_check_idle_timer(picoquic_cnx_t* cnx, uint64_t* next_wake_ti
             idle_timer = UINT64_MAX;
         }
     }
-    else if (cnx->local_parameters.idle_timeout > (PICOQUIC_MICROSEC_HANDSHAKE_MAX / 1000)) {
-        idle_timer = cnx->start_time + cnx->local_parameters.idle_timeout*1000ull;
+    else if (cnx->quic->default_handshake_timeout > 0) {
+        idle_timer = cnx->start_time + cnx->quic->default_handshake_timeout;
+    }
+    else if (cnx->local_parameters.max_idle_timeout > 0) {
+        idle_timer = cnx->start_time + cnx->local_parameters.max_idle_timeout*1000ull;
     }
     else {
         idle_timer = cnx->start_time + PICOQUIC_MICROSEC_HANDSHAKE_MAX;
@@ -4284,8 +4287,8 @@ int picoquic_prepare_packet_ex(picoquic_cnx_t* cnx,
     uint64_t initial_next_time;
     uint64_t next_wake_time = cnx->latest_receive_time + 2*PICOQUIC_MICROSEC_SILENCE_MAX;
 
-    if (cnx->local_parameters.idle_timeout >(PICOQUIC_MICROSEC_SILENCE_MAX / 500)) {
-        next_wake_time = cnx->latest_receive_time + cnx->local_parameters.idle_timeout * 1000ull;
+    if (cnx->local_parameters.max_idle_timeout >(PICOQUIC_MICROSEC_SILENCE_MAX / 500)) {
+        next_wake_time = cnx->latest_receive_time + cnx->local_parameters.max_idle_timeout * 1000ull;
     }
 
     SET_LAST_WAKE(cnx->quic, PICOQUIC_SENDER);

picoquic/timing.c

@@ -64,11 +64,11 @@ uint64_t picoquic_current_retransmit_timer(picoquic_cnx_t* cnx, picoquic_path_t
     }
 
     if (cnx->cnx_state < picoquic_state_client_ready_start) {
-        if (PICOQUIC_MICROSEC_HANDSHAKE_MAX / 1000 < cnx->local_parameters.idle_timeout) {
+        if (PICOQUIC_MICROSEC_HANDSHAKE_MAX / 1000 < cnx->local_parameters.max_idle_timeout) {
             /* Special case of very long delays */
             rto = path_x->retransmit_timer << path_x->nb_retransmit;
-            if (rto > cnx->local_parameters.idle_timeout * 100) {
-                rto = cnx->local_parameters.idle_timeout * 100;
+            if (rto > cnx->local_parameters.max_idle_timeout * 100) {
+                rto = cnx->local_parameters.max_idle_timeout * 100;
             }
         } else if (rto > PICOQUIC_INITIAL_MAX_RETRANSMIT_TIMER) {
             rto = PICOQUIC_INITIAL_MAX_RETRANSMIT_TIMER;

picoquic/transport.c

@@ -403,9 +403,9 @@ int picoquic_prepare_transport_extensions(picoquic_cnx_t* cnx, int extension_mod
             cnx->local_parameters.initial_max_stream_id_bidir);
     }
 
-    if (cnx->local_parameters.idle_timeout > 0) {
+    if (cnx->local_parameters.max_idle_timeout > 0) {
         bytes = picoquic_transport_param_type_varint_encode(bytes, bytes_max, picoquic_tp_idle_timeout,
-            cnx->local_parameters.idle_timeout);
+            cnx->local_parameters.max_idle_timeout);
     }
 
     bytes = picoquic_transport_param_type_varint_encode(bytes, bytes_max, picoquic_tp_max_packet_size,
@@ -595,7 +595,7 @@ void picoquic_clear_transport_extensions(picoquic_cnx_t* cnx)
     cnx->maxdata_remote = cnx->remote_parameters.initial_max_data;
     cnx->remote_parameters.initial_max_stream_id_bidir = 0;
     cnx->max_stream_id_bidir_remote = 0;
-    cnx->remote_parameters.idle_timeout = 0;
+    cnx->remote_parameters.max_idle_timeout = 0;
     cnx->remote_parameters.max_packet_size = 1500;
     cnx->remote_parameters.ack_delay_exponent = 3;
     cnx->remote_parameters.initial_max_stream_id_unidir = 0;
@@ -703,7 +703,7 @@ int picoquic_receive_transport_extensions(picoquic_cnx_t* cnx, int extension_mod
                     break;
                 }
                 case picoquic_tp_idle_timeout:
-                    cnx->remote_parameters.idle_timeout = 
+                    cnx->remote_parameters.max_idle_timeout = 
                         picoquic_transport_param_varint_decode(cnx, bytes + byte_index, extension_length, &ret);
                     break;
 
@@ -928,11 +928,11 @@ int picoquic_receive_transport_extensions(picoquic_cnx_t* cnx, int extension_mod
      * If the keep alive interval was set to a too short value,
      * reset it.
      */
-    cnx->idle_timeout = cnx->local_parameters.idle_timeout*1000ull;
-    if (cnx->local_parameters.idle_timeout == 0 ||
-        (cnx->remote_parameters.idle_timeout > 0 && cnx->remote_parameters.idle_timeout < 
-            cnx->local_parameters.idle_timeout)) {
-        cnx->idle_timeout = cnx->remote_parameters.idle_timeout*1000ull;
+    cnx->idle_timeout = cnx->local_parameters.max_idle_timeout*1000ull;
+    if (cnx->local_parameters.max_idle_timeout == 0 ||
+        (cnx->remote_parameters.max_idle_timeout > 0 && cnx->remote_parameters.max_idle_timeout < 
+            cnx->local_parameters.max_idle_timeout)) {
+        cnx->idle_timeout = cnx->remote_parameters.max_idle_timeout*1000ull;
     }
     if (cnx->idle_timeout == 0) {
         cnx->idle_timeout = UINT64_MAX;

picoquic_t/picoquic_t.c

@@ -271,6 +271,8 @@ static const picoquic_test_def_t test_table[] = {
     { "ec5c_silly_cid", ec5c_silly_cid_test },
     { "ec9a_preemptive_amok", ec9a_preemptive_amok_test },
     { "error_reason", error_reason_test },
+    { "idle_server", idle_server_test },
+    { "idle_timeout", idle_timeout_test },
     { "ready_to_send", ready_to_send_test },
     { "ready_to_skip", ready_to_skip_test },
     { "ready_to_zfin", ready_to_zfin_test },

picoquicfirst/picoquicdemo.c

@@ -277,9 +277,6 @@ picohttp_server_path_item_t path_item_list[2] =
     }
 };
 
-
-
-
 int quic_server(const char* server_name, picoquic_quic_config_t * config, int just_once)
 {
     /* Start: start the QUIC process with cert and key files */

picoquictest/cnxstress.c

@@ -742,7 +742,7 @@ int cnx_stress_set_default_tp(picoquic_quic_t* quic)
     tp.initial_max_stream_data_uni = 0x20000;
     tp.initial_max_stream_id_unidir = 64;
     tp.initial_max_data = 0x20000;
-    tp.idle_timeout = 60000;
+    tp.max_idle_timeout = 60000;
     tp.max_packet_size = PICOQUIC_MAX_PACKET_SIZE;
     tp.max_ack_delay = 10000;
     tp.active_connection_id_limit = 3;

picoquictest/delay_tolerant_test.c

@@ -82,7 +82,7 @@ static int dtn_test_one(uint8_t test_id, dtn_test_spec_t * spec)
     memset(&client_parameters, 0, sizeof(picoquic_tp_t));
     picoquic_init_transport_parameters(&client_parameters, 1);
     client_parameters.enable_time_stamp = 3;
-    client_parameters.idle_timeout = (uint32_t)((spec->latency * 5)/1000);
+    client_parameters.max_idle_timeout = (uint32_t)((spec->latency * 5)/1000);
     if (spec->initial_flow_control_credit > client_parameters.initial_max_data) {
         client_parameters.initial_max_data = spec->initial_flow_control_credit;
     }
@@ -95,7 +95,7 @@ static int dtn_test_one(uint8_t test_id, dtn_test_spec_t * spec)
     memset(&server_parameters, 0, sizeof(picoquic_tp_t));
     picoquic_init_transport_parameters(&server_parameters, 0);
     server_parameters.enable_time_stamp = 3;
-    server_parameters.idle_timeout = client_parameters.idle_timeout;
+    server_parameters.max_idle_timeout = client_parameters.max_idle_timeout;
 
     ret = tls_api_one_scenario_init_ex(&test_ctx, &simulated_time, PICOQUIC_INTERNAL_TEST_VERSION_1, &client_parameters, &server_parameters, &initial_cid, 0);