thrift 0.23.0 → 0.25.0

data/ext/compact_protocol.c

@@ -62,9 +62,43 @@ static int CTYPE_MAP            = 0x0B;
 static int CTYPE_STRUCT         = 0x0C;
 static int CTYPE_UUID           = 0x0D;
 
-VALUE rb_thrift_compact_proto_write_i16(VALUE self, VALUE i16);
+static uint32_t int_to_zig_zag(int32_t n);
+static void write_varint32(VALUE transport, uint32_t n);
+
+static int64_t checked_integer_range(VALUE value, int64_t min, int64_t max) {
+  CHECK_NIL(value);
+  if (RB_UNLIKELY(!RB_INTEGER_TYPE_P(value))) {
+    rb_raise(rb_eTypeError, "integer argument expected");
+  }
+
+  int64_t integer = NUM2LL(value);
+  if (RB_UNLIKELY(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);
+}
 
-// TODO: implement this
 static int get_compact_type(VALUE type_value) {
   int type = FIX2INT(type_value);
   if (type == TTYPE_BOOL) {
@@ -92,10 +126,11 @@ static int get_compact_type(VALUE type_value) {
   } else if (type == TTYPE_UUID) {
     return CTYPE_UUID;
   } else {
-    char str[50];
-    sprintf(str, "don't know what type: %d", type);
-    rb_raise(rb_eStandardError, "%s", str);
-    return 0;
+    rb_exc_raise(get_protocol_exception(
+      INT2FIX(PROTOERR_INVALID_DATA),
+      rb_sprintf("Unknown compact type: %d", type)
+    ));
+    return 0; /* unreachable */
   }
 }
 
@@ -103,13 +138,11 @@ static void write_byte_direct(VALUE transport, int8_t b) {
   WRITE(transport, (char*)&b, 1);
 }
 
-static void write_field_begin_internal(VALUE self, VALUE type, VALUE id_value, VALUE type_override) {
-  int id = FIX2INT(id_value);
+static void write_field_begin_internal(VALUE self, VALUE type, int16_t id, int8_t type_override) {
+  int8_t type_to_write = type_override == 0 ? get_compact_type(type) : type_override;
   int last_id = LAST_ID(self);
   VALUE transport = GET_TRANSPORT(self);
 
-  // if there's a type override, use that.
-  int8_t type_to_write = RTEST(type_override) ? FIX2INT(type_override) : get_compact_type(type);
   // check if we can use delta encoding for the field id
   int diff = id - last_id;
   if (diff > 0 && diff <= 15) {
@@ -118,50 +151,61 @@ static void write_field_begin_internal(VALUE self, VALUE type, VALUE id_value, V
   } else {
     // write them separate
     write_byte_direct(transport, type_to_write & 0x0f);
-    rb_thrift_compact_proto_write_i16(self, id_value);
+    write_varint32(transport, int_to_zig_zag(id));
   }
 
-  SET_LAST_ID(self, id_value);
+  SET_LAST_ID(self, INT2FIX(id));
 }
 
-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);
-      break;
-    } else {
-      write_byte_direct(transport, (n & 0x7F) | 0x80);
-      n = n >> 7;
-    }
+  unsigned char bytes[5];
+  long length = 0;
+
+  while ((n & ~0x7FU) != 0U) {
+    bytes[length++] = (n & 0x7FU) | 0x80U;
+    n >>= 7;
   }
+  bytes[length++] = n;
+
+  WRITE(transport, (const char*)bytes, length);
 }
 
 static void write_varint64(VALUE transport, uint64_t n) {
-  while (true) {
-    if ((n & ~0x7F) == 0) {
-      write_byte_direct(transport, n & 0x7f);
-      break;
-    } else {
-      write_byte_direct(transport, (n & 0x7F) | 0x80);
-      n = n >> 7;
-    }
+  unsigned char bytes[10];
+  long length = 0;
+
+  while ((n & ~0x7FULL) != 0ULL) {
+    bytes[length++] = (n & 0x7FULL) | 0x80ULL;
+    n >>= 7;
   }
+  bytes[length++] = n;
+
+  WRITE(transport, (const char*)bytes, length);
 }
 
 static void write_collection_begin(VALUE transport, VALUE elem_type, VALUE size_value) {
-  int size = FIX2INT(size_value);
+  int size = checked_size_value(size_value);
+  int compact_type = get_compact_type(elem_type);
   if (size <= 14) {
-    write_byte_direct(transport, size << 4 | get_compact_type(elem_type));
+    write_byte_direct(transport, size << 4 | compact_type);
   } else {
-    write_byte_direct(transport, 0xf0 | get_compact_type(elem_type));
+    write_byte_direct(transport, 0xf0 | compact_type);
     write_varint32(transport, size);
   }
 }
@@ -208,20 +252,23 @@ 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);
+  uint32_t type_value = (uint32_t)FIX2INT(type);
+  int32_t seqid_value = checked_i32_value(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_byte_direct(transport, (VERSION & VERSION_MASK) | ((type_value << TYPE_SHIFT_AMOUNT) & TYPE_MASK));
+  write_varint32(transport, message_seqid_to_varint32(seqid_value));
   rb_thrift_compact_proto_write_string(self, name);
 
   return Qnil;
 }
 
 VALUE rb_thrift_compact_proto_write_field_begin(VALUE self, VALUE name, VALUE type, VALUE id) {
+  int16_t field_id = checked_i16_value(id);
   if (FIX2INT(type) == TTYPE_BOOL) {
     // we want to possibly include the value, so we'll wait.
-    rb_ivar_set(self, boolean_field_id, rb_ary_new3(2, type, id));
+    rb_ivar_set(self, boolean_field_id, rb_ary_new3(2, type, INT2FIX(field_id)));
   } else {
-    write_field_begin_internal(self, type, id, Qnil);
+    write_field_begin_internal(self, type, field_id, 0);
   }
 
   return Qnil;
@@ -233,7 +280,7 @@ VALUE rb_thrift_compact_proto_write_field_stop(VALUE self) {
 }
 
 VALUE rb_thrift_compact_proto_write_map_begin(VALUE self, VALUE ktype, VALUE vtype, VALUE size_value) {
-  int size = FIX2INT(size_value);
+  int size = checked_size_value(size_value);
   VALUE transport = GET_TRANSPORT(self);
   if (size == 0) {
     write_byte_direct(transport, 0);
@@ -255,39 +302,36 @@ VALUE rb_thrift_compact_proto_write_set_begin(VALUE self, VALUE etype, VALUE siz
 }
 
 VALUE rb_thrift_compact_proto_write_bool(VALUE self, VALUE b) {
-  int8_t type = b == Qtrue ? CTYPE_BOOLEAN_TRUE : CTYPE_BOOLEAN_FALSE;
+  int8_t type = RTEST(b) ? CTYPE_BOOLEAN_TRUE : CTYPE_BOOLEAN_FALSE;
   VALUE boolean_field = rb_ivar_get(self, boolean_field_id);
   if (NIL_P(boolean_field)) {
     // we're not part of a field, so just write the value.
     write_byte_direct(GET_TRANSPORT(self), type);
   } else {
     // we haven't written the field header yet
-    write_field_begin_internal(self, rb_ary_entry(boolean_field, 0), rb_ary_entry(boolean_field, 1), INT2FIX(type));
+    write_field_begin_internal(self, rb_ary_entry(boolean_field, 0), FIX2INT(rb_ary_entry(boolean_field, 1)), type);
     rb_ivar_set(self, boolean_field_id, Qnil);
   }
   return Qnil;
 }
 
 VALUE rb_thrift_compact_proto_write_byte(VALUE self, VALUE byte) {
-  CHECK_NIL(byte);
-  write_byte_direct(GET_TRANSPORT(self), FIX2INT(byte));
+  write_byte_direct(GET_TRANSPORT(self), checked_byte_value(byte));
   return Qnil;
 }
 
 VALUE rb_thrift_compact_proto_write_i16(VALUE self, VALUE i16) {
-  rb_thrift_compact_proto_write_i32(self, i16);
+  write_varint32(GET_TRANSPORT(self), int_to_zig_zag(checked_i16_value(i16)));
   return Qnil;
 }
 
 VALUE rb_thrift_compact_proto_write_i32(VALUE self, VALUE i32) {
-  CHECK_NIL(i32);
-  write_varint32(GET_TRANSPORT(self), int_to_zig_zag(NUM2INT(i32)));
+  write_varint32(GET_TRANSPORT(self), int_to_zig_zag(checked_i32_value(i32)));
   return Qnil;
 }
 
 VALUE rb_thrift_compact_proto_write_i64(VALUE self, VALUE i64) {
-  CHECK_NIL(i64);
-  write_varint64(GET_TRANSPORT(self), ll_to_zig_zag(NUM2LL(i64)));
+  write_varint64(GET_TRANSPORT(self), ll_to_zig_zag(checked_i64_value(i64)));
   return Qnil;
 }
 
@@ -321,8 +365,12 @@ VALUE rb_thrift_compact_proto_write_string(VALUE self, VALUE str) {
 VALUE rb_thrift_compact_proto_write_binary(VALUE self, VALUE buf) {
   buf = force_binary_encoding(buf);
   VALUE transport = GET_TRANSPORT(self);
-  write_varint32(transport, (uint32_t)RSTRING_LEN(buf));
-  WRITE(transport, StringValuePtr(buf), RSTRING_LEN(buf));
+  long size = RSTRING_LEN(buf);
+  if (RB_UNLIKELY(size > INT32_MAX)) {
+    rb_raise(rb_eRangeError, "integer out of bounds");
+  }
+  write_varint32(transport, (uint32_t)size);
+  WRITE(transport, StringValuePtr(buf), size);
   return Qnil;
 }
 
@@ -407,10 +455,20 @@ static int8_t get_ttype(int8_t ctype) {
   } else if (ctype == CTYPE_UUID) {
     return TTYPE_UUID;
   } else {
-    char str[50];
-    sprintf(str, "don't know what type: %d", ctype);
-    rb_raise(rb_eStandardError, "%s", str);
-    return 0;
+    rb_exc_raise(get_protocol_exception(
+      INT2FIX(PROTOERR_INVALID_DATA),
+      rb_sprintf("Unknown compact type: %d", ctype)
+    ));
+    return 0; /* unreachable */
+  }
+}
+
+static inline void validate_container_size(uint32_t size) {
+  if (RB_UNLIKELY(size > INT32_MAX)) {
+    rb_exc_raise(get_protocol_exception(
+      INT2FIX(PROTOERR_SIZE_LIMIT),
+      rb_str_new2("Container size limit exceeded")
+    ));
   }
 }
 
@@ -419,30 +477,57 @@ 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_VARINT32_LAST_BYTE 0x0f
+#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;
   }
-  return result;
+  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 - 1; i++) {
+    int8_t b = read_byte_direct(self);
+    result |= ((uint32_t)(b & 0x7f) << shift);
+    if ((b & 0x80) != 0x80) {
+      return result;
+    }
+    shift += 7;
+  }
+
+  int8_t b = read_byte_direct(self);
+  if (RB_UNLIKELY((b & 0x80) != 0)) {
+    rb_exc_raise(get_protocol_exception(INT2FIX(PROTOERR_INVALID_DATA), rb_str_new2("Variable-length int over 5 bytes.")));
+  }
+  if (RB_UNLIKELY((b & ~MAX_VARINT32_LAST_BYTE) != 0)) {
+    rb_exc_raise(get_protocol_exception(INT2FIX(PROTOERR_INVALID_DATA), rb_str_new2("Variable-length int overflows uint32.")));
+  }
+  return result | ((uint32_t)b << shift);
 }
 
 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) {
@@ -476,25 +561,27 @@ VALUE rb_thrift_compact_proto_read_set_end(VALUE self) {
 }
 
 VALUE rb_thrift_compact_proto_read_message_begin(VALUE self) {
+  if (RTEST(rb_ivar_get(self, reset_message_size_ivar_id))) {
+    rb_funcall(GET_TRANSPORT(self), reset_message_size_method_id, 0);
+  }
+
   int8_t protocol_id = read_byte_direct(self);
   if (protocol_id != PROTOCOL_ID) {
     char buf[100];
-    int len = sprintf(buf, "Expected protocol id %d but got %d", PROTOCOL_ID, protocol_id);
-    buf[len] = 0;
-    rb_exc_raise(get_protocol_exception(INT2FIX(-1), rb_str_new2(buf)));
+    snprintf(buf, sizeof(buf), "Expected protocol id %d but got %d", PROTOCOL_ID, protocol_id);
+    rb_exc_raise(get_protocol_exception(INT2FIX(PROTOERR_BAD_VERSION), rb_str_new2(buf)));
   }
 
   int8_t version_and_type = read_byte_direct(self);
   int8_t version = version_and_type & VERSION_MASK;
   if (version != VERSION) {
     char buf[100];
-    int len = sprintf(buf, "Expected version id %d but got %d", version, VERSION);
-    buf[len] = 0;
-    rb_exc_raise(get_protocol_exception(INT2FIX(-1), rb_str_new2(buf)));
+    snprintf(buf, sizeof(buf), "Expected version %d but got %d", VERSION, version);
+    rb_exc_raise(get_protocol_exception(INT2FIX(PROTOERR_BAD_VERSION), rb_str_new2(buf)));
   }
 
   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 +619,21 @@ 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);
+  validate_container_size(size);
   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);
   }
