grpc 1.47.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

data/third_party/upb/upb/encode.c

@@ -32,6 +32,7 @@
 #include <setjmp.h>
 #include <string.h>
 
+#include "upb/extension_registry.h"
 #include "upb/msg_internal.h"
 #include "upb/upb.h"
 
@@ -76,7 +77,9 @@ static size_t upb_roundup_pow2(size_t bytes) {
   return ret;
 }
 
-UPB_NORETURN static void encode_err(upb_encstate* e) { UPB_LONGJMP(e->err, 1); }
+UPB_NORETURN static void encode_err(upb_encstate* e, upb_EncodeStatus s) {
+  UPB_LONGJMP(e->err, s);
+}
 
 UPB_NOINLINE
 static void encode_growbuffer(upb_encstate* e, size_t bytes) {
@@ -84,7 +87,7 @@ static void encode_growbuffer(upb_encstate* e, size_t bytes) {
   size_t new_size = upb_roundup_pow2(bytes + (e->limit - e->ptr));
   char* new_buf = upb_realloc(e->alloc, e->buf, old_size, new_size);
 
-  if (!new_buf) encode_err(e);
+  if (!new_buf) encode_err(e, kUpb_EncodeStatus_OutOfMemory);
 
   /* We want previous data at the end, realloc() put it at the beginning. */
   if (old_size > 0) {
@@ -255,7 +258,7 @@ static void encode_scalar(upb_encstate* e, const void* _field_mem,
       if (submsg == NULL) {
         return;
       }
-      if (--e->depth == 0) encode_err(e);
+      if (--e->depth == 0) encode_err(e, kUpb_EncodeStatus_MaxDepthExceeded);
       encode_tag(e, f->number, kUpb_WireType_EndGroup);
       encode_message(e, submsg, subm, &size);
       wire_type = kUpb_WireType_StartGroup;
@@ -269,7 +272,7 @@ static void encode_scalar(upb_encstate* e, const void* _field_mem,
       if (submsg == NULL) {
         return;
       }
-      if (--e->depth == 0) encode_err(e);
+      if (--e->depth == 0) encode_err(e, kUpb_EncodeStatus_MaxDepthExceeded);
       encode_message(e, submsg, subm, &size);
       encode_varint(e, size);
       wire_type = kUpb_WireType_Delimited;
@@ -355,7 +358,7 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
       const void* const* start = _upb_array_constptr(arr);
       const void* const* ptr = start + arr->len;
       const upb_MiniTable* subm = subs[f->submsg_index].submsg;
-      if (--e->depth == 0) encode_err(e);
+      if (--e->depth == 0) encode_err(e, kUpb_EncodeStatus_MaxDepthExceeded);
       do {
         size_t size;
         ptr--;
@@ -370,7 +373,7 @@ static void encode_array(upb_encstate* e, const upb_Message* msg,
       const void* const* start = _upb_array_constptr(arr);
       const void* const* ptr = start + arr->len;
       const upb_MiniTable* subm = subs[f->submsg_index].submsg;
-      if (--e->depth == 0) encode_err(e);
+      if (--e->depth == 0) encode_err(e, kUpb_EncodeStatus_MaxDepthExceeded);
       do {
         size_t size;
         ptr--;
@@ -413,7 +416,7 @@ static void encode_map(upb_encstate* e, const upb_Message* msg,
 
   if (map == NULL) return;
 
-  if (e->options & kUpb_Encode_Deterministic) {
+  if (e->options & kUpb_EncodeOption_Deterministic) {
     _upb_sortedmap sorted;
     _upb_mapsorter_pushmap(&e->sorter, layout->fields[0].descriptortype, map,
                            &sorted);
@@ -520,16 +523,16 @@ static void encode_message(upb_encstate* e, const upb_Message* msg,
                            const upb_MiniTable* m, size_t* size) {
   size_t pre_len = e->limit - e->ptr;
 
-  if ((e->options & kUpb_Encode_CheckRequired) && m->required_count) {
+  if ((e->options & kUpb_EncodeOption_CheckRequired) && m->required_count) {
     uint64_t msg_head;
     memcpy(&msg_head, msg, 8);
     msg_head = _upb_BigEndian_Swap64(msg_head);
     if (upb_MiniTable_requiredmask(m) & ~msg_head) {
-      encode_err(e);
+      encode_err(e, kUpb_EncodeStatus_MissingRequired);
     }
   }
 
-  if ((e->options & kUpb_Encode_SkipUnknown) == 0) {
+  if ((e->options & kUpb_EncodeOption_SkipUnknown) == 0) {
     size_t unknown_size;
     const char* unknown = upb_Message_GetUnknown(msg, &unknown_size);
 
@@ -570,8 +573,9 @@ static void encode_message(upb_encstate* e, const upb_Message* msg,
   *size = (e->limit - e->ptr) - pre_len;
 }
 
-char* upb_Encode(const void* msg, const upb_MiniTable* l, int options,
-                 upb_Arena* arena, size_t* size) {
+upb_EncodeStatus upb_Encode(const void* msg, const upb_MiniTable* l,
+                            int options, upb_Arena* arena, char** buf,
+                            size_t* size) {
   upb_encstate e;
   unsigned depth = (unsigned)options >> 16;
 
@@ -582,23 +586,28 @@ char* upb_Encode(const void* msg, const upb_MiniTable* l, int options,
   e.depth = depth ? depth : 64;
   e.options = options;
   _upb_mapsorter_init(&e.sorter);
-  char* ret = NULL;
 
-  if (UPB_SETJMP(e.err)) {
-    *size = 0;
-    ret = NULL;
-  } else {
+  upb_EncodeStatus status = UPB_SETJMP(e.err);
+
+  // Unfortunately we must continue to perform hackery here because there are
+  // code paths which blindly copy the returned pointer without bothering to
+  // check for errors until much later (b/235839510). So we still set *buf to
+  // NULL on error and we still set it to non-NULL on a successful empty result.
+  if (status == kUpb_EncodeStatus_Ok) {
     encode_message(&e, msg, l, size);
     *size = e.limit - e.ptr;
     if (*size == 0) {
       static char ch;
-      ret = &ch;
+      *buf = &ch;
     } else {
       UPB_ASSERT(e.ptr);
-      ret = e.ptr;
+      *buf = e.ptr;
     }
+  } else {
+    *buf = NULL;
+    *size = 0;
   }
 
   _upb_mapsorter_destroy(&e.sorter);
-  return ret;
+  return status;
 }

data/third_party/upb/upb/encode.h

@@ -26,7 +26,7 @@
  */
 
 /*
- * upb_Encode: parsing into a upb_Message using a upb_MiniTable.
+ * upb_Encode: parsing from a upb_Message using a upb_MiniTable.
  */
 
 #ifndef UPB_ENCODE_H_
@@ -48,19 +48,29 @@ enum {
    *
    * If your proto contains maps, the encoder will need to malloc()/free()
    * memory during encode. */
-  kUpb_Encode_Deterministic = 1,
+  kUpb_EncodeOption_Deterministic = 1,
 
   /* When set, unknown fields are not printed. */
-  kUpb_Encode_SkipUnknown = 2,
+  kUpb_EncodeOption_SkipUnknown = 2,
 
   /* When set, the encode will fail if any required fields are missing. */
-  kUpb_Encode_CheckRequired = 4,
+  kUpb_EncodeOption_CheckRequired = 4,
 };
 
 #define UPB_ENCODE_MAXDEPTH(depth) ((depth) << 16)
 
-char* upb_Encode(const void* msg, const upb_MiniTable* l, int options,
-                 upb_Arena* arena, size_t* size);
+typedef enum {
+  kUpb_EncodeStatus_Ok = 0,
+  kUpb_EncodeStatus_OutOfMemory = 1,       // Arena alloc failed
+  kUpb_EncodeStatus_MaxDepthExceeded = 2,  // Exceeded UPB_ENCODE_MAXDEPTH
+
+  // kUpb_EncodeOption_CheckRequired failed but the parse otherwise succeeded.
+  kUpb_EncodeStatus_MissingRequired = 3,
+} upb_EncodeStatus;
+
+upb_EncodeStatus upb_Encode(const void* msg, const upb_MiniTable* l,
+                            int options, upb_Arena* arena, char** buf,
+                            size_t* size);
 
 #include "upb/port_undef.inc"
 

data/third_party/upb/upb/extension_registry.c

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "upb/extension_registry.h"
+
+#include "upb/internal/table.h"
+#include "upb/msg.h"
+#include "upb/msg_internal.h"
+
+// Must be last.
+#include "upb/port_def.inc"
+
+struct upb_ExtensionRegistry {
+  upb_Arena* arena;
+  upb_strtable exts; /* Key is upb_MiniTable* concatenated with fieldnum. */
+};
+
+#define EXTREG_KEY_SIZE (sizeof(upb_MiniTable*) + sizeof(uint32_t))
+
+static void extreg_key(char* buf, const upb_MiniTable* l, uint32_t fieldnum) {
+  memcpy(buf, &l, sizeof(l));
+  memcpy(buf + sizeof(l), &fieldnum, sizeof(fieldnum));
+}
+
+upb_ExtensionRegistry* upb_ExtensionRegistry_New(upb_Arena* arena) {
+  upb_ExtensionRegistry* r = upb_Arena_Malloc(arena, sizeof(*r));
+  if (!r) return NULL;
+  r->arena = arena;
+  if (!upb_strtable_init(&r->exts, 8, arena)) return NULL;
+  return r;
+}
+
+bool _upb_extreg_add(upb_ExtensionRegistry* r,
+                     const upb_MiniTable_Extension** e, size_t count) {
+  char buf[EXTREG_KEY_SIZE];
+  const upb_MiniTable_Extension** start = e;
+  const upb_MiniTable_Extension** end = UPB_PTRADD(e, count);
+  for (; e < end; e++) {
+    const upb_MiniTable_Extension* ext = *e;
+    extreg_key(buf, ext->extendee, ext->field.number);
+    if (!upb_strtable_insert(&r->exts, buf, EXTREG_KEY_SIZE,
+                             upb_value_constptr(ext), r->arena)) {
+      goto failure;
+    }
+  }
+  return true;
+
+failure:
+  /* Back out the entries previously added. */
+  for (end = e, e = start; e < end; e++) {
+    const upb_MiniTable_Extension* ext = *e;
+    extreg_key(buf, ext->extendee, ext->field.number);
+    upb_strtable_remove2(&r->exts, buf, EXTREG_KEY_SIZE, NULL);
+  }
+  return false;
+}
+
+const upb_MiniTable_Extension* _upb_extreg_get(const upb_ExtensionRegistry* r,
+                                               const upb_MiniTable* l,
+                                               uint32_t num) {
+  char buf[EXTREG_KEY_SIZE];
+  upb_value v;
+  extreg_key(buf, l, num);
+  if (upb_strtable_lookup2(&r->exts, buf, EXTREG_KEY_SIZE, &v)) {
+    return upb_value_getconstptr(v);
+  } else {
+    return NULL;
+  }
+}

data/third_party/upb/upb/extension_registry.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_EXTENSION_REGISTRY_H_
+#define UPB_EXTENSION_REGISTRY_H_
+
+#include <stddef.h>
+
+#include "upb/upb.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Extension registry: a dynamic data structure that stores a map of:
+ *   (upb_MiniTable, number) -> extension info
+ *
+ * upb_decode() uses upb_ExtensionRegistry to look up extensions while parsing
+ * binary format.
+ *
+ * upb_ExtensionRegistry is part of the mini-table (msglayout) family of
+ * objects. Like all mini-table objects, it is suitable for reflection-less
+ * builds that do not want to expose names into the binary.
+ *
+ * Unlike most mini-table types, upb_ExtensionRegistry requires dynamic memory
+ * allocation and dynamic initialization:
+ * * If reflection is being used, then upb_DefPool will construct an appropriate
+ *   upb_ExtensionRegistry automatically.
+ * * For a mini-table only build, the user must manually construct the
+ *   upb_ExtensionRegistry and populate it with all of the extensions the user
+ * cares about.
+ * * A third alternative is to manually unpack relevant extensions after the
+ *   main parse is complete, similar to how Any works. This is perhaps the
+ *   nicest solution from the perspective of reducing dependencies, avoiding
+ *   dynamic memory allocation, and avoiding the need to parse uninteresting
+ *   extensions.  The downsides are:
+ *     (1) parse errors are not caught during the main parse
+ *     (2) the CPU hit of parsing comes during access, which could cause an
+ *         undesirable stutter in application performance.
+ *
+ * Users cannot directly get or put into this map. Users can only add the
+ * extensions from a generated module and pass the extension registry to the
+ * binary decoder.
+ *
+ * A upb_DefPool provides a upb_ExtensionRegistry, so any users who use
+ * reflection do not need to populate a upb_ExtensionRegistry directly.
+ */
+
+struct upb_ExtensionRegistry;
+typedef struct upb_ExtensionRegistry upb_ExtensionRegistry;
+
+/* Creates a upb_ExtensionRegistry in the given arena.  The arena must outlive
+ * any use of the extreg. */
+upb_ExtensionRegistry* upb_ExtensionRegistry_New(upb_Arena* arena);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* UPB_EXTENSION_REGISTRY_H_ */

data/third_party/upb/upb/{decode_internal.h → internal/decode.h}

@@ -30,15 +30,15 @@
  * decode.c and decode_fast.c.
  */
 
-#ifndef UPB_DECODE_INT_H_
-#define UPB_DECODE_INT_H_
+#ifndef UPB_INTERNAL_DECODE_H_
+#define UPB_INTERNAL_DECODE_H_
 
 #include <setjmp.h>
 
-#include "third_party/utf8_range/utf8_range.h"
 #include "upb/decode.h"
+#include "upb/internal/upb.h"
 #include "upb/msg_internal.h"
-#include "upb/upb_internal.h"
+#include "third_party/utf8_range/utf8_range.h"
 
 /* Must be last. */
 #include "upb/port_def.inc"
@@ -208,4 +208,4 @@ UPB_INLINE void decode_poplimit(upb_Decoder* d, const char* ptr,
 
 #include "upb/port_undef.inc"
 
-#endif /* UPB_DECODE_INT_H_ */
+#endif /* UPB_INTERNAL_DECODE_H_ */