Stop calling SSL_get_session in SSLClientSocketImpl.

net/socket/ssl_client_socket_impl.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/ssl_client_socket_impl.h"
 
 #include <errno.h>
 #include <openssl/bio.h>
 #include <openssl/bytestring.h>
 #include <openssl/err.h>
@@ skipping 499 matching lines @@
       ssl_(NULL),
       transport_bio_(NULL),
       transport_(std::move(transport_socket)),
       host_and_port_(host_and_port),
       ssl_config_(ssl_config),
       ssl_session_cache_shard_(context.ssl_session_cache_shard),
       next_handshake_state_(STATE_NONE),
       disconnected_(false),
       npn_status_(kNextProtoUnsupported),
       channel_id_sent_(false),
-      session_pending_(false),
       certificate_verified_(false),
       signature_result_(kNoPendingResult),
       transport_security_state_(context.transport_security_state),
       policy_enforcer_(context.ct_policy_enforcer),
       pkp_bypassed_(false),
       net_log_(transport_->socket()->NetLog()),
       weak_factory_(this) {
   CHECK(cert_verifier_);
   CHECK(transport_security_state_);
   CHECK(cert_transparency_verifier_);
@@ skipping 170 matching lines @@
   cert_authorities_.clear();
   cert_key_types_.clear();
 
   start_cert_verification_time_ = base::TimeTicks();
 
   npn_status_ = kNextProtoUnsupported;
   npn_proto_.clear();
 
   channel_id_sent_ = false;
   tb_was_negotiated_ = false;
-  session_pending_ = false;
+  pending_session_ = nullptr;
   certificate_verified_ = false;
   channel_id_request_.Cancel();
 
   signature_result_ = kNoPendingResult;
   signature_.clear();
 }
 
 bool SSLClientSocketImpl::IsConnected() const {
   // If the handshake has not yet completed.
   if (!completed_connect_)
@@ skipping 75 matching lines @@
   ssl_info->channel_id_sent = channel_id_sent_;
   ssl_info->token_binding_negotiated = tb_was_negotiated_;
   ssl_info->token_binding_key_param = tb_negotiated_param_;
   ssl_info->pinning_failure_log = pinning_failure_log_;
 
   AddCTInfoToSSLInfo(ssl_info);
 
   const SSL_CIPHER* cipher = SSL_get_current_cipher(ssl_);
   CHECK(cipher);
   ssl_info->security_bits = SSL_CIPHER_get_bits(cipher, NULL);
-  ssl_info->key_exchange_info =
-      SSL_SESSION_get_key_exchange_info(SSL_get_session(ssl_));
+  if (SSL_CIPHER_is_ECDHE(cipher)) {
+    ssl_info->key_exchange_info = SSL_get_curve_id(ssl_);
+  } else if (SSL_CIPHER_is_DHE(cipher)) {
+    ssl_info->key_exchange_info = SSL_get_dhe_group_size(ssl_);
+  }
 
   SSLConnectionStatusSetCipherSuite(
       static_cast<uint16_t>(SSL_CIPHER_get_id(cipher)),
       &ssl_info->connection_status);
   SSLConnectionStatusSetVersion(GetNetSSLVersion(ssl_),
                                 &ssl_info->connection_status);
 
   if (!SSL_get_secure_renegotiation_support(ssl_))
     ssl_info->connection_status |= SSL_CONNECTION_NO_RENEGOTIATION_EXTENSION;
 
@@ skipping 1245 matching lines @@
       reinterpret_cast<SSLClientSocketImpl*>(BIO_get_callback_arg(bio));
   CHECK(socket);
   return socket->MaybeReplayTransportError(bio, cmd, argp, argi, argl,
                                            retvalue);
 }
 
 void SSLClientSocketImpl::MaybeCacheSession() {
   // Only cache the session once both a new session has been established and the
   // certificate has been verified. Due to False Start, these events may happen
   // in either order.
-  if (!session_pending_ || !certificate_verified_)
+  if (!pending_session_ || !certificate_verified_)
     return;
 
   SSLContext::GetInstance()->session_cache()->Insert(GetSessionCacheKey(),
-                                                     SSL_get_session(ssl_));
-  session_pending_ = false;
+                                                     pending_session_.get());
+  pending_session_ = nullptr;
 }
 
 int SSLClientSocketImpl::NewSessionCallback(SSL_SESSION* session) {
-  DCHECK_EQ(session, SSL_get_session(ssl_));
-
-  // Only sessions from the initial handshake get cached. Note this callback may
-  // be signaled on abbreviated handshakes if the ticket was renewed.
-  session_pending_ = true;
+  // OpenSSL passes a reference to |session|.
+  pending_session_.reset(session);
   MaybeCacheSession();
-
-  // OpenSSL passes a reference to |session|, but the session cache does not
-  // take this reference, so release it.
-  SSL_SESSION_free(session);
   return 1;
 }
 
 void SSLClientSocketImpl::AddCTInfoToSSLInfo(SSLInfo* ssl_info) const {
   ssl_info->UpdateCertificateTransparencyInfo(ct_verify_result_);
 }
 
 std::string SSLClientSocketImpl::GetSessionCacheKey() const {
   std::string result = host_and_port_.ToString();
   result.append("/");
@@ skipping 220 matching lines @@
   if (rv != OK) {
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SSL_CONNECT, rv);
     return;
   }
 
   net_log_.EndEvent(NetLog::TYPE_SSL_CONNECT,
                     base::Bind(&NetLogSSLInfoCallback, base::Unretained(this)));
 }
 
 }  // namespace net