thrift 0.23.0 → 0.25.0

data/ext/memory_buffer.c

@@ -28,11 +28,15 @@ ID index_ivar_id;
 ID slice_method_id;
 
 int GARBAGE_BUFFER_SIZE;
+static VALUE transport_exception_class;
+static VALUE transport_negative_size;
+static ID new_method_id;
 
 #define GET_BUF(self) rb_ivar_get(self, buf_ivar_id)
 
 VALUE rb_thrift_memory_buffer_write(VALUE self, VALUE str);
 VALUE rb_thrift_memory_buffer_read(VALUE self, VALUE length_value);
+VALUE rb_thrift_memory_buffer_read_all(VALUE self, VALUE length_value);
 VALUE rb_thrift_memory_buffer_read_byte(VALUE self);
 VALUE rb_thrift_memory_buffer_read_into_buffer(VALUE self, VALUE buffer_value, VALUE size_value);
 
@@ -44,23 +48,28 @@ VALUE rb_thrift_memory_buffer_write(VALUE self, VALUE str) {
 }
 
 VALUE rb_thrift_memory_buffer_read(VALUE self, VALUE length_value) {
-  int length = FIX2INT(length_value);
+  long long length = NUM2LL(length_value);
+
+  if (RB_UNLIKELY(length < 0)) {
+    rb_exc_raise(rb_funcall(transport_exception_class, new_method_id, 2, transport_negative_size, rb_str_new2("Negative size")));
+  }
 
   VALUE index_value = rb_ivar_get(self, index_ivar_id);
-  int index = FIX2INT(index_value);
+  long index = NUM2LONG(index_value);
 
   VALUE buf = GET_BUF(self);
   VALUE data = rb_funcall(buf, slice_method_id, 2, index_value, length_value);
 
-  index += length;
-  if (index > RSTRING_LEN(buf)) {
-    index = (int)RSTRING_LEN(buf);
+  if (length > RSTRING_LEN(buf) - index) {
+    index = RSTRING_LEN(buf);
+  } else {
+    index += (long)length;
   }
   if (index >= GARBAGE_BUFFER_SIZE) {
-    rb_ivar_set(self, buf_ivar_id, rb_funcall(buf, slice_method_id, 2, INT2FIX(index), INT2FIX(RSTRING_LEN(buf) - 1)));
+    rb_ivar_set(self, buf_ivar_id, rb_funcall(buf, slice_method_id, 2, LONG2NUM(index), LONG2NUM(RSTRING_LEN(buf) - 1)));
     index = 0;
   }
-  rb_ivar_set(self, index_ivar_id, INT2FIX(index));
+  rb_ivar_set(self, index_ivar_id, LONG2NUM(index));
 
   if (RSTRING_LEN(data) < length) {
     rb_raise(rb_eEOFError, "Not enough bytes remain in memory buffer");
@@ -69,6 +78,33 @@ VALUE rb_thrift_memory_buffer_read(VALUE self, VALUE length_value) {
   return data;
 }
 
+VALUE rb_thrift_memory_buffer_read_all(VALUE self, VALUE length_value) {
+  long long length = NUM2LL(length_value);
+
+  if (RB_UNLIKELY(length < 0)) {
+    rb_exc_raise(rb_funcall(transport_exception_class, new_method_id, 2, transport_negative_size, rb_str_new2("Negative size")));
+  }
+
+  VALUE index_value = rb_ivar_get(self, index_ivar_id);
+  long index = NUM2LONG(index_value);
+  VALUE buf = GET_BUF(self);
+
+  if (RB_UNLIKELY(length > RSTRING_LEN(buf) - index)) {
+    rb_raise(rb_eEOFError, "Not enough bytes remain in memory buffer");
+  }
+
+  VALUE data = rb_str_subseq(buf, index, (long)length);
+
+  index += (long)length;
+  if (index >= GARBAGE_BUFFER_SIZE) {
+    rb_ivar_set(self, buf_ivar_id, rb_str_subseq(buf, index, RSTRING_LEN(buf) - index));
+    index = 0;
+  }
+  rb_ivar_set(self, index_ivar_id, LONG2NUM(index));
+
+  return data;
+}
+
 VALUE rb_thrift_memory_buffer_read_byte(VALUE self) {
   VALUE index_value = rb_ivar_get(self, index_ivar_id);
   int index = FIX2INT(index_value);
@@ -77,7 +113,7 @@ VALUE rb_thrift_memory_buffer_read_byte(VALUE self) {
   if (index >= RSTRING_LEN(buf)) {
     rb_raise(rb_eEOFError, "Not enough bytes remain in memory buffer");
   }
-  char byte = RSTRING_PTR(buf)[index++];
+  unsigned char byte = (unsigned char)RSTRING_PTR(buf)[index++];
 
   if (index >= GARBAGE_BUFFER_SIZE) {
     rb_ivar_set(self, buf_ivar_id, rb_funcall(buf, slice_method_id, 2, INT2FIX(index), INT2FIX(RSTRING_LEN(buf) - 1)));
@@ -85,8 +121,7 @@ VALUE rb_thrift_memory_buffer_read_byte(VALUE self) {
   }
   rb_ivar_set(self, index_ivar_id, INT2FIX(index));
 
-  int result = (int) byte;
-  return INT2FIX(result);
+  return INT2FIX(byte);
 }
 
 VALUE rb_thrift_memory_buffer_read_into_buffer(VALUE self, VALUE buffer_value, VALUE size_value) {
@@ -96,15 +131,29 @@ VALUE rb_thrift_memory_buffer_read_into_buffer(VALUE self, VALUE buffer_value, V
   VALUE buf = GET_BUF(self);
 
   index = FIX2INT(rb_ivar_get(self, index_ivar_id));
-  while (i < size) {
+  if (size > 0) {
     if (index >= RSTRING_LEN(buf)) {
+      rb_ivar_set(self, index_ivar_id, INT2FIX(index));
       rb_raise(rb_eEOFError, "Not enough bytes remain in memory buffer");
     }
-    char byte = RSTRING_PTR(buf)[index++];
+    StringValue(buffer_value);
+    if (RSTRING_LEN(buffer_value) == 0) {
+      rb_ivar_set(self, index_ivar_id, INT2FIX(index));
+      rb_raise(rb_eIndexError, "index 0 out of string");
+    }
+    rb_str_modify(buffer_value);
+  }
 
+  while (i < size) {
+    if (index >= RSTRING_LEN(buf)) {
+      rb_ivar_set(self, index_ivar_id, INT2FIX(index));
+      rb_raise(rb_eEOFError, "Not enough bytes remain in memory buffer");
+    }
     if (i >= RSTRING_LEN(buffer_value)) {
+      rb_ivar_set(self, index_ivar_id, INT2FIX(index));
       rb_raise(rb_eIndexError, "index %d out of string", i);
     }
+    char byte = RSTRING_PTR(buf)[index++];
     ((char*)RSTRING_PTR(buffer_value))[i] = byte;
     i++;
   }
@@ -122,6 +171,7 @@ void Init_memory_buffer(void) {
   VALUE thrift_memory_buffer_class = rb_const_get(thrift_module, rb_intern("MemoryBufferTransport"));
   rb_define_method(thrift_memory_buffer_class, "write", rb_thrift_memory_buffer_write, 1);
   rb_define_method(thrift_memory_buffer_class, "read", rb_thrift_memory_buffer_read, 1);
+  rb_define_method(thrift_memory_buffer_class, "read_all", rb_thrift_memory_buffer_read_all, 1);
   rb_define_method(thrift_memory_buffer_class, "read_byte", rb_thrift_memory_buffer_read_byte, 0);
   rb_define_method(thrift_memory_buffer_class, "read_into_buffer", rb_thrift_memory_buffer_read_into_buffer, 2);
 
@@ -129,6 +179,11 @@ void Init_memory_buffer(void) {
   index_ivar_id = rb_intern("@index");
 
   slice_method_id = rb_intern("slice");
+  new_method_id = rb_intern("new");
 
   GARBAGE_BUFFER_SIZE = FIX2INT(rb_const_get(thrift_memory_buffer_class, rb_intern("GARBAGE_BUFFER_SIZE")));
+  transport_exception_class = rb_const_get(thrift_module, rb_intern("TransportException"));
+  transport_negative_size = rb_const_get(transport_exception_class, rb_intern("NEGATIVE_SIZE"));
+  rb_global_variable(&transport_exception_class);
+  rb_global_variable(&transport_negative_size);
 }

data/ext/struct.c

@@ -17,6 +17,8 @@
  * under the License.
  */
 
+#include <stdint.h>
+
 #include "struct.h"
 #include "constants.h"
 #include "macros.h"
@@ -31,20 +33,63 @@ ID setvalue_id;
 ID to_s_method_id;
 ID name_to_id_method_id;
 static ID sorted_field_ids_method_id;
+static ID validate_container_size_method_id;
+static VALUE default_sym;
 
 #define IS_CONTAINER(ttype) ((ttype) == TTYPE_MAP || (ttype) == TTYPE_LIST || (ttype) == TTYPE_SET)
 #define STRUCT_FIELDS(obj) rb_const_get(CLASS_OF(obj), fields_const_id)
+// Default budget when callers do not provide a remaining depth.
+static int recursion_limit;
 
-static VALUE new_container_array(int size) {
-  if (size < 0) {
+static void validate_recursion_depth(int remaining_depth) {
+  if (RB_UNLIKELY(remaining_depth <= 0)) {
     rb_exc_raise(
       get_protocol_exception(
-        INT2FIX(PROTOERR_NEGATIVE_SIZE),
-        rb_str_new2("Negative container size")
+        INT2FIX(PROTOERR_DEPTH_LIMIT),
+        rb_str_new2("Maximum recursion depth exceeded")
       )
     );
   }
+}
+
+static int parse_recursive_args(int argc, const VALUE *argv, VALUE *protocol) {
+  if (RB_UNLIKELY(argc < 1 || argc > 2)) {
+    rb_error_arity(argc, 1, 2);
+  }
+
+  *protocol = argv[0];
+  int remaining_depth = argc == 1 ? recursion_limit : NUM2INT(argv[1]);
+  validate_recursion_depth(remaining_depth);
+  return remaining_depth;
+}
+
+static int container_size(VALUE protocol, VALUE size) {
+  if (RB_LIKELY(FIXNUM_P(size))) {
+    long value = FIX2LONG(size);
+    if (RB_UNLIKELY(value < 0)) {
+      rb_exc_raise(
+        get_protocol_exception(
+          INT2FIX(PROTOERR_NEGATIVE_SIZE),
+          rb_str_new2("Negative size")
+        )
+      );
+    }
+    if (RB_UNLIKELY((unsigned long)value > INT32_MAX)) {
+      rb_exc_raise(
+        get_protocol_exception(
+          INT2FIX(PROTOERR_SIZE_LIMIT),
+          rb_str_new2("Container size limit exceeded")
+        )
+      );
+    }
+    return (int)value;
+  }
+
+  rb_funcall(protocol, validate_container_size_method_id, 1, size);
+  return NUM2INT(size);
+}
 
+static VALUE new_container_array(int size) {
   return rb_ary_new2(size > 1024 ? 1024 : size);
 }
 
@@ -232,28 +277,28 @@ VALUE default_read_struct_end(VALUE protocol) {
 
 // end default protocol methods
 
-static VALUE rb_thrift_union_write (VALUE self, VALUE protocol);
-static VALUE rb_thrift_struct_write(VALUE self, VALUE protocol);
-static void write_anything(int ttype, VALUE value, VALUE protocol, VALUE field_info);
+static VALUE rb_thrift_struct_write_recursive(VALUE self, VALUE protocol, int remaining_depth);
+static VALUE rb_thrift_union_write_recursive(VALUE self, VALUE protocol, int remaining_depth);
+static void write_anything(int ttype, VALUE value, VALUE protocol, VALUE field_info, int remaining_depth);
 
-VALUE get_field_value(VALUE obj, VALUE field_name) {
+static inline ID field_ivar_id(VALUE field_name) {
   char name_buf[RSTRING_LEN(field_name) + 2];
 
   name_buf[0] = '@';
   strlcpy(&name_buf[1], RSTRING_PTR(field_name), RSTRING_LEN(field_name) + 1);
 
-  VALUE value = rb_ivar_get(obj, rb_intern(name_buf));
+  return rb_intern(name_buf);
+}
 
-  return value;
+VALUE get_field_value(VALUE obj, VALUE field_name) {
+  return rb_ivar_get(obj, field_ivar_id(field_name));
 }
 
-static void write_container(int ttype, VALUE field_info, VALUE value, VALUE protocol) {
+static void write_container(int ttype, VALUE field_info, VALUE value, VALUE protocol, int remaining_depth) {
   long sz, i;
 
   if (ttype == TTYPE_MAP) {
     VALUE keys;
-    VALUE key;
-    VALUE val;
 
     Check_Type(value, T_HASH);
 
@@ -272,19 +317,19 @@ static void write_container(int ttype, VALUE field_info, VALUE value, VALUE prot
     default_write_map_begin(protocol, keytype_value, valuetype_value, INT2FIX(sz));
 
     for (i = 0; i < sz; i++) {
-      key = rb_ary_entry(keys, i);
-      val = rb_hash_aref(value, key);
+      VALUE key = rb_ary_entry(keys, i);
+      VALUE val = rb_hash_aref(value, key);
 
       if (IS_CONTAINER(keytype)) {
-        write_container(keytype, key_info, key, protocol);
+        write_container(keytype, key_info, key, protocol, remaining_depth);
       } else {
-        write_anything(keytype, key, protocol, key_info);
+        write_anything(keytype, key, protocol, key_info, remaining_depth);
       }
 
       if (IS_CONTAINER(valuetype)) {
-        write_container(valuetype, value_info, val, protocol);
+        write_container(valuetype, value_info, val, protocol, remaining_depth);
       } else {
-        write_anything(valuetype, val, protocol, value_info);
+        write_anything(valuetype, val, protocol, value_info, remaining_depth);
       }
     }
 
@@ -302,9 +347,9 @@ static void write_container(int ttype, VALUE field_info, VALUE value, VALUE prot
     for (i = 0; i < sz; ++i) {
       VALUE val = rb_ary_entry(value, i);
       if (IS_CONTAINER(element_type)) {
-        write_container(element_type, element_type_info, val, protocol);
+        write_container(element_type, element_type_info, val, protocol, remaining_depth);
       } else {
-        write_anything(element_type, val, protocol, element_type_info);
+        write_anything(element_type, val, protocol, element_type_info, remaining_depth);
       }
     }
     default_write_list_end(protocol);
@@ -314,7 +359,7 @@ static void write_container(int ttype, VALUE field_info, VALUE value, VALUE prot
     if (TYPE(value) == T_ARRAY) {
       items = value;
     } else {
-      if (rb_cSet == CLASS_OF(value)) {
+      if (rb_obj_is_kind_of(value, rb_cSet)) {
         items = rb_funcall(value, entries_method_id, 0);
       } else {
         Check_Type(value, T_HASH);
@@ -333,9 +378,9 @@ static void write_container(int ttype, VALUE field_info, VALUE value, VALUE prot
     for (i = 0; i < sz; i++) {
       VALUE val = rb_ary_entry(items, i);
       if (IS_CONTAINER(element_type)) {
-        write_container(element_type, element_type_info, val, protocol);
+        write_container(element_type, element_type_info, val, protocol, remaining_depth);
       } else {
-        write_anything(element_type, val, protocol, element_type_info);
+        write_anything(element_type, val, protocol, element_type_info, remaining_depth);
       }
     }
 
@@ -345,7 +390,7 @@ static void write_container(int ttype, VALUE field_info, VALUE value, VALUE prot
   }
 }
 
-static void write_anything(int ttype, VALUE value, VALUE protocol, VALUE field_info) {
+static void write_anything(int ttype, VALUE value, VALUE protocol, VALUE field_info, int remaining_depth) {
   if (ttype == TTYPE_BOOL) {
     default_write_bool(protocol, value);
   } else if (ttype == TTYPE_BYTE) {
@@ -368,19 +413,21 @@ static void write_anything(int ttype, VALUE value, VALUE protocol, VALUE field_i
   } else if (ttype == TTYPE_UUID) {
     default_write_uuid(protocol, value);
   } else if (IS_CONTAINER(ttype)) {
-    write_container(ttype, field_info, value, protocol);
+    write_container(ttype, field_info, value, protocol, remaining_depth);
   } else if (ttype == TTYPE_STRUCT) {
+    remaining_depth--;
+    validate_recursion_depth(remaining_depth);
     if (rb_obj_is_kind_of(value, thrift_union_class)) {
-      rb_thrift_union_write(value, protocol);
+      rb_thrift_union_write_recursive(value, protocol, remaining_depth);
     } else {
-      rb_thrift_struct_write(value, protocol);
+      rb_thrift_struct_write_recursive(value, protocol, remaining_depth);
     }
   } else {
     rb_raise(rb_eNotImpError, "Unknown type for binary_encoding: %d", ttype);
   }
 }
 
-static VALUE rb_thrift_struct_write(VALUE self, VALUE protocol) {
+static VALUE rb_thrift_struct_write_recursive(VALUE self, VALUE protocol, int remaining_depth) {
   // call validate
   rb_funcall(self, validate_method_id, 0);
 
@@ -406,7 +453,7 @@ static VALUE rb_thrift_struct_write(VALUE self, VALUE protocol) {
     if (!NIL_P(field_value)) {
       default_write_field_begin(protocol, field_name, ttype_value, field_id);
 
-      write_anything(ttype, field_value, protocol, field_info);
+      write_anything(ttype, field_value, protocol, field_info, remaining_depth);
 
       default_write_field_end(protocol);
     }
@@ -420,22 +467,60 @@ static VALUE rb_thrift_struct_write(VALUE self, VALUE protocol) {
   return Qnil;
 }
 
+// cppcheck-suppress constParameterCallback
+static VALUE rb_thrift_struct_write(int argc, VALUE *argv, VALUE self) {
+  VALUE protocol;
+  int remaining_depth = parse_recursive_args(argc, argv, &protocol);
+  return rb_thrift_struct_write_recursive(self, protocol, remaining_depth);
+}
+
 //-------------------------------------------
 // Reading section
 //-------------------------------------------
 
-static VALUE rb_thrift_union_read(VALUE self, VALUE protocol);
-static VALUE rb_thrift_struct_read(VALUE self, VALUE protocol);
+static VALUE rb_thrift_union_read_recursive(VALUE self, VALUE protocol, int remaining_depth);
+static VALUE rb_thrift_struct_read_recursive(VALUE self, VALUE protocol, int remaining_depth);
 static void skip_map_contents(VALUE protocol, VALUE key_type_value, VALUE value_type_value, int size);
 static void skip_list_or_set_contents(VALUE protocol, VALUE element_type_value, int size);
 
-static void set_field_value(VALUE obj, VALUE field_name, VALUE value) {
-  char name_buf[RSTRING_LEN(field_name) + 2];
+static inline void set_field_value(VALUE obj, VALUE field_name, VALUE value) {
+  rb_ivar_set(obj, field_ivar_id(field_name), value);
+}
 
-  name_buf[0] = '@';
-  strlcpy(&name_buf[1], RSTRING_PTR(field_name), RSTRING_LEN(field_name)+1);
+/* Ruby's rescue and iteration APIs require addressable callback functions. */
+static VALUE duplicate_default_value(VALUE value) {
+  return rb_obj_dup(value);
+}
 
-  rb_ivar_set(obj, rb_intern(name_buf), value);
+static VALUE retain_default_value(VALUE value, VALUE exception) {
+  (void)exception;
+  return value;
+}
+
+static int reset_struct_field(VALUE field_id, VALUE field_info, VALUE self) {
+  (void)field_id;
+
+  VALUE field_name = rb_hash_aref(field_info, name_sym);
+  ID ivar_id = field_ivar_id(field_name);
+  VALUE default_value = rb_hash_aref(field_info, default_sym);
+
+  if (NIL_P(default_value)) {
+    if (!NIL_P(rb_ivar_get(self, ivar_id))) {
+      rb_ivar_set(self, ivar_id, Qnil);
+    }
+  } else {
+    VALUE value = rb_rescue2(
+      duplicate_default_value,
+      default_value,
+      retain_default_value,
+      default_value,
+      rb_eStandardError,
+      (VALUE)0
+    );
+    rb_ivar_set(self, ivar_id, value);
+  }
+
+  return ST_CONTINUE;
 }
 
 // Helper method to skip the contents of a map (assumes the map header has been read).
@@ -455,7 +540,7 @@ static void skip_list_or_set_contents(VALUE protocol, VALUE element_type_value,
   }
 }
 
-static VALUE read_anything(VALUE protocol, int ttype, VALUE field_info) {
+static VALUE read_anything(VALUE protocol, int ttype, VALUE field_info, int remaining_depth) {
   VALUE result = Qnil;
 
   if (ttype == TTYPE_BOOL) {
@@ -482,23 +567,19 @@ static VALUE read_anything(VALUE protocol, int ttype, VALUE field_info) {
   } else if (ttype == TTYPE_STRUCT) {
     VALUE klass = rb_hash_aref(field_info, class_sym);
     result = rb_class_new_instance(0, NULL, klass);
+    remaining_depth--;
+    validate_recursion_depth(remaining_depth);
 
     if (rb_obj_is_kind_of(result, thrift_union_class)) {
-      rb_thrift_union_read(result, protocol);
+      rb_thrift_union_read_recursive(result, protocol, remaining_depth);
     } else {
-      rb_thrift_struct_read(result, protocol);
+      rb_thrift_struct_read_recursive(result, protocol, remaining_depth);
     }
   } else if (ttype == TTYPE_MAP) {
-    int i;
-
     VALUE map_header = default_read_map_begin(protocol);
     int key_ttype = FIX2INT(rb_ary_entry(map_header, 0));
     int value_ttype = FIX2INT(rb_ary_entry(map_header, 1));
-    int num_entries = FIX2INT(rb_ary_entry(map_header, 2));
-
-    if (num_entries < 0) {
-      rb_exc_raise(get_protocol_exception(INT2FIX(PROTOERR_NEGATIVE_SIZE), rb_str_new2("Negative container size")));
-    }
+    int num_entries = container_size(protocol, rb_ary_entry(map_header, 2));
 
     // Check the declared key and value types against the expected ones and skip the map contents
     // if the types don't match.
@@ -511,11 +592,11 @@ static VALUE read_anything(VALUE protocol, int ttype, VALUE field_info) {
       if (num_entries == 0 || (specified_key_type == key_ttype && specified_value_type == value_ttype)) {
         result = rb_hash_new();
 
-        for (i = 0; i < num_entries; ++i) {
+        for (int i = 0; i < num_entries; ++i) {
           VALUE key, val;
 
-          key = read_anything(protocol, key_ttype, key_info);
-          val = read_anything(protocol, value_ttype, value_info);
+          key = read_anything(protocol, key_ttype, key_info, remaining_depth);
+          val = read_anything(protocol, value_ttype, value_info, remaining_depth);
 
           rb_hash_aset(result, key, val);
         }
@@ -528,11 +609,9 @@ static VALUE read_anything(VALUE protocol, int ttype, VALUE field_info) {
 
     default_read_map_end(protocol);
   } else if (ttype == TTYPE_LIST) {
-    int i;
-
     VALUE list_header = default_read_list_begin(protocol);
     int element_ttype = FIX2INT(rb_ary_entry(list_header, 0));
-    int num_elements = FIX2INT(rb_ary_entry(list_header, 1));
+    int num_elements = container_size(protocol, rb_ary_entry(list_header, 1));
 
     // Check the declared element type against the expected one and skip the list contents
     // if the types don't match.
@@ -542,8 +621,8 @@ static VALUE read_anything(VALUE protocol, int ttype, VALUE field_info) {
       if (specified_element_type == element_ttype) {
         result = new_container_array(num_elements);
 
-        for (i = 0; i < num_elements; ++i) {
-          rb_ary_push(result, read_anything(protocol, element_ttype, rb_hash_aref(field_info, element_sym)));
+        for (int i = 0; i < num_elements; ++i) {
+          rb_ary_push(result, read_anything(protocol, element_ttype, rb_hash_aref(field_info, element_sym), remaining_depth));
         }
       } else {
         skip_list_or_set_contents(protocol, INT2FIX(element_ttype), num_elements);
@@ -555,11 +634,10 @@ static VALUE read_anything(VALUE protocol, int ttype, VALUE field_info) {
     default_read_list_end(protocol);
   } else if (ttype == TTYPE_SET) {
     VALUE items;
-    int i;
 
     VALUE set_header = default_read_set_begin(protocol);
     int element_ttype = FIX2INT(rb_ary_entry(set_header, 0));
-    int num_elements = FIX2INT(rb_ary_entry(set_header, 1));
+    int num_elements = container_size(protocol, rb_ary_entry(set_header, 1));
 
     // Check the declared element type against the expected one and skip the set contents
     // if the types don't match.
@@ -569,8 +647,8 @@ static VALUE read_anything(VALUE protocol, int ttype, VALUE field_info) {
       if (specified_element_type == element_ttype) {
         items = new_container_array(num_elements);
 
-        for (i = 0; i < num_elements; ++i) {
-          rb_ary_push(items, read_anything(protocol, element_ttype, rb_hash_aref(field_info, element_sym)));
+        for (int i = 0; i < num_elements; ++i) {
+          rb_ary_push(items, read_anything(protocol, element_ttype, rb_hash_aref(field_info, element_sym), remaining_depth));
         }
 
         result = rb_class_new_instance(1, &items, rb_cSet);
@@ -589,12 +667,17 @@ static VALUE read_anything(VALUE protocol, int ttype, VALUE field_info) {
   return result;
 }
 
-static VALUE rb_thrift_struct_read(VALUE self, VALUE protocol) {
+static VALUE rb_thrift_struct_read_recursive(VALUE self, VALUE protocol, int remaining_depth) {
+  VALUE struct_fields = STRUCT_FIELDS(self);
+
+  if (RHASH_SIZE(struct_fields) > 0 && rb_ivar_count(self) > 0) {
+    rb_check_frozen(self);
+    rb_hash_foreach(struct_fields, reset_struct_field, self);
+  }
+
   // read struct begin
   default_read_struct_begin(protocol);
 
-  VALUE struct_fields = STRUCT_FIELDS(self);
-
   // read each field
   while (true) {
     VALUE field_header = default_read_field_begin(protocol);
@@ -613,7 +696,7 @@ static VALUE rb_thrift_struct_read(VALUE self, VALUE protocol) {
       if (field_type == specified_type) {
         // read the value
         VALUE name = rb_hash_aref(field_info, name_sym);
-        set_field_value(self, name, read_anything(protocol, field_type, field_info));
+        set_field_value(self, name, read_anything(protocol, field_type, field_info, remaining_depth));
       } else {
         rb_funcall(protocol, skip_method_id, 1, field_type_value);
       }
@@ -634,12 +717,28 @@ static VALUE rb_thrift_struct_read(VALUE self, VALUE protocol) {
   return Qnil;
 }
 
+// cppcheck-suppress constParameterCallback
+static VALUE rb_thrift_struct_read(int argc, VALUE *argv, VALUE self) {
+  VALUE protocol;
+  int remaining_depth = parse_recursive_args(argc, argv, &protocol);
+  return rb_thrift_struct_read_recursive(self, protocol, remaining_depth);
+}
+
 
 // --------------------------------
 // Union section
 // --------------------------------
 
-static VALUE rb_thrift_union_read(VALUE self, VALUE protocol) {
+static VALUE rb_thrift_union_read_recursive(VALUE self, VALUE protocol, int remaining_depth) {
+  rb_check_frozen(self);
+
+  if (!NIL_P(rb_ivar_get(self, setfield_id))) {
+    rb_ivar_set(self, setfield_id, Qnil);
+  }
+  if (!NIL_P(rb_ivar_get(self, setvalue_id))) {
+    rb_ivar_set(self, setvalue_id, Qnil);
+  }
+
   // read struct begin
   default_read_struct_begin(protocol);
 
@@ -657,8 +756,9 @@ static VALUE rb_thrift_union_read(VALUE self, VALUE protocol) {
     if (field_type == specified_type) {
       // read the value
       VALUE name = rb_hash_aref(field_info, name_sym);
+      VALUE value = read_anything(protocol, field_type, field_info, remaining_depth);
       rb_iv_set(self, "@setfield", rb_str_intern(name));
-      rb_iv_set(self, "@value", read_anything(protocol, field_type, field_info));
+      rb_iv_set(self, "@value", value);
     } else {
       rb_funcall(protocol, skip_method_id, 1, field_type_value);
     }
@@ -686,7 +786,14 @@ static VALUE rb_thrift_union_read(VALUE self, VALUE protocol) {
   return Qnil;
 }
 
-static VALUE rb_thrift_union_write(VALUE self, VALUE protocol) {
+// cppcheck-suppress constParameterCallback
+static VALUE rb_thrift_union_read(int argc, VALUE *argv, VALUE self) {
+  VALUE protocol;
+  int remaining_depth = parse_recursive_args(argc, argv, &protocol);
+  return rb_thrift_union_read_recursive(self, protocol, remaining_depth);
+}
+
+static VALUE rb_thrift_union_write_recursive(VALUE self, VALUE protocol, int remaining_depth) {
   // call validate
   rb_funcall(self, validate_method_id, 0);
 
@@ -710,7 +817,7 @@ static VALUE rb_thrift_union_write(VALUE self, VALUE protocol) {
 
   default_write_field_begin(protocol, setfield, ttype_value, field_id);
 
-  write_anything(ttype, setvalue, protocol, field_info);
+  write_anything(ttype, setvalue, protocol, field_info, remaining_depth);
 
   default_write_field_end(protocol);
 
@@ -722,17 +829,26 @@ static VALUE rb_thrift_union_write(VALUE self, VALUE protocol) {
   return Qnil;
 }
 
+// cppcheck-suppress constParameterCallback
+static VALUE rb_thrift_union_write(int argc, VALUE *argv, VALUE self) {
+  VALUE protocol;
+  int remaining_depth = parse_recursive_args(argc, argv, &protocol);
+  return rb_thrift_union_write_recursive(self, protocol, remaining_depth);
+}
+
 void Init_struct(void) {
   VALUE struct_module = rb_const_get(thrift_module, rb_intern("Struct"));
 
-  rb_define_method(struct_module, "write", rb_thrift_struct_write, 1);
-  rb_define_method(struct_module, "read", rb_thrift_struct_read, 1);
+  recursion_limit = FIX2INT(rb_const_get(thrift_module, rb_intern("DEFAULT_RECURSION_DEPTH")));
+
+  rb_define_method(struct_module, "write", rb_thrift_struct_write, -1);
+  rb_define_method(struct_module, "read", rb_thrift_struct_read, -1);
 
   thrift_union_class = rb_const_get(thrift_module, rb_intern("Union"));
   rb_global_variable(&thrift_union_class);
 
-  rb_define_method(thrift_union_class, "write", rb_thrift_union_write, 1);
-  rb_define_method(thrift_union_class, "read", rb_thrift_union_read, 1);
+  rb_define_method(thrift_union_class, "write", rb_thrift_union_write, -1);
+  rb_define_method(thrift_union_class, "read", rb_thrift_union_read, -1);
 
   setfield_id = rb_intern("@setfield");
   rb_global_variable(&setfield_id);
@@ -748,4 +864,9 @@ void Init_struct(void) {
 
   sorted_field_ids_method_id = rb_intern("sorted_field_ids");
   rb_global_variable(&sorted_field_ids_method_id);
+
+  validate_container_size_method_id = rb_intern("validate_container_size");
+
+  default_sym = ID2SYM(rb_intern("default"));
+  rb_global_variable(&default_sym);
 }