grpc 1.28.0 → 1.30.2

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

@@ -41,16 +41,14 @@
 
 #define GRPC_MAX_SOCKADDR_SIZE 128
 
-typedef struct {
+struct grpc_resolved_address {
   char addr[GRPC_MAX_SOCKADDR_SIZE];
   socklen_t len;
-} grpc_resolved_address;
-
-typedef struct {
+};
+struct grpc_resolved_addresses {
   size_t naddrs;
   grpc_resolved_address* addrs;
-} grpc_resolved_addresses;
-
+};
 typedef struct grpc_address_resolver_vtable {
   void (*resolve_address)(const char* addr, const char* default_port,
                           grpc_pollset_set* interested_parties,

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

@@ -34,12 +34,12 @@
 
 #include <string.h>
 
-typedef struct grpc_custom_resolver {
-  grpc_closure* on_done;
-  grpc_resolved_addresses** addresses;
-  char* host;
-  char* port;
-} grpc_custom_resolver;
+struct grpc_custom_resolver {
+  grpc_closure* on_done = nullptr;
+  grpc_resolved_addresses** addresses = nullptr;
+  std::string host;
+  std::string port;
+};
 
 static grpc_custom_resolver_vtable* resolve_address_vtable = nullptr;
 
@@ -48,18 +48,18 @@ static int retry_named_port_failure(grpc_custom_resolver* r,
   // This loop is copied from resolve_address_posix.c
   const char* svc[][2] = {{"http", "80"}, {"https", "443"}};
   for (size_t i = 0; i < GPR_ARRAY_SIZE(svc); i++) {
-    if (strcmp(r->port, svc[i][0]) == 0) {
-      gpr_free(r->port);
-      r->port = gpr_strdup(svc[i][1]);
+    if (r->port == svc[i][0]) {
+      r->port = svc[i][1];
       if (res) {
-        grpc_error* error =
-            resolve_address_vtable->resolve(r->host, r->port, res);
+        grpc_error* error = resolve_address_vtable->resolve(
+            r->host.c_str(), r->port.c_str(), res);
         if (error != GRPC_ERROR_NONE) {
           GRPC_ERROR_UNREF(error);
           return 0;
         }
       } else {
-        resolve_address_vtable->resolve_async(r, r->host, r->port);
+        resolve_address_vtable->resolve_async(r, r->host.c_str(),
+                                              r->port.c_str());
       }
       return 1;
     }
@@ -81,26 +81,23 @@ void grpc_custom_resolve_callback(grpc_custom_resolver* r,
   if (r->on_done) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
   }
-  gpr_free(r->host);
-  gpr_free(r->port);
-  gpr_free(r);
+  delete r;
 }
 
 static grpc_error* try_split_host_port(const char* name,
                                        const char* default_port,
-                                       grpc_core::UniquePtr<char>* host,
-                                       grpc_core::UniquePtr<char>* port) {
+                                       std::string* host, std::string* port) {
   /* parse name, splitting it into host and port parts */
   grpc_error* error;
   grpc_core::SplitHostPort(name, host, port);
-  if (*host == nullptr) {
+  if (host->empty()) {
     char* msg;
     gpr_asprintf(&msg, "unparseable host:port: '%s'", name);
     error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
     gpr_free(msg);
     return error;
   }
-  if (*port == nullptr) {
+  if (port->empty()) {
     // TODO(murgatroid99): add tests for this case
     if (default_port == nullptr) {
       char* msg;
@@ -109,7 +106,7 @@ static grpc_error* try_split_host_port(const char* name,
       gpr_free(msg);
       return error;
     }
-    port->reset(gpr_strdup(default_port));
+    *port = default_port;
   }
   return GRPC_ERROR_NONE;
 }
@@ -117,26 +114,21 @@ static grpc_error* try_split_host_port(const char* name,
 static grpc_error* blocking_resolve_address_impl(
     const char* name, const char* default_port,
     grpc_resolved_addresses** addresses) {
-  grpc_core::UniquePtr<char> host;
-  grpc_core::UniquePtr<char> port;
-  grpc_error* err;
-
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
 
-  err = try_split_host_port(name, default_port, &host, &port);
+  grpc_custom_resolver resolver;
+  grpc_error* err =
+      try_split_host_port(name, default_port, &resolver.host, &resolver.port);
   if (err != GRPC_ERROR_NONE) {
     return err;
   }
 
   /* Call getaddrinfo */
-  grpc_custom_resolver resolver;
-  resolver.host = host.get();
-  resolver.port = port.get();
-
   grpc_resolved_addresses* addrs;
   grpc_core::ExecCtx* curr = grpc_core::ExecCtx::Get();
   grpc_core::ExecCtx::Set(nullptr);
-  err = resolve_address_vtable->resolve(host.get(), port.get(), &addrs);
+  err = resolve_address_vtable->resolve(resolver.host.c_str(),
+                                        resolver.port.c_str(), &addrs);
   if (err != GRPC_ERROR_NONE) {
     if (retry_named_port_failure(&resolver, &addrs)) {
       GRPC_ERROR_UNREF(err);
@@ -154,24 +146,22 @@ static void resolve_address_impl(const char* name, const char* default_port,
                                  grpc_pollset_set* /*interested_parties*/,
                                  grpc_closure* on_done,
                                  grpc_resolved_addresses** addrs) {
-  grpc_custom_resolver* r = nullptr;
-  grpc_core::UniquePtr<char> host;
-  grpc_core::UniquePtr<char> port;
-  grpc_error* err;
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
-  err = try_split_host_port(name, default_port, &host, &port);
+  std::string host;
+  std::string port;
+  grpc_error* err = try_split_host_port(name, default_port, &host, &port);
   if (err != GRPC_ERROR_NONE) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_done, err);
     return;
   }
-  r = (grpc_custom_resolver*)gpr_malloc(sizeof(grpc_custom_resolver));
+  grpc_custom_resolver* r = new grpc_custom_resolver();
   r->on_done = on_done;
   r->addresses = addrs;
-  r->host = host.release();
-  r->port = port.release();
+  r->host = std::move(host);
+  r->port = std::move(port);
 
   /* Call getaddrinfo */
-  resolve_address_vtable->resolve_async(r, r->host, r->port);
+  resolve_address_vtable->resolve_async(r, r->host.c_str(), r->port.c_str());
 }
 
 static grpc_address_resolver_vtable custom_resolver_vtable = {

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

@@ -29,8 +29,10 @@
 typedef struct grpc_custom_resolver grpc_custom_resolver;
 
 typedef struct grpc_custom_resolver_vtable {
-  grpc_error* (*resolve)(char* host, char* port, grpc_resolved_addresses** res);
-  void (*resolve_async)(grpc_custom_resolver* resolver, char* host, char* port);
+  grpc_error* (*resolve)(const char* host, const char* port,
+                         grpc_resolved_addresses** res);
+  void (*resolve_async)(grpc_custom_resolver* resolver, const char* host,
+                        const char* port);
 } grpc_custom_resolver_vtable;
 
 void grpc_custom_resolve_callback(grpc_custom_resolver* resolver,

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

@@ -57,24 +57,24 @@ static grpc_error* posix_blocking_resolve_address(
     return grpc_resolve_unix_domain_address(name + 5, addresses);
   }
 
-  grpc_core::UniquePtr<char> host;
-  grpc_core::UniquePtr<char> port;
+  std::string host;
+  std::string port;
   /* parse name, splitting it into host and port parts */
   grpc_core::SplitHostPort(name, &host, &port);
-  if (host == nullptr) {
+  if (host.empty()) {
     err = grpc_error_set_str(
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("unparseable host:port"),
         GRPC_ERROR_STR_TARGET_ADDRESS, grpc_slice_from_copied_string(name));
     goto done;
   }
-  if (port == nullptr) {
+  if (port.empty()) {
     if (default_port == nullptr) {
       err = grpc_error_set_str(
           GRPC_ERROR_CREATE_FROM_STATIC_STRING("no port in name"),
           GRPC_ERROR_STR_TARGET_ADDRESS, grpc_slice_from_copied_string(name));
       goto done;
     }
-    port.reset(gpr_strdup(default_port));
+    port = default_port;
   }
 
   /* Call getaddrinfo */
@@ -84,16 +84,16 @@ static grpc_error* posix_blocking_resolve_address(
   hints.ai_flags = AI_PASSIVE;     /* for wildcard IP address */
 
   GRPC_SCHEDULING_START_BLOCKING_REGION;
-  s = getaddrinfo(host.get(), port.get(), &hints, &result);
+  s = getaddrinfo(host.c_str(), port.c_str(), &hints, &result);
   GRPC_SCHEDULING_END_BLOCKING_REGION;
 
   if (s != 0) {
     /* Retry if well-known service name is recognized */
     const char* svc[][2] = {{"http", "80"}, {"https", "443"}};
     for (i = 0; i < GPR_ARRAY_SIZE(svc); i++) {
-      if (strcmp(port.get(), svc[i][0]) == 0) {
+      if (port == svc[i][0]) {
         GRPC_SCHEDULING_START_BLOCKING_REGION;
-        s = getaddrinfo(host.get(), svc[i][1], &hints, &result);
+        s = getaddrinfo(host.c_str(), svc[i][1], &hints, &result);
         GRPC_SCHEDULING_END_BLOCKING_REGION;
         break;
       }
@@ -139,15 +139,14 @@ done:
   return err;
 }
 
-typedef struct {
+struct request {
   char* name;
   char* default_port;
   grpc_closure* on_done;
   grpc_resolved_addresses** addrs_out;
   grpc_closure request_closure;
   void* arg;
-} request;
-
+};
 /* Callback to be passed to grpc Executor to asynch-ify
  * grpc_blocking_resolve_address */
 static void do_request_thread(void* rp, grpc_error* /*error*/) {

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

@@ -43,14 +43,13 @@
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 
-typedef struct {
+struct request {
   char* name;
   char* default_port;
   grpc_closure request_closure;
   grpc_closure* on_done;
   grpc_resolved_addresses** addresses;
-} request;
-
+};
 static grpc_error* windows_blocking_resolve_address(
     const char* name, const char* default_port,
     grpc_resolved_addresses** addresses) {
@@ -62,17 +61,17 @@ static grpc_error* windows_blocking_resolve_address(
   grpc_error* error = GRPC_ERROR_NONE;
 
   /* parse name, splitting it into host and port parts */
-  grpc_core::UniquePtr<char> host;
-  grpc_core::UniquePtr<char> port;
+  std::string host;
+  std::string port;
   grpc_core::SplitHostPort(name, &host, &port);
-  if (host == NULL) {
+  if (host.empty()) {
     char* msg;
     gpr_asprintf(&msg, "unparseable host:port: '%s'", name);
     error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
     gpr_free(msg);
     goto done;
   }
-  if (port == NULL) {
+  if (port.empty()) {
     if (default_port == NULL) {
       char* msg;
       gpr_asprintf(&msg, "no port in name '%s'", name);
@@ -80,7 +79,7 @@ static grpc_error* windows_blocking_resolve_address(
       gpr_free(msg);
       goto done;
     }
-    port.reset(gpr_strdup(default_port));
+    port = default_port;
   }
 
   /* Call getaddrinfo */
@@ -90,7 +89,7 @@ static grpc_error* windows_blocking_resolve_address(
   hints.ai_flags = AI_PASSIVE;     /* for wildcard IP address */
 
   GRPC_SCHEDULING_START_BLOCKING_REGION;
-  s = getaddrinfo(host.get(), port.get(), &hints, &result);
+  s = getaddrinfo(host.c_str(), port.c_str(), &hints, &result);
   GRPC_SCHEDULING_END_BLOCKING_REGION;
   if (s != 0) {
     error = GRPC_WSA_ERROR(WSAGetLastError(), "getaddrinfo");
@@ -113,14 +112,6 @@ static grpc_error* windows_blocking_resolve_address(
     i++;
   }
 
-  {
-    for (i = 0; i < (*addresses)->naddrs; i++) {
-      char* buf;
-      grpc_sockaddr_to_string(&buf, &(*addresses)->addrs[i], 0);
-      gpr_free(buf);
-    }
-  }
-
 done:
   if (result) {
     freeaddrinfo(result);

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

@@ -39,11 +39,10 @@ grpc_core::TraceFlag grpc_resource_quota_trace(false, "resource_quota");
 #define MEMORY_USAGE_ESTIMATION_MAX 65536
 
 /* Internal linked list pointers for a resource user */
-typedef struct {
+struct grpc_resource_user_link {
   grpc_resource_user* next;
   grpc_resource_user* prev;
-} grpc_resource_user_link;
-
+};
 /* Resource users are kept in (potentially) several intrusive linked lists
    at once. These are the list names. */
 typedef enum {
@@ -610,12 +609,11 @@ static void ru_allocated_slices(void* arg, grpc_error* error) {
  * combiner
  */
 
-typedef struct {
+struct rq_resize_args {
   int64_t size;
   grpc_resource_quota* resource_quota;
   grpc_closure closure;
-} rq_resize_args;
-
+};
 static void rq_resize(void* args, grpc_error* /*error*/) {
   rq_resize_args* a = static_cast<rq_resize_args*>(args);
   int64_t delta = a->size - a->resource_quota->size;

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

@@ -24,6 +24,8 @@
 #include <inttypes.h>
 #include <string.h>
 
+#include "absl/strings/str_format.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -150,23 +152,18 @@ void grpc_sockaddr_make_wildcard6(int port,
   resolved_wild_out->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6));
 }
 
-int grpc_sockaddr_to_string(char** out,
-                            const grpc_resolved_address* resolved_addr,
-                            int normalize) {
-  const grpc_sockaddr* addr;
+std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
+                                    bool normalize) {
   const int save_errno = errno;
   grpc_resolved_address addr_normalized;
-  char ntop_buf[GRPC_INET6_ADDRSTRLEN];
-  const void* ip = nullptr;
-  int port = 0;
-  uint32_t sin6_scope_id = 0;
-  int ret;
-
-  *out = nullptr;
   if (normalize && grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
     resolved_addr = &addr_normalized;
   }
-  addr = reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+  const grpc_sockaddr* addr =
+      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+  const void* ip = nullptr;
+  int port = 0;
+  uint32_t sin6_scope_id = 0;
   if (addr->sa_family == GRPC_AF_INET) {
     const grpc_sockaddr_in* addr4 =
         reinterpret_cast<const grpc_sockaddr_in*>(addr);
@@ -179,25 +176,24 @@ int grpc_sockaddr_to_string(char** out,
     port = grpc_ntohs(addr6->sin6_port);
     sin6_scope_id = addr6->sin6_scope_id;
   }
+  char ntop_buf[GRPC_INET6_ADDRSTRLEN];
+  std::string out;
   if (ip != nullptr && grpc_inet_ntop(addr->sa_family, ip, ntop_buf,
                                       sizeof(ntop_buf)) != nullptr) {
-    grpc_core::UniquePtr<char> tmp_out;
     if (sin6_scope_id != 0) {
-      char* host_with_scope;
-      /* Enclose sin6_scope_id with the format defined in RFC 6784 section 2. */
-      gpr_asprintf(&host_with_scope, "%s%%25%" PRIu32, ntop_buf, sin6_scope_id);
-      ret = grpc_core::JoinHostPort(&tmp_out, host_with_scope, port);
-      gpr_free(host_with_scope);
+      // Enclose sin6_scope_id with the format defined in RFC 6784 section 2.
+      std::string host_with_scope =
+          absl::StrFormat("%s%%25%" PRIu32, ntop_buf, sin6_scope_id);
+      out = grpc_core::JoinHostPort(host_with_scope, port);
     } else {
-      ret = grpc_core::JoinHostPort(&tmp_out, ntop_buf, port);
+      out = grpc_core::JoinHostPort(ntop_buf, port);
     }
-    *out = tmp_out.release();
   } else {
-    ret = gpr_asprintf(out, "(sockaddr family=%d)", addr->sa_family);
+    out = absl::StrFormat("(sockaddr family=%d)", addr->sa_family);
   }
   /* This is probably redundant, but we wouldn't want to log the wrong error. */
   errno = save_errno;
-  return ret;
+  return out;
 }
 
 void grpc_string_to_sockaddr(grpc_resolved_address* out, char* addr, int port) {
@@ -226,15 +222,13 @@ char* grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
   if (scheme == nullptr || strcmp("unix", scheme) == 0) {
     return grpc_sockaddr_to_uri_unix_if_possible(resolved_addr);
   }
-  char* path = nullptr;
+  std::string path =
+      grpc_sockaddr_to_string(resolved_addr, false /* normalize */);
   char* uri_str = nullptr;
-  if (grpc_sockaddr_to_string(&path, resolved_addr,
-                              false /* suppress errors */) &&
-      scheme != nullptr) {
-    gpr_asprintf(&uri_str, "%s:%s", scheme, path);
+  if (scheme != nullptr) {
+    gpr_asprintf(&uri_str, "%s:%s", scheme, path.c_str());
   }
-  gpr_free(path);
-  return uri_str != nullptr ? uri_str : nullptr;
+  return uri_str;
 }
 
 const char* grpc_sockaddr_get_uri_scheme(

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

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string>
+
 #include "src/core/lib/iomgr/resolve_address.h"
 
 /* Returns true if addr is an IPv4-mapped IPv6 address within the
@@ -56,20 +58,13 @@ int grpc_sockaddr_get_port(const grpc_resolved_address* addr);
 /* Set IP port number of a sockaddr */
 int grpc_sockaddr_set_port(const grpc_resolved_address* addr, int port);
 
-/* Converts a sockaddr into a newly-allocated human-readable string.
-
-   Currently, only the AF_INET and AF_INET6 families are recognized.
-   If the normalize flag is enabled, ::ffff:0.0.0.0/96 IPv6 addresses are
-   displayed as plain IPv4.
-
-   Usage is similar to gpr_asprintf: returns the number of bytes written
-   (excluding the final '\0'), and *out points to a string which must later be
-   destroyed using gpr_free().
-
-   In the unlikely event of an error, returns -1 and sets *out to NULL.
-   The existing value of errno is always preserved. */
-int grpc_sockaddr_to_string(char** out, const grpc_resolved_address* addr,
-                            int normalize);
+// Converts a sockaddr into a newly-allocated human-readable string.
+//
+// Currently, only the AF_INET and AF_INET6 families are recognized.
+// If the normalize flag is enabled, ::ffff:0.0.0.0/96 IPv6 addresses are
+// displayed as plain IPv4.
+std::string grpc_sockaddr_to_string(const grpc_resolved_address* addr,
+                                    bool normalize);
 
 void grpc_string_to_sockaddr(grpc_resolved_address* out, char* addr, int port);