grpc 1.7.3 → 1.8.0

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

@@ -33,24 +33,32 @@
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 
-extern grpc_tracer_flag grpc_tcp_trace;
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern grpc_core::TraceFlag grpc_tcp_trace;
 
 /* Create a tcp endpoint given a file desciptor and a read slice size.
    Takes ownership of fd. */
-grpc_endpoint *grpc_tcp_create(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
-                               const grpc_channel_args *args,
-                               const char *peer_string);
+grpc_endpoint* grpc_tcp_create(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
+                               const grpc_channel_args* args,
+                               const char* peer_string);
 
 /* Return the tcp endpoint's fd, or -1 if this is not available. Does not
    release the fd.
    Requires: ep must be a tcp endpoint.
  */
-int grpc_tcp_fd(grpc_endpoint *ep);
+int grpc_tcp_fd(grpc_endpoint* ep);
 
 /* Destroy the tcp endpoint without closing its fd. *fd will be set and done
  * will be called when the endpoint is destroyed.
  * Requires: ep must be a tcp endpoint and fd must not be NULL. */
-void grpc_tcp_destroy_and_release_fd(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                                     int *fd, grpc_closure *done);
+void grpc_tcp_destroy_and_release_fd(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
+                                     int* fd, grpc_closure* done);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_IOMGR_TCP_POSIX_H */

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

@@ -25,13 +25,17 @@
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* Forward decl of grpc_tcp_server */
 typedef struct grpc_tcp_server grpc_tcp_server;
 
 typedef struct grpc_tcp_server_acceptor {
   /* grpc_tcp_server_cb functions share a ref on from_server that is valid
      until the function returns. */
-  grpc_tcp_server *from_server;
+  grpc_tcp_server* from_server;
   /* Indices that may be passed to grpc_tcp_server_port_fd(). */
   unsigned port_index;
   unsigned fd_index;
@@ -39,23 +43,23 @@ typedef struct grpc_tcp_server_acceptor {
 
 /* Called for newly connected TCP connections.
    Takes ownership of acceptor. */
-typedef void (*grpc_tcp_server_cb)(grpc_exec_ctx *exec_ctx, void *arg,
-                                   grpc_endpoint *ep,
-                                   grpc_pollset *accepting_pollset,
-                                   grpc_tcp_server_acceptor *acceptor);
+typedef void (*grpc_tcp_server_cb)(grpc_exec_ctx* exec_ctx, void* arg,
+                                   grpc_endpoint* ep,
+                                   grpc_pollset* accepting_pollset,
+                                   grpc_tcp_server_acceptor* acceptor);
 
 /* Create a server, initially not bound to any ports. The caller owns one ref.
    If shutdown_complete is not NULL, it will be used by
    grpc_tcp_server_unref() when the ref count reaches zero. */
-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_error* grpc_tcp_server_create(grpc_exec_ctx* exec_ctx,
+                                   grpc_closure* shutdown_complete,
+                                   const grpc_channel_args* args,
+                                   grpc_tcp_server** server);
 
 /* Start listening to bound ports */
-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);
+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);
 
 /* Add a port to the server, returning the newly allocated port on success, or
    -1 on failure.
@@ -66,36 +70,40 @@ void grpc_tcp_server_start(grpc_exec_ctx *exec_ctx, grpc_tcp_server *server,
    but not dualstack sockets. */
 /* TODO(ctiller): deprecate this, and make grpc_tcp_server_add_ports to handle
                   all of the multiple socket port matching logic in one place */
-grpc_error *grpc_tcp_server_add_port(grpc_tcp_server *s,
-                                     const grpc_resolved_address *addr,
-                                     int *out_port);
+grpc_error* grpc_tcp_server_add_port(grpc_tcp_server* s,
+                                     const grpc_resolved_address* addr,
+                                     int* out_port);
 
 /* Number of fds at the given port_index, or 0 if port_index is out of
    bounds. */
