grpc 1.53.1 → 1.54.0

data/third_party/boringssl-with-bazel/src/crypto/asn1/tasn_new.c

@@ -63,270 +63,264 @@
 #include <openssl/mem.h>
 #include <openssl/obj.h>
 
-#include "internal.h"
 #include "../internal.h"
+#include "internal.h"
 
 
-static int asn1_item_ex_combine_new(ASN1_VALUE **pval, const ASN1_ITEM *it,
-                                    int combine);
 static void asn1_item_clear(ASN1_VALUE **pval, const ASN1_ITEM *it);
 static int ASN1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
 static void asn1_template_clear(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
 static int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it);
 static void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it);
 
-ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it)
-{
-    ASN1_VALUE *ret = NULL;
-    if (ASN1_item_ex_new(&ret, it) > 0)
-        return ret;
-    return NULL;
-}
-
-/* Allocate an ASN1 structure */
-
-int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
-{
-    return asn1_item_ex_combine_new(pval, it, 0);
+ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it) {
+  ASN1_VALUE *ret = NULL;
+  if (ASN1_item_ex_new(&ret, it) > 0) {
+    return ret;
+  }
+  return NULL;
 }
 
-static int asn1_item_ex_combine_new(ASN1_VALUE **pval, const ASN1_ITEM *it,
-                                    int combine)
-{
-    const ASN1_TEMPLATE *tt = NULL;
-    const ASN1_EXTERN_FUNCS *ef;
-    ASN1_VALUE **pseqval;
-    int i;
+// Allocate an ASN1 structure
 
-    switch (it->itype) {
+int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
+  const ASN1_TEMPLATE *tt = NULL;
+  const ASN1_EXTERN_FUNCS *ef;
+  ASN1_VALUE **pseqval;
+  int i;
 
+  switch (it->itype) {
     case ASN1_ITYPE_EXTERN:
-        ef = it->funcs;
-        if (ef && ef->asn1_ex_new) {
-            if (!ef->asn1_ex_new(pval, it))
-                goto memerr;
+      ef = it->funcs;
+      if (ef && ef->asn1_ex_new) {
+        if (!ef->asn1_ex_new(pval, it)) {
+          goto memerr;
         }
-        break;
+      }
+      break;
 
     case ASN1_ITYPE_PRIMITIVE:
-        if (it->templates) {
-            if (!ASN1_template_new(pval, it->templates))
-                goto memerr;
-        } else if (!ASN1_primitive_new(pval, it))
-            goto memerr;
-        break;
+      if (it->templates) {
+        if (!ASN1_template_new(pval, it->templates)) {
+          goto memerr;
+        }
+      } else if (!ASN1_primitive_new(pval, it)) {
+        goto memerr;
+      }
+      break;
 
     case ASN1_ITYPE_MSTRING:
-        if (!ASN1_primitive_new(pval, it))
-            goto memerr;
-        break;
+      if (!ASN1_primitive_new(pval, it)) {
+        goto memerr;
+      }
+      break;
 
     case ASN1_ITYPE_CHOICE: {
-        const ASN1_AUX *aux = it->funcs;
-        ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
-        if (asn1_cb) {
-            i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
-            if (!i)
-                goto auxerr;
-            if (i == 2) {
-                return 1;
-            }
+      const ASN1_AUX *aux = it->funcs;
+      ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
+      if (asn1_cb) {
+        i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
+        if (!i) {
+          goto auxerr;
         }
-        if (!combine) {
-            *pval = OPENSSL_malloc(it->size);
-            if (!*pval)
-                goto memerr;
-            OPENSSL_memset(*pval, 0, it->size);
+        if (i == 2) {
+          return 1;
         }
-        asn1_set_choice_selector(pval, -1, it);
-        if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL))
-            goto auxerr2;
-        break;
+      }
+      *pval = OPENSSL_malloc(it->size);
+      if (!*pval) {
+        goto memerr;
+      }
+      OPENSSL_memset(*pval, 0, it->size);
+      asn1_set_choice_selector(pval, -1, it);
+      if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL)) {
+        goto auxerr2;
+      }
+      break;
     }
 
     case ASN1_ITYPE_SEQUENCE: {
-        const ASN1_AUX *aux = it->funcs;
-        ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
-        if (asn1_cb) {
-            i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
-            if (!i)
-                goto auxerr;
-            if (i == 2) {
-                return 1;
-            }
+      const ASN1_AUX *aux = it->funcs;
+      ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
+      if (asn1_cb) {
+        i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
+        if (!i) {
+          goto auxerr;
         }
-        if (!combine) {
-            *pval = OPENSSL_malloc(it->size);
-            if (!*pval)
-                goto memerr;
-            OPENSSL_memset(*pval, 0, it->size);
-            asn1_refcount_set_one(pval, it);
-            asn1_enc_init(pval, it);
+        if (i == 2) {
+          return 1;
         }
-        for (i = 0, tt = it->templates; i < it->tcount; tt++, i++) {
-            pseqval = asn1_get_field_ptr(pval, tt);
-            if (!ASN1_template_new(pseqval, tt))
-                goto memerr2;
+      }
+      *pval = OPENSSL_malloc(it->size);
+      if (!*pval) {
+        goto memerr;
+      }
+      OPENSSL_memset(*pval, 0, it->size);
+      asn1_refcount_set_one(pval, it);
+      asn1_enc_init(pval, it);
+      for (i = 0, tt = it->templates; i < it->tcount; tt++, i++) {
+        pseqval = asn1_get_field_ptr(pval, tt);
+        if (!ASN1_template_new(pseqval, tt)) {
+          goto memerr2;
         }
-        if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL))
-            goto auxerr2;
-        break;
-    }
+      }
+      if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL)) {
+        goto auxerr2;
+      }
+      break;
     }
