@fails-components/webtransport 0.0.1 → 0.0.2

package/third_party/boringssl/src/crypto/asn1/tasn_new.c

@@ -63,8 +63,8 @@
 #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,
@@ -75,258 +75,266 @@ 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;
+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 */
+// 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);
+int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
+  return asn1_item_ex_combine_new(pval, it, 0);
 }
 
 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;
-
-    switch (it->itype) {
+                                    int combine) {
+  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;
+      }
+      if (!combine) {
+        *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;
+      }
+      if (!combine) {
+        *pval = OPENSSL_malloc(it->size);
+        if (!*pval) {
+          goto memerr;
         }
-        if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL))
-            goto auxerr2;
-        break;
-    }
+        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;
     }
-    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_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;
 }
 
-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) {
+      OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
+      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_combine_new(pval, it, tt->flags & ASN1_TFLG_COMBINE);
+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.
- */
+// 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;
+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);
-
-    if (it->itype == ASN1_ITYPE_MSTRING)
-        utype = -1;
-    else
-        utype = it->utype;
-    switch (utype) {
+  if (!it) {
+    return 0;
+  }
+
+  // Historically, |it->funcs| for primitive types contained an
+  // |ASN1_PRIMITIVE_FUNCS| table of calbacks.
+  assert(it->funcs == NULL);
+
+  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 = it->size;
+      return 1;
 
     case V_ASN1_NULL:
-        *pval = (ASN1_VALUE *)1;
-        return 1;
+      *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;
+      typ = OPENSSL_malloc(sizeof(ASN1_TYPE));
+      if (!typ) {
+        return 0;
+      }
+      typ->value.ptr = NULL;
+      typ->type = -1;
+      *pval = (ASN1_VALUE *)typ;
+      break;
 
     default:
-        *pval = (ASN1_VALUE *)ASN1_STRING_type_new(utype);
-        break;
-    }
-    if (*pval)
-        return 1;
-    return 0;
+      *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 = it->size;
+  } else {
+    *pval = NULL;
+  }
 }

package/third_party/boringssl/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,23 @@ 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 */
+// 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 */
+// Special, OCTET STRING with indefinite length constructed support
 
 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)

package/third_party/boringssl/src/crypto/asn1/tasn_utl.c

@@ -60,27 +60,27 @@
 #include <string.h>
 
 #include <openssl/asn1t.h>
+#include <openssl/err.h>
 #include <openssl/mem.h>
 #include <openssl/obj.h>
-#include <openssl/err.h>
 #include <openssl/thread.h>
 
 #include "../internal.h"
 #include "internal.h"
 
 
-/* Utility functions for manipulating fields and offsets */
+// Utility functions for manipulating fields and offsets
 
-/* Add 'offset' to 'addr' */
+// Add 'offset' to 'addr'
 #define offset2ptr(addr, offset) (void *)(((char *)(addr)) + (offset))
 
-/* Given an ASN1_ITEM CHOICE type return the selector value */
+// Given an ASN1_ITEM CHOICE type return the selector value
 int asn1_get_choice_selector(ASN1_VALUE **pval, const ASN1_ITEM *it) {
   int *sel = offset2ptr(*pval, it->utype);
   return *sel;
 }
 
-/* Given an ASN1_ITEM CHOICE type set the selector value, return old value. */
+// Given an ASN1_ITEM CHOICE type set the selector value, return old value.
 int asn1_set_choice_selector(ASN1_VALUE **pval, int value,
                              const ASN1_ITEM *it) {
   int *sel, ret;
@@ -173,7 +173,7 @@ int asn1_enc_save(ASN1_VALUE **pval, const unsigned char *in, int inlen,
   enc->alias_only_on_next_parse = 0;
 
   if (enc->alias_only) {
-    enc->enc = (uint8_t *) in;
+    enc->enc = (uint8_t *)in;
   } else {
     enc->enc = OPENSSL_malloc(inlen);
     if (!enc->enc) {
@@ -205,20 +205,20 @@ int asn1_enc_restore(int *len, unsigned char **out, ASN1_VALUE **pval,
   return 1;
 }
 
-/* Given an ASN1_TEMPLATE get a pointer to a field */
+// Given an ASN1_TEMPLATE get a pointer to a field
 ASN1_VALUE **asn1_get_field_ptr(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt) {
   ASN1_VALUE **pvaltmp;
   if (tt->flags & ASN1_TFLG_COMBINE) {
     return pval;
   }
   pvaltmp = offset2ptr(*pval, tt->offset);
-  /* NOTE for BOOLEAN types the field is just a plain int so we can't return
-   * int **, so settle for (int *). */
+  // NOTE for BOOLEAN types the field is just a plain int so we can't return
+  // int **, so settle for (int *).
   return pvaltmp;
 }
 
-/* Handle ANY DEFINED BY template, find the selector, look up the relevant
- * ASN1_TEMPLATE in the table and return it. */
+// Handle ANY DEFINED BY template, find the selector, look up the relevant
+// ASN1_TEMPLATE in the table and return it.
 const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt,
                                  int nullerr) {
   const ASN1_ADB *adb;
@@ -229,13 +229,13 @@ const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt,
     return tt;
   }
 
-  /* Else ANY DEFINED BY ... get the table */
+  // Else ANY DEFINED BY ... get the table
   adb = ASN1_ADB_ptr(tt->item);
 
-  /* Get the selector field */
+  // Get the selector field
   sfld = offset2ptr(*pval, adb->offset);
 
-  /* Check if NULL */
+  // Check if NULL
   if (*sfld == NULL) {
     if (!adb->null_tt) {
       goto err;
@@ -243,16 +243,16 @@ const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt,
     return adb->null_tt;
   }
 
-  /* Convert type to a NID:
-   * NB: don't check for NID_undef here because it
-   * might be a legitimate value in the table */
+  // Convert type to a NID:
+  // NB: don't check for NID_undef here because it
+  // might be a legitimate value in the table
   assert(tt->flags & ASN1_TFLG_ADB_OID);
   int selector = OBJ_obj2nid((ASN1_OBJECT *)*sfld);
 
-  /* Try to find matching entry in table Maybe should check application types
-   * first to allow application override? Might also be useful to have a flag
-   * which indicates table is sorted and we can do a binary search. For now
-   * stick to a linear search. */
+  // Try to find matching entry in table Maybe should check application types
+  // first to allow application override? Might also be useful to have a flag
+  // which indicates table is sorted and we can do a binary search. For now
+  // stick to a linear search.
 
   for (atbl = adb->tbl, i = 0; i < adb->tblcount; i++, atbl++) {
     if (atbl->value == selector) {
@@ -260,16 +260,16 @@ const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt,
     }
   }
 
-  /* FIXME: need to search application table too */
+  // FIXME: need to search application table too
 
-  /* No match, return default type */
+  // No match, return default type
   if (!adb->default_tt) {
     goto err;
   }
   return adb->default_tt;
 
 err:
-  /* FIXME: should log the value or OID of unsupported type */
+  // FIXME: should log the value or OID of unsupported type
   if (nullerr) {
     OPENSSL_PUT_ERROR(ASN1, ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE);
   }