Clang format slam.

net/test/openssl_helper.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This helper binary is only used for testing Chrome's SSL stack.
 
 #include <sys/types.h>
 #include <sys/socket.h>
 
 #include <openssl/bio.h>
 #include <openssl/ssl.h>
 #include <openssl/err.h>
 
 static const char kDefaultPEMFile[] = "net/data/ssl/certificates/ok_cert.pem";
 
 // Server Name Indication callback from OpenSSL
-static int sni_cb(SSL *s, int *ad, void *arg) {
+static int sni_cb(SSL* s, int* ad, void* arg) {
   const char* servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
   if (servername && strcmp(servername, "test.example.com") == 0)
     *reinterpret_cast<bool*>(arg) = true;
 
   return SSL_TLSEXT_ERR_OK;
 }
 
 // Client certificate verification callback from OpenSSL
-static int verify_cb(int preverify_ok, X509_STORE_CTX *ctx) {
+static int verify_cb(int preverify_ok, X509_STORE_CTX* ctx) {
   return 1;
 }
 
 // Next Protocol Negotiation callback from OpenSSL
-static int next_proto_cb(SSL *ssl, const unsigned char **out,
-                         unsigned int *outlen, void *arg) {
+static int next_proto_cb(SSL* ssl,
+                         const unsigned char** out,
+                         unsigned int* outlen,
+                         void* arg) {
   bool* npn_mispredict = reinterpret_cast<bool*>(arg);
   static char kProtos[] = "\003foo\003bar";
   static char kProtos2[] = "\003baz\003boo";
   static unsigned count = 0;
 
   if (!*npn_mispredict || count == 0) {
-    *out = (const unsigned char*) kProtos;
+    *out = (const unsigned char*)kProtos;
     *outlen = sizeof(kProtos) - 1;
   } else {
-    *out = (const unsigned char*) kProtos2;
+    *out = (const unsigned char*)kProtos2;
     *outlen = sizeof(kProtos2) - 1;
   }
   count++;
   return SSL_TLSEXT_ERR_OK;
 }
 
-int
-main(int argc, char **argv) {
+int main(int argc, char** argv) {
   SSL_library_init();
   ERR_load_crypto_strings();
   OpenSSL_add_all_algorithms();
   SSL_load_error_strings();
 
   bool sni = false, sni_good = false, snap_start = false;
   bool snap_start_recovery = false, sslv3 = false, session_tickets = false;
   bool fail_resume = false, client_cert = false, npn = false;
   bool npn_mispredict = false;
 
@@ skipping 64 matching lines @@
     SSL_CTX_set_tlsext_servername_callback(ctx, sni_cb);
     SSL_CTX_set_tlsext_servername_arg(ctx, &sni_good);
   }
 
   BIO* key = BIO_new(BIO_s_file());
   if (BIO_read_filename(key, key_file) <= 0) {
     fprintf(stderr, "Failed to read %s\n", key_file);
     return 1;
   }
 
-  EVP_PKEY *pkey = PEM_read_bio_PrivateKey(key, NULL, NULL, NULL);
+  EVP_PKEY* pkey = PEM_read_bio_PrivateKey(key, NULL, NULL, NULL);
   if (!pkey) {
     fprintf(stderr, "Failed to parse %s\n", key_file);
     return 1;
   }
   BIO_free(key);
 
-
   BIO* cert = BIO_new(BIO_s_file());
   if (BIO_read_filename(cert, cert_file) <= 0) {
     fprintf(stderr, "Failed to read %s\n", cert_file);
     return 1;
   }
 
-  X509 *pcert = PEM_read_bio_X509_AUX(cert, NULL, NULL, NULL);
+  X509* pcert = PEM_read_bio_X509_AUX(cert, NULL, NULL, NULL);
   if (!pcert) {
     fprintf(stderr, "Failed to parse %s\n", cert_file);
     return 1;
   }
   BIO_free(cert);
 
   if (SSL_CTX_use_certificate(ctx, pcert) <= 0) {
     fprintf(stderr, "Failed to load %s\n", cert_file);
     return 1;
   }
@@ skipping 30 matching lines @@
 
   for (unsigned connections = 0; connections < connection_limit;
        connections++) {
     const int fd = accept(3, NULL, NULL);
 
     SSL* server = SSL_new(ctx);
     BIO* bio = BIO_new_socket(fd, 1 /* take ownership of fd */);
     SSL_set_bio(server, bio, bio);
 
     if (fail_resume) {
-      SSL_set_session_id_context(server, (unsigned char*) &connections,
-                                 sizeof(connections));
+      SSL_set_session_id_context(
+          server, (unsigned char*)&connections, sizeof(connections));
     }
 
     int err;
     for (;;) {
       const int ret = SSL_accept(server);
       if (ret == 1)
         break;
 
       err = SSL_get_error(server, ret);
       if (err == SSL_ERROR_WANT_READ)
         continue;
       if (err == SSL_ERROR_SERVER_RANDOM_VALIDATION_PENDING && snap_start) {
-        SSL_set_suggested_server_random_validity(
-            server, !snap_start_recovery);
+        SSL_set_suggested_server_random_validity(server, !snap_start_recovery);
         continue;
       }
       ERR_print_errors_fp(stderr);
       fprintf(stderr, "SSL_accept failed: %d\n", err);
       return 1;
     }
 
     if (sni && !sni_good) {
       fprintf(stderr, "SNI failed\n");
       return 1;
     }
 
     if (npn) {
-      const unsigned char *data, *expected_data;
+      const unsigned char* data, *expected_data;
       unsigned len, expected_len;
       SSL_get0_next_proto_negotiated(server, &data, &len);
       if (!npn_mispredict || connections == 0) {
-        expected_data = (unsigned char*) "foo";
+        expected_data = (unsigned char*)"foo";
         expected_len = 3;
       } else {
-        expected_data = (unsigned char*) "baz";
+        expected_data = (unsigned char*)"baz";
         expected_len = 3;
       }
       if (len != expected_len || memcmp(data, expected_data, len) != 0) {
         fprintf(stderr, "Bad NPN: %d\n", len);
         return 1;
       }
     }
 
     unsigned char buffer[6];
 
     int ret = SSL_read(server, buffer, sizeof(buffer));
     if (ret == -1) {
       err = SSL_get_error(server, ret);
       ERR_print_errors_fp(stderr);
       fprintf(stderr, "SSL_read failed: %d\n", err);
     }
     if (memcmp(buffer, "hello!", sizeof(buffer)) == 0) {
       SSL_write(server, "goodbye!", 8);
     }
 
     SSL_shutdown(server);
     SSL_shutdown(server);
   }
 
   SSL_CTX_free(ctx);
 
   return 0;
 }