Clang format slam.

net/cert/x509_certificate_openssl.cc

 // Copyright (c) 2012 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.
 
 #include "net/cert/x509_certificate.h"
 
 #include <openssl/asn1.h>
 #include <openssl/crypto.h>
 #include <openssl/obj_mac.h>
 #include <openssl/pem.h>
@@ skipping 15 matching lines @@
 #if defined(OS_ANDROID)
 #include "base/logging.h"
 #include "net/android/network_library.h"
 #endif
 
 namespace net {
 
 namespace {
 
 void CreateOSCertHandlesFromPKCS7Bytes(
-    const char* data, int length,
+    const char* data,
+    int length,
     X509Certificate::OSCertHandles* handles) {
   crypto::EnsureOpenSSLInit();
   const unsigned char* der_data = reinterpret_cast<const unsigned char*>(data);
   crypto::ScopedOpenSSL<PKCS7, PKCS7_free> pkcs7_cert(
       d2i_PKCS7(NULL, &der_data, length));
   if (!pkcs7_cert.get())
     return;
 
   STACK_OF(X509)* certs = NULL;
   int nid = OBJ_obj2nid(pkcs7_cert.get()->type);
@@ skipping 23 matching lines @@
     fields->push_back(field);
   }
 }
 
 void ParsePrincipal(X509Certificate::OSCertHandle cert,
                     X509_NAME* x509_name,
                     CertPrincipal* principal) {
   if (!x509_name)
     return;
 
-  ParsePrincipalValues(x509_name, NID_streetAddress,
-                       &principal->street_addresses);
-  ParsePrincipalValues(x509_name, NID_organizationName,
-                       &principal->organization_names);
-  ParsePrincipalValues(x509_name, NID_organizationalUnitName,
+  ParsePrincipalValues(
+      x509_name, NID_streetAddress, &principal->street_addresses);
+  ParsePrincipalValues(
+      x509_name, NID_organizationName, &principal->organization_names);
+  ParsePrincipalValues(x509_name,
+                       NID_organizationalUnitName,
                        &principal->organization_unit_names);
-  ParsePrincipalValues(x509_name, NID_domainComponent,
-                       &principal->domain_components);
+  ParsePrincipalValues(
+      x509_name, NID_domainComponent, &principal->domain_components);
 
-  x509_util::ParsePrincipalValueByNID(x509_name, NID_commonName,
-                                      &principal->common_name);
-  x509_util::ParsePrincipalValueByNID(x509_name, NID_localityName,
-                                      &principal->locality_name);
-  x509_util::ParsePrincipalValueByNID(x509_name, NID_stateOrProvinceName,
-                                      &principal->state_or_province_name);
-  x509_util::ParsePrincipalValueByNID(x509_name, NID_countryName,
-                                      &principal->country_name);
+  x509_util::ParsePrincipalValueByNID(
+      x509_name, NID_commonName, &principal->common_name);
+  x509_util::ParsePrincipalValueByNID(
+      x509_name, NID_localityName, &principal->locality_name);
+  x509_util::ParsePrincipalValueByNID(
+      x509_name, NID_stateOrProvinceName, &principal->state_or_province_name);
+  x509_util::ParsePrincipalValueByNID(
+      x509_name, NID_countryName, &principal->country_name);
 }
 
 void ParseSubjectAltName(X509Certificate::OSCertHandle cert,
                          std::vector<std::string>* dns_names,
                          std::vector<std::string>* ip_addresses) {
   DCHECK(dns_names || ip_addresses);
   int index = X509_get_ext_by_NID(cert, NID_subject_alt_name, -1);
   X509_EXTENSION* alt_name_ext = X509_get_ext(cert, index);
   if (!alt_name_ext)
     return;
@@ skipping 29 matching lines @@
           std::string(reinterpret_cast<const char*>(ip_addr), ip_addr_len));
     }
   }
 }
 
 struct DERCache {
   unsigned char* data;
   int data_length;
 };
 
