google-protobuf 4.36.2-x86_64-linux-gnu → 4.37.0.rc.1-x86_64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d09b509229a93adf7c121eeef2f4b70f0118f8d8d47a6418f36b191b653072b
-  data.tar.gz: 360ef4f793fe0cfa5f00d7f161dfffa0fae42d9db0740313902df225a77e2007
+  metadata.gz: 8ad825a3995990221cfff33863e340c0de2db68954238e44926e3d03630a54e9
+  data.tar.gz: 6860acf6ca339da448258a404140f9f608fd1c2f8b1d358cf4b98daedb708f8b
 SHA512:
-  metadata.gz: 3d5b6ecccf7f4d66c029d384432bb9aeb4d86f812f54e260a5d18929c7d3a99b695378b9dcedee129051f9c8469dd0332ae283b9f518de5fcafc44851f6bd171
-  data.tar.gz: a2f1f86512e1a7cf5bfb4ba95f8b2f64ed20794fbf98085fd22191e8b83946c929125b68f04d661e311e1e6fe993520c109aa36fb365055bd30f964dd3d4a076
+  metadata.gz: a19b18acc33139b32f8c5e45b04e5c2eac51d497143ba90c96dc224481efe2f11a44de4209f332e15ba56bf88f75b01ed83efad2e702c8c51a426635de63a664
+  data.tar.gz: 1e6fb6350f2f6c71026c0fec23120f077c0618b9cb8c1ad4f994c2b3edd2ecb3cbd24a394fa7cb01b8a574fe6cdafdb4f609ff4974809c1043a3c60c4c338c4e

data/ext/google/protobuf_c/convert.c

