grpc 1.69.0 → 1.70.1

data/src/core/xds/xds_client/xds_client.h

@@ -28,9 +28,12 @@
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_set.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
+#include "envoy/admin/v3/config_dump_shared.upb.h"
+#include "envoy/service/status/v3/csds.upb.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/util/dual_ref_counted.h"
 #include "src/core/util/orphanable.h"
@@ -71,14 +74,12 @@ class XdsClient : public DualRefCounted<XdsClient> {
   class ResourceWatcherInterface : public RefCounted<ResourceWatcherInterface> {
    public:
     virtual void OnGenericResourceChanged(
-        std::shared_ptr<const XdsResourceType::ResourceData> resource,
+        absl::StatusOr<std::shared_ptr<const XdsResourceType::ResourceData>>
+            resource,
         RefCountedPtr<ReadDelayHandle> read_delay_handle)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
-    virtual void OnError(absl::Status status,
-                         RefCountedPtr<ReadDelayHandle> read_delay_handle)
-        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
-    virtual void OnResourceDoesNotExist(
-        RefCountedPtr<ReadDelayHandle> read_delay_handle)
+    virtual void OnAmbientError(
+        absl::Status status, RefCountedPtr<ReadDelayHandle> read_delay_handle)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
   };
 
@@ -138,8 +139,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
   Mutex* mu() ABSL_LOCK_RETURNED(&mu_) { return &mu_; }
 
   // Dumps the active xDS config to the provided
-  // envoy.service.status.v3.ClientConfig message including the config status
-  // (e.g., CLIENT_REQUESTED, CLIENT_ACKED, CLIENT_NACKED).
+  // envoy.service.status.v3.ClientConfig message.
   void DumpClientConfig(std::set<std::string>* string_pool, upb_Arena* arena,
                         envoy_service_status_v3_ClientConfig* client_config)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(&mu_);
@@ -253,13 +253,93 @@ class XdsClient : public DualRefCounted<XdsClient> {
     absl::Status status_;
   };
 
-  struct ResourceState {
-    std::map<ResourceWatcherInterface*, RefCountedPtr<ResourceWatcherInterface>>
-        watchers;
+  using WatcherSet =
+      absl::flat_hash_set<RefCountedPtr<ResourceWatcherInterface>,
+                          RefCountedPtrHash<ResourceWatcherInterface>,
+                          RefCountedPtrEq<ResourceWatcherInterface>>;
+
+  class ResourceState {
+   public:
+    // Resource status from the view of a xDS client, which tells the
+    // synchronization status between the xDS client and the xDS server.
+    enum ClientResourceStatus {
+      // Client requested this resource but hasn't received any update from
+      // management server. The client will not fail requests, but will queue
+      // them until update arrives or the client times out waiting for the
+      // resource.
+      REQUESTED = 1,
+      // This resource has been requested by the client but has either not been
+      // delivered by the server or was previously delivered by the server and
+      // then subsequently removed from resources provided by the server.
+      DOES_NOT_EXIST,
+      // Client received this resource and replied with ACK.
+      ACKED,
+      // Client received this resource and replied with NACK.
+      NACKED,
+    };
+    static_assert(static_cast<ClientResourceStatus>(envoy_admin_v3_REQUESTED) ==
+                  ClientResourceStatus::REQUESTED);
+    static_assert(
+        static_cast<ClientResourceStatus>(envoy_admin_v3_DOES_NOT_EXIST) ==
+        ClientResourceStatus::DOES_NOT_EXIST);
+    static_assert(static_cast<ClientResourceStatus>(envoy_admin_v3_ACKED) ==
+                  ClientResourceStatus::ACKED);
+    static_assert(static_cast<ClientResourceStatus>(envoy_admin_v3_NACKED) ==
+                  ClientResourceStatus::NACKED);
+
+    void AddWatcher(RefCountedPtr<ResourceWatcherInterface> watcher) {
+      watchers_.insert(std::move(watcher));
+    }
+    void RemoveWatcher(ResourceWatcherInterface* watcher) {
+      watchers_.erase(watcher);
+    }
+    bool HasWatchers() const { return !watchers_.empty(); }
+    const WatcherSet& watchers() const { return watchers_; }
+
+    void SetAcked(std::shared_ptr<const XdsResourceType::ResourceData> resource,
+                  std::string serialized_proto, std::string version,
+                  Timestamp update_time);
+    void SetNacked(const std::string& version, const std::string& details,
+                   Timestamp update_time);
+    void SetDoesNotExist();
+
+    void set_ignored_deletion(bool value) { ignored_deletion_ = value; }
+    bool ignored_deletion() const { return ignored_deletion_; }
+
+    ClientResourceStatus client_status() const { return client_status_; }
+    absl::string_view CacheStateString() const;
+
+    bool HasResource() const { return resource_ != nullptr; }
+    std::shared_ptr<const XdsResourceType::ResourceData> resource() const {
+      return resource_;
+    }
+
+    absl::string_view failed_details() const { return failed_details_; }
+
+    void FillGenericXdsConfig(
+        upb_StringView type_url, upb_StringView resource_name, upb_Arena* arena,
+        envoy_service_status_v3_ClientConfig_GenericXdsConfig* entry) const;
+
+   private:
+    WatcherSet watchers_;
     // The latest data seen for the resource.
-    std::shared_ptr<const XdsResourceType::ResourceData> resource;
-    XdsApi::ResourceMetadata meta;
-    bool ignored_deletion = false;
+    std::shared_ptr<const XdsResourceType::ResourceData> resource_;
+    // Cache state.
+    ClientResourceStatus client_status_ = REQUESTED;
+    // The serialized bytes of the last successfully updated raw xDS resource.
+    std::string serialized_proto_;
+    // The timestamp when the resource was last successfully updated.
+    Timestamp update_time_;
+    // The last successfully updated version of the resource.
+    std::string version_;
+    // The rejected version string of the last failed update attempt.
+    std::string failed_version_;
+    // Details about the last failed update attempt.
+    std::string failed_details_;
+    // Timestamp of the last failed update attempt.
+    Timestamp failed_update_time_;
+    // If we've ignored deletion.
+    bool ignored_deletion_ = false;
   };
 
   struct AuthorityState {
@@ -268,15 +348,16 @@ class XdsClient : public DualRefCounted<XdsClient> {
         resource_map;
   };
 
-  // Sends an error notification to a specific set of watchers.
-  void NotifyWatchersOnErrorLocked(
-      const std::map<ResourceWatcherInterface*,
-                     RefCountedPtr<ResourceWatcherInterface>>& watchers,
-      absl::Status status, RefCountedPtr<ReadDelayHandle> read_delay_handle);
-  // Sends a resource-does-not-exist notification to a specific set of watchers.
-  void NotifyWatchersOnResourceDoesNotExist(
-      const std::map<ResourceWatcherInterface*,
-                     RefCountedPtr<ResourceWatcherInterface>>& watchers,
+  absl::Status AppendNodeToStatus(const absl::Status& status) const;
+
+  // Sends an OnResourceChanged() notification to a specific set of watchers.
+  void NotifyWatchersOnResourceChanged(
+      absl::StatusOr<std::shared_ptr<const XdsResourceType::ResourceData>>
+          resource,
+      WatcherSet watchers, RefCountedPtr<ReadDelayHandle> read_delay_handle);
+  // Sends an OnAmbientError() notification to a specific set of watchers.
+  void NotifyWatchersOnAmbientError(
+      absl::Status status, WatcherSet watchers,
       RefCountedPtr<ReadDelayHandle> read_delay_handle);
 
   void MaybeRegisterResourceTypeLocked(const XdsResourceType* resource_type)
@@ -299,10 +380,11 @@ class XdsClient : public DualRefCounted<XdsClient> {
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
   std::shared_ptr<XdsBootstrap> bootstrap_;
+  const std::string user_agent_name_;
+  const std::string user_agent_version_;
   RefCountedPtr<XdsTransportFactory> transport_factory_;
   const Duration request_timeout_;
   const bool xds_federation_enabled_;
-  XdsApi api_;
   WorkSerializer work_serializer_;
   std::shared_ptr<grpc_event_engine::experimental::EventEngine> engine_;
   std::unique_ptr<XdsMetricsReporter> metrics_reporter_;
@@ -323,8 +405,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
 
   // Stores started watchers whose resource name was not parsed successfully,
   // waiting to be cancelled or reset in Orphan().
-  std::map<ResourceWatcherInterface*, RefCountedPtr<ResourceWatcherInterface>>
-      invalid_watchers_ ABSL_GUARDED_BY(mu_);
+  WatcherSet invalid_watchers_ ABSL_GUARDED_BY(mu_);
 
   bool shutting_down_ ABSL_GUARDED_BY(mu_) = false;
 };

data/src/core/xds/xds_client/xds_resource_type_impl.h

@@ -41,18 +41,23 @@ class XdsResourceTypeImpl : public XdsResourceType {
   class WatcherInterface : public XdsClient::ResourceWatcherInterface {
    public:
     virtual void OnResourceChanged(
-        std::shared_ptr<const ResourceType> resource,
+        absl::StatusOr<std::shared_ptr<const ResourceType>> resource,
         RefCountedPtr<XdsClient::ReadDelayHandle> read_delay_handle) = 0;
 
    private:
     // Get result from XdsClient generic watcher interface, perform
     // down-casting, and invoke the caller's OnResourceChanged() method.
     void OnGenericResourceChanged(
-        std::shared_ptr<const XdsResourceType::ResourceData> resource,
+        absl::StatusOr<std::shared_ptr<const XdsResourceType::ResourceData>>
+            resource,
         RefCountedPtr<XdsClient::ReadDelayHandle> read_delay_handle) override {
-      OnResourceChanged(
-          std::static_pointer_cast<const ResourceType>(std::move(resource)),
-          std::move(read_delay_handle));
+      if (!resource.ok()) {
+        OnResourceChanged(resource.status(), std::move(read_delay_handle));
+      } else {
+        OnResourceChanged(
+            std::static_pointer_cast<const ResourceType>(std::move(*resource)),
+            std::move(read_delay_handle));
+      }
     }
   };
 

data/src/ruby/ext/grpc/extconf.rb

@@ -149,6 +149,7 @@ $CFLAGS << ' -g'
 def have_ruby_abi_version()
   return true if RUBY_ENGINE == 'truffleruby'
   # ruby_abi_version is only available in development versions: https://github.com/ruby/ruby/pull/6231
+  # See also discussion for Ruby 3.4 in https://github.com/grpc/grpc/pull/38338 and https://github.com/grpc/grpc/pull/38487
   return false if RUBY_PATCHLEVEL >= 0
 
   m = /(\d+)\.(\d+)/.match(RUBY_VERSION)

data/src/ruby/lib/grpc/version.rb

@@ -14,5 +14,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '1.69.0'
+  VERSION = '1.70.1'
 end

data/third_party/boringssl-with-bazel/src/crypto/asn1/{a_bitstr.c → a_bitstr.cc}

@@ -142,6 +142,7 @@ ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a,
   const unsigned char *p;
   unsigned char *s;
   int padding;
+  uint8_t padding_mask;
 
   if (len < 1) {
     OPENSSL_PUT_ERROR(ASN1, ASN1_R_STRING_TOO_SHORT);
@@ -170,7 +171,7 @@ ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a,
   }
 
   // Unused bits in a BIT STRING must be zero.
-  uint8_t padding_mask = (1 << padding) - 1;
+  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;
@@ -182,7 +183,7 @@ ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a,
   ret->flags |= (ASN1_STRING_FLAG_BITS_LEFT | padding);  // set
 
   if (len > 0) {
-    s = OPENSSL_memdup(p, len);
+    s = reinterpret_cast<uint8_t *>(OPENSSL_memdup(p, len));
     if (s == NULL) {
       goto err;
     }

data/third_party/boringssl-with-bazel/src/crypto/asn1/{a_d2i_fp.c → a_d2i_fp.cc}

@@ -72,7 +72,7 @@ void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x) {
     return NULL;
   }
   const uint8_t *ptr = data;
-  void *ret = ASN1_item_d2i(x, &ptr, len, it);
+  void *ret = ASN1_item_d2i(reinterpret_cast<ASN1_VALUE **>(x), &ptr, len, it);
   OPENSSL_free(data);
   return ret;
 }

data/third_party/boringssl-with-bazel/src/crypto/asn1/{a_dup.c → a_dup.cc}

@@ -73,7 +73,7 @@ void *ASN1_item_dup(const ASN1_ITEM *it, void *x) {
     return NULL;
   }
 
-  i = ASN1_item_i2d(x, &b, it);
+  i = ASN1_item_i2d(reinterpret_cast<ASN1_VALUE *>(x), &b, it);
   if (b == NULL) {
     return NULL;
   }

data/third_party/boringssl-with-bazel/src/crypto/asn1/{a_i2d_fp.c → a_i2d_fp.cc}

@@ -74,7 +74,7 @@ int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x) {
 
 int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x) {
   unsigned char *b = NULL;
-  int n = ASN1_item_i2d(x, &b, it);
+  int n = ASN1_item_i2d(reinterpret_cast<ASN1_VALUE *>(x), &b, it);
   if (b == NULL) {
     return 0;
   }

data/third_party/boringssl-with-bazel/src/crypto/asn1/{a_int.c → a_int.cc}

@@ -408,6 +408,7 @@ static ASN1_STRING *bn_to_asn1_string(const BIGNUM *bn, ASN1_STRING *ai,
   } else {
     ret = ai;
   }
+  int len;
   if (ret == NULL) {
     OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_ASN1_ERROR);
     goto err;
@@ -419,7 +420,7 @@ static ASN1_STRING *bn_to_asn1_string(const BIGNUM *bn, ASN1_STRING *ai,
     ret->type = type;
   }
 
-  int len = BN_num_bytes(bn);
+  len = BN_num_bytes(bn);
   if (!ASN1_STRING_set(ret, NULL, len) ||
       !BN_bn2bin_padded(ret->data, len, bn)) {
     goto err;

data/third_party/boringssl-with-bazel/src/crypto/asn1/{a_mbstr.c → a_mbstr.cc}

@@ -226,6 +226,8 @@ int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in,
   CBB cbb;
   CBB_zero(&cbb);
   // If both the same type just copy across
+  uint8_t *data = NULL;
+  size_t data_len = 0;
   if (inform == outform) {
     if (!ASN1_STRING_set(dest, in, len)) {
       goto err;
@@ -245,12 +247,12 @@ int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in,
       goto err;
     }
   }
-  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|.
-      !CBB_add_u8(&cbb, 0) || !CBB_finish(&cbb, &data, &data_len) ||
-      data_len < 1 || data_len > INT_MAX) {
+  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);
     OPENSSL_free(data);
     goto err;
@@ -272,7 +274,7 @@ int asn1_is_printable(uint32_t value) {
   if (value > 0x7f) {
     return 0;
   }
-  return OPENSSL_isalnum(value) || //
+  return OPENSSL_isalnum(value) ||  //
          value == ' ' || value == '\'' || value == '(' || value == ')' ||
          value == '+' || value == ',' || value == '-' || value == '.' ||
          value == '/' || value == ':' || value == '=' || value == '?';

data/third_party/boringssl-with-bazel/src/crypto/asn1/{a_object.c → a_object.cc}

@@ -114,7 +114,7 @@ int i2a_ASN1_OBJECT(BIO *bp, const ASN1_OBJECT *a) {
   int len = i2t_ASN1_OBJECT(buf, sizeof(buf), a);
   if (len > (int)sizeof(buf) - 1) {
     // The input was truncated. Allocate a buffer that fits.
-    allocated = OPENSSL_malloc(len + 1);
+    allocated = reinterpret_cast<char *>(OPENSSL_malloc(len + 1));
     if (allocated == NULL) {
       return -1;
     }

data/third_party/boringssl-with-bazel/src/crypto/asn1/{a_strnid.c → a_strnid.cc}

@@ -159,7 +159,8 @@ static int table_cmp(const ASN1_STRING_TABLE *a, const ASN1_STRING_TABLE *b) {
 }
 
 static int table_cmp_void(const void *a, const void *b) {
-  return table_cmp(a, b);
+  return table_cmp(reinterpret_cast<const ASN1_STRING_TABLE *>(a),
+                   reinterpret_cast<const ASN1_STRING_TABLE *>(b));
 }
 
 static uint32_t table_hash(const ASN1_STRING_TABLE *tbl) {
@@ -169,9 +170,9 @@ static uint32_t table_hash(const ASN1_STRING_TABLE *tbl) {
 static const ASN1_STRING_TABLE *asn1_string_table_get(int nid) {
   ASN1_STRING_TABLE key;
   key.nid = nid;
-  const ASN1_STRING_TABLE *tbl =
+  const ASN1_STRING_TABLE *tbl = reinterpret_cast<ASN1_STRING_TABLE *>(
       bsearch(&key, tbl_standard, OPENSSL_ARRAY_SIZE(tbl_standard),
-              sizeof(ASN1_STRING_TABLE), table_cmp_void);
+              sizeof(ASN1_STRING_TABLE), table_cmp_void));
   if (tbl != NULL) {
     return tbl;
   }
@@ -198,6 +199,7 @@ int ASN1_STRING_TABLE_add(int nid, long minsize, long maxsize,
   int ret = 0;
   CRYPTO_MUTEX_lock_write(&string_tables_lock);
 
+  ASN1_STRING_TABLE *tbl = NULL;
   if (string_tables == NULL) {
     string_tables = lh_ASN1_STRING_TABLE_new(table_hash, table_cmp);
     if (string_tables == NULL) {
@@ -214,7 +216,8 @@ int ASN1_STRING_TABLE_add(int nid, long minsize, long maxsize,
     }
   }
 
-  ASN1_STRING_TABLE *tbl = OPENSSL_malloc(sizeof(ASN1_STRING_TABLE));
+  tbl = reinterpret_cast<ASN1_STRING_TABLE *>(
+      OPENSSL_malloc(sizeof(ASN1_STRING_TABLE)));
   if (tbl == NULL) {
     goto err;
   }

data/third_party/boringssl-with-bazel/src/crypto/asn1/{a_type.c → a_type.cc}

@@ -137,10 +137,10 @@ void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value) {
       a->value.boolean = value ? ASN1_BOOLEAN_TRUE : ASN1_BOOLEAN_FALSE;
       break;
     case V_ASN1_OBJECT:
-      a->value.object = value;
+      a->value.object = reinterpret_cast<ASN1_OBJECT *>(value);
       break;
     default:
-      a->value.asn1_string = value;
+      a->value.asn1_string = reinterpret_cast<ASN1_STRING *>(value);
       break;
   }
 }
@@ -151,14 +151,14 @@ int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value) {
     ASN1_TYPE_set(a, type, p);
   } else if (type == V_ASN1_OBJECT) {
     ASN1_OBJECT *odup;
-    odup = OBJ_dup(value);
+    odup = OBJ_dup(reinterpret_cast<const ASN1_OBJECT *>(value));
     if (!odup) {
       return 0;
     }
     ASN1_TYPE_set(a, type, odup);
   } else {
     ASN1_STRING *sdup;
-    sdup = ASN1_STRING_dup(value);
+    sdup = ASN1_STRING_dup(reinterpret_cast<const ASN1_STRING *>(value));
     if (!sdup) {
       return 0;
     }

data/third_party/boringssl-with-bazel/src/crypto/asn1/{asn1_lib.c → asn1_lib.cc}

@@ -271,7 +271,7 @@ ASN1_STRING *ASN1_STRING_dup(const ASN1_STRING *str) {
 }
 
 int ASN1_STRING_set(ASN1_STRING *str, const void *_data, ossl_ssize_t len_s) {
-  const char *data = _data;
+  const char *data = reinterpret_cast<const char *>(_data);
   size_t len;
   if (len_s < 0) {
     if (data == NULL) {
@@ -291,9 +291,9 @@ int ASN1_STRING_set(ASN1_STRING *str, const void *_data, ossl_ssize_t len_s) {
   if (str->length <= (int)len || str->data == NULL) {
     unsigned char *c = str->data;
     if (c == NULL) {
-      str->data = OPENSSL_malloc(len + 1);
+      str->data = reinterpret_cast<uint8_t *>(OPENSSL_malloc(len + 1));
     } else {
-      str->data = OPENSSL_realloc(c, len + 1);
+      str->data = reinterpret_cast<uint8_t *>(OPENSSL_realloc(c, len + 1));
     }
 
     if (str->data == NULL) {
@@ -315,7 +315,7 @@ int ASN1_STRING_set(ASN1_STRING *str, const void *_data, ossl_ssize_t len_s) {
 
 void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len) {
   OPENSSL_free(str->data);
-  str->data = data;
+  str->data = reinterpret_cast<uint8_t *>(data);
   str->length = len;
 }
 

data/third_party/boringssl-with-bazel/src/crypto/asn1/{asn_pack.c → asn_pack.cc}

@@ -62,7 +62,7 @@
 
 ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it, ASN1_STRING **out) {
   uint8_t *new_data = NULL;
-  int len = ASN1_item_i2d(obj, &new_data, it);
+  int len = ASN1_item_i2d(reinterpret_cast<ASN1_VALUE *>(obj), &new_data, it);
   if (len <= 0) {
     OPENSSL_PUT_ERROR(ASN1, ASN1_R_ENCODE_ERROR);
     return NULL;
@@ -91,7 +91,7 @@ void *ASN1_item_unpack(const ASN1_STRING *oct, const ASN1_ITEM *it) {
   void *ret = ASN1_item_d2i(NULL, &p, oct->length, it);
   if (ret == NULL || p != oct->data + oct->length) {
     OPENSSL_PUT_ERROR(ASN1, ASN1_R_DECODE_ERROR);
-    ASN1_item_free(ret, it);
+    ASN1_item_free(reinterpret_cast<ASN1_VALUE *>(ret), it);
     return NULL;
   }
   return ret;

data/third_party/boringssl-with-bazel/src/crypto/asn1/{posix_time.c → posix_time.cc}

@@ -1,4 +1,4 @@
-/* Copyright (c) 2022, Google Inc.
+/* Copyright 2022 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -154,7 +154,7 @@ int OPENSSL_tm_to_posix(const struct tm *tm, int64_t *out) {
 }
 
 int OPENSSL_posix_to_tm(int64_t time, struct tm *out_tm) {
-  struct tm tmp_tm = {0};
+  struct tm tmp_tm = {};
   if (!utc_from_posix_time(time, &tmp_tm.tm_year, &tmp_tm.tm_mon,
                            &tmp_tm.tm_mday, &tmp_tm.tm_hour, &tmp_tm.tm_min,
                            &tmp_tm.tm_sec)) {

data/third_party/boringssl-with-bazel/src/crypto/asn1/{tasn_dec.c → tasn_dec.cc}

@@ -282,7 +282,8 @@ static int asn1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in,
         OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_TEMPLATE);
         goto err;
       }
-      const ASN1_EXTERN_FUNCS *ef = it->funcs;
+      const ASN1_EXTERN_FUNCS *ef =
+          reinterpret_cast<const ASN1_EXTERN_FUNCS *>(it->funcs);
       return ef->asn1_ex_d2i(pval, in, len, it, opt, NULL);
     }
 
@@ -294,7 +295,7 @@ static int asn1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in,
         goto err;
       }
 
-      const ASN1_AUX *aux = it->funcs;
+      const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
       ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
       if (asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it, NULL)) {
         goto auxerr;
@@ -379,7 +380,7 @@ static int asn1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in,
         goto err;
       }
 
-      const ASN1_AUX *aux = it->funcs;
+      const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
       ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
       if (asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it, NULL)) {
         goto auxerr;

data/third_party/boringssl-with-bazel/src/crypto/asn1/{tasn_enc.c → tasn_enc.cc}

@@ -90,7 +90,7 @@ int ASN1_item_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it) {
     if (len <= 0) {
       return len;
     }
-    buf = OPENSSL_malloc(len);
+    buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(len));
     if (!buf) {
       return -1;
     }
@@ -191,7 +191,8 @@ int asn1_item_ex_i2d_opt(ASN1_VALUE **pval, unsigned char **out,
         OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_TEMPLATE);
         return -1;
       }
-      const ASN1_EXTERN_FUNCS *ef = it->funcs;
+      const ASN1_EXTERN_FUNCS *ef =
+          reinterpret_cast<const ASN1_EXTERN_FUNCS *>(it->funcs);
       int ret = ef->asn1_ex_i2d(pval, out, it);
       if (ret == 0) {
         // |asn1_ex_i2d| should never return zero. We have already checked
@@ -424,7 +425,8 @@ typedef struct {
 } DER_ENC;
 
 static int der_cmp(const void *a, const void *b) {
-  const DER_ENC *d1 = a, *d2 = b;
+  const DER_ENC *d1 = reinterpret_cast<const DER_ENC *>(a),
+                *d2 = reinterpret_cast<const DER_ENC *>(b);
   int cmplen, i;
   cmplen = (d1->length < d2->length) ? d1->length : d2->length;
   i = OPENSSL_memcmp(d1->data, d2->data, cmplen);
@@ -453,14 +455,15 @@ static int asn1_set_seq_out(STACK_OF(ASN1_VALUE) *sk, unsigned char **out,
   }
 
   int ret = 0;
-  unsigned char *const buf = OPENSSL_malloc(skcontlen);
-  DER_ENC *encoded = OPENSSL_calloc(sk_ASN1_VALUE_num(sk), sizeof(*encoded));
+  uint8_t *const buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(skcontlen));
+  DER_ENC *encoded = reinterpret_cast<DER_ENC *>(
+      OPENSSL_calloc(sk_ASN1_VALUE_num(sk), sizeof(*encoded)));
+  uint8_t *p = buf;
   if (encoded == NULL || buf == NULL) {
     goto err;
   }
 
   // Encode all the elements into |buf| and populate |encoded|.
-  unsigned char *p = buf;
   for (size_t i = 0; i < sk_ASN1_VALUE_num(sk); i++) {
     ASN1_VALUE *skitem = sk_ASN1_VALUE_value(sk, i);
     encoded[i].data = p;

data/third_party/boringssl-with-bazel/src/crypto/asn1/{tasn_fre.c → tasn_fre.cc}

@@ -70,9 +70,6 @@ void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it) {
 }
 
 void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
-  const ASN1_TEMPLATE *tt = NULL, *seqtt;
-  const ASN1_EXTERN_FUNCS *ef;
-  int i;
   if (!pval) {
     return;
   }
@@ -94,19 +91,17 @@ void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
       break;
 
     case ASN1_ITYPE_CHOICE: {
-      const ASN1_AUX *aux = it->funcs;
+      const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
       ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
       if (asn1_cb) {
-        i = asn1_cb(ASN1_OP_FREE_PRE, pval, it, NULL);
-        if (i == 2) {
+        if (asn1_cb(ASN1_OP_FREE_PRE, pval, it, NULL) == 2) {
           return;
         }
       }
-      i = asn1_get_choice_selector(pval, it);
+      int i = asn1_get_choice_selector(pval, it);
       if ((i >= 0) && (i < it->tcount)) {
-        ASN1_VALUE **pchval;
-        tt = it->templates + i;
-        pchval = asn1_get_field_ptr(pval, tt);
+        const ASN1_TEMPLATE *tt = it->templates + i;
+        ASN1_VALUE **pchval = asn1_get_field_ptr(pval, tt);
         ASN1_template_free(pchval, tt);
       }
       if (asn1_cb) {
@@ -117,22 +112,23 @@ void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
       break;
     }
 
-    case ASN1_ITYPE_EXTERN:
-      ef = it->funcs;
+    case ASN1_ITYPE_EXTERN: {
+      const ASN1_EXTERN_FUNCS *ef =
+          reinterpret_cast<const ASN1_EXTERN_FUNCS *>(it->funcs);
       if (ef && ef->asn1_ex_free) {
         ef->asn1_ex_free(pval, it);
       }
       break;
+    }
 
     case ASN1_ITYPE_SEQUENCE: {
       if (!asn1_refcount_dec_and_test_zero(pval, it)) {
         return;
       }
-      const ASN1_AUX *aux = it->funcs;
+      const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
       ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
       if (asn1_cb) {
-        i = asn1_cb(ASN1_OP_FREE_PRE, pval, it, NULL);
-        if (i == 2) {
+        if (asn1_cb(ASN1_OP_FREE_PRE, pval, it, NULL) == 2) {
           return;
         }
       }
@@ -140,14 +136,12 @@ void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
       // If we free up as normal we will invalidate any ANY DEFINED BY
       // field and we wont be able to determine the type of the field it
       // defines. So free up in reverse order.
-      tt = it->templates + it->tcount - 1;
-      for (i = 0; i < it->tcount; tt--, i++) {
-        ASN1_VALUE **pseqval;
-        seqtt = asn1_do_adb(pval, tt, 0);
+      for (int i = it->tcount - 1; i >= 0; i--) {
+        const ASN1_TEMPLATE *seqtt = asn1_do_adb(pval, &it->templates[i], 0);
         if (!seqtt) {
           continue;
         }
-        pseqval = asn1_get_field_ptr(pval, seqtt);
+        ASN1_VALUE **pseqval = asn1_get_field_ptr(pval, seqtt);
         ASN1_template_free(pseqval, seqtt);
       }
       if (asn1_cb) {