grpc 1.37.1 → 1.38.0.pre1

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);
 
@@ -210,7 +212,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);

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

@@ -36,9 +36,9 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.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"
 
 /* Return the listener in s with address addr or NULL. */
 static grpc_tcp_listener* find_listener_with_addr(grpc_tcp_server* s,
@@ -58,12 +58,12 @@ static grpc_tcp_listener* find_listener_with_addr(grpc_tcp_server* s,
 }
 
 /* Bind to "::" to get a port number not used by any address. */
-static grpc_error* get_unused_port(int* port) {
+static grpc_error_handle get_unused_port(int* port) {
   grpc_resolved_address wild;
   grpc_sockaddr_make_wildcard6(0, &wild);
   grpc_dualstack_mode dsmode;
   int fd;
-  grpc_error* err =
+  grpc_error_handle err =
       grpc_create_dualstack_socket(&wild, SOCK_STREAM, 0, &dsmode, &fd);
   if (err != GRPC_ERROR_NONE) {
     return err;
@@ -89,15 +89,15 @@ static grpc_error* get_unused_port(int* port) {
                     : GRPC_ERROR_NONE;
 }
 
-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) {
   struct ifaddrs* ifa = nullptr;
   struct ifaddrs* ifa_it;
   unsigned fd_index = 0;
   grpc_tcp_listener* sp = nullptr;
-  grpc_error* err = GRPC_ERROR_NONE;
+  grpc_error_handle err = GRPC_ERROR_NONE;
   if (requested_port == 0) {
     /* Note: There could be a race where some local addrs can listen on the
        selected port and some can't. The sane way to handle this would be to
@@ -146,7 +146,7 @@ grpc_error* grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
     }
     if ((err = grpc_tcp_server_add_addr(s, &addr, port_index, fd_index, &dsmode,
                                         &new_sp)) != GRPC_ERROR_NONE) {
-      grpc_error* root_err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+      grpc_error_handle root_err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
           absl::StrCat("Failed to add listener: ", addr_str).c_str());
       err = grpc_error_add_child(root_err, err);
       break;

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

@@ -24,10 +24,10 @@
 
 #include "src/core/lib/iomgr/tcp_server_utils_posix.h"
 
-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) {
   return GRPC_ERROR_CREATE_FROM_STATIC_STRING("no ifaddrs available");
 }
 

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

@@ -38,11 +38,11 @@
 #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/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/pollset_windows.h"
 #include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/iomgr/tcp_windows.h"
@@ -101,9 +101,9 @@ struct grpc_tcp_server {
 
 /* Public function. Allocates the proper data structures to hold a
    grpc_tcp_server. */
-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 = (grpc_tcp_server*)gpr_malloc(sizeof(grpc_tcp_server));
   s->channel_args = grpc_channel_args_copy(args);
   gpr_ref_init(&s->refs, 1);
@@ -120,7 +120,7 @@ static grpc_error* tcp_server_create(grpc_closure* shutdown_complete,
   return GRPC_ERROR_NONE;
 }
 
-static void destroy_server(void* arg, grpc_error* error) {
+static void destroy_server(void* arg, grpc_error_handle error) {
   grpc_tcp_server* s = (grpc_tcp_server*)arg;
 
   /* Now that the accepts have been aborted, we can destroy the sockets.
@@ -191,11 +191,11 @@ static void tcp_server_unref(grpc_tcp_server* s) {
 }
 
 /* Prepare (bind) a recently-created socket for listening. */
-static grpc_error* prepare_socket(SOCKET sock,
-                                  const grpc_resolved_address* addr,
-                                  int* port) {
+static grpc_error_handle prepare_socket(SOCKET sock,
+                                        const grpc_resolved_address* addr,
+                                        int* port) {
   grpc_resolved_address sockname_temp;
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
   int sockname_temp_len;
 
   error = grpc_tcp_prepare_socket(sock);
@@ -249,12 +249,12 @@ static void decrement_active_ports_and_notify_locked(grpc_tcp_listener* sp) {
 
 /* In order to do an async accept, we need to create a socket first which
    will be the one assigned to the new incoming connection. */
-static grpc_error* start_accept_locked(grpc_tcp_listener* port) {
+static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   SOCKET sock = INVALID_SOCKET;
   BOOL success;
   DWORD addrlen = sizeof(grpc_sockaddr_in6) + 16;
   DWORD bytes_received = 0;
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
 
   if (port->shutting_down) {
     return GRPC_ERROR_NONE;
@@ -299,7 +299,7 @@ failure:
 }
 
 /* Event manager callback when reads are ready. */
-static void on_accept(void* arg, grpc_error* error) {
+static void on_accept(void* arg, grpc_error_handle error) {
   grpc_tcp_listener* sp = (grpc_tcp_listener*)arg;
   SOCKET sock = sp->new_socket;
   grpc_winsocket_callback_info* info = &sp->socket->read_info;
@@ -318,8 +318,8 @@ static void on_accept(void* arg, grpc_error* error) {
      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) {
-    const char* msg = grpc_error_string(error);
-    gpr_log(GPR_INFO, "Skipping on_accept due to error: %s", msg);
+    gpr_log(GPR_INFO, "Skipping on_accept due to error: %s",
+            grpc_error_std_string(error).c_str());
 
     gpr_mu_unlock(&sp->server->mu);
     return;
@@ -388,17 +388,17 @@ static void on_accept(void* arg, grpc_error* error) {
   gpr_mu_unlock(&sp->server->mu);
 }
 
-static grpc_error* add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
-                                        const grpc_resolved_address* addr,
-                                        unsigned port_index,
-                                        grpc_tcp_listener** listener) {
+static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
+                                              const grpc_resolved_address* addr,
+                                              unsigned port_index,
+                                              grpc_tcp_listener** listener) {
   grpc_tcp_listener* sp = NULL;
   int port = -1;
   int status;
   GUID guid = WSAID_ACCEPTEX;
   DWORD ioctl_num_bytes;
   LPFN_ACCEPTEX AcceptEx;
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
 
   /* We need to grab the AcceptEx pointer for that port, as it may be
      interface-dependent. We'll cache it to avoid doing that again. */
@@ -446,9 +446,9 @@ static grpc_error* add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
   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) {
   grpc_tcp_listener* sp = NULL;
   SOCKET sock;
   grpc_resolved_address addr6_v4mapped;
@@ -456,7 +456,7 @@ static grpc_error* tcp_server_add_port(grpc_tcp_server* s,
   grpc_resolved_address* allocated_addr = NULL;
   grpc_resolved_address sockname_temp;
   unsigned port_index = 0;
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
 
   if (s->tail != NULL) {
     port_index = s->tail->port_index + 1;
@@ -508,8 +508,9 @@ done:
   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_uv.cc

@@ -55,7 +55,7 @@ typedef struct uv_socket_t {
 
   int pending_connections;
   grpc_custom_socket* accept_socket;
-  grpc_error* accept_error;
+  grpc_error_handle accept_error;
 
   grpc_custom_connect_callback connect_cb;
   grpc_custom_write_callback write_cb;
@@ -65,11 +65,11 @@ typedef struct uv_socket_t {
 
 } uv_socket_t;
 
-static grpc_error* tcp_error_create(const char* desc, int status) {
+static grpc_error_handle tcp_error_create(const char* desc, int status) {
   if (status == 0) {
     return GRPC_ERROR_NONE;
   }
-  grpc_error* error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(desc);
+  grpc_error_handle error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(desc);
   /* All tcp errors are marked with UNAVAILABLE so that application may
    * choose to retry. */
   error = grpc_error_set_int(error, GRPC_ERROR_INT_GRPC_STATUS,
@@ -95,7 +95,7 @@ static void alloc_uv_buf(uv_handle_t* handle, size_t suggested_size,
 
 static void uv_read_callback(uv_stream_t* stream, ssize_t nread,
                              const uv_buf_t* buf) {
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
   if (nread == 0) {
     // Nothing happened. Wait for the next callback
     return;
@@ -126,7 +126,7 @@ static void uv_socket_read(grpc_custom_socket* socket, char* buffer,
                            size_t length, grpc_custom_read_callback read_cb) {
   uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
   int status;
-  grpc_error* error;
+  grpc_error_handle error;
   uv_socket->read_cb = read_cb;
   uv_socket->read_buf = buffer;
   uv_socket->read_len = length;
@@ -184,7 +184,8 @@ static void uv_socket_close(grpc_custom_socket* socket,
   uv_close((uv_handle_t*)uv_socket->handle, uv_close_callback);
 }
 
-static grpc_error* uv_socket_init_helper(uv_socket_t* uv_socket, int domain) {
+static grpc_error_handle uv_socket_init_helper(uv_socket_t* uv_socket,
+                                               int domain) {
   uv_tcp_t* tcp = (uv_tcp_t*)gpr_malloc(sizeof(uv_tcp_t));
   uv_socket->handle = tcp;
   int status = uv_tcp_init_ex(uv_default_loop(), tcp, (unsigned int)domain);
@@ -212,9 +213,10 @@ static grpc_error* uv_socket_init_helper(uv_socket_t* uv_socket, int domain) {
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* uv_socket_init(grpc_custom_socket* socket, int domain) {
+static grpc_error_handle uv_socket_init(grpc_custom_socket* socket,
+                                        int domain) {
   uv_socket_t* uv_socket = (uv_socket_t*)gpr_malloc(sizeof(uv_socket_t));
-  grpc_error* error = uv_socket_init_helper(uv_socket, domain);
+  grpc_error_handle error = uv_socket_init_helper(uv_socket, domain);
   if (error != GRPC_ERROR_NONE) {
     return error;
   }
@@ -223,18 +225,18 @@ static grpc_error* uv_socket_init(grpc_custom_socket* socket, int domain) {
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* uv_socket_getpeername(grpc_custom_socket* socket,
-                                         const grpc_sockaddr* addr,
-                                         int* addr_len) {
+static grpc_error_handle uv_socket_getpeername(grpc_custom_socket* socket,
+                                               const grpc_sockaddr* addr,
+                                               int* addr_len) {
   uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
   int err = uv_tcp_getpeername(uv_socket->handle,
                                (struct sockaddr*)IGNORE_CONST(addr), addr_len);
   return tcp_error_create("getpeername failed", err);
 }
 
-static grpc_error* uv_socket_getsockname(grpc_custom_socket* socket,
-                                         const grpc_sockaddr* addr,
-                                         int* addr_len) {
+static grpc_error_handle uv_socket_getsockname(grpc_custom_socket* socket,
+                                               const grpc_sockaddr* addr,
+                                               int* addr_len) {
   uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
   int err = uv_tcp_getsockname(uv_socket->handle,
                                (struct sockaddr*)IGNORE_CONST(addr), addr_len);
@@ -247,7 +249,7 @@ static void accept_new_connection(grpc_custom_socket* socket) {
     return;
   }
   grpc_custom_socket* new_socket = uv_socket->accept_socket;
-  grpc_error* error = uv_socket->accept_error;
+  grpc_error_handle error = uv_socket->accept_error;
   uv_socket->accept_socket = nullptr;
   uv_socket->accept_error = GRPC_ERROR_NONE;
   uv_socket->pending_connections -= 1;
@@ -293,16 +295,16 @@ void uv_socket_accept(grpc_custom_socket* socket,
   accept_new_connection(socket);
 }
 
-static grpc_error* uv_socket_bind(grpc_custom_socket* socket,
-                                  const grpc_sockaddr* addr, size_t len,
-                                  int flags) {
+static grpc_error_handle uv_socket_bind(grpc_custom_socket* socket,
+                                        const grpc_sockaddr* addr, size_t len,
+                                        int flags) {
   uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
   int status =
       uv_tcp_bind((uv_tcp_t*)uv_socket->handle, (struct sockaddr*)addr, 0);
   return tcp_error_create("Failed to bind to port", status);
 }
 
-static grpc_error* uv_socket_listen(grpc_custom_socket* socket) {
+static grpc_error_handle uv_socket_listen(grpc_custom_socket* socket) {
   uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
   int status =
       uv_listen((uv_stream_t*)uv_socket->handle, SOMAXCONN, uv_on_connect);
@@ -312,7 +314,7 @@ static grpc_error* uv_socket_listen(grpc_custom_socket* socket) {
 static void uv_tc_on_connect(uv_connect_t* req, int status) {
   grpc_custom_socket* socket = (grpc_custom_socket*)req->data;
   uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  grpc_error* error;
+  grpc_error_handle error;
   if (status == UV_ECANCELED) {
     // This should only happen if the handle is already closed
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Timeout occurred");
@@ -370,8 +372,8 @@ static void uv_resolve_callback(uv_getaddrinfo_t* req, int status,
                                tcp_error_create("getaddrinfo failed", status));
 }
 
-static grpc_error* uv_resolve(const char* host, const char* port,
-                              grpc_resolved_addresses** result) {
+static grpc_error_handle uv_resolve(const char* host, const char* port,
+                                    grpc_resolved_addresses** result) {
   int status;
   uv_getaddrinfo_t req;
   struct addrinfo hints;
@@ -403,7 +405,7 @@ static void uv_resolve_async(grpc_custom_resolver* r, const char* host,
                           port, &hints);
   if (status != 0) {
     gpr_free(req);
-    grpc_error* error = tcp_error_create("getaddrinfo failed", status);
+    grpc_error_handle error = tcp_error_create("getaddrinfo failed", status);
     grpc_custom_resolve_callback(r, NULL, error);
   }
 }