@@ -24,10 +24,16 @@ static upb_StringView Convert_StringData(VALUE str, upb_Arena* arena) {
   upb_StringView ret;
   if (arena) {
     char* ptr = upb_Arena_Malloc(arena, RSTRING_LEN(str));
+    if (!ptr) Arena_raise_oom();
     memcpy(ptr, RSTRING_PTR(str), RSTRING_LEN(str));
     ret.data = ptr;
   } else {
-    // Data is only needed temporarily (within map lookup).
+    // Alias the Ruby String's bytes instead of copying them. Only valid when
+    // the result is consumed before anything can allocate: Convert_RubyToUpb
+    // may have converted `str` to a temporary that nothing else references, so
+    // any GC between here and the read can free or move it. The map lookup
+    // paths (Map_index, Map_has_key, Map_delete) satisfy this; insertion paths
+    // must pass an arena.
     ret.data = RSTRING_PTR(str);
   }
   ret.size = RSTRING_LEN(str);
@@ -292,6 +298,7 @@ upb_MessageValue Msgval_DeepCopy(upb_MessageValue msgval, TypeInfo type_info,
     case kUpb_CType_Bytes: {
       size_t n = msgval.str_val.size;
       char* mem = upb_Arena_Malloc(arena, n);
+      if (!mem) Arena_raise_oom();
       new_msgval.str_val.data = mem;
       new_msgval.str_val.size = n;
       memcpy(mem, msgval.str_val.data, n);

data/ext/google/protobuf_c/defs.c

@@ -114,6 +114,7 @@ static VALUE DescriptorPool_alloc(VALUE klass) {
 
   RB_OBJ_WRITE(ret, &self->def_to_descriptor, rb_hash_new());
   self->symtab = upb_DefPool_New();
+  if (!self->symtab) Arena_raise_oom();
 
   // Ruby treats all enums as open.
   upb_DefPool_DisableClosedEnumChecking(self->symtab);
@@ -485,13 +486,20 @@ static VALUE Descriptor_options(VALUE _self) {
   const google_protobuf_MessageOptions* opts =
       upb_MessageDef_Options(self->msgdef);
   upb_Arena* arena = upb_Arena_New();
+  if (!arena) goto err;
   size_t size;
   char* serialized =
       google_protobuf_MessageOptions_serialize(opts, arena, &size);
+  if (!serialized) goto err;
   VALUE message_options = decode_options(_self, "MessageOptions", size,
                                          serialized, self->descriptor_pool);
   upb_Arena_Free(arena);
   return message_options;
+
+err:
+  if (arena) upb_Arena_Free(arena);
+  Arena_raise_oom();
+  return Qnil;
 }
 
 /*
@@ -506,16 +514,24 @@ static VALUE Descriptor_options(VALUE _self) {
 static VALUE Descriptor_to_proto(VALUE _self) {
   Descriptor* self = ruby_to_Descriptor(_self);
   upb_Arena* arena = upb_Arena_New();
+  if (!arena) goto err;
   google_protobuf_DescriptorProto* proto =
       upb_MessageDef_ToProto(self->msgdef, arena);
+  if (!proto) goto err;
   size_t size;
   const char* serialized =
       google_protobuf_DescriptorProto_serialize(proto, arena, &size);
+  if (!serialized) goto err;
   VALUE proto_class = rb_path2class("Google::Protobuf::DescriptorProto");
   VALUE proto_rb =
       Message_decode_bytes(size, serialized, 0, proto_class, false);
   upb_Arena_Free(arena);
   return proto_rb;
+
+err:
+  if (arena) upb_Arena_Free(arena);
+  Arena_raise_oom();
+  return Qnil;
 }
 
 static void Descriptor_register(VALUE module) {
@@ -628,12 +644,19 @@ static VALUE FileDescriptor_options(VALUE _self) {
   FileDescriptor* self = ruby_to_FileDescriptor(_self);
   const google_protobuf_FileOptions* opts = upb_FileDef_Options(self->filedef);
   upb_Arena* arena = upb_Arena_New();
+  if (!arena) goto err;
   size_t size;
   char* serialized = google_protobuf_FileOptions_serialize(opts, arena, &size);
+  if (!serialized) goto err;
   VALUE file_options = decode_options(_self, "FileOptions", size, serialized,
                                       self->descriptor_pool);
   upb_Arena_Free(arena);
   return file_options;
+
+err:
+  if (arena) upb_Arena_Free(arena);
+  Arena_raise_oom();
+  return Qnil;
 }
 
 /*
@@ -648,12 +671,15 @@ static VALUE FileDescriptor_options(VALUE _self) {
 static VALUE FileDescriptor_to_proto(VALUE _self) {
   FileDescriptor* self = ruby_to_FileDescriptor(_self);
   upb_Arena* arena = upb_Arena_New();
+  if (!arena) goto err;
   google_protobuf_FileDescriptorProto* file_proto =
       upb_FileDef_ToProto(self->filedef, arena);
+  if (!file_proto) goto err;
 
   size_t size;
   const char* serialized =
       google_protobuf_FileDescriptorProto_serialize(file_proto, arena, &size);
+  if (!serialized) goto err;
 
   VALUE file_proto_class =
       rb_path2class("Google::Protobuf::FileDescriptorProto");
@@ -661,6 +687,11 @@ static VALUE FileDescriptor_to_proto(VALUE _self) {
       Message_decode_bytes(size, serialized, 0, file_proto_class, false);
   upb_Arena_Free(arena);
   return proto_rb;
+
+err:
+  if (arena) upb_Arena_Free(arena);
+  Arena_raise_oom();
+  return Qnil;
 }
 
 static void FileDescriptor_register(VALUE module) {
@@ -1085,7 +1116,9 @@ static VALUE FieldDescriptor_set(VALUE _self, VALUE msg_rb, VALUE value) {
 
   msgval = Convert_RubyToUpb(value, upb_FieldDef_Name(self->fielddef),
                              TypeInfo_get(self->fielddef), arena);
-  upb_Message_SetFieldByDef(msg, self->fielddef, msgval, arena);
+  if (!upb_Message_SetFieldByDef(msg, self->fielddef, msgval, arena)) {
+    Arena_raise_oom();
+  }
   return Qnil;
 }
 
@@ -1103,8 +1136,13 @@ static VALUE FieldDescriptor_options(VALUE _self) {
   const google_protobuf_FieldOptions* opts =
       upb_FieldDef_Options(self->fielddef);
   upb_Arena* arena = upb_Arena_New();
+  if (!arena) Arena_raise_oom();
   size_t size;
   char* serialized = google_protobuf_FieldOptions_serialize(opts, arena, &size);
+  if (!serialized) {
+    upb_Arena_Free(arena);
+    Arena_raise_oom();
+  }
   VALUE field_options = decode_options(_self, "FieldOptions", size, serialized,
                                        self->descriptor_pool);
   upb_Arena_Free(arena);
@@ -1123,11 +1161,20 @@ static VALUE FieldDescriptor_options(VALUE _self) {
 static VALUE FieldDescriptor_to_proto(VALUE _self) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
   upb_Arena* arena = upb_Arena_New();
+  if (!arena) Arena_raise_oom();
   google_protobuf_FieldDescriptorProto* proto =
       upb_FieldDef_ToProto(self->fielddef, arena);
+  if (!proto) {
+    upb_Arena_Free(arena);
+    Arena_raise_oom();
+  }
   size_t size;
   const char* serialized =
       google_protobuf_FieldDescriptorProto_serialize(proto, arena, &size);
+  if (!serialized) {
+    upb_Arena_Free(arena);
+    Arena_raise_oom();
+  }
   VALUE proto_class = rb_path2class("Google::Protobuf::FieldDescriptorProto");
   VALUE proto_rb =
       Message_decode_bytes(size, serialized, 0, proto_class, false);
@@ -1279,8 +1326,13 @@ static VALUE OneOfDescriptor_options(VALUE _self) {
   const google_protobuf_OneofOptions* opts =
       upb_OneofDef_Options(self->oneofdef);
   upb_Arena* arena = upb_Arena_New();
+  if (!arena) Arena_raise_oom();
   size_t size;
   char* serialized = google_protobuf_OneofOptions_serialize(opts, arena, &size);
+  if (!serialized) {
+    upb_Arena_Free(arena);
+    Arena_raise_oom();
+  }
   VALUE oneof_options = decode_options(_self, "OneofOptions", size, serialized,
                                        self->descriptor_pool);
   upb_Arena_Free(arena);
@@ -1299,11 +1351,20 @@ static VALUE OneOfDescriptor_options(VALUE _self) {
 static VALUE OneOfDescriptor_to_proto(VALUE _self) {
   OneofDescriptor* self = ruby_to_OneofDescriptor(_self);
   upb_Arena* arena = upb_Arena_New();
+  if (!arena) Arena_raise_oom();
   google_protobuf_OneofDescriptorProto* proto =
       upb_OneofDef_ToProto(self->oneofdef, arena);
+  if (!proto) {
+    upb_Arena_Free(arena);
+    Arena_raise_oom();
+  }
   size_t size;
   const char* serialized =
       google_protobuf_OneofDescriptorProto_serialize(proto, arena, &size);
+  if (!serialized) {
+    upb_Arena_Free(arena);
+    Arena_raise_oom();
+  }
   VALUE proto_class = rb_path2class("Google::Protobuf::OneofDescriptorProto");
   VALUE proto_rb =
       Message_decode_bytes(size, serialized, 0, proto_class, false);
@@ -1529,8 +1590,13 @@ static VALUE EnumDescriptor_options(VALUE _self) {
   EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
   const google_protobuf_EnumOptions* opts = upb_EnumDef_Options(self->enumdef);
   upb_Arena* arena = upb_Arena_New();
+  if (!arena) Arena_raise_oom();
   size_t size;
   char* serialized = google_protobuf_EnumOptions_serialize(opts, arena, &size);
+  if (!serialized) {
+    upb_Arena_Free(arena);
+    Arena_raise_oom();
+  }
   VALUE enum_options = decode_options(_self, "EnumOptions", size, serialized,
                                       self->descriptor_pool);
   upb_Arena_Free(arena);
@@ -1548,12 +1614,21 @@ static VALUE EnumDescriptor_options(VALUE _self) {
 static VALUE EnumDescriptor_to_proto(VALUE _self) {
   EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
   upb_Arena* arena = upb_Arena_New();
+  if (!arena) Arena_raise_oom();
   google_protobuf_EnumDescriptorProto* proto =
       upb_EnumDef_ToProto(self->enumdef, arena);
+  if (!proto) {
+    upb_Arena_Free(arena);
+    Arena_raise_oom();
+  }
 
   size_t size;
   const char* serialized =
       google_protobuf_EnumDescriptorProto_serialize(proto, arena, &size);
+  if (!serialized) {
+    upb_Arena_Free(arena);
+    Arena_raise_oom();
+  }
 
   VALUE proto_class = rb_path2class("Google::Protobuf::EnumDescriptorProto");
   VALUE proto_rb =
@@ -1707,9 +1782,14 @@ static VALUE ServiceDescriptor_options(VALUE _self) {
   const google_protobuf_ServiceOptions* opts =
       upb_ServiceDef_Options(self->servicedef);
   upb_Arena* arena = upb_Arena_New();
+  if (!arena) Arena_raise_oom();
   size_t size;
   char* serialized =
       google_protobuf_ServiceOptions_serialize(opts, arena, &size);
+  if (!serialized) {
+    upb_Arena_Free(arena);
+    Arena_raise_oom();
+  }
   VALUE service_options = decode_options(_self, "ServiceOptions", size,
                                          serialized, self->descriptor_pool);
   upb_Arena_Free(arena);
@@ -1728,11 +1808,20 @@ static VALUE ServiceDescriptor_options(VALUE _self) {
 static VALUE ServiceDescriptor_to_proto(VALUE _self) {
   ServiceDescriptor* self = ruby_to_ServiceDescriptor(_self);
   upb_Arena* arena = upb_Arena_New();
+  if (!arena) Arena_raise_oom();
   google_protobuf_ServiceDescriptorProto* proto =
       upb_ServiceDef_ToProto(self->servicedef, arena);
+  if (!proto) {
+    upb_Arena_Free(arena);
+    Arena_raise_oom();
+  }
   size_t size;
   const char* serialized =
       google_protobuf_ServiceDescriptorProto_serialize(proto, arena, &size);
+  if (!serialized) {
+    upb_Arena_Free(arena);
+    Arena_raise_oom();
+  }
   VALUE proto_class = rb_path2class("Google::Protobuf::ServiceDescriptorProto");
   VALUE proto_rb =
       Message_decode_bytes(size, serialized, 0, proto_class, false);
@@ -1850,9 +1939,14 @@ static VALUE MethodDescriptor_options(VALUE _self) {
   const google_protobuf_MethodOptions* opts =
       upb_MethodDef_Options(self->methoddef);
   upb_Arena* arena = upb_Arena_New();
+  if (!arena) Arena_raise_oom();
   size_t size;
   char* serialized =
       google_protobuf_MethodOptions_serialize(opts, arena, &size);
+  if (!serialized) {
+    upb_Arena_Free(arena);
+    Arena_raise_oom();
+  }
   VALUE method_options = decode_options(_self, "MethodOptions", size,
                                         serialized, self->descriptor_pool);
   upb_Arena_Free(arena);
@@ -1909,11 +2003,20 @@ static VALUE MethodDescriptor_client_streaming(VALUE _self) {
 static VALUE MethodDescriptor_to_proto(VALUE _self) {
   MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
   upb_Arena* arena = upb_Arena_New();
+  if (!arena) Arena_raise_oom();
   google_protobuf_MethodDescriptorProto* proto =
       upb_MethodDef_ToProto(self->methoddef, arena);
+  if (!proto) {
+    upb_Arena_Free(arena);
+    Arena_raise_oom();
+  }
   size_t size;
   const char* serialized =
       google_protobuf_MethodDescriptorProto_serialize(proto, arena, &size);
+  if (!serialized) {
+    upb_Arena_Free(arena);
+    Arena_raise_oom();
+  }
   VALUE proto_class = rb_path2class("Google::Protobuf::MethodDescriptorProto");
   VALUE proto_rb =
       Message_decode_bytes(size, serialized, 0, proto_class, false);

data/ext/google/protobuf_c/extconf.rb

@@ -22,7 +22,12 @@ debug_enabled = ENV["PROTOBUF_CONFIG"] == "dbg"
 
 additional_c_flags = debug_enabled ? "-O0 -fno-omit-frame-pointer -fvisibility=default -g" : "-O3 -DNDEBUG -fvisibility=hidden"
 
-if RUBY_PLATFORM =~ /darwin/ || RUBY_PLATFORM =~ /linux/ || RUBY_PLATFORM =~ /freebsd/
+if RUBY_PLATFORM =~ /mswin/
+  # cl.exe does not understand GCC-style flags. C11 or later is required
+  # for _Generic, which the upb MSVC atomics fall back on. c17 is the
+  # highest C standard mode cl.exe supports.
+  $CFLAGS += debug_enabled ? " -std:c17 -Od" : " -std:c17 -DNDEBUG"
+elsif RUBY_PLATFORM =~ /darwin/ || RUBY_PLATFORM =~ /linux/ || RUBY_PLATFORM =~ /freebsd/
   $CFLAGS += " -std=gnu99 -Wall -Wsign-compare -Wno-declaration-after-statement #{additional_c_flags}"
 else
   $CFLAGS += " -std=gnu99 #{additional_c_flags}"

data/ext/google/protobuf_c/map.c

@@ -91,6 +91,7 @@ static VALUE Map_new_this_type(Map* from) {
   VALUE arena_rb = Arena_new();
   upb_Map* map = upb_Map_New(Arena_get(arena_rb), from->key_type,
                              from->value_type_info.type);
+  if (!map) Arena_raise_oom();
   VALUE ret =
       Map_GetRubyWrapper(map, from->key_type, from->value_type_info, arena_rb);
   PBRUBY_ASSERT(ruby_to_Map(ret)->value_type_class == from->value_type_class);
@@ -110,8 +111,8 @@ static upb_Map* Map_GetMutable(VALUE _self) {
   return (upb_Map*)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,
+                     bool emit_defaults) {
   VALUE hash = rb_hash_new();
   TypeInfo key_info = TypeInfo_from_type(key_type);
 
@@ -121,7 +122,7 @@ VALUE Map_CreateHash(const upb_Map* map, upb_CType key_type,
   upb_MessageValue key, val;
   while (upb_Map_Next(map, &key, &val, &iter)) {
     VALUE key_val = Convert_UpbToRuby(key, key_info, Qnil);
-    VALUE val_val = Scalar_CreateHash(val, val_info);
+    VALUE val_val = Scalar_CreateHash(val, val_info, emit_defaults);
     rb_hash_aset(hash, key_val, val_val);
   }
 
@@ -134,12 +135,15 @@ VALUE Map_deep_copy(VALUE obj) {
   upb_Arena* arena = Arena_get(new_arena_rb);
   upb_Map* new_map =
       upb_Map_New(arena, self->key_type, self->value_type_info.type);
+  if (!new_map) Arena_raise_oom();
   size_t iter = kUpb_Map_Begin;
   upb_MessageValue key, val;
   while (upb_Map_Next(self->map, &key, &val, &iter)) {
     upb_MessageValue val_copy =
         Msgval_DeepCopy(val, self->value_type_info, arena);
-    upb_Map_Set(new_map, key, val_copy, arena);
+    if (!upb_Map_Set(new_map, key, val_copy, arena)) {
+      Arena_raise_oom();
+    }
   }
 
   return Map_GetRubyWrapper(new_map, self->key_type, self->value_type_info,
@@ -202,7 +206,9 @@ static int merge_into_self_callback(VALUE key, VALUE val, VALUE _self) {
       Convert_RubyToUpb(key, "", Map_keyinfo(self), arena);
   upb_MessageValue val_val =
       Convert_RubyToUpb(val, "", self->value_type_info, arena);
-  upb_Map_Set(Map_GetMutable(_self), key_val, val_val, arena);
+  if (!upb_Map_Set(Map_GetMutable(_self), key_val, val_val, arena)) {
+    Arena_raise_oom();
+  }
   return ST_CONTINUE;
 }
 
@@ -228,7 +234,9 @@ static VALUE Map_merge_into_self(VALUE _self, VALUE hashmap) {
     size_t iter = kUpb_Map_Begin;
     upb_MessageValue key, val;
     while (upb_Map_Next(other->map, &key, &val, &iter)) {
-      upb_Map_Set(self_map, key, val, arena);
+      if (!upb_Map_Set(self_map, key, val, arena)) {
+        Arena_raise_oom();
+      }
     }
   } else {
     rb_raise(rb_eArgError, "Unknown type merging into Map");
@@ -293,6 +301,7 @@ static VALUE Map_init(int argc, VALUE* argv, VALUE _self) {
   self->value_type_info =
       TypeInfo_FromClass(argc, argv, 1, &self->value_type_class, &init_arg);
   self->arena = Arena_new();
+  if (!self->arena) Arena_raise_oom();
 
   // Check that the key type is an allowed type.
   switch (self->key_type) {
@@ -311,6 +320,7 @@ static VALUE Map_init(int argc, VALUE* argv, VALUE _self) {
 
   self->map = upb_Map_New(Arena_get(self->arena), self->key_type,
                           self->value_type_info.type);
+  if (!self->map) Arena_raise_oom();
   VALUE stored = ObjectCache_TryAdd(self->map, _self);
   (void)stored;
   PBRUBY_ASSERT(stored == _self);
@@ -424,12 +434,19 @@ static VALUE Map_index(VALUE _self, VALUE key) {
 static VALUE Map_index_set(VALUE _self, VALUE key, VALUE val) {
   Map* self = ruby_to_Map(_self);
   upb_Arena* arena = Arena_get(self->arena);
+  // The key must be copied into the arena, not aliased. Converting the value
+  // below can allocate a Ruby object and therefore trigger GC, which may free
+  // or move the String the key would otherwise point into. Passing NULL here is
+  // only safe when the key is consumed before any allocation, as in the lookup
+  // paths (Map_index, Map_has_key, Map_delete).
   upb_MessageValue key_upb =
-      Convert_RubyToUpb(key, "", Map_keyinfo(self), NULL);
+      Convert_RubyToUpb(key, "", Map_keyinfo(self), arena);
   upb_MessageValue val_upb =
       Convert_RubyToUpb(val, "", self->value_type_info, arena);
 
-  upb_Map_Set(Map_GetMutable(_self), key_upb, val_upb, arena);
+  if (!upb_Map_Set(Map_GetMutable(_self), key_upb, val_upb, arena)) {
+    Arena_raise_oom();
+  }
 
   return val;
 }
@@ -523,7 +540,9 @@ static VALUE Map_dup(VALUE _self) {
 
   upb_MessageValue key, val;
   while (upb_Map_Next(self->map, &key, &val, &iter)) {
-    upb_Map_Set(new_map, key, val, arena);
+    if (!upb_Map_Set(new_map, key, val, arena)) {
+      Arena_raise_oom();
+    }
   }
 
   return new_map_rb;
@@ -655,6 +674,7 @@ VALUE Map_EmptyFrozen(const upb_FieldDef* f) {
     self->arena = Arena_new();
     self->map =
         upb_Map_New(Arena_get(self->arena), key_type, value_type_info.type);
+    if (!self->map) Arena_raise_oom();
     self->key_type = key_type;
     self->value_type_info = value_type_info;
     if (self->value_type_info.type == kUpb_CType_Message) {
@@ -699,7 +719,8 @@ VALUE Map_hash(VALUE _self) {
  */
 VALUE Map_to_h(VALUE _self) {
   Map* self = ruby_to_Map(_self);
-  return Map_CreateHash(self->map, self->key_type, self->value_type_info);
+  return Map_CreateHash(self->map, self->key_type, self->value_type_info,
+                        false);
 }
 
 /*

data/ext/google/protobuf_c/map.h

@@ -31,7 +31,8 @@ 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,
+                     bool emit_defaults);
 
 // Returns a deep copy of this Map object.
 VALUE Map_deep_copy(VALUE obj);