google-protobuf 4.35.0-x86-linux-gnu → 4.36.0.rc.1-x86-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 227a2322972654ab579639baee0613dec9f89d7a4a735b24dc848087b119e4fb
-  data.tar.gz: 21b7520c6af66a9b5a8ca78753709f34160170b15be3a0aa6a49355d4d8c8c16
+  metadata.gz: ff373548768164b1f5cfbe51a196bd2aafb651567471e6c1ee6529c7e61334b2
+  data.tar.gz: 5bc8e04c22b480a602fd9a55af4e63b5ec71a21b642ea1cceb1900c5f77fd558
 SHA512:
-  metadata.gz: f60fd1359e43d85b9fe9168fefcb32417c737382ed007a06726161147629dc96864f6e21fcff58b3a249724aa3b0b7ad231e37388402090934a91a45eb1edd27
-  data.tar.gz: '08e1c3f4f082ee333e62f7537879209c3b78429b500d300cbb86bcf1db9cd68dcdb77bd92f0a09eee48b05ebd83f8b253c92cb46424b22bf74bcbc19d7a54c10'
+  metadata.gz: 308986a7bf182d3968b7b19879ad8640ae4170dd1f58e024bca93620c4f51928ef2991840a51554622bb2f1af3db59ff33b1ac8ad004233e1715b41eb5f173b1
+  data.tar.gz: ee7689552c74f2be1ba96fe263653f97f9ef7a4d20c00a847c6e9d648154acc8a2856aa7ff7d3366283163d27df41715a43ffd50c28deb86446056fe4e9105f8

data/ext/google/protobuf_c/convert.c

@@ -112,8 +112,8 @@ VALUE Convert_CheckStringUtf8(VALUE str) {
     // not mean that it is *valid* UTF-8.  We have to check separately
     // whether it is valid.
     if (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN) {
-      VALUE exc = rb_const_get_at(
-          rb_cEncoding, rb_intern("InvalidByteSequenceError"));
+      VALUE exc =
+          rb_const_get_at(rb_cEncoding, rb_intern("InvalidByteSequenceError"));
       rb_raise(exc, "String is invalid UTF-8");
     }
   } else {
@@ -226,8 +226,8 @@ upb_MessageValue Convert_RubyToUpb(VALUE value, const char* name,
       }
       break;
     default:
-      rb_raise(cTypeError,
-                "Convert_RubyToUpb(): Unexpected type %d", (int)type_info.type);
+      rb_raise(cTypeError, "Convert_RubyToUpb(): Unexpected type %d",
+               (int)type_info.type);
   }
 
   return ret;

data/ext/google/protobuf_c/convert.h

@@ -22,8 +22,8 @@
 // - If type is message and the Ruby value is a message instance, we will fuse
 //   the message's arena into |arena|, to ensure that this message outlives the
 //   container.
-upb_MessageValue Convert_RubyToUpb(VALUE ruby_val, const char *name,
-                                   TypeInfo type_info, upb_Arena *arena);
+upb_MessageValue Convert_RubyToUpb(VALUE ruby_val, const char* name,
+                                   TypeInfo type_info, upb_Arena* arena);
 
 // Converts |upb_val| to a Ruby VALUE according to |type_info|. This may involve
 // creating a Ruby wrapper object.
@@ -36,7 +36,7 @@ VALUE Convert_UpbToRuby(upb_MessageValue upb_val, TypeInfo type_info,
 
 // Creates a deep copy of |msgval| in |arena|.
 upb_MessageValue Msgval_DeepCopy(upb_MessageValue msgval, TypeInfo type_info,
-                                 upb_Arena *arena);
+                                 upb_Arena* arena);
 
 // Returns true if |val1| and |val2| are equal. Their type is given by
 // |type_info|.

data/ext/google/protobuf_c/map.h

@@ -17,21 +17,21 @@ VALUE Map_EmptyFrozen(const upb_FieldDef* f);
 
 // Returns a Ruby wrapper object for the given map, which will be created if
 // one does not exist already.