-unsigned grpc_tcp_server_port_fd_count(grpc_tcp_server *s, unsigned port_index);
+unsigned grpc_tcp_server_port_fd_count(grpc_tcp_server* s, unsigned port_index);
 
 /* Returns the file descriptor of the Mth (fd_index) listening socket of the Nth
    (port_index) call to add_port() on this server, or -1 if the indices are out
    of bounds. The file descriptor remains owned by the server, and will be
    cleaned up when the ref count reaches zero. */
-int grpc_tcp_server_port_fd(grpc_tcp_server *s, unsigned port_index,
+int grpc_tcp_server_port_fd(grpc_tcp_server* s, unsigned port_index,
                             unsigned fd_index);
 
 /* Ref s and return s. */
-grpc_tcp_server *grpc_tcp_server_ref(grpc_tcp_server *s);
+grpc_tcp_server* grpc_tcp_server_ref(grpc_tcp_server* s);
 
 /* shutdown_starting is called when ref count has reached zero and the server is
    about to be destroyed. The server will be deleted after it returns. Calling
    grpc_tcp_server_ref() from it has no effect. */
-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);
 
 /* If the refcount drops to zero, enqueue calls on exec_ctx to
    shutdown_listeners and delete 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);
 
 /* Shutdown the fds of listeners. */
-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);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_IOMGR_TCP_SERVER_H */

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

@@ -68,16 +68,16 @@ static void init(void) {
 #endif
 }
 
