grpc 1.9.1 → 1.10.0.pre1

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

@@ -27,13 +27,14 @@
 #include <sys/types.h>
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/host_port.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
-#include <grpc/support/thd.h>
 #include <grpc/support/time.h>
-#include <grpc/support/useful.h>
+
+#include "src/core/lib/gpr/host_port.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gpr/thd.h"
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/block_annotate.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
@@ -113,14 +114,14 @@ static grpc_error* blocking_resolve_address_impl(
   }
 
   /* Success path: set addrs non-NULL, fill it in */
-  *addresses =
-      (grpc_resolved_addresses*)gpr_malloc(sizeof(grpc_resolved_addresses));
+  *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 = (grpc_resolved_address*)gpr_malloc(
-      sizeof(grpc_resolved_address) * (*addresses)->naddrs);
+  (*addresses)->addrs = static_cast<grpc_resolved_address*>(
+      gpr_malloc(sizeof(grpc_resolved_address) * (*addresses)->naddrs));
   i = 0;
   for (resp = result; resp != nullptr; resp = resp->ai_next) {
     memcpy(&(*addresses)->addrs[i].addr, resp->ai_addr, resp->ai_addrlen);
@@ -154,7 +155,7 @@ typedef struct {
 /* Callback to be passed to grpc_executor to asynch-ify
  * grpc_blocking_resolve_address */
 static void do_request_thread(void* rp, grpc_error* error) {
-  request* r = (request*)rp;
+  request* r = static_cast<request*>(rp);
   GRPC_CLOSURE_SCHED(r->on_done, grpc_blocking_resolve_address(
                                      r->name, r->default_port, r->addrs_out));
   gpr_free(r->name);
@@ -173,7 +174,7 @@ static void resolve_address_impl(const char* name, const char* default_port,
                                  grpc_pollset_set* interested_parties,
                                  grpc_closure* on_done,
                                  grpc_resolved_addresses** addrs) {
-  request* r = (request*)gpr_malloc(sizeof(request));
+  request* r = static_cast<request*>(gpr_malloc(sizeof(request)));
   GRPC_CLOSURE_INIT(&r->request_closure, do_request_thread, r,
                     grpc_executor_scheduler(GRPC_EXECUTOR_SHORT));
   r->name = gpr_strdup(name);

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

@@ -22,11 +22,11 @@
 #include <uv.h>
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/host_port.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
-#include <grpc/support/useful.h>
 
+#include "src/core/lib/gpr/host_port.h"
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"

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

@@ -28,13 +28,14 @@
 #include <sys/types.h>
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/host_port.h>
 #include <grpc/support/log.h>
 #include <grpc/support/log_windows.h>
 #include <grpc/support/string_util.h>
-#include <grpc/support/thd.h>
 #include <grpc/support/time.h>
+
+#include "src/core/lib/gpr/host_port.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gpr/thd.h"
 #include "src/core/lib/iomgr/block_annotate.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"

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

@@ -27,8 +27,8 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
-#include <grpc/support/useful.h>
 
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/combiner.h"
 
 grpc_core::TraceFlag grpc_resource_quota_trace(false, "resource_quota");
@@ -244,7 +244,7 @@ static bool rq_reclaim_from_per_user_free_pool(
 static bool rq_reclaim(grpc_resource_quota* resource_quota, bool destructive);
 
 static void rq_step(void* rq, grpc_error* error) {
-  grpc_resource_quota* resource_quota = (grpc_resource_quota*)rq;
+  grpc_resource_quota* resource_quota = static_cast<grpc_resource_quota*>(rq);
   resource_quota->step_scheduled = false;
   do {
     if (rq_alloc(resource_quota)) goto done;
@@ -303,7 +303,7 @@ static bool rq_alloc(grpc_resource_quota* resource_quota) {
       resource_user->free_pool += aborted_allocations;
       GRPC_CLOSURE_LIST_SCHED(&resource_user->on_allocated);
       gpr_mu_unlock(&resource_user->mu);
-      ru_unref_by(resource_user, (gpr_atm)aborted_allocations);
+      ru_unref_by(resource_user, static_cast<gpr_atm>(aborted_allocations));
       continue;
     }
     if (resource_user->free_pool < 0 &&
@@ -401,12 +401,12 @@ typedef struct {
 } ru_slice_refcount;
 
 static void ru_slice_ref(void* p) {
-  ru_slice_refcount* rc = (ru_slice_refcount*)p;
+  ru_slice_refcount* rc = static_cast<ru_slice_refcount*>(p);
   gpr_ref(&rc->refs);
 }
 
 static void ru_slice_unref(void* p) {
-  ru_slice_refcount* rc = (ru_slice_refcount*)p;
+  ru_slice_refcount* rc = static_cast<ru_slice_refcount*>(p);
   if (gpr_unref(&rc->refs)) {
     grpc_resource_user_free(rc->resource_user, rc->size);
     gpr_free(rc);
@@ -419,8 +419,8 @@ static const grpc_slice_refcount_vtable ru_slice_vtable = {
 
 static grpc_slice ru_slice_create(grpc_resource_user* resource_user,
                                   size_t size) {
-  ru_slice_refcount* rc =
-      (ru_slice_refcount*)gpr_malloc(sizeof(ru_slice_refcount) + size);
+  ru_slice_refcount* rc = static_cast<ru_slice_refcount*>(
+      gpr_malloc(sizeof(ru_slice_refcount) + size));
   rc->base.vtable = &ru_slice_vtable;
   rc->base.sub_refcount = &rc->base;
   gpr_ref_init(&rc->refs, 1);
@@ -428,7 +428,7 @@ static grpc_slice ru_slice_create(grpc_resource_user* resource_user,
   rc->size = size;
   grpc_slice slice;
   slice.refcount = &rc->base;
-  slice.data.refcounted.bytes = (uint8_t*)(rc + 1);
+  slice.data.refcounted.bytes = reinterpret_cast<uint8_t*>(rc + 1);
   slice.data.refcounted.length = size;
   return slice;
 }
@@ -439,7 +439,7 @@ static grpc_slice ru_slice_create(grpc_resource_user* resource_user,
  */
 
 static void ru_allocate(void* ru, grpc_error* error) {
-  grpc_resource_user* resource_user = (grpc_resource_user*)ru;
+  grpc_resource_user* resource_user = static_cast<grpc_resource_user*>(ru);
   if (rulist_empty(resource_user->resource_quota,
                    GRPC_RULIST_AWAITING_ALLOCATION)) {
     rq_step_sched(resource_user->resource_quota);
@@ -448,7 +448,7 @@ static void ru_allocate(void* ru, grpc_error* error) {
 }
 
 static void ru_add_to_free_pool(void* ru, grpc_error* error) {
-  grpc_resource_user* resource_user = (grpc_resource_user*)ru;
+  grpc_resource_user* resource_user = static_cast<grpc_resource_user*>(ru);
   if (!rulist_empty(resource_user->resource_quota,
                     GRPC_RULIST_AWAITING_ALLOCATION) &&
       rulist_empty(resource_user->resource_quota,
@@ -473,7 +473,7 @@ static bool ru_post_reclaimer(grpc_resource_user* resource_user,
 }
 
 static void ru_post_benign_reclaimer(void* ru, grpc_error* error) {
-  grpc_resource_user* resource_user = (grpc_resource_user*)ru;
+  grpc_resource_user* resource_user = static_cast<grpc_resource_user*>(ru);
   if (!ru_post_reclaimer(resource_user, false)) return;
   if (!rulist_empty(resource_user->resource_quota,
                     GRPC_RULIST_AWAITING_ALLOCATION) &&
@@ -487,7 +487,7 @@ static void ru_post_benign_reclaimer(void* ru, grpc_error* error) {
 }
 
 static void ru_post_destructive_reclaimer(void* ru, grpc_error* error) {
-  grpc_resource_user* resource_user = (grpc_resource_user*)ru;
+  grpc_resource_user* resource_user = static_cast<grpc_resource_user*>(ru);
   if (!ru_post_reclaimer(resource_user, true)) return;
   if (!rulist_empty(resource_user->resource_quota,
                     GRPC_RULIST_AWAITING_ALLOCATION) &&
@@ -506,7 +506,7 @@ static void ru_shutdown(void* ru, grpc_error* error) {
   if (grpc_resource_quota_trace.enabled()) {
     gpr_log(GPR_DEBUG, "RU shutdown %p", ru);
   }
-  grpc_resource_user* resource_user = (grpc_resource_user*)ru;
+  grpc_resource_user* resource_user = static_cast<grpc_resource_user*>(ru);
   gpr_mu_lock(&resource_user->mu);
   GRPC_CLOSURE_SCHED(resource_user->reclaimers[0], GRPC_ERROR_CANCELLED);
   GRPC_CLOSURE_SCHED(resource_user->reclaimers[1], GRPC_ERROR_CANCELLED);
@@ -521,10 +521,10 @@ static void ru_shutdown(void* ru, grpc_error* error) {
 }
 
 static void ru_destroy(void* ru, grpc_error* error) {
-  grpc_resource_user* resource_user = (grpc_resource_user*)ru;
+  grpc_resource_user* resource_user = static_cast<grpc_resource_user*>(ru);
   GPR_ASSERT(gpr_atm_no_barrier_load(&resource_user->refs) == 0);
   for (int i = 0; i < GRPC_RULIST_COUNT; i++) {
-    rulist_remove(resource_user, (grpc_rulist)i);
+    rulist_remove(resource_user, static_cast<grpc_rulist>(i));
   }
   GRPC_CLOSURE_SCHED(resource_user->reclaimers[0], GRPC_ERROR_CANCELLED);
   GRPC_CLOSURE_SCHED(resource_user->reclaimers[1], GRPC_ERROR_CANCELLED);
@@ -540,7 +540,7 @@ static void ru_destroy(void* ru, grpc_error* error) {
 
 static void ru_allocated_slices(void* arg, grpc_error* error) {
   grpc_resource_user_slice_allocator* slice_allocator =
-      (grpc_resource_user_slice_allocator*)arg;
+      static_cast<grpc_resource_user_slice_allocator*>(arg);
   if (error == GRPC_ERROR_NONE) {
     for (size_t i = 0; i < slice_allocator->count; i++) {
       grpc_slice_buffer_add_indexed(
@@ -563,7 +563,7 @@ typedef struct {
 } rq_resize_args;
 
 static void rq_resize(void* args, grpc_error* error) {
-  rq_resize_args* a = (rq_resize_args*)args;
+  rq_resize_args* a = static_cast<rq_resize_args*>(args);
   int64_t delta = a->size - a->resource_quota->size;
   a->resource_quota->size += delta;
   a->resource_quota->free_pool += delta;
@@ -574,7 +574,7 @@ static void rq_resize(void* args, grpc_error* error) {
 }
 
 static void rq_reclamation_done(void* rq, grpc_error* error) {
-  grpc_resource_quota* resource_quota = (grpc_resource_quota*)rq;
+  grpc_resource_quota* resource_quota = static_cast<grpc_resource_quota*>(rq);
   resource_quota->reclaiming = false;
   rq_step_sched(resource_quota);
   grpc_resource_quota_unref_internal(resource_quota);
@@ -587,7 +587,7 @@ static void rq_reclamation_done(void* rq, grpc_error* error) {
 /* Public API */
 grpc_resource_quota* grpc_resource_quota_create(const char* name) {
   grpc_resource_quota* resource_quota =
-      (grpc_resource_quota*)gpr_malloc(sizeof(*resource_quota));
+      static_cast<grpc_resource_quota*>(gpr_malloc(sizeof(*resource_quota)));
   gpr_ref_init(&resource_quota->refs, 1);
   resource_quota->combiner = grpc_combiner_create();
   resource_quota->free_pool = INT64_MAX;
@@ -640,18 +640,18 @@ void grpc_resource_quota_ref(grpc_resource_quota* resource_quota) {
 
 double grpc_resource_quota_get_memory_pressure(
     grpc_resource_quota* resource_quota) {
-  return ((double)(gpr_atm_no_barrier_load(
+  return (static_cast<double>(gpr_atm_no_barrier_load(
              &resource_quota->memory_usage_estimation))) /
-         ((double)MEMORY_USAGE_ESTIMATION_MAX);
+         (static_cast<double>(MEMORY_USAGE_ESTIMATION_MAX));
 }
 
 /* Public API */
 void grpc_resource_quota_resize(grpc_resource_quota* resource_quota,
                                 size_t size) {
   grpc_core::ExecCtx exec_ctx;
-  rq_resize_args* a = (rq_resize_args*)gpr_malloc(sizeof(*a));
+  rq_resize_args* a = static_cast<rq_resize_args*>(gpr_malloc(sizeof(*a)));
   a->resource_quota = grpc_resource_quota_ref_internal(resource_quota);
-  a->size = (int64_t)size;
+  a->size = static_cast<int64_t>(size);
   gpr_atm_no_barrier_store(&resource_quota->last_size,
                            (gpr_atm)GPR_MIN((size_t)GPR_ATM_MAX, size));
   GRPC_CLOSURE_INIT(&a->closure, rq_resize, a, grpc_schedule_on_exec_ctx);
@@ -659,7 +659,8 @@ void grpc_resource_quota_resize(grpc_resource_quota* resource_quota,
 }
 
 size_t grpc_resource_quota_peek_size(grpc_resource_quota* resource_quota) {
-  return (size_t)gpr_atm_no_barrier_load(&resource_quota->last_size);
+  return static_cast<size_t>(
+      gpr_atm_no_barrier_load(&resource_quota->last_size));
 }
 
 /*******************************************************************************
@@ -672,7 +673,8 @@ grpc_resource_quota* grpc_resource_quota_from_channel_args(
     if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_RESOURCE_QUOTA)) {
       if (channel_args->args[i].type == GRPC_ARG_POINTER) {
         return grpc_resource_quota_ref_internal(
-            (grpc_resource_quota*)channel_args->args[i].value.pointer.p);
+            static_cast<grpc_resource_quota*>(
+                channel_args->args[i].value.pointer.p));
       } else {
         gpr_log(GPR_DEBUG, GRPC_ARG_RESOURCE_QUOTA " should be a pointer");
       }
@@ -682,12 +684,12 @@ grpc_resource_quota* grpc_resource_quota_from_channel_args(
 }
 
 static void* rq_copy(void* rq) {
-  grpc_resource_quota_ref((grpc_resource_quota*)rq);
+  grpc_resource_quota_ref(static_cast<grpc_resource_quota*>(rq));
   return rq;
 }
 
 static void rq_destroy(void* rq) {
-  grpc_resource_quota_unref_internal((grpc_resource_quota*)rq);
+  grpc_resource_quota_unref_internal(static_cast<grpc_resource_quota*>(rq));
 }
 
 static int rq_cmp(void* a, void* b) { return GPR_ICMP(a, b); }
@@ -704,7 +706,7 @@ const grpc_arg_pointer_vtable* grpc_resource_quota_arg_vtable(void) {
 grpc_resource_user* grpc_resource_user_create(
     grpc_resource_quota* resource_quota, const char* name) {
   grpc_resource_user* resource_user =
-      (grpc_resource_user*)gpr_malloc(sizeof(*resource_user));
+      static_cast<grpc_resource_user*>(gpr_malloc(sizeof(*resource_user)));
   resource_user->resource_quota =
       grpc_resource_quota_ref_internal(resource_quota);
   GRPC_CLOSURE_INIT(&resource_user->allocate_closure, &ru_allocate,
@@ -785,9 +787,9 @@ void grpc_resource_user_shutdown(grpc_resource_user* resource_user) {
 void grpc_resource_user_alloc(grpc_resource_user* resource_user, size_t size,
                               grpc_closure* optional_on_done) {
   gpr_mu_lock(&resource_user->mu);
-  ru_ref_by(resource_user, (gpr_atm)size);
-  resource_user->free_pool -= (int64_t)size;
-  resource_user->outstanding_allocations += (int64_t)size;
+  ru_ref_by(resource_user, static_cast<gpr_atm>(size));
+  resource_user->free_pool -= static_cast<int64_t>(size);
+  resource_user->outstanding_allocations += static_cast<int64_t>(size);
   if (grpc_resource_quota_trace.enabled()) {
     gpr_log(GPR_DEBUG, "RQ %s %s: alloc %" PRIdPTR "; free_pool -> %" PRId64,
             resource_user->resource_quota->name, resource_user->name, size,
@@ -801,7 +803,7 @@ void grpc_resource_user_alloc(grpc_resource_user* resource_user, size_t size,
       GRPC_CLOSURE_SCHED(&resource_user->allocate_closure, GRPC_ERROR_NONE);
     }
   } else {
-    resource_user->outstanding_allocations -= (int64_t)size;
+    resource_user->outstanding_allocations -= static_cast<int64_t>(size);
     GRPC_CLOSURE_SCHED(optional_on_done, GRPC_ERROR_NONE);
   }
   gpr_mu_unlock(&resource_user->mu);
@@ -810,7 +812,7 @@ void grpc_resource_user_alloc(grpc_resource_user* resource_user, size_t size,
 void grpc_resource_user_free(grpc_resource_user* resource_user, size_t size) {
   gpr_mu_lock(&resource_user->mu);
   bool was_zero_or_negative = resource_user->free_pool <= 0;
-  resource_user->free_pool += (int64_t)size;
+  resource_user->free_pool += static_cast<int64_t>(size);
   if (grpc_resource_quota_trace.enabled()) {
     gpr_log(GPR_DEBUG, "RQ %s %s: free %" PRIdPTR "; free_pool -> %" PRId64,
             resource_user->resource_quota->name, resource_user->name, size,
@@ -824,7 +826,7 @@ void grpc_resource_user_free(grpc_resource_user* resource_user, size_t size) {
                        GRPC_ERROR_NONE);
   }
   gpr_mu_unlock(&resource_user->mu);
-  ru_unref_by(resource_user, (gpr_atm)size);
+  ru_unref_by(resource_user, static_cast<gpr_atm>(size));
 }
 
 void grpc_resource_user_post_reclaimer(grpc_resource_user* resource_user,

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

@@ -23,11 +23,11 @@
 #include <string.h>
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/host_port.h>
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
+#include "src/core/lib/gpr/host_port.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
@@ -39,13 +39,15 @@ static const uint8_t kV4MappedPrefix[] = {0, 0, 0, 0, 0,    0,
 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;
+  const struct sockaddr* addr =
+      reinterpret_cast<const struct sockaddr*>(resolved_addr->addr);
   struct sockaddr_in* addr4_out =
       resolved_addr4_out == nullptr
           ? nullptr
-          : (struct sockaddr_in*)resolved_addr4_out->addr;
+          : reinterpret_cast<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 =
+        reinterpret_cast<const struct sockaddr_in6*>(addr);
     if (memcmp(addr6->sin6_addr.s6_addr, kV4MappedPrefix,
                sizeof(kV4MappedPrefix)) == 0) {
       if (resolved_addr4_out != nullptr) {
@@ -66,11 +68,13 @@ int grpc_sockaddr_is_v4mapped(const grpc_resolved_address* resolved_addr,
 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;
+  const struct sockaddr* addr =
+      reinterpret_cast<const struct sockaddr*>(resolved_addr->addr);
   struct sockaddr_in6* addr6_out =
-      (struct sockaddr_in6*)resolved_addr6_out->addr;
+      reinterpret_cast<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 =
+        reinterpret_cast<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);
@@ -89,10 +93,11 @@ int grpc_sockaddr_is_wildcard(const grpc_resolved_address* resolved_addr,
   if (grpc_sockaddr_is_v4mapped(resolved_addr, &addr4_normalized)) {
     resolved_addr = &addr4_normalized;
   }
-  addr = (const struct sockaddr*)resolved_addr->addr;
+  addr = reinterpret_cast<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 =
+        reinterpret_cast<const struct sockaddr_in*>(addr);
     if (addr4->sin_addr.s_addr != 0) {
       return 0;
     }
@@ -100,7 +105,8 @@ 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 =
+        reinterpret_cast<const struct sockaddr_in6*>(addr);
     int i;
     for (i = 0; i < 16; i++) {
       if (addr6->sin6_addr.s6_addr[i] != 0) {
@@ -122,21 +128,23 @@ void grpc_sockaddr_make_wildcards(int port, grpc_resolved_address* wild4_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;
+  struct sockaddr_in* wild_out =
+      reinterpret_cast<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;
-  wild_out->sin_port = htons((uint16_t)port);
+  wild_out->sin_port = htons(static_cast<uint16_t>(port));
   resolved_wild_out->len = sizeof(struct sockaddr_in);
 }
 
 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;
+  struct sockaddr_in6* wild_out =
+      reinterpret_cast<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;
-  wild_out->sin6_port = htons((uint16_t)port);
+  wild_out->sin6_port = htons(static_cast<uint16_t>(port));
   resolved_wild_out->len = sizeof(struct sockaddr_in6);
 }
 
@@ -156,13 +164,15 @@ int grpc_sockaddr_to_string(char** out,
   if (normalize && grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
     resolved_addr = &addr_normalized;
   }
-  addr = (const struct sockaddr*)resolved_addr->addr;
+  addr = reinterpret_cast<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 =
+        reinterpret_cast<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 =
+        reinterpret_cast<const struct sockaddr_in6*>(addr);
     ip = &addr6->sin6_addr;
     port = ntohs(addr6->sin6_port);
     sin6_scope_id = addr6->sin6_scope_id;
@@ -208,7 +218,8 @@ char* grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
 
 const char* grpc_sockaddr_get_uri_scheme(
     const grpc_resolved_address* resolved_addr) {
-  const struct sockaddr* addr = (const struct sockaddr*)resolved_addr->addr;
+  const struct sockaddr* addr =
+      reinterpret_cast<const struct sockaddr*>(resolved_addr->addr);
   switch (addr->sa_family) {
     case AF_INET:
       return "ipv4";
@@ -221,12 +232,14 @@ const char* grpc_sockaddr_get_uri_scheme(
 }
 
 int grpc_sockaddr_get_family(const grpc_resolved_address* resolved_addr) {
-  const struct sockaddr* addr = (const struct sockaddr*)resolved_addr->addr;
+  const struct sockaddr* addr =
+      reinterpret_cast<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;
+  const struct sockaddr* addr =
+      reinterpret_cast<const struct sockaddr*>(resolved_addr->addr);
   switch (addr->sa_family) {
     case AF_INET:
       return ntohs(((struct sockaddr_in*)addr)->sin_port);
@@ -244,15 +257,18 @@ int grpc_sockaddr_get_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 =
+      reinterpret_cast<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(static_cast<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(static_cast<uint16_t>(port));
       return 1;
     default:
       gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_set_port",