grpc 1.7.3-x86-mingw32 → 1.8.0-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20f3488022488d631f2efe2316d3c5398af55518a46e9be668ba6b296325e28f
-  data.tar.gz: ee596e0d6d8b05243aa2ae1ce0e2194dbceeab5054e6ce68ea59be706260cf72
+  metadata.gz: 8d8bde7d8aa007e4952168772e4c3574a962b58acab89add7dfeeb92a9526e65
+  data.tar.gz: c02ee07f4bb40e13a9c5a489469ed188d1da3d4bc8f4c2a4a58664d8b7d924a3
 SHA512:
-  metadata.gz: 22ca53ea5a3ef93c31143860e178cc651e34a698bb3c14e43114f7c2f2c92dbde9827f3bd533ca59779edfec574eb2d34274e503d631d5b7a8910ebaba684a1a
-  data.tar.gz: cb99f0f56ccf744407edf0717727c4587c4b51d4332c5557e0adbd6d5c61a39c6e579c4a96c4049e6bf3b764b4d68a50f4c1d5c9806687cac8320e6d916ea328
+  metadata.gz: 84ff3fd188e1482dcd52df44755cd68add98331906b863c520c119b19494e7c2cc33e296d529f3e6af2464f366ffb79078b037b1301035e2bad2495f82a23e61
+  data.tar.gz: 12bc9d861407ea3b5b74c992ce1b17307e4fc93c11d04d08396a256d3927e18dd4bf788f6235102a498b299dfb278a618318a4a81daf9af6949487de0722f8e1

data/src/ruby/ext/grpc/extconf.rb

@@ -41,6 +41,7 @@ LIB_DIRS = [
 ]
 
 windows = RUBY_PLATFORM =~ /mingw|mswin/
+bsd = RUBY_PLATFORM =~ /bsd/
 
 grpc_root = File.expand_path(File.join(File.dirname(__FILE__), '../../../..'))
 
@@ -60,7 +61,7 @@ ENV['EMBED_ZLIB'] = 'true'
 ENV['EMBED_CARES'] = 'true'
 ENV['ARCH_FLAGS'] = RbConfig::CONFIG['ARCH_FLAG']
 ENV['ARCH_FLAGS'] = '-arch i386 -arch x86_64' if RUBY_PLATFORM =~ /darwin/
-ENV['CFLAGS'] = '-DGPR_BACKWARDS_COMPATIBILITY_MODE'
+ENV['CPPFLAGS'] = '-DGPR_BACKWARDS_COMPATIBILITY_MODE'
 
 output_dir = File.expand_path(RbConfig::CONFIG['topdir'])
 grpc_lib_dir = File.join(output_dir, 'libs', grpc_config)
@@ -70,7 +71,8 @@ unless windows
   puts 'Building internal gRPC into ' + grpc_lib_dir
   nproc = 4
   nproc = Etc.nprocessors * 2 if Etc.respond_to? :nprocessors
-  system("make -j#{nproc} -C #{grpc_root} #{grpc_lib_dir}/libgrpc.a CONFIG=#{grpc_config} Q=")
+  make = bsd ? 'gmake' : 'make'
+  system("#{make} -j#{nproc} -C #{grpc_root} #{grpc_lib_dir}/libgrpc.a CONFIG=#{grpc_config} Q=")
   exit 1 unless $? == 0
 end
 

data/src/ruby/ext/grpc/rb_byte_buffer.c

@@ -26,14 +26,14 @@
 #include <grpc/slice.h>
 #include "rb_grpc.h"
 
