thrift 0.23.0 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97c9f50f4cf15be35eb546b5762d7625e3c2b3f8b97765217962409ba66acb99
-  data.tar.gz: 92ebb46420c41a9aaa1db0a78cbb7e513d43898c3064283a0b521d4037e63d22
+  metadata.gz: 90306a751b8d883922c4556778391d56c8c48fbf008187d3edfe411db4e9f6f7
+  data.tar.gz: 95287ba8714521389775a7d2ad265b3ad60a3ca44ada102abcf0c2ee152347cd
 SHA512:
-  metadata.gz: 4d5bcb6f79e7625989ff71e4693de7a0ba19babddb01c7727f4820343947af84ee0fef2a916d836c6a8343a4516670fae8af8f7a35bf8b3c94ab001000615baf
-  data.tar.gz: 6216728eb0196480044992e42c8896f82d6e84314aa530bcc438ee50fa636d690a8bd9196868312cc70263ac3e53f99887001cd3073577573baf63f95142f504
+  metadata.gz: d7e052575e5b7e581440a9073d2f4c6ce828b79963f7ce5c077f77e7c759b3589d5671a9e6f37ff4df996061af6b77362cc6248c7d22ac414156594b3fd77339
+  data.tar.gz: 35f5ee1d30099e5c70fa49d420153442e2b0b97587a908dea86ad1f9a2bbc44df5ff1baa3474cbc48f4064e20571eab7aa00c5fb155202f05edcd17579cbaddf

data/README.md

@@ -47,49 +47,55 @@ clients and services.
 The Ruby library does not include the Thrift compiler. Use a compiler built
 from the root of this repository to generate Ruby bindings:
 
-    thrift --gen rb path/to/service.thrift
-    # with namespaced modules
-    thrift --gen rb:namespaced --recurse path/to/service.thrift
+```bash
+thrift --gen rb path/to/service.thrift
+# with namespaced modules
+thrift --gen rb:namespaced --recurse path/to/service.thrift
+```
 
 Generated files are typically written to `gen-rb/` and can be required
 directly from your application.
 
 ## Basic Client Usage
 
-    $:.push File.expand_path('gen-rb', __dir__)
-    require 'thrift'
-    require 'calculator'
+```ruby
+$:.push File.expand_path('gen-rb', __dir__)
+require 'thrift'
+require 'calculator'
 
-    socket     = Thrift::Socket.new('localhost', 9090)
-    transport  = Thrift::BufferedTransport.new(socket)
-    protocol   = Thrift::BinaryProtocol.new(transport)
-    client     = Calculator::Client.new(protocol)
+socket     = Thrift::Socket.new('localhost', 9090)
+transport  = Thrift::BufferedTransport.new(socket)
+protocol   = Thrift::BinaryProtocol.new(transport)
+client     = Calculator::Client.new(protocol)
 
-    transport.open
-    puts client.add(1, 1)
-    transport.close
+transport.open
+puts client.add(1, 1)
+transport.close
+```
 
 ## Basic Server Usage
 
-    $:.push File.expand_path('gen-rb', __dir__)
-    require 'thrift'
-    require 'calculator'
+```ruby
+$:.push File.expand_path('gen-rb', __dir__)
+require 'thrift'
+require 'calculator'
 
-    class CalculatorHandler
-      def add(a, b)
-        a + b
-      end
-    end
+class CalculatorHandler
+  def add(a, b)
+    a + b
+  end
+end
 
-    handler            = CalculatorHandler.new
-    processor          = Calculator::Processor.new(handler)
-    server_transport   = Thrift::ServerSocket.new(9090)
-    transport_factory  = Thrift::BufferedTransportFactory.new
-    protocol_factory   = Thrift::BinaryProtocolFactory.new
+handler            = CalculatorHandler.new
+processor          = Calculator::Processor.new(handler)
+server_transport   = Thrift::ServerSocket.new(9090)
+transport_factory  = Thrift::BufferedTransportFactory.new
+protocol_factory   = Thrift::BinaryProtocolFactory.new
 
-    server = Thrift::ThreadedServer.new(processor, server_transport,
-                                        transport_factory, protocol_factory)
-    server.serve
+server = Thrift::ThreadedServer.new(processor, server_transport,
+                                    transport_factory, protocol_factory)
+server.serve
+```
 
 ## Development and Tests
 
