Fix 32-bit Windows issues related to QUIC_ACKM / QUIC_CC

The re-occuring surprise is that in Win32, size_t is 32 bits...
Fixed by changing size_t to uint64_t in QUIC_CC

Reviewed-by: Hugo Landau <hlandau@openssl.org>
Reviewed-by: Tomas Mraz <tomas@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/19345)

diff --git a/include/internal/quic_cc.h b/include/internal/quic_cc.h
index 298d9c5890837eeb3d315b9a1c9a16636efa5625..2a702b0731364b7ce2fcad6ce3dd6d2f2e0cd745 100644 (file)
--- a/include/internal/quic_cc.h
+++ b/include/internal/quic_cc.h
@@ -72,14 +72,14 @@ typedef struct ossl_cc_method_st {
      * |time_valid| is 1 if the |time_since_last_send| holds
      * a meaningful value, 0 otherwise.
      */
-    size_t (*get_send_allowance)(OSSL_CC_DATA *ccdata,
-                                 OSSL_TIME time_since_last_send,
-                                 int time_valid);
+    uint64_t (*get_send_allowance)(OSSL_CC_DATA *ccdata,
+                                   OSSL_TIME time_since_last_send,
+                                   int time_valid);
 
     /*
      * Returns the maximum number of bytes allowed to be in flight.
      */
-    size_t (*get_bytes_in_flight_max)(OSSL_CC_DATA *ccdata);
+    uint64_t (*get_bytes_in_flight_max)(OSSL_CC_DATA *ccdata);
 
     /*
      * To be called when a packet with retransmittable data was sent.
@@ -88,7 +88,7 @@ typedef struct ossl_cc_method_st {
      * Returns 1 on success, 0 otherwise.
      */
     int (*on_data_sent)(OSSL_CC_DATA *ccdata,
-                        size_t num_retransmittable_bytes);
+                        uint64_t num_retransmittable_bytes);
 
     /*
      * To be called when retransmittable data was invalidated.
@@ -101,7 +101,7 @@ typedef struct ossl_cc_method_st {
      * otherwise.
      */
     int (*on_data_invalidated)(OSSL_CC_DATA *ccdata,
-                               size_t num_retransmittable_bytes);
+                               uint64_t num_retransmittable_bytes);
 
     /*
      * To be called when sent data was acked.
@@ -116,7 +116,7 @@ typedef struct ossl_cc_method_st {
     int (*on_data_acked)(OSSL_CC_DATA *ccdata,
                          OSSL_TIME time_now,
                          uint64_t last_pn_acked,
-                         size_t num_retransmittable_bytes);
+                         uint64_t num_retransmittable_bytes);
 
     /*
      * To be called when sent data is considered lost.
@@ -132,7 +132,7 @@ typedef struct ossl_cc_method_st {
     void (*on_data_lost)(OSSL_CC_DATA *ccdata,
                          uint64_t largest_pn_lost,
                          uint64_t largest_pn_sent,
-                         size_t num_retransmittable_bytes,
+                         uint64_t num_retransmittable_bytes,
                          int persistent_congestion);
 
     /*

diff --git a/ssl/quic/cc_dummy.c b/ssl/quic/cc_dummy.c
index a5f94d9498dbbeb7a319f5e78b6a57150fc373b3..feeb6cb015c59d9dec9880a9918d7ad7e7af66dc 100644 (file)
--- a/ssl/quic/cc_dummy.c
+++ b/ssl/quic/cc_dummy.c
@@ -44,32 +44,33 @@ static int dummy_can_send(OSSL_CC_DATA *cc)
     return 1;
 }
 
-static size_t dummy_get_send_allowance(OSSL_CC_DATA *cc,
+static uint64_t dummy_get_send_allowance(OSSL_CC_DATA *cc,
                                        OSSL_TIME time_since_last_send,
                                        int time_valid)
 {
     return SIZE_MAX;
 }
 
-static size_t dummy_get_bytes_in_flight_max(OSSL_CC_DATA *cc)
+static uint64_t dummy_get_bytes_in_flight_max(OSSL_CC_DATA *cc)
 {
     return SIZE_MAX;
 }
 
-static int dummy_on_data_sent(OSSL_CC_DATA *cc, size_t num_retransmittable_bytes)
+static int dummy_on_data_sent(OSSL_CC_DATA *cc,
+                              uint64_t num_retransmittable_bytes)
 {
     return 1;
 }
 
 static int dummy_on_data_invalidated(OSSL_CC_DATA *cc,
-                                     size_t num_retransmittable_bytes)
+                                     uint64_t num_retransmittable_bytes)
 {
     return 1;
 }
 
 static int dummy_on_data_acked(OSSL_CC_DATA *cc, OSSL_TIME time_now,
                                uint64_t last_pn_acked,
-                               size_t num_retransmittable_bytes)
+                               uint64_t num_retransmittable_bytes)
 {
     return 1;
 }
@@ -77,7 +78,7 @@ static int dummy_on_data_acked(OSSL_CC_DATA *cc, OSSL_TIME time_now,
 static void dummy_on_data_lost(OSSL_CC_DATA *cc,
                               uint64_t largest_pn_lost,
                               uint64_t largest_pn_sent,
-                              size_t num_retransmittable_bytes,
+                              uint64_t num_retransmittable_bytes,
                               int persistent_congestion)
 {
 

diff --git a/ssl/quic/quic_ackm.c b/ssl/quic/quic_ackm.c
index a73fb982f730c69f524358d8b596ca0f40734f7c..492bf2f1e4937a3bc9bcd9099615a1b3af06e64b 100644 (file)
--- a/ssl/quic/quic_ackm.c
+++ b/ssl/quic/quic_ackm.c
@@ -61,7 +61,8 @@ DEFINE_LHASH_OF_EX(OSSL_ACKM_TX_PKT);
 
 static unsigned long tx_pkt_info_hash(const OSSL_ACKM_TX_PKT *pkt)
 {
-    return pkt->pkt_num;
+    /* Using low bits of the packet number as the hash should be enough */
+    return (unsigned long)pkt->pkt_num;
 }
 
 static int tx_pkt_info_compare(const OSSL_ACKM_TX_PKT *a,
@@ -843,8 +844,9 @@ static OSSL_TIME ackm_get_pto_time_and_space(OSSL_ACKM *ackm, int *space)
                                       ossl_ticks2time(K_GRANULARITY)));
 
     duration
