fix: correct 0-RTT transport param validation guard and test mock

Revert the ineffective `|| XQC_CONN_FLAG_0RTT_OK` added to the
production guard in xqc_conn_tls_transport_params_cb.  The original
condition `xqc_tls_is_early_data_accepted() == ACCEPT` is already
correct at tp_cb time: BoringSSL sets `early_data_accepted` during
do_read_encrypted_extensions (step 2), while set_read_secret(application)
fires in do_complete_second_flight (step 9), so the SSL query returns
the right value.  0RTT_OK is set even later in handshake completion,
making the `||` branch dead code in production.

The real problem was the unit test: mock connections have
tls->resumption == FALSE (no session ticket), causing
xqc_tls_is_early_data_accepted() to early-return NO_EARLY_DATA and
skip the validation block entirely.

Fix by adding xqc_tls_set_early_data_accepted() to override the
early-data query result without a real TLS handshake, and use it in
the test mock setup.  Also move 0-RTT test registration earlier in
main.c to avoid a pre-existing SIGSEGV in a later test.

Refs: RFC 9000 Section 7.4.1, issue #717

Co-Authored-By: Claude (claude-opus-4-6) <noreply@anthropic.com>

Author: cherylsy

src/tls/xqc_tls.c

@@ -65,6 +65,10 @@ typedef struct xqc_tls_s {
 
     xqc_bool_t                  key_update_confirmed;
 
+    /* test-only: override early_data_accepted result (XQC_TLS_EARLY_DATA_ACCEPT
+     * or XQC_TLS_EARLY_DATA_REJECT); 0 means no override (default) */
+    xqc_tls_early_data_accept_t early_data_accepted_override;
+
 } xqc_tls_t;
 
 
