grpc 1.39.0 → 1.40.0.pre1

data/src/core/lib/gprpp/manual_constructor.h

@@ -210,4 +210,4 @@ class ManualConstructor {
 
 }  // namespace grpc_core
 
-#endif
+#endif  // GRPC_CORE_LIB_GPRPP_MANUAL_CONSTRUCTOR_H

data/src/core/lib/gprpp/orphanable.h

@@ -72,7 +72,7 @@ inline OrphanablePtr<T> MakeOrphanable(Args&&... args) {
 }
 
 // A type of Orphanable with internal ref-counting.
-template <typename Child>
+template <typename Child, UnrefBehavior UnrefBehaviorArg = kUnrefDelete>
 class InternallyRefCounted : public Orphanable {
  public:
   // Not copyable nor movable.
@@ -102,12 +102,12 @@ class InternallyRefCounted : public Orphanable {
 
   void Unref() {
     if (GPR_UNLIKELY(refs_.Unref())) {
-      delete this;
+      internal::Delete<Child, UnrefBehaviorArg>(static_cast<Child*>(this));
     }
   }
   void Unref(const DebugLocation& location, const char* reason) {
     if (GPR_UNLIKELY(refs_.Unref(location, reason))) {
-      delete this;
+      internal::Delete<Child, UnrefBehaviorArg>(static_cast<Child*>(this));
     }
   }
 

data/src/core/lib/gprpp/sync.h

@@ -19,10 +19,9 @@
 #ifndef GRPC_CORE_LIB_GPRPP_SYNC_H
 #define GRPC_CORE_LIB_GPRPP_SYNC_H
 
-#include <grpc/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/log.h>
-#include <grpc/impl/codegen/sync.h>
+#include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
@@ -145,33 +144,6 @@ class CondVar {
 
 #endif  // GPR_ABSEIL_SYNC
 
-template <typename Predicate>
-static void WaitUntil(CondVar* cv, Mutex* mu, Predicate pred) {
-  while (!pred()) {
-    cv->Wait(mu);
-  }
-}
-
-// Returns true iff we timed-out
-template <typename Predicate>
-static bool WaitUntilWithTimeout(CondVar* cv, Mutex* mu, Predicate pred,
-                                 absl::Duration timeout) {
-  while (!pred()) {
-    if (cv->WaitWithTimeout(mu, timeout)) return true;
-  }
-  return false;
-}
-
-// Returns true iff we timed-out
-template <typename Predicate>
-static bool WaitUntilWithDeadline(CondVar* cv, Mutex* mu, Predicate pred,
-                                  absl::Time deadline) {
-  while (!pred()) {
-    if (cv->WaitWithDeadline(mu, deadline)) return true;
-  }
-  return false;
-}
-
 // Deprecated. Prefer MutexLock
 class MutexLockForGprMu {
  public:

data/src/core/lib/iomgr/buffer_list.cc

@@ -190,7 +190,7 @@ void extract_opt_stats_from_cmsg(ConnectionMetrics* metrics,
 
 static int get_socket_tcp_info(grpc_core::tcp_info* info, int fd) {
   memset(info, 0, sizeof(*info));
-  info->length = sizeof(*info) - sizeof(socklen_t);
+  info->length = offsetof(grpc_core::tcp_info, length);
   return getsockopt(fd, IPPROTO_TCP, TCP_INFO, info, &(info->length));
 }
 } /* namespace */

data/src/core/lib/iomgr/ev_apple.h

@@ -40,4 +40,4 @@ extern grpc_pollset_set_vtable grpc_apple_pollset_set_vtable;
 
 #endif
 
-#endif
+#endif  // GRPC_CORE_LIB_IOMGR_EV_APPLE_H

data/src/core/lib/iomgr/event_engine/endpoint.cc

@@ -59,7 +59,7 @@ void endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
         exec_ctx.Flush();
         grpc_pollset_ee_broadcast_event();
       },
-      read_buffer, absl::InfiniteFuture());
+      read_buffer);
 }
 
 void endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
@@ -83,7 +83,7 @@ void endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
         exec_ctx.Flush();
         grpc_pollset_ee_broadcast_event();
       },