-        = ossl_time_multiply(duration, 1U << min_u32(ackm->pto_count,
-                                                     MAX_PTO_COUNT));
+        = ossl_time_multiply(duration,
+                             (uint64_t)1 << min_u32(ackm->pto_count,
+                                                    MAX_PTO_COUNT));
 
     /* Anti-deadlock PTO starts from the current time. */
     if (ackm_ack_eliciting_bytes_in_flight(ackm) == 0) {
@@ -866,12 +868,15 @@ static OSSL_TIME ackm_get_pto_time_and_space(OSSL_ACKM *ackm, int *space)
                 break;
 
             /* Include max_ack_delay and backoff for app data. */
-            if (!ossl_time_is_infinite(rtt.max_ack_delay))
+            if (!ossl_time_is_infinite(rtt.max_ack_delay)) {
+                uint64_t factor
+                    = (uint64_t)1 << min_u32(ackm->pto_count, MAX_PTO_COUNT);
+
                 duration
                     = ossl_time_add(duration,
                                     ossl_time_multiply(rtt.max_ack_delay,
-                                                       1U << min_u32(ackm->pto_count,
-                                                                     MAX_PTO_COUNT)));
+                                                       factor));
+            }
         }
 
         t = ossl_time_add(ackm->time_of_last_ack_eliciting_pkt[i], duration);

diff --git a/ssl/quic/quic_rx_depack.c b/ssl/quic/quic_rx_depack.c
index 404d5b883e441c6ca1e0f814751ef2215b46064d..42fb8ff34caf92b3e1edb200dfc1d7459287ee65 100644 (file)
--- a/ssl/quic/quic_rx_depack.c
+++ b/ssl/quic/quic_rx_depack.c
@@ -201,12 +201,14 @@ static int depack_do_frame_ack(PACKET *pkt, QUIC_CONNECTION *connection,
     int ok = 1;          /* Assume the best */
 
     if (!ossl_quic_wire_peek_frame_ack_num_ranges(pkt, &total_ranges)
+        /* In case sizeof(uint64_t) > sizeof(size_t) */
+        || total_ranges > SIZE_MAX / sizeof(ack_ranges[0])
         || (ack_ranges = OPENSSL_zalloc(sizeof(ack_ranges[0])
-                                        * total_ranges)) == NULL)
+                                        * (size_t)total_ranges)) == NULL)
         return 0;
 
     ack.ack_ranges = ack_ranges;
-    ack.num_ack_ranges = total_ranges;
+    ack.num_ack_ranges = (size_t)total_ranges;
 
     if (!ossl_quic_wire_decode_frame_ack(pkt, ack_delay_exp, &ack, NULL))
         ok = 0;

diff --git a/ssl/quic/quic_wire.c b/ssl/quic/quic_wire.c
index 2e7e785b7dc5c6ad9e41f6af0b56ea871474c559..291a1bb0d780342f56ce04309bc780231787cd05 100644 (file)
--- a/ssl/quic/quic_wire.c
+++ b/ssl/quic/quic_wire.c
@@ -47,7 +47,7 @@ int ossl_quic_wire_encode_frame_ack(WPACKET *pkt,
                                            : OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN;
 
     uint64_t largest_ackd, first_ack_range, ack_delay_enc;
-    size_t i, num_ack_ranges = ack->num_ack_ranges;
+    uint64_t i, num_ack_ranges = ack->num_ack_ranges;
     OSSL_TIME delay;
 
     if (num_ack_ranges == 0)
@@ -440,6 +440,9 @@ int ossl_quic_wire_decode_frame_ack(PACKET *pkt,
     if (first_ack_range > largest_ackd)
         return 0;
 
+    if (ack_range_count > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? */)
+        return 0;
+
     start = largest_ackd - first_ack_range;
 
     if (ack != NULL) {
@@ -476,7 +479,7 @@ int ossl_quic_wire_decode_frame_ack(PACKET *pkt,
     }
 
     if (ack != NULL && ack_range_count + 1 < ack->num_ack_ranges)
-        ack->num_ack_ranges = ack_range_count + 1;
+        ack->num_ack_ranges = (size_t)ack_range_count + 1;
 
     if (total_ranges != NULL)
         *total_ranges = ack_range_count + 1;