Include better OpenSSL error information in NetLog.

net/socket/nss_ssl_util.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/socket/nss_ssl_util.h"
 
 #include <nss.h>
 #include <secerr.h>
 #include <ssl.h>
 #include <sslerr.h>
@@ skipping 11 matching lines @@
 #include "build/build_config.h"
 #include "crypto/nss_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/nss_memio.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
+namespace net {
+
 namespace {
 
 // CiphersRemove takes a zero-terminated array of cipher suite ids in
 // |to_remove| and sets every instance of them in |ciphers| to zero. It returns
 // true if it found and removed every element of |to_remove|. It assumes that
 // there are no duplicates in |ciphers| nor in |to_remove|.
 bool CiphersRemove(const uint16* to_remove, uint16* ciphers, size_t num) {
   size_t i, found = 0;
 
   for (i = 0; ; i++) {
@@ skipping 28 matching lines @@
 // CiphersCopy copies the zero-terminated array |in| to |out|. It returns the
 // number of cipher suite ids copied.
 size_t CiphersCopy(const uint16* in, uint16* out) {
   for (size_t i = 0; ; i++) {
     if (in[i] == 0)
       return i;
     out[i] = in[i];
   }
 }
 
-}  // anonymous namespace
-
-namespace net {
+base::Value* NetLogSSLErrorCallback(int net_error,
+                                    int ssl_lib_error,
+                                    NetLog::LogLevel /* log_level */) {
+  base::DictionaryValue* dict = new base::DictionaryValue();
+  dict->SetInteger("net_error", net_error);
+  if (ssl_lib_error)
+    dict->SetInteger("ssl_lib_error", ssl_lib_error);
+  return dict;

[Ryan Sleevi, 2014/08/25 06:24:35]

Should you also call PR_GetErrorText  (noting PR_GetErrorTextLength) and
PR_GetOSError ?

Note: All of these have to be called on the originating error thread (they're in
the thread's thread local storage), which means you'd need to dupe the string
for safety

[davidben, 2014/08/26 22:13:51]

Eh, this just came from net/socket/ssl_error_params.cc. I figured I'd just leave
it as-is so as not to have to think about these thread-local problems. :-)

+}
 
 class NSSSSLInitSingleton {
  public:
   NSSSSLInitSingleton() : model_fd_(NULL) {
     crypto::EnsureNSSInit();
 
     NSS_SetDomesticPolicy();
 
     const PRUint16* const ssl_ciphers = SSL_GetImplementedCiphers();
     const PRUint16 num_ciphers = SSL_GetNumImplementedCiphers();
@@ skipping 101 matching lines @@
     // Have to clear the cache, or NSS_Shutdown fails with SEC_ERROR_BUSY.
     SSL_ClearSessionCache();
     if (model_fd_)
       PR_Close(model_fd_);
   }
 
  private:
   PRFileDesc* model_fd_;
 };
 
-static base::LazyInstance<NSSSSLInitSingleton>::Leaky g_nss_ssl_init_singleton =
+base::LazyInstance<NSSSSLInitSingleton>::Leaky g_nss_ssl_init_singleton =
     LAZY_INSTANCE_INITIALIZER;
 
+}  // anonymous namespace
+
 // Initialize the NSS SSL library if it isn't already initialized.  This must
 // be called before any other NSS SSL functions.  This function is
 // thread-safe, and the NSS SSL library will only ever be initialized once.
 // The NSS SSL library will be properly shut down on program exit.
 void EnsureNSSSSLInit() {
   // Initializing SSL causes us to do blocking IO.
   // Temporarily allow it until we fix
   //   http://code.google.com/p/chromium/issues/detail?id=59847
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
@@ skipping 175 matching lines @@
                           const char* function,
                           const char* param) {
   DCHECK(function);
   DCHECK(param);
   net_log.AddEvent(
       NetLog::TYPE_SSL_NSS_ERROR,
       base::Bind(&NetLogSSLFailedNSSFunctionCallback,
                  function, param, PR_GetError()));
 }
 
+NetLog::ParametersCallback CreateNetLogSSLErrorCallback(int net_error,
+                                                        int ssl_lib_error) {
+  return base::Bind(&NetLogSSLErrorCallback, net_error, ssl_lib_error);
+}
+
 }  // namespace net