-void DERCache_free(void* parent, void* ptr, CRYPTO_EX_DATA* ad, int idx,
-                   long argl, void* argp) {
+void DERCache_free(void* parent,
+                   void* ptr,
+                   CRYPTO_EX_DATA* ad,
+                   int idx,
+                   long argl,
+                   void* argp) {
   DERCache* der_cache = static_cast<DERCache*>(ptr);
   if (!der_cache)
-      return;
+    return;
   if (der_cache->data)
-      OPENSSL_free(der_cache->data);
+    OPENSSL_free(der_cache->data);
   OPENSSL_free(der_cache);
 }
 
 class X509InitSingleton {
  public:
   static X509InitSingleton* GetInstance() {
     // We allow the X509 store to leak, because it is used from a non-joinable
     // worker that is not stopped on shutdown, hence may still be using
     // OpenSSL library after the AtExit runner has completed.
     return Singleton<X509InitSingleton,
@@ skipping 22 matching lines @@
   crypto::ScopedOpenSSL<X509_STORE, X509_STORE_free> store_;
 
   DISALLOW_COPY_AND_ASSIGN(X509InitSingleton);
 };
 
 // Takes ownership of |data| (which must have been allocated by OpenSSL).
 DERCache* SetDERCache(X509Certificate::OSCertHandle cert,
                       int x509_der_cache_index,
                       unsigned char* data,
                       int data_length) {
-  DERCache* internal_cache = static_cast<DERCache*>(
-      OPENSSL_malloc(sizeof(*internal_cache)));
+  DERCache* internal_cache =
+      static_cast<DERCache*>(OPENSSL_malloc(sizeof(*internal_cache)));
   if (!internal_cache) {
     // We took ownership of |data|, so we must free if we can't add it to
     // |cert|.
     OPENSSL_free(data);
     return NULL;
   }
 
   internal_cache->data = data;
   internal_cache->data_length = data_length;
   X509_set_ex_data(cert, x509_der_cache_index, internal_cache);
   return internal_cache;
 }
 
 // Returns true if |der_cache| points to valid data, false otherwise.
 // (note: the DER-encoded data in |der_cache| is owned by |cert|, callers should
 // not free it).
 bool GetDERAndCacheIfNeeded(X509Certificate::OSCertHandle cert,
                             DERCache* der_cache) {
   int x509_der_cache_index =
       X509InitSingleton::GetInstance()->der_cache_ex_index();
 
   // Re-encoding the DER data via i2d_X509 is an expensive operation, but it's
   // necessary for comparing two certificates. We re-encode at most once per
   // certificate and cache the data within the X509 cert using X509_set_ex_data.
-  DERCache* internal_cache = static_cast<DERCache*>(
-      X509_get_ex_data(cert, x509_der_cache_index));
+  DERCache* internal_cache =
+      static_cast<DERCache*>(X509_get_ex_data(cert, x509_der_cache_index));
   if (!internal_cache) {
     unsigned char* data = NULL;
     int data_length = i2d_X509(cert, &data);
     if (data_length <= 0 || !data)
       return false;
     internal_cache = SetDERCache(cert, x509_der_cache_index, data, data_length);
     if (!internal_cache)
       return false;
   }
   *der_cache = *internal_cache;
   return true;
 }
 
 // Used to free a list of X509_NAMEs and the objects it points to.
-void sk_X509_NAME_free_all(STACK_OF(X509_NAME)* sk) {
+void sk_X509_NAME_free_all(STACK_OF(X509_NAME) * sk) {
   sk_X509_NAME_pop_free(sk, X509_NAME_free);
 }
 
 }  // namespace
 
 // static
 X509Certificate::OSCertHandle X509Certificate::DupOSCertHandle(
     OSCertHandle cert_handle) {
   DCHECK(cert_handle);
   // Using X509_dup causes the entire certificate to be reparsed. This
@@ skipping 68 matching lines @@
       return sha1;
     SHA1_Update(&sha1_ctx, der_cache.data, der_cache.data_length);
   }
   SHA1_Final(sha1.data, &sha1_ctx);
 
   return sha1;
 }
 
 // static
 X509Certificate::OSCertHandle X509Certificate::CreateOSCertHandleFromBytes(
-    const char* data, int length) {
+    const char* data,
+    int length) {
   if (length < 0)
     return NULL;
   crypto::EnsureOpenSSLInit();
-  const unsigned char* d2i_data =
-      reinterpret_cast<const unsigned char*>(data);
+  const unsigned char* d2i_data = reinterpret_cast<const unsigned char*>(data);
   // Don't cache this data via SetDERCache as this wire format may be not be
   // identical from the i2d_X509 roundtrip.
   X509* cert = d2i_X509(NULL, &d2i_data, length);
   return cert;
 }
 
 // static
 X509Certificate::OSCertHandles X509Certificate::CreateOSCertHandlesFromBytes(
-    const char* data, int length, Format format) {
+    const char* data,
+    int length,
+    Format format) {
   OSCertHandles results;
   if (length < 0)
     return results;
 
   switch (format) {
     case FORMAT_SINGLE_CERTIFICATE: {
       OSCertHandle handle = CreateOSCertHandleFromBytes(data, length);
       if (handle)
         results.push_back(handle);
       break;
@@ skipping 44 matching lines @@
   DCHECK(a && b);
   if (a == b)
     return true;
 
   // X509_cmp only checks the fingerprint, but we want to compare the whole
   // DER data. Encoding it from OSCertHandle is an expensive operation, so we
   // cache the DER (if not already cached via X509_set_ex_data).
   DERCache der_cache_a, der_cache_b;
 
   return GetDERAndCacheIfNeeded(a, &der_cache_a) &&
-      GetDERAndCacheIfNeeded(b, &der_cache_b) &&
-      der_cache_a.data_length == der_cache_b.data_length &&
-      memcmp(der_cache_a.data, der_cache_b.data, der_cache_a.data_length) == 0;
+         GetDERAndCacheIfNeeded(b, &der_cache_b) &&
+         der_cache_a.data_length == der_cache_b.data_length &&
+         memcmp(der_cache_a.data, der_cache_b.data, der_cache_a.data_length) ==
+             0;
 }
 
 // static
-X509Certificate::OSCertHandle
-X509Certificate::ReadOSCertHandleFromPickle(PickleIterator* pickle_iter) {
+X509Certificate::OSCertHandle X509Certificate::ReadOSCertHandleFromPickle(
+    PickleIterator* pickle_iter) {
   const char* data;
   int length;
   if (!pickle_iter->ReadData(&data, &length))
     return NULL;
 
   return CreateOSCertHandleFromBytes(data, length);
 }
 
 // static
 bool X509Certificate::WriteOSCertHandleToPickle(OSCertHandle cert_handle,
                                                 Pickle* pickle) {
   DERCache der_cache;
   if (!GetDERAndCacheIfNeeded(cert_handle, &der_cache))
     return false;
 
-  return pickle->WriteData(
-      reinterpret_cast<const char*>(der_cache.data),
-      der_cache.data_length);
+  return pickle->WriteData(reinterpret_cast<const char*>(der_cache.data),
+                           der_cache.data_length);
 }
 
 // static
 void X509Certificate::GetPublicKeyInfo(OSCertHandle cert_handle,
                                        size_t* size_bits,
                                        PublicKeyType* type) {
   *type = kPublicKeyTypeUnknown;
   *size_bits = 0;
 
   crypto::ScopedOpenSSL<EVP_PKEY, EVP_PKEY_free> scoped_key(
@@ skipping 30 matching lines @@
     return false;
 
   // Convert to a temporary list of X509_NAME objects.
   // It will own the objects it points to.
   crypto::ScopedOpenSSL<STACK_OF(X509_NAME), sk_X509_NAME_free_all>
       issuer_names(sk_X509_NAME_new_null());
   if (!issuer_names.get())
     return false;
 
   for (std::vector<std::string>::const_iterator it = valid_issuers.begin();
-      it != valid_issuers.end(); ++it) {
-    const unsigned char* p =
-        reinterpret_cast<const unsigned char*>(it->data());
+       it != valid_issuers.end();
+       ++it) {
+    const unsigned char* p = reinterpret_cast<const unsigned char*>(it->data());
     long len = static_cast<long>(it->length());
     X509_NAME* ca_name = d2i_X509_NAME(NULL, &p, len);
     if (ca_name == NULL)
       return false;
     sk_X509_NAME_push(issuer_names.get(), ca_name);
   }
 
   // Create a temporary list of X509_NAME objects corresponding
   // to the certificate chain. It doesn't own the object it points to.
   std::vector<X509_NAME*> cert_names;
   X509_NAME* issuer = X509_get_issuer_name(cert_handle_);
   if (issuer == NULL)
     return false;
 
   cert_names.push_back(issuer);
   for (OSCertHandles::iterator it = intermediate_ca_certs_.begin();
-      it != intermediate_ca_certs_.end(); ++it) {
+       it != intermediate_ca_certs_.end();
+       ++it) {
     issuer = X509_get_issuer_name(*it);
     if (issuer == NULL)
       return false;
     cert_names.push_back(issuer);
   }
 
   // and 'cert_names'.
   for (size_t n = 0; n < cert_names.size(); ++n) {
     for (int m = 0; m < sk_X509_NAME_num(issuer_names.get()); ++m) {
       X509_NAME* issuer = sk_X509_NAME_value(issuer_names.get(), m);
       if (X509_NAME_cmp(issuer, cert_names[n]) == 0) {
         return true;
       }
     }
   }
 
   return false;
 }
 
 }  // namespace net