@@ -111,6 +117,52 @@ directly from your application.
 
 ## Breaking Changes
 
+### 0.24.0
+
+Connect timeout handling changed for both `Thrift::Socket` and
+`Thrift::SSLSocket`.
+
+- `timeout == nil` and `timeout == 0` now use blocking connect/open semantics.
+  Older releases already treated `nil` that way, but treated `0` differently
+  across operations: `read` and `write` used the blocking path, plain TCP
+  `open` used a zero-length poll, and TLS `open` could spin in the handshake
+  retry loop.
+- Positive timeouts now bound the whole connect/open operation instead of
+  effectively applying a fresh timeout window at each wait or address attempt.
+  For plain TCP this budget is shared across address fallback. For TLS it is
+  shared across the TCP connect and the SSL handshake.
+- Connect/open timeout expiry now raises
+  `Thrift::TransportException::TIMED_OUT`. Older releases could report the same
+  condition as `NOT_OPEN`, and `Thrift::SSLSocket` could keep retrying the
+  handshake after the wait timed out.
+
+If your application matched `NOT_OPEN` for connect timeout handling, update it
+to handle `TIMED_OUT`. If you relied on `timeout = 0` meaning immediate failure
+or on repeated retries extending the effective timeout during TCP fallback or
+TLS handshake, update those call paths before upgrading.
+
+Ruby server socket transports now apply a 5-second timeout to accepted client
+sockets by default. This prevents stalled clients from blocking server threads
+indefinitely during response writes. Applications that intentionally require
+blocking accepted sockets can pass `client_timeout: nil` or `client_timeout: 0`
+when constructing `Thrift::ServerSocket`, `Thrift::SSLServerSocket`, or
+`Thrift::UNIXServerSocket`.
+
+Generated Ruby structs and unions now suffix field ID constants as
+`*_FIELD_ID` instead of exposing bare uppercased field names. For example,
+`MyStruct::FOO` becomes `MyStruct::FOO_FIELD_ID`. This avoids collisions with
+the generated `FIELDS` metadata hash for field names such as `fields`, but it
+is a source-compatible break if your application referenced the old constants
+directly. Regenerate Ruby code and update those constant references atomically.
+
+Ruby binary protocol writers now enforce signed Thrift integer ranges before
+serializing values. `byte`, `i16`, `i32`, and `i64` writes reject values outside
+their declared signed ranges, and binary/string/container sizes must fit in a
+non-negative signed `i32` length. Older releases could silently wrap or clip
+some out-of-range values, such as writing `255` as a byte that read back as
+`-1`. This applies to both `Thrift::BinaryProtocol` and
+`Thrift::BinaryProtocolAccelerated`.
+
 ### 0.23.0
 
 The documented source-build flow now effectively requires Ruby `2.7+`.
@@ -157,14 +209,22 @@ best-effort, not guaranteed.
   `thrift --gen rb` and namespaced output from `thrift --gen rb:namespaced`
   use different require paths, so switch them atomically with regenerated code.
 
-      # --gen rb
-      require 'calculator'
+  ```ruby
+  # --gen rb
+  require 'calculator'
 
-      # --gen rb:namespaced
-      require 'my_namespace/calculator'
+  # --gen rb:namespaced
+  require 'my_namespace/calculator'
+  ```
 
 ## Migration Notes
 
+- If you upgrade to `0.24.0`, treat `timeout` on `Thrift::Socket` and
+  `Thrift::SSLSocket` as one budget for the whole open path. For
+  `Thrift::SSLSocket`, that includes both the TCP connect and the TLS
+  handshake.
+- If you upgrade to `0.24.0`, handle connect/open timeout expiry as
+  `Thrift::TransportException::TIMED_OUT` instead of `NOT_OPEN`.
 - If you upgrade across the stricter reply-validation changes, regenerate all
   Ruby stubs and deploy them with the matching Ruby runtime. Do not mix old
   generated code, new generated code, and new runtime code on the same client