-grpc_byte_buffer *grpc_rb_s_to_byte_buffer(char *string, size_t length) {
+grpc_byte_buffer* grpc_rb_s_to_byte_buffer(char* string, size_t length) {
   grpc_slice slice = grpc_slice_from_copied_buffer(string, length);
-  grpc_byte_buffer *buffer = grpc_raw_byte_buffer_create(&slice, 1);
+  grpc_byte_buffer* buffer = grpc_raw_byte_buffer_create(&slice, 1);
   grpc_slice_unref(slice);
   return buffer;
 }
 
-VALUE grpc_rb_byte_buffer_to_s(grpc_byte_buffer *buffer) {
+VALUE grpc_rb_byte_buffer_to_s(grpc_byte_buffer* buffer) {
   VALUE rb_string;
   grpc_byte_buffer_reader reader;
   grpc_slice next;
@@ -46,7 +46,7 @@ VALUE grpc_rb_byte_buffer_to_s(grpc_byte_buffer *buffer) {
     return Qnil;
   }
   while (grpc_byte_buffer_reader_next(&reader, &next) != 0) {
-    rb_str_cat(rb_string, (const char *)GRPC_SLICE_START_PTR(next),
+    rb_str_cat(rb_string, (const char*)GRPC_SLICE_START_PTR(next),
                GRPC_SLICE_LENGTH(next));
     grpc_slice_unref(next);
   }
@@ -59,6 +59,6 @@ VALUE grpc_rb_slice_to_ruby_string(grpc_slice slice) {
     rb_raise(rb_eRuntimeError,
              "attempt to convert uninitialized grpc_slice to ruby string");
   }
-  return rb_str_new((char *)GRPC_SLICE_START_PTR(slice),
+  return rb_str_new((char*)GRPC_SLICE_START_PTR(slice),
                     GRPC_SLICE_LENGTH(slice));
 }

data/src/ruby/ext/grpc/rb_byte_buffer.h

@@ -24,10 +24,10 @@
 #include <grpc/grpc.h>
 
 /* Converts a char* with a length to a grpc_byte_buffer */
-grpc_byte_buffer *grpc_rb_s_to_byte_buffer(char *string, size_t length);
+grpc_byte_buffer* grpc_rb_s_to_byte_buffer(char* string, size_t length);
 
 /* Converts a grpc_byte_buffer to a ruby string */
-VALUE grpc_rb_byte_buffer_to_s(grpc_byte_buffer *buffer);
+VALUE grpc_rb_byte_buffer_to_s(grpc_byte_buffer* buffer);
 
 /* Converts a grpc_slice to a ruby string */
 VALUE grpc_rb_slice_to_ruby_string(grpc_slice slice);

data/src/ruby/ext/grpc/rb_call.c

@@ -24,7 +24,6 @@
 #include <grpc/grpc.h>
 #include <grpc/impl/codegen/compression_types.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "rb_byte_buffer.h"
@@ -81,11 +80,11 @@ static VALUE sym_status;
 static VALUE sym_cancelled;
 
 typedef struct grpc_rb_call {
-  grpc_call *wrapped;
-  grpc_completion_queue *queue;
+  grpc_call* wrapped;
+  grpc_completion_queue* queue;
 } grpc_rb_call;
 
-static void destroy_call(grpc_rb_call *call) {
+static void destroy_call(grpc_rb_call* call) {
   /* Ensure that we only try to destroy the call once */
   if (call->wrapped != NULL) {
     grpc_call_unref(call->wrapped);
@@ -96,19 +95,19 @@ static void destroy_call(grpc_rb_call *call) {
 }
 
 /* Destroys a Call. */
-static void grpc_rb_call_destroy(void *p) {
+static void grpc_rb_call_destroy(void* p) {
   if (p == NULL) {
     return;
   }
-  destroy_call((grpc_rb_call *)p);
+  destroy_call((grpc_rb_call*)p);
   xfree(p);
 }
 
-static size_t md_ary_datasize(const void *p) {
-  const grpc_metadata_array *const ary = (grpc_metadata_array *)p;
+static size_t md_ary_datasize(const void* p) {
+  const grpc_metadata_array* const ary = (grpc_metadata_array*)p;
   size_t i, datasize = sizeof(grpc_metadata_array);
   for (i = 0; i < ary->count; ++i) {
-    const grpc_metadata *const md = &ary->metadata[i];
+    const grpc_metadata* const md = &ary->metadata[i];
     datasize += GRPC_SLICE_LENGTH(md->key);
     datasize += GRPC_SLICE_LENGTH(md->value);
   }
@@ -151,9 +150,9 @@ static const rb_data_type_t grpc_call_data_type = {"grpc_call",
 VALUE rb_error_code_details;
 
 /* Obtains the error detail string for given error code */
-const char *grpc_call_error_detail_of(grpc_call_error err) {
+const char* grpc_call_error_detail_of(grpc_call_error err) {
   VALUE detail_ref = rb_hash_aref(rb_error_code_details, UINT2NUM(err));
-  const char *detail = "unknown error code!";
+  const char* detail = "unknown error code!";
   if (detail_ref != Qnil) {
     detail = StringValueCStr(detail_ref);
   }
@@ -163,7 +162,7 @@ const char *grpc_call_error_detail_of(grpc_call_error err) {
 /* Called by clients to cancel an RPC on the server.
    Can be called multiple times, from any thread. */
 static VALUE grpc_rb_call_cancel(VALUE self) {
-  grpc_rb_call *call = NULL;
+  grpc_rb_call* call = NULL;
   grpc_call_error err;
   if (RTYPEDDATA_DATA(self) == NULL) {
     // This call has been closed
@@ -187,7 +186,7 @@ static VALUE grpc_rb_call_cancel(VALUE self) {
  * message. */
 static VALUE grpc_rb_call_cancel_with_status(VALUE self, VALUE status_code,
                                              VALUE details) {
-  grpc_rb_call *call = NULL;
+  grpc_rb_call* call = NULL;
   grpc_call_error err;
   if (RTYPEDDATA_DATA(self) == NULL) {
     // This call has been closed
@@ -217,7 +216,7 @@ static VALUE grpc_rb_call_cancel_with_status(VALUE self, VALUE status_code,
    processed.
 */
 static VALUE grpc_rb_call_close(VALUE self) {
-  grpc_rb_call *call = NULL;
+  grpc_rb_call* call = NULL;
   TypedData_Get_Struct(self, grpc_rb_call, &grpc_call_data_type, call);
   if (call != NULL) {
     destroy_call(call);
@@ -230,8 +229,8 @@ static VALUE grpc_rb_call_close(VALUE self) {
 /* Called to obtain the peer that this call is connected to. */
 static VALUE grpc_rb_call_get_peer(VALUE self) {
   VALUE res = Qnil;
-  grpc_rb_call *call = NULL;
-  char *peer = NULL;
+  grpc_rb_call* call = NULL;
+  char* peer = NULL;
   if (RTYPEDDATA_DATA(self) == NULL) {
     rb_raise(grpc_rb_eCallError, "Cannot get peer value on closed call");
     return Qnil;
@@ -246,9 +245,9 @@ static VALUE grpc_rb_call_get_peer(VALUE self) {
 
 /* Called to obtain the x509 cert of an authenticated peer. */
 static VALUE grpc_rb_call_get_peer_cert(VALUE self) {
-  grpc_rb_call *call = NULL;
+  grpc_rb_call* call = NULL;
   VALUE res = Qnil;
-  grpc_auth_context *ctx = NULL;
+  grpc_auth_context* ctx = NULL;
   if (RTYPEDDATA_DATA(self) == NULL) {
     rb_raise(grpc_rb_eCallError, "Cannot get peer cert on closed call");
     return Qnil;
@@ -264,7 +263,7 @@ static VALUE grpc_rb_call_get_peer_cert(VALUE self) {
   {
     grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name(
         ctx, GRPC_X509_PEM_CERT_PROPERTY_NAME);
-    const grpc_auth_property *prop = grpc_auth_property_iterator_next(&it);
+    const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it);
     if (prop == NULL) {
       return Qnil;
     }
@@ -379,8 +378,8 @@ static VALUE grpc_rb_call_set_write_flag(VALUE self, VALUE write_flag) {
 
   Sets credentials on a call */
 static VALUE grpc_rb_call_set_credentials(VALUE self, VALUE credentials) {
-  grpc_rb_call *call = NULL;
-  grpc_call_credentials *creds;
+  grpc_rb_call* call = NULL;
+  grpc_call_credentials* creds;
   grpc_call_error err;
   if (RTYPEDDATA_DATA(self) == NULL) {
     rb_raise(grpc_rb_eCallError, "Cannot set credentials of closed call");
@@ -407,12 +406,12 @@ static VALUE grpc_rb_call_set_credentials(VALUE self, VALUE credentials) {
    grpc_rb_md_ary_capacity_hash_cb
 */
 static int grpc_rb_md_ary_fill_hash_cb(VALUE key, VALUE val, VALUE md_ary_obj) {
-  grpc_metadata_array *md_ary = NULL;
+  grpc_metadata_array* md_ary = NULL;
   long array_length;
   long i;
   grpc_slice key_slice;
   grpc_slice value_slice;
-  char *tmp_str = NULL;
+  char* tmp_str = NULL;
 
   if (TYPE(key) == T_SYMBOL) {
     key_slice = grpc_slice_from_static_string(rb_id2name(SYM2ID(key)));
@@ -482,7 +481,7 @@ static int grpc_rb_md_ary_fill_hash_cb(VALUE key, VALUE val, VALUE md_ary_obj) {
 */
 static int grpc_rb_md_ary_capacity_hash_cb(VALUE key, VALUE val,
                                            VALUE md_ary_obj) {
-  grpc_metadata_array *md_ary = NULL;
+  grpc_metadata_array* md_ary = NULL;
 
   (void)key;
 
@@ -503,7 +502,7 @@ static int grpc_rb_md_ary_capacity_hash_cb(VALUE key, VALUE val,
 /* grpc_rb_md_ary_convert converts a ruby metadata hash into
    a grpc_metadata_array.
 */
-void grpc_rb_md_ary_convert(VALUE md_ary_hash, grpc_metadata_array *md_ary) {
+void grpc_rb_md_ary_convert(VALUE md_ary_hash, grpc_metadata_array* md_ary) {
   VALUE md_ary_obj = Qnil;
   if (md_ary_hash == Qnil) {
     return; /* Do nothing if the expected has value is nil */
@@ -524,7 +523,7 @@ void grpc_rb_md_ary_convert(VALUE md_ary_hash, grpc_metadata_array *md_ary) {
 }
 
 /* Converts a metadata array to a hash. */
-VALUE grpc_rb_md_ary_to_h(grpc_metadata_array *md_ary) {
+VALUE grpc_rb_md_ary_to_h(grpc_metadata_array* md_ary) {
   VALUE key = Qnil;
   VALUE new_ary = Qnil;
   VALUE value = Qnil;
@@ -587,7 +586,7 @@ static int grpc_rb_call_check_op_keys_hash_cb(VALUE key, VALUE val,
    struct to the 'send_status_from_server' portion of an op.
 */
 static void grpc_rb_op_update_status_from_server(
-    grpc_op *op, grpc_metadata_array *md_ary, grpc_slice *send_status_details,
+    grpc_op* op, grpc_metadata_array* md_ary, grpc_slice* send_status_details,
     VALUE status) {
   VALUE code = rb_struct_aref(status, sym_code);
   VALUE details = rb_struct_aref(status, sym_details);
@@ -627,7 +626,7 @@ typedef struct run_batch_stack {
   grpc_metadata_array send_trailing_metadata;
 
   /* Data being received */
-  grpc_byte_buffer *recv_message;
+  grpc_byte_buffer* recv_message;
   grpc_metadata_array recv_metadata;
   grpc_metadata_array recv_trailing_metadata;
   int recv_cancelled;
@@ -639,7 +638,7 @@ typedef struct run_batch_stack {
 
 /* grpc_run_batch_stack_init ensures the run_batch_stack is properly
  * initialized */
-static void grpc_run_batch_stack_init(run_batch_stack *st,
+static void grpc_run_batch_stack_init(run_batch_stack* st,
                                       unsigned write_flag) {
   MEMZERO(st, run_batch_stack, 1);
   grpc_metadata_array_init(&st->send_metadata);
@@ -651,7 +650,7 @@ static void grpc_run_batch_stack_init(run_batch_stack *st,
 }
 
 void grpc_rb_metadata_array_destroy_including_entries(
-    grpc_metadata_array *array) {
+    grpc_metadata_array* array) {
   size_t i;
   if (array->metadata) {
     for (i = 0; i < array->count; i++) {
@@ -664,7 +663,7 @@ void grpc_rb_metadata_array_destroy_including_entries(
 
 /* grpc_run_batch_stack_cleanup ensures the run_batch_stack is properly
  * cleaned up */
-static void grpc_run_batch_stack_cleanup(run_batch_stack *st) {
+static void grpc_run_batch_stack_cleanup(run_batch_stack* st) {
   size_t i = 0;
 
   grpc_rb_metadata_array_destroy_including_entries(&st->send_metadata);
@@ -693,7 +692,7 @@ static void grpc_run_batch_stack_cleanup(run_batch_stack *st) {
 
 /* grpc_run_batch_stack_fill_ops fills the run_batch_stack ops array from
  * ops_hash */
-static void grpc_run_batch_stack_fill_ops(run_batch_stack *st, VALUE ops_hash) {
+static void grpc_run_batch_stack_fill_ops(run_batch_stack* st, VALUE ops_hash) {
   VALUE this_op = Qnil;
   VALUE this_value = Qnil;
   VALUE ops_ary = rb_ary_new();
@@ -760,7 +759,7 @@ static void grpc_run_batch_stack_fill_ops(run_batch_stack *st, VALUE ops_hash) {
 
 /* grpc_run_batch_stack_build_result fills constructs a ruby BatchResult struct
    after the results have run */
-static VALUE grpc_run_batch_stack_build_result(run_batch_stack *st) {
+static VALUE grpc_run_batch_stack_build_result(run_batch_stack* st) {
   size_t i = 0;
   VALUE result = rb_struct_new(grpc_rb_sBatchResult, Qnil, Qnil, Qnil, Qnil,
                                Qnil, Qnil, Qnil, Qnil, NULL);
@@ -823,14 +822,14 @@ static VALUE grpc_run_batch_stack_build_result(run_batch_stack *st) {
    Only one operation of each type can be active at once in any given
    batch */
 static VALUE grpc_rb_call_run_batch(VALUE self, VALUE ops_hash) {
-  run_batch_stack *st = NULL;
-  grpc_rb_call *call = NULL;
+  run_batch_stack* st = NULL;
+  grpc_rb_call* call = NULL;
   grpc_event ev;
   grpc_call_error err;
   VALUE result = Qnil;
   VALUE rb_write_flag = rb_ivar_get(self, id_write_flag);
   unsigned write_flag = 0;
-  void *tag = (void *)&st;
+  void* tag = (void*)&st;
 
   if (RTYPEDDATA_DATA(self) == NULL) {
     rb_raise(grpc_rb_eCallError, "Cannot run batch on closed call");
@@ -997,8 +996,8 @@ void Init_grpc_call() {
   rb_define_method(grpc_rb_cCall, "metadata=", grpc_rb_call_set_metadata, 1);
   rb_define_method(grpc_rb_cCall, "trailing_metadata",
                    grpc_rb_call_get_trailing_metadata, 0);
-  rb_define_method(grpc_rb_cCall, "trailing_metadata=",
-                   grpc_rb_call_set_trailing_metadata, 1);
+  rb_define_method(grpc_rb_cCall,
+                   "trailing_metadata=", grpc_rb_call_set_trailing_metadata, 1);
   rb_define_method(grpc_rb_cCall, "write_flag", grpc_rb_call_get_write_flag, 0);
   rb_define_method(grpc_rb_cCall, "write_flag=", grpc_rb_call_set_write_flag,
                    1);
@@ -1035,15 +1034,15 @@ void Init_grpc_call() {
 }
 
 /* Gets the call from the ruby object */
-grpc_call *grpc_rb_get_wrapped_call(VALUE v) {
-  grpc_rb_call *call = NULL;
+grpc_call* grpc_rb_get_wrapped_call(VALUE v) {
+  grpc_rb_call* call = NULL;
   TypedData_Get_Struct(v, grpc_rb_call, &grpc_call_data_type, call);
   return call->wrapped;
 }
 
 /* Obtains the wrapped object for a given call */
-VALUE grpc_rb_wrap_call(grpc_call *c, grpc_completion_queue *q) {
-  grpc_rb_call *wrapper;
+VALUE grpc_rb_wrap_call(grpc_call* c, grpc_completion_queue* q) {
+  grpc_rb_call* wrapper;
   if (c == NULL || q == NULL) {
     return Qnil;
   }

data/src/ruby/ext/grpc/rb_call.h

@@ -24,24 +24,24 @@
 #include <grpc/grpc.h>
 
 /* Gets the wrapped call from a VALUE. */
-grpc_call *grpc_rb_get_wrapped_call(VALUE v);
+grpc_call* grpc_rb_get_wrapped_call(VALUE v);
 
 /* Gets the VALUE corresponding to given grpc_call. */
-VALUE grpc_rb_wrap_call(grpc_call *c, grpc_completion_queue *q);
+VALUE grpc_rb_wrap_call(grpc_call* c, grpc_completion_queue* q);
 
 /* Provides the details of an call error */
-const char *grpc_call_error_detail_of(grpc_call_error err);
+const char* grpc_call_error_detail_of(grpc_call_error err);
 
 /* Converts a metadata array to a hash. */
-VALUE grpc_rb_md_ary_to_h(grpc_metadata_array *md_ary);
+VALUE grpc_rb_md_ary_to_h(grpc_metadata_array* md_ary);
 
 /* grpc_rb_md_ary_convert converts a ruby metadata hash into
    a grpc_metadata_array.
 */
-void grpc_rb_md_ary_convert(VALUE md_ary_hash, grpc_metadata_array *md_ary);
+void grpc_rb_md_ary_convert(VALUE md_ary_hash, grpc_metadata_array* md_ary);
 
 void grpc_rb_metadata_array_destroy_including_entries(
-    grpc_metadata_array *md_ary);
+    grpc_metadata_array* md_ary);
 
 /* grpc_rb_eCallError is the ruby class of the exception thrown during call
    operations. */

data/src/ruby/ext/grpc/rb_call_credentials.c

@@ -44,13 +44,13 @@ typedef struct grpc_rb_call_credentials {
   VALUE mark;
 
   /* The actual credentials */
-  grpc_call_credentials *wrapped;
+  grpc_call_credentials* wrapped;
 } grpc_rb_call_credentials;
 
 typedef struct callback_params {
   VALUE get_metadata;
   grpc_auth_metadata_context context;
-  void *user_data;
+  void* user_data;
   grpc_credentials_plugin_metadata_cb callback;
 } callback_params;
 
@@ -82,8 +82,8 @@ static VALUE grpc_rb_call_credentials_callback_rescue(VALUE args,
   return result;
 }
 
-static void grpc_rb_call_credentials_callback_with_gil(void *param) {
-  callback_params *const params = (callback_params *)param;
+static void grpc_rb_call_credentials_callback_with_gil(void* param) {
+  callback_params* const params = (callback_params*)param;
   VALUE auth_uri = rb_str_new_cstr(params->context.service_url);
   /* Pass the arguments to the proc in a hash, which currently only has they key
      'auth_uri' */
@@ -93,7 +93,7 @@ static void grpc_rb_call_credentials_callback_with_gil(void *param) {
   grpc_metadata_array md_ary;
   grpc_status_code status;
   VALUE details;
-  char *error_details;
+  char* error_details;
   grpc_metadata_array_init(&md_ary);
   rb_hash_aset(args, ID2SYM(rb_intern("jwt_aud_uri")), auth_uri);
   rb_ary_push(callback_args, params->get_metadata);
@@ -113,34 +113,34 @@ static void grpc_rb_call_credentials_callback_with_gil(void *param) {
 }
 
 static int grpc_rb_call_credentials_plugin_get_metadata(
-    void *state, grpc_auth_metadata_context context,
-    grpc_credentials_plugin_metadata_cb cb, void *user_data,
+    void* state, grpc_auth_metadata_context context,
+    grpc_credentials_plugin_metadata_cb cb, void* user_data,
     grpc_metadata creds_md[GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX],
-    size_t *num_creds_md, grpc_status_code *status,
-    const char **error_details) {
-  callback_params *params = gpr_malloc(sizeof(callback_params));
+    size_t* num_creds_md, grpc_status_code* status,
+    const char** error_details) {
+  callback_params* params = gpr_malloc(sizeof(callback_params));
   params->get_metadata = (VALUE)state;
   params->context = context;
   params->user_data = user_data;
   params->callback = cb;
 
   grpc_rb_event_queue_enqueue(grpc_rb_call_credentials_callback_with_gil,
-                              (void *)(params));
+                              (void*)(params));
   return 0;  // Async return.
 }
 
-static void grpc_rb_call_credentials_plugin_destroy(void *state) {
+static void grpc_rb_call_credentials_plugin_destroy(void* state) {
   (void)state;
   // Not sure what needs to be done here
 }
 
 /* Destroys the credentials instances. */
-static void grpc_rb_call_credentials_free(void *p) {
-  grpc_rb_call_credentials *wrapper;
+static void grpc_rb_call_credentials_free(void* p) {
+  grpc_rb_call_credentials* wrapper;
   if (p == NULL) {
     return;
   }
-  wrapper = (grpc_rb_call_credentials *)p;
+  wrapper = (grpc_rb_call_credentials*)p;
   grpc_call_credentials_release(wrapper->wrapped);
   wrapper->wrapped = NULL;
 
@@ -148,12 +148,12 @@ static void grpc_rb_call_credentials_free(void *p) {
 }
 
 /* Protects the mark object from GC */
-static void grpc_rb_call_credentials_mark(void *p) {
-  grpc_rb_call_credentials *wrapper = NULL;
+static void grpc_rb_call_credentials_mark(void* p) {
+  grpc_rb_call_credentials* wrapper = NULL;
   if (p == NULL) {
     return;
   }
-  wrapper = (grpc_rb_call_credentials *)p;
+  wrapper = (grpc_rb_call_credentials*)p;
   if (wrapper->mark != Qnil) {
     rb_gc_mark(wrapper->mark);
   }
@@ -175,7 +175,7 @@ static rb_data_type_t grpc_rb_call_credentials_data_type = {
 /* Allocates CallCredentials instances.
    Provides safe initial defaults for the instance fields. */
 static VALUE grpc_rb_call_credentials_alloc(VALUE cls) {
-  grpc_rb_call_credentials *wrapper = ALLOC(grpc_rb_call_credentials);
+  grpc_rb_call_credentials* wrapper = ALLOC(grpc_rb_call_credentials);
   wrapper->wrapped = NULL;
   wrapper->mark = Qnil;
   return TypedData_Wrap_Struct(cls, &grpc_rb_call_credentials_data_type,
@@ -185,9 +185,9 @@ static VALUE grpc_rb_call_credentials_alloc(VALUE cls) {
 /* Creates a wrapping object for a given call credentials. This should only be
  * called with grpc_call_credentials objects that are not already associated
  * with any Ruby object */
-VALUE grpc_rb_wrap_call_credentials(grpc_call_credentials *c, VALUE mark) {
+VALUE grpc_rb_wrap_call_credentials(grpc_call_credentials* c, VALUE mark) {
   VALUE rb_wrapper;
-  grpc_rb_call_credentials *wrapper;
+  grpc_rb_call_credentials* wrapper;
   if (c == NULL) {
     return Qnil;
   }
@@ -208,8 +208,8 @@ static ID id_callback;
   proc: (required) Proc that generates auth metadata
   Initializes CallCredential instances. */
 static VALUE grpc_rb_call_credentials_init(VALUE self, VALUE proc) {
-  grpc_rb_call_credentials *wrapper = NULL;
-  grpc_call_credentials *creds = NULL;
+  grpc_rb_call_credentials* wrapper = NULL;
+  grpc_call_credentials* creds = NULL;
   grpc_metadata_credentials_plugin plugin;
 
   grpc_ruby_once_init();
@@ -223,7 +223,7 @@ static VALUE grpc_rb_call_credentials_init(VALUE self, VALUE proc) {
     rb_raise(rb_eTypeError, "Argument to CallCredentials#new must be a proc");
     return Qnil;
   }
-  plugin.state = (void *)proc;
+  plugin.state = (void*)proc;
   plugin.type = "";
 
   creds = grpc_metadata_credentials_create_from_plugin(plugin, NULL);
@@ -239,11 +239,11 @@ static VALUE grpc_rb_call_credentials_init(VALUE self, VALUE proc) {
   return self;
 }
 
-static VALUE grpc_rb_call_credentials_compose(int argc, VALUE *argv,
+static VALUE grpc_rb_call_credentials_compose(int argc, VALUE* argv,
                                               VALUE self) {
-  grpc_call_credentials *creds;
-  grpc_call_credentials *other;
-  grpc_call_credentials *prev = NULL;
+  grpc_call_credentials* creds;
+  grpc_call_credentials* other;
+  grpc_call_credentials* prev = NULL;
   VALUE mark;
   if (argc == 0) {
     return self;
@@ -282,8 +282,8 @@ void Init_grpc_call_credentials() {
 }
 
 /* Gets the wrapped grpc_call_credentials from the ruby wrapper */
-grpc_call_credentials *grpc_rb_get_wrapped_call_credentials(VALUE v) {
-  grpc_rb_call_credentials *wrapper = NULL;
+grpc_call_credentials* grpc_rb_get_wrapped_call_credentials(VALUE v) {
+  grpc_rb_call_credentials* wrapper = NULL;
   TypedData_Get_Struct(v, grpc_rb_call_credentials,
                        &grpc_rb_call_credentials_data_type, wrapper);
   return wrapper->wrapped;