grpc 1.7.3 → 1.8.0

data/src/core/tsi/ssl_transport_security.h

@@ -49,11 +49,11 @@ typedef struct tsi_ssl_client_handshaker_factory
 typedef struct {
   /* private_key is the NULL-terminated string containing the PEM encoding of
      the client's private key. */
-  const char *private_key;
+  const char* private_key;
 
   /* cert_chain is the NULL-terminated string containing the PEM encoding of
      the client's certificate chain. */
-  const char *cert_chain;
+  const char* cert_chain;
 } tsi_ssl_pem_key_cert_pair;
 
 /* Creates a client handshaker factory.
@@ -78,10 +78,10 @@ typedef struct {
    - This method returns TSI_OK on success or TSI_INVALID_PARAMETER in the case
      where a parameter is invalid.  */
 tsi_result tsi_create_ssl_client_handshaker_factory(
-    const tsi_ssl_pem_key_cert_pair *pem_key_cert_pair,
-    const char *pem_root_certs, const char *cipher_suites,
-    const char **alpn_protocols, uint16_t num_alpn_protocols,
-    tsi_ssl_client_handshaker_factory **factory);
+    const tsi_ssl_pem_key_cert_pair* pem_key_cert_pair,
+    const char* pem_root_certs, const char* cipher_suites,
+    const char** alpn_protocols, uint16_t num_alpn_protocols,
+    tsi_ssl_client_handshaker_factory** factory);
 
 /* Creates a client handshaker.
   - self is the factory from which the handshaker will be created.
@@ -93,13 +93,13 @@ tsi_result tsi_create_ssl_client_handshaker_factory(
   - This method returns TSI_OK on success or TSI_INVALID_PARAMETER in the case
     where a parameter is invalid.  */
 tsi_result tsi_ssl_client_handshaker_factory_create_handshaker(
-    tsi_ssl_client_handshaker_factory *self, const char *server_name_indication,
-    tsi_handshaker **handshaker);
+    tsi_ssl_client_handshaker_factory* self, const char* server_name_indication,
+    tsi_handshaker** handshaker);
 
 /* Decrements reference count of the handshaker factory. Handshaker factory will
  * be destroyed once no references exist. */
 void tsi_ssl_client_handshaker_factory_unref(
-    tsi_ssl_client_handshaker_factory *factory);
+    tsi_ssl_client_handshaker_factory* factory);
 
 /* --- tsi_ssl_server_handshaker_factory object ---
 
@@ -130,11 +130,11 @@ typedef struct tsi_ssl_server_handshaker_factory
    - This method returns TSI_OK on success or TSI_INVALID_PARAMETER in the case
      where a parameter is invalid.  */
 tsi_result tsi_create_ssl_server_handshaker_factory(
-    const tsi_ssl_pem_key_cert_pair *pem_key_cert_pairs,
-    size_t num_key_cert_pairs, const char *pem_client_root_certs,
-    int force_client_auth, const char *cipher_suites,
-    const char **alpn_protocols, uint16_t num_alpn_protocols,
-    tsi_ssl_server_handshaker_factory **factory);
+    const tsi_ssl_pem_key_cert_pair* pem_key_cert_pairs,
+    size_t num_key_cert_pairs, const char* pem_client_root_certs,
+    int force_client_auth, const char* cipher_suites,
+    const char** alpn_protocols, uint16_t num_alpn_protocols,
+    tsi_ssl_server_handshaker_factory** factory);
 
 /* Same as tsi_create_ssl_server_handshaker_factory method except uses
    tsi_client_certificate_request_type to support more ways to handle client
@@ -143,11 +143,11 @@ tsi_result tsi_create_ssl_server_handshaker_factory(
      authenticate with an SSL cert. Note that this option is ignored if
      pem_client_root_certs is NULL or pem_client_roots_certs_size is 0 */
 tsi_result tsi_create_ssl_server_handshaker_factory_ex(
-    const tsi_ssl_pem_key_cert_pair *pem_key_cert_pairs,
-    size_t num_key_cert_pairs, const char *pem_client_root_certs,
+    const tsi_ssl_pem_key_cert_pair* pem_key_cert_pairs,
+    size_t num_key_cert_pairs, const char* pem_client_root_certs,
     tsi_client_certificate_request_type client_certificate_request,
-    const char *cipher_suites, const char **alpn_protocols,
-    uint16_t num_alpn_protocols, tsi_ssl_server_handshaker_factory **factory);
+    const char* cipher_suites, const char** alpn_protocols,
+    uint16_t num_alpn_protocols, tsi_ssl_server_handshaker_factory** factory);
 
 /* Creates a server handshaker.
   - self is the factory from which the handshaker will be created.
@@ -156,19 +156,19 @@ tsi_result tsi_create_ssl_server_handshaker_factory_ex(
   - This method returns TSI_OK on success or TSI_INVALID_PARAMETER in the case
     where a parameter is invalid.  */
 tsi_result tsi_ssl_server_handshaker_factory_create_handshaker(
-    tsi_ssl_server_handshaker_factory *self, tsi_handshaker **handshaker);
+    tsi_ssl_server_handshaker_factory* self, tsi_handshaker** handshaker);
 
 /* Decrements reference count of the handshaker factory. Handshaker factory will
  * be destroyed once no references exist. */
 void tsi_ssl_server_handshaker_factory_unref(
-    tsi_ssl_server_handshaker_factory *self);
+    tsi_ssl_server_handshaker_factory* self);
 
 /* Util that checks that an ssl peer matches a specific name.
    Still TODO(jboeuf):
    - handle mixed case.
    - handle %encoded chars.
    - handle public suffix wildchar more strictly (e.g. *.co.uk) */