-      write_buffer, absl::InfiniteFuture());
+      write_buffer);
 }
 void endpoint_add_to_pollset(grpc_endpoint* /* ep */,
                              grpc_pollset* /* pollset */) {}
@@ -123,9 +123,8 @@ absl::string_view endpoint_get_peer(grpc_endpoint* ep) {
     return "";
   }
   if (eeep->peer_address.empty()) {
-    const EventEngine::ResolvedAddress* addr = eeep->endpoint->GetPeerAddress();
-    GPR_ASSERT(addr != nullptr);
-    eeep->peer_address = ResolvedAddressToURI(*addr);
+    const EventEngine::ResolvedAddress& addr = eeep->endpoint->GetPeerAddress();
+    eeep->peer_address = ResolvedAddressToURI(addr);
   }
   return eeep->peer_address;
 }
@@ -136,10 +135,9 @@ absl::string_view endpoint_get_local_address(grpc_endpoint* ep) {
     return "";
   }
   if (eeep->local_address.empty()) {
-    const EventEngine::ResolvedAddress* addr =
+    const EventEngine::ResolvedAddress& addr =
         eeep->endpoint->GetLocalAddress();
-    GPR_ASSERT(addr != nullptr);
-    eeep->local_address = ResolvedAddressToURI(*addr);
+    eeep->local_address = ResolvedAddressToURI(addr);
   }
   return eeep->local_address;
 }

data/src/core/lib/iomgr/event_engine/tcp.cc

@@ -38,20 +38,36 @@ using ::grpc_event_engine::experimental::EventEngine;
 using ::grpc_event_engine::experimental::GrpcClosureToCallback;
 using ::grpc_event_engine::experimental::SliceAllocator;
 using ::grpc_event_engine::experimental::SliceAllocatorFactory;
+using ::grpc_event_engine::experimental::SliceBuffer;
 }  // namespace
 
+// TODO(hork): remove these classes in PR #26643, when the iomgr APIs change to
+// accept SliceAllocators and SliceAllocatorFactory(ie)s. In the meantime, the
+// libuv work has temporary implementations as well.
+class NoopSliceAllocator : public SliceAllocator {
+ public:
+  absl::Status Allocate(size_t size, SliceBuffer* dest,
+                        SliceAllocator::AllocateCallback cb) {
+    return absl::OkStatus();
+  }
+};
+
+class NoopSliceAllocatorFactory : public SliceAllocatorFactory {
+ public:
+  std::unique_ptr<SliceAllocator> CreateSliceAllocator(
+      absl::string_view peer_name) {
+    return absl::make_unique<NoopSliceAllocator>();
+  };
+};
+
 struct grpc_tcp_server {
-  grpc_tcp_server(std::unique_ptr<EventEngine::Listener> listener,
-                  grpc_resource_quota* rq)
+  explicit grpc_tcp_server(std::unique_ptr<EventEngine::Listener> listener)
       : refcount(1, GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) ? "tcp" : nullptr),
-        listener(std::move(listener)),
-        resource_quota(rq) {
+        listener(std::move(listener)) {
     shutdown_starting.head = nullptr;
     shutdown_starting.tail = nullptr;
   };
   ~grpc_tcp_server() {
-    // TODO(nnoble): see if we can handle this in ~SliceAllocatorFactory
-    grpc_resource_quota_unref_internal(resource_quota);
     grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &shutdown_starting);
     grpc_core::ExecCtx::Get()->Flush();
   }
@@ -59,7 +75,6 @@ struct grpc_tcp_server {
   grpc_core::Mutex mu;
   std::unique_ptr<EventEngine::Listener> listener;
   grpc_closure_list shutdown_starting ABSL_GUARDED_BY(mu);
-  grpc_resource_quota* resource_quota;
   grpc_tcp_server_cb on_accept_internal;
   void* on_accept_internal_arg;
 };
