grpc 1.7.3 → 1.8.0

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

@@ -24,6 +24,10 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /** \file Tracks resource usage against a pool.
 
     The current implementation tracks only memory usage, but in the future
@@ -61,60 +65,60 @@
     maintain lists of users (which users arrange to leave before they are
     destroyed) */
 
-extern grpc_tracer_flag grpc_resource_quota_trace;
+extern grpc_core::TraceFlag grpc_resource_quota_trace;
 
-grpc_resource_quota *grpc_resource_quota_ref_internal(
-    grpc_resource_quota *resource_quota);
-void grpc_resource_quota_unref_internal(grpc_exec_ctx *exec_ctx,
-                                        grpc_resource_quota *resource_quota);
-grpc_resource_quota *grpc_resource_quota_from_channel_args(
-    const grpc_channel_args *channel_args);
+grpc_resource_quota* grpc_resource_quota_ref_internal(
+    grpc_resource_quota* resource_quota);
+void grpc_resource_quota_unref_internal(grpc_exec_ctx* exec_ctx,
+                                        grpc_resource_quota* resource_quota);
+grpc_resource_quota* grpc_resource_quota_from_channel_args(
+    const grpc_channel_args* channel_args);
 
 /* Return a number indicating current memory pressure:
    0.0 ==> no memory usage
    1.0 ==> maximum memory usage */
 double grpc_resource_quota_get_memory_pressure(
-    grpc_resource_quota *resource_quota);
+    grpc_resource_quota* resource_quota);
 
-size_t grpc_resource_quota_peek_size(grpc_resource_quota *resource_quota);
+size_t grpc_resource_quota_peek_size(grpc_resource_quota* resource_quota);
 
 typedef struct grpc_resource_user grpc_resource_user;
 
-grpc_resource_user *grpc_resource_user_create(
-    grpc_resource_quota *resource_quota, const char *name);
+grpc_resource_user* grpc_resource_user_create(
+    grpc_resource_quota* resource_quota, const char* name);
 
 /* Returns a borrowed reference to the underlying resource quota for this
    resource user. */
-grpc_resource_quota *grpc_resource_user_quota(
-    grpc_resource_user *resource_user);
+grpc_resource_quota* grpc_resource_user_quota(
+    grpc_resource_user* resource_user);
 
-void grpc_resource_user_ref(grpc_resource_user *resource_user);
-void grpc_resource_user_unref(grpc_exec_ctx *exec_ctx,
-                              grpc_resource_user *resource_user);
-void grpc_resource_user_shutdown(grpc_exec_ctx *exec_ctx,
-                                 grpc_resource_user *resource_user);
+void grpc_resource_user_ref(grpc_resource_user* resource_user);
+void grpc_resource_user_unref(grpc_exec_ctx* exec_ctx,
+                              grpc_resource_user* resource_user);
+void grpc_resource_user_shutdown(grpc_exec_ctx* exec_ctx,
+                                 grpc_resource_user* resource_user);
 
 /* Allocate from the resource user (and its quota).
    If optional_on_done is NULL, then allocate immediately. This may push the
    quota over-limit, at which point reclamation will kick in.
    If optional_on_done is non-NULL, it will be scheduled when the allocation has
    been granted by the quota. */
-void grpc_resource_user_alloc(grpc_exec_ctx *exec_ctx,
-                              grpc_resource_user *resource_user, size_t size,
-                              grpc_closure *optional_on_done);
+void grpc_resource_user_alloc(grpc_exec_ctx* exec_ctx,
+                              grpc_resource_user* resource_user, size_t size,
+                              grpc_closure* optional_on_done);
 /* Release memory back to the quota */
-void grpc_resource_user_free(grpc_exec_ctx *exec_ctx,
-                             grpc_resource_user *resource_user, size_t size);
+void grpc_resource_user_free(grpc_exec_ctx* exec_ctx,
+                             grpc_resource_user* resource_user, size_t size);
 /* Post a memory reclaimer to the resource user. Only one benign and one
    destructive reclaimer can be posted at once. When executed, the reclaimer
    MUST call grpc_resource_user_finish_reclamation before it completes, to
    return control to the resource quota. */
