grpc 1.22.0 → 1.23.0

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

@@ -59,8 +59,10 @@ void grpc_prefork() {
             "environment variable GRPC_ENABLE_FORK_SUPPORT=1");
     return;
   }
-  if (strcmp(grpc_get_poll_strategy_name(), "epoll1") != 0 &&
-      strcmp(grpc_get_poll_strategy_name(), "poll") != 0) {
+  const char* poll_strategy_name = grpc_get_poll_strategy_name();
+  if (poll_strategy_name == nullptr ||
+      (strcmp(poll_strategy_name, "epoll1") != 0 &&
+       strcmp(poll_strategy_name, "poll") != 0)) {
     gpr_log(GPR_INFO,
             "Fork support is only compatible with the epoll1 and poll polling "
             "strategies");

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

@@ -90,12 +90,12 @@ grpc_iocp_work_status grpc_iocp_work(grpc_millis deadline) {
     abort();
   }
   if (socket->shutdown_called) {
-    info->bytes_transfered = 0;
+    info->bytes_transferred = 0;
     info->wsa_error = WSA_OPERATION_ABORTED;
   } else {
     success = WSAGetOverlappedResult(socket->socket, &info->overlapped, &bytes,
                                      FALSE, &flags);
-    info->bytes_transfered = bytes;
+    info->bytes_transferred = bytes;
     info->wsa_error = success ? 0 : WSAGetLastError();
   }
   GPR_ASSERT(overlapped == &info->overlapped);

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

@@ -78,9 +78,19 @@ static grpc_iomgr_platform_vtable vtable = {
 void grpc_set_default_iomgr_platform() {
   char* enable_cfstream = getenv(grpc_cfstream_env_var);
   grpc_tcp_client_vtable* client_vtable = &grpc_posix_tcp_client_vtable;
+  // CFStream is enabled by default on iOS, and disabled by default on other
+  // platforms. Defaults can be overriden by setting the grpc_cfstream
+  // environment variable.
+#if TARGET_OS_IPHONE
+  if (enable_cfstream == nullptr || enable_cfstream[0] == '1') {
+    client_vtable = &grpc_cfstream_client_vtable;
+  }
+#else
   if (enable_cfstream != nullptr && enable_cfstream[0] == '1') {
     client_vtable = &grpc_cfstream_client_vtable;
   }
+#endif
+
   grpc_set_tcp_client_impl(client_vtable);
   grpc_set_tcp_server_impl(&grpc_posix_tcp_server_vtable);
   grpc_set_timer_impl(&grpc_generic_timer_vtable);
@@ -90,4 +100,8 @@ void grpc_set_default_iomgr_platform() {
   grpc_set_iomgr_platform_vtable(&vtable);
 }
 
+bool grpc_iomgr_run_in_background() {
+  return grpc_event_engine_run_in_background();
+}
+
 #endif /* GRPC_CFSTREAM_IOMGR */

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

@@ -37,4 +37,7 @@ void grpc_set_default_iomgr_platform() {
   grpc_custom_iomgr_init(&grpc_uv_socket_vtable, &uv_resolver_vtable,
                          &uv_timer_vtable, &uv_pollset_vtable);
 }
+
+bool grpc_iomgr_run_in_background() { return false; }
+
 #endif

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

@@ -95,7 +95,7 @@ void LockfreeEvent::NotifyOn(grpc_closure* closure) {
      * referencing it. */
     gpr_atm curr = gpr_atm_acq_load(&state_);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
-      gpr_log(GPR_ERROR, "LockfreeEvent::NotifyOn: %p curr=%p closure=%p", this,
+      gpr_log(GPR_DEBUG, "LockfreeEvent::NotifyOn: %p curr=%p closure=%p", this,
               (void*)curr, closure);
     }
     switch (curr) {
@@ -161,7 +161,7 @@ bool LockfreeEvent::SetShutdown(grpc_error* shutdown_err) {
   while (true) {
     gpr_atm curr = gpr_atm_no_barrier_load(&state_);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
-      gpr_log(GPR_ERROR, "LockfreeEvent::SetShutdown: %p curr=%p err=%s",
+      gpr_log(GPR_DEBUG, "LockfreeEvent::SetShutdown: %p curr=%p err=%s",
               &state_, (void*)curr, grpc_error_string(shutdown_err));
     }
     switch (curr) {
@@ -210,7 +210,7 @@ void LockfreeEvent::SetReady() {
     gpr_atm curr = gpr_atm_no_barrier_load(&state_);
 
     if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
-      gpr_log(GPR_ERROR, "LockfreeEvent::SetReady: %p curr=%p", &state_,
+      gpr_log(GPR_DEBUG, "LockfreeEvent::SetReady: %p curr=%p", &state_,
               (void*)curr);
     }
 

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

@@ -24,9 +24,9 @@
 #include <grpc/support/string_util.h>
 
 #include <grpc/support/log.h>
-#include "src/core/lib/gpr/host_port.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/host_port.h"
 
 #include "src/core/lib/iomgr/iomgr_custom.h"
 #include "src/core/lib/iomgr/resolve_address_custom.h"
@@ -71,6 +71,7 @@ void grpc_custom_resolve_callback(grpc_custom_resolver* r,
                                   grpc_resolved_addresses* result,
                                   grpc_error* error) {
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   if (error == GRPC_ERROR_NONE) {
     *r->addresses = result;
@@ -86,11 +87,12 @@ void grpc_custom_resolve_callback(grpc_custom_resolver* r,
 }
 
 static grpc_error* try_split_host_port(const char* name,
-                                       const char* default_port, char** host,
-                                       char** port) {
+                                       const char* default_port,
+                                       grpc_core::UniquePtr<char>* host,
+                                       grpc_core::UniquePtr<char>* port) {
   /* parse name, splitting it into host and port parts */
   grpc_error* error;
-  gpr_split_host_port(name, host, port);
+  SplitHostPort(name, host, port);
   if (*host == nullptr) {
     char* msg;
     gpr_asprintf(&msg, "unparseable host:port: '%s'", name);
@@ -107,7 +109,7 @@ static grpc_error* try_split_host_port(const char* name,
       gpr_free(msg);
       return error;
     }
-    *port = gpr_strdup(default_port);
+    port->reset(gpr_strdup(default_port));
   }
   return GRPC_ERROR_NONE;
 }
@@ -115,28 +117,26 @@ static grpc_error* try_split_host_port(const char* name,
 static grpc_error* blocking_resolve_address_impl(
     const char* name, const char* default_port,
     grpc_resolved_addresses** addresses) {
-  char* host;
-  char* port;
+  grpc_core::UniquePtr<char> host;
+  grpc_core::UniquePtr<char> port;
   grpc_error* err;
 
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
 
   err = try_split_host_port(name, default_port, &host, &port);
   if (err != GRPC_ERROR_NONE) {
-    gpr_free(host);
-    gpr_free(port);
     return err;
   }
 
   /* Call getaddrinfo */
   grpc_custom_resolver resolver;
-  resolver.host = host;
-  resolver.port = port;
+  resolver.host = host.get();
+  resolver.port = port.get();
 
   grpc_resolved_addresses* addrs;
   grpc_core::ExecCtx* curr = grpc_core::ExecCtx::Get();
   grpc_core::ExecCtx::Set(nullptr);
-  err = resolve_address_vtable->resolve(host, port, &addrs);
+  err = resolve_address_vtable->resolve(host.get(), port.get(), &addrs);
   if (err != GRPC_ERROR_NONE) {
     if (retry_named_port_failure(&resolver, &addrs)) {
       GRPC_ERROR_UNREF(err);
@@ -147,8 +147,6 @@ static grpc_error* blocking_resolve_address_impl(
   if (err == GRPC_ERROR_NONE) {
     *addresses = addrs;
   }
-  gpr_free(resolver.host);
-  gpr_free(resolver.port);
   return err;
 }
 
@@ -157,22 +155,20 @@ static void resolve_address_impl(const char* name, const char* default_port,
                                  grpc_closure* on_done,
                                  grpc_resolved_addresses** addrs) {
   grpc_custom_resolver* r = nullptr;
-  char* host = nullptr;
-  char* port = nullptr;
+  grpc_core::UniquePtr<char> host;
+  grpc_core::UniquePtr<char> port;
   grpc_error* err;
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
   err = try_split_host_port(name, default_port, &host, &port);
   if (err != GRPC_ERROR_NONE) {
     GRPC_CLOSURE_SCHED(on_done, err);
-    gpr_free(host);
-    gpr_free(port);
     return;
   }
   r = (grpc_custom_resolver*)gpr_malloc(sizeof(grpc_custom_resolver));
   r->on_done = on_done;
   r->addresses = addrs;
-  r->host = host;
-  r->port = port;
+  r->host = host.release();
+  r->port = port.release();
 
   /* Call getaddrinfo */
   resolve_address_vtable->resolve_async(r, r->host, r->port);

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

@@ -33,9 +33,9 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 
-#include "src/core/lib/gpr/host_port.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/block_annotate.h"
 #include "src/core/lib/iomgr/executor.h"
@@ -48,8 +48,6 @@ static grpc_error* posix_blocking_resolve_address(
   grpc_core::ExecCtx exec_ctx;
   struct addrinfo hints;
   struct addrinfo *result = nullptr, *resp;
-  char* host;
-  char* port;
   int s;
   size_t i;
   grpc_error* err;
@@ -59,8 +57,10 @@ static grpc_error* posix_blocking_resolve_address(
     return grpc_resolve_unix_domain_address(name + 5, addresses);
   }
 
+  grpc_core::UniquePtr<char> host;
+  grpc_core::UniquePtr<char> port;
   /* parse name, splitting it into host and port parts */
-  gpr_split_host_port(name, &host, &port);
+  grpc_core::SplitHostPort(name, &host, &port);
   if (host == nullptr) {
     err = grpc_error_set_str(
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("unparseable host:port"),
@@ -74,7 +74,7 @@ static grpc_error* posix_blocking_resolve_address(
           GRPC_ERROR_STR_TARGET_ADDRESS, grpc_slice_from_copied_string(name));
       goto done;
     }
-    port = gpr_strdup(default_port);
+    port.reset(gpr_strdup(default_port));
   }
 
   /* Call getaddrinfo */
@@ -84,16 +84,16 @@ static grpc_error* posix_blocking_resolve_address(
   hints.ai_flags = AI_PASSIVE;     /* for wildcard IP address */
 
   GRPC_SCHEDULING_START_BLOCKING_REGION;
-  s = getaddrinfo(host, port, &hints, &result);
+  s = getaddrinfo(host.get(), port.get(), &hints, &result);
   GRPC_SCHEDULING_END_BLOCKING_REGION;
 
   if (s != 0) {
     /* Retry if well-known service name is recognized */
     const char* svc[][2] = {{"http", "80"}, {"https", "443"}};
     for (i = 0; i < GPR_ARRAY_SIZE(svc); i++) {
-      if (strcmp(port, svc[i][0]) == 0) {
+      if (strcmp(port.get(), svc[i][0]) == 0) {
         GRPC_SCHEDULING_START_BLOCKING_REGION;
-        s = getaddrinfo(host, svc[i][1], &hints, &result);
+        s = getaddrinfo(host.get(), svc[i][1], &hints, &result);
         GRPC_SCHEDULING_END_BLOCKING_REGION;
         break;
       }
@@ -133,8 +133,6 @@ static grpc_error* posix_blocking_resolve_address(
   err = GRPC_ERROR_NONE;
 
 done:
-  gpr_free(host);
-  gpr_free(port);
   if (result) {
     freeaddrinfo(result);
   }

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

@@ -35,8 +35,8 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 
-#include "src/core/lib/gpr/host_port.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/block_annotate.h"
 #include "src/core/lib/iomgr/executor.h"
@@ -57,14 +57,14 @@ static grpc_error* windows_blocking_resolve_address(
   grpc_core::ExecCtx exec_ctx;
   struct addrinfo hints;
   struct addrinfo *result = NULL, *resp;
-  char* host;
-  char* port;
   int s;
   size_t i;
   grpc_error* error = GRPC_ERROR_NONE;
 
   /* parse name, splitting it into host and port parts */
-  gpr_split_host_port(name, &host, &port);
+  grpc_core::UniquePtr<char> host;
+  grpc_core::UniquePtr<char> port;
+  grpc_core::SplitHostPort(name, &host, &port);
   if (host == NULL) {
     char* msg;
     gpr_asprintf(&msg, "unparseable host:port: '%s'", name);
@@ -80,7 +80,7 @@ static grpc_error* windows_blocking_resolve_address(
       gpr_free(msg);
       goto done;
     }
-    port = gpr_strdup(default_port);
+    port.reset(gpr_strdup(default_port));
   }
 
   /* Call getaddrinfo */
@@ -90,7 +90,7 @@ static grpc_error* windows_blocking_resolve_address(
   hints.ai_flags = AI_PASSIVE;     /* for wildcard IP address */
 
   GRPC_SCHEDULING_START_BLOCKING_REGION;
-  s = getaddrinfo(host, port, &hints, &result);
+  s = getaddrinfo(host.get(), port.get(), &hints, &result);
   GRPC_SCHEDULING_END_BLOCKING_REGION;
   if (s != 0) {
     error = GRPC_WSA_ERROR(WSAGetLastError(), "getaddrinfo");
@@ -122,8 +122,6 @@ static grpc_error* windows_blocking_resolve_address(
   }
 
 done:
-  gpr_free(host);
-  gpr_free(port);
   if (result) {
     freeaddrinfo(result);
   }

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

@@ -28,8 +28,8 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/gpr/host_port.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
@@ -181,15 +181,17 @@ int grpc_sockaddr_to_string(char** out,
   }
   if (ip != nullptr && grpc_inet_ntop(addr->sa_family, ip, ntop_buf,
                                       sizeof(ntop_buf)) != nullptr) {
+    grpc_core::UniquePtr<char> tmp_out;
     if (sin6_scope_id != 0) {
       char* host_with_scope;
       /* Enclose sin6_scope_id with the format defined in RFC 6784 section 2. */
       gpr_asprintf(&host_with_scope, "%s%%25%" PRIu32, ntop_buf, sin6_scope_id);
-      ret = gpr_join_host_port(out, host_with_scope, port);
+      ret = grpc_core::JoinHostPort(&tmp_out, host_with_scope, port);
       gpr_free(host_with_scope);
     } else {
-      ret = gpr_join_host_port(out, ntop_buf, port);
+      ret = grpc_core::JoinHostPort(&tmp_out, ntop_buf, port);
     }
+    *out = tmp_out.release();
   } else {
     ret = gpr_asprintf(out, "(sockaddr family=%d)", addr->sa_family);
   }

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

@@ -46,7 +46,6 @@
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/host_port.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/sockaddr_utils.h"

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

@@ -59,7 +59,7 @@ typedef struct grpc_winsocket_callback_info {
      to hold a mutex for a long amount of time. */
   int has_pending_iocp;
   /* The results of the overlapped operation. */
-  DWORD bytes_transfered;
+  DWORD bytes_transferred;
   int wsa_error;
 } grpc_winsocket_callback_info;
 

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

@@ -34,7 +34,7 @@
 #include <netinet/in.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/host_port.h"
+#include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/cfstream_handle.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint_cfstream.h"
@@ -143,12 +143,13 @@ static void OnOpen(void* arg, grpc_error* error) {
 
 static void ParseResolvedAddress(const grpc_resolved_address* addr,
                                  CFStringRef* host, int* port) {
-  char *host_port, *host_string, *port_string;
+  char* host_port;
   grpc_sockaddr_to_string(&host_port, addr, 1);
-  gpr_split_host_port(host_port, &host_string, &port_string);
-  *host = CFStringCreateWithCString(NULL, host_string, kCFStringEncodingUTF8);
-  gpr_free(host_string);
-  gpr_free(port_string);
+  grpc_core::UniquePtr<char> host_string;
+  grpc_core::UniquePtr<char> port_string;
+  grpc_core::SplitHostPort(host_port, &host_string, &port_string);
+  *host =
+      CFStringCreateWithCString(NULL, host_string.get(), kCFStringEncodingUTF8);
   gpr_free(host_port);
   *port = grpc_sockaddr_get_port(addr);
 }

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

@@ -101,6 +101,7 @@ static void custom_connect_callback_internal(grpc_custom_socket* socket,
 
 static void custom_connect_callback(grpc_custom_socket* socket,
                                     grpc_error* error) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   if (grpc_core::ExecCtx::Get() == nullptr) {
     /* If we are being run on a thread which does not have an exec_ctx created
      * yet, we should create one. */

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

@@ -145,6 +145,7 @@ static void call_read_cb(custom_tcp_endpoint* tcp, grpc_error* error) {
 
 static void custom_read_callback(grpc_custom_socket* socket, size_t nread,
                                  grpc_error* error) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   grpc_slice_buffer garbage;
   custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)socket->endpoint;
@@ -207,6 +208,7 @@ static void endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
 
 static void custom_write_callback(grpc_custom_socket* socket,
                                   grpc_error* error) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)socket->endpoint;
   grpc_closure* cb = tcp->write_cb;
@@ -301,6 +303,7 @@ static void custom_close_callback(grpc_custom_socket* socket) {
     grpc_custom_socket_vtable->destroy(socket);
     gpr_free(socket);
   } else if (socket->endpoint) {
+    grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
     grpc_core::ExecCtx exec_ctx;
     custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)socket->endpoint;
     TCP_UNREF(tcp, "destroy");
@@ -343,6 +346,7 @@ grpc_endpoint* custom_tcp_endpoint_create(grpc_custom_socket* socket,
                                           char* peer_string) {
   custom_tcp_endpoint* tcp =
       (custom_tcp_endpoint*)gpr_malloc(sizeof(custom_tcp_endpoint));
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {

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

@@ -435,12 +435,17 @@ static void tcp_do_read(grpc_tcp* tcp) {
   GPR_TIMER_SCOPE("tcp_do_read", 0);
   struct msghdr msg;
   struct iovec iov[MAX_READ_IOVEC];
-  char cmsgbuf[24 /*CMSG_SPACE(sizeof(int))*/];
   ssize_t read_bytes;
   size_t total_read_bytes = 0;
-
   size_t iov_len =
       std::min<size_t>(MAX_READ_IOVEC, tcp->incoming_buffer->count);
+#ifdef GRPC_LINUX_ERRQUEUE
+  constexpr size_t cmsg_alloc_space =
+      CMSG_SPACE(sizeof(grpc_core::scm_timestamping)) + CMSG_SPACE(sizeof(int));
+#else
+  constexpr size_t cmsg_alloc_space = 24 /* CMSG_SPACE(sizeof(int)) */;
+#endif /* GRPC_LINUX_ERRQUEUE */
+  char cmsgbuf[cmsg_alloc_space];
   for (size_t i = 0; i < iov_len; i++) {
     iov[i].iov_base = GRPC_SLICE_START_PTR(tcp->incoming_buffer->slices[i]);
     iov[i].iov_len = GRPC_SLICE_LENGTH(tcp->incoming_buffer->slices[i]);
@@ -524,6 +529,7 @@ static void tcp_do_read(grpc_tcp* tcp) {
         if (cmsg->cmsg_level == SOL_TCP && cmsg->cmsg_type == TCP_CM_INQ &&
             cmsg->cmsg_len == CMSG_LEN(sizeof(int))) {
           tcp->inq = *reinterpret_cast<int*>(CMSG_DATA(cmsg));
+          break;
         }
       }
     }