data/benchmark/benchmark.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -116,7 +117,7 @@ class BenchmarkManager
   def collect_output
     puts "Collecting output..."
     # read from @pool until all sockets are closed
-    @buffers = Hash.new { |h, k| h[k] = '' }
+    @buffers = Hash.new { |h, k| h[k] = ''.b }
     until @pool.empty?
       rd, = select(@pool)
       next if rd.nil?

data/benchmark/client.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file

data/benchmark/server.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file

data/benchmark/thin_server.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file

data/ext/binary_protocol_accelerated.c

@@ -31,13 +31,59 @@ VALUE rb_thrift_binary_proto_native_qmark(VALUE self) {
   return Qtrue;
 }
 
-
-
 static int VERSION_1;
 static int VERSION_MASK;
 static int TYPE_MASK;
 static ID rbuf_ivar_id;
 
+static int64_t checked_integer_value(VALUE value) {
+  if (!RB_INTEGER_TYPE_P(value)) {
+    rb_raise(rb_eTypeError, "integer argument expected");
+  }
+
+  return NUM2LL(value);
+}
+
+static int64_t checked_integer_range(VALUE value, int64_t min, int64_t max) {
+  int64_t integer = checked_integer_value(value);
+
+  if (integer < min || integer > max) {
+    rb_raise(rb_eRangeError, "integer out of bounds");
+  }
+
+  return integer;
+}
+
+static int8_t checked_byte_value(VALUE value) {
+  return (int8_t)checked_integer_range(value, INT8_MIN, INT8_MAX);
+}
+
+static int16_t checked_i16_value(VALUE value) {
+  return (int16_t)checked_integer_range(value, INT16_MIN, INT16_MAX);
+}
+
+static int32_t checked_i32_value(VALUE value) {
+  return (int32_t)checked_integer_range(value, INT32_MIN, INT32_MAX);
+}
+
+static int32_t checked_size_value(VALUE value) {
+  return (int32_t)checked_integer_range(value, 0, INT32_MAX);
+}
+
+static int64_t checked_i64_value(VALUE value) {
+  return checked_integer_range(value, INT64_MIN, INT64_MAX);
+}
+
+static int32_t checked_string_length(VALUE str) {
+  long length = RSTRING_LEN(str);
+
+  if (length > INT32_MAX) {
+    rb_raise(rb_eRangeError, "string too long");
+  }
+
+  return (int32_t)length;
+}
+
 static void write_byte_direct(VALUE trans, int8_t b) {
   WRITE(trans, (char*)&b, 1);
 }
@@ -83,7 +129,7 @@ static void write_string_direct(VALUE trans, VALUE str) {
     rb_raise(rb_eStandardError, "Value should be a string");
   }
   str = convert_to_utf8_byte_buffer(str);
-  write_i32_direct(trans, (int32_t)RSTRING_LEN(str));
+  write_i32_direct(trans, checked_string_length(str));
   rb_funcall(trans, write_method_id, 1, str);
 }
 