-void grpc_resource_user_post_reclaimer(grpc_exec_ctx *exec_ctx,
-                                       grpc_resource_user *resource_user,
-                                       bool destructive, grpc_closure *closure);
+void grpc_resource_user_post_reclaimer(grpc_exec_ctx* exec_ctx,
+                                       grpc_resource_user* resource_user,
+                                       bool destructive, grpc_closure* closure);
 /* Finish a reclamation step */
-void grpc_resource_user_finish_reclamation(grpc_exec_ctx *exec_ctx,
-                                           grpc_resource_user *resource_user);
+void grpc_resource_user_finish_reclamation(grpc_exec_ctx* exec_ctx,
+                                           grpc_resource_user* resource_user);
 
 /* Helper to allocate slices from a resource user */
 typedef struct grpc_resource_user_slice_allocator {
@@ -127,27 +131,31 @@ typedef struct grpc_resource_user_slice_allocator {
   /* Number of slices to allocate on the current request */
   size_t count;
   /* Destination for slices to allocate on the current request */
-  grpc_slice_buffer *dest;
+  grpc_slice_buffer* dest;
   /* Parent resource user */
-  grpc_resource_user *resource_user;
+  grpc_resource_user* resource_user;
 } grpc_resource_user_slice_allocator;
 
 /* Initialize a slice allocator.
    When an allocation is completed, calls \a cb with arg \p. */
 void grpc_resource_user_slice_allocator_init(
-    grpc_resource_user_slice_allocator *slice_allocator,
-    grpc_resource_user *resource_user, grpc_iomgr_cb_func cb, void *p);
+    grpc_resource_user_slice_allocator* slice_allocator,
+    grpc_resource_user* resource_user, grpc_iomgr_cb_func cb, void* p);
 
 /* Allocate \a count slices of length \a length into \a dest. Only one request
    can be outstanding at a time. */
 void grpc_resource_user_alloc_slices(
-    grpc_exec_ctx *exec_ctx,
-    grpc_resource_user_slice_allocator *slice_allocator, size_t length,
-    size_t count, grpc_slice_buffer *dest);
+    grpc_exec_ctx* exec_ctx,
+    grpc_resource_user_slice_allocator* slice_allocator, size_t length,
+    size_t count, grpc_slice_buffer* dest);
 
 /* Allocate one slice of length \a size synchronously. */