-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_error* grpc_tcp_server_create(grpc_exec_ctx* exec_ctx,
+                                   grpc_closure* shutdown_complete,
+                                   const grpc_channel_args* args,
+                                   grpc_tcp_server** server) {
   gpr_once_init(&check_init, init);
 
-  grpc_tcp_server *s = (grpc_tcp_server *)gpr_zalloc(sizeof(grpc_tcp_server));
+  grpc_tcp_server* s = (grpc_tcp_server*)gpr_zalloc(sizeof(grpc_tcp_server));
   s->so_reuseport = has_so_reuseport;
   s->expand_wildcard_addrs = false;
-  for (size_t i = 0; i < (args == NULL ? 0 : args->num_args); i++) {
+  for (size_t i = 0; i < (args == nullptr ? 0 : args->num_args); i++) {
     if (0 == strcmp(GRPC_ARG_ALLOW_REUSEPORT, args->args[i].key)) {
       if (args->args[i].type == GRPC_ARG_INTEGER) {
         s->so_reuseport =
@@ -102,13 +102,13 @@ grpc_error *grpc_tcp_server_create(grpc_exec_ctx *exec_ctx,
   s->active_ports = 0;
   s->destroyed_ports = 0;
   s->shutdown = false;
-  s->shutdown_starting.head = NULL;
-  s->shutdown_starting.tail = NULL;
+  s->shutdown_starting.head = nullptr;
+  s->shutdown_starting.tail = nullptr;
   s->shutdown_complete = shutdown_complete;
-  s->on_accept_cb = NULL;
-  s->on_accept_cb_arg = NULL;
-  s->head = NULL;
-  s->tail = NULL;
+  s->on_accept_cb = nullptr;
+  s->on_accept_cb_arg = nullptr;
+  s->head = nullptr;
+  s->tail = nullptr;
   s->nports = 0;
   s->channel_args = grpc_channel_args_copy(args);
   gpr_atm_no_barrier_store(&s->next_pollset_to_assign, 0);
@@ -116,18 +116,18 @@ grpc_error *grpc_tcp_server_create(grpc_exec_ctx *exec_ctx,
   return 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_mu_lock(&s->mu);
   GPR_ASSERT(s->shutdown);
   gpr_mu_unlock(&s->mu);
-  if (s->shutdown_complete != NULL) {
+  if (s->shutdown_complete != nullptr) {
     GRPC_CLOSURE_SCHED(exec_ctx, s->shutdown_complete, GRPC_ERROR_NONE);
   }
 
   gpr_mu_destroy(&s->mu);
 
   while (s->head) {
-    grpc_tcp_listener *sp = s->head;
+    grpc_tcp_listener* sp = s->head;
     s->head = sp->next;
     gpr_free(sp);
   }
@@ -136,9 +136,9 @@ static void finish_shutdown(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s) {
   gpr_free(s);
 }
 
-static void destroyed_port(grpc_exec_ctx *exec_ctx, void *server,
-                           grpc_error *error) {
-  grpc_tcp_server *s = (grpc_tcp_server *)server;
+static void destroyed_port(grpc_exec_ctx* exec_ctx, void* server,
+                           grpc_error* error) {
+  grpc_tcp_server* s = (grpc_tcp_server*)server;
   gpr_mu_lock(&s->mu);
   s->destroyed_ports++;
   if (s->destroyed_ports == s->nports) {
@@ -153,19 +153,19 @@ static void destroyed_port(grpc_exec_ctx *exec_ctx, void *server,
 /* called when all listening endpoints have been shutdown, so no further
    events will be received on them - at this point it's safe to destroy
    things */
-static void deactivated_all_ports(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s) {
+static void deactivated_all_ports(grpc_exec_ctx* exec_ctx, grpc_tcp_server* s) {
   /* delete ALL the things */
   gpr_mu_lock(&s->mu);
 
   GPR_ASSERT(s->shutdown);
 
   if (s->head) {
-    grpc_tcp_listener *sp;
+    grpc_tcp_listener* sp;
     for (sp = s->head; sp; sp = sp->next) {
       grpc_unlink_if_unix_domain_socket(&sp->addr);
       GRPC_CLOSURE_INIT(&sp->destroyed_closure, destroyed_port, s,
                         grpc_schedule_on_exec_ctx);
-      grpc_fd_orphan(exec_ctx, sp->emfd, &sp->destroyed_closure, NULL,
+      grpc_fd_orphan(exec_ctx, sp->emfd, &sp->destroyed_closure, nullptr,
                      false /* already_closed */, "tcp_listener_shutdown");
     }
     gpr_mu_unlock(&s->mu);
@@ -175,7 +175,7 @@ static void deactivated_all_ports(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s) {
   }
 }
 
-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) {
   gpr_mu_lock(&s->mu);
 
   GPR_ASSERT(!s->shutdown);
@@ -183,10 +183,11 @@ static void tcp_server_destroy(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s) {
 
   /* shutdown all fd's */
   if (s->active_ports) {
-    grpc_tcp_listener *sp;
+    grpc_tcp_listener* sp;
     for (sp = s->head; sp; sp = sp->next) {
-      grpc_fd_shutdown(exec_ctx, sp->emfd, GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                                               "Server destroyed"));
+      grpc_fd_shutdown(
+          exec_ctx, sp->emfd,
+          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server destroyed"));
     }
     gpr_mu_unlock(&s->mu);
   } else {
@@ -196,9 +197,9 @@ static void tcp_server_destroy(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s) {
 }
 
 /* event manager callback when reads are ready */
-static void on_read(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *err) {
-  grpc_tcp_listener *sp = (grpc_tcp_listener *)arg;
-  grpc_pollset *read_notifier_pollset;
+static void on_read(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* err) {
+  grpc_tcp_listener* sp = (grpc_tcp_listener*)arg;
+  grpc_pollset* read_notifier_pollset;
   if (err != GRPC_ERROR_NONE) {
     goto error;
   }
@@ -211,8 +212,8 @@ static void on_read(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *err) {
   /* loop until accept4 returns EAGAIN, and then re-arm notification */
   for (;;) {
     grpc_resolved_address addr;
-    char *addr_str;
-    char *name;
+    char* addr_str;
+    char* name;
     addr.len = sizeof(struct sockaddr_storage);
     /* Note: If we ever decide to return this address to the user, remember to
        strip off the ::ffff:0.0.0.0/96 prefix first. */
@@ -242,17 +243,17 @@ static void on_read(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *err) {
     addr_str = grpc_sockaddr_to_uri(&addr);
     gpr_asprintf(&name, "tcp-server-connection:%s", addr_str);
 
-    if (GRPC_TRACER_ON(grpc_tcp_trace)) {
+    if (grpc_tcp_trace.enabled()) {
       gpr_log(GPR_DEBUG, "SERVER_CONNECT: incoming connection: %s", addr_str);
     }
 
-    grpc_fd *fdobj = grpc_fd_create(fd, name);
+    grpc_fd* fdobj = grpc_fd_create(fd, name);
 
     grpc_pollset_add_fd(exec_ctx, read_notifier_pollset, fdobj);
 
     // Create acceptor.
-    grpc_tcp_server_acceptor *acceptor =
-        (grpc_tcp_server_acceptor *)gpr_malloc(sizeof(*acceptor));
+    grpc_tcp_server_acceptor* acceptor =
+        (grpc_tcp_server_acceptor*)gpr_malloc(sizeof(*acceptor));
     acceptor->from_server = sp->server;
     acceptor->port_index = sp->port_index;
     acceptor->fd_index = sp->fd_index;
@@ -279,18 +280,18 @@ error:
 }
 
 /* Treat :: or 0.0.0.0 as a family-agnostic wildcard. */
-static grpc_error *add_wildcard_addrs_to_server(grpc_tcp_server *s,
+static grpc_error* add_wildcard_addrs_to_server(grpc_tcp_server* s,
                                                 unsigned port_index,
                                                 int requested_port,
-                                                int *out_port) {
+                                                int* out_port) {
   grpc_resolved_address wild4;
   grpc_resolved_address wild6;
   unsigned fd_index = 0;
   grpc_dualstack_mode dsmode;
-  grpc_tcp_listener *sp = NULL;
-  grpc_tcp_listener *sp2 = NULL;
-  grpc_error *v6_err = GRPC_ERROR_NONE;
-  grpc_error *v4_err = GRPC_ERROR_NONE;
+  grpc_tcp_listener* sp = nullptr;
+  grpc_tcp_listener* sp2 = nullptr;
+  grpc_error* v6_err = GRPC_ERROR_NONE;
+  grpc_error* v4_err = GRPC_ERROR_NONE;
   *out_port = -1;
 
   if (grpc_tcp_server_have_ifaddrs() && s->expand_wildcard_addrs) {
@@ -313,7 +314,7 @@ static grpc_error *add_wildcard_addrs_to_server(grpc_tcp_server *s,
   if ((v4_err = grpc_tcp_server_add_addr(s, &wild4, port_index, fd_index,
                                          &dsmode, &sp2)) == GRPC_ERROR_NONE) {
     *out_port = sp2->port;
-    if (sp != NULL) {
+    if (sp != nullptr) {
       sp2->is_sibling = 1;
       sp->sibling = sp2;
     }
@@ -335,7 +336,7 @@ static grpc_error *add_wildcard_addrs_to_server(grpc_tcp_server *s,
     }
     return GRPC_ERROR_NONE;
   } else {
-    grpc_error *root_err = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+    grpc_error* root_err = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Failed to add any wildcard listeners");
     GPR_ASSERT(v6_err != GRPC_ERROR_NONE && v4_err != GRPC_ERROR_NONE);
     root_err = grpc_error_add_child(root_err, v6_err);
@@ -344,13 +345,13 @@ static grpc_error *add_wildcard_addrs_to_server(grpc_tcp_server *s,
   }
 }
 
-static grpc_error *clone_port(grpc_tcp_listener *listener, unsigned count) {
-  grpc_tcp_listener *sp = NULL;
-  char *addr_str;
-  char *name;
-  grpc_error *err;
+static grpc_error* clone_port(grpc_tcp_listener* listener, unsigned count) {
+  grpc_tcp_listener* sp = nullptr;
+  char* addr_str;
+  char* name;
+  grpc_error* err;
 
-  for (grpc_tcp_listener *l = listener->next; l && l->is_sibling; l = l->next) {
+  for (grpc_tcp_listener* l = listener->next; l && l->is_sibling; l = l->next) {
     l->fd_index += count;
   }
 
@@ -366,7 +367,7 @@ static grpc_error *clone_port(grpc_tcp_listener *listener, unsigned count) {
     listener->server->nports++;
     grpc_sockaddr_to_string(&addr_str, &listener->addr, 1);
     gpr_asprintf(&name, "tcp-server-listener:%s/clone-%d", addr_str, i);
-    sp = (grpc_tcp_listener *)gpr_malloc(sizeof(grpc_tcp_listener));
+    sp = (grpc_tcp_listener*)gpr_malloc(sizeof(grpc_tcp_listener));
     sp->next = listener->next;
     listener->next = sp;
     /* sp (the new listener) is a sibling of 'listener' (the original
@@ -382,7 +383,7 @@ static grpc_error *clone_port(grpc_tcp_listener *listener, unsigned count) {
     sp->port_index = listener->port_index;
     sp->fd_index = listener->fd_index + count - i;
     GPR_ASSERT(sp->emfd);
-    while (listener->server->tail->next != NULL) {
+    while (listener->server->tail->next != nullptr) {
       listener->server->tail = listener->server->tail->next;
     }
     gpr_free(addr_str);
@@ -392,18 +393,18 @@ static grpc_error *clone_port(grpc_tcp_listener *listener, unsigned count) {
   return GRPC_ERROR_NONE;
 }
 
-grpc_error *grpc_tcp_server_add_port(grpc_tcp_server *s,
-                                     const grpc_resolved_address *addr,
-                                     int *out_port) {
-  grpc_tcp_listener *sp;
+grpc_error* grpc_tcp_server_add_port(grpc_tcp_server* s,
+                                     const grpc_resolved_address* addr,
+                                     int* out_port) {
+  grpc_tcp_listener* sp;
   grpc_resolved_address sockname_temp;
   grpc_resolved_address addr6_v4mapped;
   int requested_port = grpc_sockaddr_get_port(addr);
   unsigned port_index = 0;
   grpc_dualstack_mode dsmode;
-  grpc_error *err;
+  grpc_error* err;
   *out_port = -1;
-  if (s->tail != NULL) {
+  if (s->tail != nullptr) {
     port_index = s->tail->port_index + 1;
   }
   grpc_unlink_if_unix_domain_socket(addr);
@@ -413,8 +414,8 @@ grpc_error *grpc_tcp_server_add_port(grpc_tcp_server *s,
   if (requested_port == 0) {
     for (sp = s->head; sp; sp = sp->next) {
       sockname_temp.len = sizeof(struct sockaddr_storage);
-      if (0 == getsockname(sp->fd, (struct sockaddr *)&sockname_temp.addr,
-                           (socklen_t *)&sockname_temp.len)) {
+      if (0 == getsockname(sp->fd, (struct sockaddr*)&sockname_temp.addr,
+                           (socklen_t*)&sockname_temp.len)) {
         int used_port = grpc_sockaddr_get_port(&sockname_temp);
         if (used_port > 0) {
           memcpy(&sockname_temp, addr, sizeof(grpc_resolved_address));
@@ -442,10 +443,10 @@ grpc_error *grpc_tcp_server_add_port(grpc_tcp_server *s,
 
 /* Return listener at port_index or NULL. Should only be called with s->mu
    locked. */
-static grpc_tcp_listener *get_port_index(grpc_tcp_server *s,
+static grpc_tcp_listener* get_port_index(grpc_tcp_server* s,
                                          unsigned port_index) {
   unsigned num_ports = 0;
-  grpc_tcp_listener *sp;
+  grpc_tcp_listener* sp;
   for (sp = s->head; sp; sp = sp->next) {
     if (!sp->is_sibling) {
       if (++num_ports > port_index) {
@@ -453,14 +454,14 @@ static grpc_tcp_listener *get_port_index(grpc_tcp_server *s,
       }
     }
   }
-  return NULL;
+  return nullptr;
 }
 
-unsigned grpc_tcp_server_port_fd_count(grpc_tcp_server *s,
+unsigned grpc_tcp_server_port_fd_count(grpc_tcp_server* s,
                                        unsigned port_index) {
   unsigned num_fds = 0;
   gpr_mu_lock(&s->mu);
-  grpc_tcp_listener *sp = get_port_index(s, port_index);
+  grpc_tcp_listener* sp = get_port_index(s, port_index);
   for (; sp; sp = sp->sibling) {
     ++num_fds;
   }
@@ -468,10 +469,10 @@ unsigned grpc_tcp_server_port_fd_count(grpc_tcp_server *s,
   return num_fds;
 }
 
-int grpc_tcp_server_port_fd(grpc_tcp_server *s, unsigned port_index,
+int grpc_tcp_server_port_fd(grpc_tcp_server* s, unsigned port_index,
                             unsigned fd_index) {
   gpr_mu_lock(&s->mu);
-  grpc_tcp_listener *sp = get_port_index(s, port_index);
+  grpc_tcp_listener* sp = get_port_index(s, port_index);
   for (; sp; sp = sp->sibling, --fd_index) {
     if (fd_index == 0) {
       gpr_mu_unlock(&s->mu);
@@ -482,12 +483,12 @@ int grpc_tcp_server_port_fd(grpc_tcp_server *s, unsigned port_index,
   return -1;
 }
 
-void grpc_tcp_server_start(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s,
-                           grpc_pollset **pollsets, size_t pollset_count,
+void grpc_tcp_server_start(grpc_exec_ctx* exec_ctx, grpc_tcp_server* s,
+                           grpc_pollset** pollsets, size_t pollset_count,
                            grpc_tcp_server_cb on_accept_cb,
-                           void *on_accept_cb_arg) {
+                           void* on_accept_cb_arg) {
   size_t i;
-  grpc_tcp_listener *sp;
+  grpc_tcp_listener* sp;
   GPR_ASSERT(on_accept_cb);
   gpr_mu_lock(&s->mu);
   GPR_ASSERT(!s->on_accept_cb);
@@ -497,7 +498,7 @@ void grpc_tcp_server_start(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s,
   s->pollsets = pollsets;
   s->pollset_count = pollset_count;
   sp = s->head;
-  while (sp != NULL) {
+  while (sp != nullptr) {
     if (s->so_reuseport && !grpc_is_unix_socket(&sp->addr) &&
         pollset_count > 1) {
       GPR_ASSERT(GRPC_LOG_IF_ERROR(
@@ -524,20 +525,20 @@ void grpc_tcp_server_start(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s,
   gpr_mu_unlock(&s->mu);
 }
 
-grpc_tcp_server *grpc_tcp_server_ref(grpc_tcp_server *s) {
+grpc_tcp_server* grpc_tcp_server_ref(grpc_tcp_server* s) {
   gpr_ref_non_zero(&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) {
   gpr_mu_lock(&s->mu);
   grpc_closure_list_append(&s->shutdown_starting, shutdown_starting,
                            GRPC_ERROR_NONE);
   gpr_mu_unlock(&s->mu);
 }
 
-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) {
   if (gpr_unref(&s->refs)) {
     grpc_tcp_server_shutdown_listeners(exec_ctx, s);
     gpr_mu_lock(&s->mu);
@@ -547,13 +548,13 @@ void grpc_tcp_server_unref(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s) {
   }
 }
 
-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) {
   gpr_mu_lock(&s->mu);
   s->shutdown_listeners = true;
   /* shutdown all fd's */
   if (s->active_ports) {
-    grpc_tcp_listener *sp;
+    grpc_tcp_listener* sp;
     for (sp = s->head; sp; sp = sp->next) {
       grpc_fd_shutdown(exec_ctx, sp->emfd,
                        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server shutdown"));