@@ -124,13 +170,14 @@ VALUE rb_thrift_binary_proto_write_message_begin(VALUE self, VALUE name, VALUE t
   VALUE strict_write = GET_STRICT_WRITE(self);
 
   if (strict_write == Qtrue) {
-    write_i32_direct(trans, VERSION_1 | FIX2INT(type));
+    int8_t message_type = checked_byte_value(type);
+    write_i32_direct(trans, VERSION_1 | message_type);
     write_string_direct(trans, name);
-    write_i32_direct(trans, FIX2INT(seqid));
+    write_i32_direct(trans, checked_i32_value(seqid));
   } else {
     write_string_direct(trans, name);
-    write_byte_direct(trans, FIX2INT(type));
-    write_i32_direct(trans, FIX2INT(seqid));
+    write_byte_direct(trans, checked_byte_value(type));
+    write_i32_direct(trans, checked_i32_value(seqid));
   }
 
   return Qnil;
@@ -138,8 +185,8 @@ VALUE rb_thrift_binary_proto_write_message_begin(VALUE self, VALUE name, VALUE t
 
 VALUE rb_thrift_binary_proto_write_field_begin(VALUE self, VALUE name, VALUE type, VALUE id) {
   VALUE trans = GET_TRANSPORT(self);
-  write_byte_direct(trans, FIX2INT(type));
-  write_i16_direct(trans, FIX2INT(id));
+  write_byte_direct(trans, checked_byte_value(type));
+  write_i16_direct(trans, checked_i16_value(id));
 
   return Qnil;
 }
@@ -151,17 +198,17 @@ VALUE rb_thrift_binary_proto_write_field_stop(VALUE self) {
 
 VALUE rb_thrift_binary_proto_write_map_begin(VALUE self, VALUE ktype, VALUE vtype, VALUE size) {
   VALUE trans = GET_TRANSPORT(self);
-  write_byte_direct(trans, FIX2INT(ktype));
-  write_byte_direct(trans, FIX2INT(vtype));
-  write_i32_direct(trans, FIX2INT(size));
+  write_byte_direct(trans, checked_byte_value(ktype));
+  write_byte_direct(trans, checked_byte_value(vtype));
+  write_i32_direct(trans, checked_size_value(size));
 
   return Qnil;
 }
 
 VALUE rb_thrift_binary_proto_write_list_begin(VALUE self, VALUE etype, VALUE size) {
   VALUE trans = GET_TRANSPORT(self);
-  write_byte_direct(trans, FIX2INT(etype));
-  write_i32_direct(trans, FIX2INT(size));
+  write_byte_direct(trans, checked_byte_value(etype));
+  write_i32_direct(trans, checked_size_value(size));
 
   return Qnil;
 }
@@ -178,25 +225,25 @@ VALUE rb_thrift_binary_proto_write_bool(VALUE self, VALUE b) {
 
 VALUE rb_thrift_binary_proto_write_byte(VALUE self, VALUE byte) {
   CHECK_NIL(byte);
-  write_byte_direct(GET_TRANSPORT(self), NUM2INT(byte));
+  write_byte_direct(GET_TRANSPORT(self), checked_byte_value(byte));
   return Qnil;
 }
 
 VALUE rb_thrift_binary_proto_write_i16(VALUE self, VALUE i16) {
   CHECK_NIL(i16);
-  write_i16_direct(GET_TRANSPORT(self), FIX2INT(i16));
+  write_i16_direct(GET_TRANSPORT(self), checked_i16_value(i16));
   return Qnil;
 }
 
 VALUE rb_thrift_binary_proto_write_i32(VALUE self, VALUE i32) {
   CHECK_NIL(i32);
-  write_i32_direct(GET_TRANSPORT(self), NUM2INT(i32));
+  write_i32_direct(GET_TRANSPORT(self), checked_i32_value(i32));
   return Qnil;
 }
 
 VALUE rb_thrift_binary_proto_write_i64(VALUE self, VALUE i64) {
   CHECK_NIL(i64);
-  write_i64_direct(GET_TRANSPORT(self), NUM2LL(i64));
+  write_i64_direct(GET_TRANSPORT(self), checked_i64_value(i64));
   return Qnil;
 }
 
@@ -224,7 +271,7 @@ VALUE rb_thrift_binary_proto_write_binary(VALUE self, VALUE buf) {
   CHECK_NIL(buf);
   VALUE trans = GET_TRANSPORT(self);
   buf = force_binary_encoding(buf);
-  write_i32_direct(trans, (int32_t)RSTRING_LEN(buf));
+  write_i32_direct(trans, checked_string_length(buf));
   rb_funcall(trans, write_method_id, 1, buf);
   return Qnil;
 }
@@ -377,17 +424,24 @@ VALUE rb_thrift_binary_proto_read_field_begin(VALUE self) {
   }
 }
 
+#define CHECK_NEGATIVE_SIZE(size) \
+  if (RB_UNLIKELY((size) < 0)) { \
+    rb_exc_raise(get_protocol_exception(INT2FIX(PROTOERR_NEGATIVE_SIZE), rb_str_new2("Negative size"))); \
+  }
+
 VALUE rb_thrift_binary_proto_read_map_begin(VALUE self) {
   VALUE ktype = rb_thrift_binary_proto_read_byte(self);
   VALUE vtype = rb_thrift_binary_proto_read_byte(self);
-  VALUE size = rb_thrift_binary_proto_read_i32(self);
-  return rb_ary_new3(3, ktype, vtype, size);
+  int size = read_i32_direct(self);
+  CHECK_NEGATIVE_SIZE(size);
+  return rb_ary_new3(3, ktype, vtype, INT2NUM(size));
 }
 
 VALUE rb_thrift_binary_proto_read_list_begin(VALUE self) {
   VALUE etype = rb_thrift_binary_proto_read_byte(self);
-  VALUE size = rb_thrift_binary_proto_read_i32(self);
-  return rb_ary_new3(2, etype, size);
+  int size = read_i32_direct(self);
+  CHECK_NEGATIVE_SIZE(size);
+  return rb_ary_new3(2, etype, INT2NUM(size));
 }
 
 VALUE rb_thrift_binary_proto_read_set_begin(VALUE self) {
@@ -431,6 +485,7 @@ VALUE rb_thrift_binary_proto_read_string(VALUE self) {
 
 VALUE rb_thrift_binary_proto_read_binary(VALUE self) {
   int size = read_i32_direct(self);
+  CHECK_NEGATIVE_SIZE(size);
   return READ(self, size);
 }
 

data/ext/bytes.c

@@ -24,6 +24,20 @@
 #include <constants.h>
 
 VALUE force_binary_encoding(VALUE buffer) {
+  if (RB_TYPE_P(buffer, T_STRING)) {
+    if (rb_enc_get_index(buffer) == rb_ascii8bit_encindex()) {
+      return buffer;
+    }
+
+    if (RB_OBJ_FROZEN(buffer)) {
+      buffer = rb_obj_dup(buffer);
+    }
+
+    rb_enc_associate_index(buffer, rb_ascii8bit_encindex());
+
+    return buffer;
+  }
+
   return rb_funcall(thrift_bytes_module, force_binary_encoding_id, 1, buffer);
 }
 

data/ext/compact_protocol.c

@@ -124,21 +124,29 @@ static void write_field_begin_internal(VALUE self, VALUE type, VALUE id_value, V
   SET_LAST_ID(self, id_value);
 }
 
-static int32_t int_to_zig_zag(int32_t n) {
-  return (n << 1) ^ (n >> 31);
+static uint32_t int_to_zig_zag(int32_t n) {
+  return (((uint32_t)n) << 1) ^ (0U - (uint32_t)(n < 0));
 }
 
 static uint64_t ll_to_zig_zag(int64_t n) {
-  return (n << 1) ^ (n >> 63);
+  return (((uint64_t)n) << 1) ^ (0ULL - (uint64_t)(n < 0));
+}
+
+static uint32_t message_seqid_to_varint32(int32_t seqid) {
+  return seqid < 0 ? (uint32_t)((int64_t)seqid + (INT64_C(1) << 32)) : (uint32_t)seqid;
+}
+
+static int32_t message_seqid_from_varint32(uint32_t seqid) {
+  return seqid > INT32_MAX ? (int32_t)((int64_t)seqid - (INT64_C(1) << 32)) : (int32_t)seqid;
 }
 
 static void write_varint32(VALUE transport, uint32_t n) {
   while (true) {
-    if ((n & ~0x7F) == 0) {
-      write_byte_direct(transport, n & 0x7f);
+    if ((n & ~0x7FU) == 0U) {
+      write_byte_direct(transport, n & 0x7FU);
       break;
     } else {
-      write_byte_direct(transport, (n & 0x7F) | 0x80);
+      write_byte_direct(transport, (n & 0x7FU) | 0x80U);
       n = n >> 7;
     }
   }
@@ -146,11 +154,11 @@ static void write_varint32(VALUE transport, uint32_t n) {
 
 static void write_varint64(VALUE transport, uint64_t n) {
   while (true) {
-    if ((n & ~0x7F) == 0) {
-      write_byte_direct(transport, n & 0x7f);
+    if ((n & ~0x7FULL) == 0ULL) {
+      write_byte_direct(transport, n & 0x7FULL);
       break;
     } else {
-      write_byte_direct(transport, (n & 0x7F) | 0x80);
+      write_byte_direct(transport, (n & 0x7FULL) | 0x80ULL);
       n = n >> 7;
     }
   }
@@ -208,9 +216,10 @@ VALUE rb_thrift_compact_proto_write_set_end(VALUE self) {
 
 VALUE rb_thrift_compact_proto_write_message_begin(VALUE self, VALUE name, VALUE type, VALUE seqid) {
   VALUE transport = GET_TRANSPORT(self);
+  int32_t seqid_value = FIX2INT(seqid);
   write_byte_direct(transport, PROTOCOL_ID);
   write_byte_direct(transport, (VERSION & VERSION_MASK) | ((FIX2INT(type) << TYPE_SHIFT_AMOUNT) & TYPE_MASK));
-  write_varint32(transport, FIX2INT(seqid));
+  write_varint32(transport, message_seqid_to_varint32(seqid_value));
   rb_thrift_compact_proto_write_string(self, name);
 
   return Qnil;
@@ -419,30 +428,49 @@ static char read_byte_direct(VALUE self) {
   return (char)(FIX2INT(byte));
 }
 
-static int64_t zig_zag_to_ll(int64_t n) {
-  return (((uint64_t)n) >> 1) ^ -(n & 1);
+static int64_t zig_zag_to_ll(uint64_t n) {
+  return (int64_t)((n >> 1) ^ (0ULL - (n & 1ULL)));
 }
 
-static int32_t zig_zag_to_int(int32_t n) {
-  return (((uint32_t)n) >> 1) ^ -(n & 1);
+static int32_t zig_zag_to_int(uint32_t n) {
+  return (int32_t)((n >> 1) ^ (0U - (n & 1U)));
 }
 
-static int64_t read_varint64(VALUE self) {
-  int shift = 0;
-  int64_t result = 0;
-  while (true) {
+#define MAX_VARINT32_BYTES 5  /* ceil(32/7); matches protobuf wire format */
+#define MAX_VARINT64_BYTES 10 /* ceil(64/7); matches protobuf wire format */
+
+static uint64_t read_varint64(VALUE self) {
+  int i, shift = 0;
+  uint64_t result = 0;
+  for (i = 0; i < MAX_VARINT64_BYTES; i++) {
     int8_t b = read_byte_direct(self);
-    result = result | ((uint64_t)(b & 0x7f) << shift);
+    result |= ((uint64_t)(b & 0x7f) << shift);
     if ((b & 0x80) != 0x80) {
-      break;
+      return result;
+    }
+    shift += 7;
+  }
+  rb_exc_raise(get_protocol_exception(INT2FIX(PROTOERR_INVALID_DATA), rb_str_new2("Variable-length int over 10 bytes.")));
+  return 0; /* unreachable */
+}
+
+static uint32_t read_varint32(VALUE self) {
+  int i, shift = 0;
+  uint32_t result = 0;
+  for (i = 0; i < MAX_VARINT32_BYTES; i++) {
+    int8_t b = read_byte_direct(self);
+    result |= ((uint32_t)(b & 0x7f) << shift);
+    if ((b & 0x80) != 0x80) {
+      return result;
     }
     shift += 7;
   }
-  return result;
+  rb_exc_raise(get_protocol_exception(INT2FIX(PROTOERR_INVALID_DATA), rb_str_new2("Variable-length int over 5 bytes.")));
+  return 0; /* unreachable */
 }
 
 static int16_t read_i16(VALUE self) {
-  return zig_zag_to_int((int32_t)read_varint64(self));
+  return (int16_t)zig_zag_to_int(read_varint32(self));
 }
 
 VALUE rb_thrift_compact_proto_read_message_end(VALUE self) {
@@ -494,7 +522,7 @@ VALUE rb_thrift_compact_proto_read_message_begin(VALUE self) {
   }
 
   int8_t type = (version_and_type >> TYPE_SHIFT_AMOUNT) & TYPE_BITS;
-  int32_t seqid = (int32_t)read_varint64(self);
+  int32_t seqid = message_seqid_from_varint32(read_varint32(self));
   VALUE messageName = rb_thrift_compact_proto_read_string(self);
   return rb_ary_new3(3, messageName, INT2FIX(type), INT2NUM(seqid));
 }
@@ -532,19 +560,19 @@ VALUE rb_thrift_compact_proto_read_field_begin(VALUE self) {
 }
 
 VALUE rb_thrift_compact_proto_read_map_begin(VALUE self) {
-  int32_t size = (int32_t)read_varint64(self);
+  uint32_t size = read_varint32(self);
   uint8_t key_and_value_type = size == 0 ? 0 : read_byte_direct(self);
-  return rb_ary_new3(3, INT2FIX(get_ttype(key_and_value_type >> 4)), INT2FIX(get_ttype(key_and_value_type & 0xf)), INT2FIX(size));
+  return rb_ary_new3(3, INT2FIX(get_ttype(key_and_value_type >> 4)), INT2FIX(get_ttype(key_and_value_type & 0xf)), UINT2NUM(size));
 }
 
 VALUE rb_thrift_compact_proto_read_list_begin(VALUE self) {
   uint8_t size_and_type = read_byte_direct(self);
-  int32_t size = (size_and_type >> 4) & 0x0f;
+  uint32_t size = (size_and_type >> 4) & 0x0f;
   if (size == 15) {
-    size = (int32_t)read_varint64(self);
+    size = read_varint32(self);
   }
   uint8_t type = get_ttype(size_and_type & 0x0f);
-  return rb_ary_new3(2, INT2FIX(type), INT2FIX(size));
+  return rb_ary_new3(2, INT2FIX(type), UINT2NUM(size));
 }
 
 VALUE rb_thrift_compact_proto_read_set_begin(VALUE self) {
@@ -570,7 +598,7 @@ VALUE rb_thrift_compact_proto_read_i16(VALUE self) {
 }
 
 VALUE rb_thrift_compact_proto_read_i32(VALUE self) {
-  return INT2NUM(zig_zag_to_int((int32_t)read_varint64(self)));
+  return INT2NUM(zig_zag_to_int(read_varint32(self)));
 }
 
 VALUE rb_thrift_compact_proto_read_i64(VALUE self) {
@@ -603,8 +631,8 @@ VALUE rb_thrift_compact_proto_read_string(VALUE self) {
 }
 
 VALUE rb_thrift_compact_proto_read_binary(VALUE self) {
-  int64_t size = read_varint64(self);
-  return READ(self, size);
+  uint32_t size = read_varint32(self);
+  return rb_funcall(GET_TRANSPORT(self), read_all_method_id, 1, UINT2NUM(size));
 }
 
 VALUE rb_thrift_compact_proto_read_uuid(VALUE self) {

data/ext/extconf.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -24,6 +25,13 @@ else
 
   append_cflags(["-fsigned-char", "-g", "-O2", "-Wall", "-Werror", "-Werror=old-style-definition"])
 
+  # clang 21+ introduced -Wdefault-const-init-field-unsafe, which fires on
+  # Ruby 3.2's rstring.h (struct RString has a const field via RBasic).
+  # This is a Ruby header issue, not a Thrift bug, so suppress the warning here.
+  # append_cflags silently ignores flags unsupported by the compiler, so this
+  # is safe across all clang versions.
+  append_cflags("-Wno-default-const-init-field-unsafe")
+
   # Makes all symbols private by default to avoid unintended conflict
   # with other gems. To explicitly export symbols you can use RUBY_FUNC_EXPORTED
   # selectively, or entirely remove this flag.