grpc 1.28.0.pre2 → 1.31.0.pre1

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

@@ -82,10 +82,9 @@ struct grpc_tcp_server {
   /* shutdown callback */
   grpc_closure* shutdown_complete;
 
-  /* all pollsets interested in new connections */
-  grpc_pollset** pollsets;
-  /* number of pollsets in the pollsets array */
-  size_t pollset_count;
+  /* all pollsets interested in new connections. The object pointed at is not
+   * owned by this struct */
+  const std::vector<grpc_pollset*>* pollsets;
 
   /* next pollset to assign a channel to */
   gpr_atm next_pollset_to_assign;

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

@@ -29,9 +29,12 @@
 #include <stdio.h>
 #include <string.h>
 
+#include <string>
+
+#include "absl/strings/str_cat.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/iomgr/error.h"
@@ -83,15 +86,13 @@ 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;
-  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);
+    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");
@@ -105,7 +106,7 @@ static grpc_error* add_socket_to_server(grpc_tcp_server* s, int fd,
     s->tail = sp;
     sp->server = s;
     sp->fd = fd;
-    sp->emfd = grpc_fd_create(fd, name, true);
+    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;
@@ -114,8 +115,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);
   }
 
   *listener = sp;

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

@@ -29,9 +29,12 @@
 #include <stddef.h>
 #include <string.h>
 
+#include <string>
+
+#include "absl/strings/str_cat.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/sockaddr.h"
@@ -112,7 +115,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 +133,21 @@ 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) {
-        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);
+      grpc_error* 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;
     } else {
@@ -166,7 +159,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_server_windows.cc

@@ -27,6 +27,10 @@
 #include <inttypes.h>
 #include <io.h>
 
+#include <vector>
+
+#include "absl/strings/str_cat.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/log_windows.h>
@@ -42,6 +46,7 @@
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/iomgr/tcp_windows.h"
+#include "src/core/lib/slice/slice_internal.h"
 
 #define MIN_SAFE_ACCEPT_QUEUE_SIZE 100
 
@@ -222,14 +227,13 @@ static grpc_error* prepare_socket(SOCKET sock,
 
 failure:
   GPR_ASSERT(error != GRPC_ERROR_NONE);
-  char* tgtaddr = 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_slice_from_copied_string(tgtaddr)),
+      grpc_error_set_str(
+          GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+              "Failed to prepare server socket", &error, 1),
+          GRPC_ERROR_STR_TARGET_ADDRESS,
+          grpc_slice_from_cpp_string(grpc_sockaddr_to_uri(addr))),
       GRPC_ERROR_INT_FD, (intptr_t)sock);
-  gpr_free(tgtaddr);
   GRPC_ERROR_UNREF(error);
   if (sock != INVALID_SOCKET) closesocket(sock);
   return error;
