grpc 1.43.1 → 1.44.0.pre2

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

@@ -37,30 +37,89 @@
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolve_address_posix.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/transport/error_utils.h"
+
+namespace grpc_core {
+namespace {
+
+class NativeDNSRequest : public DNSResolver::Request {
+ public:
+  NativeDNSRequest(
+      absl::string_view name, absl::string_view default_port,
+      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+          on_done)
+      : name_(name), default_port_(default_port), on_done_(std::move(on_done)) {
+    GRPC_CLOSURE_INIT(&request_closure_, DoRequestThread, this, nullptr);
+  }
+
+  // Starts the resolution
+  void Start() override {
+    Ref().release();  // ref held by callback
+    Executor::Run(&request_closure_, GRPC_ERROR_NONE, ExecutorType::RESOLVER);
+  }
+
+  // This is a no-op for the native resolver. Note
+  // that no I/O polling is required for the resolution to finish.
+  void Orphan() override { Unref(); }
+
+ private:
+  // Callback to be passed to grpc Executor to asynch-ify
+  // ResolveNameBlocking
+  static void DoRequestThread(void* rp, grpc_error_handle /*error*/) {
+    NativeDNSRequest* r = static_cast<NativeDNSRequest*>(rp);
+    auto result =
+        GetDNSResolver()->ResolveNameBlocking(r->name_, r->default_port_);
+    // running inline is safe since we've already been scheduled on the executor
+    r->on_done_(std::move(result));
+    r->Unref();
+  }
+
+  const std::string name_;
+  const std::string default_port_;
+  const std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+      on_done_;
+  grpc_closure request_closure_;
+};
 
-static grpc_error_handle posix_blocking_resolve_address(
-    const char* name, const char* default_port,
-    grpc_resolved_addresses** addresses) {
-  grpc_core::ExecCtx exec_ctx;
+}  // namespace
+
+NativeDNSResolver* NativeDNSResolver::GetOrCreate() {
+  static NativeDNSResolver* instance = new NativeDNSResolver();
+  return instance;
+}
+
+OrphanablePtr<DNSResolver::Request> NativeDNSResolver::ResolveName(
+    absl::string_view name, absl::string_view default_port,
+    grpc_pollset_set* /* interested_parties */,
+    std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+        on_done) {
+  return MakeOrphanable<NativeDNSRequest>(name, default_port,
+                                          std::move(on_done));
+}
+
+absl::StatusOr<std::vector<grpc_resolved_address>>
+NativeDNSResolver::ResolveNameBlocking(absl::string_view name,
+                                       absl::string_view default_port) {
+  ExecCtx exec_ctx;
   struct addrinfo hints;
   struct addrinfo *result = nullptr, *resp;
   int s;
   size_t i;
   grpc_error_handle err;
-
+  std::vector<grpc_resolved_address> addresses;
   std::string host;
   std::string port;
-  /* parse name, splitting it into host and port parts */
-  grpc_core::SplitHostPort(name, &host, &port);
+  // parse name, splitting it into host and port parts
+  SplitHostPort(name, &host, &port);
   if (host.empty()) {
     err = grpc_error_set_str(
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("unparseable host:port"),
         GRPC_ERROR_STR_TARGET_ADDRESS, name);
     goto done;
   }
-
   if (port.empty()) {
     if (default_port == nullptr) {
       err = grpc_error_set_str(
@@ -68,21 +127,18 @@ static grpc_error_handle posix_blocking_resolve_address(
           GRPC_ERROR_STR_TARGET_ADDRESS, name);
       goto done;
     }
-    port = default_port;
+    port = std::string(default_port);
   }
-
-  /* Call getaddrinfo */
+  // Call getaddrinfo
   memset(&hints, 0, sizeof(hints));
   hints.ai_family = AF_UNSPEC;     /* ipv4 or ipv6 */
   hints.ai_socktype = SOCK_STREAM; /* stream socket */
   hints.ai_flags = AI_PASSIVE;     /* for wildcard IP address */
-
   GRPC_SCHEDULING_START_BLOCKING_REGION;
   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 */
+    // 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 (port == svc[i][0]) {
@@ -93,7 +149,6 @@ static grpc_error_handle posix_blocking_resolve_address(
       }
     }
   }
-
   if (s != 0) {
     err = grpc_error_set_str(
         grpc_error_set_str(
@@ -106,65 +161,26 @@ static grpc_error_handle posix_blocking_resolve_address(
         GRPC_ERROR_STR_TARGET_ADDRESS, name);
     goto done;
   }
-
-  /* Success path: set addrs non-NULL, fill it in */
-  *addresses = static_cast<grpc_resolved_addresses*>(
-      gpr_malloc(sizeof(grpc_resolved_addresses)));
-  (*addresses)->naddrs = 0;
-  for (resp = result; resp != nullptr; resp = resp->ai_next) {
-    (*addresses)->naddrs++;
-  }
-  (*addresses)->addrs = static_cast<grpc_resolved_address*>(
-      gpr_malloc(sizeof(grpc_resolved_address) * (*addresses)->naddrs));
-  i = 0;
+  // Success path: fill in addrs
   for (resp = result; resp != nullptr; resp = resp->ai_next) {
-    memcpy(&(*addresses)->addrs[i].addr, resp->ai_addr, resp->ai_addrlen);
-    (*addresses)->addrs[i].len = resp->ai_addrlen;
-    i++;
+    grpc_resolved_address addr;
+    memcpy(&addr.addr, resp->ai_addr, resp->ai_addrlen);
+    addr.len = resp->ai_addrlen;
+    addresses.push_back(addr);
   }
   err = GRPC_ERROR_NONE;
-
 done:
   if (result) {
     freeaddrinfo(result);
   }
-  return err;
-}
-
-struct request {
-  char* name;
-  char* default_port;
-  grpc_closure* on_done;
-  grpc_resolved_addresses** addrs_out;
-  grpc_closure request_closure;
-  void* arg;
-};
-/* Callback to be passed to grpc Executor to asynch-ify
- * grpc_blocking_resolve_address */
-static void do_request_thread(void* rp, grpc_error_handle /*error*/) {
-  request* r = static_cast<request*>(rp);
-  grpc_core::ExecCtx::Run(
-      DEBUG_LOCATION, r->on_done,
-      grpc_blocking_resolve_address(r->name, r->default_port, r->addrs_out));
-  gpr_free(r->name);
-  gpr_free(r->default_port);
-  gpr_free(r);
+  if (err == GRPC_ERROR_NONE) {
+    return addresses;
+  }
+  auto error_result = grpc_error_to_absl_status(err);
+  GRPC_ERROR_UNREF(err);
+  return error_result;
 }
 
-static void posix_resolve_address(const char* name, const char* default_port,
-                                  grpc_pollset_set* /*interested_parties*/,
-                                  grpc_closure* on_done,
-                                  grpc_resolved_addresses** addrs) {
-  request* r = static_cast<request*>(gpr_malloc(sizeof(request)));
-  GRPC_CLOSURE_INIT(&r->request_closure, do_request_thread, r, nullptr);
-  r->name = gpr_strdup(name);
-  r->default_port = gpr_strdup(default_port);
-  r->on_done = on_done;
-  r->addrs_out = addrs;
-  grpc_core::Executor::Run(&r->request_closure, GRPC_ERROR_NONE,
-                           grpc_core::ExecutorType::RESOLVER);
-}
+}  // namespace grpc_core
 
-grpc_address_resolver_vtable grpc_posix_resolver_vtable = {
-    posix_resolve_address, posix_blocking_resolve_address};
 #endif

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

@@ -0,0 +1,47 @@
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_POSIX_H
+#define GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_POSIX_H
+
+#include <grpc/support/port_platform.h>
+
+#include <functional>
+
+#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+
+namespace grpc_core {
+
+// A DNS resolver which uses the native platform's getaddrinfo API.
+class NativeDNSResolver : public DNSResolver {
+ public:
+  // Gets the singleton instance, creating it first if it doesn't exist
+  static NativeDNSResolver* GetOrCreate();
+
+  OrphanablePtr<DNSResolver::Request> ResolveName(
+      absl::string_view name, absl::string_view default_port,
+      grpc_pollset_set* interested_parties,
+      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+          on_done) override;
+
+  absl::StatusOr<std::vector<grpc_resolved_address>> ResolveNameBlocking(
+      absl::string_view name, absl::string_view default_port) override;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_POSIX_H

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

@@ -1,20 +1,18 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -43,29 +41,83 @@
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolve_address_windows.h"
 #include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/transport/error_utils.h"
+
+namespace grpc_core {
+namespace {
+
+class NativeDNSRequest : public DNSResolver::Request {
+ public:
+  NativeDNSRequest(
+      absl::string_view name, absl::string_view default_port,
+      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+          on_done)
+      : name_(name), default_port_(default_port), on_done_(std::move(on_done)) {
+    GRPC_CLOSURE_INIT(&request_closure_, DoRequestThread, this, nullptr);
+  }
+
+  // Starts the resolution
+  void Start() override {
+    Ref().release();  // ref held by callback
+    Executor::Run(&request_closure_, GRPC_ERROR_NONE, ExecutorType::RESOLVER);
+  }
+
+  // This is a no-op for the native resolver. Note
+  // that no I/O polling is required for the resolution to finish.
+  void Orphan() override { Unref(); }
+
+ private:
+  // Callback to be passed to grpc Executor to asynch-ify
+  // ResolveNameBlocking
+  static void DoRequestThread(void* rp, grpc_error_handle /*error*/) {
+    NativeDNSRequest* r = static_cast<NativeDNSRequest*>(rp);
+    auto result =
+        GetDNSResolver()->ResolveNameBlocking(r->name_, r->default_port_);
+    // running inline is safe since we've already been scheduled on the executor
+    r->on_done_(std::move(result));
+    r->Unref();
+  }
 
-struct request {
-  char* name;
-  char* default_port;
-  grpc_closure request_closure;
-  grpc_closure* on_done;
-  grpc_resolved_addresses** addresses;
+  const std::string name_;
+  const std::string default_port_;
+  const std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+      on_done_;
+  grpc_closure request_closure_;
 };
-static grpc_error_handle windows_blocking_resolve_address(
-    const char* name, const char* default_port,
-    grpc_resolved_addresses** addresses) {
-  grpc_core::ExecCtx exec_ctx;
+
+}  // namespace
+
+NativeDNSResolver* NativeDNSResolver::GetOrCreate() {
+  static NativeDNSResolver* instance = new NativeDNSResolver();
+  return instance;
+}
+
+OrphanablePtr<DNSResolver::Request> NativeDNSResolver::ResolveName(
+    absl::string_view name, absl::string_view default_port,
+    grpc_pollset_set* /* interested_parties */,
+    std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+        on_done) {
+  return MakeOrphanable<NativeDNSRequest>(name, default_port,
+                                          std::move(on_done));
+}
+
+absl::StatusOr<std::vector<grpc_resolved_address>>
+NativeDNSResolver::ResolveNameBlocking(absl::string_view name,
+                                       absl::string_view default_port) {
+  ExecCtx exec_ctx;
   struct addrinfo hints;
   struct addrinfo *result = NULL, *resp;
   int s;
   size_t i;
   grpc_error_handle error = GRPC_ERROR_NONE;
+  std::vector<grpc_resolved_address> addresses;
 
-  /* parse name, splitting it into host and port parts */
+  // parse name, splitting it into host and port parts
   std::string host;
   std::string port;
-  grpc_core::SplitHostPort(name, &host, &port);
+  SplitHostPort(name, &host, &port);
   if (host.empty()) {
     error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
         absl::StrFormat("unparseable host:port: '%s'", name));
@@ -77,10 +129,10 @@ static grpc_error_handle windows_blocking_resolve_address(
           absl::StrFormat("no port in name '%s'", name));
       goto done;
     }
-    port = default_port;
+    port = std::string(default_port);
   }
 
-  /* Call getaddrinfo */
+  // Call getaddrinfo
   memset(&hints, 0, sizeof(hints));
   hints.ai_family = AF_UNSPEC;     /* ipv4 or ipv6 */
   hints.ai_socktype = SOCK_STREAM; /* stream socket */
@@ -94,59 +146,26 @@ static grpc_error_handle windows_blocking_resolve_address(
     goto done;
   }
 
-  /* Success path: set addrs non-NULL, fill it in */
-  (*addresses) =
-      (grpc_resolved_addresses*)gpr_malloc(sizeof(grpc_resolved_addresses));
-  (*addresses)->naddrs = 0;
-  for (resp = result; resp != NULL; resp = resp->ai_next) {
-    (*addresses)->naddrs++;
-  }
-  (*addresses)->addrs = (grpc_resolved_address*)gpr_malloc(
-      sizeof(grpc_resolved_address) * (*addresses)->naddrs);
-  i = 0;
+  // Success path: set addrs non-NULL, fill it in
   for (resp = result; resp != NULL; resp = resp->ai_next) {
-    memcpy(&(*addresses)->addrs[i].addr, resp->ai_addr, resp->ai_addrlen);
-    (*addresses)->addrs[i].len = resp->ai_addrlen;
-    i++;
+    grpc_resolved_address addr;
+    memcpy(&addr.addr, resp->ai_addr, resp->ai_addrlen);
+    addr.len = resp->ai_addrlen;
+    addresses.push_back(addr);
   }
 
 done:
   if (result) {
     freeaddrinfo(result);
   }
-  return error;
-}
-
-/* Callback to be passed to grpc_executor to asynch-ify
- * grpc_blocking_resolve_address */
-static void do_request_thread(void* rp, grpc_error_handle error) {
-  request* r = (request*)rp;
   if (error == GRPC_ERROR_NONE) {
-    error =
-        grpc_blocking_resolve_address(r->name, r->default_port, r->addresses);
-  } else {
-    GRPC_ERROR_REF(error);
+    return addresses;
   }
-  grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
-  gpr_free(r->name);
-  gpr_free(r->default_port);
-  gpr_free(r);
+  auto error_result = grpc_error_to_absl_status(error);
+  GRPC_ERROR_UNREF(error);
+  return error_result;
 }
 
-static void windows_resolve_address(const char* name, const char* default_port,
-                                    grpc_pollset_set* interested_parties,
-                                    grpc_closure* on_done,
-                                    grpc_resolved_addresses** addresses) {
-  request* r = (request*)gpr_malloc(sizeof(request));
-  GRPC_CLOSURE_INIT(&r->request_closure, do_request_thread, r, nullptr);
-  r->name = gpr_strdup(name);
-  r->default_port = gpr_strdup(default_port);
-  r->on_done = on_done;
-  r->addresses = addresses;
-  grpc_core::Executor::Run(&r->request_closure, GRPC_ERROR_NONE,
-                           grpc_core::ExecutorType::RESOLVER);
-}
+}  // namespace grpc_core
 
-grpc_address_resolver_vtable grpc_windows_resolver_vtable = {
-    windows_resolve_address, windows_blocking_resolve_address};
 #endif

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

@@ -0,0 +1,47 @@
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_WINDOWS_H
+#define GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_WINDOWS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <functional>
+
+#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+
+namespace grpc_core {
+
+// A DNS resolver which uses the native platform's getaddrinfo API.
+class NativeDNSResolver : public DNSResolver {
+ public:
+  // Gets the singleton instance, creating it first if it doesn't exist
+  static NativeDNSResolver* GetOrCreate();
+
+  OrphanablePtr<DNSResolver::Request> ResolveName(
+      absl::string_view name, absl::string_view default_port,
+      grpc_pollset_set* interested_parties,
+      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+          on_done) override;
+
+  absl::StatusOr<std::vector<grpc_resolved_address>> ResolveNameBlocking(
+      absl::string_view name, absl::string_view default_port) override;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_WINDOWS_H

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

@@ -0,0 +1,39 @@
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_CORE_LIB_IOMGR_RESOLVED_ADDRESS_H
+#define GRPC_CORE_LIB_IOMGR_RESOLVED_ADDRESS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_WINSOCK_SOCKET
+#include <ws2tcpip.h>
+#endif
+
+#if defined(GRPC_POSIX_SOCKET) || defined(GRPC_CFSTREAM)
+#include <sys/socket.h>
+#endif
+
+#define GRPC_MAX_SOCKADDR_SIZE 128
+
+struct grpc_resolved_address {
+  char addr[GRPC_MAX_SOCKADDR_SIZE];
+  socklen_t len;
+};
+
+#endif /* GRPC_CORE_LIB_IOMGR_RESOLVED_ADDRESS_H */

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

@@ -26,6 +26,7 @@
 #include <limits.h>
 #include <stdio.h>
 #include <string.h>
+#include <sys/socket.h>
 
 #include <string>
 

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

@@ -26,6 +26,7 @@
 #include <ifaddrs.h>
 #include <stddef.h>
 #include <string.h>
+#include <sys/socket.h>
 
 #include <string>
 

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

@@ -35,29 +35,35 @@
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/transport/error_utils.h"
 
 void grpc_create_socketpair_if_unix(int sv[2]) {
   GPR_ASSERT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
 }
 
-grpc_error_handle grpc_resolve_unix_domain_address(
-    absl::string_view name, grpc_resolved_addresses** addresses) {
-  *addresses = static_cast<grpc_resolved_addresses*>(
-      gpr_malloc(sizeof(grpc_resolved_addresses)));
-  (*addresses)->naddrs = 1;
-  (*addresses)->addrs = static_cast<grpc_resolved_address*>(
-      gpr_malloc(sizeof(grpc_resolved_address)));
-  return grpc_core::UnixSockaddrPopulate(name, (*addresses)->addrs);
+absl::StatusOr<std::vector<grpc_resolved_address>>
+grpc_resolve_unix_domain_address(absl::string_view name) {
+  grpc_resolved_address addr;
+  grpc_error_handle error = grpc_core::UnixSockaddrPopulate(name, &addr);
+  if (error == GRPC_ERROR_NONE) {
+    return std::vector<grpc_resolved_address>({addr});
+  }
+  auto result = grpc_error_to_absl_status(error);
+  GRPC_ERROR_UNREF(error);
+  return result;
 }
 
-grpc_error_handle grpc_resolve_unix_abstract_domain_address(
-    const absl::string_view name, grpc_resolved_addresses** addresses) {
-  *addresses = static_cast<grpc_resolved_addresses*>(
-      gpr_malloc(sizeof(grpc_resolved_addresses)));
-  (*addresses)->naddrs = 1;
-  (*addresses)->addrs = static_cast<grpc_resolved_address*>(
-      gpr_malloc(sizeof(grpc_resolved_address)));
-  return grpc_core::UnixAbstractSockaddrPopulate(name, (*addresses)->addrs);
+absl::StatusOr<std::vector<grpc_resolved_address>>
+grpc_resolve_unix_abstract_domain_address(const absl::string_view name) {
+  grpc_resolved_address addr;
+  grpc_error_handle error =
+      grpc_core::UnixAbstractSockaddrPopulate(name, &addr);
+  if (error == GRPC_ERROR_NONE) {
+    return std::vector<grpc_resolved_address>({addr});
+  }
+  auto result = grpc_error_to_absl_status(error);
+  GRPC_ERROR_UNREF(error);
+  return result;
 }
 
 int grpc_is_unix_socket(const grpc_resolved_address* resolved_addr) {
@@ -87,22 +93,4 @@ void grpc_unlink_if_unix_domain_socket(
   }
 }
 
-std::string grpc_sockaddr_to_uri_unix_if_possible(
-    const grpc_resolved_address* resolved_addr) {
-  const grpc_sockaddr* addr =
-      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
-  if (addr->sa_family != AF_UNIX) {
-    return "";
-  }
-  const auto* unix_addr = reinterpret_cast<const struct sockaddr_un*>(addr);
-  if (unix_addr->sun_path[0] == '\0' && unix_addr->sun_path[1] != '\0') {
-    return absl::StrCat(
-        "unix-abstract:",
-        absl::string_view(
-            unix_addr->sun_path + 1,
-            resolved_addr->len - sizeof(unix_addr->sun_family) - 1));
-  }
-  return absl::StrCat("unix:", unix_addr->sun_path);
-}
-
 #endif

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

@@ -32,18 +32,15 @@
 
 void grpc_create_socketpair_if_unix(int sv[2]);
 
-grpc_error_handle grpc_resolve_unix_domain_address(
-    absl::string_view name, grpc_resolved_addresses** addresses);
+absl::StatusOr<std::vector<grpc_resolved_address>>
+grpc_resolve_unix_domain_address(absl::string_view name);
 
-grpc_error_handle grpc_resolve_unix_abstract_domain_address(
-    absl::string_view name, grpc_resolved_addresses** addresses);
+absl::StatusOr<std::vector<grpc_resolved_address>>
+grpc_resolve_unix_abstract_domain_address(absl::string_view name);
 
 int grpc_is_unix_socket(const grpc_resolved_address* resolved_addr);
 
 void grpc_unlink_if_unix_domain_socket(
     const grpc_resolved_address* resolved_addr);
 
-std::string grpc_sockaddr_to_uri_unix_if_possible(
-    const grpc_resolved_address* resolved_addr);
-
 #endif /* GRPC_CORE_LIB_IOMGR_UNIX_SOCKETS_POSIX_H */