grpc 1.56.2 → 1.57.0.pre1

data/third_party/boringssl-with-bazel/src/crypto/x509/by_dir.c

@@ -81,7 +81,6 @@ typedef struct lookup_dir_entry_st {
 } BY_DIR_ENTRY;
 
 typedef struct lookup_dir_st {
-  BUF_MEM *buffer;
   STACK_OF(BY_DIR_ENTRY) *dirs;
 } BY_DIR;
 
@@ -141,10 +140,6 @@ static int new_dir(X509_LOOKUP *lu) {
   if ((a = (BY_DIR *)OPENSSL_malloc(sizeof(BY_DIR))) == NULL) {
     return 0;
   }
-  if ((a->buffer = BUF_MEM_new()) == NULL) {
-    OPENSSL_free(a);
-    return 0;
-  }
   a->dirs = NULL;
   lu->method_data = a;
   return 1;
@@ -175,7 +170,6 @@ static void free_dir(X509_LOOKUP *lu) {
   BY_DIR *a = lu->method_data;
   if (a != NULL) {
     sk_BY_DIR_ENTRY_pop_free(a->dirs, by_dir_entry_free);
-    BUF_MEM_free(a->buffer);
     OPENSSL_free(a);
   }
 }
@@ -238,7 +232,7 @@ static int add_cert_dir(BY_DIR *ctx, const char *dir, int type) {
 
 // g_ent_hashes_lock protects the |hashes| member of all |BY_DIR_ENTRY|
 // objects.
-static struct CRYPTO_STATIC_MUTEX g_ent_hashes_lock = CRYPTO_STATIC_MUTEX_INIT;
+static CRYPTO_MUTEX g_ent_hashes_lock = CRYPTO_MUTEX_INIT;
 
 static int get_cert_by_subject(X509_LOOKUP *xl, int type, X509_NAME *name,
                                X509_OBJECT *ret) {
@@ -304,7 +298,7 @@ static int get_cert_by_subject(X509_LOOKUP *xl, int type, X509_NAME *name,
       }
       if (type == X509_LU_CRL && ent->hashes) {
         htmp.hash = h;
-        CRYPTO_STATIC_MUTEX_lock_read(&g_ent_hashes_lock);
+        CRYPTO_MUTEX_lock_read(&g_ent_hashes_lock);
         if (sk_BY_DIR_HASH_find(ent->hashes, &idx, &htmp)) {
           hent = sk_BY_DIR_HASH_value(ent->hashes, idx);
           k = hent->suffix;
@@ -312,7 +306,7 @@ static int get_cert_by_subject(X509_LOOKUP *xl, int type, X509_NAME *name,
           hent = NULL;
           k = 0;
         }
-        CRYPTO_STATIC_MUTEX_unlock_read(&g_ent_hashes_lock);
+        CRYPTO_MUTEX_unlock_read(&g_ent_hashes_lock);
       } else {
         k = 0;
         hent = NULL;
@@ -357,7 +351,7 @@ static int get_cert_by_subject(X509_LOOKUP *xl, int type, X509_NAME *name,
       // If a CRL, update the last file suffix added for this
 
       if (type == X509_LU_CRL) {
-        CRYPTO_STATIC_MUTEX_lock_write(&g_ent_hashes_lock);
+        CRYPTO_MUTEX_lock_write(&g_ent_hashes_lock);
         // Look for entry again in case another thread added an entry
         // first.
         if (!hent) {
@@ -370,14 +364,14 @@ static int get_cert_by_subject(X509_LOOKUP *xl, int type, X509_NAME *name,
         if (!hent) {
           hent = OPENSSL_malloc(sizeof(BY_DIR_HASH));
           if (hent == NULL) {
-            CRYPTO_STATIC_MUTEX_unlock_write(&g_ent_hashes_lock);
+            CRYPTO_MUTEX_unlock_write(&g_ent_hashes_lock);
             ok = 0;
             goto finish;
           }
           hent->hash = h;
           hent->suffix = k;
           if (!sk_BY_DIR_HASH_push(ent->hashes, hent)) {
-            CRYPTO_STATIC_MUTEX_unlock_write(&g_ent_hashes_lock);
+            CRYPTO_MUTEX_unlock_write(&g_ent_hashes_lock);
             OPENSSL_free(hent);
             ok = 0;
             goto finish;
@@ -387,7 +381,7 @@ static int get_cert_by_subject(X509_LOOKUP *xl, int type, X509_NAME *name,
           hent->suffix = k;
         }
 
-        CRYPTO_STATIC_MUTEX_unlock_write(&g_ent_hashes_lock);
+        CRYPTO_MUTEX_unlock_write(&g_ent_hashes_lock);
       }
 
       if (tmp != NULL) {

data/third_party/boringssl-with-bazel/src/crypto/x509/internal.h

@@ -64,6 +64,7 @@
 #include <openssl/x509.h>
 
 #include "../asn1/internal.h"
+#include "../internal.h"
 
 #if defined(__cplusplus)
 extern "C" {
@@ -274,7 +275,6 @@ struct x509_lookup_method_st {
 // function is then called to actually check the cert chain.
 struct x509_store_st {
   // The following is a cache of trusted certs
-  int cache;                    // if true, stash any hits
   STACK_OF(X509_OBJECT) *objs;  // Cache of all objects
   CRYPTO_MUTEX objs_lock;
 

data/third_party/boringssl-with-bazel/src/crypto/x509/x509_att.c

@@ -189,7 +189,7 @@ err:
 }
 
 int X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr) {
-  return sk_ASN1_TYPE_num(attr->set);
+  return (int)sk_ASN1_TYPE_num(attr->set);
 }
 
 ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr) {

data/third_party/boringssl-with-bazel/src/crypto/x509/x509_lu.c

@@ -173,7 +173,6 @@ X509_STORE *X509_STORE_new(void) {
   if (ret->objs == NULL) {
     goto err;
   }
-  ret->cache = 1;
   ret->get_cert_methods = sk_X509_LOOKUP_new_null();
   if (ret->get_cert_methods == NULL) {
     goto err;
@@ -423,9 +422,8 @@ static int x509_object_idx_cnt(STACK_OF(X509_OBJECT) *h, int type,
   }
 
   if (pnmatch != NULL) {
-    int tidx;
     *pnmatch = 1;
-    for (tidx = idx + 1; tidx < (int)sk_X509_OBJECT_num(h); tidx++) {
+    for (size_t tidx = idx + 1; tidx < sk_X509_OBJECT_num(h); tidx++) {
       const X509_OBJECT *tobj = sk_X509_OBJECT_value(h, tidx);
       if (x509_object_cmp(tobj, &stmp)) {
         break;
@@ -434,7 +432,7 @@ static int x509_object_idx_cnt(STACK_OF(X509_OBJECT) *h, int type,
     }
   }
 
-  return idx;
+  return (int)idx;
 }
 
 int X509_OBJECT_idx_by_subject(STACK_OF(X509_OBJECT) *h, int type,

data/third_party/boringssl-with-bazel/src/crypto/x509/x509_req.c

@@ -161,7 +161,7 @@ int X509_REQ_add_extensions(X509_REQ *req,
 }
 
 int X509_REQ_get_attr_count(const X509_REQ *req) {
-  return sk_X509_ATTRIBUTE_num(req->req_info->attributes);
+  return (int)sk_X509_ATTRIBUTE_num(req->req_info->attributes);
 }
 
 int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, int lastpos) {
@@ -181,7 +181,7 @@ int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, const ASN1_OBJECT *obj,
   if (lastpos < 0) {
     lastpos = 0;
   }
-  int n = sk_X509_ATTRIBUTE_num(req->req_info->attributes);
+  int n = (int)sk_X509_ATTRIBUTE_num(req->req_info->attributes);
   for (; lastpos < n; lastpos++) {
     const X509_ATTRIBUTE *attr =
         sk_X509_ATTRIBUTE_value(req->req_info->attributes, lastpos);

data/third_party/boringssl-with-bazel/src/crypto/x509/x509_trs.c

@@ -168,7 +168,7 @@ int X509_TRUST_set(int *t, int trust) {
 }
 
 int X509_TRUST_add(int id, int flags, int (*ck)(X509_TRUST *, X509 *, int),
-                   char *name, int arg1, void *arg2) {
+                   const char *name, int arg1, void *arg2) {
   int idx;
   X509_TRUST *trtmp;
   char *name_dup;

data/third_party/boringssl-with-bazel/src/crypto/x509/x509_v3.c

@@ -69,7 +69,7 @@ int X509v3_get_ext_count(const STACK_OF(X509_EXTENSION) *x) {
   if (x == NULL) {
     return 0;
   }
-  return (sk_X509_EXTENSION_num(x));
+  return (int)sk_X509_EXTENSION_num(x);
 }
 
 int X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x, int nid,
@@ -83,9 +83,6 @@ int X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x, int nid,
 
 int X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *sk,
                           const ASN1_OBJECT *obj, int lastpos) {
-  int n;
-  X509_EXTENSION *ex;
-
   if (sk == NULL) {
     return -1;
   }
@@ -93,9 +90,9 @@ int X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *sk,
   if (lastpos < 0) {
     lastpos = 0;
   }
-  n = sk_X509_EXTENSION_num(sk);
+  int n = (int)sk_X509_EXTENSION_num(sk);
   for (; lastpos < n; lastpos++) {
-    ex = sk_X509_EXTENSION_value(sk, lastpos);
+    const X509_EXTENSION *ex = sk_X509_EXTENSION_value(sk, lastpos);
     if (OBJ_cmp(ex->object, obj) == 0) {
       return lastpos;
     }
@@ -115,7 +112,7 @@ int X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *sk, int crit,
   }
 
   crit = !!crit;
-  int n = sk_X509_EXTENSION_num(sk);
+  int n = (int)sk_X509_EXTENSION_num(sk);
   for (; lastpos < n; lastpos++) {
     const X509_EXTENSION *ex = sk_X509_EXTENSION_value(sk, lastpos);
     if (X509_EXTENSION_get_critical(ex) == crit) {
@@ -146,13 +143,12 @@ X509_EXTENSION *X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc) {
 STACK_OF(X509_EXTENSION) *X509v3_add_ext(STACK_OF(X509_EXTENSION) **x,
                                          const X509_EXTENSION *ex, int loc) {
   X509_EXTENSION *new_ex = NULL;
-  int n;
   STACK_OF(X509_EXTENSION) *sk = NULL;
   int free_sk = 0;
 
   if (x == NULL) {
     OPENSSL_PUT_ERROR(X509, ERR_R_PASSED_NULL_PARAMETER);
-    goto err2;
+    goto err;
   }
 
   if (*x == NULL) {
@@ -164,7 +160,7 @@ STACK_OF(X509_EXTENSION) *X509v3_add_ext(STACK_OF(X509_EXTENSION) **x,
     sk = *x;
   }
 
-  n = sk_X509_EXTENSION_num(sk);
+  int n = (int)sk_X509_EXTENSION_num(sk);
   if (loc > n) {
     loc = n;
   } else if (loc < 0) {
@@ -172,7 +168,7 @@ STACK_OF(X509_EXTENSION) *X509v3_add_ext(STACK_OF(X509_EXTENSION) **x,
   }
 
   if ((new_ex = X509_EXTENSION_dup(ex)) == NULL) {
-    goto err2;
+    goto err;
   }
   if (!sk_X509_EXTENSION_insert(sk, new_ex, loc)) {
     goto err;
@@ -181,8 +177,8 @@ STACK_OF(X509_EXTENSION) *X509v3_add_ext(STACK_OF(X509_EXTENSION) **x,
     *x = sk;
   }
   return sk;
+
 err:
-err2:
   X509_EXTENSION_free(new_ex);
   if (free_sk) {
     sk_X509_EXTENSION_free(sk);

data/third_party/boringssl-with-bazel/src/crypto/x509/x509_vfy.c

@@ -217,7 +217,7 @@ int X509_verify_cert(X509_STORE_CTX *ctx) {
     goto end;
   }
 
-  num = sk_X509_num(ctx->chain);
+  num = (int)sk_X509_num(ctx->chain);
   x = sk_X509_value(ctx->chain, num - 1);
   depth = param->depth;
 
@@ -284,7 +284,7 @@ int X509_verify_cert(X509_STORE_CTX *ctx) {
 
   do {
     // Examine last certificate in chain and see if it is self signed.
-    i = sk_X509_num(ctx->chain);
+    i = (int)sk_X509_num(ctx->chain);
     x = sk_X509_value(ctx->chain, i - 1);
 
     int is_self_signed;
@@ -396,7 +396,7 @@ int X509_verify_cert(X509_STORE_CTX *ctx) {
             X509_free(xtmp);
             num--;
           }
-          ctx->last_untrusted = sk_X509_num(ctx->chain);
+          ctx->last_untrusted = (int)sk_X509_num(ctx->chain);
           retry = 1;
           break;
         }
@@ -628,7 +628,7 @@ static int check_name_constraints(X509_STORE_CTX *ctx) {
   int i, j, rv;
   int has_name_constraints = 0;
   // Check name constraints for all certificates
-  for (i = sk_X509_num(ctx->chain) - 1; i >= 0; i--) {
+  for (i = (int)sk_X509_num(ctx->chain) - 1; i >= 0; i--) {
     X509 *x = sk_X509_value(ctx->chain, i);
     // Ignore self issued certs unless last in chain
     if (i && (x->ex_flags & EXFLAG_SI)) {
@@ -638,7 +638,7 @@ static int check_name_constraints(X509_STORE_CTX *ctx) {
     // including trust anchor. Trust anchor not strictly speaking needed
     // but if it includes constraints it is to be assumed it expects them
     // to be obeyed.
-    for (j = sk_X509_num(ctx->chain) - 1; j > i; j--) {
+    for (j = (int)sk_X509_num(ctx->chain) - 1; j > i; j--) {
       NAME_CONSTRAINTS *nc = sk_X509_value(ctx->chain, j)->nc;
       if (nc) {
         has_name_constraints = 1;
@@ -748,11 +748,10 @@ static int check_id(X509_STORE_CTX *ctx) {
 }
 
 static int check_trust(X509_STORE_CTX *ctx) {
-  size_t i;
   int ok;
   X509 *x = NULL;
   // Check all trusted certificates in chain
-  for (i = ctx->last_untrusted; i < sk_X509_num(ctx->chain); i++) {
+  for (size_t i = ctx->last_untrusted; i < sk_X509_num(ctx->chain); i++) {
     x = sk_X509_value(ctx->chain, i);
     ok = X509_check_trust(x, ctx->param->trust, 0);
     // If explicitly trusted return trusted
@@ -762,7 +761,7 @@ static int check_trust(X509_STORE_CTX *ctx) {
     // If explicitly rejected notify callback and reject if not
     // overridden.
     if (ok == X509_TRUST_REJECTED) {
-      ctx->error_depth = i;
+      ctx->error_depth = (int)i;
       ctx->current_cert = x;
       ctx->error = X509_V_ERR_CERT_REJECTED;
       ok = ctx->verify_cb(0, ctx);
@@ -794,12 +793,12 @@ static int check_trust(X509_STORE_CTX *ctx) {
 }
 
 static int check_revocation(X509_STORE_CTX *ctx) {
-  int i, last, ok;
   if (!(ctx->param->flags & X509_V_FLAG_CRL_CHECK)) {
     return 1;
   }
+  int last;
   if (ctx->param->flags & X509_V_FLAG_CRL_CHECK_ALL) {
-    last = sk_X509_num(ctx->chain) - 1;
+    last = (int)sk_X509_num(ctx->chain) - 1;
   } else {
     // If checking CRL paths this isn't the EE certificate
     if (ctx->parent) {
@@ -807,9 +806,9 @@ static int check_revocation(X509_STORE_CTX *ctx) {
     }
     last = 0;
   }
-  for (i = 0; i <= last; i++) {
+  for (int i = 0; i <= last; i++) {
     ctx->error_depth = i;
-    ok = check_cert(ctx);
+    int ok = check_cert(ctx);
     if (!ok) {
       return ok;
     }
@@ -1478,9 +1477,9 @@ done:
 static int check_crl(X509_STORE_CTX *ctx, X509_CRL *crl) {
   X509 *issuer = NULL;
   EVP_PKEY *ikey = NULL;
-  int ok = 0, chnum, cnum;
-  cnum = ctx->error_depth;
-  chnum = sk_X509_num(ctx->chain) - 1;
+  int ok = 0;
+  int cnum = ctx->error_depth;
+  int chnum = (int)sk_X509_num(ctx->chain) - 1;
   // if we have an alternative CRL issuer cert use that
   if (ctx->current_issuer) {
     issuer = ctx->current_issuer;
@@ -1691,11 +1690,11 @@ static int check_cert_time(X509_STORE_CTX *ctx, X509 *x) {
 }
 
 static int internal_verify(X509_STORE_CTX *ctx) {
-  int ok = 0, n;
+  int ok = 0;
   X509 *xs, *xi;
   EVP_PKEY *pkey = NULL;
 
-  n = sk_X509_num(ctx->chain);
+  int n = (int)sk_X509_num(ctx->chain);
   ctx->error_depth = n - 1;
   n--;
   xi = sk_X509_value(ctx->chain, n);
@@ -1776,7 +1775,7 @@ int X509_cmp_current_time(const ASN1_TIME *ctm) {
   return X509_cmp_time_posix(ctm, time(NULL));
 }
 
-int X509_cmp_time(const ASN1_TIME *ctm, time_t *cmp_time) {
+int X509_cmp_time(const ASN1_TIME *ctm, const time_t *cmp_time) {
   int64_t compare_time = (cmp_time == NULL) ? time(NULL) : *cmp_time;
   return X509_cmp_time_posix(ctm, compare_time);
 }
@@ -1794,12 +1793,12 @@ ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long offset_sec) {
   return X509_time_adj(s, offset_sec, NULL);
 }
 
-ASN1_TIME *X509_time_adj(ASN1_TIME *s, long offset_sec, time_t *in_tm) {
+ASN1_TIME *X509_time_adj(ASN1_TIME *s, long offset_sec, const time_t *in_tm) {
   return X509_time_adj_ex(s, 0, offset_sec, in_tm);
 }
 
 ASN1_TIME *X509_time_adj_ex(ASN1_TIME *s, int offset_day, long offset_sec,
-                            time_t *in_tm) {
+                            const time_t *in_tm) {
   int64_t t = 0;
 
   if (in_tm) {

data/third_party/boringssl-with-bazel/src/crypto/x509/x509name.c

@@ -99,7 +99,7 @@ int X509_NAME_entry_count(const X509_NAME *name) {
   if (name == NULL) {
     return 0;
   }
-  return (sk_X509_NAME_ENTRY_num(name->entries));
+  return (int)sk_X509_NAME_ENTRY_num(name->entries);
 }
 
 int X509_NAME_get_index_by_NID(const X509_NAME *name, int nid, int lastpos) {
@@ -109,26 +109,22 @@ int X509_NAME_get_index_by_NID(const X509_NAME *name, int nid, int lastpos) {
   if (obj == NULL) {
     return -2;
   }
-  return (X509_NAME_get_index_by_OBJ(name, obj, lastpos));
+  return X509_NAME_get_index_by_OBJ(name, obj, lastpos);
 }
 
 // NOTE: you should be passsing -1, not 0 as lastpos
 int X509_NAME_get_index_by_OBJ(const X509_NAME *name, const ASN1_OBJECT *obj,
                                int lastpos) {
-  int n;
-  X509_NAME_ENTRY *ne;
-  STACK_OF(X509_NAME_ENTRY) *sk;
-
   if (name == NULL) {
     return -1;
   }
   if (lastpos < 0) {
     lastpos = -1;
   }
-  sk = name->entries;
-  n = sk_X509_NAME_ENTRY_num(sk);
+  const STACK_OF(X509_NAME_ENTRY) *sk = name->entries;
+  int n = (int)sk_X509_NAME_ENTRY_num(sk);
   for (lastpos++; lastpos < n; lastpos++) {
-    ne = sk_X509_NAME_ENTRY_value(sk, lastpos);
+    const X509_NAME_ENTRY *ne = sk_X509_NAME_ENTRY_value(sk, lastpos);
     if (OBJ_cmp(ne->object, obj) == 0) {
       return lastpos;
     }
@@ -153,9 +149,9 @@ X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc) {
 
   STACK_OF(X509_NAME_ENTRY) *sk = name->entries;
   X509_NAME_ENTRY *ret = sk_X509_NAME_ENTRY_delete(sk, loc);
-  int n = sk_X509_NAME_ENTRY_num(sk);
+  size_t n = sk_X509_NAME_ENTRY_num(sk);
   name->modified = 1;
-  if (loc == n) {
+  if ((size_t)loc == n) {
     return ret;
   }
 
@@ -170,7 +166,7 @@ X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc) {
   // If we removed a singleton RDN, update the RDN indices so they are
   // consecutive again.
   if (set_prev + 1 < set_next) {
-    for (int i = loc; i < n; i++) {
+    for (size_t i = loc; i < n; i++) {
       sk_X509_NAME_ENTRY_value(sk, i)->set--;
     }
   }
@@ -221,14 +217,14 @@ int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type,
 int X509_NAME_add_entry(X509_NAME *name, const X509_NAME_ENTRY *entry, int loc,
                         int set) {
   X509_NAME_ENTRY *new_name = NULL;
-  int n, i, inc;
+  int i, inc;
   STACK_OF(X509_NAME_ENTRY) *sk;
 
   if (name == NULL) {
     return 0;
   }
   sk = name->entries;
-  n = sk_X509_NAME_ENTRY_num(sk);
+  int n = (int)sk_X509_NAME_ENTRY_num(sk);
   if (loc > n) {
     loc = n;
   } else if (loc < 0) {
@@ -266,7 +262,7 @@ int X509_NAME_add_entry(X509_NAME *name, const X509_NAME_ENTRY *entry, int loc,
     goto err;
   }
   if (inc) {
-    n = sk_X509_NAME_ENTRY_num(sk);
+    n = (int)sk_X509_NAME_ENTRY_num(sk);
     for (i = loc + 1; i < n; i++) {
       sk_X509_NAME_ENTRY_value(sk, i)->set += 1;
     }

data/third_party/boringssl-with-bazel/src/crypto/x509/x_crl.c

@@ -430,7 +430,7 @@ static int crl_revoked_issuer_match(X509_CRL *crl, X509_NAME *nm,
   return 0;
 }
 
-static struct CRYPTO_STATIC_MUTEX g_crl_sort_lock = CRYPTO_STATIC_MUTEX_INIT;
+static CRYPTO_MUTEX g_crl_sort_lock = CRYPTO_MUTEX_INIT;
 
 static int crl_lookup(X509_CRL *crl, X509_REVOKED **ret, ASN1_INTEGER *serial,
                       X509_NAME *issuer) {
@@ -443,16 +443,16 @@ static int crl_lookup(X509_CRL *crl, X509_REVOKED **ret, ASN1_INTEGER *serial,
   // Sort revoked into serial number order if not already sorted. Do this
   // under a lock to avoid race condition.
 
-  CRYPTO_STATIC_MUTEX_lock_read(&g_crl_sort_lock);
+  CRYPTO_MUTEX_lock_read(&g_crl_sort_lock);
   const int is_sorted = sk_X509_REVOKED_is_sorted(crl->crl->revoked);
-  CRYPTO_STATIC_MUTEX_unlock_read(&g_crl_sort_lock);
+  CRYPTO_MUTEX_unlock_read(&g_crl_sort_lock);
 
   if (!is_sorted) {
-    CRYPTO_STATIC_MUTEX_lock_write(&g_crl_sort_lock);
+    CRYPTO_MUTEX_lock_write(&g_crl_sort_lock);
     if (!sk_X509_REVOKED_is_sorted(crl->crl->revoked)) {
       sk_X509_REVOKED_sort(crl->crl->revoked);
     }
-    CRYPTO_STATIC_MUTEX_unlock_write(&g_crl_sort_lock);
+    CRYPTO_MUTEX_unlock_write(&g_crl_sort_lock);
   }
 
   if (!sk_X509_REVOKED_find(crl->crl->revoked, &idx, &rtmp)) {

data/third_party/boringssl-with-bazel/src/crypto/x509/x_name.c

@@ -230,7 +230,7 @@ static int x509_name_ex_d2i(ASN1_VALUE **val, const unsigned char **in,
     entries = sk_STACK_OF_X509_NAME_ENTRY_value(intname, i);
     for (j = 0; j < sk_X509_NAME_ENTRY_num(entries); j++) {
       entry = sk_X509_NAME_ENTRY_value(entries, j);
-      entry->set = i;
+      entry->set = (int)i;
       if (!sk_X509_NAME_ENTRY_push(nm->entries, entry)) {
         goto err;
       }

data/third_party/boringssl-with-bazel/src/crypto/x509/x_pubkey.c

@@ -128,7 +128,7 @@ error:
 // |X509_PUBKEY| objects. Really |X509_PUBKEY| should have a |CRYPTO_once_t|
 // inside it for this, but |CRYPTO_once_t| is private and |X509_PUBKEY| is
 // not.
-static struct CRYPTO_STATIC_MUTEX g_pubkey_lock = CRYPTO_STATIC_MUTEX_INIT;
+static CRYPTO_MUTEX g_pubkey_lock = CRYPTO_MUTEX_INIT;
 
 EVP_PKEY *X509_PUBKEY_get(X509_PUBKEY *key) {
   EVP_PKEY *ret = NULL;
@@ -138,13 +138,13 @@ EVP_PKEY *X509_PUBKEY_get(X509_PUBKEY *key) {
     goto error;
   }
 
-  CRYPTO_STATIC_MUTEX_lock_read(&g_pubkey_lock);
+  CRYPTO_MUTEX_lock_read(&g_pubkey_lock);
   if (key->pkey != NULL) {
-    CRYPTO_STATIC_MUTEX_unlock_read(&g_pubkey_lock);
+    CRYPTO_MUTEX_unlock_read(&g_pubkey_lock);
     EVP_PKEY_up_ref(key->pkey);
     return key->pkey;
   }
-  CRYPTO_STATIC_MUTEX_unlock_read(&g_pubkey_lock);
+  CRYPTO_MUTEX_unlock_read(&g_pubkey_lock);
 
   // Re-encode the |X509_PUBKEY| to DER and parse it.
   int spki_len = i2d_X509_PUBKEY(key, &spki);
@@ -160,14 +160,14 @@ EVP_PKEY *X509_PUBKEY_get(X509_PUBKEY *key) {
   }
 
   // Check to see if another thread set key->pkey first
-  CRYPTO_STATIC_MUTEX_lock_write(&g_pubkey_lock);
+  CRYPTO_MUTEX_lock_write(&g_pubkey_lock);
   if (key->pkey) {
-    CRYPTO_STATIC_MUTEX_unlock_write(&g_pubkey_lock);
+    CRYPTO_MUTEX_unlock_write(&g_pubkey_lock);
     EVP_PKEY_free(ret);
     ret = key->pkey;
   } else {
     key->pkey = ret;
-    CRYPTO_STATIC_MUTEX_unlock_write(&g_pubkey_lock);
+    CRYPTO_MUTEX_unlock_write(&g_pubkey_lock);
   }
 
   OPENSSL_free(spki);

data/third_party/boringssl-with-bazel/src/crypto/x509v3/v3_lib.c

@@ -195,7 +195,6 @@ void *X509V3_EXT_d2i(const X509_EXTENSION *ext) {
 void *X509V3_get_d2i(const STACK_OF(X509_EXTENSION) *extensions, int nid,
                      int *out_critical, int *out_idx) {
   int lastpos;
-  size_t i;
   X509_EXTENSION *ex, *found_ex = NULL;
   if (!extensions) {
     if (out_idx) {
@@ -214,13 +213,13 @@ void *X509V3_get_d2i(const STACK_OF(X509_EXTENSION) *extensions, int nid,
   if (lastpos < 0) {
     lastpos = 0;
   }
-  for (i = lastpos; i < sk_X509_EXTENSION_num(extensions); i++) {
+  for (size_t i = lastpos; i < sk_X509_EXTENSION_num(extensions); i++) {
     ex = sk_X509_EXTENSION_value(extensions, i);
     if (OBJ_obj2nid(ex->object) == nid) {
       if (out_idx) {
         // TODO(https://crbug.com/boringssl/379): Consistently reject
         // duplicate extensions.
-        *out_idx = i;
+        *out_idx = (int)i;
         found_ex = ex;
         break;
       } else if (found_ex) {

data/third_party/boringssl-with-bazel/src/crypto/x509v3/v3_purp.c

@@ -177,10 +177,9 @@ X509_PURPOSE *X509_PURPOSE_get0(int idx) {
   return sk_X509_PURPOSE_value(xptable, idx - X509_PURPOSE_COUNT);
 }
 
-int X509_PURPOSE_get_by_sname(char *sname) {
-  int i;
+int X509_PURPOSE_get_by_sname(const char *sname) {
   X509_PURPOSE *xptmp;
-  for (i = 0; i < X509_PURPOSE_get_count(); i++) {
+  for (int i = 0; i < X509_PURPOSE_get_count(); i++) {
     xptmp = X509_PURPOSE_get0(i);
     if (!strcmp(xptmp->sname, sname)) {
       return i;
@@ -209,8 +208,7 @@ int X509_PURPOSE_get_by_id(int purpose) {
 
 int X509_PURPOSE_add(int id, int trust, int flags,
                      int (*ck)(const X509_PURPOSE *, const X509 *, int),
-                     char *name, char *sname, void *arg) {
-  int idx;
+                     const char *name, const char *sname, void *arg) {
   X509_PURPOSE *ptmp;
   char *name_dup, *sname_dup;
 
@@ -219,7 +217,7 @@ int X509_PURPOSE_add(int id, int trust, int flags,
   // This will always be set for application modified trust entries
   flags |= X509_PURPOSE_DYNAMIC_NAME;
   // Get existing entry if any
-  idx = X509_PURPOSE_get_by_id(id);
+  int idx = X509_PURPOSE_get_by_id(id);
   // Need a new entry
   if (idx == -1) {
     if (!(ptmp = OPENSSL_malloc(sizeof(X509_PURPOSE)))) {