Replace NULL with nullptr in all C++ files.

webrtc/base/openssladapter.cc

 /*
  *  Copyright 2008 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 23 matching lines @@
 #include "webrtc/base/sslroots.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/thread.h"
 
 #ifndef OPENSSL_IS_BORINGSSL
 
 // TODO: Use a nicer abstraction for mutex.
 
 #if defined(WEBRTC_WIN)
   #define MUTEX_TYPE HANDLE
-  #define MUTEX_SETUP(x) (x) = CreateMutex(NULL, FALSE, NULL)
-  #define MUTEX_CLEANUP(x) CloseHandle(x)
-  #define MUTEX_LOCK(x) WaitForSingleObject((x), INFINITE)
-  #define MUTEX_UNLOCK(x) ReleaseMutex(x)
-  #define THREAD_ID GetCurrentThreadId()
+#define MUTEX_SETUP(x) (x) = CreateMutex(nullptr, FALSE, nullptr)
+#define MUTEX_CLEANUP(x) CloseHandle(x)
+#define MUTEX_LOCK(x) WaitForSingleObject((x), INFINITE)
+#define MUTEX_UNLOCK(x) ReleaseMutex(x)
+#define THREAD_ID GetCurrentThreadId()
 #elif defined(WEBRTC_POSIX)
   #define MUTEX_TYPE pthread_mutex_t
-  #define MUTEX_SETUP(x) pthread_mutex_init(&(x), NULL)
-  #define MUTEX_CLEANUP(x) pthread_mutex_destroy(&(x))
-  #define MUTEX_LOCK(x) pthread_mutex_lock(&(x))
-  #define MUTEX_UNLOCK(x) pthread_mutex_unlock(&(x))
-  #define THREAD_ID pthread_self()
+#define MUTEX_SETUP(x) pthread_mutex_init(&(x), nullptr)
+#define MUTEX_CLEANUP(x) pthread_mutex_destroy(&(x))
+#define MUTEX_LOCK(x) pthread_mutex_lock(&(x))
+#define MUTEX_UNLOCK(x) pthread_mutex_unlock(&(x))
+#define THREAD_ID pthread_self()
 #else
   #error You must define mutex operations appropriate for your platform!
 #endif
 
 struct CRYPTO_dynlock_value {
   MUTEX_TYPE mutex;
 };
 
 #endif  // #ifndef OPENSSL_IS_BORINGSSL
 
 //////////////////////////////////////////////////////////////////////
 // SocketBIO
 //////////////////////////////////////////////////////////////////////
 
 static int socket_write(BIO* h, const char* buf, int num);
 static int socket_read(BIO* h, char* buf, int size);
 static int socket_puts(BIO* h, const char* str);
 static long socket_ctrl(BIO* h, int cmd, long arg1, void* arg2);
 static int socket_new(BIO* h);
 static int socket_free(BIO* data);
 
 // TODO(davidben): This should be const once BoringSSL is assumed.
 static BIO_METHOD methods_socket = {
-  BIO_TYPE_BIO,
-  "socket",
-  socket_write,
-  socket_read,
-  socket_puts,
-  0,
-  socket_ctrl,
-  socket_new,
-  socket_free,
-  NULL,
+    BIO_TYPE_BIO, "socket",   socket_write, socket_read, socket_puts, 0,
+    socket_ctrl,  socket_new, socket_free,  nullptr,
 };
 
 static BIO_METHOD* BIO_s_socket2() { return(&methods_socket); }
 
 static BIO* BIO_new_socket(rtc::AsyncSocket* socket) {
   BIO* ret = BIO_new(BIO_s_socket2());
-  if (ret == NULL) {
-          return NULL;
+  if (ret == nullptr) {
+    return nullptr;
   }
   ret->ptr = socket;
   return ret;
 }
 
 static int socket_new(BIO* b) {
   b->shutdown = 0;
   b->init = 1;
   b->num = 0; // 1 means socket closed
   b->ptr = 0;
   return 1;
 }
 
 static int socket_free(BIO* b) {
-  if (b == NULL)
+  if (b == nullptr)
     return 0;
   return 1;
 }
 
 static int socket_read(BIO* b, char* out, int outl) {
   if (!out)
     return -1;
   rtc::AsyncSocket* socket = static_cast<rtc::AsyncSocket*>(b->ptr);
   BIO_clear_retry_flags(b);
   int result = socket->Recv(out, outl, nullptr);
@@ skipping 46 matching lines @@
 
 /////////////////////////////////////////////////////////////////////////////
 // OpenSSLAdapter
 /////////////////////////////////////////////////////////////////////////////
 
 namespace rtc {
 
 #ifndef OPENSSL_IS_BORINGSSL
 
 // This array will store all of the mutexes available to OpenSSL.
-static MUTEX_TYPE* mutex_buf = NULL;
+static MUTEX_TYPE* mutex_buf = nullptr;
 
 static void locking_function(int mode, int n, const char * file, int line) {
   if (mode & CRYPTO_LOCK) {
     MUTEX_LOCK(mutex_buf[n]);
   } else {
     MUTEX_UNLOCK(mutex_buf[n]);
   }
 }
 
 static unsigned long id_function() {  // NOLINT
   // Use old-style C cast because THREAD_ID's type varies with the platform,
   // in some cases requiring static_cast, and in others requiring
   // reinterpret_cast.
   return (unsigned long)THREAD_ID; // NOLINT
 }
 
 static CRYPTO_dynlock_value* dyn_create_function(const char* file, int line) {
   CRYPTO_dynlock_value* value = new CRYPTO_dynlock_value;
   if (!value)
-    return NULL;
+    return nullptr;
   MUTEX_SETUP(value->mutex);
   return value;
 }
 
 static void dyn_lock_function(int mode, CRYPTO_dynlock_value* l,
                               const char* file, int line) {
   if (mode & CRYPTO_LOCK) {
     MUTEX_LOCK(l->mutex);
   } else {
     MUTEX_UNLOCK(l->mutex);
   }
 }
 
 static void dyn_destroy_function(CRYPTO_dynlock_value* l,
                                  const char* file, int line) {
   MUTEX_CLEANUP(l->mutex);
   delete l;
 }
 
 #endif  // #ifndef OPENSSL_IS_BORINGSSL
 
-VerificationCallback OpenSSLAdapter::custom_verify_callback_ = NULL;
+VerificationCallback OpenSSLAdapter::custom_verify_callback_ = nullptr;
 
 bool OpenSSLAdapter::InitializeSSL(VerificationCallback callback) {
   if (!InitializeSSLThread() || !SSL_library_init())
       return false;
 #if !defined(ADDRESS_SANITIZER) || !defined(WEBRTC_MAC) || defined(WEBRTC_IOS)
   // Loading the error strings crashes mac_asan.  Omit this debugging aid there.
   SSL_load_error_strings();
 #endif
   ERR_load_BIO_strings();
   OpenSSL_add_all_algorithms();
@@ skipping 20 matching lines @@
   CRYPTO_set_dynlock_lock_callback(dyn_lock_function);
   CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function);
 #endif  // #ifndef OPENSSL_IS_BORINGSSL
   return true;
 }
 
 bool OpenSSLAdapter::CleanupSSL() {
 #ifndef OPENSSL_IS_BORINGSSL
   if (!mutex_buf)
     return false;
-  CRYPTO_set_id_callback(NULL);
-  CRYPTO_set_locking_callback(NULL);
-  CRYPTO_set_dynlock_create_callback(NULL);
-  CRYPTO_set_dynlock_lock_callback(NULL);
-  CRYPTO_set_dynlock_destroy_callback(NULL);
+  CRYPTO_set_id_callback(nullptr);
+  CRYPTO_set_locking_callback(nullptr);
+  CRYPTO_set_dynlock_create_callback(nullptr);
+  CRYPTO_set_dynlock_lock_callback(nullptr);
+  CRYPTO_set_dynlock_destroy_callback(nullptr);
   for (int i = 0; i < CRYPTO_num_locks(); ++i)
     MUTEX_CLEANUP(mutex_buf[i]);
   delete [] mutex_buf;
-  mutex_buf = NULL;
+  mutex_buf = nullptr;
 #endif  // #ifndef OPENSSL_IS_BORINGSSL
   return true;
 }
 
 OpenSSLAdapter::OpenSSLAdapter(AsyncSocket* socket)
-  : SSLAdapter(socket),
-    state_(SSL_NONE),
-    ssl_read_needs_write_(false),
-    ssl_write_needs_read_(false),
-    restartable_(false),
-    ssl_(NULL), ssl_ctx_(NULL),
-    ssl_mode_(SSL_MODE_TLS),
-    custom_verification_succeeded_(false) {
-}
+    : SSLAdapter(socket),
+      state_(SSL_NONE),
+      ssl_read_needs_write_(false),
+      ssl_write_needs_read_(false),
+      restartable_(false),
+      ssl_(nullptr),
+      ssl_ctx_(nullptr),
+      ssl_mode_(SSL_MODE_TLS),
+      custom_verification_succeeded_(false) {}
 
 OpenSSLAdapter::~OpenSSLAdapter() {
   Cleanup();
 }
 
 void
 OpenSSLAdapter::SetMode(SSLMode mode) {
   RTC_DCHECK(state_ == SSL_NONE);
   ssl_mode_ = mode;
 }
@@ skipping 19 matching lines @@
 
   return 0;
 }
 
 int
 OpenSSLAdapter::BeginSSL() {
   LOG(LS_INFO) << "BeginSSL: " << ssl_host_name_;
   RTC_DCHECK(state_ == SSL_CONNECTING);
 
   int err = 0;
-  BIO* bio = NULL;
+  BIO* bio = nullptr;
 
   // First set up the context
   if (!ssl_ctx_)
     ssl_ctx_ = SetupSSLContext();
 
   if (!ssl_ctx_) {
     err = -1;
     goto ssl_error;
   }
 
   bio = BIO_new_socket(socket_);
   if (!bio) {
     err = -1;
     goto ssl_error;
   }
 
   ssl_ = SSL_new(ssl_ctx_);
   if (!ssl_) {
     err = -1;
     goto ssl_error;
   }
 
   SSL_set_app_data(ssl_, this);
 
   SSL_set_bio(ssl_, bio, bio);
   SSL_set_mode(ssl_, SSL_MODE_ENABLE_PARTIAL_WRITE |
                      SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
 
   // the SSL object owns the bio now
-  bio = NULL;
+  bio = nullptr;
 
   // Do the connect
   err = ContinueSSL();
   if (err != 0)
     goto ssl_error;
 
   return err;
 
 ssl_error:
   Cleanup();
@@ skipping 70 matching lines @@
 OpenSSLAdapter::Cleanup() {
   LOG(LS_INFO) << "Cleanup";
 
   state_ = SSL_NONE;
   ssl_read_needs_write_ = false;
   ssl_write_needs_read_ = false;
   custom_verification_succeeded_ = false;
 
   if (ssl_) {
     SSL_free(ssl_);
-    ssl_ = NULL;
+    ssl_ = nullptr;
   }
 
   if (ssl_ctx_) {
     SSL_CTX_free(ssl_ctx_);
-    ssl_ctx_ = NULL;
+    ssl_ctx_ = nullptr;
   }
 
   // Clear the DTLS timer
   Thread::Current()->Clear(this, MSG_TIMEOUT);
 }
 
 //
 // AsyncSocket Implementation
 //
 
@@ skipping 247 matching lines @@
 // This code is taken from the "Network Security with OpenSSL"
 // sample in chapter 5
 
 bool OpenSSLAdapter::VerifyServerName(SSL* ssl, const char* host,
                                       bool ignore_bad_cert) {
   if (!host)
     return false;
 
   // Checking the return from SSL_get_peer_certificate here is not strictly
   // necessary.  With our setup, it is not possible for it to return
-  // NULL.  However, it is good form to check the return.
+  // null.  However, it is good form to check the return.
   X509* certificate = SSL_get_peer_certificate(ssl);
   if (!certificate)
     return false;
 
   // Logging certificates is extremely verbose. So it is disabled by default.
 #ifdef LOG_CERTIFICATES
   {
     LOG(LS_INFO) << "Certificate from server:";
     BIO* mem = BIO_new(BIO_s_mem());
     X509_print_ex(mem, certificate, XN_FLAG_SEP_CPLUS_SPC, X509_FLAG_NO_HEADER);
     BIO_write(mem, "\0", 1);
     char* buffer;
     BIO_get_mem_data(mem, &buffer);
     LOG(LS_INFO) << buffer;
     BIO_free(mem);
 
     char* cipher_description =
-      SSL_CIPHER_description(SSL_get_current_cipher(ssl), NULL, 128);
+        SSL_CIPHER_description(SSL_get_current_cipher(ssl), nullptr, 128);
     LOG(LS_INFO) << "Cipher: " << cipher_description;
     OPENSSL_free(cipher_description);
   }
 #endif
 
   bool ok = false;
   int extension_count = X509_get_ext_count(certificate);
   for (int i = 0; i < extension_count; ++i) {
     X509_EXTENSION* extension = X509_get_ext(certificate, i);
     int extension_nid = OBJ_obj2nid(X509_EXTENSION_get_object(extension));
 
     if (extension_nid == NID_subject_alt_name) {
       const X509V3_EXT_METHOD* meth = X509V3_EXT_get(extension);
       if (!meth)
         break;
 
-      void* ext_str = NULL;
+      void* ext_str = nullptr;
 
       // We assign this to a local variable, instead of passing the address
       // directly to ASN1_item_d2i.
       // See http://readlist.com/lists/openssl.org/openssl-users/0/4761.html.
       unsigned char* ext_value_data = extension->value->data;
 
       const unsigned char **ext_value_data_ptr =
           (const_cast<const unsigned char **>(&ext_value_data));
 
       if (meth->it) {
-        ext_str = ASN1_item_d2i(NULL, ext_value_data_ptr,
-                                extension->value->length,
-                                ASN1_ITEM_ptr(meth->it));
+        ext_str =
+            ASN1_item_d2i(nullptr, ext_value_data_ptr, extension->value->length,
+                          ASN1_ITEM_ptr(meth->it));
       } else {
-        ext_str = meth->d2i(NULL, ext_value_data_ptr, extension->value->length);
+        ext_str =
+            meth->d2i(nullptr, ext_value_data_ptr, extension->value->length);
       }
 
-      STACK_OF(CONF_VALUE)* value = meth->i2v(meth, ext_str, NULL);
+      STACK_OF(CONF_VALUE)* value = meth->i2v(meth, ext_str, nullptr);
 
       // Cast to size_t to be compilable for both OpenSSL and BoringSSL.
       for (size_t j = 0; j < static_cast<size_t>(sk_CONF_VALUE_num(value));
            ++j) {
         CONF_VALUE* nval = sk_CONF_VALUE_value(value, j);
         // The value for nval can contain wildcards
         if (!strcmp(nval->name, "DNS") && string_match(host, nval->value)) {
           ok = true;
           break;
         }
       }
       sk_CONF_VALUE_pop_free(value, X509V3_conf_free);
-      value = NULL;
+      value = nullptr;
 
       if (meth->it) {
         ASN1_item_free(reinterpret_cast<ASN1_VALUE*>(ext_str),
                        ASN1_ITEM_ptr(meth->it));
       } else {
         meth->ext_free(ext_str);
       }
-      ext_str = NULL;
+      ext_str = nullptr;
     }
     if (ok)
       break;
   }
 
   char data[256];
   X509_NAME* subject;
-  if (!ok
-      && ((subject = X509_get_subject_name(certificate)) != NULL)
-      && (X509_NAME_get_text_by_NID(subject, NID_commonName,
-                                    data, sizeof(data)) > 0)) {
+  if (!ok && ((subject = X509_get_subject_name(certificate)) != nullptr) &&
+      (X509_NAME_get_text_by_NID(subject, NID_commonName, data, sizeof(data)) >
+       0)) {
     data[sizeof(data)-1] = 0;
     if (_stricmp(data, host) == 0)
       ok = true;
   }
 
   X509_free(certificate);
 
   // This should only ever be turned on for debugging and development.
   if (!ok && ignore_bad_cert) {
     LOG(LS_WARNING) << "TLS certificate check FAILED.  "
@@ skipping 96 matching lines @@
 
   return ok;
 }
 
 bool OpenSSLAdapter::ConfigureTrustedRootCertificates(SSL_CTX* ctx) {
   // Add the root cert that we care about to the SSL context
   int count_of_added_certs = 0;
   for (size_t i = 0; i < arraysize(kSSLCertCertificateList); i++) {
     const unsigned char* cert_buffer = kSSLCertCertificateList[i];
     size_t cert_buffer_len = kSSLCertCertificateSizeList[i];
-    X509* cert = d2i_X509(NULL, &cert_buffer,
-                          checked_cast<long>(cert_buffer_len));
+    X509* cert =
+        d2i_X509(nullptr, &cert_buffer, checked_cast<long>(cert_buffer_len));
     if (cert) {
       int return_value = X509_STORE_add_cert(SSL_CTX_get_cert_store(ctx), cert);
       if (return_value == 0) {
         LOG(LS_WARNING) << "Unable to add certificate.";
       } else {
         count_of_added_certs++;
       }
       X509_free(cert);
     }
   }
   return count_of_added_certs > 0;
 }
 
 SSL_CTX*
 OpenSSLAdapter::SetupSSLContext() {
   SSL_CTX* ctx = SSL_CTX_new(ssl_mode_ == SSL_MODE_DTLS ?
       DTLSv1_client_method() : TLSv1_client_method());
-  if (ctx == NULL) {
+  if (ctx == nullptr) {
     unsigned long error = ERR_get_error();  // NOLINT: type used by OpenSSL.
     LOG(LS_WARNING) << "SSL_CTX creation failed: "
                     << '"' << ERR_reason_error_string(error) << "\" "
                     << "(error=" << error << ')';
-    return NULL;
+    return nullptr;
   }
   if (!ConfigureTrustedRootCertificates(ctx)) {
     SSL_CTX_free(ctx);
-    return NULL;
+    return nullptr;
   }
 
 #if !defined(NDEBUG)
   SSL_CTX_set_info_callback(ctx, SSLInfoCallback);
 #endif
 
   SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, SSLVerifyCallback);
   SSL_CTX_set_verify_depth(ctx, 4);
   SSL_CTX_set_cipher_list(ctx, "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
 
   if (ssl_mode_ == SSL_MODE_DTLS) {
     SSL_CTX_set_read_ahead(ctx, 1);
   }
 
   return ctx;
 }
 
 } // namespace rtc