Run convert_comments.go on the recently-converted files

This CL is the result of the following commands:

    for d in asn1 x509 x509v3 pem; do
      go run util/convert_comments.go crypto/$d/*.h
      go run util/convert_comments.go crypto/$d/*.c
    done

Change-Id: If78433f68cb2f913b0de06ded744a5a65540e1cf
Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/53087
Reviewed-by: Bob Beck <[email protected]>
Commit-Queue: Bob Beck <[email protected]>
(cherry picked from commit 46350487c1983268ac77ca9d63c34dc60b721058)

Author: davidben

crypto/asn1/a_bitstr.c

@@ -164,19 +164,17 @@ ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a,
     goto err;
   }
 
-  /* Unused bits in a BIT STRING must be zero. */
+  // Unused bits in a BIT STRING must be zero.
   uint8_t padding_mask = (1 << padding) - 1;
   if (padding != 0 && (len < 1 || (p[len - 1] & padding_mask) != 0)) {
     OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_BIT_STRING_PADDING);
     goto err;
   }
 
-  /*
-   * We do this to preserve the settings.  If we modify the settings, via
-   * the _set_bit function, we will recalculate on output
-   */
-  ret->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);   /* clear */
-  ret->flags |= (ASN1_STRING_FLAG_BITS_LEFT | padding); /* set */
+  // We do this to preserve the settings.  If we modify the settings, via
+  // the _set_bit function, we will recalculate on output
+  ret->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);    // clear
+  ret->flags |= (ASN1_STRING_FLAG_BITS_LEFT | padding);  // set
 
   if (len > 0) {
     s = OPENSSL_memdup(p, len);
@@ -205,9 +203,7 @@ ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a,
   return (NULL);
 }
 
-/*
- * These next 2 functions from Goetz Babin-Ebell <[email protected]>
- */
+// These next 2 functions from Goetz Babin-Ebell <[email protected]>
 int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value) {
   int w, v, iv;
   unsigned char *c;
@@ -223,11 +219,11 @@ int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value) {
     return 0;
   }
 
