grpc 1.7.3 → 1.8.0

data/src/core/tsi/transport_security.h

@@ -28,57 +28,57 @@
 extern "C" {
 #endif
 
-extern grpc_tracer_flag tsi_tracing_enabled;
+extern grpc_core::TraceFlag tsi_tracing_enabled;
 
 /* Base for tsi_frame_protector implementations.
    See transport_security_interface.h for documentation. */
 typedef struct {
-  tsi_result (*protect)(tsi_frame_protector *self,
-                        const unsigned char *unprotected_bytes,
-                        size_t *unprotected_bytes_size,
-                        unsigned char *protected_output_frames,
-                        size_t *protected_output_frames_size);
-  tsi_result (*protect_flush)(tsi_frame_protector *self,
-                              unsigned char *protected_output_frames,
-                              size_t *protected_output_frames_size,
-                              size_t *still_pending_size);
-  tsi_result (*unprotect)(tsi_frame_protector *self,
-                          const unsigned char *protected_frames_bytes,
-                          size_t *protected_frames_bytes_size,
-                          unsigned char *unprotected_bytes,
-                          size_t *unprotected_bytes_size);
-  void (*destroy)(tsi_frame_protector *self);
+  tsi_result (*protect)(tsi_frame_protector* self,
+                        const unsigned char* unprotected_bytes,
+                        size_t* unprotected_bytes_size,
+                        unsigned char* protected_output_frames,
+                        size_t* protected_output_frames_size);
+  tsi_result (*protect_flush)(tsi_frame_protector* self,
+                              unsigned char* protected_output_frames,
+                              size_t* protected_output_frames_size,
+                              size_t* still_pending_size);
+  tsi_result (*unprotect)(tsi_frame_protector* self,
+                          const unsigned char* protected_frames_bytes,
+                          size_t* protected_frames_bytes_size,
+                          unsigned char* unprotected_bytes,
+                          size_t* unprotected_bytes_size);
+  void (*destroy)(tsi_frame_protector* self);
 } tsi_frame_protector_vtable;
 
 struct tsi_frame_protector {
-  const tsi_frame_protector_vtable *vtable;
+  const tsi_frame_protector_vtable* vtable;
 };
 
 /* Base for tsi_handshaker implementations.
    See transport_security_interface.h for documentation. */
 typedef struct {
-  tsi_result (*get_bytes_to_send_to_peer)(tsi_handshaker *self,
-                                          unsigned char *bytes,
-                                          size_t *bytes_size);
-  tsi_result (*process_bytes_from_peer)(tsi_handshaker *self,
-                                        const unsigned char *bytes,
-                                        size_t *bytes_size);
-  tsi_result (*get_result)(tsi_handshaker *self);
-  tsi_result (*extract_peer)(tsi_handshaker *self, tsi_peer *peer);
-  tsi_result (*create_frame_protector)(tsi_handshaker *self,
-                                       size_t *max_protected_frame_size,
-                                       tsi_frame_protector **protector);
-  void (*destroy)(tsi_handshaker *self);
-  tsi_result (*next)(tsi_handshaker *self, const unsigned char *received_bytes,
+  tsi_result (*get_bytes_to_send_to_peer)(tsi_handshaker* self,
+                                          unsigned char* bytes,
+                                          size_t* bytes_size);
+  tsi_result (*process_bytes_from_peer)(tsi_handshaker* self,
+                                        const unsigned char* bytes,
+                                        size_t* bytes_size);
+  tsi_result (*get_result)(tsi_handshaker* self);
+  tsi_result (*extract_peer)(tsi_handshaker* self, tsi_peer* peer);
+  tsi_result (*create_frame_protector)(tsi_handshaker* self,
+                                       size_t* max_protected_frame_size,
+                                       tsi_frame_protector** protector);
+  void (*destroy)(tsi_handshaker* self);
+  tsi_result (*next)(tsi_handshaker* self, const unsigned char* received_bytes,
                      size_t received_bytes_size,
-                     const unsigned char **bytes_to_send,
-                     size_t *bytes_to_send_size,
-                     tsi_handshaker_result **handshaker_result,
-                     tsi_handshaker_on_next_done_cb cb, void *user_data);
+                     const unsigned char** bytes_to_send,
+                     size_t* bytes_to_send_size,
+                     tsi_handshaker_result** handshaker_result,
+                     tsi_handshaker_on_next_done_cb cb, void* user_data);
 } tsi_handshaker_vtable;
 
 struct tsi_handshaker {
-  const tsi_handshaker_vtable *vtable;
+  const tsi_handshaker_vtable* vtable;
   bool frame_protector_created;
   bool handshaker_result_created;
 };
@@ -92,39 +92,39 @@ struct tsi_handshaker {
    needs to compile in other applications, where grpc_exec_ctx is not defined.
 */
 typedef struct {
-  tsi_result (*extract_peer)(const tsi_handshaker_result *self, tsi_peer *peer);
+  tsi_result (*extract_peer)(const tsi_handshaker_result* self, tsi_peer* peer);
   tsi_result (*create_zero_copy_grpc_protector)(
-      void *exec_ctx, const tsi_handshaker_result *self,
-      size_t *max_output_protected_frame_size,
-      tsi_zero_copy_grpc_protector **protector);
-  tsi_result (*create_frame_protector)(const tsi_handshaker_result *self,
-                                       size_t *max_output_protected_frame_size,
-                                       tsi_frame_protector **protector);
-  tsi_result (*get_unused_bytes)(const tsi_handshaker_result *self,
-                                 const unsigned char **bytes,
-                                 size_t *bytes_size);
-  void (*destroy)(tsi_handshaker_result *self);
+      void* exec_ctx, const tsi_handshaker_result* self,
+      size_t* max_output_protected_frame_size,
+      tsi_zero_copy_grpc_protector** protector);
+  tsi_result (*create_frame_protector)(const tsi_handshaker_result* self,
+                                       size_t* max_output_protected_frame_size,
+                                       tsi_frame_protector** protector);
+  tsi_result (*get_unused_bytes)(const tsi_handshaker_result* self,
+                                 const unsigned char** bytes,
+                                 size_t* bytes_size);
+  void (*destroy)(tsi_handshaker_result* self);
 } tsi_handshaker_result_vtable;
 
 struct tsi_handshaker_result {
-  const tsi_handshaker_result_vtable *vtable;
+  const tsi_handshaker_result_vtable* vtable;
 };
 
 /* Peer and property construction/destruction functions. */
-tsi_result tsi_construct_peer(size_t property_count, tsi_peer *peer);
+tsi_result tsi_construct_peer(size_t property_count, tsi_peer* peer);
 tsi_peer_property tsi_init_peer_property(void);
-void tsi_peer_property_destruct(tsi_peer_property *property);
-tsi_result tsi_construct_string_peer_property(const char *name,
-                                              const char *value,
+void tsi_peer_property_destruct(tsi_peer_property* property);
+tsi_result tsi_construct_string_peer_property(const char* name,
+                                              const char* value,
                                               size_t value_length,
-                                              tsi_peer_property *property);
+                                              tsi_peer_property* property);
 tsi_result tsi_construct_allocated_string_peer_property(
-    const char *name, size_t value_length, tsi_peer_property *property);
+    const char* name, size_t value_length, tsi_peer_property* property);
 tsi_result tsi_construct_string_peer_property_from_cstring(
-    const char *name, const char *value, tsi_peer_property *property);
+    const char* name, const char* value, tsi_peer_property* property);
 
 /* Utils. */