-grpc_slice grpc_resource_user_slice_malloc(grpc_exec_ctx *exec_ctx,
-                                           grpc_resource_user *resource_user,
+grpc_slice grpc_resource_user_slice_malloc(grpc_exec_ctx* exec_ctx,
+                                           grpc_resource_user* resource_user,
                                            size_t size);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_IOMGR_RESOURCE_QUOTA_H */

data/src/core/lib/iomgr/{sockaddr_utils.c → sockaddr_utils.cc}

@@ -19,6 +19,7 @@
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 
 #include <errno.h>
+#include <inttypes.h>
 #include <string.h>
 
 #include <grpc/support/alloc.h>
@@ -35,19 +36,19 @@
 static const uint8_t kV4MappedPrefix[] = {0, 0, 0, 0, 0,    0,
                                           0, 0, 0, 0, 0xff, 0xff};
 
-int grpc_sockaddr_is_v4mapped(const grpc_resolved_address *resolved_addr,
-                              grpc_resolved_address *resolved_addr4_out) {
+int grpc_sockaddr_is_v4mapped(const grpc_resolved_address* resolved_addr,
+                              grpc_resolved_address* resolved_addr4_out) {
   GPR_ASSERT(resolved_addr != resolved_addr4_out);
-  const struct sockaddr *addr = (const struct sockaddr *)resolved_addr->addr;
-  struct sockaddr_in *addr4_out =
-      resolved_addr4_out == NULL
-          ? NULL
-          : (struct sockaddr_in *)resolved_addr4_out->addr;
+  const struct sockaddr* addr = (const struct sockaddr*)resolved_addr->addr;
+  struct sockaddr_in* addr4_out =
+      resolved_addr4_out == nullptr
+          ? nullptr
+          : (struct sockaddr_in*)resolved_addr4_out->addr;
   if (addr->sa_family == AF_INET6) {
-    const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6 *)addr;
+    const struct sockaddr_in6* addr6 = (const struct sockaddr_in6*)addr;
     if (memcmp(addr6->sin6_addr.s6_addr, kV4MappedPrefix,
                sizeof(kV4MappedPrefix)) == 0) {
-      if (resolved_addr4_out != NULL) {
+      if (resolved_addr4_out != nullptr) {
         /* Normalize ::ffff:0.0.0.0/96 to IPv4. */
         memset(resolved_addr4_out, 0, sizeof(*resolved_addr4_out));
         addr4_out->sin_family = AF_INET;
@@ -62,14 +63,14 @@ int grpc_sockaddr_is_v4mapped(const grpc_resolved_address *resolved_addr,
   return 0;
 }
 
-int grpc_sockaddr_to_v4mapped(const grpc_resolved_address *resolved_addr,
-                              grpc_resolved_address *resolved_addr6_out) {
+int grpc_sockaddr_to_v4mapped(const grpc_resolved_address* resolved_addr,
+                              grpc_resolved_address* resolved_addr6_out) {
   GPR_ASSERT(resolved_addr != resolved_addr6_out);
-  const struct sockaddr *addr = (const struct sockaddr *)resolved_addr->addr;
-  struct sockaddr_in6 *addr6_out =
-      (struct sockaddr_in6 *)resolved_addr6_out->addr;
+  const struct sockaddr* addr = (const struct sockaddr*)resolved_addr->addr;
+  struct sockaddr_in6* addr6_out =
+      (struct sockaddr_in6*)resolved_addr6_out->addr;
   if (addr->sa_family == AF_INET) {
-    const struct sockaddr_in *addr4 = (const struct sockaddr_in *)addr;
+    const struct sockaddr_in* addr4 = (const struct sockaddr_in*)addr;
     memset(resolved_addr6_out, 0, sizeof(*resolved_addr6_out));
     addr6_out->sin6_family = AF_INET6;
     memcpy(&addr6_out->sin6_addr.s6_addr[0], kV4MappedPrefix, 12);
@@ -81,17 +82,17 @@ int grpc_sockaddr_to_v4mapped(const grpc_resolved_address *resolved_addr,
   return 0;
 }
 
-int grpc_sockaddr_is_wildcard(const grpc_resolved_address *resolved_addr,
-                              int *port_out) {
-  const struct sockaddr *addr;
+int grpc_sockaddr_is_wildcard(const grpc_resolved_address* resolved_addr,
+                              int* port_out) {
+  const struct sockaddr* addr;
   grpc_resolved_address addr4_normalized;
   if (grpc_sockaddr_is_v4mapped(resolved_addr, &addr4_normalized)) {
     resolved_addr = &addr4_normalized;
   }
-  addr = (const struct sockaddr *)resolved_addr->addr;
+  addr = (const struct sockaddr*)resolved_addr->addr;
   if (addr->sa_family == AF_INET) {
     /* Check for 0.0.0.0 */
-    const struct sockaddr_in *addr4 = (const struct sockaddr_in *)addr;
+    const struct sockaddr_in* addr4 = (const struct sockaddr_in*)addr;
     if (addr4->sin_addr.s_addr != 0) {
       return 0;
     }
@@ -99,7 +100,7 @@ int grpc_sockaddr_is_wildcard(const grpc_resolved_address *resolved_addr,
     return 1;
   } else if (addr->sa_family == AF_INET6) {
     /* Check for :: */
-    const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6 *)addr;
+    const struct sockaddr_in6* addr6 = (const struct sockaddr_in6*)addr;
     int i;
     for (i = 0; i < 16; i++) {
       if (addr6->sin6_addr.s6_addr[i] != 0) {
@@ -113,15 +114,15 @@ int grpc_sockaddr_is_wildcard(const grpc_resolved_address *resolved_addr,
   }
 }
 
-void grpc_sockaddr_make_wildcards(int port, grpc_resolved_address *wild4_out,
-                                  grpc_resolved_address *wild6_out) {
+void grpc_sockaddr_make_wildcards(int port, grpc_resolved_address* wild4_out,
+                                  grpc_resolved_address* wild6_out) {
   grpc_sockaddr_make_wildcard4(port, wild4_out);
   grpc_sockaddr_make_wildcard6(port, wild6_out);
 }
 
 void grpc_sockaddr_make_wildcard4(int port,
-                                  grpc_resolved_address *resolved_wild_out) {
-  struct sockaddr_in *wild_out = (struct sockaddr_in *)resolved_wild_out->addr;
+                                  grpc_resolved_address* resolved_wild_out) {
+  struct sockaddr_in* wild_out = (struct sockaddr_in*)resolved_wild_out->addr;
   GPR_ASSERT(port >= 0 && port < 65536);
   memset(resolved_wild_out, 0, sizeof(*resolved_wild_out));
   wild_out->sin_family = AF_INET;
@@ -130,9 +131,8 @@ void grpc_sockaddr_make_wildcard4(int port,
 }
 
 void grpc_sockaddr_make_wildcard6(int port,
-                                  grpc_resolved_address *resolved_wild_out) {
-  struct sockaddr_in6 *wild_out =
-      (struct sockaddr_in6 *)resolved_wild_out->addr;
+                                  grpc_resolved_address* resolved_wild_out) {
+  struct sockaddr_in6* wild_out = (struct sockaddr_in6*)resolved_wild_out->addr;
   GPR_ASSERT(port >= 0 && port < 65536);
   memset(resolved_wild_out, 0, sizeof(*resolved_wild_out));
   wild_out->sin6_family = AF_INET6;
@@ -140,37 +140,37 @@ void grpc_sockaddr_make_wildcard6(int port,
   resolved_wild_out->len = sizeof(struct sockaddr_in6);
 }
 
-int grpc_sockaddr_to_string(char **out,
-                            const grpc_resolved_address *resolved_addr,
+int grpc_sockaddr_to_string(char** out,
+                            const grpc_resolved_address* resolved_addr,
                             int normalize) {
-  const struct sockaddr *addr;
+  const struct sockaddr* addr;
   const int save_errno = errno;
   grpc_resolved_address addr_normalized;
   char ntop_buf[INET6_ADDRSTRLEN];
-  const void *ip = NULL;
-  int port;
+  const void* ip = nullptr;
+  int port = 0;
   uint32_t sin6_scope_id = 0;
   int ret;
 
-  *out = NULL;
+  *out = nullptr;
   if (normalize && grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
     resolved_addr = &addr_normalized;
   }
-  addr = (const struct sockaddr *)resolved_addr->addr;
+  addr = (const struct sockaddr*)resolved_addr->addr;
   if (addr->sa_family == AF_INET) {
-    const struct sockaddr_in *addr4 = (const struct sockaddr_in *)addr;
+    const struct sockaddr_in* addr4 = (const struct sockaddr_in*)addr;
     ip = &addr4->sin_addr;
     port = ntohs(addr4->sin_port);
   } else if (addr->sa_family == AF_INET6) {
-    const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6 *)addr;
+    const struct sockaddr_in6* addr6 = (const struct sockaddr_in6*)addr;
     ip = &addr6->sin6_addr;
     port = ntohs(addr6->sin6_port);
     sin6_scope_id = addr6->sin6_scope_id;
   }
-  if (ip != NULL &&
-      grpc_inet_ntop(addr->sa_family, ip, ntop_buf, sizeof(ntop_buf)) != NULL) {
+  if (ip != nullptr && grpc_inet_ntop(addr->sa_family, ip, ntop_buf,
+                                      sizeof(ntop_buf)) != nullptr) {
     if (sin6_scope_id != 0) {
-      char *host_with_scope;
+      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 = gpr_join_host_port(out, host_with_scope, port);
@@ -186,29 +186,29 @@ int grpc_sockaddr_to_string(char **out,
   return ret;
 }
 
-char *grpc_sockaddr_to_uri(const grpc_resolved_address *resolved_addr) {
+char* grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
   grpc_resolved_address addr_normalized;
   if (grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
     resolved_addr = &addr_normalized;
   }
-  const char *scheme = grpc_sockaddr_get_uri_scheme(resolved_addr);
-  if (scheme == NULL || strcmp("unix", scheme) == 0) {
+  const char* scheme = grpc_sockaddr_get_uri_scheme(resolved_addr);
+  if (scheme == nullptr || strcmp("unix", scheme) == 0) {
     return grpc_sockaddr_to_uri_unix_if_possible(resolved_addr);
   }
-  char *path = NULL;
-  char *uri_str = NULL;
+  char* path = nullptr;
+  char* uri_str = nullptr;
   if (grpc_sockaddr_to_string(&path, resolved_addr,
                               false /* suppress errors */) &&
-      scheme != NULL) {
+      scheme != nullptr) {
     gpr_asprintf(&uri_str, "%s:%s", scheme, path);
   }
   gpr_free(path);
-  return uri_str != NULL ? uri_str : NULL;
+  return uri_str != nullptr ? uri_str : nullptr;
 }
 
-const char *grpc_sockaddr_get_uri_scheme(
-    const grpc_resolved_address *resolved_addr) {
-  const struct sockaddr *addr = (const struct sockaddr *)resolved_addr->addr;
+const char* grpc_sockaddr_get_uri_scheme(
+    const grpc_resolved_address* resolved_addr) {
+  const struct sockaddr* addr = (const struct sockaddr*)resolved_addr->addr;
   switch (addr->sa_family) {
     case AF_INET:
       return "ipv4";
@@ -217,21 +217,21 @@ const char *grpc_sockaddr_get_uri_scheme(
     case AF_UNIX:
       return "unix";
   }
-  return NULL;
+  return nullptr;
 }
 
-int grpc_sockaddr_get_family(const grpc_resolved_address *resolved_addr) {
-  const struct sockaddr *addr = (const struct sockaddr *)resolved_addr->addr;
+int grpc_sockaddr_get_family(const grpc_resolved_address* resolved_addr) {
+  const struct sockaddr* addr = (const struct sockaddr*)resolved_addr->addr;
   return addr->sa_family;
 }
 
-int grpc_sockaddr_get_port(const grpc_resolved_address *resolved_addr) {
-  const struct sockaddr *addr = (const struct sockaddr *)resolved_addr->addr;
+int grpc_sockaddr_get_port(const grpc_resolved_address* resolved_addr) {
+  const struct sockaddr* addr = (const struct sockaddr*)resolved_addr->addr;
   switch (addr->sa_family) {
     case AF_INET:
-      return ntohs(((struct sockaddr_in *)addr)->sin_port);
+      return ntohs(((struct sockaddr_in*)addr)->sin_port);
     case AF_INET6:
-      return ntohs(((struct sockaddr_in6 *)addr)->sin6_port);
+      return ntohs(((struct sockaddr_in6*)addr)->sin6_port);
     default:
       if (grpc_is_unix_socket(resolved_addr)) {
         return 1;
@@ -242,17 +242,17 @@ int grpc_sockaddr_get_port(const grpc_resolved_address *resolved_addr) {
   }
 }
 
-int grpc_sockaddr_set_port(const grpc_resolved_address *resolved_addr,
+int grpc_sockaddr_set_port(const grpc_resolved_address* resolved_addr,
                            int port) {
-  const struct sockaddr *addr = (const struct sockaddr *)resolved_addr->addr;
+  const struct sockaddr* addr = (const struct sockaddr*)resolved_addr->addr;
   switch (addr->sa_family) {
     case AF_INET:
       GPR_ASSERT(port >= 0 && port < 65536);
-      ((struct sockaddr_in *)addr)->sin_port = htons((uint16_t)port);
+      ((struct sockaddr_in*)addr)->sin_port = htons((uint16_t)port);
       return 1;
     case AF_INET6:
       GPR_ASSERT(port >= 0 && port < 65536);
-      ((struct sockaddr_in6 *)addr)->sin6_port = htons((uint16_t)port);
+      ((struct sockaddr_in6*)addr)->sin6_port = htons((uint16_t)port);
       return 1;
     default:
       gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_set_port",

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

@@ -21,38 +21,42 @@
 
 #include "src/core/lib/iomgr/resolve_address.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* Returns true if addr is an IPv4-mapped IPv6 address within the
    ::ffff:0.0.0.0/96 range, or false otherwise.
 
    If addr4_out is non-NULL, the inner IPv4 address will be copied here when
    returning true. */
-int grpc_sockaddr_is_v4mapped(const grpc_resolved_address *addr,
-                              grpc_resolved_address *addr4_out);
+int grpc_sockaddr_is_v4mapped(const grpc_resolved_address* addr,
+                              grpc_resolved_address* addr4_out);
 
 /* If addr is an AF_INET address, writes the corresponding ::ffff:0.0.0.0/96
    address to addr6_out and returns true.  Otherwise returns false. */
-int grpc_sockaddr_to_v4mapped(const grpc_resolved_address *addr,
-                              grpc_resolved_address *addr6_out);
+int grpc_sockaddr_to_v4mapped(const grpc_resolved_address* addr,
+                              grpc_resolved_address* addr6_out);
 
 /* If addr is ::, 0.0.0.0, or ::ffff:0.0.0.0, writes the port number to
  *port_out (if not NULL) and returns true, otherwise returns false. */
-int grpc_sockaddr_is_wildcard(const grpc_resolved_address *addr, int *port_out);
+int grpc_sockaddr_is_wildcard(const grpc_resolved_address* addr, int* port_out);
 
 /* Writes 0.0.0.0:port and [::]:port to separate sockaddrs. */
-void grpc_sockaddr_make_wildcards(int port, grpc_resolved_address *wild4_out,
-                                  grpc_resolved_address *wild6_out);
+void grpc_sockaddr_make_wildcards(int port, grpc_resolved_address* wild4_out,
+                                  grpc_resolved_address* wild6_out);
 
 /* Writes 0.0.0.0:port. */
-void grpc_sockaddr_make_wildcard4(int port, grpc_resolved_address *wild_out);
+void grpc_sockaddr_make_wildcard4(int port, grpc_resolved_address* wild_out);
 
 /* Writes [::]:port. */
-void grpc_sockaddr_make_wildcard6(int port, grpc_resolved_address *wild_out);
+void grpc_sockaddr_make_wildcard6(int port, grpc_resolved_address* wild_out);
 
 /* Return the IP port number of a sockaddr */
-int grpc_sockaddr_get_port(const grpc_resolved_address *addr);
+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);
+int grpc_sockaddr_set_port(const grpc_resolved_address* addr, int port);
 
 /* Converts a sockaddr into a newly-allocated human-readable string.
 
@@ -66,15 +70,19 @@ int grpc_sockaddr_set_port(const grpc_resolved_address *addr, int port);
 
    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 grpc_sockaddr_to_string(char** out, const grpc_resolved_address* addr,
                             int normalize);
 
 /* Returns the URI string corresponding to \a addr */
-char *grpc_sockaddr_to_uri(const grpc_resolved_address *addr);
+char* grpc_sockaddr_to_uri(const grpc_resolved_address* addr);
 
 /* Returns the URI scheme corresponding to \a addr */
-const char *grpc_sockaddr_get_uri_scheme(const grpc_resolved_address *addr);
+const char* grpc_sockaddr_get_uri_scheme(const grpc_resolved_address* addr);
+
+int grpc_sockaddr_get_family(const grpc_resolved_address* resolved_addr);
 
-int grpc_sockaddr_get_family(const grpc_resolved_address *resolved_addr);
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_IOMGR_SOCKADDR_UTILS_H */