-  a->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07); /* clear, set on write */
+  a->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);  // clear, set on write
 
   if ((a->length < (w + 1)) || (a->data == NULL)) {
     if (!value) {
-      return (1); /* Don't need to set */
+      return (1);  // Don't need to set
     }
     if (a->data == NULL) {
       c = (unsigned char *)OPENSSL_malloc(w + 1);
@@ -262,27 +258,23 @@ int ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n) {
   return ((a->data[w] & v) != 0);
 }
 
-/*
- * Checks if the given bit string contains only bits specified by
- * the flags vector. Returns 0 if there is at least one bit set in 'a'
- * which is not specified in 'flags', 1 otherwise.
- * 'len' is the length of 'flags'.
- */
+// Checks if the given bit string contains only bits specified by
+// the flags vector. Returns 0 if there is at least one bit set in 'a'
+// which is not specified in 'flags', 1 otherwise.
+// 'len' is the length of 'flags'.
 int ASN1_BIT_STRING_check(const ASN1_BIT_STRING *a, const unsigned char *flags,
                           int flags_len) {
   int i, ok;
-  /* Check if there is one bit set at all. */
+  // Check if there is one bit set at all.
   if (!a || !a->data) {
     return 1;
   }
 
-  /*
-   * Check each byte of the internal representation of the bit string.
-   */
+  // Check each byte of the internal representation of the bit string.
   ok = 1;
   for (i = 0; i < a->length && ok; ++i) {
     unsigned char mask = i < flags_len ? ~flags[i] : 0xff;
-    /* We are done if there is an unneeded bit set. */
+    // We are done if there is an unneeded bit set.
     ok = (a->data[i] & mask) == 0;
   }
   return ok;

crypto/asn1/a_bool.c

@@ -80,10 +80,8 @@ int i2d_ASN1_BOOLEAN(ASN1_BOOLEAN a, unsigned char **pp) {
   ASN1_put_object(&p, 0, 1, V_ASN1_BOOLEAN, V_ASN1_UNIVERSAL);
   *p = a ? 0xff : 0x00;
 
-  /*
-   * If a new buffer was allocated, just return it back.
-   * If not, return the incremented buffer pointer.
-   */
+  // If a new buffer was allocated, just return it back.
+  // If not, return the incremented buffer pointer.
   *pp = allocated != NULL ? allocated : p + 1;
   return r;
 }

crypto/asn1/a_dup.c

@@ -59,12 +59,10 @@
 #include <openssl/err.h>
 #include <openssl/mem.h>
 
-/*
- * ASN1_ITEM version of dup: this follows the model above except we don't
- * need to allocate the buffer. At some point this could be rewritten to
- * directly dup the underlying structure instead of doing and encode and
- * decode.
- */
+// ASN1_ITEM version of dup: this follows the model above except we don't
+// need to allocate the buffer. At some point this could be rewritten to
+// directly dup the underlying structure instead of doing and encode and
+// decode.
 void *ASN1_item_dup(const ASN1_ITEM *it, void *x) {
   unsigned char *b = NULL;
   const unsigned char *p;

crypto/asn1/a_int.c

@@ -72,16 +72,16 @@ ASN1_INTEGER *ASN1_INTEGER_dup(const ASN1_INTEGER *x) {
 }
 
 int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y) {
-  /* Compare signs. */
+  // Compare signs.
   int neg = x->type & V_ASN1_NEG;
   if (neg != (y->type & V_ASN1_NEG)) {
     return neg ? -1 : 1;
   }
 
   int ret = ASN1_STRING_cmp(x, y);
   if (neg) {
-    /* This could be |-ret|, but |ASN1_STRING_cmp| is not forbidden from
-     * returning |INT_MIN|. */
+    // This could be |-ret|, but |ASN1_STRING_cmp| is not forbidden from
+    // returning |INT_MIN|.
     if (ret < 0) {
       return 1;
     } else if (ret > 0) {
@@ -94,8 +94,8 @@ int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y) {
   return ret;
 }
 
-/* negate_twos_complement negates |len| bytes from |buf| in-place, interpreted
- * as a signed, big-endian two's complement value. */
+// negate_twos_complement negates |len| bytes from |buf| in-place, interpreted
+// as a signed, big-endian two's complement value.
 static void negate_twos_complement(uint8_t *buf, size_t len) {
   uint8_t borrow = 0;
   for (size_t i = len - 1; i < len; i--) {
@@ -119,9 +119,9 @@ int i2c_ASN1_INTEGER(const ASN1_INTEGER *in, unsigned char **outp) {
     return 0;
   }
 
-  /* |ASN1_INTEGER|s should be represented minimally, but it is possible to
-   * construct invalid ones. Skip leading zeros so this does not produce an
-   * invalid encoding or break invariants. */
+  // |ASN1_INTEGER|s should be represented minimally, but it is possible to
+  // construct invalid ones. Skip leading zeros so this does not produce an
+  // invalid encoding or break invariants.
   int start = 0;
   while (start < in->length && in->data[start] == 0) {
     start++;
@@ -130,20 +130,20 @@ int i2c_ASN1_INTEGER(const ASN1_INTEGER *in, unsigned char **outp) {
   int is_negative = (in->type & V_ASN1_NEG) != 0;
   int pad;
   if (start >= in->length) {
-    /* Zero is represented as a single byte. */
+    // Zero is represented as a single byte.
     is_negative = 0;
     pad = 1;
   } else if (is_negative) {
-    /* 0x80...01 through 0xff...ff have a two's complement of 0x7f...ff
-     * through 0x00...01 and need an extra byte to be negative.
-     * 0x01...00 through 0x80...00 have a two's complement of 0xfe...ff
-     * through 0x80...00 and can be negated as-is. */
+    // 0x80...01 through 0xff...ff have a two's complement of 0x7f...ff
+    // through 0x00...01 and need an extra byte to be negative.
+    // 0x01...00 through 0x80...00 have a two's complement of 0xfe...ff
+    // through 0x80...00 and can be negated as-is.
     pad = in->data[start] > 0x80 ||
           (in->data[start] == 0x80 &&
            !is_all_zeros(in->data + start + 1, in->length - start - 1));
   } else {
-    /* If the high bit is set, the signed representation needs an extra
-     * byte to be positive. */
+    // If the high bit is set, the signed representation needs an extra
+    // byte to be positive.
     pad = (in->data[start] & 0x80) != 0;
   }
 
@@ -173,11 +173,9 @@ int i2c_ASN1_INTEGER(const ASN1_INTEGER *in, unsigned char **outp) {
 
 ASN1_INTEGER *c2i_ASN1_INTEGER(ASN1_INTEGER **out, const unsigned char **inp,
                                long len) {
-  /*
-   * This function can handle lengths up to INT_MAX - 1, but the rest of the
-   * legacy ASN.1 code mixes integer types, so avoid exposing it to
-   * ASN1_INTEGERS with larger lengths.
-   */
+  // This function can handle lengths up to INT_MAX - 1, but the rest of the
+  // legacy ASN.1 code mixes integer types, so avoid exposing it to
+  // ASN1_INTEGERS with larger lengths.
   if (len < 0 || len > INT_MAX / 2) {
     OPENSSL_PUT_ERROR(ASN1, ASN1_R_TOO_LONG);
     return NULL;
@@ -201,19 +199,19 @@ ASN1_INTEGER *c2i_ASN1_INTEGER(ASN1_INTEGER **out, const unsigned char **inp,
     ret = *out;
   }
 
-  /* Convert to |ASN1_INTEGER|'s sign-and-magnitude representation. First,
-   * determine the size needed for a minimal result. */
+  // Convert to |ASN1_INTEGER|'s sign-and-magnitude representation. First,
+  // determine the size needed for a minimal result.
   if (is_negative) {
-    /* 0xff00...01 through 0xff7f..ff have a two's complement of 0x00ff...ff
-     * through 0x000100...001 and need one leading zero removed. 0x8000...00
-     * through 0xff00...00 have a two's complement of 0x8000...00 through
-     * 0x0100...00 and will be minimally-encoded as-is. */
+    // 0xff00...01 through 0xff7f..ff have a two's complement of 0x00ff...ff
+    // through 0x000100...001 and need one leading zero removed. 0x8000...00
+    // through 0xff00...00 have a two's complement of 0x8000...00 through
+    // 0x0100...00 and will be minimally-encoded as-is.
     if (CBS_len(&cbs) > 0 && CBS_data(&cbs)[0] == 0xff &&
         !is_all_zeros(CBS_data(&cbs) + 1, CBS_len(&cbs) - 1)) {
       CBS_skip(&cbs, 1);
     }
   } else {
-    /* Remove the leading zero byte, if any. */
+    // Remove the leading zero byte, if any.
     if (CBS_len(&cbs) > 0 && CBS_data(&cbs)[0] == 0x00) {
       CBS_skip(&cbs, 1);
     }
@@ -230,9 +228,9 @@ ASN1_INTEGER *c2i_ASN1_INTEGER(ASN1_INTEGER **out, const unsigned char **inp,
     ret->type = V_ASN1_INTEGER;
   }
 
-  /* The value should be minimally-encoded. */
+  // The value should be minimally-encoded.
   assert(ret->length == 0 || ret->data[0] != 0);
-  /* Zero is not negative. */
+  // Zero is not negative.
   assert(!is_negative || ret->length > 0);
 
   *inp += len;
@@ -347,7 +345,7 @@ static long asn1_string_get_long(const ASN1_STRING *a, int type) {
 
   int64_t i64;
   int fits_in_i64;
-  /* Check |v != 0| to handle manually-constructed negative zeros. */
+  // Check |v != 0| to handle manually-constructed negative zeros.
   if ((a->type & V_ASN1_NEG) && v != 0) {
     i64 = (int64_t)(0u - v);
     fits_in_i64 = i64 < 0;
@@ -362,7 +360,7 @@ static long asn1_string_get_long(const ASN1_STRING *a, int type) {
   }
 
 err:
-  /* This function's return value does not distinguish overflow from -1. */
+  // This function's return value does not distinguish overflow from -1.
   ERR_clear_error();
   return -1;
 }

crypto/asn1/a_mbstr.c

@@ -66,14 +66,12 @@
 #include "../bytestring/internal.h"
 #include "internal.h"
 
-/*
- * These functions take a string in UTF8, ASCII or multibyte form and a mask
- * of permissible ASN1 string types. It then works out the minimal type
- * (using the order Printable < IA5 < T61 < BMP < Universal < UTF8) and
- * creates a string of the correct type with the supplied data. Yes this is
- * horrible: it has to be :-( The 'ncopy' form checks minimum and maximum
- * size limits too.
- */
+// These functions take a string in UTF8, ASCII or multibyte form and a mask
+// of permissible ASN1 string types. It then works out the minimal type
+// (using the order Printable < IA5 < T61 < BMP < Universal < UTF8) and
+// creates a string of the correct type with the supplied data. Yes this is
+// horrible: it has to be :-( The 'ncopy' form checks minimum and maximum
+// size limits too.
 
 int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len,
                        int inform, unsigned long mask) {
@@ -127,7 +125,7 @@ int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
       return -1;
   }
 
-  /* Check |minsize| and |maxsize| and work out the minimal type, if any. */
+  // Check |minsize| and |maxsize| and work out the minimal type, if any.
   CBS cbs;
   CBS_init(&cbs, in, len);
   size_t utf8_len = 0;
@@ -139,17 +137,17 @@ int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
     }
     if (nchar == 0 && (inform == MBSTRING_BMP || inform == MBSTRING_UNIV) &&
         c == 0xfeff) {
-      /* Reject byte-order mark. We could drop it but that would mean
-       * adding ambiguity around whether a BOM was included or not when
-       * matching strings.
-       *
-       * For a little-endian UCS-2 string, the BOM will appear as 0xfffe
-       * and will be rejected as noncharacter, below. */
+      // Reject byte-order mark. We could drop it but that would mean
+      // adding ambiguity around whether a BOM was included or not when
+      // matching strings.
+      //
+      // For a little-endian UCS-2 string, the BOM will appear as 0xfffe
+      // and will be rejected as noncharacter, below.
       OPENSSL_PUT_ERROR(ASN1, ASN1_R_ILLEGAL_CHARACTERS);
       return -1;
     }
 
-    /* Update which output formats are still possible. */
+    // Update which output formats are still possible.
     if ((mask & B_ASN1_PRINTABLESTRING) && !asn1_is_printable(c)) {
       mask &= ~B_ASN1_PRINTABLESTRING;
     }
@@ -185,7 +183,7 @@ int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
     return -1;
   }
 
-  /* Now work out output format and string type */
+  // Now work out output format and string type
   int (*encode_func)(CBB *, uint32_t) = cbb_add_latin1;
   size_t size_estimate = nchar;
   int outform = MBSTRING_ASC;
@@ -237,7 +235,7 @@ int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
     *out = dest;
   }
 
-  /* If both the same type just copy across */
+  // If both the same type just copy across
   if (inform == outform) {
     if (!ASN1_STRING_set(dest, in, len)) {
       OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
@@ -261,8 +259,8 @@ int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
   }
   uint8_t *data = NULL;
   size_t data_len;
-  if (/* OpenSSL historically NUL-terminated this value with a single byte,
-       * even for |MBSTRING_BMP| and |MBSTRING_UNIV|. */
+  if (// OpenSSL historically NUL-terminated this value with a single byte,
+      // even for |MBSTRING_BMP| and |MBSTRING_UNIV|.
       !CBB_add_u8(&cbb, 0) || !CBB_finish(&cbb, &data, &data_len) ||
       data_len < 1 || data_len > INT_MAX) {
     OPENSSL_PUT_ERROR(ASN1, ERR_R_INTERNAL_ERROR);
@@ -285,7 +283,7 @@ int asn1_is_printable(uint32_t value) {
   if (value > 0x7f) {
     return 0;
   }
-  /* Note we cannot use |isalnum| because it is locale-dependent. */
+  // Note we cannot use |isalnum| because it is locale-dependent.
   return ('a' <= value && value <= 'z') ||  //
          ('A' <= value && value <= 'Z') ||  //
          ('0' <= value && value <= '9') ||  //