-char *tsi_strdup(const char *src); /* Sadly, no strdup in C89. */
+char* tsi_strdup(const char* src); /* Sadly, no strdup in C89. */
 
 #ifdef __cplusplus
 }

data/src/core/tsi/{transport_security_adapter.c → transport_security_adapter.cc}

@@ -30,36 +30,36 @@
 
 typedef struct {
   tsi_handshaker_result base;
-  tsi_handshaker *wrapped;
-  unsigned char *unused_bytes;
+  tsi_handshaker* wrapped;
+  unsigned char* unused_bytes;
   size_t unused_bytes_size;
 } tsi_adapter_handshaker_result;
 
-static tsi_result adapter_result_extract_peer(const tsi_handshaker_result *self,
-                                              tsi_peer *peer) {
-  tsi_adapter_handshaker_result *impl = (tsi_adapter_handshaker_result *)self;
+static tsi_result adapter_result_extract_peer(const tsi_handshaker_result* self,
+                                              tsi_peer* peer) {
+  tsi_adapter_handshaker_result* impl = (tsi_adapter_handshaker_result*)self;
   return tsi_handshaker_extract_peer(impl->wrapped, peer);
 }
 
 static tsi_result adapter_result_create_frame_protector(
-    const tsi_handshaker_result *self, size_t *max_output_protected_frame_size,
-    tsi_frame_protector **protector) {
-  tsi_adapter_handshaker_result *impl = (tsi_adapter_handshaker_result *)self;
+    const tsi_handshaker_result* self, size_t* max_output_protected_frame_size,
+    tsi_frame_protector** protector) {
+  tsi_adapter_handshaker_result* impl = (tsi_adapter_handshaker_result*)self;
   return tsi_handshaker_create_frame_protector(
       impl->wrapped, max_output_protected_frame_size, protector);
 }
 
 static tsi_result adapter_result_get_unused_bytes(
-    const tsi_handshaker_result *self, const unsigned char **bytes,
-    size_t *byte_size) {
-  tsi_adapter_handshaker_result *impl = (tsi_adapter_handshaker_result *)self;
+    const tsi_handshaker_result* self, const unsigned char** bytes,
+    size_t* byte_size) {
+  tsi_adapter_handshaker_result* impl = (tsi_adapter_handshaker_result*)self;
   *bytes = impl->unused_bytes;
   *byte_size = impl->unused_bytes_size;
   return TSI_OK;
 }
 
-static void adapter_result_destroy(tsi_handshaker_result *self) {
-  tsi_adapter_handshaker_result *impl = (tsi_adapter_handshaker_result *)self;
+static void adapter_result_destroy(tsi_handshaker_result* self) {
+  tsi_adapter_handshaker_result* impl = (tsi_adapter_handshaker_result*)self;
   tsi_handshaker_destroy(impl->wrapped);
   gpr_free(impl->unused_bytes);
   gpr_free(self);
@@ -67,7 +67,7 @@ static void adapter_result_destroy(tsi_handshaker_result *self) {
 
 static const tsi_handshaker_result_vtable result_vtable = {
     adapter_result_extract_peer,
-    NULL, /* create_zero_copy_grpc_protector */
+    nullptr, /* create_zero_copy_grpc_protector */
     adapter_result_create_frame_protector,
     adapter_result_get_unused_bytes,
     adapter_result_destroy,
@@ -75,20 +75,22 @@ static const tsi_handshaker_result_vtable result_vtable = {
 
 /* Ownership of wrapped tsi_handshaker is transferred to the result object.  */
 static tsi_result tsi_adapter_create_handshaker_result(
-    tsi_handshaker *wrapped, const unsigned char *unused_bytes,
-    size_t unused_bytes_size, tsi_handshaker_result **handshaker_result) {
-  if (wrapped == NULL || (unused_bytes_size > 0 && unused_bytes == NULL)) {
+    tsi_handshaker* wrapped, const unsigned char* unused_bytes,
+    size_t unused_bytes_size, tsi_handshaker_result** handshaker_result) {
+  if (wrapped == nullptr ||
+      (unused_bytes_size > 0 && unused_bytes == nullptr)) {
     return TSI_INVALID_ARGUMENT;
   }
-  tsi_adapter_handshaker_result *impl = gpr_zalloc(sizeof(*impl));
+  tsi_adapter_handshaker_result* impl =
+      (tsi_adapter_handshaker_result*)gpr_zalloc(sizeof(*impl));
   impl->base.vtable = &result_vtable;
   impl->wrapped = wrapped;
   impl->unused_bytes_size = unused_bytes_size;
   if (unused_bytes_size > 0) {
-    impl->unused_bytes = gpr_malloc(unused_bytes_size);
+    impl->unused_bytes = (unsigned char*)gpr_malloc(unused_bytes_size);
     memcpy(impl->unused_bytes, unused_bytes, unused_bytes_size);
   } else {
-    impl->unused_bytes = NULL;
+    impl->unused_bytes = nullptr;
   }
   *handshaker_result = &impl->base;
   return TSI_OK;
@@ -98,63 +100,63 @@ static tsi_result tsi_adapter_create_handshaker_result(
 
 typedef struct {
   tsi_handshaker base;
-  tsi_handshaker *wrapped;
-  unsigned char *adapter_buffer;
+  tsi_handshaker* wrapped;
+  unsigned char* adapter_buffer;
   size_t adapter_buffer_size;
 } tsi_adapter_handshaker;
 
-static tsi_result adapter_get_bytes_to_send_to_peer(tsi_handshaker *self,
-                                                    unsigned char *bytes,
-                                                    size_t *bytes_size) {
+static tsi_result adapter_get_bytes_to_send_to_peer(tsi_handshaker* self,
+                                                    unsigned char* bytes,
+                                                    size_t* bytes_size) {
   return tsi_handshaker_get_bytes_to_send_to_peer(
       tsi_adapter_handshaker_get_wrapped(self), bytes, bytes_size);
 }
 
-static tsi_result adapter_process_bytes_from_peer(tsi_handshaker *self,
-                                                  const unsigned char *bytes,
-                                                  size_t *bytes_size) {
+static tsi_result adapter_process_bytes_from_peer(tsi_handshaker* self,
+                                                  const unsigned char* bytes,
+                                                  size_t* bytes_size) {
   return tsi_handshaker_process_bytes_from_peer(
       tsi_adapter_handshaker_get_wrapped(self), bytes, bytes_size);
 }
 
-static tsi_result adapter_get_result(tsi_handshaker *self) {
+static tsi_result adapter_get_result(tsi_handshaker* self) {
   return tsi_handshaker_get_result(tsi_adapter_handshaker_get_wrapped(self));
 }
 
-static tsi_result adapter_extract_peer(tsi_handshaker *self, tsi_peer *peer) {
+static tsi_result adapter_extract_peer(tsi_handshaker* self, tsi_peer* peer) {
   return tsi_handshaker_extract_peer(tsi_adapter_handshaker_get_wrapped(self),
                                      peer);
 }
 
 static tsi_result adapter_create_frame_protector(
-    tsi_handshaker *self, size_t *max_protected_frame_size,
-    tsi_frame_protector **protector) {
+    tsi_handshaker* self, size_t* max_protected_frame_size,
+    tsi_frame_protector** protector) {
   return tsi_handshaker_create_frame_protector(
       tsi_adapter_handshaker_get_wrapped(self), max_protected_frame_size,
       protector);
 }
 
-static void adapter_destroy(tsi_handshaker *self) {
-  tsi_adapter_handshaker *impl = (tsi_adapter_handshaker *)self;
+static void adapter_destroy(tsi_handshaker* self) {
+  tsi_adapter_handshaker* impl = (tsi_adapter_handshaker*)self;
   tsi_handshaker_destroy(impl->wrapped);
   gpr_free(impl->adapter_buffer);
   gpr_free(self);
 }
 
 static tsi_result adapter_next(
-    tsi_handshaker *self, const unsigned char *received_bytes,
-    size_t received_bytes_size, const unsigned char **bytes_to_send,
-    size_t *bytes_to_send_size, tsi_handshaker_result **handshaker_result,
-    tsi_handshaker_on_next_done_cb cb, void *user_data) {
+    tsi_handshaker* self, const unsigned char* received_bytes,
+    size_t received_bytes_size, const unsigned char** bytes_to_send,
+    size_t* bytes_to_send_size, tsi_handshaker_result** handshaker_result,
+    tsi_handshaker_on_next_done_cb cb, void* user_data) {
   /* Input sanity check.  */
-  if ((received_bytes_size > 0 && received_bytes == NULL) ||
-      bytes_to_send == NULL || bytes_to_send_size == NULL ||
-      handshaker_result == NULL) {
+  if ((received_bytes_size > 0 && received_bytes == nullptr) ||
+      bytes_to_send == nullptr || bytes_to_send_size == nullptr ||
+      handshaker_result == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
 
   /* If there are received bytes, process them first.  */
-  tsi_adapter_handshaker *impl = (tsi_adapter_handshaker *)self;
+  tsi_adapter_handshaker* impl = (tsi_adapter_handshaker*)self;
   tsi_result status = TSI_OK;
   size_t bytes_consumed = received_bytes_size;
   if (received_bytes_size > 0) {
@@ -172,8 +174,8 @@ static tsi_result adapter_next(
     offset += to_send_size;
     if (status == TSI_INCOMPLETE_DATA) {
       impl->adapter_buffer_size *= 2;
-      impl->adapter_buffer =
-          gpr_realloc(impl->adapter_buffer, impl->adapter_buffer_size);
+      impl->adapter_buffer = (unsigned char*)gpr_realloc(
+          impl->adapter_buffer, impl->adapter_buffer_size);
     }
   } while (status == TSI_INCOMPLETE_DATA);
   if (status != TSI_OK) return status;
@@ -182,16 +184,16 @@ static tsi_result adapter_next(
 
   /* If handshake completes, create tsi_handshaker_result.  */
   if (tsi_handshaker_is_in_progress(impl->wrapped)) {
-    *handshaker_result = NULL;
+    *handshaker_result = nullptr;
   } else {
     size_t unused_bytes_size = received_bytes_size - bytes_consumed;
-    const unsigned char *unused_bytes =
-        unused_bytes_size == 0 ? NULL : received_bytes + bytes_consumed;
+    const unsigned char* unused_bytes =
+        unused_bytes_size == 0 ? nullptr : received_bytes + bytes_consumed;
     status = tsi_adapter_create_handshaker_result(
         impl->wrapped, unused_bytes, unused_bytes_size, handshaker_result);
     if (status == TSI_OK) {
       impl->base.handshaker_result_created = true;
-      impl->wrapped = NULL;
+      impl->wrapped = nullptr;
     }
   }
   return status;
@@ -207,18 +209,19 @@ static const tsi_handshaker_vtable handshaker_vtable = {
     adapter_next,
 };
 
-tsi_handshaker *tsi_create_adapter_handshaker(tsi_handshaker *wrapped) {
-  GPR_ASSERT(wrapped != NULL);
-  tsi_adapter_handshaker *impl = gpr_zalloc(sizeof(*impl));
+tsi_handshaker* tsi_create_adapter_handshaker(tsi_handshaker* wrapped) {
+  GPR_ASSERT(wrapped != nullptr);
+  tsi_adapter_handshaker* impl =
+      (tsi_adapter_handshaker*)gpr_zalloc(sizeof(*impl));
   impl->base.vtable = &handshaker_vtable;
   impl->wrapped = wrapped;
   impl->adapter_buffer_size = TSI_ADAPTER_INITIAL_BUFFER_SIZE;
-  impl->adapter_buffer = gpr_malloc(impl->adapter_buffer_size);
+  impl->adapter_buffer = (unsigned char*)gpr_malloc(impl->adapter_buffer_size);
   return &impl->base;
 }
 
-tsi_handshaker *tsi_adapter_handshaker_get_wrapped(tsi_handshaker *adapter) {
-  if (adapter == NULL) return NULL;
-  tsi_adapter_handshaker *impl = (tsi_adapter_handshaker *)adapter;
+tsi_handshaker* tsi_adapter_handshaker_get_wrapped(tsi_handshaker* adapter) {
+  if (adapter == nullptr) return nullptr;
+  tsi_adapter_handshaker* impl = (tsi_adapter_handshaker*)adapter;
   return impl->wrapped;
 }

data/src/core/tsi/transport_security_adapter.h

@@ -33,12 +33,12 @@ extern "C" {
    this tsi adapter handshaker is temporary. It will be removed once TSI has
    been fully migrated to the new interface.
    Ownership of input tsi_handshaker is transferred to this new adapter.  */
-tsi_handshaker *tsi_create_adapter_handshaker(tsi_handshaker *wrapped);
+tsi_handshaker* tsi_create_adapter_handshaker(tsi_handshaker* wrapped);
 
 /* Given a tsi adapter handshaker, return the original wrapped handshaker. The
    adapter still owns the wrapped handshaker which should not be destroyed by
    the caller. */
-tsi_handshaker *tsi_adapter_handshaker_get_wrapped(tsi_handshaker *adapter);
+tsi_handshaker* tsi_adapter_handshaker_get_wrapped(tsi_handshaker* adapter);
 
 #ifdef __cplusplus
 }

data/src/core/tsi/{transport_security_grpc.c → transport_security_grpc.cc}

@@ -20,14 +20,14 @@
 
 /* This method creates a tsi_zero_copy_grpc_protector object.  */
 tsi_result tsi_handshaker_result_create_zero_copy_grpc_protector(
-    grpc_exec_ctx *exec_ctx, const tsi_handshaker_result *self,
-    size_t *max_output_protected_frame_size,
-    tsi_zero_copy_grpc_protector **protector) {
-  if (exec_ctx == NULL || self == NULL || self->vtable == NULL ||
-      protector == NULL) {
+    grpc_exec_ctx* exec_ctx, const tsi_handshaker_result* self,
+    size_t* max_output_protected_frame_size,
+    tsi_zero_copy_grpc_protector** protector) {
+  if (exec_ctx == nullptr || self == nullptr || self->vtable == nullptr ||
+      protector == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
-  if (self->vtable->create_zero_copy_grpc_protector == NULL) {
+  if (self->vtable->create_zero_copy_grpc_protector == nullptr) {
     return TSI_UNIMPLEMENTED;
   }
   return self->vtable->create_zero_copy_grpc_protector(
@@ -39,33 +39,33 @@ tsi_result tsi_handshaker_result_create_zero_copy_grpc_protector(
    Calls specific implementation after state/input validation. */
 
 tsi_result tsi_zero_copy_grpc_protector_protect(
-    grpc_exec_ctx *exec_ctx, tsi_zero_copy_grpc_protector *self,
-    grpc_slice_buffer *unprotected_slices,
-    grpc_slice_buffer *protected_slices) {
-  if (exec_ctx == NULL || self == NULL || self->vtable == NULL ||
-      unprotected_slices == NULL || protected_slices == NULL) {
+    grpc_exec_ctx* exec_ctx, tsi_zero_copy_grpc_protector* self,
+    grpc_slice_buffer* unprotected_slices,
+    grpc_slice_buffer* protected_slices) {
+  if (exec_ctx == nullptr || self == nullptr || self->vtable == nullptr ||
+      unprotected_slices == nullptr || protected_slices == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
-  if (self->vtable->protect == NULL) return TSI_UNIMPLEMENTED;
+  if (self->vtable->protect == nullptr) return TSI_UNIMPLEMENTED;
   return self->vtable->protect(exec_ctx, self, unprotected_slices,
                                protected_slices);
 }
 
 tsi_result tsi_zero_copy_grpc_protector_unprotect(
-    grpc_exec_ctx *exec_ctx, tsi_zero_copy_grpc_protector *self,
-    grpc_slice_buffer *protected_slices,
-    grpc_slice_buffer *unprotected_slices) {
-  if (exec_ctx == NULL || self == NULL || self->vtable == NULL ||
-      protected_slices == NULL || unprotected_slices == NULL) {
+    grpc_exec_ctx* exec_ctx, tsi_zero_copy_grpc_protector* self,
+    grpc_slice_buffer* protected_slices,
+    grpc_slice_buffer* unprotected_slices) {
+  if (exec_ctx == nullptr || self == nullptr || self->vtable == nullptr ||
+      protected_slices == nullptr || unprotected_slices == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
-  if (self->vtable->unprotect == NULL) return TSI_UNIMPLEMENTED;
+  if (self->vtable->unprotect == nullptr) return TSI_UNIMPLEMENTED;
   return self->vtable->unprotect(exec_ctx, self, protected_slices,
                                  unprotected_slices);
 }
 
-void tsi_zero_copy_grpc_protector_destroy(grpc_exec_ctx *exec_ctx,
-                                          tsi_zero_copy_grpc_protector *self) {
-  if (self == NULL) return;
+void tsi_zero_copy_grpc_protector_destroy(grpc_exec_ctx* exec_ctx,
+                                          tsi_zero_copy_grpc_protector* self) {
+  if (self == nullptr) return;
   self->vtable->destroy(exec_ctx, self);
 }