grpc 1.43.1 → 1.48.0

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

@@ -29,6 +29,7 @@
 
 #include <errno.h>
 #include <fcntl.h>
+#include <inttypes.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <string.h>
@@ -61,6 +62,8 @@
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "src/core/lib/resource_quota/api.h"
 
+static std::atomic<int64_t> num_dropped_connections{0};
+
 static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
                                            const grpc_channel_args* args,
                                            grpc_tcp_server** server) {
@@ -188,7 +191,7 @@ static void tcp_server_destroy(grpc_tcp_server* s) {
 static void on_read(void* arg, grpc_error_handle err) {
   grpc_tcp_listener* sp = static_cast<grpc_tcp_listener*>(arg);
   grpc_pollset* read_notifier_pollset;
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     goto error;
   }
 
@@ -201,27 +204,34 @@ static void on_read(void* arg, grpc_error_handle err) {
        strip off the ::ffff:0.0.0.0/96 prefix first. */
     int fd = grpc_accept4(sp->fd, &addr, 1, 1);
     if (fd < 0) {
-      switch (errno) {
-        case EINTR:
-          continue;
-        case EAGAIN:
-          grpc_fd_notify_on_read(sp->emfd, &sp->read_closure);
-          return;
-        default:
-          gpr_mu_lock(&sp->server->mu);
-          if (!sp->server->shutdown_listeners) {
-            gpr_log(GPR_ERROR, "Failed accept4: %s", strerror(errno));
-          } else {
-            /* if we have shutdown listeners, accept4 could fail, and we
-               needn't notify users */
-          }
-          gpr_mu_unlock(&sp->server->mu);
-          goto error;
+      if (errno == EINTR) {
+        continue;
+      } else if (errno == EAGAIN || errno == ECONNABORTED ||
+                 errno == EWOULDBLOCK) {
+        grpc_fd_notify_on_read(sp->emfd, &sp->read_closure);
+        return;
+      } else {
+        gpr_mu_lock(&sp->server->mu);
+        if (!sp->server->shutdown_listeners) {
+          gpr_log(GPR_ERROR, "Failed accept4: %s", strerror(errno));
+        } else {
+          /* if we have shutdown listeners, accept4 could fail, and we
+             needn't notify users */
+        }
+        gpr_mu_unlock(&sp->server->mu);
+        goto error;
       }
     }
 
     if (sp->server->memory_quota->IsMemoryPressureHigh()) {
-      gpr_log(GPR_INFO, "Drop incoming connection: high memory pressure");
+      int64_t dropped_connections_count =
+          num_dropped_connections.fetch_add(1, std::memory_order_relaxed) + 1;
+      if (dropped_connections_count % 1000 == 1) {
+        gpr_log(GPR_INFO,
+                "Dropped >= %" PRId64
+                " new connection attempts due to high memory pressure",
+                dropped_connections_count);
+      }
       close(fd);
       continue;
     }
@@ -243,17 +253,22 @@ static void on_read(void* arg, grpc_error_handle err) {
 
     err = grpc_apply_socket_mutator_in_args(fd, GRPC_FD_SERVER_CONNECTION_USAGE,
                                             sp->server->channel_args);
-    if (err != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(err)) {
       goto error;
     }
 
-    std::string addr_str = grpc_sockaddr_to_uri(&addr);
+    auto addr_uri = grpc_sockaddr_to_uri(&addr);
+    if (!addr_uri.ok()) {
+      gpr_log(GPR_ERROR, "Invalid address: %s",
+              addr_uri.status().ToString().c_str());
+      goto error;
+    }
     if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
       gpr_log(GPR_INFO, "SERVER_CONNECT: incoming connection: %s",
-              addr_str.c_str());
+              addr_uri->c_str());
     }
 
-    std::string name = absl::StrCat("tcp-server-connection:", addr_str);
+    std::string name = absl::StrCat("tcp-server-connection:", addr_uri.value());
     grpc_fd* fdobj = grpc_fd_create(fd, name.c_str(), true);
 
     read_notifier_pollset = (*(sp->server->pollsets))
@@ -272,7 +287,7 @@ static void on_read(void* arg, grpc_error_handle err) {
     acceptor->external_connection = false;
     sp->server->on_accept_cb(
         sp->server->on_accept_cb_arg,
-        grpc_tcp_create(fdobj, sp->server->channel_args, addr_str),
+        grpc_tcp_create(fdobj, sp->server->channel_args, addr_uri.value()),
         read_notifier_pollset, acceptor);
   }
 
@@ -329,14 +344,14 @@ static grpc_error_handle add_wildcard_addrs_to_server(grpc_tcp_server* s,
     }
   }
   if (*out_port > 0) {
-    if (v6_err != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(v6_err)) {
       gpr_log(GPR_INFO,
               "Failed to add :: listener, "
               "the environment may not support IPv6: %s",
               grpc_error_std_string(v6_err).c_str());
       GRPC_ERROR_UNREF(v6_err);
     }
-    if (v4_err != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(v4_err)) {
       gpr_log(GPR_INFO,
               "Failed to add 0.0.0.0 listener, "
               "the environment may not support IPv4: %s",
@@ -347,7 +362,7 @@ static grpc_error_handle add_wildcard_addrs_to_server(grpc_tcp_server* s,
   } else {
     grpc_error_handle root_err = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Failed to add any wildcard listeners");
-    GPR_ASSERT(v6_err != GRPC_ERROR_NONE && v4_err != GRPC_ERROR_NONE);
+    GPR_ASSERT(!GRPC_ERROR_IS_NONE(v6_err) && !GRPC_ERROR_IS_NONE(v4_err));
     root_err = grpc_error_add_child(root_err, v6_err);
     root_err = grpc_error_add_child(root_err, v4_err);
     return root_err;
@@ -357,7 +372,7 @@ static grpc_error_handle add_wildcard_addrs_to_server(grpc_tcp_server* s,
 static grpc_error_handle clone_port(grpc_tcp_listener* listener,
                                     unsigned count) {
   grpc_tcp_listener* sp = nullptr;
-  std::string addr_str;
+  absl::StatusOr<std::string> addr_str;
   grpc_error_handle err;
 
   for (grpc_tcp_listener* l = listener->next; l && l->is_sibling; l = l->next) {
@@ -370,12 +385,15 @@ static grpc_error_handle clone_port(grpc_tcp_listener* listener,
     grpc_dualstack_mode dsmode;
     err = grpc_create_dualstack_socket(&listener->addr, SOCK_STREAM, 0, &dsmode,
                                        &fd);
-    if (err != GRPC_ERROR_NONE) return err;
+    if (!GRPC_ERROR_IS_NONE(err)) return err;
     err = grpc_tcp_server_prepare_socket(listener->server, fd, &listener->addr,
                                          true, &port);
-    if (err != GRPC_ERROR_NONE) return err;
+    if (!GRPC_ERROR_IS_NONE(err)) return err;
     listener->server->nports++;
     addr_str = grpc_sockaddr_to_string(&listener->addr, true);
+    if (!addr_str.ok()) {
+      return GRPC_ERROR_CREATE_FROM_CPP_STRING(addr_str.status().ToString());
+    }
     sp = static_cast<grpc_tcp_listener*>(gpr_malloc(sizeof(grpc_tcp_listener)));
     sp->next = listener->next;
     listener->next = sp;
@@ -388,7 +406,7 @@ static grpc_error_handle clone_port(grpc_tcp_listener* listener,
     sp->fd = fd;
     sp->emfd = grpc_fd_create(
         fd,
-        absl::StrFormat("tcp-server-listener:%s/clone-%d", addr_str.c_str(), i)
+        absl::StrFormat("tcp-server-listener:%s/clone-%d", *addr_str, i)
             .c_str(),
         true);
     memcpy(&sp->addr, &listener->addr, sizeof(grpc_resolved_address));
@@ -595,12 +613,17 @@ class ExternalConnectionHandler : public grpc_core::TcpServerFdHandler {
       return;
     }
     (void)grpc_set_socket_no_sigpipe_if_possible(fd);
-    std::string addr_str = grpc_sockaddr_to_uri(&addr);
+    auto addr_uri = grpc_sockaddr_to_uri(&addr);
+    if (!addr_uri.ok()) {
+      gpr_log(GPR_ERROR, "Invalid address: %s",
+              addr_uri.status().ToString().c_str());
+      return;
+    }
     if (grpc_tcp_trace.enabled()) {
       gpr_log(GPR_INFO, "SERVER_CONNECT: incoming external connection: %s",
-              addr_str.c_str());
+              addr_uri->c_str());
     }
-    std::string name = absl::StrCat("tcp-server-connection:", addr_str);
+    std::string name = absl::StrCat("tcp-server-connection:", addr_uri.value());
     grpc_fd* fdobj = grpc_fd_create(fd, name.c_str(), true);
     read_notifier_pollset =
         (*(s_->pollsets))[static_cast<size_t>(gpr_atm_no_barrier_fetch_add(
@@ -616,7 +639,7 @@ class ExternalConnectionHandler : public grpc_core::TcpServerFdHandler {
     acceptor->listener_fd = listener_fd;
     acceptor->pending_data = buf;
     s_->on_accept_cb(s_->on_accept_cb_arg,
-                     grpc_tcp_create(fdobj, s_->channel_args, addr_str),
+                     grpc_tcp_create(fdobj, s_->channel_args, addr_uri.value()),
                      read_notifier_pollset, acceptor);
   }
 

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

@@ -26,6 +26,7 @@
 #include <limits.h>
 #include <stdio.h>
 #include <string.h>
+#include <sys/socket.h>
 
 #include <string>
 
@@ -84,38 +85,41 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, int fd,
                                               unsigned port_index,
                                               unsigned fd_index,
                                               grpc_tcp_listener** listener) {
-  grpc_tcp_listener* sp = nullptr;
+  *listener = nullptr;
   int port = -1;
 
   grpc_error_handle err =
       grpc_tcp_server_prepare_socket(s, fd, addr, s->so_reuseport, &port);
-  if (err == GRPC_ERROR_NONE) {
-    GPR_ASSERT(port > 0);
-    std::string addr_str = grpc_sockaddr_to_string(addr, true);
-    std::string name = absl::StrCat("tcp-server-listener:", addr_str);
-    gpr_mu_lock(&s->mu);
-    s->nports++;
-    GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server");
-    sp = static_cast<grpc_tcp_listener*>(gpr_malloc(sizeof(grpc_tcp_listener)));
-    sp->next = nullptr;
-    if (s->head == nullptr) {
-      s->head = sp;
-    } else {
-      s->tail->next = sp;
-    }
-    s->tail = sp;
-    sp->server = s;
-    sp->fd = fd;
-    sp->emfd = grpc_fd_create(fd, name.c_str(), true);
-    memcpy(&sp->addr, addr, sizeof(grpc_resolved_address));
-    sp->port = port;
-    sp->port_index = port_index;
-    sp->fd_index = fd_index;
-    sp->is_sibling = 0;
-    sp->sibling = nullptr;
-    GPR_ASSERT(sp->emfd);
-    gpr_mu_unlock(&s->mu);
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
+  GPR_ASSERT(port > 0);
+  absl::StatusOr<std::string> addr_str = grpc_sockaddr_to_string(addr, true);
+  if (!addr_str.ok()) {
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(addr_str.status().ToString());
+  }
+  std::string name = absl::StrCat("tcp-server-listener:", addr_str.value());
+  gpr_mu_lock(&s->mu);
+  s->nports++;
+  GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server");
+  grpc_tcp_listener* sp =
+      static_cast<grpc_tcp_listener*>(gpr_malloc(sizeof(grpc_tcp_listener)));
+  sp->next = nullptr;
+  if (s->head == nullptr) {
+    s->head = sp;
+  } else {
+    s->tail->next = sp;
   }
+  s->tail = sp;
+  sp->server = s;
+  sp->fd = fd;
+  sp->emfd = grpc_fd_create(fd, name.c_str(), true);
+  memcpy(&sp->addr, addr, sizeof(grpc_resolved_address));
+  sp->port = port;
+  sp->port_index = port_index;
+  sp->fd_index = fd_index;
+  sp->is_sibling = 0;
+  sp->sibling = nullptr;
+  GPR_ASSERT(sp->emfd);
+  gpr_mu_unlock(&s->mu);
 
   *listener = sp;
   return err;
@@ -133,7 +137,7 @@ grpc_error_handle grpc_tcp_server_add_addr(grpc_tcp_server* s,
   int fd;
   grpc_error_handle err =
       grpc_create_dualstack_socket(addr, SOCK_STREAM, 0, dsmode, &fd);
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     return err;
   }
   if (*dsmode == GRPC_DSMODE_IPV4 &&
@@ -154,36 +158,36 @@ grpc_error_handle grpc_tcp_server_prepare_socket(
 
   if (so_reuseport && !grpc_is_unix_socket(addr)) {
     err = grpc_set_socket_reuse_port(fd, 1);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
   }
 
 #ifdef GRPC_LINUX_ERRQUEUE
   err = grpc_set_socket_zerocopy(fd);
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     /* it's not fatal, so just log it. */
     gpr_log(GPR_DEBUG, "Node does not support SO_ZEROCOPY, continuing.");
     GRPC_ERROR_UNREF(err);
   }
 #endif
   err = grpc_set_socket_nonblocking(fd, 1);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
   err = grpc_set_socket_cloexec(fd, 1);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
   if (!grpc_is_unix_socket(addr)) {
     err = grpc_set_socket_low_latency(fd, 1);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
     err = grpc_set_socket_reuse_addr(fd, 1);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
     err = grpc_set_socket_tcp_user_timeout(fd, s->channel_args,
                                            false /* is_client */);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
   }
   err = grpc_set_socket_no_sigpipe_if_possible(fd);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
 
   err = grpc_apply_socket_mutator_in_args(fd, GRPC_FD_SERVER_LISTENER_USAGE,
                                           s->channel_args);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
 
   if (bind(fd, reinterpret_cast<grpc_sockaddr*>(const_cast<char*>(addr->addr)),
            addr->len) < 0) {
@@ -208,7 +212,7 @@ grpc_error_handle grpc_tcp_server_prepare_socket(
   return GRPC_ERROR_NONE;
 
 error:
-  GPR_ASSERT(err != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(err));
   if (fd >= 0) {
     close(fd);
   }

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

@@ -26,6 +26,7 @@
 #include <ifaddrs.h>
 #include <stddef.h>
 #include <string.h>
+#include <sys/socket.h>
 
 #include <string>
 
@@ -64,7 +65,7 @@ static grpc_error_handle get_unused_port(int* port) {
   int fd;
   grpc_error_handle err =
       grpc_create_dualstack_socket(&wild, SOCK_STREAM, 0, &dsmode, &fd);
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     return err;
   }
   if (dsmode == GRPC_DSMODE_IPV4) {
@@ -132,21 +133,24 @@ grpc_error_handle grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
       err = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to set port");
       break;
     }
-    std::string addr_str = grpc_sockaddr_to_string(&addr, false);
+    auto addr_str = grpc_sockaddr_to_string(&addr, false);
+    if (!addr_str.ok()) {
+      return GRPC_ERROR_CREATE_FROM_CPP_STRING(addr_str.status().ToString());
+    }
     gpr_log(GPR_DEBUG,
             "Adding local addr from interface %s flags 0x%x to server: %s",
-            ifa_name, ifa_it->ifa_flags, addr_str.c_str());
+            ifa_name, ifa_it->ifa_flags, addr_str->c_str());
     /* We could have multiple interfaces with the same address (e.g., bonding),
        so look for duplicates. */
     if (find_listener_with_addr(s, &addr) != nullptr) {
       gpr_log(GPR_DEBUG, "Skipping duplicate addr %s on interface %s",
-              addr_str.c_str(), ifa_name);
+              addr_str->c_str(), ifa_name);
       continue;
     }
     if ((err = grpc_tcp_server_add_addr(s, &addr, port_index, fd_index, &dsmode,
                                         &new_sp)) != GRPC_ERROR_NONE) {
       grpc_error_handle root_err = GRPC_ERROR_CREATE_FROM_CPP_STRING(
-          absl::StrCat("Failed to add listener: ", addr_str));
+          absl::StrCat("Failed to add listener: ", addr_str.value()));
       err = grpc_error_add_child(root_err, err);
       break;
     } else {
@@ -160,7 +164,7 @@ grpc_error_handle grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
     }
   }
   freeifaddrs(ifa);
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     return err;
   } else if (sp == nullptr) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("No local addresses");

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

@@ -197,7 +197,7 @@ static grpc_error_handle prepare_socket(SOCKET sock,
   int sockname_temp_len;
 
   error = grpc_tcp_prepare_socket(sock);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     goto failure;
   }
 
@@ -224,12 +224,14 @@ static grpc_error_handle prepare_socket(SOCKET sock,
   return GRPC_ERROR_NONE;
 
 failure:
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
+  auto addr_uri = grpc_sockaddr_to_uri(addr);
   grpc_error_set_int(
-      grpc_error_set_str(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                             "Failed to prepare server socket", &error, 1),
-                         GRPC_ERROR_STR_TARGET_ADDRESS,
-                         grpc_sockaddr_to_uri(addr)),
+      grpc_error_set_str(
+          GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+              "Failed to prepare server socket", &error, 1),
+          GRPC_ERROR_STR_TARGET_ADDRESS,
+          addr_uri.ok() ? *addr_uri : addr_uri.status().ToString()),
       GRPC_ERROR_INT_FD, (intptr_t)sock);
   GRPC_ERROR_UNREF(error);
   if (sock != INVALID_SOCKET) closesocket(sock);
@@ -265,7 +267,7 @@ static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   }
 
   error = grpc_tcp_prepare_socket(sock);
-  if (error != GRPC_ERROR_NONE) goto failure;
+  if (!GRPC_ERROR_IS_NONE(error)) goto failure;
 
   /* Start the "accept" asynchronously. */
   success = port->AcceptEx(port->socket->socket, sock, port->addresses, 0,
@@ -290,7 +292,7 @@ static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   return error;
 
 failure:
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
   if (sock != INVALID_SOCKET) closesocket(sock);
   return error;
 }
@@ -314,7 +316,7 @@ static void on_accept(void* arg, grpc_error_handle error) {
   /* The general mechanism for shutting down is to queue abortion calls. While
      this is necessary in the read/write case, it's useless for the accept
      case. We only need to adjust the pending callback count */
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_INFO, "Skipping on_accept due to error: %s",
             grpc_error_std_string(error).c_str());
 
@@ -347,7 +349,13 @@ static void on_accept(void* arg, grpc_error_handle error) {
       peer_name.len = (size_t)peer_name_len;
       std::string peer_name_string;
       if (!err) {
-        peer_name_string = grpc_sockaddr_to_uri(&peer_name);
+        auto addr_uri = grpc_sockaddr_to_uri(&peer_name);
+        if (addr_uri.ok()) {
+          peer_name_string = addr_uri.value();
+        } else {
+          gpr_log(GPR_ERROR, "invalid peer name: %s",
+                  addr_uri.status().ToString().c_str());
+        }
       } else {
         char* utf8_message = gpr_format_message(WSAGetLastError());
         gpr_log(GPR_ERROR, "getpeername error: %s", utf8_message);
@@ -411,7 +419,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
   }
 
   error = prepare_socket(sock, addr, &port);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     return error;
   }
 
@@ -503,7 +511,7 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
 done:
   gpr_free(allocated_addr);
 
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_error_handle error_out =
         GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
             "Failed to add port to server", &error, 1);

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

@@ -31,6 +31,7 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/sockaddr.h"
@@ -88,11 +89,11 @@ static grpc_error_handle enable_socket_low_latency(SOCKET sock) {
 grpc_error_handle grpc_tcp_prepare_socket(SOCKET sock) {
   grpc_error_handle err;
   err = grpc_tcp_set_non_block(sock);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   err = set_dualstack(sock);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   err = enable_socket_low_latency(sock);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   return GRPC_ERROR_NONE;
 }
 
@@ -185,7 +186,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
 
   (void)GRPC_ERROR_REF(error);
 
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     if (info->wsa_error != 0 && !tcp->shutting_down) {
       char* utf8_message = gpr_format_message(info->wsa_error);
       error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(utf8_message);
@@ -219,10 +220,12 @@ static void on_read(void* tcpp, grpc_error_handle error) {
           gpr_log(GPR_INFO, "TCP:%p unref read_slice", tcp);
         }
         grpc_slice_buffer_reset_and_unref_internal(tcp->read_slices);
-        error = tcp->shutting_down
-                    ? GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                          "TCP stream shutting down", &tcp->shutdown_error, 1)
-                    : GRPC_ERROR_CREATE_FROM_STATIC_STRING("End of TCP stream");
+        error = grpc_error_set_int(
+            tcp->shutting_down
+                ? GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+                      "TCP stream shutting down", &tcp->shutdown_error, 1)
+                : GRPC_ERROR_CREATE_FROM_STATIC_STRING("End of TCP stream"),
+            GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
       }
     }
   }
@@ -235,7 +238,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
 #define DEFAULT_TARGET_READ_SIZE 8192
 #define MAX_WSABUF_COUNT 16
 static void win_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
-                     grpc_closure* cb, bool urgent) {
+                     grpc_closure* cb, bool urgent, int /*min_progress_size*/) {
   grpc_tcp* tcp = (grpc_tcp*)ep;
   grpc_winsocket* handle = tcp->socket;
   grpc_winsocket_callback_info* info = &handle->read_info;
@@ -252,8 +255,10 @@ static void win_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
   if (tcp->shutting_down) {
     grpc_core::ExecCtx::Run(
         DEBUG_LOCATION, cb,
-        GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-            "TCP socket is shutting down", &tcp->shutdown_error, 1));
+        grpc_error_set_int(
+            GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+                "TCP socket is shutting down", &tcp->shutdown_error, 1),
+            GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE));
     return;
   }
 
@@ -326,7 +331,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
   tcp->write_cb = NULL;
   gpr_mu_unlock(&tcp->mu);
 
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     if (info->wsa_error != 0) {
       error = GRPC_WSA_ERROR(info->wsa_error, "WSASend");
     } else {
@@ -340,7 +345,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
 
 /* Initiates a write. */
 static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                      grpc_closure* cb, void* arg) {
+                      grpc_closure* cb, void* arg, int /*max_frame_size*/) {
   grpc_tcp* tcp = (grpc_tcp*)ep;
   grpc_winsocket* socket = tcp->socket;
   grpc_winsocket_callback_info* info = &socket->write_info;
@@ -366,8 +371,10 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
   if (tcp->shutting_down) {
     grpc_core::ExecCtx::Run(
         DEBUG_LOCATION, cb,
-        GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-            "TCP socket is shutting down", &tcp->shutdown_error, 1));
+        grpc_error_set_int(
+            GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+                "TCP socket is shutting down", &tcp->shutdown_error, 1),
+            GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE));
     return;
   }
 
@@ -500,8 +507,9 @@ static grpc_endpoint_vtable vtable = {win_read,
 grpc_endpoint* grpc_tcp_create(grpc_winsocket* socket,
                                grpc_channel_args* channel_args,
                                absl::string_view peer_string) {
-  grpc_tcp* tcp = new grpc_tcp;
-  memset(tcp, 0, sizeof(grpc_tcp));
+  // TODO(jtattermusch): C++ize grpc_tcp and its dependencies (i.e. add
+  // constructors) to ensure proper initialization
+  grpc_tcp* tcp = new grpc_tcp{};
   tcp->base.vtable = &vtable;
   tcp->socket = socket;
   gpr_mu_init(&tcp->mu);
@@ -510,12 +518,14 @@ grpc_endpoint* grpc_tcp_create(grpc_winsocket* socket,
   GRPC_CLOSURE_INIT(&tcp->on_write, on_write, tcp, grpc_schedule_on_exec_ctx);
   grpc_resolved_address resolved_local_addr;
   resolved_local_addr.len = sizeof(resolved_local_addr.addr);
+  absl::StatusOr<std::string> addr_uri;
   if (getsockname(tcp->socket->socket,
                   reinterpret_cast<sockaddr*>(resolved_local_addr.addr),
-                  &resolved_local_addr.len) < 0) {
+                  &resolved_local_addr.len) < 0 ||
+      !(addr_uri = grpc_sockaddr_to_uri(&resolved_local_addr)).ok()) {
     tcp->local_address = "";
   } else {
-    tcp->local_address = grpc_sockaddr_to_uri(&resolved_local_addr);
+    tcp->local_address = grpc_sockaddr_to_uri(&resolved_local_addr).value();
   }
   tcp->peer_string = std::string(peer_string);
   grpc_slice_buffer_init(&tcp->last_read_buffer);

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

@@ -28,14 +28,14 @@ void grpc_set_timer_impl(grpc_timer_vtable* vtable) {
   grpc_timer_impl = vtable;
 }
 
-void grpc_timer_init(grpc_timer* timer, grpc_millis deadline,
+void grpc_timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
                      grpc_closure* closure) {
   grpc_timer_impl->init(timer, deadline, closure);
 }
 
 void grpc_timer_cancel(grpc_timer* timer) { grpc_timer_impl->cancel(timer); }
 
-grpc_timer_check_result grpc_timer_check(grpc_millis* next) {
+grpc_timer_check_result grpc_timer_check(grpc_core::Timestamp* next) {
   return grpc_timer_impl->check(next);
 }