@@ -99,7 +114,9 @@ void tcp_connect(grpc_closure* on_connect, grpc_endpoint** endpoint,
   *endpoint = &ee_endpoint->base;
   EventEngine::OnConnectCallback ee_on_connect =
       GrpcClosureToOnConnectCallback(on_connect, endpoint);
-  SliceAllocator sa(ee_endpoint->ru);
+  // TODO(hork): tcp_connect will change to accept a SliceAllocator. This is
+  // temporary.
+  auto sa = absl::make_unique<NoopSliceAllocator>();
   EventEngine::ResolvedAddress ra(reinterpret_cast<const sockaddr*>(addr->addr),
                                   addr->len);
   absl::Time ee_deadline = grpc_core::ToAbslTime(
@@ -124,6 +141,9 @@ grpc_error* tcp_server_create(grpc_closure* shutdown_complete,
   if (rq == nullptr) {
     rq = grpc_resource_quota_create(nullptr);
   }
+  // TODO(hork): tcp_server_create will change to accept a
+  // SliceAllocatorFactory. This is temporary.
+  auto saf = absl::make_unique<NoopSliceAllocatorFactory>();
   EventEngine* event_engine = grpc_iomgr_event_engine();
   absl::StatusOr<std::unique_ptr<EventEngine::Listener>> listener =
       event_engine->CreateListener(
@@ -144,11 +164,11 @@ grpc_error* tcp_server_create(grpc_closure* shutdown_complete,
             grpc_pollset_ee_broadcast_event();
           },
           GrpcClosureToCallback(shutdown_complete, GRPC_ERROR_NONE),
-          endpoint_config, SliceAllocatorFactory(rq));
+          endpoint_config, std::move(saf));
   if (!listener.ok()) {
     return absl_status_to_grpc_error(listener.status());
   }
-  *server = new grpc_tcp_server(std::move(*listener), rq);
+  *server = new grpc_tcp_server(std::move(*listener));
   return GRPC_ERROR_NONE;
 }
 

data/src/core/lib/iomgr/python_util.h

@@ -43,4 +43,4 @@ inline int grpc_slice_buffer_length(grpc_slice_buffer* buffer, int i) {
   return GRPC_SLICE_LENGTH(buffer->slices[i]);
 }
 
-#endif
+#endif  // GRPC_CORE_LIB_IOMGR_PYTHON_UTIL_H

data/src/core/lib/iomgr/resource_quota.cc

@@ -805,6 +805,8 @@ grpc_resource_user* grpc_resource_user_create(
   for (int i = 0; i < GRPC_RULIST_COUNT; i++) {
     resource_user->links[i].next = resource_user->links[i].prev = nullptr;
   }
+  // TODO(hork): the RU should own a copy of the name. See Craig's comments on
+  // the EventEngine gRFC for justification.
   if (name != nullptr) {
     resource_user->name = name;
   } else {

data/src/core/lib/iomgr/tcp_client_windows.cc

@@ -206,8 +206,10 @@ static void tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   GRPC_CLOSURE_INIT(&ac->on_connect, on_connect, ac, grpc_schedule_on_exec_ctx);
 
   GRPC_CLOSURE_INIT(&ac->on_alarm, on_alarm, ac, grpc_schedule_on_exec_ctx);
+  gpr_mu_lock(&ac->mu);
   grpc_timer_init(&ac->alarm, deadline, &ac->on_alarm);
   grpc_socket_notify_on_write(socket, &ac->on_connect);
+  gpr_mu_unlock(&ac->mu);
   return;
 
 failure:

data/src/core/lib/iomgr/tcp_server_posix.cc

@@ -405,6 +405,7 @@ static grpc_error_handle clone_port(grpc_tcp_listener* listener,
 static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
                                              const grpc_resolved_address* addr,
                                              int* out_port) {
+  GPR_ASSERT(addr->len <= GRPC_MAX_SOCKADDR_SIZE);
   grpc_tcp_listener* sp;
   grpc_resolved_address sockname_temp;
   grpc_resolved_address addr6_v4mapped;

data/src/core/lib/iomgr/timer_manager.cc

@@ -250,7 +250,7 @@ static void timer_main_loop() {
           gpr_log(GPR_INFO, "timers not checked: expect another thread to");
         }
         next = GRPC_MILLIS_INF_FUTURE;
-      // fallthrough
+        ABSL_FALLTHROUGH_INTENDED;
       case GRPC_TIMERS_CHECKED_AND_EMPTY:
         if (!wait_until(next)) {
           return;

data/src/core/lib/json/json_reader.cc

@@ -347,8 +347,7 @@ JsonReader::Status JsonReader::Run() {
             }
             if (!SetNumber()) return Status::GRPC_JSON_PARSE_ERROR;
             state_ = State::GRPC_JSON_STATE_VALUE_END;
-            /* The missing break here is intentional. */
-            /* fallthrough */
+            ABSL_FALLTHROUGH_INTENDED;
 
           case State::GRPC_JSON_STATE_VALUE_END:
           case State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN:

data/src/core/lib/matchers/matchers.cc

@@ -32,14 +32,12 @@ absl::StatusOr<StringMatcher> StringMatcher::Create(Type type,
                                                     absl::string_view matcher,
                                                     bool case_sensitive) {
   if (type == Type::kSafeRegex) {
-    RE2::Options options;
-    options.set_case_sensitive(case_sensitive);
-    auto regex_matcher = absl::make_unique<RE2>(std::string(matcher), options);
+    auto regex_matcher = absl::make_unique<RE2>(std::string(matcher));
     if (!regex_matcher->ok()) {
       return absl::InvalidArgumentError(
           "Invalid regex string specified in matcher.");
     }
-    return StringMatcher(std::move(regex_matcher), case_sensitive);
+    return StringMatcher(std::move(regex_matcher));
   } else {
     return StringMatcher(type, matcher, case_sensitive);
   }
@@ -49,19 +47,13 @@ StringMatcher::StringMatcher(Type type, absl::string_view matcher,
                              bool case_sensitive)
     : type_(type), string_matcher_(matcher), case_sensitive_(case_sensitive) {}
 
-StringMatcher::StringMatcher(std::unique_ptr<RE2> regex_matcher,
-                             bool case_sensitive)
-    : type_(Type::kSafeRegex),
-      regex_matcher_(std::move(regex_matcher)),
-      case_sensitive_(case_sensitive) {}
+StringMatcher::StringMatcher(std::unique_ptr<RE2> regex_matcher)
+    : type_(Type::kSafeRegex), regex_matcher_(std::move(regex_matcher)) {}
 
 StringMatcher::StringMatcher(const StringMatcher& other)
     : type_(other.type_), case_sensitive_(other.case_sensitive_) {
   if (type_ == Type::kSafeRegex) {
-    RE2::Options options;
-    options.set_case_sensitive(other.case_sensitive_);
-    regex_matcher_ =
-        absl::make_unique<RE2>(other.regex_matcher_->pattern(), options);
+    regex_matcher_ = absl::make_unique<RE2>(other.regex_matcher_->pattern());
   } else {
     string_matcher_ = other.string_matcher_;
   }
@@ -70,10 +62,7 @@ StringMatcher::StringMatcher(const StringMatcher& other)
 StringMatcher& StringMatcher::operator=(const StringMatcher& other) {
   type_ = other.type_;
   if (type_ == Type::kSafeRegex) {
-    RE2::Options options;
-    options.set_case_sensitive(other.case_sensitive_);
-    regex_matcher_ =
-        absl::make_unique<RE2>(other.regex_matcher_->pattern(), options);
+    regex_matcher_ = absl::make_unique<RE2>(other.regex_matcher_->pattern());
   } else {
     string_matcher_ = other.string_matcher_;
   }
@@ -151,9 +140,8 @@ std::string StringMatcher::ToString() const {
       return absl::StrFormat("StringMatcher{contains=%s%s}", string_matcher_,
                              case_sensitive_ ? "" : ", case_sensitive=false");
     case Type::kSafeRegex:
-      return absl::StrFormat("StringMatcher{safe_regex=%s%s}",
-                             regex_matcher_->pattern(),
-                             case_sensitive_ ? "" : ", case_sensitive=false");
+      return absl::StrFormat("StringMatcher{safe_regex=%s}",
+                             regex_matcher_->pattern());
     default:
       return "";
   }

data/src/core/lib/matchers/matchers.h

@@ -39,6 +39,7 @@ class StringMatcher {
   };
 
   // Creates StringMatcher instance. Returns error status on failure.
+  // Note: case_sensitive is ignored for type kSafeRegex.
   static absl::StatusOr<StringMatcher> Create(Type type,
                                               absl::string_view matcher,
                                               bool case_sensitive = true);
@@ -66,7 +67,7 @@ class StringMatcher {
 
  private:
   StringMatcher(Type type, absl::string_view matcher, bool case_sensitive);
-  StringMatcher(std::unique_ptr<RE2> regex_matcher, bool case_sensitive);
+  explicit StringMatcher(std::unique_ptr<RE2> regex_matcher);
 
   Type type_ = Type::kExact;
   std::string string_matcher_;

data/src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.cc

@@ -21,6 +21,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
+#include <openssl/ssl.h>
 
 #include "src/core/lib/gprpp/stat.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -364,6 +365,54 @@ FileWatcherCertificateProvider::ReadIdentityKeyCertPairFromFiles(
   return absl::nullopt;
 }
 
+absl::StatusOr<bool> PrivateKeyAndCertificateMatch(
+    absl::string_view private_key, absl::string_view cert_chain) {
+  if (private_key.empty()) {
+    return absl::InvalidArgumentError("Private key string is empty.");
+  }
+  if (cert_chain.empty()) {
+    return absl::InvalidArgumentError("Certificate string is empty.");
+  }
+  BIO* cert_bio = BIO_new_mem_buf(cert_chain.data(), cert_chain.size());
+  if (cert_bio == nullptr) {
+    return absl::InvalidArgumentError(
+        "Conversion from certificate string to BIO failed.");
+  }
+  // Reads the first cert from the cert_chain which is expected to be the leaf
+  // cert
+  X509* x509 = PEM_read_bio_X509(cert_bio, nullptr, nullptr, nullptr);
+  BIO_free(cert_bio);
+  if (x509 == nullptr) {
+    return absl::InvalidArgumentError(
+        "Conversion from PEM string to X509 failed.");
+  }
+  EVP_PKEY* public_evp_pkey = X509_get_pubkey(x509);
+  X509_free(x509);
+  if (public_evp_pkey == nullptr) {
+    return absl::InvalidArgumentError(
+        "Extraction of public key from x.509 certificate failed.");
+  }
+  BIO* private_key_bio =
+      BIO_new_mem_buf(private_key.data(), private_key.size());
+  if (private_key_bio == nullptr) {
+    EVP_PKEY_free(public_evp_pkey);
+    return absl::InvalidArgumentError(
+        "Conversion from private key string to BIO failed.");
+  }
+  EVP_PKEY* private_evp_pkey =
+      PEM_read_bio_PrivateKey(private_key_bio, nullptr, nullptr, nullptr);
+  BIO_free(private_key_bio);
+  if (private_evp_pkey == nullptr) {
+    EVP_PKEY_free(public_evp_pkey);
+    return absl::InvalidArgumentError(
+        "Conversion from PEM string to EVP_PKEY failed.");
+  }
+  bool result = EVP_PKEY_cmp(private_evp_pkey, public_evp_pkey) == 1;
+  EVP_PKEY_free(private_evp_pkey);
+  EVP_PKEY_free(public_evp_pkey);
+  return result;
+}
+
 }  // namespace grpc_core
 
 /** -- Wrapper APIs declared in grpc_security.h -- **/

data/src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.h

@@ -23,6 +23,7 @@
 #include <string.h>
 
 #include "absl/container/inlined_vector.h"
+#include "absl/status/statusor.h"
 
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -133,6 +134,12 @@ class FileWatcherCertificateProvider final
   std::map<std::string, WatcherInfo> watcher_info_;
 };
 
+//  Checks if the private key matches the certificate's public key.
+//  Returns a not-OK status on failure, or a bool indicating
+//  whether the key/cert pair matches.
+absl::StatusOr<bool> PrivateKeyAndCertificateMatch(
+    absl::string_view private_key, absl::string_view cert_chain);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CERTIFICATE_PROVIDER_H