@@ -301,8 +305,6 @@ static void on_accept(void* arg, grpc_error* error) {
   grpc_winsocket_callback_info* info = &sp->socket->read_info;
   grpc_endpoint* ep = NULL;
   grpc_resolved_address peer_name;
-  char* peer_name_string;
-  char* fd_name;
   DWORD transfered_bytes;
   DWORD flags;
   BOOL wsa_success;
@@ -337,7 +339,6 @@ static void on_accept(void* arg, grpc_error* error) {
     closesocket(sock);
   } else {
     if (!sp->shutting_down) {
-      peer_name_string = NULL;
       err = setsockopt(sock, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT,
                        (char*)&sp->socket->socket, sizeof(sp->socket->socket));
       if (err) {
@@ -348,6 +349,7 @@ static void on_accept(void* arg, grpc_error* error) {
       int peer_name_len = (int)peer_name.len;
       err = getpeername(sock, (grpc_sockaddr*)peer_name.addr, &peer_name_len);
       peer_name.len = (size_t)peer_name_len;
+      std::string peer_name_string;
       if (!err) {
         peer_name_string = grpc_sockaddr_to_uri(&peer_name);
       } else {
@@ -355,11 +357,9 @@ static void on_accept(void* arg, grpc_error* error) {
         gpr_log(GPR_ERROR, "getpeername error: %s", utf8_message);
         gpr_free(utf8_message);
       }
-      gpr_asprintf(&fd_name, "tcp_server:%s", peer_name_string);
-      ep = grpc_tcp_create(grpc_winsocket_create(sock, fd_name),
-                           sp->server->channel_args, peer_name_string);
-      gpr_free(fd_name);
-      gpr_free(peer_name_string);
+      std::string fd_name = absl::StrCat("tcp_server:", peer_name_string);
+      ep = grpc_tcp_create(grpc_winsocket_create(sock, fd_name.c_str()),
+                           sp->server->channel_args, peer_name_string.c_str());
     } else {
       closesocket(sock);
     }
@@ -520,8 +520,8 @@ done:
   return error;
 }
 
-static void tcp_server_start(grpc_tcp_server* s, grpc_pollset** pollset,
-                             size_t pollset_count,
+static void tcp_server_start(grpc_tcp_server* s,
+                             const std::vector<grpc_pollset*>* /*pollsets*/,
                              grpc_tcp_server_cb on_accept_cb,
                              void* on_accept_cb_arg) {
   grpc_tcp_listener* sp;

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

@@ -22,12 +22,15 @@
 
 #include <inttypes.h>
 
+#include <string>
+
+#include "absl/strings/str_cat.h"
+
 #include "src/core/lib/iomgr/timer.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/cpu.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/debug/trace.h"
@@ -56,7 +59,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 +73,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
@@ -707,38 +709,36 @@ static grpc_timer_check_result timer_check(grpc_millis* next) {
 
   // tracing
   if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-    char* next_str;
+    std::string next_str;
     if (next == nullptr) {
-      next_str = gpr_strdup("NULL");
+      next_str = "NULL";
     } else {
-      gpr_asprintf(&next_str, "%" PRId64, *next);
+      next_str = absl::StrCat(*next);
     }
 #if GPR_ARCH_64
     gpr_log(GPR_INFO,
             "TIMER CHECK BEGIN: now=%" PRId64 " next=%s tls_min=%" PRId64
             " glob_min=%" PRId64,
-            now, next_str, min_timer,
+            now, next_str.c_str(), min_timer,
             static_cast<grpc_millis>(gpr_atm_no_barrier_load(
                 (gpr_atm*)(&g_shared_mutables.min_timer))));
 #else
     gpr_log(GPR_INFO, "TIMER CHECK BEGIN: now=%" PRId64 " next=%s min=%" PRId64,
-            now, next_str, min_timer);
+            now, next_str.c_str(), min_timer);
 #endif
-    gpr_free(next_str);
   }
   // actual code
   grpc_timer_check_result r =
       run_some_expired_timers(now, next, shutdown_error);
   // tracing
   if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-    char* next_str;
+    std::string next_str;
     if (next == nullptr) {
-      next_str = gpr_strdup("NULL");
+      next_str = "NULL";
     } else {
-      gpr_asprintf(&next_str, "%" PRId64, *next);
+      next_str = absl::StrCat(*next);
     }
-    gpr_log(GPR_INFO, "TIMER CHECK END: r=%d; next=%s", r, next_str);
-    gpr_free(next_str);
+    gpr_log(GPR_INFO, "TIMER CHECK END: r=%d; next=%s", r, next_str.c_str());
   }
   return r;
 }

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 */

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

@@ -23,12 +23,11 @@
 
 #include "src/core/lib/iomgr/timer.h"
 
-typedef struct {
+struct grpc_timer_heap {
   grpc_timer** timers;
   uint32_t timer_count;
   uint32_t timer_capacity;
-} grpc_timer_heap;
-
+};
 /* return true if the new timer is the first timer in the heap */
 bool grpc_timer_heap_add(grpc_timer_heap* heap, grpc_timer* timer);
 

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

@@ -44,6 +44,12 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include <string>
+#include <vector>
+
+#include "absl/container/inlined_vector.h"
+#include "absl/strings/str_cat.h"
+
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -52,7 +58,6 @@
 #include <grpc/support/time.h>
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/ev_posix.h"
@@ -73,7 +78,7 @@ class GrpcUdpListener {
   ~GrpcUdpListener();
 
   /* Called when grpc server starts to listening on the grpc_fd. */
-  void StartListening(grpc_pollset** pollsets, size_t pollset_count,
+  void StartListening(const std::vector<grpc_pollset*>* pollsets,
                       GrpcUdpHandlerFactory* handler_factory);
 
   /* Called when data is available to read from the socket.
@@ -147,15 +152,11 @@ GrpcUdpListener::GrpcUdpListener(grpc_udp_server* server, int fd,
       server_(server),
       orphan_notified_(false),
       already_shutdown_(false) {
-  char* addr_str;
-  char* name;
-  grpc_sockaddr_to_string(&addr_str, addr, 1);
-  gpr_asprintf(&name, "udp-server-listener:%s", addr_str);
-  gpr_free(addr_str);
-  emfd_ = grpc_fd_create(fd, name, true);
+  std::string addr_str = grpc_sockaddr_to_string(addr, true);
+  std::string name = absl::StrCat("udp-server-listener:", addr_str);
+  emfd_ = grpc_fd_create(fd, name.c_str(), true);
   memcpy(&addr_, addr, sizeof(grpc_resolved_address));
   GPR_ASSERT(emfd_);
-  gpr_free(name);
   gpr_mu_init(&mutex_);
 }
 
@@ -177,7 +178,7 @@ struct grpc_udp_server {
   int shutdown;
 
   /* An array of listeners */
-  grpc_core::InlinedVector<GrpcUdpListener, 16> listeners;
+  absl::InlinedVector<GrpcUdpListener, 16> listeners;
 
   /* factory for use to create udp listeners */
   GrpcUdpHandlerFactory* handler_factory;
@@ -185,10 +186,9 @@ struct grpc_udp_server {
   /* shutdown callback */
   grpc_closure* shutdown_complete;
 
-  /* all pollsets interested in new connections */
-  grpc_pollset** pollsets;
-  /* number of pollsets in the pollsets array */
-  size_t pollset_count;
+  /* all pollsets interested in new connections. The object pointed at is not
+   * owned by this struct. */
+  const std::vector<grpc_pollset*>* pollsets;
   /* opaque object to pass to callbacks */
   void* user_data;
 
@@ -282,7 +282,7 @@ static void deactivated_all_ports(grpc_udp_server* s) {
 
   GPR_ASSERT(s->shutdown);
 
-  if (s->listeners.size() == 0) {
+  if (s->listeners.empty()) {
     gpr_mu_unlock(&s->mu);
     finish_shutdown(s);
     return;
@@ -412,10 +412,8 @@ static int prepare_socket(grpc_socket_factory* socket_factory, int fd,
   }
 
   if (bind_socket(socket_factory, fd, addr) < 0) {
-    char* addr_str;
-    grpc_sockaddr_to_string(&addr_str, addr, 0);
-    gpr_log(GPR_ERROR, "bind addr=%s: %s", addr_str, strerror(errno));
-    gpr_free(addr_str);
+    std::string addr_str = grpc_sockaddr_to_string(addr, false);
+    gpr_log(GPR_ERROR, "bind addr=%s: %s", addr_str.c_str(), strerror(errno));
     goto error;
   }
 
@@ -582,10 +580,8 @@ int grpc_udp_server_add_port(grpc_udp_server* s,
             "Try to have multiple listeners on same port, but SO_REUSEPORT is "
             "not supported. Only create 1 listener.");
   }
-  char* addr_str;
-  grpc_sockaddr_to_string(&addr_str, addr, 1);
-  gpr_log(GPR_DEBUG, "add address: %s to server", addr_str);
-  gpr_free(addr_str);
+  std::string addr_str = grpc_sockaddr_to_string(addr, true);
+  gpr_log(GPR_DEBUG, "add address: %s to server", addr_str.c_str());
 
   int allocated_port1 = -1;
   int allocated_port2 = -1;
@@ -705,29 +701,29 @@ int grpc_udp_server_get_fd(grpc_udp_server* s, unsigned port_index) {
   return s->listeners[port_index].fd();
 }
 
-void grpc_udp_server_start(grpc_udp_server* s, grpc_pollset** pollsets,
-                           size_t pollset_count, void* user_data) {
+void grpc_udp_server_start(grpc_udp_server* udp_server,
+                           const std::vector<grpc_pollset*>* pollsets,
+                           void* user_data) {
   gpr_log(GPR_DEBUG, "grpc_udp_server_start");
-  gpr_mu_lock(&s->mu);
-  GPR_ASSERT(s->active_ports == 0);
-  s->pollsets = pollsets;
-  s->user_data = user_data;
+  gpr_mu_lock(&udp_server->mu);
+  GPR_ASSERT(udp_server->active_ports == 0);
+  udp_server->pollsets = pollsets;
+  udp_server->user_data = user_data;
 
-  for (size_t i = 0; i < s->listeners.size(); ++i) {
-    s->listeners[i].StartListening(pollsets, pollset_count, s->handler_factory);
+  for (auto& listener : udp_server->listeners) {
+    listener.StartListening(pollsets, udp_server->handler_factory);
   }
 
-  gpr_mu_unlock(&s->mu);
+  gpr_mu_unlock(&udp_server->mu);
 }
 
-void GrpcUdpListener::StartListening(grpc_pollset** pollsets,
-                                     size_t pollset_count,
+void GrpcUdpListener::StartListening(const std::vector<grpc_pollset*>* pollsets,
                                      GrpcUdpHandlerFactory* handler_factory) {
   gpr_mu_lock(&mutex_);
   handler_factory_ = handler_factory;
   udp_handler_ = handler_factory->CreateUdpHandler(emfd_, server_->user_data);
-  for (size_t i = 0; i < pollset_count; i++) {
-    grpc_pollset_add_fd(pollsets[i], emfd_);
+  for (grpc_pollset* pollset : *pollsets) {
+    grpc_pollset_add_fd(pollset, emfd_);
   }
   GRPC_CLOSURE_INIT(&read_closure_, on_read, this, grpc_schedule_on_exec_ctx);
   grpc_fd_notify_on_read(emfd_, &read_closure_);