grpc 1.28.0 → 1.30.2

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

@@ -26,7 +26,7 @@
 #include "src/core/lib/iomgr/resolve_address.h"
 
 /** The virtual table of grpc_socket_factory */
-typedef struct {
+struct grpc_socket_factory_vtable {
   /** Replacement for socket(2) */
   int (*socket)(grpc_socket_factory* factory, int domain, int type,
                 int protocol);
@@ -37,8 +37,7 @@ typedef struct {
   int (*compare)(grpc_socket_factory* a, grpc_socket_factory* b);
   /** Destroys the socket factory instance */
   void (*destroy)(grpc_socket_factory* factory);
-} grpc_socket_factory_vtable;
-
+};
 /** The Socket Factory interface allows changes on socket options */
 struct grpc_socket_factory {
   const grpc_socket_factory_vtable* vtable;

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

@@ -27,15 +27,14 @@
 #include <stdbool.h>
 
 /** The virtual table of grpc_socket_mutator */
-typedef struct {
+struct grpc_socket_mutator_vtable {
   /** Mutates the socket options of \a fd */
   bool (*mutate_fd)(int fd, grpc_socket_mutator* mutator);
   /** Compare socket mutator \a a and \a b */
   int (*compare)(grpc_socket_mutator* a, grpc_socket_mutator* b);
   /** Destroys the socket mutator instance */
   void (*destroy)(grpc_socket_mutator* mutator);
-} grpc_socket_mutator_vtable;
-
+};
 /** The Socket Mutator interface allows changes on socket options */
 struct grpc_socket_mutator {
   const grpc_socket_mutator_vtable* vtable;

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

@@ -41,6 +41,8 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include <string>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
@@ -210,7 +212,6 @@ static gpr_once g_probe_so_reuesport_once = GPR_ONCE_INIT;
 static int g_support_so_reuseport = false;
 
 void probe_so_reuseport_once(void) {
-#ifndef GPR_MANYLINUX1
   int s = socket(AF_INET, SOCK_STREAM, 0);
   if (s < 0) {
     /* This might be an ipv6-only environment in which case 'socket(AF_INET,..)'
@@ -222,7 +223,6 @@ void probe_so_reuseport_once(void) {
         "check for SO_REUSEPORT", grpc_set_socket_reuse_port(s, 1));
     close(s);
   }
-#endif
 }
 
 bool grpc_is_socket_reuse_port_supported() {
@@ -396,31 +396,12 @@ int grpc_ipv6_loopback_available(void) {
   return g_ipv6_loopback_available;
 }
 
-/* This should be 0 in production, but it may be enabled for testing or
-   debugging purposes, to simulate an environment where IPv6 sockets can't
-   also speak IPv4. */
-int grpc_forbid_dualstack_sockets_for_testing = 0;
-
-static int set_socket_dualstack(int fd) {
-  if (!grpc_forbid_dualstack_sockets_for_testing) {
-    const int off = 0;
-    return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(off));
-  } else {
-    /* Force an IPv6-only socket, for testing purposes. */
-    const int on = 1;
-    setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on));
-    return 0;
-  }
-}
-
 static grpc_error* error_for_fd(int fd, const grpc_resolved_address* addr) {
   if (fd >= 0) return GRPC_ERROR_NONE;
-  char* addr_str;
-  grpc_sockaddr_to_string(&addr_str, addr, 0);
-  grpc_error* err = grpc_error_set_str(GRPC_OS_ERROR(errno, "socket"),
-                                       GRPC_ERROR_STR_TARGET_ADDRESS,
-                                       grpc_slice_from_copied_string(addr_str));
-  gpr_free(addr_str);
+  std::string addr_str = grpc_sockaddr_to_string(addr, false);
+  grpc_error* err = grpc_error_set_str(
+      GRPC_OS_ERROR(errno, "socket"), GRPC_ERROR_STR_TARGET_ADDRESS,
+      grpc_slice_from_copied_string(addr_str.c_str()));
   return err;
 }
 
@@ -452,7 +433,7 @@ grpc_error* grpc_create_dualstack_socket_using_factory(
       errno = EAFNOSUPPORT;
     }
     /* Check if we've got a valid dualstack socket. */
-    if (*newfd >= 0 && set_socket_dualstack(*newfd)) {
+    if (*newfd >= 0 && grpc_set_socket_dualstack(*newfd)) {
       *dsmode = GRPC_DSMODE_DUALSTACK;
       return GRPC_ERROR_NONE;
     }

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

@@ -126,6 +126,9 @@ typedef enum grpc_dualstack_mode {
 /* Only tests should use this flag. */
 extern int grpc_forbid_dualstack_sockets_for_testing;
 
+/* Tries to set the socket to dualstack. Returns 1 on success. */
+int grpc_set_socket_dualstack(int fd);
+
 /* Creates a new socket for connecting to (or listening on) an address.
 
    If addr is AF_INET6, this creates an IPv6 socket first.  If that fails,

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

@@ -143,14 +143,12 @@ static void OnOpen(void* arg, grpc_error* error) {
 
 static void ParseResolvedAddress(const grpc_resolved_address* addr,
                                  CFStringRef* host, int* port) {
-  char* host_port;
-  grpc_sockaddr_to_string(&host_port, addr, 1);
-  grpc_core::UniquePtr<char> host_string;
-  grpc_core::UniquePtr<char> port_string;
+  std::string host_port = grpc_sockaddr_to_string(addr, true);
+  std::string host_string;
+  std::string port_string;
   grpc_core::SplitHostPort(host_port, &host_string, &port_string);
-  *host =
-      CFStringCreateWithCString(NULL, host_string.get(), kCFStringEncodingUTF8);
-  gpr_free(host_port);
+  *host = CFStringCreateWithCString(NULL, host_string.c_str(),
+                                    kCFStringEncodingUTF8);
   *port = grpc_sockaddr_get_port(addr);
 }
 

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

@@ -49,7 +49,7 @@
 
 extern grpc_core::TraceFlag grpc_tcp_trace;
 
-typedef struct {
+struct async_connect {
   gpr_mu mu;
   grpc_fd* fd;
   grpc_timer alarm;
@@ -61,8 +61,7 @@ typedef struct {
   grpc_endpoint** ep;
   grpc_closure* closure;
   grpc_channel_args* channel_args;
-} async_connect;
-
+};
 static grpc_error* prepare_socket(const grpc_resolved_address* addr, int fd,
                                   const grpc_channel_args* channel_args) {
   grpc_error* err = GRPC_ERROR_NONE;
@@ -302,9 +301,13 @@ void grpc_tcp_client_create_from_prepared_fd(
     return;
   }
   if (errno != EWOULDBLOCK && errno != EINPROGRESS) {
+    grpc_error* error = GRPC_OS_ERROR(errno, "connect");
+    char* addr_str = grpc_sockaddr_to_uri(addr);
+    error = grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS,
+                               grpc_slice_from_copied_string(addr_str));
+    gpr_free(addr_str);
     grpc_fd_orphan(fdobj, nullptr, nullptr, "tcp_client_connect_error");
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure,
-                            GRPC_OS_ERROR(errno, "connect"));
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
     return;
   }
 

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

@@ -40,7 +40,7 @@
 #include "src/core/lib/iomgr/tcp_windows.h"
 #include "src/core/lib/iomgr/timer.h"
 
-typedef struct {
+struct async_connect {
   grpc_closure* on_done;
   gpr_mu mu;
   grpc_winsocket* socket;
@@ -51,8 +51,7 @@ typedef struct {
   grpc_closure on_connect;
   grpc_endpoint** endpoint;
   grpc_channel_args* channel_args;
-} async_connect;
-
+};
 static void async_connect_unlock_and_cleanup(async_connect* ac,
                                              grpc_winsocket* socket) {
   int done = (--ac->refs == 0);

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

@@ -52,7 +52,7 @@ void grpc_custom_endpoint_init(grpc_socket_vtable* impl) {
   grpc_set_tcp_server_impl(&custom_tcp_server_vtable);
 }
 
-typedef struct {
+struct custom_tcp_endpoint {
   grpc_endpoint base;
   gpr_refcount refcount;
   grpc_custom_socket* socket;
@@ -69,8 +69,7 @@ typedef struct {
   bool shutting_down;
 
   char* peer_string;
-} custom_tcp_endpoint;
-
+};
 static void tcp_free(grpc_custom_socket* s) {
   custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)s->endpoint;
   grpc_resource_user_unref(tcp->resource_user);

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

@@ -23,6 +23,8 @@
 #include <assert.h>
 #include <string.h>
 
+#include <string>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
@@ -389,15 +391,9 @@ static grpc_error* tcp_server_add_port(grpc_tcp_server* s,
   }
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-    char* port_string;
-    grpc_sockaddr_to_string(&port_string, addr, 0);
-    const char* str = grpc_error_string(error);
-    if (port_string) {
-      gpr_log(GPR_INFO, "SERVER %p add_port %s error=%s", s, port_string, str);
-      gpr_free(port_string);
-    } else {
-      gpr_log(GPR_INFO, "SERVER %p add_port error=%s", s, str);
-    }
+    gpr_log(GPR_INFO, "SERVER %p add_port %s error=%s", s,
+            grpc_sockaddr_to_string(addr, false).c_str(),
+            grpc_error_string(error));
   }
 
   family = grpc_sockaddr_get_family(addr);

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

@@ -37,6 +37,8 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include <string>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -349,7 +351,7 @@ static grpc_error* add_wildcard_addrs_to_server(grpc_tcp_server* s,
 
 static grpc_error* clone_port(grpc_tcp_listener* listener, unsigned count) {
   grpc_tcp_listener* sp = nullptr;
-  char* addr_str;
+  std::string addr_str;
   char* name;
   grpc_error* err;
 
@@ -368,8 +370,8 @@ static grpc_error* clone_port(grpc_tcp_listener* listener, unsigned count) {
                                          true, &port);
     if (err != GRPC_ERROR_NONE) return err;
     listener->server->nports++;
-    grpc_sockaddr_to_string(&addr_str, &listener->addr, 1);
-    gpr_asprintf(&name, "tcp-server-listener:%s/clone-%d", addr_str, i);
+    addr_str = grpc_sockaddr_to_string(&listener->addr, true);
+    gpr_asprintf(&name, "tcp-server-listener:%s/clone-%d", addr_str.c_str(), i);
     sp = static_cast<grpc_tcp_listener*>(gpr_malloc(sizeof(grpc_tcp_listener)));
     sp->next = listener->next;
     listener->next = sp;
@@ -389,7 +391,6 @@ static grpc_error* clone_port(grpc_tcp_listener* listener, unsigned count) {
     while (listener->server->tail->next != nullptr) {
       listener->server->tail = listener->server->tail->next;
     }
-    gpr_free(addr_str);
     gpr_free(name);
   }
 

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

@@ -29,6 +29,8 @@
 #include <stdio.h>
 #include <string.h>
 
+#include <string>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -83,15 +85,15 @@ static grpc_error* add_socket_to_server(grpc_tcp_server* s, int fd,
                                         grpc_tcp_listener** listener) {
   grpc_tcp_listener* sp = nullptr;
   int port = -1;
-  char* addr_str;
+  std::string addr_str;
   char* name;
 
   grpc_error* err =
       grpc_tcp_server_prepare_socket(s, fd, addr, s->so_reuseport, &port);
   if (err == GRPC_ERROR_NONE) {
     GPR_ASSERT(port > 0);
-    grpc_sockaddr_to_string(&addr_str, addr, 1);
-    gpr_asprintf(&name, "tcp-server-listener:%s", addr_str);
+    addr_str = grpc_sockaddr_to_string(addr, true);
+    gpr_asprintf(&name, "tcp-server-listener:%s", addr_str.c_str());
     gpr_mu_lock(&s->mu);
     s->nports++;
     GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server");
@@ -114,7 +116,6 @@ static grpc_error* add_socket_to_server(grpc_tcp_server* s, int fd,
     sp->sibling = nullptr;
     GPR_ASSERT(sp->emfd);
     gpr_mu_unlock(&s->mu);
-    gpr_free(addr_str);
     gpr_free(name);
   }
 

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

@@ -29,6 +29,8 @@
 #include <stddef.h>
 #include <string.h>
 
+#include <string>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -112,7 +114,6 @@ grpc_error* grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
   }
   for (ifa_it = ifa; ifa_it != nullptr; ifa_it = ifa_it->ifa_next) {
     grpc_resolved_address addr;
-    char* addr_str = nullptr;
     grpc_dualstack_mode dsmode;
     grpc_tcp_listener* new_sp = nullptr;
     const char* ifa_name = (ifa_it->ifa_name ? ifa_it->ifa_name : "<unknown>");
@@ -131,30 +132,27 @@ grpc_error* grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
       err = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to set port");
       break;
     }
-    if (grpc_sockaddr_to_string(&addr_str, &addr, 0) < 0) {
-      addr_str = gpr_strdup("<error>");
-    }
+    std::string addr_str = grpc_sockaddr_to_string(&addr, false);
     gpr_log(GPR_DEBUG,
             "Adding local addr from interface %s flags 0x%x to server: %s",
-            ifa_name, ifa_it->ifa_flags, addr_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,
-              ifa_name);
-      gpr_free(addr_str);
+      gpr_log(GPR_DEBUG, "Skipping duplicate addr %s on interface %s",
+              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) {
       char* err_str = nullptr;
       grpc_error* root_err;
-      if (gpr_asprintf(&err_str, "Failed to add listener: %s", addr_str) < 0) {
+      if (gpr_asprintf(&err_str, "Failed to add listener: %s",
+                       addr_str.c_str()) < 0) {
         err_str = gpr_strdup("Failed to add listener");
       }
       root_err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(err_str);
       gpr_free(err_str);
-      gpr_free(addr_str);
       err = grpc_error_add_child(root_err, err);
       break;
     } else {
@@ -166,7 +164,6 @@ grpc_error* grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
       }
       sp = new_sp;
     }
-    gpr_free(addr_str);
   }
   freeifaddrs(ifa);
   if (err != GRPC_ERROR_NONE) {

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

@@ -370,7 +370,7 @@ static void uv_resolve_callback(uv_getaddrinfo_t* req, int status,
                                tcp_error_create("getaddrinfo failed", status));
 }
 
-static grpc_error* uv_resolve(char* host, char* port,
+static grpc_error* uv_resolve(const char* host, const char* port,
                               grpc_resolved_addresses** result) {
   int status;
   uv_getaddrinfo_t req;
@@ -388,7 +388,8 @@ static grpc_error* uv_resolve(char* host, char* port,
   return tcp_error_create("getaddrinfo failed", status);
 }
 
-static void uv_resolve_async(grpc_custom_resolver* r, char* host, char* port) {
+static void uv_resolve_async(grpc_custom_resolver* r, const char* host,
+                             const char* port) {
   int status;
   uv_getaddrinfo_t* req =
       (uv_getaddrinfo_t*)gpr_malloc(sizeof(uv_getaddrinfo_t));

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

@@ -24,7 +24,7 @@
    weighted mean.  It is designed for batch operations where we do many adds
    before updating the average. */
 
-typedef struct {
+struct grpc_time_averaged_stats {
   /* The initial average value.  This is the reported average until the first
      grpc_time_averaged_stats_update_average call.  If a positive regress_weight
      is used, we also regress towards this value on each update. */
@@ -56,8 +56,7 @@ typedef struct {
   /* A time-decayed average of the (batch_total_value_ / batch_num_samples_),
      computed by decaying the samples_in_avg_ weight in the weighted average. */
   double aggregate_weighted_avg;
-} grpc_time_averaged_stats;
-
+};
 /* See the comments on the members above for an explanation of init_avg,
    regress_weight, and persistence_factor. */
 void grpc_time_averaged_stats_init(grpc_time_averaged_stats* stats,

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

@@ -56,7 +56,7 @@ grpc_core::TraceFlag grpc_timer_check_trace(false, "timer_check");
  * stats maintained in 'stats' and the relevant timers are then moved from the
  * 'list' to 'heap'.
  */
-typedef struct {
+struct timer_shard {
   gpr_mu mu;
   grpc_time_averaged_stats stats;
   /* All and only timers with deadlines < this will be in the heap. */
@@ -70,8 +70,7 @@ typedef struct {
   grpc_timer_heap heap;
   /* This holds timers whose deadline is >= queue_deadline_cap. */
   grpc_timer list;
-} timer_shard;
-
+};
 static size_t g_num_shards;
 
 /* Array of timer shards. Whenever a timer (grpc_timer *) is added, its address

data/src/core/lib/{gprpp/inlined_vector.h → iomgr/timer_generic.h}

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright 2017 gRPC authors.
+ * Copyright 2016 gRPC authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,22 +16,24 @@
  *
  */
 
-#ifndef GRPC_CORE_LIB_GPRPP_INLINED_VECTOR_H
-#define GRPC_CORE_LIB_GPRPP_INLINED_VECTOR_H
+#ifndef GRPC_CORE_LIB_IOMGR_TIMER_GENERIC_H
+#define GRPC_CORE_LIB_IOMGR_TIMER_GENERIC_H
 
 #include <grpc/support/port_platform.h>
 
-#include <cassert>
-#include <cstring>
-
-#include "absl/container/inlined_vector.h"
-#include "src/core/lib/gprpp/memory.h"
-
-namespace grpc_core {
-
-template <typename T, size_t N, typename A = std::allocator<T>>
-using InlinedVector = absl::InlinedVector<T, N, A>;
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_GPRPP_INLINED_VECTOR_H */
+#include <grpc/support/time.h>
+#include "src/core/lib/iomgr/exec_ctx.h"
+
+struct grpc_timer {
+  gpr_atm deadline;
+  uint32_t heap_index; /* INVALID_HEAP_INDEX if not in heap */
+  bool pending;
+  struct grpc_timer* next;
+  struct grpc_timer* prev;
+  grpc_closure* closure;
+#ifndef NDEBUG
+  struct grpc_timer* hash_table_next;
+#endif
+};
+
+#endif /* GRPC_CORE_LIB_IOMGR_TIMER_GENERIC_H */