grpc 1.7.3 → 1.8.0

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

@@ -24,25 +24,29 @@
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/tcp_server.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* one listening port */
 typedef struct grpc_tcp_listener {
   int fd;
-  grpc_fd *emfd;
-  grpc_tcp_server *server;
+  grpc_fd* emfd;
+  grpc_tcp_server* server;
   grpc_resolved_address addr;
   int port;
   unsigned port_index;
   unsigned fd_index;
   grpc_closure read_closure;
   grpc_closure destroyed_closure;
-  struct grpc_tcp_listener *next;
+  struct grpc_tcp_listener* next;
   /* sibling is a linked list of all listeners for a given port. add_port and
      clone_port place all new listeners in the same sibling list. A member of
      the 'sibling' list is also a member of the 'next' list. The head of each
      sibling list has is_sibling==0, and subsequent members of sibling lists
      have is_sibling==1. is_sibling allows separate sibling lists to be
      identified while iterating through 'next'. */
-  struct grpc_tcp_listener *sibling;
+  struct grpc_tcp_listener* sibling;
   int is_sibling;
 } grpc_tcp_listener;
 
@@ -51,7 +55,7 @@ struct grpc_tcp_server {
   gpr_refcount refs;
   /* Called whenever accept() succeeds on a server port. */
   grpc_tcp_server_cb on_accept_cb;
-  void *on_accept_cb_arg;
+  void* on_accept_cb_arg;
 
   gpr_mu mu;
 
@@ -70,18 +74,18 @@ struct grpc_tcp_server {
   bool expand_wildcard_addrs;
 
   /* linked list of server ports */
-  grpc_tcp_listener *head;
-  grpc_tcp_listener *tail;
+  grpc_tcp_listener* head;
+  grpc_tcp_listener* tail;
   unsigned nports;
 
   /* List of closures passed to shutdown_starting_add(). */
   grpc_closure_list shutdown_starting;
 
   /* shutdown callback */
-  grpc_closure *shutdown_complete;
+  grpc_closure* shutdown_complete;
 
   /* all pollsets interested in new connections */
-  grpc_pollset **pollsets;
+  grpc_pollset** pollsets;
   /* number of pollsets in the pollsets array */
   size_t pollset_count;
 
@@ -89,32 +93,36 @@ struct grpc_tcp_server {
   gpr_atm next_pollset_to_assign;
 
   /* channel args for this server */
-  grpc_channel_args *channel_args;
+  grpc_channel_args* channel_args;
 };
 
 /* If successful, add a listener to \a s for \a addr, set \a dsmode for the
    socket, and return the \a listener. */
-grpc_error *grpc_tcp_server_add_addr(grpc_tcp_server *s,
-                                     const grpc_resolved_address *addr,
+grpc_error* grpc_tcp_server_add_addr(grpc_tcp_server* s,
+                                     const grpc_resolved_address* addr,
                                      unsigned port_index, unsigned fd_index,
-                                     grpc_dualstack_mode *dsmode,
-                                     grpc_tcp_listener **listener);
+                                     grpc_dualstack_mode* dsmode,
+                                     grpc_tcp_listener** listener);
 
 /* Get all addresses assigned to network interfaces on the machine and create a
    listener for each. requested_port is the port to use for every listener, or 0
    to select one random port that will be used for every listener. Set *out_port
    to the port selected. Return GRPC_ERROR_NONE only if all listeners were
    added. */
-grpc_error *grpc_tcp_server_add_all_local_addrs(grpc_tcp_server *s,
+grpc_error* grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
                                                 unsigned port_index,
                                                 int requested_port,
-                                                int *out_port);
+                                                int* out_port);
 
 /* Prepare a recently-created socket for listening. */
-grpc_error *grpc_tcp_server_prepare_socket(int fd,
-                                           const grpc_resolved_address *addr,
-                                           bool so_reuseport, int *port);
+grpc_error* grpc_tcp_server_prepare_socket(int fd,
+                                           const grpc_resolved_address* addr,
+                                           bool so_reuseport, int* port);
 /* Ruturn true if the platform supports ifaddrs */
 bool grpc_tcp_server_have_ifaddrs(void);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_IOMGR_TCP_SERVER_UTILS_POSIX_H */

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

@@ -46,14 +46,14 @@ static int s_max_accept_queue_size;
 static void init_max_accept_queue_size(void) {
   int n = SOMAXCONN;
   char buf[64];
-  FILE *fp = fopen("/proc/sys/net/core/somaxconn", "r");
-  if (fp == NULL) {
+  FILE* fp = fopen("/proc/sys/net/core/somaxconn", "r");
+  if (fp == nullptr) {
     /* 2.4 kernel. */
     s_max_accept_queue_size = SOMAXCONN;
     return;
   }
   if (fgets(buf, sizeof buf, fp)) {
-    char *end;
+    char* end;
     long i = strtol(buf, &end, 10);
     if (i > 0 && i <= INT_MAX && end && *end == 0) {
       n = (int)i;
@@ -75,16 +75,16 @@ static int get_max_accept_queue_size(void) {
   return s_max_accept_queue_size;
 }
 
-static grpc_error *add_socket_to_server(grpc_tcp_server *s, int fd,
-                                        const grpc_resolved_address *addr,
+static grpc_error* add_socket_to_server(grpc_tcp_server* s, int fd,
+                                        const grpc_resolved_address* addr,
                                         unsigned port_index, unsigned fd_index,
-                                        grpc_tcp_listener **listener) {
-  grpc_tcp_listener *sp = NULL;
+                                        grpc_tcp_listener** listener) {
+  grpc_tcp_listener* sp = nullptr;
   int port = -1;
-  char *addr_str;
-  char *name;
+  char* addr_str;
+  char* name;
 
-  grpc_error *err =
+  grpc_error* err =
       grpc_tcp_server_prepare_socket(fd, addr, s->so_reuseport, &port);
   if (err == GRPC_ERROR_NONE) {
     GPR_ASSERT(port > 0);
@@ -93,9 +93,9 @@ static grpc_error *add_socket_to_server(grpc_tcp_server *s, int fd,
     gpr_mu_lock(&s->mu);
     s->nports++;
     GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server");
-    sp = (grpc_tcp_listener *)gpr_malloc(sizeof(grpc_tcp_listener));
-    sp->next = NULL;
-    if (s->head == NULL) {
+    sp = (grpc_tcp_listener*)gpr_malloc(sizeof(grpc_tcp_listener));
+    sp->next = nullptr;
+    if (s->head == nullptr) {
       s->head = sp;
     } else {
       s->tail->next = sp;
@@ -109,7 +109,7 @@ static grpc_error *add_socket_to_server(grpc_tcp_server *s, int fd,
     sp->port_index = port_index;
     sp->fd_index = fd_index;
     sp->is_sibling = 0;
-    sp->sibling = NULL;
+    sp->sibling = nullptr;
     GPR_ASSERT(sp->emfd);
     gpr_mu_unlock(&s->mu);
     gpr_free(addr_str);
@@ -122,14 +122,14 @@ static grpc_error *add_socket_to_server(grpc_tcp_server *s, int fd,
 
 /* If successful, add a listener to s for addr, set *dsmode for the socket, and
    return the *listener. */
-grpc_error *grpc_tcp_server_add_addr(grpc_tcp_server *s,
-                                     const grpc_resolved_address *addr,
+grpc_error* grpc_tcp_server_add_addr(grpc_tcp_server* s,
+                                     const grpc_resolved_address* addr,
                                      unsigned port_index, unsigned fd_index,
-                                     grpc_dualstack_mode *dsmode,
-                                     grpc_tcp_listener **listener) {
+                                     grpc_dualstack_mode* dsmode,
+                                     grpc_tcp_listener** listener) {
   grpc_resolved_address addr4_copy;
   int fd;
-  grpc_error *err =
+  grpc_error* err =
       grpc_create_dualstack_socket(addr, SOCK_STREAM, 0, dsmode, &fd);
   if (err != GRPC_ERROR_NONE) {
     return err;
@@ -142,11 +142,11 @@ grpc_error *grpc_tcp_server_add_addr(grpc_tcp_server *s,
 }
 
 /* Prepare a recently-created socket for listening. */
-grpc_error *grpc_tcp_server_prepare_socket(int fd,
-                                           const grpc_resolved_address *addr,
-                                           bool so_reuseport, int *port) {
+grpc_error* grpc_tcp_server_prepare_socket(int fd,
+                                           const grpc_resolved_address* addr,
+                                           bool so_reuseport, int* port) {
   grpc_resolved_address sockname_temp;
-  grpc_error *err = GRPC_ERROR_NONE;
+  grpc_error* err = GRPC_ERROR_NONE;
 
   GPR_ASSERT(fd >= 0);
 
@@ -169,7 +169,7 @@ grpc_error *grpc_tcp_server_prepare_socket(int fd,
   if (err != GRPC_ERROR_NONE) goto error;
 
   GPR_ASSERT(addr->len < ~(socklen_t)0);
-  if (bind(fd, (struct sockaddr *)addr->addr, (socklen_t)addr->len) < 0) {
+  if (bind(fd, (struct sockaddr*)addr->addr, (socklen_t)addr->len) < 0) {
     err = GRPC_OS_ERROR(errno, "bind");
     goto error;
   }
@@ -181,8 +181,8 @@ grpc_error *grpc_tcp_server_prepare_socket(int fd,
 
   sockname_temp.len = sizeof(struct sockaddr_storage);
 
-  if (getsockname(fd, (struct sockaddr *)sockname_temp.addr,
-                  (socklen_t *)&sockname_temp.len) < 0) {
+  if (getsockname(fd, (struct sockaddr*)sockname_temp.addr,
+                  (socklen_t*)&sockname_temp.len) < 0) {
     err = GRPC_OS_ERROR(errno, "getsockname");
     goto error;
   }
@@ -195,7 +195,7 @@ error:
   if (fd >= 0) {
     close(fd);
   }
-  grpc_error *ret =
+  grpc_error* ret =
       grpc_error_set_int(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                              "Unable to configure socket", &err, 1),
                          GRPC_ERROR_INT_FD, fd);

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

@@ -36,11 +36,11 @@
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 
 /* Return the listener in s with address addr or NULL. */
-static grpc_tcp_listener *find_listener_with_addr(grpc_tcp_server *s,
-                                                  grpc_resolved_address *addr) {
-  grpc_tcp_listener *l;
+static grpc_tcp_listener* find_listener_with_addr(grpc_tcp_server* s,
+                                                  grpc_resolved_address* addr) {
+  grpc_tcp_listener* l;
   gpr_mu_lock(&s->mu);
-  for (l = s->head; l != NULL; l = l->next) {
+  for (l = s->head; l != nullptr; l = l->next) {
     if (l->addr.len != addr->len) {
       continue;
     }
@@ -53,12 +53,12 @@ static grpc_tcp_listener *find_listener_with_addr(grpc_tcp_server *s,
 }
 
 /* Bind to "::" to get a port number not used by any address. */
-static grpc_error *get_unused_port(int *port) {
+static grpc_error* get_unused_port(int* port) {
   grpc_resolved_address wild;
   grpc_sockaddr_make_wildcard6(0, &wild);
   grpc_dualstack_mode dsmode;
   int fd;
-  grpc_error *err =
+  grpc_error* err =
       grpc_create_dualstack_socket(&wild, SOCK_STREAM, 0, &dsmode, &fd);
   if (err != GRPC_ERROR_NONE) {
     return err;
@@ -66,12 +66,12 @@ static grpc_error *get_unused_port(int *port) {
   if (dsmode == GRPC_DSMODE_IPV4) {
     grpc_sockaddr_make_wildcard4(0, &wild);
   }
-  if (bind(fd, (const struct sockaddr *)wild.addr, (socklen_t)wild.len) != 0) {
+  if (bind(fd, (const struct sockaddr*)wild.addr, (socklen_t)wild.len) != 0) {
     err = GRPC_OS_ERROR(errno, "bind");
     close(fd);
     return err;
   }
-  if (getsockname(fd, (struct sockaddr *)wild.addr, (socklen_t *)&wild.len) !=
+  if (getsockname(fd, (struct sockaddr*)wild.addr, (socklen_t*)&wild.len) !=
       0) {
     err = GRPC_OS_ERROR(errno, "getsockname");
     close(fd);
@@ -83,15 +83,15 @@ static grpc_error *get_unused_port(int *port) {
                     : GRPC_ERROR_NONE;
 }
 
-grpc_error *grpc_tcp_server_add_all_local_addrs(grpc_tcp_server *s,
+grpc_error* grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
                                                 unsigned port_index,
                                                 int requested_port,
-                                                int *out_port) {
-  struct ifaddrs *ifa = NULL;
-  struct ifaddrs *ifa_it;
+                                                int* out_port) {
+  struct ifaddrs* ifa = nullptr;
+  struct ifaddrs* ifa_it;
   unsigned fd_index = 0;
-  grpc_tcp_listener *sp = NULL;
-  grpc_error *err = GRPC_ERROR_NONE;
+  grpc_tcp_listener* sp = nullptr;
+  grpc_error* err = GRPC_ERROR_NONE;
   if (requested_port == 0) {
     /* Note: There could be a race where some local addrs can listen on the
        selected port and some can't. The sane way to handle this would be to
@@ -104,16 +104,16 @@ grpc_error *grpc_tcp_server_add_all_local_addrs(grpc_tcp_server *s,
     }
     gpr_log(GPR_DEBUG, "Picked unused port %d", requested_port);
   }
-  if (getifaddrs(&ifa) != 0 || ifa == NULL) {
+  if (getifaddrs(&ifa) != 0 || ifa == nullptr) {
     return GRPC_OS_ERROR(errno, "getifaddrs");
   }
-  for (ifa_it = ifa; ifa_it != NULL; ifa_it = ifa_it->ifa_next) {
+  for (ifa_it = ifa; ifa_it != nullptr; ifa_it = ifa_it->ifa_next) {
     grpc_resolved_address addr;
-    char *addr_str = NULL;
+    char* addr_str = nullptr;
     grpc_dualstack_mode dsmode;
-    grpc_tcp_listener *new_sp = NULL;
-    const char *ifa_name = (ifa_it->ifa_name ? ifa_it->ifa_name : "<unknown>");
-    if (ifa_it->ifa_addr == NULL) {
+    grpc_tcp_listener* new_sp = nullptr;
+    const char* ifa_name = (ifa_it->ifa_name ? ifa_it->ifa_name : "<unknown>");
+    if (ifa_it->ifa_addr == nullptr) {
       continue;
     } else if (ifa_it->ifa_addr->sa_family == AF_INET) {
       addr.len = sizeof(struct sockaddr_in);
@@ -136,7 +136,7 @@ grpc_error *grpc_tcp_server_add_all_local_addrs(grpc_tcp_server *s,
             ifa_name, ifa_it->ifa_flags, addr_str);
     /* We could have multiple interfaces with the same address (e.g., bonding),
        so look for duplicates. */
-    if (find_listener_with_addr(s, &addr) != NULL) {
+    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);
@@ -144,8 +144,8 @@ grpc_error *grpc_tcp_server_add_all_local_addrs(grpc_tcp_server *s,
     }
     if ((err = grpc_tcp_server_add_addr(s, &addr, port_index, fd_index, &dsmode,
                                         &new_sp)) != GRPC_ERROR_NONE) {
-      char *err_str = NULL;
-      grpc_error *root_err;
+      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");
       }
@@ -157,7 +157,7 @@ grpc_error *grpc_tcp_server_add_all_local_addrs(grpc_tcp_server *s,
     } else {
       GPR_ASSERT(requested_port == new_sp->port);
       ++fd_index;
-      if (sp != NULL) {
+      if (sp != nullptr) {
         new_sp->is_sibling = 1;
         sp->sibling = new_sp;
       }
@@ -168,7 +168,7 @@ grpc_error *grpc_tcp_server_add_all_local_addrs(grpc_tcp_server *s,
   freeifaddrs(ifa);
   if (err != GRPC_ERROR_NONE) {
     return err;
-  } else if (sp == NULL) {
+  } else if (sp == nullptr) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("No local addresses");
   } else {
     *out_port = sp->port;

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

@@ -22,10 +22,10 @@
 
 #include "src/core/lib/iomgr/tcp_server_utils_posix.h"
 
-grpc_error *grpc_tcp_server_add_all_local_addrs(grpc_tcp_server *s,
+grpc_error* grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
                                                 unsigned port_index,
                                                 int requested_port,
-                                                int *out_port) {
+                                                int* out_port) {
   return GRPC_ERROR_CREATE_FROM_STATIC_STRING("no ifaddrs available");
 }
 

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

@@ -37,12 +37,12 @@
 /* one listening port */
 typedef struct grpc_tcp_listener grpc_tcp_listener;
 struct grpc_tcp_listener {
-  uv_tcp_t *handle;
-  grpc_tcp_server *server;
+  uv_tcp_t* handle;
+  grpc_tcp_server* server;
   unsigned port_index;
   int port;
   /* linked list */
-  struct grpc_tcp_listener *next;
+  struct grpc_tcp_listener* next;
 
   bool closed;
 
@@ -54,37 +54,37 @@ struct grpc_tcp_server {
 
   /* Called whenever accept() succeeds on a server port. */
   grpc_tcp_server_cb on_accept_cb;
-  void *on_accept_cb_arg;
+  void* on_accept_cb_arg;
 
   int open_ports;
 
   /* linked list of server ports */
-  grpc_tcp_listener *head;
-  grpc_tcp_listener *tail;
+  grpc_tcp_listener* head;
+  grpc_tcp_listener* tail;
 
   /* List of closures passed to shutdown_starting_add(). */
   grpc_closure_list shutdown_starting;
 
   /* shutdown callback */
-  grpc_closure *shutdown_complete;
+  grpc_closure* shutdown_complete;
 
   bool shutdown;
 
-  grpc_resource_quota *resource_quota;
+  grpc_resource_quota* resource_quota;
 };
 
-grpc_error *grpc_tcp_server_create(grpc_exec_ctx *exec_ctx,
-                                   grpc_closure *shutdown_complete,
-                                   const grpc_channel_args *args,
-                                   grpc_tcp_server **server) {
-  grpc_tcp_server *s = gpr_malloc(sizeof(grpc_tcp_server));
+grpc_error* grpc_tcp_server_create(grpc_exec_ctx* exec_ctx,
+                                   grpc_closure* shutdown_complete,
+                                   const grpc_channel_args* args,
+                                   grpc_tcp_server** server) {
+  grpc_tcp_server* s = (grpc_tcp_server*)gpr_malloc(sizeof(grpc_tcp_server));
   s->resource_quota = grpc_resource_quota_create(NULL);
   for (size_t i = 0; i < (args == NULL ? 0 : args->num_args); i++) {
     if (0 == strcmp(GRPC_ARG_RESOURCE_QUOTA, args->args[i].key)) {
       if (args->args[i].type == GRPC_ARG_POINTER) {
         grpc_resource_quota_unref_internal(exec_ctx, s->resource_quota);
-        s->resource_quota =
-            grpc_resource_quota_ref_internal(args->args[i].value.pointer.p);
+        s->resource_quota = grpc_resource_quota_ref_internal(
+            (grpc_resource_quota*)args->args[i].value.pointer.p);
       } else {
         grpc_resource_quota_unref_internal(exec_ctx, s->resource_quota);
         gpr_free(s);
@@ -107,26 +107,26 @@ grpc_error *grpc_tcp_server_create(grpc_exec_ctx *exec_ctx,
   return GRPC_ERROR_NONE;
 }
 
-grpc_tcp_server *grpc_tcp_server_ref(grpc_tcp_server *s) {
+grpc_tcp_server* grpc_tcp_server_ref(grpc_tcp_server* s) {
   GRPC_UV_ASSERT_SAME_THREAD();
   gpr_ref(&s->refs);
   return s;
 }
 
-void grpc_tcp_server_shutdown_starting_add(grpc_tcp_server *s,
-                                           grpc_closure *shutdown_starting) {
+void grpc_tcp_server_shutdown_starting_add(grpc_tcp_server* s,
+                                           grpc_closure* shutdown_starting) {
   grpc_closure_list_append(&s->shutdown_starting, shutdown_starting,
                            GRPC_ERROR_NONE);
 }
 
-static void finish_shutdown(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s) {
+static void finish_shutdown(grpc_exec_ctx* exec_ctx, grpc_tcp_server* s) {
   GPR_ASSERT(s->shutdown);
   if (s->shutdown_complete != NULL) {
     GRPC_CLOSURE_SCHED(exec_ctx, s->shutdown_complete, GRPC_ERROR_NONE);
   }
 
   while (s->head) {
-    grpc_tcp_listener *sp = s->head;
+    grpc_tcp_listener* sp = s->head;
     s->head = sp->next;
     sp->next = NULL;
     gpr_free(sp->handle);
@@ -136,8 +136,8 @@ static void finish_shutdown(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s) {
   gpr_free(s);
 }
 
-static void handle_close_callback(uv_handle_t *handle) {
-  grpc_tcp_listener *sp = (grpc_tcp_listener *)handle->data;
+static void handle_close_callback(uv_handle_t* handle) {
+  grpc_tcp_listener* sp = (grpc_tcp_listener*)handle->data;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   sp->server->open_ports--;
   if (sp->server->open_ports == 0 && sp->server->shutdown) {
@@ -146,16 +146,16 @@ static void handle_close_callback(uv_handle_t *handle) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void close_listener(grpc_tcp_listener *sp) {
+static void close_listener(grpc_tcp_listener* sp) {
   if (!sp->closed) {
     sp->closed = true;
-    uv_close((uv_handle_t *)sp->handle, handle_close_callback);
+    uv_close((uv_handle_t*)sp->handle, handle_close_callback);
   }
 }
 
-static void tcp_server_destroy(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s) {
+static void tcp_server_destroy(grpc_exec_ctx* exec_ctx, grpc_tcp_server* s) {
   int immediately_done = 0;
-  grpc_tcp_listener *sp;
+  grpc_tcp_listener* sp;
 
   GPR_ASSERT(!s->shutdown);
   s->shutdown = true;
@@ -172,7 +172,7 @@ static void tcp_server_destroy(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s) {
   }
 }
 
-void grpc_tcp_server_unref(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s) {
+void grpc_tcp_server_unref(grpc_exec_ctx* exec_ctx, grpc_tcp_server* s) {
   GRPC_UV_ASSERT_SAME_THREAD();
   if (gpr_unref(&s->refs)) {
     /* Complete shutdown_starting work before destroying. */
@@ -189,30 +189,31 @@ void grpc_tcp_server_unref(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s) {
   }
 }
 
-static void finish_accept(grpc_exec_ctx *exec_ctx, grpc_tcp_listener *sp) {
-  grpc_tcp_server_acceptor *acceptor = gpr_malloc(sizeof(*acceptor));
-  uv_tcp_t *client;
-  grpc_endpoint *ep = NULL;
+static void finish_accept(grpc_exec_ctx* exec_ctx, grpc_tcp_listener* sp) {
+  grpc_tcp_server_acceptor* acceptor =
+      (grpc_tcp_server_acceptor*)gpr_malloc(sizeof(*acceptor));
+  uv_tcp_t* client = NULL;
+  grpc_endpoint* ep = NULL;
   grpc_resolved_address peer_name;
-  char *peer_name_string;
+  char* peer_name_string;
   int err;
-  uv_tcp_t *server = sp->handle;
+  uv_tcp_t* server = sp->handle;
 
-  client = gpr_malloc(sizeof(uv_tcp_t));
+  client = (uv_tcp_t*)gpr_malloc(sizeof(uv_tcp_t));
   uv_tcp_init(uv_default_loop(), client);
   // UV documentation says this is guaranteed to succeed
-  uv_accept((uv_stream_t *)server, (uv_stream_t *)client);
+  uv_accept((uv_stream_t*)server, (uv_stream_t*)client);
   peer_name_string = NULL;
   memset(&peer_name, 0, sizeof(grpc_resolved_address));
   peer_name.len = sizeof(struct sockaddr_storage);
-  err = uv_tcp_getpeername(client, (struct sockaddr *)&peer_name.addr,
-                           (int *)&peer_name.len);
+  err = uv_tcp_getpeername(client, (struct sockaddr*)&peer_name.addr,
+                           (int*)&peer_name.len);
   if (err == 0) {
     peer_name_string = grpc_sockaddr_to_uri(&peer_name);
   } else {
     gpr_log(GPR_INFO, "uv_tcp_getpeername error: %s", uv_strerror(err));
   }
-  if (GRPC_TRACER_ON(grpc_tcp_trace)) {
+  if (grpc_tcp_trace.enabled()) {
     if (peer_name_string) {
       gpr_log(GPR_DEBUG, "SERVER_CONNECT: %p accepted connection: %s",
               sp->server, peer_name_string);
@@ -229,8 +230,8 @@ static void finish_accept(grpc_exec_ctx *exec_ctx, grpc_tcp_listener *sp) {
   gpr_free(peer_name_string);
 }
 
-static void on_connect(uv_stream_t *server, int status) {
-  grpc_tcp_listener *sp = (grpc_tcp_listener *)server->data;
+static void on_connect(uv_stream_t* server, int status) {
+  grpc_tcp_listener* sp = (grpc_tcp_listener*)server->data;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   if (status < 0) {
@@ -246,7 +247,7 @@ static void on_connect(uv_stream_t *server, int status) {
 
   GPR_ASSERT(!sp->has_pending_connection);
 
-  if (GRPC_TRACER_ON(grpc_tcp_trace)) {
+  if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "SERVER_CONNECT: %p incoming connection", sp->server);
   }
 
@@ -259,18 +260,39 @@ static void on_connect(uv_stream_t *server, int status) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static grpc_error *add_socket_to_server(grpc_tcp_server *s, uv_tcp_t *handle,
-                                        const grpc_resolved_address *addr,
-                                        unsigned port_index,
-                                        grpc_tcp_listener **listener) {
-  grpc_tcp_listener *sp = NULL;
+static grpc_error* add_addr_to_server(grpc_tcp_server* s,
+                                      const grpc_resolved_address* addr,
+                                      unsigned port_index,
+                                      grpc_tcp_listener** listener) {
+  grpc_tcp_listener* sp = NULL;
   int port = -1;
   int status;
-  grpc_error *error;
+  grpc_error* error;
   grpc_resolved_address sockname_temp;
+  uv_tcp_t* handle = (uv_tcp_t*)gpr_malloc(sizeof(uv_tcp_t));
+  int family = grpc_sockaddr_get_family(addr);
+
+  status = uv_tcp_init_ex(uv_default_loop(), handle, (unsigned int)family);
+#if defined(GPR_LINUX) && defined(SO_REUSEPORT)
+  if (family == AF_INET || family == AF_INET6) {
+    int fd;
+    uv_fileno((uv_handle_t*)handle, &fd);
+    int enable = 1;
+    setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &enable, sizeof(enable));
+  }
+#endif /* GPR_LINUX && SO_REUSEPORT */
+
+  if (status != 0) {
+    error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "Failed to initialize UV tcp handle");
+    error =
+        grpc_error_set_str(error, GRPC_ERROR_STR_OS_ERROR,
+                           grpc_slice_from_static_string(uv_strerror(status)));
+    return error;
+  }
 
   // The last argument to uv_tcp_bind is flags
-  status = uv_tcp_bind(handle, (struct sockaddr *)addr->addr, 0);
+  status = uv_tcp_bind(handle, (struct sockaddr*)addr->addr, 0);
   if (status != 0) {
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to bind to port");
     error =
@@ -279,7 +301,7 @@ static grpc_error *add_socket_to_server(grpc_tcp_server *s, uv_tcp_t *handle,
     return error;
   }
 
-  status = uv_listen((uv_stream_t *)handle, SOMAXCONN, on_connect);
+  status = uv_listen((uv_stream_t*)handle, SOMAXCONN, on_connect);
   if (status != 0) {
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to listen to port");
     error =
@@ -289,8 +311,8 @@ static grpc_error *add_socket_to_server(grpc_tcp_server *s, uv_tcp_t *handle,
   }
 
   sockname_temp.len = (int)sizeof(struct sockaddr_storage);
-  status = uv_tcp_getsockname(handle, (struct sockaddr *)&sockname_temp.addr,
-                              (int *)&sockname_temp.len);
+  status = uv_tcp_getsockname(handle, (struct sockaddr*)&sockname_temp.addr,
+                              (int*)&sockname_temp.len);
   if (status != 0) {
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("getsockname failed");
     error =
@@ -303,7 +325,7 @@ static grpc_error *add_socket_to_server(grpc_tcp_server *s, uv_tcp_t *handle,
 
   GPR_ASSERT(port >= 0);
   GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server");
-  sp = gpr_zalloc(sizeof(grpc_tcp_listener));
+  sp = (grpc_tcp_listener*)gpr_zalloc(sizeof(grpc_tcp_listener));
   sp->next = NULL;
   if (s->head == NULL) {
     s->head = sp;
@@ -324,20 +346,48 @@ static grpc_error *add_socket_to_server(grpc_tcp_server *s, uv_tcp_t *handle,
   return GRPC_ERROR_NONE;
 }
 
-grpc_error *grpc_tcp_server_add_port(grpc_tcp_server *s,
-                                     const grpc_resolved_address *addr,
-                                     int *port) {
+static grpc_error* add_wildcard_addrs_to_server(grpc_tcp_server* s,
+                                                unsigned port_index,
+                                                int requested_port,
+                                                grpc_tcp_listener** listener) {
+  grpc_resolved_address wild4;
+  grpc_resolved_address wild6;
+  grpc_tcp_listener* sp = nullptr;
+  grpc_tcp_listener* sp2 = nullptr;
+  grpc_error* v6_err = GRPC_ERROR_NONE;
+  grpc_error* v4_err = GRPC_ERROR_NONE;
+
+  grpc_sockaddr_make_wildcards(requested_port, &wild4, &wild6);
+  /* Try listening on IPv6 first. */
+  if ((v6_err = add_addr_to_server(s, &wild6, port_index, &sp)) ==
+      GRPC_ERROR_NONE) {
+    *listener = sp;
+    return GRPC_ERROR_NONE;
+  }
+
+  if ((v4_err = add_addr_to_server(s, &wild4, port_index, &sp2)) ==
+      GRPC_ERROR_NONE) {
+    *listener = sp2;
+    return GRPC_ERROR_NONE;
+  }
+
+  grpc_error* root_err = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      "Failed to add any wildcard listeners");
+  root_err = grpc_error_add_child(root_err, v6_err);
+  root_err = grpc_error_add_child(root_err, v4_err);
+  return root_err;
+}
+
+grpc_error* grpc_tcp_server_add_port(grpc_tcp_server* s,
+                                     const grpc_resolved_address* addr,
+                                     int* port) {
   // This function is mostly copied from tcp_server_windows.c
-  grpc_tcp_listener *sp = NULL;
-  uv_tcp_t *handle;
+  grpc_tcp_listener* sp = NULL;
   grpc_resolved_address addr6_v4mapped;
-  grpc_resolved_address wildcard;
-  grpc_resolved_address *allocated_addr = NULL;
+  grpc_resolved_address* allocated_addr = NULL;
   grpc_resolved_address sockname_temp;
   unsigned port_index = 0;
-  int status;
-  grpc_error *error = GRPC_ERROR_NONE;
-  int family;
+  grpc_error* error = GRPC_ERROR_NONE;
 
   GRPC_UV_ASSERT_SAME_THREAD();
 
@@ -351,11 +401,12 @@ grpc_error *grpc_tcp_server_add_port(grpc_tcp_server *s,
     for (sp = s->head; sp; sp = sp->next) {
       sockname_temp.len = sizeof(struct sockaddr_storage);
       if (0 == uv_tcp_getsockname(sp->handle,
-                                  (struct sockaddr *)&sockname_temp.addr,
-                                  (int *)&sockname_temp.len)) {
+                                  (struct sockaddr*)&sockname_temp.addr,
+                                  (int*)&sockname_temp.len)) {
         *port = grpc_sockaddr_get_port(&sockname_temp);
         if (*port > 0) {
-          allocated_addr = gpr_malloc(sizeof(grpc_resolved_address));
+          allocated_addr =
+              (grpc_resolved_address*)gpr_malloc(sizeof(grpc_resolved_address));
           memcpy(allocated_addr, addr, sizeof(grpc_resolved_address));
           grpc_sockaddr_set_port(allocated_addr, *port);
           addr = allocated_addr;
@@ -365,46 +416,23 @@ grpc_error *grpc_tcp_server_add_port(grpc_tcp_server *s,
     }
   }
 
-  if (grpc_sockaddr_to_v4mapped(addr, &addr6_v4mapped)) {
-    addr = &addr6_v4mapped;
-  }
-
   /* Treat :: or 0.0.0.0 as a family-agnostic wildcard. */
   if (grpc_sockaddr_is_wildcard(addr, port)) {
-    grpc_sockaddr_make_wildcard6(*port, &wildcard);
-
-    addr = &wildcard;
-  }
-
-  handle = gpr_malloc(sizeof(uv_tcp_t));
-
-  family = grpc_sockaddr_get_family(addr);
-  status = uv_tcp_init_ex(uv_default_loop(), handle, (unsigned int)family);
-#if defined(GPR_LINUX) && defined(SO_REUSEPORT)
-  if (family == AF_INET || family == AF_INET6) {
-    int fd;
-    uv_fileno((uv_handle_t *)handle, &fd);
-    int enable = 1;
-    setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &enable, sizeof(enable));
-  }
-#endif /* GPR_LINUX && SO_REUSEPORT */
-
-  if (status == 0) {
-    error = add_socket_to_server(s, handle, addr, port_index, &sp);
+    error = add_wildcard_addrs_to_server(s, port_index, *port, &sp);
   } else {
-    error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Failed to initialize UV tcp handle");
-    error =
-        grpc_error_set_str(error, GRPC_ERROR_STR_OS_ERROR,
-                           grpc_slice_from_static_string(uv_strerror(status)));
+    if (grpc_sockaddr_to_v4mapped(addr, &addr6_v4mapped)) {
+      addr = &addr6_v4mapped;
+    }
+
+    error = add_addr_to_server(s, addr, port_index, &sp);
   }
 
   gpr_free(allocated_addr);
 
-  if (GRPC_TRACER_ON(grpc_tcp_trace)) {
-    char *port_string;
+  if (grpc_tcp_trace.enabled()) {
+    char* port_string;
     grpc_sockaddr_to_string(&port_string, addr, 0);
-    const char *str = grpc_error_string(error);
+    const char* str = grpc_error_string(error);
     if (port_string) {
       gpr_log(GPR_DEBUG, "SERVER %p add_port %s error=%s", s, port_string, str);
       gpr_free(port_string);
@@ -414,7 +442,7 @@ grpc_error *grpc_tcp_server_add_port(grpc_tcp_server *s,
   }
 
   if (error != GRPC_ERROR_NONE) {
-    grpc_error *error_out = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+    grpc_error* error_out = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
         "Failed to add port to server", &error, 1);
     GRPC_ERROR_UNREF(error);
     error = error_out;
@@ -426,14 +454,14 @@ grpc_error *grpc_tcp_server_add_port(grpc_tcp_server *s,
   return error;
 }
 
-void grpc_tcp_server_start(grpc_exec_ctx *exec_ctx, grpc_tcp_server *server,
-                           grpc_pollset **pollsets, size_t pollset_count,
-                           grpc_tcp_server_cb on_accept_cb, void *cb_arg) {
-  grpc_tcp_listener *sp;
+void grpc_tcp_server_start(grpc_exec_ctx* exec_ctx, grpc_tcp_server* server,
+                           grpc_pollset** pollsets, size_t pollset_count,
+                           grpc_tcp_server_cb on_accept_cb, void* cb_arg) {
+  grpc_tcp_listener* sp;
   (void)pollsets;
   (void)pollset_count;
   GRPC_UV_ASSERT_SAME_THREAD();
-  if (GRPC_TRACER_ON(grpc_tcp_trace)) {
+  if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "SERVER_START %p", server);
   }
   GPR_ASSERT(on_accept_cb);
@@ -448,7 +476,7 @@ void grpc_tcp_server_start(grpc_exec_ctx *exec_ctx, grpc_tcp_server *server,
   }
 }
 
-void grpc_tcp_server_shutdown_listeners(grpc_exec_ctx *exec_ctx,
-                                        grpc_tcp_server *s) {}
+void grpc_tcp_server_shutdown_listeners(grpc_exec_ctx* exec_ctx,
+                                        grpc_tcp_server* s) {}
 
 #endif /* GRPC_UV */