grpc 1.37.1 → 1.39.0

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

@@ -57,4 +57,12 @@ int grpc_tcp_fd(grpc_endpoint* ep);
 void grpc_tcp_destroy_and_release_fd(grpc_endpoint* ep, int* fd,
                                      grpc_closure* done);
 
+#ifdef GRPC_POSIX_SOCKET_TCP
+
+void grpc_tcp_posix_init();
+
+void grpc_tcp_posix_shutdown();
+
+#endif /* GRPC_POSIX_SOCKET_TCP */
+
 #endif /* GRPC_CORE_LIB_IOMGR_TCP_POSIX_H */

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

@@ -22,9 +22,9 @@
 
 grpc_tcp_server_vtable* grpc_tcp_server_impl;
 
-grpc_error* grpc_tcp_server_create(grpc_closure* shutdown_complete,
-                                   const grpc_channel_args* args,
-                                   grpc_tcp_server** server) {
+grpc_error_handle grpc_tcp_server_create(grpc_closure* shutdown_complete,
+                                         const grpc_channel_args* args,
+                                         grpc_tcp_server** server) {
   return grpc_tcp_server_impl->create(shutdown_complete, args, server);
 }
 
@@ -34,9 +34,9 @@ void grpc_tcp_server_start(grpc_tcp_server* server,
   grpc_tcp_server_impl->start(server, pollsets, on_accept_cb, cb_arg);
 }
 
-grpc_error* grpc_tcp_server_add_port(grpc_tcp_server* s,
-                                     const grpc_resolved_address* addr,
-                                     int* out_port) {
+grpc_error_handle grpc_tcp_server_add_port(grpc_tcp_server* s,
+                                           const grpc_resolved_address* addr,
+                                           int* out_port) {
   return grpc_tcp_server_impl->add_port(s, addr, out_port);
 }
 

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

@@ -63,14 +63,15 @@ class TcpServerFdHandler {
 }  // namespace grpc_core
 
 typedef struct grpc_tcp_server_vtable {
-  grpc_error* (*create)(grpc_closure* shutdown_complete,
-                        const grpc_channel_args* args,
-                        grpc_tcp_server** server);
+  grpc_error_handle (*create)(grpc_closure* shutdown_complete,
+                              const grpc_channel_args* args,
+                              grpc_tcp_server** server);
   void (*start)(grpc_tcp_server* server,
                 const std::vector<grpc_pollset*>* pollsets,
                 grpc_tcp_server_cb on_accept_cb, void* cb_arg);
-  grpc_error* (*add_port)(grpc_tcp_server* s, const grpc_resolved_address* addr,
-                          int* out_port);
+  grpc_error_handle (*add_port)(grpc_tcp_server* s,
+                                const grpc_resolved_address* addr,
+                                int* out_port);
   grpc_core::TcpServerFdHandler* (*create_fd_handler)(grpc_tcp_server* s);
   unsigned (*port_fd_count)(grpc_tcp_server* s, unsigned port_index);
   int (*port_fd)(grpc_tcp_server* s, unsigned port_index, unsigned fd_index);
@@ -84,9 +85,9 @@ typedef struct grpc_tcp_server_vtable {
 /* Create a server, initially not bound to any ports. The caller owns one ref.
    If shutdown_complete is not NULL, it will be used by
    grpc_tcp_server_unref() when the ref count reaches zero. */
-grpc_error* grpc_tcp_server_create(grpc_closure* shutdown_complete,
-                                   const grpc_channel_args* args,
-                                   grpc_tcp_server** server);
+grpc_error_handle grpc_tcp_server_create(grpc_closure* shutdown_complete,
+                                         const grpc_channel_args* args,
+                                         grpc_tcp_server** server);
 
 /* Start listening to bound ports */
 void grpc_tcp_server_start(grpc_tcp_server* server,
@@ -102,9 +103,9 @@ void grpc_tcp_server_start(grpc_tcp_server* server,
    but not dualstack sockets. */
 /* TODO(ctiller): deprecate this, and make grpc_tcp_server_add_ports to handle
                   all of the multiple socket port matching logic in one place */
-grpc_error* grpc_tcp_server_add_port(grpc_tcp_server* s,
-                                     const grpc_resolved_address* addr,
-                                     int* out_port);
+grpc_error_handle grpc_tcp_server_add_port(grpc_tcp_server* s,
+                                           const grpc_resolved_address* addr,
+                                           int* out_port);
 
 /* Create and return a TcpServerFdHandler so that it can be used by upper layer
    to hand over an externally connected fd to the grpc server. */

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

@@ -28,12 +28,12 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr_custom.h"
 #include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/tcp_custom.h"
 #include "src/core/lib/iomgr/tcp_server.h"
 
@@ -80,9 +80,9 @@ struct grpc_tcp_server {
   grpc_resource_quota* resource_quota;
 };
 
-static grpc_error* tcp_server_create(grpc_closure* shutdown_complete,
-                                     const grpc_channel_args* args,
-                                     grpc_tcp_server** server) {
+static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
+                                           const grpc_channel_args* args,
+                                           grpc_tcp_server** server) {
   grpc_tcp_server* s =
       static_cast<grpc_tcp_server*>(gpr_malloc(sizeof(grpc_tcp_server)));
   // Let the implementation decide if so_reuseport can be enabled or not.
@@ -218,7 +218,7 @@ static void finish_accept(grpc_tcp_listener* sp, grpc_custom_socket* socket) {
   grpc_endpoint* ep = nullptr;
   grpc_resolved_address peer_name;
   std::string peer_name_string;
-  grpc_error* err;
+  grpc_error_handle err;
 
   memset(&peer_name, 0, sizeof(grpc_resolved_address));
   peer_name.len = GRPC_MAX_SOCKADDR_SIZE;
@@ -246,17 +246,18 @@ static void finish_accept(grpc_tcp_listener* sp, grpc_custom_socket* socket) {
 
 static void custom_accept_callback(grpc_custom_socket* socket,
                                    grpc_custom_socket* client,
-                                   grpc_error* error);
+                                   grpc_error_handle error);
 
 static void custom_accept_callback(grpc_custom_socket* socket,
                                    grpc_custom_socket* client,
-                                   grpc_error* error) {
+                                   grpc_error_handle error) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   grpc_tcp_listener* sp = socket->listener;
   if (error != GRPC_ERROR_NONE) {
     if (!sp->closed) {
-      gpr_log(GPR_ERROR, "Accept failed: %s", grpc_error_string(error));
+      gpr_log(GPR_ERROR, "Accept failed: %s",
+              grpc_error_std_string(error).c_str());
     }
     gpr_free(client);
     GRPC_ERROR_UNREF(error);
@@ -275,14 +276,14 @@ static void custom_accept_callback(grpc_custom_socket* socket,
   }
 }
 
-static grpc_error* add_socket_to_server(grpc_tcp_server* s,
-                                        grpc_custom_socket* socket,
-                                        const grpc_resolved_address* addr,
-                                        unsigned port_index,
-                                        grpc_tcp_listener** listener) {
+static grpc_error_handle add_socket_to_server(grpc_tcp_server* s,
+                                              grpc_custom_socket* socket,
+                                              const grpc_resolved_address* addr,
+                                              unsigned port_index,
+                                              grpc_tcp_listener** listener) {
   grpc_tcp_listener* sp = nullptr;
   int port = -1;
-  grpc_error* error;
+  grpc_error_handle error;
   grpc_resolved_address sockname_temp;
 
   // NOTE(lidiz) The last argument is "flags" which is unused by other
@@ -335,9 +336,9 @@ static grpc_error* add_socket_to_server(grpc_tcp_server* s,
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* tcp_server_add_port(grpc_tcp_server* s,
-                                       const grpc_resolved_address* addr,
-                                       int* port) {
+static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
+                                             const grpc_resolved_address* addr,
+                                             int* port) {
   // This function is mostly copied from tcp_server_windows.c
   grpc_tcp_listener* sp = nullptr;
   grpc_custom_socket* socket;
@@ -346,7 +347,7 @@ static grpc_error* tcp_server_add_port(grpc_tcp_server* s,
   grpc_resolved_address* allocated_addr = nullptr;
   grpc_resolved_address sockname_temp;
   unsigned port_index = 0;
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
   int family;
 
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
@@ -361,10 +362,9 @@ static grpc_error* tcp_server_add_port(grpc_tcp_server* s,
     for (sp = s->head; sp; sp = sp->next) {
       socket = sp->socket;
       sockname_temp.len = GRPC_MAX_SOCKADDR_SIZE;
-      if (nullptr == grpc_custom_socket_vtable->getsockname(
-                         socket,
-                         reinterpret_cast<grpc_sockaddr*>(&sockname_temp.addr),
-                         reinterpret_cast<int*>(&sockname_temp.len))) {
+      if (grpc_custom_socket_vtable->getsockname(
+              socket, reinterpret_cast<grpc_sockaddr*>(&sockname_temp.addr),
+              reinterpret_cast<int*>(&sockname_temp.len)) == GRPC_ERROR_NONE) {
         *port = grpc_sockaddr_get_port(&sockname_temp);
         if (*port > 0) {
           allocated_addr = static_cast<grpc_resolved_address*>(
@@ -392,7 +392,7 @@ static grpc_error* tcp_server_add_port(grpc_tcp_server* s,
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     gpr_log(GPR_INFO, "SERVER %p add_port %s error=%s", s,
             grpc_sockaddr_to_string(addr, false).c_str(),
-            grpc_error_string(error));
+            grpc_error_std_string(error).c_str());
   }
 
   family = grpc_sockaddr_get_family(addr);
@@ -410,8 +410,9 @@ static grpc_error* tcp_server_add_port(grpc_tcp_server* s,
   gpr_free(allocated_addr);
 
   if (error != GRPC_ERROR_NONE) {
-    grpc_error* error_out = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-        "Failed to add port to server", &error, 1);
+    grpc_error_handle error_out =
+        GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+            "Failed to add port to server", &error, 1);
     GRPC_ERROR_UNREF(error);
     error = error_out;
     *port = -1;

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

@@ -47,22 +47,22 @@
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/iomgr/tcp_server_utils_posix.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 
-static grpc_error* tcp_server_create(grpc_closure* shutdown_complete,
-                                     const grpc_channel_args* args,
-                                     grpc_tcp_server** server) {
+static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
+                                           const grpc_channel_args* args,
+                                           grpc_tcp_server** server) {
   grpc_tcp_server* s =
       static_cast<grpc_tcp_server*>(gpr_zalloc(sizeof(grpc_tcp_server)));
   s->so_reuseport = grpc_is_socket_reuse_port_supported();
@@ -129,7 +129,7 @@ static void finish_shutdown(grpc_tcp_server* s) {
   gpr_free(s);
 }
 
-static void destroyed_port(void* server, grpc_error* /*error*/) {
+static void destroyed_port(void* server, grpc_error_handle /*error*/) {
   grpc_tcp_server* s = static_cast<grpc_tcp_server*>(server);
   gpr_mu_lock(&s->mu);
   s->destroyed_ports++;
@@ -188,7 +188,7 @@ static void tcp_server_destroy(grpc_tcp_server* s) {
 }
 
 /* event manager callback when reads are ready */
-static void on_read(void* arg, grpc_error* err) {
+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) {
@@ -238,6 +238,12 @@ static void on_read(void* arg, grpc_error* err) {
 
     grpc_set_socket_no_sigpipe_if_possible(fd);
 
+    err = grpc_apply_socket_mutator_in_args(fd, GRPC_FD_SERVER_CONNECTION_USAGE,
+                                            sp->server->channel_args);
+    if (err != GRPC_ERROR_NONE) {
+      goto error;
+    }
+
     std::string addr_str = grpc_sockaddr_to_uri(&addr);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
       gpr_log(GPR_INFO, "SERVER_CONNECT: incoming connection: %s",
@@ -281,18 +287,18 @@ error:
 }
 
 /* Treat :: or 0.0.0.0 as a family-agnostic wildcard. */
-static grpc_error* add_wildcard_addrs_to_server(grpc_tcp_server* s,
-                                                unsigned port_index,
-                                                int requested_port,
-                                                int* out_port) {
+static grpc_error_handle add_wildcard_addrs_to_server(grpc_tcp_server* s,
+                                                      unsigned port_index,
+                                                      int requested_port,
+                                                      int* out_port) {
   grpc_resolved_address wild4;
   grpc_resolved_address wild6;
   unsigned fd_index = 0;
   grpc_dualstack_mode dsmode;
   grpc_tcp_listener* sp = nullptr;
   grpc_tcp_listener* sp2 = nullptr;
-  grpc_error* v6_err = GRPC_ERROR_NONE;
-  grpc_error* v4_err = GRPC_ERROR_NONE;
+  grpc_error_handle v6_err = GRPC_ERROR_NONE;
+  grpc_error_handle v4_err = GRPC_ERROR_NONE;
   *out_port = -1;
 
   if (grpc_tcp_server_have_ifaddrs() && s->expand_wildcard_addrs) {
@@ -325,19 +331,19 @@ static grpc_error* add_wildcard_addrs_to_server(grpc_tcp_server* s,
       gpr_log(GPR_INFO,
               "Failed to add :: listener, "
               "the environment may not support IPv6: %s",
-              grpc_error_string(v6_err));
+              grpc_error_std_string(v6_err).c_str());
       GRPC_ERROR_UNREF(v6_err);
     }
     if (v4_err != GRPC_ERROR_NONE) {
       gpr_log(GPR_INFO,
               "Failed to add 0.0.0.0 listener, "
               "the environment may not support IPv4: %s",
-              grpc_error_string(v4_err));
+              grpc_error_std_string(v4_err).c_str());
       GRPC_ERROR_UNREF(v4_err);
     }
     return GRPC_ERROR_NONE;
   } else {
-    grpc_error* root_err = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+    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);
     root_err = grpc_error_add_child(root_err, v6_err);
@@ -346,10 +352,11 @@ static grpc_error* add_wildcard_addrs_to_server(grpc_tcp_server* s,
   }
 }
 
-static grpc_error* clone_port(grpc_tcp_listener* listener, unsigned count) {
+static grpc_error_handle clone_port(grpc_tcp_listener* listener,
+                                    unsigned count) {
   grpc_tcp_listener* sp = nullptr;
   std::string addr_str;
-  grpc_error* err;
+  grpc_error_handle err;
 
   for (grpc_tcp_listener* l = listener->next; l && l->is_sibling; l = l->next) {
     l->fd_index += count;
@@ -395,16 +402,16 @@ static grpc_error* clone_port(grpc_tcp_listener* listener, unsigned count) {
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* tcp_server_add_port(grpc_tcp_server* s,
-                                       const grpc_resolved_address* addr,
-                                       int* out_port) {
+static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
+                                             const grpc_resolved_address* addr,
+                                             int* out_port) {
   grpc_tcp_listener* sp;
   grpc_resolved_address sockname_temp;
   grpc_resolved_address addr6_v4mapped;
   int requested_port = grpc_sockaddr_get_port(addr);
   unsigned port_index = 0;
   grpc_dualstack_mode dsmode;
-  grpc_error* err;
+  grpc_error_handle err;
   *out_port = -1;
   if (s->tail != nullptr) {
     port_index = s->tail->port_index + 1;

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

@@ -98,26 +98,27 @@ struct grpc_tcp_server {
 
 /* If successful, add a listener to \a s for \a addr, set \a dsmode for the
    socket, and return the \a listener. */
-grpc_error* grpc_tcp_server_add_addr(grpc_tcp_server* s,
-                                     const grpc_resolved_address* addr,
-                                     unsigned port_index, unsigned fd_index,
-                                     grpc_dualstack_mode* dsmode,
-                                     grpc_tcp_listener** listener);
+grpc_error_handle grpc_tcp_server_add_addr(grpc_tcp_server* s,
+                                           const grpc_resolved_address* addr,
+                                           unsigned port_index,
+                                           unsigned fd_index,
+                                           grpc_dualstack_mode* dsmode,
+                                           grpc_tcp_listener** listener);
 
 /* Get all addresses assigned to network interfaces on the machine and create a
    listener for each. requested_port is the port to use for every listener, or 0
    to select one random port that will be used for every listener. Set *out_port
    to the port selected. Return GRPC_ERROR_NONE only if all listeners were
    added. */
-grpc_error* grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
-                                                unsigned port_index,
-                                                int requested_port,
-                                                int* out_port);
+grpc_error_handle grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
+                                                      unsigned port_index,
+                                                      int requested_port,
+                                                      int* out_port);
 
 /* Prepare a recently-created socket for listening. */
-grpc_error* grpc_tcp_server_prepare_socket(grpc_tcp_server*, int fd,
-                                           const grpc_resolved_address* addr,
-                                           bool so_reuseport, int* port);
+grpc_error_handle grpc_tcp_server_prepare_socket(
+    grpc_tcp_server*, int fd, const grpc_resolved_address* addr,
+    bool so_reuseport, int* port);
 /* Ruturn true if the platform supports ifaddrs */
 bool grpc_tcp_server_have_ifaddrs(void);
 

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

@@ -37,9 +37,9 @@
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 
 #define MIN_SAFE_ACCEPT_QUEUE_SIZE 100
@@ -80,14 +80,15 @@ static int get_max_accept_queue_size(void) {
   return s_max_accept_queue_size;
 }
 
-static grpc_error* add_socket_to_server(grpc_tcp_server* s, int fd,
-                                        const grpc_resolved_address* addr,
-                                        unsigned port_index, unsigned fd_index,
-                                        grpc_tcp_listener** listener) {
+static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, int fd,
+                                              const grpc_resolved_address* addr,
+                                              unsigned port_index,
+                                              unsigned fd_index,
+                                              grpc_tcp_listener** listener) {
   grpc_tcp_listener* sp = nullptr;
   int port = -1;
 
-  grpc_error* err =
+  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);
@@ -123,14 +124,15 @@ static grpc_error* add_socket_to_server(grpc_tcp_server* s, int fd,
 
 /* If successful, add a listener to s for addr, set *dsmode for the socket, and
    return the *listener. */
-grpc_error* grpc_tcp_server_add_addr(grpc_tcp_server* s,
-                                     const grpc_resolved_address* addr,
-                                     unsigned port_index, unsigned fd_index,
-                                     grpc_dualstack_mode* dsmode,
-                                     grpc_tcp_listener** listener) {
+grpc_error_handle grpc_tcp_server_add_addr(grpc_tcp_server* s,
+                                           const grpc_resolved_address* addr,
+                                           unsigned port_index,
+                                           unsigned fd_index,
+                                           grpc_dualstack_mode* dsmode,
+                                           grpc_tcp_listener** listener) {
   grpc_resolved_address addr4_copy;
   int fd;
-  grpc_error* err =
+  grpc_error_handle err =
       grpc_create_dualstack_socket(addr, SOCK_STREAM, 0, dsmode, &fd);
   if (err != GRPC_ERROR_NONE) {
     return err;
@@ -143,11 +145,11 @@ grpc_error* grpc_tcp_server_add_addr(grpc_tcp_server* s,
 }
 
 /* Prepare a recently-created socket for listening. */
-grpc_error* grpc_tcp_server_prepare_socket(grpc_tcp_server* s, int fd,
-                                           const grpc_resolved_address* addr,
-                                           bool so_reuseport, int* port) {
+grpc_error_handle grpc_tcp_server_prepare_socket(
+    grpc_tcp_server* s, int fd, const grpc_resolved_address* addr,
+    bool so_reuseport, int* port) {
   grpc_resolved_address sockname_temp;
-  grpc_error* err = GRPC_ERROR_NONE;
+  grpc_error_handle err = GRPC_ERROR_NONE;
 
   GPR_ASSERT(fd >= 0);
 
@@ -180,7 +182,8 @@ grpc_error* grpc_tcp_server_prepare_socket(grpc_tcp_server* s, int fd,
   err = grpc_set_socket_no_sigpipe_if_possible(fd);
   if (err != GRPC_ERROR_NONE) goto error;
 
-  err = grpc_apply_socket_mutator_in_args(fd, s->channel_args);
+  err = grpc_apply_socket_mutator_in_args(fd, GRPC_FD_SERVER_LISTENER_USAGE,
+                                          s->channel_args);
   if (err != GRPC_ERROR_NONE) goto error;
 
   if (bind(fd, reinterpret_cast<grpc_sockaddr*>(const_cast<char*>(addr->addr)),
@@ -210,7 +213,7 @@ error:
   if (fd >= 0) {
     close(fd);
   }
-  grpc_error* ret =
+  grpc_error_handle ret =
       grpc_error_set_int(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                              "Unable to configure socket", &err, 1),
                          GRPC_ERROR_INT_FD, fd);