-int tsi_ssl_peer_matches_name(const tsi_peer *peer, const char *name);
+int tsi_ssl_peer_matches_name(const tsi_peer* peer, const char* name);
 
 /* --- Testing support. ---
 
@@ -180,7 +180,7 @@ typedef struct tsi_ssl_handshaker_factory tsi_ssl_handshaker_factory;
 
 /* Function pointer to handshaker_factory destructor. */
 typedef void (*tsi_ssl_handshaker_factory_destructor)(
-    tsi_ssl_handshaker_factory *factory);
+    tsi_ssl_handshaker_factory* factory);
 
 /* Virtual table for tsi_ssl_handshaker_factory. */
 typedef struct {
@@ -189,9 +189,9 @@ typedef struct {
 
 /* Set destructor of handshaker_factory to new_destructor, returns previous
    destructor. */
-const tsi_ssl_handshaker_factory_vtable *tsi_ssl_handshaker_factory_swap_vtable(
-    tsi_ssl_handshaker_factory *factory,
-    tsi_ssl_handshaker_factory_vtable *new_vtable);
+const tsi_ssl_handshaker_factory_vtable* tsi_ssl_handshaker_factory_swap_vtable(
+    tsi_ssl_handshaker_factory* factory,
+    tsi_ssl_handshaker_factory_vtable* new_vtable);
 
 #ifdef __cplusplus
 }

data/src/core/tsi/ssl_types.h

@@ -19,6 +19,10 @@
 #ifndef GRPC_CORE_TSI_SSL_TYPES_H
 #define GRPC_CORE_TSI_SSL_TYPES_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* A collection of macros to cast between various integer types that are
  * used differently between BoringSSL and OpenSSL:
  * TSI_INT_AS_SIZE(x):  convert 'int x' to a length parameter for an OpenSSL
@@ -37,4 +41,8 @@
 #define TSI_SIZE_AS_SIZE(x) ((int)(x))
 #endif
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_TSI_SSL_TYPES_H */

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

@@ -26,11 +26,11 @@
 
 /* --- Tracing. --- */
 
-grpc_tracer_flag tsi_tracing_enabled = GRPC_TRACER_INITIALIZER(false, "tsi");
+grpc_core::TraceFlag tsi_tracing_enabled(false, "tsi");
 
 /* --- tsi_result common implementation. --- */
 
-const char *tsi_result_to_string(tsi_result result) {
+const char* tsi_result_to_string(tsi_result result) {
   switch (result) {
     case TSI_OK:
       return "TSI_OK";
@@ -69,52 +69,56 @@ const char *tsi_result_to_string(tsi_result result) {
 
    Calls specific implementation after state/input validation. */
 
-tsi_result tsi_frame_protector_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) {
-  if (self == NULL || self->vtable == NULL || unprotected_bytes == NULL ||
-      unprotected_bytes_size == NULL || protected_output_frames == NULL ||
-      protected_output_frames_size == NULL) {
+tsi_result tsi_frame_protector_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) {
+  if (self == nullptr || self->vtable == nullptr ||
+      unprotected_bytes == nullptr || unprotected_bytes_size == nullptr ||
+      protected_output_frames == nullptr ||
+      protected_output_frames_size == 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(self, unprotected_bytes, unprotected_bytes_size,
                                protected_output_frames,
                                protected_output_frames_size);
 }
 
 tsi_result tsi_frame_protector_protect_flush(
-    tsi_frame_protector *self, unsigned char *protected_output_frames,
-    size_t *protected_output_frames_size, size_t *still_pending_size) {
-  if (self == NULL || self->vtable == NULL || protected_output_frames == NULL ||
-      protected_output_frames_size == NULL || still_pending_size == NULL) {
+    tsi_frame_protector* self, unsigned char* protected_output_frames,
+    size_t* protected_output_frames_size, size_t* still_pending_size) {
+  if (self == nullptr || self->vtable == nullptr ||
+      protected_output_frames == nullptr ||
+      protected_output_frames_size == nullptr ||
+      still_pending_size == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
-  if (self->vtable->protect_flush == NULL) return TSI_UNIMPLEMENTED;
+  if (self->vtable->protect_flush == nullptr) return TSI_UNIMPLEMENTED;
   return self->vtable->protect_flush(self, protected_output_frames,
                                      protected_output_frames_size,
                                      still_pending_size);
 }
 
 tsi_result tsi_frame_protector_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) {
-  if (self == NULL || self->vtable == NULL || protected_frames_bytes == NULL ||
-      protected_frames_bytes_size == NULL || unprotected_bytes == NULL ||
-      unprotected_bytes_size == NULL) {
+    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) {
+  if (self == nullptr || self->vtable == nullptr ||
+      protected_frames_bytes == nullptr ||
+      protected_frames_bytes_size == nullptr || unprotected_bytes == nullptr ||
+      unprotected_bytes_size == 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(self, protected_frames_bytes,
                                  protected_frames_bytes_size, unprotected_bytes,
                                  unprotected_bytes_size);
 }
 
-void tsi_frame_protector_destroy(tsi_frame_protector *self) {
-  if (self == NULL) return;
+void tsi_frame_protector_destroy(tsi_frame_protector* self) {
+  if (self == nullptr) return;
   self->vtable->destroy(self);
 }
 
@@ -122,39 +126,41 @@ void tsi_frame_protector_destroy(tsi_frame_protector *self) {
 
    Calls specific implementation after state/input validation. */
 
-tsi_result tsi_handshaker_get_bytes_to_send_to_peer(tsi_handshaker *self,
-                                                    unsigned char *bytes,
-                                                    size_t *bytes_size) {
-  if (self == NULL || self->vtable == NULL || bytes == NULL ||
-      bytes_size == NULL) {
+tsi_result tsi_handshaker_get_bytes_to_send_to_peer(tsi_handshaker* self,
+                                                    unsigned char* bytes,
+                                                    size_t* bytes_size) {
+  if (self == nullptr || self->vtable == nullptr || bytes == nullptr ||
+      bytes_size == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
   if (self->frame_protector_created) return TSI_FAILED_PRECONDITION;
-  if (self->vtable->get_bytes_to_send_to_peer == NULL) return TSI_UNIMPLEMENTED;
+  if (self->vtable->get_bytes_to_send_to_peer == nullptr)
+    return TSI_UNIMPLEMENTED;
   return self->vtable->get_bytes_to_send_to_peer(self, bytes, bytes_size);
 }
 
-tsi_result tsi_handshaker_process_bytes_from_peer(tsi_handshaker *self,
-                                                  const unsigned char *bytes,
-                                                  size_t *bytes_size) {
-  if (self == NULL || self->vtable == NULL || bytes == NULL ||
-      bytes_size == NULL) {
+tsi_result tsi_handshaker_process_bytes_from_peer(tsi_handshaker* self,
+                                                  const unsigned char* bytes,
+                                                  size_t* bytes_size) {
+  if (self == nullptr || self->vtable == nullptr || bytes == nullptr ||
+      bytes_size == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
   if (self->frame_protector_created) return TSI_FAILED_PRECONDITION;
-  if (self->vtable->process_bytes_from_peer == NULL) return TSI_UNIMPLEMENTED;
+  if (self->vtable->process_bytes_from_peer == nullptr)
+    return TSI_UNIMPLEMENTED;
   return self->vtable->process_bytes_from_peer(self, bytes, bytes_size);
 }
 
-tsi_result tsi_handshaker_get_result(tsi_handshaker *self) {
-  if (self == NULL || self->vtable == NULL) return TSI_INVALID_ARGUMENT;
+tsi_result tsi_handshaker_get_result(tsi_handshaker* self) {
+  if (self == nullptr || self->vtable == nullptr) return TSI_INVALID_ARGUMENT;
   if (self->frame_protector_created) return TSI_FAILED_PRECONDITION;
-  if (self->vtable->get_result == NULL) return TSI_UNIMPLEMENTED;
+  if (self->vtable->get_result == nullptr) return TSI_UNIMPLEMENTED;
   return self->vtable->get_result(self);
 }
 
-tsi_result tsi_handshaker_extract_peer(tsi_handshaker *self, tsi_peer *peer) {
-  if (self == NULL || self->vtable == NULL || peer == NULL) {
+tsi_result tsi_handshaker_extract_peer(tsi_handshaker* self, tsi_peer* peer) {
+  if (self == nullptr || self->vtable == nullptr || peer == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
   memset(peer, 0, sizeof(tsi_peer));
@@ -162,20 +168,20 @@ tsi_result tsi_handshaker_extract_peer(tsi_handshaker *self, tsi_peer *peer) {
   if (tsi_handshaker_get_result(self) != TSI_OK) {
     return TSI_FAILED_PRECONDITION;
   }
-  if (self->vtable->extract_peer == NULL) return TSI_UNIMPLEMENTED;
+  if (self->vtable->extract_peer == nullptr) return TSI_UNIMPLEMENTED;
   return self->vtable->extract_peer(self, peer);
 }
 
 tsi_result tsi_handshaker_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) {
   tsi_result result;
-  if (self == NULL || self->vtable == NULL || protector == NULL) {
+  if (self == nullptr || self->vtable == nullptr || protector == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
   if (self->frame_protector_created) return TSI_FAILED_PRECONDITION;
   if (tsi_handshaker_get_result(self) != TSI_OK) return TSI_FAILED_PRECONDITION;
-  if (self->vtable->create_frame_protector == NULL) return TSI_UNIMPLEMENTED;
+  if (self->vtable->create_frame_protector == nullptr) return TSI_UNIMPLEMENTED;
   result = self->vtable->create_frame_protector(self, max_protected_frame_size,
                                                 protector);
   if (result == TSI_OK) {
@@ -185,59 +191,59 @@ tsi_result tsi_handshaker_create_frame_protector(
 }
 
 tsi_result tsi_handshaker_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) {
-  if (self == NULL || self->vtable == NULL) return TSI_INVALID_ARGUMENT;
+    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) {
+  if (self == nullptr || self->vtable == nullptr) return TSI_INVALID_ARGUMENT;
   if (self->handshaker_result_created) return TSI_FAILED_PRECONDITION;
-  if (self->vtable->next == NULL) return TSI_UNIMPLEMENTED;
+  if (self->vtable->next == nullptr) return TSI_UNIMPLEMENTED;
   return self->vtable->next(self, received_bytes, received_bytes_size,
                             bytes_to_send, bytes_to_send_size,
                             handshaker_result, cb, user_data);
 }
 
-void tsi_handshaker_destroy(tsi_handshaker *self) {
-  if (self == NULL) return;
+void tsi_handshaker_destroy(tsi_handshaker* self) {
+  if (self == nullptr) return;
   self->vtable->destroy(self);
 }
 
 /* --- tsi_handshaker_result implementation. --- */
 
-tsi_result tsi_handshaker_result_extract_peer(const tsi_handshaker_result *self,
-                                              tsi_peer *peer) {
-  if (self == NULL || self->vtable == NULL || peer == NULL) {
+tsi_result tsi_handshaker_result_extract_peer(const tsi_handshaker_result* self,
+                                              tsi_peer* peer) {
+  if (self == nullptr || self->vtable == nullptr || peer == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
   memset(peer, 0, sizeof(tsi_peer));
-  if (self->vtable->extract_peer == NULL) return TSI_UNIMPLEMENTED;
+  if (self->vtable->extract_peer == nullptr) return TSI_UNIMPLEMENTED;
   return self->vtable->extract_peer(self, peer);
 }
 
 tsi_result tsi_handshaker_result_create_frame_protector(
-    const tsi_handshaker_result *self, size_t *max_protected_frame_size,
-    tsi_frame_protector **protector) {
-  if (self == NULL || self->vtable == NULL || protector == NULL) {
+    const tsi_handshaker_result* self, size_t* max_protected_frame_size,
+    tsi_frame_protector** protector) {
+  if (self == nullptr || self->vtable == nullptr || protector == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
-  if (self->vtable->create_frame_protector == NULL) return TSI_UNIMPLEMENTED;
+  if (self->vtable->create_frame_protector == nullptr) return TSI_UNIMPLEMENTED;
   return self->vtable->create_frame_protector(self, max_protected_frame_size,
                                               protector);
 }
 
 tsi_result tsi_handshaker_result_get_unused_bytes(
-    const tsi_handshaker_result *self, const unsigned char **bytes,
-    size_t *bytes_size) {
-  if (self == NULL || self->vtable == NULL || bytes == NULL ||
-      bytes_size == NULL) {
+    const tsi_handshaker_result* self, const unsigned char** bytes,
+    size_t* bytes_size) {
+  if (self == nullptr || self->vtable == nullptr || bytes == nullptr ||
+      bytes_size == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
-  if (self->vtable->get_unused_bytes == NULL) return TSI_UNIMPLEMENTED;
+  if (self->vtable->get_unused_bytes == nullptr) return TSI_UNIMPLEMENTED;
   return self->vtable->get_unused_bytes(self, bytes, bytes_size);
 }
 
-void tsi_handshaker_result_destroy(tsi_handshaker_result *self) {
-  if (self == NULL) return;
+void tsi_handshaker_result_destroy(tsi_handshaker_result* self) {
+  if (self == nullptr) return;
   self->vtable->destroy(self);
 }
 
@@ -249,7 +255,7 @@ tsi_peer_property tsi_init_peer_property(void) {
   return property;
 }
 
-static void tsi_peer_destroy_list_property(tsi_peer_property *children,
+static void tsi_peer_destroy_list_property(tsi_peer_property* children,
                                            size_t child_count) {
   size_t i;
   for (i = 0; i < child_count; i++) {
@@ -258,46 +264,46 @@ static void tsi_peer_destroy_list_property(tsi_peer_property *children,
   gpr_free(children);
 }
 
-void tsi_peer_property_destruct(tsi_peer_property *property) {
-  if (property->name != NULL) {
+void tsi_peer_property_destruct(tsi_peer_property* property) {
+  if (property->name != nullptr) {
     gpr_free(property->name);
   }
-  if (property->value.data != NULL) {
+  if (property->value.data != nullptr) {
     gpr_free(property->value.data);
   }
   *property = tsi_init_peer_property(); /* Reset everything to 0. */
 }
 
-void tsi_peer_destruct(tsi_peer *self) {
-  if (self == NULL) return;
-  if (self->properties != NULL) {
+void tsi_peer_destruct(tsi_peer* self) {
+  if (self == nullptr) return;
+  if (self->properties != nullptr) {
     tsi_peer_destroy_list_property(self->properties, self->property_count);
-    self->properties = NULL;
+    self->properties = nullptr;
   }
   self->property_count = 0;
 }
 
 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) {
   *property = tsi_init_peer_property();
-  if (name != NULL) property->name = gpr_strdup(name);
+  if (name != nullptr) property->name = gpr_strdup(name);
   if (value_length > 0) {
-    property->value.data = gpr_zalloc(value_length);
+    property->value.data = (char*)gpr_zalloc(value_length);
     property->value.length = value_length;
   }
   return TSI_OK;
 }
 
 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) {
   return tsi_construct_string_peer_property(name, value, strlen(value),
                                             property);
 }
 
-tsi_result tsi_construct_string_peer_property(const char *name,
-                                              const char *value,
+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 result = tsi_construct_allocated_string_peer_property(
       name, value_length, property);
   if (result != TSI_OK) return result;
@@ -307,10 +313,11 @@ tsi_result tsi_construct_string_peer_property(const char *name,
   return TSI_OK;
 }
 
-tsi_result tsi_construct_peer(size_t property_count, tsi_peer *peer) {
+tsi_result tsi_construct_peer(size_t property_count, tsi_peer* peer) {
   memset(peer, 0, sizeof(tsi_peer));
   if (property_count > 0) {
-    peer->properties = gpr_zalloc(property_count * sizeof(tsi_peer_property));
+    peer->properties = (tsi_peer_property*)gpr_zalloc(
+        property_count * sizeof(tsi_peer_property));
     peer->property_count = property_count;
   }
   return TSI_OK;