-    return 1;
-
- memerr2:
-    asn1_item_combine_free(pval, it, combine);
- memerr:
-    OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
-    return 0;
-
- auxerr2:
-    asn1_item_combine_free(pval, it, combine);
- auxerr:
-    OPENSSL_PUT_ERROR(ASN1, ASN1_R_AUX_ERROR);
-    return 0;
-
+  }
+  return 1;
+
+memerr2:
+  ASN1_item_ex_free(pval, it);
+memerr:
+  return 0;
+
+auxerr2:
+  ASN1_item_ex_free(pval, it);
+auxerr:
+  OPENSSL_PUT_ERROR(ASN1, ASN1_R_AUX_ERROR);
+  return 0;
 }
 
-static void asn1_item_clear(ASN1_VALUE **pval, const ASN1_ITEM *it)
-{
-    const ASN1_EXTERN_FUNCS *ef;
-
-    switch (it->itype) {
+static void asn1_item_clear(ASN1_VALUE **pval, const ASN1_ITEM *it) {
+  const ASN1_EXTERN_FUNCS *ef;
 
+  switch (it->itype) {
     case ASN1_ITYPE_EXTERN:
-        ef = it->funcs;
-        if (ef && ef->asn1_ex_clear)
-            ef->asn1_ex_clear(pval, it);
-        else
-            *pval = NULL;
-        break;
+      ef = it->funcs;
+      if (ef && ef->asn1_ex_clear) {
+        ef->asn1_ex_clear(pval, it);
+      } else {
+        *pval = NULL;
+      }
+      break;
 
     case ASN1_ITYPE_PRIMITIVE:
-        if (it->templates)
-            asn1_template_clear(pval, it->templates);
-        else
-            asn1_primitive_clear(pval, it);
-        break;
+      if (it->templates) {
+        asn1_template_clear(pval, it->templates);
+      } else {
+        asn1_primitive_clear(pval, it);
+      }
+      break;
 
     case ASN1_ITYPE_MSTRING:
-        asn1_primitive_clear(pval, it);
-        break;
+      asn1_primitive_clear(pval, it);
+      break;
 
     case ASN1_ITYPE_CHOICE:
     case ASN1_ITYPE_SEQUENCE:
-        *pval = NULL;
-        break;
-    }
+      *pval = NULL;
+      break;
+  }
 }
 
-static int ASN1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt)
-{
-    const ASN1_ITEM *it = ASN1_ITEM_ptr(tt->item);
-    int ret;
-    if (tt->flags & ASN1_TFLG_OPTIONAL) {
-        asn1_template_clear(pval, tt);
-        return 1;
-    }
-    /* If ANY DEFINED BY nothing to do */
+static int ASN1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt) {
+  const ASN1_ITEM *it = ASN1_ITEM_ptr(tt->item);
+  int ret;
+  if (tt->flags & ASN1_TFLG_OPTIONAL) {
+    asn1_template_clear(pval, tt);
+    return 1;
+  }
+  // If ANY DEFINED BY nothing to do
 
-    if (tt->flags & ASN1_TFLG_ADB_MASK) {
-        *pval = NULL;
-        return 1;
-    }
-    /* If SET OF or SEQUENCE OF, its a STACK */
-    if (tt->flags & ASN1_TFLG_SK_MASK) {
-        STACK_OF(ASN1_VALUE) *skval;
-        skval = sk_ASN1_VALUE_new_null();
-        if (!skval) {
-            OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
-            ret = 0;
-            goto done;
-        }
-        *pval = (ASN1_VALUE *)skval;
-        ret = 1;
-        goto done;
+  if (tt->flags & ASN1_TFLG_ADB_MASK) {
+    *pval = NULL;
+    return 1;
+  }
+  // If SET OF or SEQUENCE OF, its a STACK
+  if (tt->flags & ASN1_TFLG_SK_MASK) {
+    STACK_OF(ASN1_VALUE) *skval;
+    skval = sk_ASN1_VALUE_new_null();
+    if (!skval) {
+      ret = 0;
+      goto done;
     }
-    /* Otherwise pass it back to the item routine */
-    ret = asn1_item_ex_combine_new(pval, it, tt->flags & ASN1_TFLG_COMBINE);
- done:
-    return ret;
+    *pval = (ASN1_VALUE *)skval;
+    ret = 1;
+    goto done;
+  }
+  // Otherwise pass it back to the item routine
+  ret = ASN1_item_ex_new(pval, it);
+done:
+  return ret;
 }
 
-static void asn1_template_clear(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt)
-{
-    /* If ADB or STACK just NULL the field */
-    if (tt->flags & (ASN1_TFLG_ADB_MASK | ASN1_TFLG_SK_MASK))
-        *pval = NULL;
-    else
-        asn1_item_clear(pval, ASN1_ITEM_ptr(tt->item));
+static void asn1_template_clear(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt) {
+  // If ADB or STACK just NULL the field
+  if (tt->flags & (ASN1_TFLG_ADB_MASK | ASN1_TFLG_SK_MASK)) {
+    *pval = NULL;
+  } else {
+    asn1_item_clear(pval, ASN1_ITEM_ptr(tt->item));
+  }
 }
 
-/*
- * NB: could probably combine most of the real XXX_new() behaviour and junk
- * all the old functions.
- */
-
-static int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
-{
-    ASN1_TYPE *typ;
-    int utype;
-
-    if (!it)
-        return 0;
-
-    /* Historically, |it->funcs| for primitive types contained an
-     * |ASN1_PRIMITIVE_FUNCS| table of calbacks. */
-    assert(it->funcs == NULL);
+// NB: could probably combine most of the real XXX_new() behaviour and junk
+// all the old functions.
 
-    if (it->itype == ASN1_ITYPE_MSTRING)
-        utype = -1;
-    else
-        utype = it->utype;
-    switch (utype) {
+static int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
+  if (!it) {
+    return 0;
+  }
+
+  // Historically, |it->funcs| for primitive types contained an
+  // |ASN1_PRIMITIVE_FUNCS| table of calbacks.
+  assert(it->funcs == NULL);
+
+  int utype;
+  if (it->itype == ASN1_ITYPE_MSTRING) {
+    utype = -1;
+  } else {
+    utype = it->utype;
+  }
+  switch (utype) {
     case V_ASN1_OBJECT:
-        *pval = (ASN1_VALUE *)OBJ_nid2obj(NID_undef);
-        return 1;
+      *pval = (ASN1_VALUE *)OBJ_nid2obj(NID_undef);
+      return 1;
 
     case V_ASN1_BOOLEAN:
-        *(ASN1_BOOLEAN *)pval = it->size;
-        return 1;
+      *(ASN1_BOOLEAN *)pval = (ASN1_BOOLEAN)it->size;
+      return 1;
 
     case V_ASN1_NULL:
-        *pval = (ASN1_VALUE *)1;
-        return 1;
-
-    case V_ASN1_ANY:
-        typ = OPENSSL_malloc(sizeof(ASN1_TYPE));
-        if (!typ)
-            return 0;
-        typ->value.ptr = NULL;
-        typ->type = -1;
-        *pval = (ASN1_VALUE *)typ;
-        break;
+      *pval = (ASN1_VALUE *)1;
+      return 1;
 
-    default:
-        *pval = (ASN1_VALUE *)ASN1_STRING_type_new(utype);
-        break;
+    case V_ASN1_ANY: {
+      ASN1_TYPE *typ = OPENSSL_malloc(sizeof(ASN1_TYPE));
+      if (!typ) {
+        return 0;
+      }
+      typ->value.ptr = NULL;
+      typ->type = -1;
+      *pval = (ASN1_VALUE *)typ;
+      break;
     }
-    if (*pval)
-        return 1;
-    return 0;
+
+    default:
+      *pval = (ASN1_VALUE *)ASN1_STRING_type_new(utype);
+      break;
+  }
+  if (*pval) {
+    return 1;
+  }
+  return 0;
 }
 
-static void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it)
-{
-    int utype;
-    /* Historically, |it->funcs| for primitive types contained an
-     * |ASN1_PRIMITIVE_FUNCS| table of calbacks. */
-    assert(it == NULL || it->funcs == NULL);
-    if (!it || (it->itype == ASN1_ITYPE_MSTRING))
-        utype = -1;
-    else
-        utype = it->utype;
-    if (utype == V_ASN1_BOOLEAN)
-        *(ASN1_BOOLEAN *)pval = it->size;
-    else
-        *pval = NULL;
+static void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it) {
+  int utype;
+  // Historically, |it->funcs| for primitive types contained an
+  // |ASN1_PRIMITIVE_FUNCS| table of calbacks.
+  assert(it == NULL || it->funcs == NULL);
+  if (!it || (it->itype == ASN1_ITYPE_MSTRING)) {
+    utype = -1;
+  } else {
+    utype = it->utype;
+  }
+  if (utype == V_ASN1_BOOLEAN) {
+    *(ASN1_BOOLEAN *)pval = (ASN1_BOOLEAN)it->size;
+  } else {
+    *pval = NULL;
+  }
 }

data/third_party/boringssl-with-bazel/src/crypto/asn1/tasn_typ.c

@@ -58,19 +58,13 @@
 
 #include <openssl/asn1t.h>
 
-/* Declarations for string types */
-
-#define IMPLEMENT_ASN1_STRING_FUNCTIONS(sname) \
-        IMPLEMENT_ASN1_TYPE(sname) \
-        IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(sname, sname, sname) \
-        sname *sname##_new(void) \
-        { \
-                return ASN1_STRING_type_new(V_##sname); \
-        } \
-        void sname##_free(sname *x) \
-        { \
-                ASN1_STRING_free(x); \
-        }
+// Declarations for string types
+
+#define IMPLEMENT_ASN1_STRING_FUNCTIONS(sname)                         \
+  IMPLEMENT_ASN1_TYPE(sname)                                           \
+  IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(sname, sname, sname)     \
+  sname *sname##_new(void) { return ASN1_STRING_type_new(V_##sname); } \
+  void sname##_free(sname *x) { ASN1_STRING_free(x); }
 
 IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_OCTET_STRING)
 IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_INTEGER)
@@ -94,12 +88,12 @@ IMPLEMENT_ASN1_TYPE(ASN1_OBJECT)
 
 IMPLEMENT_ASN1_TYPE(ASN1_ANY)
 
-/* Just swallow an ASN1_SEQUENCE in an ASN1_STRING */
+// Just swallow an ASN1_SEQUENCE in an ASN1_STRING
 IMPLEMENT_ASN1_TYPE(ASN1_SEQUENCE)
 
 IMPLEMENT_ASN1_FUNCTIONS_const_fname(ASN1_TYPE, ASN1_ANY, ASN1_TYPE)
 
-/* Multistring types */
+// Multistring types
 
 IMPLEMENT_ASN1_MSTRING(ASN1_PRINTABLE, B_ASN1_PRINTABLE)
 IMPLEMENT_ASN1_FUNCTIONS_const_fname(ASN1_STRING, ASN1_PRINTABLE,
@@ -112,20 +106,21 @@ IMPLEMENT_ASN1_MSTRING(DIRECTORYSTRING, B_ASN1_DIRECTORYSTRING)
 IMPLEMENT_ASN1_FUNCTIONS_const_fname(ASN1_STRING, DIRECTORYSTRING,
                                      DIRECTORYSTRING)
 
-/* Three separate BOOLEAN type: normal, DEFAULT TRUE and DEFAULT FALSE */
-IMPLEMENT_ASN1_TYPE_ex(ASN1_BOOLEAN, ASN1_BOOLEAN, -1)
-IMPLEMENT_ASN1_TYPE_ex(ASN1_TBOOLEAN, ASN1_BOOLEAN, 1)
-IMPLEMENT_ASN1_TYPE_ex(ASN1_FBOOLEAN, ASN1_BOOLEAN, 0)
-
-/* Special, OCTET STRING with indefinite length constructed support */
+// Three separate BOOLEAN type: normal, DEFAULT TRUE and DEFAULT FALSE
+IMPLEMENT_ASN1_TYPE_ex(ASN1_BOOLEAN, ASN1_BOOLEAN, ASN1_BOOLEAN_NONE)
+IMPLEMENT_ASN1_TYPE_ex(ASN1_TBOOLEAN, ASN1_BOOLEAN, ASN1_BOOLEAN_TRUE)
+IMPLEMENT_ASN1_TYPE_ex(ASN1_FBOOLEAN, ASN1_BOOLEAN, ASN1_BOOLEAN_FALSE)
 
 ASN1_ITEM_TEMPLATE(ASN1_SEQUENCE_ANY) =
-        ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, ASN1_SEQUENCE_ANY, ASN1_ANY)
+    ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, ASN1_SEQUENCE_ANY, ASN1_ANY)
 ASN1_ITEM_TEMPLATE_END(ASN1_SEQUENCE_ANY)
 
-ASN1_ITEM_TEMPLATE(ASN1_SET_ANY) =
-        ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SET_OF, 0, ASN1_SET_ANY, ASN1_ANY)
+ASN1_ITEM_TEMPLATE(ASN1_SET_ANY) = ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SET_OF, 0,
+                                                         ASN1_SET_ANY, ASN1_ANY)
 ASN1_ITEM_TEMPLATE_END(ASN1_SET_ANY)
 
-IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(ASN1_SEQUENCE_ANY, ASN1_SEQUENCE_ANY, ASN1_SEQUENCE_ANY)
-IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(ASN1_SEQUENCE_ANY, ASN1_SET_ANY, ASN1_SET_ANY)
+IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(ASN1_SEQUENCE_ANY,
+                                            ASN1_SEQUENCE_ANY,
+                                            ASN1_SEQUENCE_ANY)
+IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(ASN1_SEQUENCE_ANY, ASN1_SET_ANY,
+                                            ASN1_SET_ANY)