grpc 1.45.0 → 1.46.2

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

@@ -0,0 +1,87 @@
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_CORE_LIB_GPRPP_SINGLE_SET_PTR_H
+#define GRPC_CORE_LIB_GPRPP_SINGLE_SET_PTR_H
+
+#include <grpc/support/port_platform.h>
+
+#include <atomic>
+#include <memory>
+
+#include <grpc/support/log.h>
+
+namespace grpc_core {
+
+template <class T, class Deleter = std::default_delete<T>>
+class SingleSetPtr {
+ public:
+  SingleSetPtr() = default;
+  explicit SingleSetPtr(T* p) : p_{p} {}
+  explicit SingleSetPtr(std::unique_ptr<T, Deleter> p) : p_{p.release()} {}
+  ~SingleSetPtr() { Delete(p_.load(std::memory_order_relaxed)); }
+
+  SingleSetPtr(const SingleSetPtr&) = delete;
+  SingleSetPtr& operator=(const SingleSetPtr&) = delete;
+  SingleSetPtr(SingleSetPtr&& other) noexcept
+      : p_(other.p_.exchange(nullptr)) {}
+  SingleSetPtr& operator=(SingleSetPtr&& other) noexcept {
+    Set(other.p_.exchange(nullptr, std::memory_order_acq_rel));
+    return *this;
+  }
+
+  // Set the pointer;
+  // if already set, return the pre-set value and delete ptr;
+  // if deleted, return nullptr and delete ptr.
+  T* Set(T* ptr) {
+    T* expected = nullptr;
+    if (!p_.compare_exchange_strong(expected, ptr, std::memory_order_acq_rel,
+                                    std::memory_order_acquire)) {
+      Delete(ptr);
+      return expected;
+    }
+    return ptr;
+  }
+
+  // Set the pointer from a compatible unique_ptr - with the same caveats as
+  // above.
+  T* Set(std::unique_ptr<T, Deleter> ptr) { return Set(ptr.release()); }
+
+  // Clear the pointer.
+  void Reset() { Delete(p_.exchange(nullptr, std::memory_order_acq_rel)); }
+
+  bool is_set() const {
+    T* p = p_.load(std::memory_order_acquire);
+    return p != nullptr;
+  }
+
+  T* operator->() const {
+    T* p = p_.load(std::memory_order_acquire);
+    GPR_DEBUG_ASSERT(p != nullptr);
+    return p;
+  }
+
+  T& operator*() const { return *operator->(); }
+
+ private:
+  static void Delete(T* p) {
+    if (p == nullptr) return;
+    Deleter()(p);
+  }
+  std::atomic<T*> p_{nullptr};
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_SINGLE_SET_PTR_H

data/src/core/lib/gprpp/status_helper.cc

@@ -20,6 +20,8 @@
 
 #include "src/core/lib/gprpp/status_helper.h"
 
+#include <type_traits>
+
 #include "absl/strings/cord.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/match.h"
@@ -218,9 +220,23 @@ absl::optional<std::string> StatusGetStr(const absl::Status& status,
 
 void StatusSetTime(absl::Status* status, StatusTimeProperty key,
                    absl::Time time) {
+#if !defined(__clang__) && defined(_MSC_VER) && _MSC_VER < 1910
+  // Abseil has a workaround for MSVC 2015 which prevents absl::Time
+  // from being is_trivially_copyable but it's still safe to be
+  // memcopied.
+#elif defined(__GNUG__) && __GNUC__ < 5
+  // GCC versions < 5 do not support std::is_trivially_copyable
+#else
+  static_assert(std::is_trivially_copyable<absl::Time>::value,
+                "absl::Time needs to be able to be memcopied");
+#endif
+  // This is required not to get uninitialized padding of absl::Time.
+  alignas(absl::Time) char buf[sizeof(time)] = {
+      0,
+  };
+  new (buf) absl::Time(time);
   status->SetPayload(GetStatusTimePropertyUrl(key),
-                     absl::Cord(absl::string_view(
-                         reinterpret_cast<const char*>(&time), sizeof(time))));
+                     absl::Cord(absl::string_view(buf, sizeof(time))));
 }
 
 absl::optional<absl::Time> StatusGetTime(const absl::Status& status,

data/src/core/lib/gprpp/time.cc

@@ -155,6 +155,12 @@ gpr_timespec Timestamp::as_timespec(gpr_clock_type clock_type) const {
 }
 
 std::string Timestamp::ToString() const {
+  if (millis_ == std::numeric_limits<int64_t>::max()) {
+    return "@∞";
+  }
+  if (millis_ == std::numeric_limits<int64_t>::min()) {
+    return "@-∞";
+  }
   return "@" + std::to_string(millis_) + "ms";
 }
 
@@ -167,6 +173,12 @@ Duration Duration::FromTimespec(gpr_timespec t) {
 }
 
 std::string Duration::ToString() const {
+  if (millis_ == std::numeric_limits<int64_t>::max()) {
+    return "∞";
+  }
+  if (millis_ == std::numeric_limits<int64_t>::min()) {
+    return "-∞";
+  }
   return std::to_string(millis_) + "ms";
 }
 

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

@@ -120,7 +120,7 @@ class Timestamp {
 // Duration represents a span of time.
 class Duration {
  public:
-  constexpr Duration() : millis_(0) {}
+  constexpr Duration() noexcept : millis_(0) {}
 
   static Duration FromTimespec(gpr_timespec t);
   static Duration FromSecondsAndNanoseconds(int64_t seconds, int32_t nanos);

data/src/core/lib/http/format_request.cc

@@ -40,8 +40,7 @@ static void fill_common_header(const grpc_http_request* request,
                                bool connection_close,
                                std::vector<std::string>* buf) {
   buf->push_back(path);
-  buf->push_back(" HTTP/1.0\r\n");
-  /* just in case some crazy server really expects HTTP/1.1 */
+  buf->push_back(" HTTP/1.1\r\n");
   buf->push_back("Host: ");
   buf->push_back(host);
   buf->push_back("\r\n");

data/src/core/lib/http/httpcli_security_connector.cc

@@ -48,7 +48,7 @@ class grpc_httpcli_ssl_channel_security_connector final
  public:
   explicit grpc_httpcli_ssl_channel_security_connector(char* secure_peer_name)
       : grpc_channel_security_connector(
-            /*url_scheme=*/nullptr,
+            /*url_scheme=*/{},
             /*channel_creds=*/nullptr,
             /*request_metadata_creds=*/nullptr),
         secure_peer_name_(secure_peer_name) {}
@@ -77,7 +77,8 @@ class grpc_httpcli_ssl_channel_security_connector final
     tsi_handshaker* handshaker = nullptr;
     if (handshaker_factory_ != nullptr) {
       tsi_result result = tsi_ssl_client_handshaker_factory_create_handshaker(
-          handshaker_factory_, secure_peer_name_, &handshaker);
+          handshaker_factory_, secure_peer_name_, /*network_bio_buf_size=*/0,
+          /*ssl_bio_buf_size=*/0, &handshaker);
       if (result != TSI_OK) {
         gpr_log(GPR_ERROR, "Handshaker creation failed with error %s.",
                 tsi_result_to_string(result));
@@ -152,9 +153,6 @@ httpcli_ssl_channel_security_connector_create(
 
 class HttpRequestSSLCredentials : public grpc_channel_credentials {
  public:
-  HttpRequestSSLCredentials() : grpc_channel_credentials("HttpRequestSSL") {}
-  ~HttpRequestSSLCredentials() override {}
-
   RefCountedPtr<grpc_channel_security_connector> create_security_connector(
       RefCountedPtr<grpc_call_credentials> /*call_creds*/, const char* target,
       const grpc_channel_args* args,
@@ -184,6 +182,8 @@ class HttpRequestSSLCredentials : public grpc_channel_credentials {
     return args;
   }
 
+  const char* type() const override { return "HttpRequestSSL"; }
+
  private:
   int cmp_impl(const grpc_channel_credentials* /* other */) const override {
     // There's no differentiating factor between two HttpRequestSSLCredentials

data/src/core/lib/http/parser.cc

@@ -177,6 +177,7 @@ static grpc_error_handle add_header(grpc_http_parser* parser) {
   uint8_t* cur = beg;
   uint8_t* end = beg + parser->cur_line_length;
   size_t* hdr_count = nullptr;
+  size_t size = 0;
   grpc_http_header** hdrs = nullptr;
   grpc_http_header hdr = {nullptr, nullptr};
   grpc_error_handle error = GRPC_ERROR_NONE;
@@ -205,13 +206,20 @@ static grpc_error_handle add_header(grpc_http_parser* parser) {
     cur++;
   }
   GPR_ASSERT((size_t)(end - cur) >= parser->cur_line_end_length);
-  hdr.value = buf2str(
-      cur, static_cast<size_t>(end - cur) - parser->cur_line_end_length);
+  size = static_cast<size_t>(end - cur) - parser->cur_line_end_length;
+  if ((size != 0) && (cur[size - 1] == '\r')) {
+    size--;
+  }
+  hdr.value = buf2str(cur, size);
 
   switch (parser->type) {
     case GRPC_HTTP_RESPONSE:
       hdr_count = &parser->http.response->hdr_count;
       hdrs = &parser->http.response->hdrs;
+      if ((strcmp(hdr.key, "Transfer-Encoding") == 0) &&
+          (strcmp(hdr.value, "chunked") == 0)) {
+        parser->http.response->chunked_state = GRPC_HTTP_CHUNKED_LENGTH;
+      }
       break;
     case GRPC_HTTP_REQUEST:
       hdr_count = &parser->http.request->hdr_count;
@@ -245,17 +253,24 @@ static grpc_error_handle finish_line(grpc_http_parser* parser,
       parser->state = GRPC_HTTP_HEADERS;
       break;
     case GRPC_HTTP_HEADERS:
+    case GRPC_HTTP_TRAILERS:
       if (parser->cur_line_length == parser->cur_line_end_length) {
-        parser->state = GRPC_HTTP_BODY;
-        *found_body_start = true;
+        if (parser->state == GRPC_HTTP_HEADERS) {
+          parser->state = GRPC_HTTP_BODY;
+          *found_body_start = true;
+        } else {
+          parser->state = GRPC_HTTP_END;
+        }
         break;
-      }
-      err = add_header(parser);
-      if (err != GRPC_ERROR_NONE) {
-        return err;
+      } else {
+        err = add_header(parser);
+        if (err != GRPC_ERROR_NONE) {
+          return err;
+        }
       }
       break;
     case GRPC_HTTP_BODY:
+    case GRPC_HTTP_END:
       GPR_UNREACHABLE_CODE(return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "Should never reach here"));
   }
@@ -269,6 +284,59 @@ static grpc_error_handle addbyte_body(grpc_http_parser* parser, uint8_t byte) {
   char** body = nullptr;
 
   if (parser->type == GRPC_HTTP_RESPONSE) {
+    switch (parser->http.response->chunked_state) {
+      case GRPC_HTTP_CHUNKED_LENGTH:
+        if ((byte == '\r') || (byte == ';')) {
+          parser->http.response->chunked_state =
+              GRPC_HTTP_CHUNKED_IGNORE_ALL_UNTIL_LF;
+        } else if ((byte >= '0') && (byte <= '9')) {
+          parser->http.response->chunk_length *= 16;
+          parser->http.response->chunk_length += byte - '0';
+        } else if ((byte >= 'a') && (byte <= 'f')) {
+          parser->http.response->chunk_length *= 16;
+          parser->http.response->chunk_length += byte - 'a' + 10;
+        } else if ((byte >= 'A') && (byte <= 'F')) {
+          parser->http.response->chunk_length *= 16;
+          parser->http.response->chunk_length += byte - 'A' + 10;
+        } else {
+          return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+              "Expected chunk size in hexadecimal");
+        }
+        return GRPC_ERROR_NONE;
+      case GRPC_HTTP_CHUNKED_IGNORE_ALL_UNTIL_LF:
+        if (byte == '\n') {
+          if (parser->http.response->chunk_length == 0) {
+            parser->state = GRPC_HTTP_TRAILERS;
+          } else {
+            parser->http.response->chunked_state = GRPC_HTTP_CHUNKED_BODY;
+          }
+        }
+        return GRPC_ERROR_NONE;
+      case GRPC_HTTP_CHUNKED_BODY:
+        if (parser->http.response->chunk_length == 0) {
+          if (byte != '\r') {
+            return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                "Expected '\\r\\n' after chunk body");
+          }
+          parser->http.response->chunked_state = GRPC_HTTP_CHUNKED_CONSUME_LF;
+          parser->http.response->chunk_length = 0;
+          return GRPC_ERROR_NONE;
+        } else {
+          parser->http.response->chunk_length--;
+          /* fallback to the normal body appending code below */
+        }
+        break;
+      case GRPC_HTTP_CHUNKED_CONSUME_LF:
+        if (byte != '\n') {
+          return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+              "Expected '\\r\\n' after chunk body");
+        }
+        parser->http.response->chunked_state = GRPC_HTTP_CHUNKED_LENGTH;
+        return GRPC_ERROR_NONE;
+      case GRPC_HTTP_CHUNKED_PLAIN:
+        /* avoiding warning; just fallback to normal codepath */
+        break;
+    }
     body_length = &parser->http.response->body_length;
     body = &parser->http.response->body;
   } else if (parser->type == GRPC_HTTP_REQUEST) {
@@ -318,6 +386,7 @@ static grpc_error_handle addbyte(grpc_http_parser* parser, uint8_t byte,
   switch (parser->state) {
     case GRPC_HTTP_FIRST_LINE:
     case GRPC_HTTP_HEADERS:
+    case GRPC_HTTP_TRAILERS:
       if (parser->cur_line_length >= GRPC_HTTP_PARSER_MAX_HEADER_LENGTH) {
         if (GRPC_TRACE_FLAG_ENABLED(grpc_http1_trace)) {
           gpr_log(GPR_ERROR, "HTTP header max line length (%d) exceeded",
@@ -334,6 +403,8 @@ static grpc_error_handle addbyte(grpc_http_parser* parser, uint8_t byte,
       return GRPC_ERROR_NONE;
     case GRPC_HTTP_BODY:
       return addbyte_body(parser, byte);
+    case GRPC_HTTP_END:
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Unexpected byte after end");
   }
   GPR_UNREACHABLE_CODE(return GRPC_ERROR_NONE);
 }
@@ -385,7 +456,7 @@ grpc_error_handle grpc_http_parser_parse(grpc_http_parser* parser,
 }
 
 grpc_error_handle grpc_http_parser_eof(grpc_http_parser* parser) {
-  if (parser->state != GRPC_HTTP_BODY) {
+  if ((parser->state != GRPC_HTTP_BODY) && (parser->state != GRPC_HTTP_END)) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Did not finish headers");
   }
   return GRPC_ERROR_NONE;

data/src/core/lib/http/parser.h

@@ -38,9 +38,19 @@ typedef struct grpc_http_header {
 typedef enum {
   GRPC_HTTP_FIRST_LINE,
   GRPC_HTTP_HEADERS,
-  GRPC_HTTP_BODY
+  GRPC_HTTP_BODY,
+  GRPC_HTTP_TRAILERS,
+  GRPC_HTTP_END,
 } grpc_http_parser_state;
 
+typedef enum {
+  GRPC_HTTP_CHUNKED_PLAIN,
+  GRPC_HTTP_CHUNKED_LENGTH,
+  GRPC_HTTP_CHUNKED_IGNORE_ALL_UNTIL_LF,
+  GRPC_HTTP_CHUNKED_BODY,
+  GRPC_HTTP_CHUNKED_CONSUME_LF,
+} grpc_http_parser_chunked_state;
+
 typedef enum {
   GRPC_HTTP_HTTP10,
   GRPC_HTTP_HTTP11,
@@ -77,6 +87,9 @@ typedef struct grpc_http_response {
   grpc_http_header* hdrs = nullptr;
   /* Body: length and contents; contents are NOT null-terminated */
   size_t body_length = 0;
+  /* State of the chunked parser. Only valid for the response. */
+  grpc_http_parser_chunked_state chunked_state = GRPC_HTTP_CHUNKED_PLAIN;
+  size_t chunk_length = 0;
   char* body = nullptr;
 } grpc_http_response;
 

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

@@ -32,7 +32,6 @@
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/iomgr/ev_epoll1_linux.h"
-#include "src/core/lib/iomgr/ev_epollex_linux.h"
 #include "src/core/lib/iomgr/ev_poll_posix.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/internal_errqueue.h"
@@ -126,12 +125,12 @@ const grpc_event_engine_vtable* init_non_polling(bool explicit_request) {
 // environment variable if that variable is set (which should be a
 // comma-separated list of one or more event engine names)
 static event_engine_factory g_factories[] = {
-    {ENGINE_HEAD_CUSTOM, nullptr},        {ENGINE_HEAD_CUSTOM, nullptr},
-    {ENGINE_HEAD_CUSTOM, nullptr},        {ENGINE_HEAD_CUSTOM, nullptr},
-    {"epollex", grpc_init_epollex_linux}, {"epoll1", grpc_init_epoll1_linux},
-    {"poll", grpc_init_poll_posix},       {"none", init_non_polling},
-    {ENGINE_TAIL_CUSTOM, nullptr},        {ENGINE_TAIL_CUSTOM, nullptr},
-    {ENGINE_TAIL_CUSTOM, nullptr},        {ENGINE_TAIL_CUSTOM, nullptr},
+    {ENGINE_HEAD_CUSTOM, nullptr},      {ENGINE_HEAD_CUSTOM, nullptr},
+    {ENGINE_HEAD_CUSTOM, nullptr},      {ENGINE_HEAD_CUSTOM, nullptr},
+    {"epoll1", grpc_init_epoll1_linux}, {"poll", grpc_init_poll_posix},
+    {"none", init_non_polling},         {ENGINE_TAIL_CUSTOM, nullptr},
+    {ENGINE_TAIL_CUSTOM, nullptr},      {ENGINE_TAIL_CUSTOM, nullptr},
+    {ENGINE_TAIL_CUSTOM, nullptr},
 };
 
 static void add(const char* beg, const char* end, char*** ss, size_t* ns) {

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

@@ -67,7 +67,7 @@ void grpc_prefork() {
   if (poll_strategy_name == nullptr ||
       (strcmp(poll_strategy_name, "epoll1") != 0 &&
        strcmp(poll_strategy_name, "poll") != 0)) {
-    gpr_log(GPR_ERROR,
+    gpr_log(GPR_INFO,
             "Fork support is only compatible with the epoll1 and poll polling "
             "strategies");
     return;

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

@@ -107,7 +107,6 @@
 #define GRPC_POSIX_SOCKET_ARES_EV_DRIVER 1
 #define GRPC_POSIX_SOCKET_EV 1
 #define GRPC_POSIX_SOCKET_EV_EPOLL1 1
-#define GRPC_POSIX_SOCKET_EV_EPOLLEX 1
 #define GRPC_POSIX_SOCKET_EV_POLL 1
 #define GRPC_POSIX_SOCKET_IF_NAMETOINDEX 1
 #define GRPC_POSIX_SOCKET_RESOLVE_ADDRESS 1
@@ -192,7 +191,6 @@
 #ifdef GRPC_POSIX_SOCKET
 #define GRPC_POSIX_SOCKET_ARES_EV_DRIVER 1
 #define GRPC_POSIX_SOCKET_EV 1
-#define GRPC_POSIX_SOCKET_EV_EPOLLEX 1
 #define GRPC_POSIX_SOCKET_EV_POLL 1
 #define GRPC_POSIX_SOCKET_EV_EPOLL1 1
 #define GRPC_POSIX_SOCKET_IF_NAMETOINDEX 1

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

@@ -136,6 +136,7 @@ static void on_writable(void* acp, grpc_error_handle error) {
   int done;
   grpc_endpoint** ep = ac->ep;
   grpc_closure* closure = ac->closure;
+  std::string addr_str = ac->addr_str;
   grpc_fd* fd;
 
   (void)GRPC_ERROR_REF(error);
@@ -221,8 +222,7 @@ finish:
     std::string description =
         absl::StrCat("Failed to connect to remote host: ", str);
     error = grpc_error_set_str(error, GRPC_ERROR_STR_DESCRIPTION, description);
-    error =
-        grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS, ac->addr_str);
+    error = grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS, addr_str);
   }
   if (done) {
     // This is safe even outside the lock, because "done", the sentinel, is