grpc 1.9.1 → 1.10.0.pre1

data/third_party/boringssl/include/openssl/ex_data.h

@@ -118,87 +118,77 @@ extern "C" {
 #endif
 
 
-/* ex_data is a mechanism for associating arbitrary extra data with objects.
- * For each type of object that supports ex_data, different users can be
- * assigned indexes in which to store their data. Each index has callback
- * functions that are called when an object of that type is freed or
- * duplicated. */
+// ex_data is a mechanism for associating arbitrary extra data with objects.
+// For each type of object that supports ex_data, different users can be
+// assigned indexes in which to store their data. Each index has callback
+// functions that are called when an object of that type is freed or
+// duplicated.
 
 
 typedef struct crypto_ex_data_st CRYPTO_EX_DATA;
 
 
-/* Type-specific functions.
- *
- * Each type that supports ex_data provides three functions: */
+// Type-specific functions.
+//
+// Each type that supports ex_data provides three functions:
 
-#if 0 /* Sample */
+#if 0  // Sample
 
-/* TYPE_get_ex_new_index allocates a new index for |TYPE|. See the
- * descriptions of the callback typedefs for details of when they are
- * called. Any of the callback arguments may be NULL. The |argl| and |argp|
- * arguments are opaque values that are passed to the callbacks. It returns the
- * new index or a negative number on error.
- *
- * TODO(fork): this should follow the standard calling convention. */
+// TYPE_get_ex_new_index allocates a new index for |TYPE|. An optional
+// |free_func| argument may be provided which is called when the owning object
+// is destroyed. See |CRYPTO_EX_free| for details. The |argl| and |argp|
+// arguments are opaque values that are passed to the callback. It returns the
+// new index or a negative number on error.
 OPENSSL_EXPORT int TYPE_get_ex_new_index(long argl, void *argp,
                                          CRYPTO_EX_unused *unused,
-                                         CRYPTO_EX_dup *dup_func,
+                                         CRYPTO_EX_dup *dup_unused,
                                          CRYPTO_EX_free *free_func);
 
-/* TYPE_set_ex_data sets an extra data pointer on |t|. The |index| argument
- * should have been returned from a previous call to |TYPE_get_ex_new_index|. */
+// TYPE_set_ex_data sets an extra data pointer on |t|. The |index| argument
+// should have been returned from a previous call to |TYPE_get_ex_new_index|.
 OPENSSL_EXPORT int TYPE_set_ex_data(TYPE *t, int index, void *arg);
 
-/* TYPE_get_ex_data returns an extra data pointer for |t|, or NULL if no such
- * pointer exists. The |index| argument should have been returned from a
- * previous call to |TYPE_get_ex_new_index|. */
+// TYPE_get_ex_data returns an extra data pointer for |t|, or NULL if no such
+// pointer exists. The |index| argument should have been returned from a
+// previous call to |TYPE_get_ex_new_index|.
 OPENSSL_EXPORT void *TYPE_get_ex_data(const TYPE *t, int index);
 
-#endif /* Sample */
+#endif  // Sample
 
 
-/* Callback types. */
+// Callback types.
 
-/* CRYPTO_EX_free is a callback function that is called when an object of the
- * class with extra data pointers is being destroyed. For example, if this
- * callback has been passed to |SSL_get_ex_new_index| then it may be called each
- * time an |SSL*| is destroyed.
- *
- * The callback is passed the new object (i.e. the |SSL*|) in |parent|. The
- * arguments |argl| and |argp| contain opaque values that were given to
- * |CRYPTO_get_ex_new_index|. The callback should return one on success, but
- * the value is ignored.
- *
- * This callback may be called with a NULL value for |ptr| if |parent| has no
- * value set for this index. However, the callbacks may also be skipped entirely
- * if no extra data pointers are set on |parent| at all. */
+// CRYPTO_EX_free is a callback function that is called when an object of the
+// class with extra data pointers is being destroyed. For example, if this
+// callback has been passed to |SSL_get_ex_new_index| then it may be called each
+// time an |SSL*| is destroyed.
+//
+// The callback is passed the new object (i.e. the |SSL*|) in |parent|. The
+// arguments |argl| and |argp| contain opaque values that were given to
+// |CRYPTO_get_ex_new_index|. The callback should return one on success, but
+// the value is ignored.
+//
+// This callback may be called with a NULL value for |ptr| if |parent| has no
+// value set for this index. However, the callbacks may also be skipped entirely
+// if no extra data pointers are set on |parent| at all.
 typedef void CRYPTO_EX_free(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
                             int index, long argl, void *argp);
 
-/* CRYPTO_EX_dup is a callback function that is called when an object of the
- * class is being copied and thus the ex_data linked to it also needs to be
- * copied. On entry, |*from_d| points to the data for this index from the
- * original object. When the callback returns, |*from_d| will be set as the
- * data for this index in |to|.
- *
- * This callback may be called with a NULL value for |*from_d| if |from| has no
- * value set for this index. However, the callbacks may also be skipped entirely
- * if no extra data pointers are set on |from| at all. */
-typedef int CRYPTO_EX_dup(CRYPTO_EX_DATA *to, const CRYPTO_EX_DATA *from,
-                          void **from_d, int index, long argl, void *argp);
-
 
-/* Deprecated functions. */
+// Deprecated functions.
 
-/* CRYPTO_cleanup_all_ex_data does nothing. */
+// CRYPTO_cleanup_all_ex_data does nothing.
 OPENSSL_EXPORT void CRYPTO_cleanup_all_ex_data(void);
 
+// CRYPTO_EX_dup is a legacy callback function type which is ignored.
+typedef int CRYPTO_EX_dup(CRYPTO_EX_DATA *to, const CRYPTO_EX_DATA *from,
+                          void **from_d, int index, long argl, void *argp);
+
 
-/* Private structures. */
+// Private structures.
 
-/* CRYPTO_EX_unused is a placeholder for an unused callback. It is aliased to
- * int to ensure non-NULL callers fail to compile rather than fail silently. */
+// CRYPTO_EX_unused is a placeholder for an unused callback. It is aliased to
+// int to ensure non-NULL callers fail to compile rather than fail silently.
 typedef int CRYPTO_EX_unused;
 
 struct crypto_ex_data_st {
@@ -207,7 +197,7 @@ struct crypto_ex_data_st {
 
 
 #if defined(__cplusplus)
-}  /* extern C */
+}  // extern C
 #endif
 
-#endif  /* OPENSSL_HEADER_EX_DATA_H */
+#endif  // OPENSSL_HEADER_EX_DATA_H

data/third_party/boringssl/include/openssl/hkdf.h

@@ -22,33 +22,33 @@ extern "C" {
 #endif
 
 
-/* HKDF. */
+// HKDF.
 
 
-/* HKDF computes HKDF (as specified by RFC 5869) of initial keying material
- * |secret| with |salt| and |info| using |digest|, and outputs |out_len| bytes
- * to |out_key|. It returns one on success and zero on error.
- *
- * HKDF is an Extract-and-Expand algorithm. It does not do any key stretching,
- * and as such, is not suited to be used alone to generate a key from a
- * password. */
+// HKDF computes HKDF (as specified by RFC 5869) of initial keying material
+// |secret| with |salt| and |info| using |digest|, and outputs |out_len| bytes
+// to |out_key|. It returns one on success and zero on error.
+//
+// HKDF is an Extract-and-Expand algorithm. It does not do any key stretching,
+// and as such, is not suited to be used alone to generate a key from a
+// password.
 OPENSSL_EXPORT int HKDF(uint8_t *out_key, size_t out_len, const EVP_MD *digest,
                         const uint8_t *secret, size_t secret_len,
                         const uint8_t *salt, size_t salt_len,
                         const uint8_t *info, size_t info_len);
 
-/* HKDF_extract computes a HKDF PRK (as specified by RFC 5869) from initial
- * keying material |secret| and salt |salt| using |digest|, and outputs
- * |out_len| bytes to |out_key|. The maximum output size is |EVP_MAX_MD_SIZE|.
- * It returns one on success and zero on error. */
+// HKDF_extract computes a HKDF PRK (as specified by RFC 5869) from initial
+// keying material |secret| and salt |salt| using |digest|, and outputs
+// |out_len| bytes to |out_key|. The maximum output size is |EVP_MAX_MD_SIZE|.
+// It returns one on success and zero on error.
 OPENSSL_EXPORT int HKDF_extract(uint8_t *out_key, size_t *out_len,
                                 const EVP_MD *digest, const uint8_t *secret,
                                 size_t secret_len, const uint8_t *salt,
                                 size_t salt_len);
 
-/* HKDF_expand computes a HKDF OKM (as specified by RFC 5869) of length
- * |out_len| from the PRK |prk| and info |info| using |digest|, and outputs
- * the result to |out_key|. It returns one on success and zero on error. */
+// HKDF_expand computes a HKDF OKM (as specified by RFC 5869) of length
+// |out_len| from the PRK |prk| and info |info| using |digest|, and outputs
+// the result to |out_key|. It returns one on success and zero on error.
 OPENSSL_EXPORT int HKDF_expand(uint8_t *out_key, size_t out_len,
                                const EVP_MD *digest, const uint8_t *prk,
                                size_t prk_len, const uint8_t *info,
@@ -56,9 +56,9 @@ OPENSSL_EXPORT int HKDF_expand(uint8_t *out_key, size_t out_len,
 
 
 #if defined(__cplusplus)
-}  /* extern C */
+}  // extern C
 #endif
 
 #define HKDF_R_OUTPUT_TOO_LARGE 100
 
-#endif  /* OPENSSL_HEADER_HKDF_H */
+#endif  // OPENSSL_HEADER_HKDF_H

data/third_party/boringssl/include/openssl/hmac.h

@@ -66,84 +66,94 @@ extern "C" {
 #endif
 
 
-/* HMAC contains functions for constructing PRFs from Merkle–Damgård hash
- * functions using HMAC. */
+// HMAC contains functions for constructing PRFs from Merkle–Damgård hash
+// functions using HMAC.
 
 
-/* One-shot operation. */
+// One-shot operation.
 
-/* HMAC calculates the HMAC of |data_len| bytes of |data|, using the given key
- * and hash function, and writes the result to |out|. On entry, |out| must
- * contain at least |EVP_MD_size| bytes of space. The actual length of the
- * result is written to |*out_len|. An output size of |EVP_MAX_MD_SIZE| will
- * always be large enough. It returns |out| or NULL on error. */
+// HMAC calculates the HMAC of |data_len| bytes of |data|, using the given key
+// and hash function, and writes the result to |out|. On entry, |out| must
+// contain at least |EVP_MD_size| bytes of space. The actual length of the
+// result is written to |*out_len|. An output size of |EVP_MAX_MD_SIZE| will
+// always be large enough. It returns |out| or NULL on error.
 OPENSSL_EXPORT uint8_t *HMAC(const EVP_MD *evp_md, const void *key,
                              size_t key_len, const uint8_t *data,
                              size_t data_len, uint8_t *out,
                              unsigned int *out_len);
 
 
-/* Incremental operation. */
+// Incremental operation.
 
-/* HMAC_CTX_init initialises |ctx| for use in an HMAC operation. It's assumed
- * that HMAC_CTX objects will be allocated on the stack thus no allocation
- * function is provided. If needed, allocate |sizeof(HMAC_CTX)| and call
- * |HMAC_CTX_init| on it. */
+// HMAC_CTX_init initialises |ctx| for use in an HMAC operation. It's assumed
+// that HMAC_CTX objects will be allocated on the stack thus no allocation
+// function is provided.
 OPENSSL_EXPORT void HMAC_CTX_init(HMAC_CTX *ctx);
 
-/* HMAC_CTX_cleanup frees data owned by |ctx|. */
+// HMAC_CTX_new allocates and initialises a new |HMAC_CTX| and returns it, or
+// NULL on allocation failure. The caller must use |HMAC_CTX_free| to release
+// the resulting object.
+OPENSSL_EXPORT HMAC_CTX *HMAC_CTX_new(void);
+
+// HMAC_CTX_cleanup frees data owned by |ctx|. It does not free |ctx| itself.
 OPENSSL_EXPORT void HMAC_CTX_cleanup(HMAC_CTX *ctx);
 
-/* HMAC_Init_ex sets up an initialised |HMAC_CTX| to use |md| as the hash
- * function and |key| as the key. For a non-initial call, |md| may be NULL, in
- * which case the previous hash function will be used. If the hash function has
- * not changed and |key| is NULL, |ctx| reuses the previous key. It returns one
- * on success or zero otherwise.
- *
- * WARNING: NULL and empty keys are ambiguous on non-initial calls. Passing NULL
- * |key| but repeating the previous |md| reuses the previous key rather than the
- * empty key. */
+// HMAC_CTX_free calls |HMAC_CTX_cleanup| and then frees |ctx| itself.
+OPENSSL_EXPORT void HMAC_CTX_free(HMAC_CTX *ctx);
+
+// HMAC_Init_ex sets up an initialised |HMAC_CTX| to use |md| as the hash
+// function and |key| as the key. For a non-initial call, |md| may be NULL, in
+// which case the previous hash function will be used. If the hash function has
+// not changed and |key| is NULL, |ctx| reuses the previous key. It returns one
+// on success or zero otherwise.
+//
+// WARNING: NULL and empty keys are ambiguous on non-initial calls. Passing NULL
+// |key| but repeating the previous |md| reuses the previous key rather than the
+// empty key.
 OPENSSL_EXPORT int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, size_t key_len,
                                 const EVP_MD *md, ENGINE *impl);
 
-/* HMAC_Update hashes |data_len| bytes from |data| into the current HMAC
- * operation in |ctx|. It returns one. */
+// HMAC_Update hashes |data_len| bytes from |data| into the current HMAC
+// operation in |ctx|. It returns one.
 OPENSSL_EXPORT int HMAC_Update(HMAC_CTX *ctx, const uint8_t *data,
                                size_t data_len);
 
-/* HMAC_Final completes the HMAC operation in |ctx| and writes the result to
- * |out| and the sets |*out_len| to the length of the result. On entry, |out|
- * must contain at least |HMAC_size| bytes of space. An output size of
- * |EVP_MAX_MD_SIZE| will always be large enough. It returns one on success or
- * zero on error. */
+// HMAC_Final completes the HMAC operation in |ctx| and writes the result to
+// |out| and the sets |*out_len| to the length of the result. On entry, |out|
+// must contain at least |HMAC_size| bytes of space. An output size of
+// |EVP_MAX_MD_SIZE| will always be large enough. It returns one on success or
+// zero on error.
 OPENSSL_EXPORT int HMAC_Final(HMAC_CTX *ctx, uint8_t *out,
                               unsigned int *out_len);
 
 
-/* Utility functions. */
+// Utility functions.
 
-/* HMAC_size returns the size, in bytes, of the HMAC that will be produced by
- * |ctx|. On entry, |ctx| must have been setup with |HMAC_Init_ex|. */
+// HMAC_size returns the size, in bytes, of the HMAC that will be produced by
+// |ctx|. On entry, |ctx| must have been setup with |HMAC_Init_ex|.
 OPENSSL_EXPORT size_t HMAC_size(const HMAC_CTX *ctx);
 
-/* HMAC_CTX_copy_ex sets |dest| equal to |src|. On entry, |dest| must have been
- * initialised by calling |HMAC_CTX_init|. It returns one on success and zero
- * on error. */
+// HMAC_CTX_copy_ex sets |dest| equal to |src|. On entry, |dest| must have been
+// initialised by calling |HMAC_CTX_init|. It returns one on success and zero
+// on error.
 OPENSSL_EXPORT int HMAC_CTX_copy_ex(HMAC_CTX *dest, const HMAC_CTX *src);
 
+// HMAC_CTX_reset calls |HMAC_CTX_cleanup| followed by |HMAC_CTX_init|.
+OPENSSL_EXPORT void HMAC_CTX_reset(HMAC_CTX *ctx);
 
-/* Deprecated functions. */
+
+// Deprecated functions.
 
 OPENSSL_EXPORT int HMAC_Init(HMAC_CTX *ctx, const void *key, int key_len,
                              const EVP_MD *md);
 
-/* HMAC_CTX_copy calls |HMAC_CTX_init| on |dest| and then sets it equal to
- * |src|. On entry, |dest| must /not/ be initialised for an operation with
- * |HMAC_Init_ex|. It returns one on success and zero on error. */
+// HMAC_CTX_copy calls |HMAC_CTX_init| on |dest| and then sets it equal to
+// |src|. On entry, |dest| must /not/ be initialised for an operation with
+// |HMAC_Init_ex|. It returns one on success and zero on error.
 OPENSSL_EXPORT int HMAC_CTX_copy(HMAC_CTX *dest, const HMAC_CTX *src);
 
 
-/* Private functions */
+// Private functions
 
 struct hmac_ctx_st {
   const EVP_MD *md;
@@ -154,13 +164,15 @@ struct hmac_ctx_st {
 
 
 #if defined(__cplusplus)
-}  /* extern C */
+}  // extern C
 
 #if !defined(BORINGSSL_NO_CXX)
 extern "C++" {
 
 namespace bssl {
 
+BORINGSSL_MAKE_DELETER(HMAC_CTX, HMAC_CTX_free)
+
 using ScopedHMAC_CTX =
     internal::StackAllocated<HMAC_CTX, void, HMAC_CTX_init, HMAC_CTX_cleanup>;
 
@@ -171,4 +183,4 @@ using ScopedHMAC_CTX =
 
 #endif
 
-#endif  /* OPENSSL_HEADER_HMAC_H */
+#endif  // OPENSSL_HEADER_HMAC_H

data/third_party/boringssl/include/openssl/is_boringssl.h

@@ -0,0 +1,16 @@
+/* Copyright (c) 2017, Google Inc.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+
+// This header is provided in order to catch include path errors in consuming
+// BoringSSL.

data/third_party/boringssl/include/openssl/lhash.h

@@ -65,24 +65,24 @@ extern "C" {
 #endif
 
 
-/* lhash is a traditional, chaining hash table that automatically expands and
- * contracts as needed. One should not use the lh_* functions directly, rather
- * use the type-safe macro wrappers:
- *
- * A hash table of a specific type of object has type |LHASH_OF(type)|. This
- * can be defined (once) with |DEFINE_LHASH_OF(type)| and declared where needed
- * with |DECLARE_LHASH_OF(type)|. For example:
- *
- *   struct foo {
- *     int bar;
- *   };
- *
- *   DEFINE_LHASH_OF(struct foo);
- *
- * Although note that the hash table will contain /pointers/ to |foo|.
- *
- * A macro will be defined for each of the lh_* functions below. For
- * LHASH_OF(foo), the macros would be lh_foo_new, lh_foo_num_items etc. */
+// lhash is a traditional, chaining hash table that automatically expands and
+// contracts as needed. One should not use the lh_* functions directly, rather
+// use the type-safe macro wrappers:
+//
+// A hash table of a specific type of object has type |LHASH_OF(type)|. This
+// can be defined (once) with |DEFINE_LHASH_OF(type)| and declared where needed
+// with |DECLARE_LHASH_OF(type)|. For example:
+//
+//   struct foo {
+//     int bar;
+//   };
+//
+//   DEFINE_LHASH_OF(struct foo);
+//
+// Although note that the hash table will contain /pointers/ to |foo|.
+//
+// A macro will be defined for each of the lh_* functions below. For
+// LHASH_OF(foo), the macros would be lh_foo_new, lh_foo_num_items etc.
 
 
 #define LHASH_OF(type) struct lhash_st_##type
@@ -91,101 +91,101 @@ extern "C" {
 
 #define DECLARE_LHASH_OF(type) LHASH_OF(type);
 
-/* The make_macros.sh script in this directory parses the following lines and
- * generates the lhash_macros.h file that contains macros for the following
- * types of stacks:
- *
- * LHASH_OF:ASN1_OBJECT
- * LHASH_OF:CONF_VALUE
- * LHASH_OF:CRYPTO_BUFFER
- * LHASH_OF:SSL_SESSION */
+// The make_macros.sh script in this directory parses the following lines and
+// generates the lhash_macros.h file that contains macros for the following
+// types of stacks:
+//
+// LHASH_OF:ASN1_OBJECT
+// LHASH_OF:CONF_VALUE
+// LHASH_OF:CRYPTO_BUFFER
+// LHASH_OF:SSL_SESSION
 
 #define IN_LHASH_H
 #include <openssl/lhash_macros.h>
 #undef IN_LHASH_H
 
 
-/* lhash_item_st is an element of a hash chain. It points to the opaque data
- * for this element and to the next item in the chain. The linked-list is NULL
- * terminated. */
+// lhash_item_st is an element of a hash chain. It points to the opaque data
+// for this element and to the next item in the chain. The linked-list is NULL
+// terminated.
 typedef struct lhash_item_st {
   void *data;
   struct lhash_item_st *next;
-  /* hash contains the cached, hash value of |data|. */
+  // hash contains the cached, hash value of |data|.
   uint32_t hash;
 } LHASH_ITEM;
 
-/* lhash_cmp_func is a comparison function that returns a value equal, or not
- * equal, to zero depending on whether |*a| is equal, or not equal to |*b|,
- * respectively. Note the difference between this and |stack_cmp_func| in that
- * this takes pointers to the objects directly. */
+// lhash_cmp_func is a comparison function that returns a value equal, or not
+// equal, to zero depending on whether |*a| is equal, or not equal to |*b|,
+// respectively. Note the difference between this and |stack_cmp_func| in that
+// this takes pointers to the objects directly.
 typedef int (*lhash_cmp_func)(const void *a, const void *b);
 
-/* lhash_hash_func is a function that maps an object to a uniformly distributed
- * uint32_t. */
+// lhash_hash_func is a function that maps an object to a uniformly distributed
+// uint32_t.
 typedef uint32_t (*lhash_hash_func)(const void *a);
 
 typedef struct lhash_st {
-  /* num_items contains the total number of items in the hash table. */
+  // num_items contains the total number of items in the hash table.
   size_t num_items;
-  /* buckets is an array of |num_buckets| pointers. Each points to the head of
-   * a chain of LHASH_ITEM objects that have the same hash value, mod
-   * |num_buckets|. */
+  // buckets is an array of |num_buckets| pointers. Each points to the head of
+  // a chain of LHASH_ITEM objects that have the same hash value, mod
+  // |num_buckets|.
   LHASH_ITEM **buckets;
-  /* num_buckets contains the length of |buckets|. This value is always >=
-   * kMinNumBuckets. */
+  // num_buckets contains the length of |buckets|. This value is always >=
+  // kMinNumBuckets.
   size_t num_buckets;
-  /* callback_depth contains the current depth of |lh_doall| or |lh_doall_arg|
-   * calls. If non-zero then this suppresses resizing of the |buckets| array,
-   * which would otherwise disrupt the iteration. */
+  // callback_depth contains the current depth of |lh_doall| or |lh_doall_arg|
+  // calls. If non-zero then this suppresses resizing of the |buckets| array,
+  // which would otherwise disrupt the iteration.
   unsigned callback_depth;
 
   lhash_cmp_func comp;
   lhash_hash_func hash;
 } _LHASH;
 
-/* lh_new returns a new, empty hash table or NULL on error. */
+// lh_new returns a new, empty hash table or NULL on error.
 OPENSSL_EXPORT _LHASH *lh_new(lhash_hash_func hash, lhash_cmp_func comp);
 
-/* lh_free frees the hash table itself but none of the elements. See
- * |lh_doall|. */
+// lh_free frees the hash table itself but none of the elements. See
+// |lh_doall|.
 OPENSSL_EXPORT void lh_free(_LHASH *lh);
 
-/* lh_num_items returns the number of items in |lh|. */
+// lh_num_items returns the number of items in |lh|.
 OPENSSL_EXPORT size_t lh_num_items(const _LHASH *lh);
 
-/* lh_retrieve finds an element equal to |data| in the hash table and returns
- * it. If no such element exists, it returns NULL. */
+// lh_retrieve finds an element equal to |data| in the hash table and returns
+// it. If no such element exists, it returns NULL.
 OPENSSL_EXPORT void *lh_retrieve(const _LHASH *lh, const void *data);
 
-/* lh_insert inserts |data| into the hash table. If an existing element is
- * equal to |data| (with respect to the comparison function) then |*old_data|
- * will be set to that value and it will be replaced. Otherwise, or in the
- * event of an error, |*old_data| will be set to NULL. It returns one on
- * success or zero in the case of an allocation error. */
+// lh_insert inserts |data| into the hash table. If an existing element is
+// equal to |data| (with respect to the comparison function) then |*old_data|
+// will be set to that value and it will be replaced. Otherwise, or in the
+// event of an error, |*old_data| will be set to NULL. It returns one on
+// success or zero in the case of an allocation error.
 OPENSSL_EXPORT int lh_insert(_LHASH *lh, void **old_data, void *data);
 
-/* lh_delete removes an element equal to |data| from the hash table and returns
- * it. If no such element is found, it returns NULL. */
+// lh_delete removes an element equal to |data| from the hash table and returns
+// it. If no such element is found, it returns NULL.
 OPENSSL_EXPORT void *lh_delete(_LHASH *lh, const void *data);
 
-/* lh_doall calls |func| on each element of the hash table.
- * TODO(fork): rename this */
+// lh_doall calls |func| on each element of the hash table.
+// TODO(fork): rename this
 OPENSSL_EXPORT void lh_doall(_LHASH *lh, void (*func)(void *));
 
-/* lh_doall_arg calls |func| on each element of the hash table and also passes
- * |arg| as the second argument.
- * TODO(fork): rename this */
+// lh_doall_arg calls |func| on each element of the hash table and also passes
+// |arg| as the second argument.
+// TODO(fork): rename this
 OPENSSL_EXPORT void lh_doall_arg(_LHASH *lh, void (*func)(void *, void *),
                                  void *arg);
 
-/* lh_strhash is the default hash function which processes NUL-terminated
- * strings. */
+// lh_strhash is the default hash function which processes NUL-terminated
+// strings.
 OPENSSL_EXPORT uint32_t lh_strhash(const char *c);
 
 
 #if defined(__cplusplus)
-} /* extern C */
+}  // extern C
 #endif
 
-#endif /* OPENSSL_HEADER_LHASH_H */
+#endif  // OPENSSL_HEADER_LHASH_H