Add OSSTATUS_LOG API

net/base/x509_certificate_mac.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/base/x509_certificate.h"
 
 #include <CommonCrypto/CommonDigest.h>
 #include <CoreServices/CoreServices.h>
 #include <Security/Security.h>
 #include <time.h>
 
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/mac/mac_logging.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/singleton.h"
 #include "base/pickle.h"
 #include "base/sha1.h"
 #include "base/sys_string_conversions.h"
 #include "crypto/cssm_init.h"
 #include "crypto/nss_util.h"
 #include "crypto/rsa_private_key.h"
 #include "crypto/sha2.h"
 #include "net/base/asn1_util.h"
@@ skipping 20 matching lines @@
   switch (status) {
     case noErr:
       return OK;
     case errSecNotAvailable:
     case errSecNoCertificateModule:
     case errSecNoPolicyModule:
       return ERR_NOT_IMPLEMENTED;
     case errSecAuthFailed:
       return ERR_ACCESS_DENIED;
     default: {
-      base::mac::ScopedCFTypeRef<CFStringRef> error_string(
-          SecCopyErrorMessageString(status, NULL));
-      LOG(ERROR) << "Unknown error " << status
-                 << " (" << base::SysCFStringRefToUTF8(error_string) << ")"
-                 << " mapped to ERR_FAILED";
+      OSSTATUS_LOG(ERROR, status) << "Unknown error mapped to ERR_FAILED";
       return ERR_FAILED;
     }
   }
 }
 
 CertStatus CertStatusFromOSStatus(OSStatus status) {
   switch (status) {
     case noErr:
       return 0;
 
@@ skipping 43 matching lines @@
       return CERT_STATUS_UNABLE_TO_CHECK_REVOCATION;
 
     case CSSMERR_APPLETP_CRL_BAD_URI:
     case CSSMERR_APPLETP_IDP_FAIL:
       return CERT_STATUS_INVALID;
 
     default: {
       // Failure was due to something Chromium doesn't define a
       // specific status for (such as basic constraints violation, or
       // unknown critical extension)
-      base::mac::ScopedCFTypeRef<CFStringRef> error_string(
-          SecCopyErrorMessageString(status, NULL));
-      LOG(WARNING) << "Unknown error " << status
-                   << " (" << base::SysCFStringRefToUTF8(error_string) << ")"
-                   << " mapped to CERT_STATUS_INVALID";
+      OSSTATUS_LOG(WARNING, status)
+          << "Unknown error mapped to CERT_STATUS_INVALID";
       return CERT_STATUS_INVALID;
     }
   }
 }
 
 // Wrapper for a CSSM_DATA_PTR that was obtained via one of the CSSM field
 // accessors (such as CSSM_CL_CertGet[First/Next]Value or
 // CSSM_CL_CertGet[First/Next]CachedValue).
 class CSSMFieldValue {
  public:
@@ skipping 390 matching lines @@
                               X509Certificate::OSCertHandles* output) {
   SecExternalFormat input_format = format;
   ScopedCFTypeRef<CFDataRef> local_data(CFDataCreateWithBytesNoCopy(
       kCFAllocatorDefault, reinterpret_cast<const UInt8*>(data), length,
       kCFAllocatorNull));
 
   CFArrayRef items = NULL;
   OSStatus status = SecKeychainItemImport(local_data, NULL, &input_format,
                                           NULL, 0, NULL, NULL, &items);
   if (status) {
-    DLOG(WARNING) << status << " Unable to import items from data of length "
-                  << length;
+    OSSTATUS_DLOG(WARNING, status)
+        << "Unable to import items from data of length " << length;
     return;
   }
 
   ScopedCFTypeRef<CFArrayRef> scoped_items(items);
   CFTypeID cert_type_id = SecCertificateGetTypeID();
 
   for (CFIndex i = 0; i < CFArrayGetCount(items); ++i) {
     SecKeychainItemRef item = reinterpret_cast<SecKeychainItemRef>(
         const_cast<void*>(CFArrayGetValueAtIndex(items, i)));
 
@@ skipping 228 matching lines @@
 // static
 X509Certificate* X509Certificate::CreateSelfSigned(
     crypto::RSAPrivateKey* key,
     const std::string& subject,
     uint32 serial_number,
     base::TimeDelta valid_duration) {
   DCHECK(key);
   DCHECK(!subject.empty());
 
   if (valid_duration.InSeconds() > kuint32max) {
-     LOG(ERROR) << "valid_duration too big" << valid_duration.InSeconds();
+     LOG(ERROR) << "valid_duration too big " << valid_duration.InSeconds();
      valid_duration = base::TimeDelta::FromSeconds(kuint32max);
   }
 
   // There is a comment in
   // http://www.opensource.apple.com/source/security_certtool/security_certtool-31828/src/CertTool.cpp
   // that serial_numbers being passed into CSSM_TP_SubmitCredRequest can't have
   // their high bit set. We will continue though and mask it out below.
   if (serial_number & 0x80000000)
     LOG(ERROR) << "serial_number has high bit set " << serial_number;
 
@@ skipping 99 matching lines @@
   }
 
   CSSM_ENCODED_CERT* encCert =
       reinterpret_cast<CSSM_ENCODED_CERT*>(resultSet->Results);
   base::mac::ScopedCFTypeRef<SecCertificateRef> scoped_cert;
   SecCertificateRef certificate_ref = NULL;
   OSStatus os_status =
       SecCertificateCreateFromData(&encCert->CertBlob, encCert->CertType,
                                    encCert->CertEncoding, &certificate_ref);
   if (os_status != 0) {
-    DLOG(ERROR) << "SecCertificateCreateFromData failed: " << os_status;
+    OSSTATUS_DLOG(ERROR, os_status) << "SecCertificateCreateFromData failed";
     return NULL;
   }
   scoped_cert.reset(certificate_ref);
 
   return CreateFromHandle(scoped_cert, X509Certificate::OSCertHandles());
 }
 
 void X509Certificate::GetSubjectAltName(
     std::vector<std::string>* dns_names,
     std::vector<std::string>* ip_addrs) const {
@@ skipping 404 matching lines @@
     if (!ExtendedKeyUsageAllows(ext_key_usage, &CSSMOID_ClientAuth))
       return false;
   }
   return true;
 }
 
 bool X509Certificate::IsIssuedBy(
     const std::vector<CertPrincipal>& valid_issuers) {
   // Get the cert's issuer chain.
   CFArrayRef cert_chain = NULL;
-  OSStatus result;
-  result = CopyCertChain(os_cert_handle(), &cert_chain);
+  OSStatus result = CopyCertChain(os_cert_handle(), &cert_chain);
   if (result)
     return false;
   ScopedCFTypeRef<CFArrayRef> scoped_cert_chain(cert_chain);
 
   // Check all the certs in the chain for a match.
   int n = CFArrayGetCount(cert_chain);
   for (int i = 0; i < n; ++i) {
     SecCertificateRef cert_handle = reinterpret_cast<SecCertificateRef>(
         const_cast<void*>(CFArrayGetValueAtIndex(cert_chain, i)));
     scoped_refptr<X509Certificate> cert(X509Certificate::CreateFromHandle(
@@ skipping 149 matching lines @@
     // The cert passes, so add it to the vector.
     // If it's the preferred identity, add it at the start (so it'll be
     // selected by default in the UI.)
     if (is_preferred)
       certs->insert(certs->begin(), cert);
     else
       certs->push_back(cert);
   }
 
   if (err != errSecItemNotFound) {
-    LOG(ERROR) << "SecIdentitySearch error " << err;
+    OSSTATUS_LOG(ERROR, err) << "SecIdentitySearch error ";

[wtc, 2012/01/28 00:06:26]

Nit: the space at the end of the string isn't needed?

     return false;
   }
   return true;
 }
 
 CFArrayRef X509Certificate::CreateClientCertificateChain() const {
   // Initialize the result array with just the IdentityRef of the receiver:
-  OSStatus result;
   SecIdentityRef identity;
-  result = SecIdentityCreateWithCertificate(NULL, cert_handle_, &identity);
+  OSStatus result =
+      SecIdentityCreateWithCertificate(NULL, cert_handle_, &identity);
   if (result) {
-    LOG(ERROR) << "SecIdentityCreateWithCertificate error " << result;
+    OSSTATUS_LOG(ERROR, result) << "SecIdentityCreateWithCertificate error";
     return NULL;
   }
   ScopedCFTypeRef<CFMutableArrayRef> chain(
       CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks));
   CFArrayAppendValue(chain, identity);
 
   CFArrayRef cert_chain = NULL;
   result = CopyCertChain(cert_handle_, &cert_chain);
   ScopedCFTypeRef<CFArrayRef> scoped_cert_chain(cert_chain);
   if (result) {
-    LOG(ERROR) << "CreateIdentityCertificateChain error " << result;
+    OSSTATUS_LOG(ERROR, result) << "CreateIdentityCertificateChain error";
     return chain.release();
   }
 
   // Append the intermediate certs from SecTrust to the result array:
   if (cert_chain) {
     int chain_count = CFArrayGetCount(cert_chain);
     if (chain_count > 1) {
       CFArrayAppendArray(chain,
                          cert_chain,
                          CFRangeMake(1, chain_count - 1));
@@ skipping 80 matching lines @@
       *type = kPublicKeyTypeDH;
       break;
     default:
       *type = kPublicKeyTypeUnknown;
       *size_bits = 0;
       break;
   }
 }
 
 }  // namespace net