-VALUE Map_GetRubyWrapper(const upb_Map *map, upb_CType key_type,
+VALUE Map_GetRubyWrapper(const upb_Map* map, upb_CType key_type,
                          TypeInfo value_type, VALUE arena);
 
 // Gets the underlying upb_Map for this Ruby map object, which must have
 // key/value type that match |field|. If this is not a map or the type doesn't
 // match, raises an exception.
-const upb_Map *Map_GetUpbMap(VALUE val, const upb_FieldDef *field,
-                             upb_Arena *arena);
+const upb_Map* Map_GetUpbMap(VALUE val, const upb_FieldDef* field,
+                             upb_Arena* arena);
 
 // Implements #inspect for this map by appending its contents to |b|.
-void Map_Inspect(StringBuilder *b, const upb_Map *map, upb_CType key_type,
+void Map_Inspect(StringBuilder* b, const upb_Map* map, upb_CType key_type,
                  TypeInfo val_type);
 
 // Returns a new Hash object containing the contents of this Map.
-VALUE Map_CreateHash(const upb_Map *map, upb_CType key_type, TypeInfo val_info);
+VALUE Map_CreateHash(const upb_Map* map, upb_CType key_type, TypeInfo val_info);
 
 // Returns a deep copy of this Map object.
 VALUE Map_deep_copy(VALUE obj);

data/ext/google/protobuf_c/message.c

@@ -401,6 +401,9 @@ static VALUE Message_field_accessor(VALUE _self, const upb_FieldDef* f,
       if (upb_FieldDef_IsRepeated(f)) {
         // Map repeated fields to a new type with ints
         VALUE arr = rb_ary_new();
+        if (msgval.array_val == NULL) {
+          return arr;
+        }
         size_t i, n = upb_Array_Size(msgval.array_val);
         for (i = 0; i < n; i++) {
           upb_MessageValue elem = upb_Array_Get(msgval.array_val, i);
@@ -690,7 +693,10 @@ static VALUE Message_dup(VALUE _self) {
   VALUE new_msg = rb_class_new_instance(0, NULL, CLASS_OF(_self));
   Message* new_msg_self = ruby_to_Message(new_msg);
   const upb_MiniTable* m = upb_MessageDef_MiniTable(self->msgdef);
-  upb_Message_ShallowCopy((upb_Message*)new_msg_self->msg, self->msg, m);
+  if (!upb_Message_ShallowCopy((upb_Message*)new_msg_self->msg, self->msg, m,
+                               Arena_get(new_msg_self->arena))) {
+    rb_raise(rb_eRuntimeError, "Failed to shallow copy message.");
+  }
   Arena_fuse(self->arena, Arena_get(new_msg_self->arena));
   return new_msg;
 }
@@ -1052,8 +1058,8 @@ static VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
   const upb_DefPool* pool = upb_FileDef_Pool(upb_MessageDef_File(msg->msgdef));
 
   int result = upb_JsonDecodeDetectingNonconformance(
-      RSTRING_PTR(data), RSTRING_LEN(data), (upb_Message*)msg->msg,
-      msg->msgdef, pool, options, Arena_get(msg->arena), &status);
+      RSTRING_PTR(data), RSTRING_LEN(data), (upb_Message*)msg->msg, msg->msgdef,
+      pool, options, Arena_get(msg->arena), &status);
 
   switch (result) {
     case kUpb_JsonDecodeResult_Ok:

data/ext/google/protobuf_c/protobuf.c

@@ -15,13 +15,13 @@
 VALUE cParseError;
 VALUE cTypeError;
 
-const upb_FieldDef *map_field_key(const upb_FieldDef *field) {
-  const upb_MessageDef *entry = upb_FieldDef_MessageSubDef(field);
+const upb_FieldDef* map_field_key(const upb_FieldDef* field) {
+  const upb_MessageDef* entry = upb_FieldDef_MessageSubDef(field);
   return upb_MessageDef_FindFieldByNumber(entry, 1);
 }
 
-const upb_FieldDef *map_field_value(const upb_FieldDef *field) {
-  const upb_MessageDef *entry = upb_FieldDef_MessageSubDef(field);
+const upb_FieldDef* map_field_value(const upb_FieldDef* field) {
+  const upb_MessageDef* entry = upb_FieldDef_MessageSubDef(field);
   return upb_MessageDef_FindFieldByNumber(entry, 2);
 }
 
@@ -32,7 +32,7 @@ const upb_FieldDef *map_field_value(const upb_FieldDef *field) {
 struct StringBuilder {
   size_t size;
   size_t cap;
-  char *data;
+  char* data;
 };
 
 typedef struct StringBuilder StringBuilder;
@@ -41,21 +41,21 @@ static size_t StringBuilder_SizeOf(size_t cap) {
   return sizeof(StringBuilder) + cap;
 }
 
-StringBuilder *StringBuilder_New() {
+StringBuilder* StringBuilder_New() {
   const size_t cap = 128;
-  StringBuilder *builder = malloc(sizeof(*builder));
+  StringBuilder* builder = malloc(sizeof(*builder));
   builder->size = 0;
   builder->cap = cap;
   builder->data = malloc(builder->cap);
   return builder;
 }
 
-void StringBuilder_Free(StringBuilder *b) {
+void StringBuilder_Free(StringBuilder* b) {
   free(b->data);
   free(b);
 }
 
-void StringBuilder_Printf(StringBuilder *b, const char *fmt, ...) {
+void StringBuilder_Printf(StringBuilder* b, const char* fmt, ...) {
   size_t have = b->cap - b->size;
   size_t n;
   va_list args;
@@ -79,15 +79,15 @@ void StringBuilder_Printf(StringBuilder *b, const char *fmt, ...) {
   b->size += n;
 }
 
-VALUE StringBuilder_ToRubyString(StringBuilder *b) {
+VALUE StringBuilder_ToRubyString(StringBuilder* b) {
   VALUE ret = rb_str_new(b->data, b->size);
   rb_enc_associate(ret, rb_utf8_encoding());
   return ret;
 }
 
-static void StringBuilder_PrintEnum(StringBuilder *b, int32_t val,
-                                    const upb_EnumDef *e) {
-  const upb_EnumValueDef *ev = upb_EnumDef_FindValueByNumber(e, val);
+static void StringBuilder_PrintEnum(StringBuilder* b, int32_t val,
+                                    const upb_EnumDef* e) {
+  const upb_EnumValueDef* ev = upb_EnumDef_FindValueByNumber(e, val);
   if (ev) {
     StringBuilder_Printf(b, ":%s", upb_EnumValueDef_Name(ev));
   } else {
@@ -95,7 +95,7 @@ static void StringBuilder_PrintEnum(StringBuilder *b, int32_t val,
   }
 }
 
-void StringBuilder_PrintMsgval(StringBuilder *b, upb_MessageValue val,
+void StringBuilder_PrintMsgval(StringBuilder* b, upb_MessageValue val,
                                TypeInfo info) {
   switch (info.type) {
     case kUpb_CType_Bool:
@@ -145,25 +145,25 @@ void StringBuilder_PrintMsgval(StringBuilder *b, upb_MessageValue val,
 // -----------------------------------------------------------------------------
 
 typedef struct {
-  upb_Arena *arena;
+  upb_Arena* arena;
   // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
   // macro to update VALUE references, as to trigger write barriers.
   VALUE pinned_objs;
 } Arena;
 
-static void Arena_mark(void *data) {
-  Arena *arena = data;
+static void Arena_mark(void* data) {
+  Arena* arena = data;
   rb_gc_mark(arena->pinned_objs);
 }
 
-static void Arena_free(void *data) {
-  Arena *arena = data;
+static void Arena_free(void* data) {
+  Arena* arena = data;
   upb_Arena_Free(arena->arena);
   xfree(arena);
 }
 
-static size_t Arena_memsize(const void *data) {
-  const Arena *arena = data;
+static size_t Arena_memsize(const void* data) {
+  const Arena* arena = data;
   size_t fused_count;
   size_t memsize = upb_Arena_SpaceAllocated(arena->arena, &fused_count);
   if (fused_count > 1) {
@@ -182,8 +182,8 @@ const rb_data_type_t Arena_type = {
     .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
-static void *ruby_upb_allocfunc(upb_alloc *alloc, void *ptr, size_t oldsize,
-                                size_t size, size_t *actual_size) {
+static void* ruby_upb_allocfunc(upb_alloc* alloc, void* ptr, size_t oldsize,
+                                size_t size, size_t* actual_size) {
   if (size == 0) {
     xfree(ptr);
     return NULL;
@@ -195,20 +195,20 @@ static void *ruby_upb_allocfunc(upb_alloc *alloc, void *ptr, size_t oldsize,
 upb_alloc ruby_upb_alloc = {&ruby_upb_allocfunc};
 
 static VALUE Arena_alloc(VALUE klass) {
-  Arena *arena = ALLOC(Arena);
+  Arena* arena = ALLOC(Arena);
   arena->arena = upb_Arena_Init(NULL, 0, &ruby_upb_alloc);
   arena->pinned_objs = Qnil;
   return TypedData_Wrap_Struct(klass, &Arena_type, arena);
 }
 
-upb_Arena *Arena_get(VALUE _arena) {
-  Arena *arena;
+upb_Arena* Arena_get(VALUE _arena) {
+  Arena* arena;
   TypedData_Get_Struct(_arena, Arena, &Arena_type, arena);
   return arena->arena;
 }
 
-void Arena_fuse(VALUE _arena, upb_Arena *other) {
-  Arena *arena;
+void Arena_fuse(VALUE _arena, upb_Arena* other) {
+  Arena* arena;
   TypedData_Get_Struct(_arena, Arena, &Arena_type, arena);
   if (!upb_Arena_Fuse(arena->arena, other)) {
     rb_raise(rb_eRuntimeError,
@@ -255,7 +255,7 @@ static void ObjectCache_Init(VALUE protobuf) {
   rb_const_set(internal, rb_intern("SIZEOF_VALUE"), INT2NUM(SIZEOF_VALUE));
 }
 
-static VALUE ObjectCache_GetKey(const void *key) {
+static VALUE ObjectCache_GetKey(const void* key) {
   VALUE key_val = (VALUE)key;
   PBRUBY_ASSERT((key_val & 3) == 0);
   // Ensure the key can be stored as a Fixnum since 1 bit is needed for
@@ -265,13 +265,13 @@ static VALUE ObjectCache_GetKey(const void *key) {
   return new_key;
 }
 
-VALUE ObjectCache_TryAdd(const void *key, VALUE val) {
+VALUE ObjectCache_TryAdd(const void* key, VALUE val) {
   VALUE key_val = ObjectCache_GetKey(key);
   return rb_funcall(weak_obj_cache, item_try_add, 2, key_val, val);
 }
 
 // Returns the cached object for this key, if any. Otherwise returns Qnil.
-VALUE ObjectCache_Get(const void *key) {
+VALUE ObjectCache_Get(const void* key) {
   VALUE key_val = ObjectCache_GetKey(key);
   return rb_funcall(weak_obj_cache, item_get, 1, key_val);
 }
@@ -284,8 +284,8 @@ VALUE ObjectCache_Get(const void *key) {
  * unknown fields in submessages.
  */
 static VALUE Google_Protobuf_discard_unknown(VALUE self, VALUE msg_rb) {
-  const upb_MessageDef *m;
-  upb_Message *msg = Message_GetMutable(msg_rb, &m);
+  const upb_MessageDef* m;
+  upb_Message* msg = Message_GetMutable(msg_rb, &m);
   const upb_DefPool* ext_pool = upb_FileDef_Pool(upb_MessageDef_File(m));
   if (!upb_Message_DiscardUnknown(msg, m, ext_pool, 128)) {
     rb_raise(rb_eRuntimeError, "Messages nested too deeply.");
@@ -309,10 +309,10 @@ VALUE Google_Protobuf_deep_copy(VALUE self, VALUE obj) {
     return Map_deep_copy(obj);
   } else {
     VALUE new_arena_rb = Arena_new();
-    upb_Arena *new_arena = Arena_get(new_arena_rb);
-    const upb_MessageDef *m;
-    const upb_Message *msg = Message_Get(obj, &m);
-    upb_Message *new_msg = Message_deep_copy(msg, m, new_arena);
+    upb_Arena* new_arena = Arena_get(new_arena_rb);
+    const upb_MessageDef* m;
+    const upb_Message* msg = Message_Get(obj, &m);
+    upb_Message* new_msg = Message_deep_copy(msg, m, new_arena);
     return Message_GetRubyWrapper(new_msg, m, new_arena_rb);
   }
 }
@@ -351,7 +351,7 @@ __attribute__((visibility("default"))) void Init_protobuf_c() {
 
 // Raises a Ruby error if val is frozen in Ruby or UPB.
 void Protobuf_CheckNotFrozen(VALUE val, bool upb_frozen) {
-  if (RB_UNLIKELY(rb_obj_frozen_p(val)||upb_frozen)) {
+  if (RB_UNLIKELY(rb_obj_frozen_p(val) || upb_frozen)) {
     rb_error_frozen_object(val);
   }
 }

data/ext/google/protobuf_c/repeated_field.c

@@ -180,11 +180,18 @@ static int index_position(VALUE _index, RepeatedField* repeated_field) {
 }
 
 static VALUE RepeatedField_subarray(RepeatedField* self, long beg, long len) {
-  size_t size = upb_Array_Size(self->array);
-  VALUE ary = rb_ary_new2(size);
-  long i;
-
-  for (i = beg; i < beg + len; i++) {
+  long size = (long)upb_Array_Size(self->array);
+
+  // Match Ruby Array#[beg, len] semantics and avoid an out-of-bounds read
+  // through upb_Array_Get (which only has a debug-only UPB_ASSERT for
+  // bounds): clamp len to what is actually available, and reject negative
+  // len up front.
+  if (len < 0) return Qnil;
+  if (beg < 0 || beg > size) return Qnil;
+  if (len > size - beg) len = size - beg;
+
+  VALUE ary = rb_ary_new2(len);
+  for (long i = beg; i < beg + len; i++) {
     upb_MessageValue msgval = upb_Array_Get(self->array, i);
     VALUE elem = Convert_UpbToRuby(msgval, self->type_info, self->arena);
     rb_ary_push(ary, elem);
@@ -264,7 +271,7 @@ static VALUE RepeatedField_index(int argc, VALUE* argv, VALUE _self) {
   if (beg < 0) {
     beg += size;
   }
-  if (beg >= size) {
+  if (beg > size) {
     return Qnil;
   }
   return RepeatedField_subarray(self, beg, len);