Merge master

2 files changed, 59 insertions, 59 deletions

diff --git a/test/core/handshake/client_ssl.cc b/test/core/handshake/client_ssl.cc
index f501948b96..b8cfd627a9 100644
--- a/test/core/handshake/client_ssl.cc
+++ b/test/core/handshake/client_ssl.cc
@@ -46,13 +46,13 @@
 // Arguments for TLS server thread.
 typedef struct {
   int socket;
-  char *alpn_preferred;
+  char* alpn_preferred;
 } server_args;
 
 // Based on https://wiki.openssl.org/index.php/Simple_TLS_Server.
 // Pick an arbitrary unused port and return it in *out_port. Return
 // an fd>=0 on success.
-static int create_socket(int *out_port) {
+static int create_socket(int* out_port) {
   int s;
   struct sockaddr_in addr;
   socklen_t addr_len;
@@ -68,7 +68,7 @@ static int create_socket(int *out_port) {
     return -1;
   }
 
-  if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+  if (bind(s, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
     perror("Unable to bind");
     gpr_log(GPR_ERROR, "%s", "Unable to bind to any port");
     close(s);
@@ -82,7 +82,7 @@ static int create_socket(int *out_port) {
   }
 
   addr_len = sizeof(addr);
-  if (getsockname(s, (struct sockaddr *)&addr, &addr_len) != 0 ||
+  if (getsockname(s, (struct sockaddr*)&addr, &addr_len) != 0 ||
       addr_len > sizeof(addr)) {
     perror("getsockname");
     gpr_log(GPR_ERROR, "%s", "Unable to get socket local address");
@@ -96,19 +96,19 @@ static int create_socket(int *out_port) {
 
 // Server callback during ALPN negotiation. See man page for
 // SSL_CTX_set_alpn_select_cb.
-static int alpn_select_cb(SSL *ssl, const uint8_t **out, uint8_t *out_len,
-                          const uint8_t *in, unsigned in_len, void *arg) {
-  const uint8_t *alpn_preferred = (const uint8_t *)arg;
+static int alpn_select_cb(SSL* ssl, const uint8_t** out, uint8_t* out_len,
+                          const uint8_t* in, unsigned in_len, void* arg) {
+  const uint8_t* alpn_preferred = (const uint8_t*)arg;
 
   *out = alpn_preferred;
-  *out_len = (uint8_t)strlen((char *)alpn_preferred);
+  *out_len = (uint8_t)strlen((char*)alpn_preferred);
 
   // Validate that the ALPN list includes "h2" and "grpc-exp", that "grpc-exp"
   // precedes "h2".
   bool grpc_exp_seen = false;
   bool h2_seen = false;
-  const char *inp = (const char *)in;
-  const char *in_end = inp + in_len;
+  const char* inp = (const char*)in;
+  const char* in_end = inp + in_len;
   while (inp < in_end) {
     const size_t length = (size_t)*inp++;
     if (length == strlen("grpc-exp") && strncmp(inp, "grpc-exp", length) == 0) {
@@ -132,14 +132,14 @@ static int alpn_select_cb(SSL *ssl, const uint8_t **out, uint8_t *out_len,
 // Minimal TLS server. This is largely based on the example at
 // https://wiki.openssl.org/index.php/Simple_TLS_Server and the gRPC core
 // internals in src/core/tsi/ssl_transport_security.c.
-static void server_thread(void *arg) {
-  const server_args *args = (server_args *)arg;
+static void server_thread(void* arg) {
+  const server_args* args = (server_args*)arg;
 
   SSL_load_error_strings();
   OpenSSL_add_ssl_algorithms();
 
-  const SSL_METHOD *method = TLSv1_2_server_method();
-  SSL_CTX *ctx = SSL_CTX_new(method);
+  const SSL_METHOD* method = TLSv1_2_server_method();
+  SSL_CTX* ctx = SSL_CTX_new(method);
   if (!ctx) {
     perror("Unable to create SSL context");
     ERR_print_errors_fp(stderr);
@@ -158,7 +158,7 @@ static void server_thread(void *arg) {
 
   // Set the cipher list to match the one expressed in
   // src/core/tsi/ssl_transport_security.c.
-  const char *cipher_list =
+  const char* cipher_list =
       "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-"
       "SHA384:ECDHE-RSA-AES256-GCM-SHA384";
   if (!SSL_CTX_set_cipher_list(ctx, cipher_list)) {
@@ -175,14 +175,14 @@ static void server_thread(void *arg) {
   gpr_log(GPR_INFO, "Server listening");
   struct sockaddr_in addr;
   socklen_t len = sizeof(addr);
-  const int client = accept(sock, (struct sockaddr *)&addr, &len);
+  const int client = accept(sock, (struct sockaddr*)&addr, &len);
   if (client < 0) {
     perror("Unable to accept");
     abort();
   }
 
   // Establish a SSL* and accept at SSL layer.
-  SSL *ssl = SSL_new(ctx);
+  SSL* ssl = SSL_new(ctx);
   GPR_ASSERT(ssl);
   SSL_set_fd(ssl, client);
   if (SSL_accept(ssl) <= 0) {
@@ -208,7 +208,7 @@ static void server_thread(void *arg) {
 // establishes a TLS handshake via the core library to the server. The TLS
 // server validates ALPN aspects of the handshake and supplies the protocol
 // specified in the server_alpn_preferred argument to the client.
-static bool client_ssl_test(char *server_alpn_preferred) {
+static bool client_ssl_test(char* server_alpn_preferred) {
   bool success = true;
 
   grpc_init();
@@ -242,24 +242,24 @@ static bool client_ssl_test(char *server_alpn_preferred) {
                                grpc_load_file(SSL_CERT_PATH, 1, &cert_slice)));
   GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
                                grpc_load_file(SSL_KEY_PATH, 1, &key_slice)));
-  const char *ca_cert = (const char *)GRPC_SLICE_START_PTR(ca_slice);
-  pem_key_cert_pair.private_key = (const char *)GRPC_SLICE_START_PTR(key_slice);
-  pem_key_cert_pair.cert_chain = (const char *)GRPC_SLICE_START_PTR(cert_slice);
-  grpc_channel_credentials *ssl_creds =
+  const char* ca_cert = (const char*)GRPC_SLICE_START_PTR(ca_slice);
+  pem_key_cert_pair.private_key = (const char*)GRPC_SLICE_START_PTR(key_slice);
+  pem_key_cert_pair.cert_chain = (const char*)GRPC_SLICE_START_PTR(cert_slice);
+  grpc_channel_credentials* ssl_creds =
       grpc_ssl_credentials_create(ca_cert, &pem_key_cert_pair, NULL);
 
   // Establish a channel pointing at the TLS server. Since the gRPC runtime is
   // lazy, this won't necessarily establish a connection yet.
-  char *target;
+  char* target;
   gpr_asprintf(&target, "127.0.0.1:%d", port);
   grpc_arg ssl_name_override = {
       GRPC_ARG_STRING,
-      const_cast<char *>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),
-      {const_cast<char *>("foo.test.google.fr")}};
+      const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),
+      {const_cast<char*>("foo.test.google.fr")}};
   grpc_channel_args grpc_args;
   grpc_args.num_args = 1;
   grpc_args.args = &ssl_name_override;
-  grpc_channel *channel =
+  grpc_channel* channel =
       grpc_secure_channel_create(ssl_creds, target, &grpc_args, NULL);
   GPR_ASSERT(channel);
   gpr_free(target);
@@ -274,7 +274,7 @@ static bool client_ssl_test(char *server_alpn_preferred) {
   // completed and we know that the client's ALPN list satisfied the server.
   int retries = 10;
   grpc_connectivity_state state = GRPC_CHANNEL_IDLE;
-  grpc_completion_queue *cq = grpc_completion_queue_create_for_next(NULL);
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(NULL);
 
   while (state != GRPC_CHANNEL_READY && retries-- > 0) {
     grpc_channel_watch_connectivity_state(
@@ -303,21 +303,21 @@ static bool client_ssl_test(char *server_alpn_preferred) {
   return success;
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   // Handshake succeeeds when the server has grpc-exp as the ALPN preference.
-  GPR_ASSERT(client_ssl_test(const_cast<char *>("grpc-exp")));
+  GPR_ASSERT(client_ssl_test(const_cast<char*>("grpc-exp")));
   // Handshake succeeeds when the server has h2 as the ALPN preference. This
   // covers legacy gRPC servers which don't support grpc-exp.
-  GPR_ASSERT(client_ssl_test(const_cast<char *>("h2")));
+  GPR_ASSERT(client_ssl_test(const_cast<char*>("h2")));
   // Handshake fails when the server uses a fake protocol as its ALPN
   // preference. This validates the client is correctly validating ALPN returns
   // and sanity checks the client_ssl_test.
-  GPR_ASSERT(!client_ssl_test(const_cast<char *>("foo")));
+  GPR_ASSERT(!client_ssl_test(const_cast<char*>("foo")));
   return 0;
 }
 
 #else /* GRPC_POSIX_SOCKET */
 
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
 
 #endif /* GRPC_POSIX_SOCKET */
diff --git a/test/core/handshake/server_ssl.cc b/test/core/handshake/server_ssl.cc
index 7b24459688..bb92c8435a 100644
--- a/test/core/handshake/server_ssl.cc
+++ b/test/core/handshake/server_ssl.cc
@@ -55,7 +55,7 @@ static int create_socket(int port) {
     return -1;
   }
 
-  if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+  if (connect(s, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
     perror("Unable to connect");
     return -1;
   }
@@ -64,8 +64,8 @@ static int create_socket(int port) {
 }
 
 // Simple gRPC server. This listens until client_handshake_complete occurs.
-static void server_thread(void *arg) {
-  const int port = *(int *)arg;
+static void server_thread(void* arg) {
+  const int port = *(int*)arg;
 
   // Load key pair and establish server SSL credentials.
   grpc_ssl_pem_key_cert_pair pem_key_cert_pair;
@@ -76,20 +76,20 @@ static void server_thread(void *arg) {
                                grpc_load_file(SSL_CERT_PATH, 1, &cert_slice)));
   GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
                                grpc_load_file(SSL_KEY_PATH, 1, &key_slice)));
-  const char *ca_cert = (const char *)GRPC_SLICE_START_PTR(ca_slice);
-  pem_key_cert_pair.private_key = (const char *)GRPC_SLICE_START_PTR(key_slice);
-  pem_key_cert_pair.cert_chain = (const char *)GRPC_SLICE_START_PTR(cert_slice);
-  grpc_server_credentials *ssl_creds = grpc_ssl_server_credentials_create(
+  const char* ca_cert = (const char*)GRPC_SLICE_START_PTR(ca_slice);
+  pem_key_cert_pair.private_key = (const char*)GRPC_SLICE_START_PTR(key_slice);
+  pem_key_cert_pair.cert_chain = (const char*)GRPC_SLICE_START_PTR(cert_slice);
+  grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
       ca_cert, &pem_key_cert_pair, 1, 0, NULL);
 
   // Start server listening on local port.
-  char *addr;
+  char* addr;
   gpr_asprintf(&addr, "127.0.0.1:%d", port);
-  grpc_server *server = grpc_server_create(NULL, NULL);
+  grpc_server* server = grpc_server_create(NULL, NULL);
   GPR_ASSERT(grpc_server_add_secure_http2_port(server, addr, ssl_creds));
   free(addr);
 
-  grpc_completion_queue *cq = grpc_completion_queue_create_for_next(NULL);
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(NULL);
 
   grpc_server_register_completion_queue(server, cq, NULL);
   grpc_server_start(server);
@@ -123,8 +123,8 @@ static void server_thread(void *arg) {
 // TLS handshake via a minimal TLS client. The TLS client has configurable (via
 // alpn_list) ALPN settings and can probe at the supported ALPN preferences
 // using this (via alpn_expected).
-static bool server_ssl_test(const char *alpn_list[], unsigned int alpn_list_len,
-                            const char *alpn_expected) {
+static bool server_ssl_test(const char* alpn_list[], unsigned int alpn_list_len,
+                            const char* alpn_expected) {
   bool success = true;
 
   grpc_init();
@@ -140,8 +140,8 @@ static bool server_ssl_test(const char *alpn_list[], unsigned int alpn_list_len,
   SSL_load_error_strings();
   OpenSSL_add_ssl_algorithms();
 
-  const SSL_METHOD *method = TLSv1_2_client_method();
-  SSL_CTX *ctx = SSL_CTX_new(method);
+  const SSL_METHOD* method = TLSv1_2_client_method();
+  SSL_CTX* ctx = SSL_CTX_new(method);
   if (!ctx) {
     perror("Unable to create SSL context");
     ERR_print_errors_fp(stderr);
@@ -160,7 +160,7 @@ static bool server_ssl_test(const char *alpn_list[], unsigned int alpn_list_len,
 
   // Set the cipher list to match the one expressed in
   // src/core/tsi/ssl_transport_security.c.
-  const char *cipher_list =
+  const char* cipher_list =
       "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-"
       "SHA384:ECDHE-RSA-AES256-GCM-SHA384";
   if (!SSL_CTX_set_cipher_list(ctx, cipher_list)) {
@@ -175,9 +175,9 @@ static bool server_ssl_test(const char *alpn_list[], unsigned int alpn_list_len,
   for (unsigned int i = 0; i < alpn_list_len; ++i) {
     alpn_protos_len += (unsigned int)strlen(alpn_list[i]);
   }
-  unsigned char *alpn_protos =
-      static_cast<unsigned char *>(gpr_malloc(alpn_protos_len));
-  unsigned char *p = alpn_protos;
+  unsigned char* alpn_protos =
+      static_cast<unsigned char*>(gpr_malloc(alpn_protos_len));
+  unsigned char* p = alpn_protos;
   for (unsigned int i = 0; i < alpn_list_len; ++i) {
     const uint8_t len = (uint8_t)strlen(alpn_list[i]);
     *p++ = len;
@@ -200,7 +200,7 @@ static bool server_ssl_test(const char *alpn_list[], unsigned int alpn_list_len,
   gpr_log(GPR_INFO, "Connected to server on port %d", port);
 
   // Establish a SSL* and connect at SSL layer.
-  SSL *ssl = SSL_new(ctx);
+  SSL* ssl = SSL_new(ctx);
   GPR_ASSERT(ssl);
   SSL_set_fd(ssl, sock);
   if (SSL_connect(ssl) <= 0) {
@@ -210,12 +210,12 @@ static bool server_ssl_test(const char *alpn_list[], unsigned int alpn_list_len,
   } else {
     gpr_log(GPR_INFO, "Handshake successful.");
     // Validate ALPN preferred by server matches alpn_expected.
-    const unsigned char *alpn_selected;
+    const unsigned char* alpn_selected;
     unsigned int alpn_selected_len;
     SSL_get0_alpn_selected(ssl, &alpn_selected, &alpn_selected_len);
     if (strlen(alpn_expected) != alpn_selected_len ||
-        strncmp((const char *)alpn_selected, alpn_expected,
-                alpn_selected_len) != 0) {
+        strncmp((const char*)alpn_selected, alpn_expected, alpn_selected_len) !=
+            0) {
       gpr_log(GPR_ERROR, "Unexpected ALPN protocol preference");
       success = false;
     }
@@ -235,22 +235,22 @@ static bool server_ssl_test(const char *alpn_list[], unsigned int alpn_list_len,
   return success;
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   // Handshake succeeeds when the client supplies the standard ALPN list.
-  const char *full_alpn_list[] = {"grpc-exp", "h2"};
+  const char* full_alpn_list[] = {"grpc-exp", "h2"};
   GPR_ASSERT(server_ssl_test(full_alpn_list, 2, "grpc-exp"));
   // Handshake succeeeds when the client supplies only h2 as the ALPN list. This
   // covers legacy gRPC clients which don't support grpc-exp.
-  const char *h2_only_alpn_list[] = {"h2"};
+  const char* h2_only_alpn_list[] = {"h2"};
   GPR_ASSERT(server_ssl_test(h2_only_alpn_list, 1, "h2"));
   // Handshake succeeds when the client supplies superfluous ALPN entries and
   // also when h2 precedes gprc-exp.
-  const char *extra_alpn_list[] = {"foo", "h2", "bar", "grpc-exp"};
+  const char* extra_alpn_list[] = {"foo", "h2", "bar", "grpc-exp"};
   GPR_ASSERT(server_ssl_test(extra_alpn_list, 4, "h2"));
   // Handshake fails when the client uses a fake protocol as its only ALPN
   // preference. This validates the server is correctly validating ALPN
   // and sanity checks the server_ssl_test.
-  const char *fake_alpn_list[] = {"foo"};
+  const char* fake_alpn_list[] = {"foo"};
   GPR_ASSERT(!server_ssl_test(fake_alpn_list, 1, "foo"));
   return 0;
 }