@@ -708,6 +712,11 @@ xqc_tls_get_cipher_id(SSL *ssl, const SSL_CIPHER *cipher, xqc_encrypt_level_t le
 xqc_tls_early_data_accept_t
 xqc_tls_is_early_data_accepted(xqc_tls_t *tls)
 {
+    /* allow tests to bypass the SSL query */
+    if (tls->early_data_accepted_override != XQC_TLS_NO_EARLY_DATA) {
+        return tls->early_data_accepted_override;
+    }
+
     /* client set no session ticket */
     if (tls->type == XQC_TLS_TYPE_CLIENT && !tls->resumption) {
         return XQC_TLS_NO_EARLY_DATA;
@@ -717,6 +726,13 @@ xqc_tls_is_early_data_accepted(xqc_tls_t *tls)
         ? XQC_TLS_EARLY_DATA_ACCEPT : XQC_TLS_EARLY_DATA_REJECT;
 }
 
+void
+xqc_tls_set_early_data_accepted(xqc_tls_t *tls,
+                                xqc_tls_early_data_accept_t accepted)
+{
+    tls->early_data_accepted_override = accepted;
+}
+
 xqc_bool_t
 xqc_tls_is_ready_to_send_early_data(xqc_tls_t *tls)
 {

src/tls/xqc_tls.h

@@ -175,6 +175,13 @@ xqc_bool_t xqc_tls_is_ready_to_send_early_data(xqc_tls_t *tls);
  */
 xqc_tls_early_data_accept_t xqc_tls_is_early_data_accepted(xqc_tls_t *tls);
 
+/**
+ * @brief override the early_data_accepted result (for testing without a real
+ *        TLS handshake).  set to XQC_TLS_NO_EARLY_DATA (0) to clear.
+ */
+void xqc_tls_set_early_data_accepted(xqc_tls_t *tls,
+                                     xqc_tls_early_data_accept_t accepted);
+
 /**
  * @brief get crypto aead tag length
  */

tests/unittest/main.c

@@ -83,6 +83,13 @@ main()
         || !CU_add_test(pSuite, "xqc_test_conn_tls_error_first_writer_wins", xqc_test_conn_tls_error_first_writer_wins)
         || !CU_add_test(pSuite, "xqc_test_conn_tls_error_cb_alert_zero", xqc_test_conn_tls_error_cb_alert_zero)
         || !CU_add_test(pSuite, "xqc_test_conn_tls_error_cb_max_alert", xqc_test_conn_tls_error_cb_max_alert)
+        /* issue #717: 0-RTT transport parameter validation (RFC 9000 Section 7.4.1) */
+        || !CU_add_test(pSuite, "xqc_test_0rtt_params_all_equal",
+                        xqc_test_0rtt_params_all_equal)
+        || !CU_add_test(pSuite, "xqc_test_0rtt_params_all_increased",
+                        xqc_test_0rtt_params_all_increased)
+        || !CU_add_test(pSuite, "xqc_test_0rtt_params_each_reduced",
+                        xqc_test_0rtt_params_each_reduced)
         || !CU_add_test(pSuite, "xqc_test_pq", xqc_test_pq)
         || !CU_add_test(pSuite, "xqc_test_common", xqc_test_common)
         || !CU_add_test(pSuite, "xqc_test_vint", xqc_test_vint)
@@ -221,13 +228,6 @@ main()
         || !CU_add_test(pSuite, "xqc_test_initial_salt_length", xqc_test_initial_salt_length)
         || !CU_add_test(pSuite, "xqc_test_initial_salt_v1_value", xqc_test_initial_salt_v1_value)
         || !CU_add_test(pSuite, "xqc_test_initial_salt_null_byte_regression", xqc_test_initial_salt_null_byte_regression)
-        /* issue #717: 0-RTT transport parameter validation (RFC 9000 Section 7.4.1) */
-        || !CU_add_test(pSuite, "xqc_test_0rtt_params_all_equal",
-                        xqc_test_0rtt_params_all_equal)
-        || !CU_add_test(pSuite, "xqc_test_0rtt_params_all_increased",
-                        xqc_test_0rtt_params_all_increased)
-        || !CU_add_test(pSuite, "xqc_test_0rtt_params_each_reduced",
-                        xqc_test_0rtt_params_each_reduced)
         /* ALPN negotiation tests (issue #709) */
         || !CU_add_test(pSuite, "xqc_test_alpn_error_code_value",
                         xqc_test_alpn_error_code_value)

tests/unittest/xqc_conn_test.c

@@ -18,6 +18,7 @@
 #include "src/transport/xqc_engine.h"
 #include "src/transport/xqc_transport_params.h"
 #include "src/transport/xqc_cid.h"
+#include "src/tls/xqc_tls.h"
 
 extern void xqc_conn_tls_error_cb(xqc_int_t tls_err, void *user_data);
 
@@ -403,6 +404,10 @@ xqc_0rtt_test_make_conn(xqc_cid_t *out_server_scid)
 
     /* mark the connection as having 0-RTT */
     conn->conn_flag |= XQC_CONN_FLAG_HAS_0RTT;
+    /* make xqc_tls_is_early_data_accepted() return ACCEPT without a real
+     * TLS handshake — mirrors the state a production client would have at
+     * tp_cb time when the server accepted early data. */
+    xqc_tls_set_early_data_accepted(conn->tls, XQC_TLS_EARLY_DATA_ACCEPT);
     /* clear any prior errors */
     conn->conn_err = 0;
     conn->conn_flag &= ~XQC_CONN_FLAG_ERROR;
@@ -625,7 +630,9 @@ xqc_test_0rtt_params_each_reduced(void)
 
         /* reduce exactly one field below remembered */
         uint64_t *field = (uint64_t *)((char *)&params + cases[i].tp_offset);
-        *field = cases[i].remembered_val - 1;
+        *field = cases[i].remembered_val <= 4
+                 ? cases[i].remembered_val - 1
+                 : cases[i].remembered_val / 2;
 
         xqc_int_t err = xqc_0rtt_test_fire(conn, &params);
         CU_ASSERT_EQUAL(err, TRA_0RTT_TRANS_PARAMS_ERROR);