+  validate_container_size(size);
   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 +659,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) {
@@ -580,19 +669,19 @@ VALUE rb_thrift_compact_proto_read_i64(VALUE self) {
 VALUE rb_thrift_compact_proto_read_double(VALUE self) {
   union {
     double f;
-    int64_t l;
+    uint64_t l;
   } transfer;
   VALUE rbuf = rb_ivar_get(self, rbuf_ivar_id);
   rb_funcall(GET_TRANSPORT(self), read_into_buffer_method_id, 2, rbuf, INT2FIX(8));
-  uint32_t lo = ((uint8_t)(RSTRING_PTR(rbuf)[0]))
-    | (((uint8_t)(RSTRING_PTR(rbuf)[1])) << 8)
-    | (((uint8_t)(RSTRING_PTR(rbuf)[2])) << 16)
-    | (((uint8_t)(RSTRING_PTR(rbuf)[3])) << 24);
-  uint64_t hi = (((uint8_t)(RSTRING_PTR(rbuf)[4])))
-    | (((uint8_t)(RSTRING_PTR(rbuf)[5])) << 8)
-    | (((uint8_t)(RSTRING_PTR(rbuf)[6])) << 16)
-    | (((uint8_t)(RSTRING_PTR(rbuf)[7])) << 24);
-  transfer.l = (hi << 32) | lo;
+  const uint8_t* bytes = (const uint8_t*)RSTRING_PTR(rbuf);
+  transfer.l = (uint64_t)bytes[0]
+    | ((uint64_t)bytes[1] << 8)
+    | ((uint64_t)bytes[2] << 16)
+    | ((uint64_t)bytes[3] << 24)
+    | ((uint64_t)bytes[4] << 32)
+    | ((uint64_t)bytes[5] << 40)
+    | ((uint64_t)bytes[6] << 48)
+    | ((uint64_t)bytes[7] << 56);
 
   return rb_float_new(transfer.f);
 }
@@ -603,8 +692,12 @@ 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);
+  if (RB_UNLIKELY(size > INT32_MAX)) {
+    rb_exc_raise(get_protocol_exception(INT2FIX(PROTOERR_SIZE_LIMIT), rb_str_new2("Binary size limit exceeded")));
+  }
+  CHECK_STRING_SIZE(self, size);
+  return rb_funcall(GET_TRANSPORT(self), read_all_method_id, 1, UINT2NUM(size));
 }
 
 VALUE rb_thrift_compact_proto_read_uuid(VALUE self) {

data/ext/constants.h

@@ -77,14 +77,17 @@ extern ID skip_method_id;
 extern ID write_method_id;
 extern ID read_all_method_id;
 extern ID read_into_buffer_method_id;
+extern ID reset_message_size_method_id;
 extern ID force_binary_encoding_id;
 extern ID convert_to_utf8_byte_buffer_id;
 extern ID convert_to_string_id;
 
 extern ID fields_const_id;
 extern ID transport_ivar_id;
+extern ID reset_message_size_ivar_id;
 extern ID strict_read_ivar_id;
 extern ID strict_write_ivar_id;
+extern ID max_string_size_ivar_id;
 
 extern VALUE type_sym;
 extern VALUE name_sym;

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
@@ -17,13 +18,20 @@
 # under the License.
 #
 
-if defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /jruby/
-  File.open('Makefile', 'w'){ |f| f.puts "all:\n\ninstall:\n" }
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+  File.open("Makefile", "w") { |f| f.puts "all:\n\ninstall:\n" }
 else
-  require 'mkmf'
+  require "mkmf"
 
   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.
@@ -31,5 +39,5 @@ else
 
   have_func("strlcpy", "string.h")
 
-  create_makefile 'thrift_native'
+  create_makefile "thrift_native"
 end

data/ext/macros.h

@@ -24,6 +24,17 @@
 #define CHECK_NIL(obj) if (NIL_P(obj)) { rb_raise(rb_eStandardError, "nil argument not allowed!");}
 #define READ(obj, length) rb_funcall(GET_TRANSPORT(obj), read_all_method_id, 1, INT2FIX(length))
 
+// Refuse a declared string length over the protocol's @max_string_size (nil
+// means no limit) before it becomes a read size.
+#define CHECK_STRING_SIZE(obj, size) \
+  do { \
+    VALUE max_string_size_ = rb_ivar_get(obj, max_string_size_ivar_id); \
+    if (!NIL_P(max_string_size_) && RB_UNLIKELY((long long)(size) > NUM2LL(max_string_size_))) { \
+      rb_exc_raise(get_protocol_exception(INT2FIX(PROTOERR_SIZE_LIMIT), \
+        rb_sprintf("String size %lld larger than the maximum %lld", (long long)(size), NUM2LL(max_string_size_)))); \
+    } \
+  } while (0)
+
 #ifndef RFLOAT_VALUE
 #  define RFLOAT_VALUE(v) RFLOAT(rb_Float(v))->value
 #endif