Home | History | Annotate | Download | only in socket 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "net/socket/ssl_server_socket_nss.h"
      6 
      7 #if defined(OS_WIN)
      8 #include <winsock2.h>
      9 #endif
     10 
     11 #if defined(USE_SYSTEM_SSL)
     12 #include <dlfcn.h>
     13 #endif
     14 #if defined(OS_MACOSX)
     15 #include <Security/Security.h>
     16 #endif
     17 #include <certdb.h>
     18 #include <cryptohi.h>
     19 #include <hasht.h>
     20 #include <keyhi.h>
     21 #include <nspr.h>
     22 #include <nss.h>
     23 #include <pk11pub.h>
     24 #include <secerr.h>
     25 #include <sechash.h>
     26 #include <ssl.h>
     27 #include <sslerr.h>
     28 #include <sslproto.h>
     29 
     30 #include <limits>
     31 
     32 #include "base/lazy_instance.h"
     33 #include "base/memory/ref_counted.h"
     34 #include "crypto/rsa_private_key.h"
     35 #include "crypto/nss_util_internal.h"
     36 #include "net/base/io_buffer.h"
     37 #include "net/base/net_errors.h"
     38 #include "net/base/net_log.h"
     39 #include "net/socket/nss_ssl_util.h"
     40 #include "net/socket/ssl_error_params.h"
     41 
     42 // SSL plaintext fragments are shorter than 16KB. Although the record layer
     43 // overhead is allowed to be 2K + 5 bytes, in practice the overhead is much
     44 // smaller than 1KB. So a 17KB buffer should be large enough to hold an
     45 // entire SSL record.
     46 static const int kRecvBufferSize = 17 * 1024;
     47 static const int kSendBufferSize = 17 * 1024;
     48 
     49 #define GotoState(s) next_handshake_state_ = s
     50 
     51 namespace net {
     52 
     53 namespace {
     54 
     55 bool g_nss_server_sockets_init = false;
     56 
     57 class NSSSSLServerInitSingleton {
     58  public:
     59   NSSSSLServerInitSingleton() {
     60     EnsureNSSSSLInit();
     61 
     62     SSL_ConfigServerSessionIDCache(1024, 5, 5, NULL);
     63     g_nss_server_sockets_init = true;
     64   }
     65 
     66   ~NSSSSLServerInitSingleton() {
     67     SSL_ShutdownServerSessionIDCache();
     68     g_nss_server_sockets_init = false;
     69   }
     70 };
     71 
     72 static base::LazyInstance<NSSSSLServerInitSingleton>
     73     g_nss_ssl_server_init_singleton = LAZY_INSTANCE_INITIALIZER;
     74 
     75 }  // namespace
     76 
     77 void EnableSSLServerSockets() {
     78   g_nss_ssl_server_init_singleton.Get();
     79 }
     80 
     81 SSLServerSocket* CreateSSLServerSocket(
     82     StreamSocket* socket,
     83     X509Certificate* cert,
     84     crypto::RSAPrivateKey* key,
     85     const SSLConfig& ssl_config) {
     86   DCHECK(g_nss_server_sockets_init) << "EnableSSLServerSockets() has not been"
     87                                     << "called yet!";
     88 
     89   return new SSLServerSocketNSS(socket, cert, key, ssl_config);
     90 }
     91 
     92 SSLServerSocketNSS::SSLServerSocketNSS(
     93     StreamSocket* transport_socket,
     94     scoped_refptr<X509Certificate> cert,
     95     crypto::RSAPrivateKey* key,
     96     const SSLConfig& ssl_config)
     97     : transport_send_busy_(false),
     98       transport_recv_busy_(false),
     99       user_read_buf_len_(0),
    100       user_write_buf_len_(0),
    101       nss_fd_(NULL),
    102       nss_bufs_(NULL),
    103       transport_socket_(transport_socket),
    104       ssl_config_(ssl_config),
    105       cert_(cert),
    106       next_handshake_state_(STATE_NONE),
    107       completed_handshake_(false) {
    108   ssl_config_.false_start_enabled = false;
    109   ssl_config_.version_min = SSL_PROTOCOL_VERSION_SSL3;
    110   ssl_config_.version_max = SSL_PROTOCOL_VERSION_TLS1_1;
    111 
    112   // TODO(hclam): Need a better way to clone a key.
    113   std::vector<uint8> key_bytes;
    114   CHECK(key->ExportPrivateKey(&key_bytes));
    115   key_.reset(crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_bytes));
    116   CHECK(key_.get());
    117 }
    118 
    119 SSLServerSocketNSS::~SSLServerSocketNSS() {
    120   if (nss_fd_ != NULL) {
    121     PR_Close(nss_fd_);
    122     nss_fd_ = NULL;
    123   }
    124 }
    125 
    126 int SSLServerSocketNSS::Handshake(const CompletionCallback& callback) {
    127   net_log_.BeginEvent(NetLog::TYPE_SSL_SERVER_HANDSHAKE);
    128 
    129   int rv = Init();
    130   if (rv != OK) {
    131     LOG(ERROR) << "Failed to initialize NSS";
    132     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SSL_SERVER_HANDSHAKE, rv);
    133     return rv;
    134   }
    135 
    136   rv = InitializeSSLOptions();
    137   if (rv != OK) {
    138     LOG(ERROR) << "Failed to initialize SSL options";
    139     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SSL_SERVER_HANDSHAKE, rv);
    140     return rv;
    141   }
    142 
    143   // Set peer address. TODO(hclam): This should be in a separate method.
    144   PRNetAddr peername;
    145   memset(&peername, 0, sizeof(peername));
    146   peername.raw.family = AF_INET;
    147   memio_SetPeerName(nss_fd_, &peername);
    148 
    149   GotoState(STATE_HANDSHAKE);
    150   rv = DoHandshakeLoop(OK);
    151   if (rv == ERR_IO_PENDING) {
    152     user_handshake_callback_ = callback;
    153   } else {
    154     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SSL_SERVER_HANDSHAKE, rv);
    155   }
    156 
    157   return rv > OK ? OK : rv;
    158 }
    159 
    160 int SSLServerSocketNSS::ExportKeyingMaterial(const base::StringPiece& label,
    161                                              bool has_context,
    162                                              const base::StringPiece& context,
    163                                              unsigned char* out,
    164                                              unsigned int outlen) {
    165   if (!IsConnected())
    166     return ERR_SOCKET_NOT_CONNECTED;
    167   SECStatus result = SSL_ExportKeyingMaterial(
    168       nss_fd_, label.data(), label.size(), has_context,
    169       reinterpret_cast<const unsigned char*>(context.data()),
    170       context.length(), out, outlen);
    171   if (result != SECSuccess) {
    172     LogFailedNSSFunction(net_log_, "SSL_ExportKeyingMaterial", "");
    173     return MapNSSError(PORT_GetError());
    174   }
    175   return OK;
    176 }
    177 
    178 int SSLServerSocketNSS::GetTLSUniqueChannelBinding(std::string* out) {
    179   if (!IsConnected())
    180     return ERR_SOCKET_NOT_CONNECTED;
    181   unsigned char buf[64];
    182   unsigned int len;
    183   SECStatus result = SSL_GetChannelBinding(nss_fd_,
    184                                            SSL_CHANNEL_BINDING_TLS_UNIQUE,
    185                                            buf, &len, arraysize(buf));
    186   if (result != SECSuccess) {
    187     LogFailedNSSFunction(net_log_, "SSL_GetChannelBinding", "");
    188     return MapNSSError(PORT_GetError());
    189   }
    190   out->assign(reinterpret_cast<char*>(buf), len);
    191   return OK;
    192 }
    193 
    194 int SSLServerSocketNSS::Connect(const CompletionCallback& callback) {
    195   NOTIMPLEMENTED();
    196   return ERR_NOT_IMPLEMENTED;
    197 }
    198 
    199 int SSLServerSocketNSS::Read(IOBuffer* buf, int buf_len,
    200                              const CompletionCallback& callback) {
    201   DCHECK(user_read_callback_.is_null());
    202   DCHECK(user_handshake_callback_.is_null());
    203   DCHECK(!user_read_buf_.get());
    204   DCHECK(nss_bufs_);
    205   DCHECK(!callback.is_null());
    206 
    207   user_read_buf_ = buf;
    208   user_read_buf_len_ = buf_len;
    209 
    210   DCHECK(completed_handshake_);
    211 
    212   int rv = DoReadLoop(OK);
    213 
    214   if (rv == ERR_IO_PENDING) {
    215     user_read_callback_ = callback;
    216   } else {
    217     user_read_buf_ = NULL;
    218     user_read_buf_len_ = 0;
    219   }
    220   return rv;
    221 }
    222 
    223 int SSLServerSocketNSS::Write(IOBuffer* buf, int buf_len,
    224                               const CompletionCallback& callback) {
    225   DCHECK(user_write_callback_.is_null());
    226   DCHECK(!user_write_buf_.get());
    227   DCHECK(nss_bufs_);
    228   DCHECK(!callback.is_null());
    229 
    230   user_write_buf_ = buf;
    231   user_write_buf_len_ = buf_len;
    232 
    233   int rv = DoWriteLoop(OK);
    234 
    235   if (rv == ERR_IO_PENDING) {
    236     user_write_callback_ = callback;
    237   } else {
    238     user_write_buf_ = NULL;
    239     user_write_buf_len_ = 0;
    240   }
    241   return rv;
    242 }
    243 
    244 bool SSLServerSocketNSS::SetReceiveBufferSize(int32 size) {
    245   return transport_socket_->SetReceiveBufferSize(size);
    246 }
    247 
    248 bool SSLServerSocketNSS::SetSendBufferSize(int32 size) {
    249   return transport_socket_->SetSendBufferSize(size);
    250 }
    251 
    252 bool SSLServerSocketNSS::IsConnected() const {
    253   return completed_handshake_;
    254 }
    255 
    256 void SSLServerSocketNSS::Disconnect() {
    257   transport_socket_->Disconnect();
    258 }
    259 
    260 bool SSLServerSocketNSS::IsConnectedAndIdle() const {
    261   return completed_handshake_ && transport_socket_->IsConnectedAndIdle();
    262 }
    263 
    264 int SSLServerSocketNSS::GetPeerAddress(IPEndPoint* address) const {
    265   if (!IsConnected())
    266     return ERR_SOCKET_NOT_CONNECTED;
    267   return transport_socket_->GetPeerAddress(address);
    268 }
    269 
    270 int SSLServerSocketNSS::GetLocalAddress(IPEndPoint* address) const {
    271   if (!IsConnected())
    272     return ERR_SOCKET_NOT_CONNECTED;
    273   return transport_socket_->GetLocalAddress(address);
    274 }
    275 
    276 const BoundNetLog& SSLServerSocketNSS::NetLog() const {
    277   return net_log_;
    278 }
    279 
    280 void SSLServerSocketNSS::SetSubresourceSpeculation() {
    281   transport_socket_->SetSubresourceSpeculation();
    282 }
    283 
    284 void SSLServerSocketNSS::SetOmniboxSpeculation() {
    285   transport_socket_->SetOmniboxSpeculation();
    286 }
    287 
    288 bool SSLServerSocketNSS::WasEverUsed() const {
    289   return transport_socket_->WasEverUsed();
    290 }
    291 
    292 bool SSLServerSocketNSS::UsingTCPFastOpen() const {
    293   return transport_socket_->UsingTCPFastOpen();
    294 }
    295 
    296 bool SSLServerSocketNSS::WasNpnNegotiated() const {
    297   return false;
    298 }
    299 
    300 NextProto SSLServerSocketNSS::GetNegotiatedProtocol() const {
    301   // NPN is not supported by this class.
    302   return kProtoUnknown;
    303 }
    304 
    305 bool SSLServerSocketNSS::GetSSLInfo(SSLInfo* ssl_info) {
    306   NOTIMPLEMENTED();
    307   return false;
    308 }
    309 
    310 int SSLServerSocketNSS::InitializeSSLOptions() {
    311   // Transport connected, now hook it up to nss
    312   nss_fd_ = memio_CreateIOLayer(kRecvBufferSize, kSendBufferSize);
    313   if (nss_fd_ == NULL) {
    314     return ERR_OUT_OF_MEMORY;  // TODO(port): map NSPR error code.
    315   }
    316 
    317   // Grab pointer to buffers
    318   nss_bufs_ = memio_GetSecret(nss_fd_);
    319 
    320   /* Create SSL state machine */
    321   /* Push SSL onto our fake I/O socket */
    322   nss_fd_ = SSL_ImportFD(NULL, nss_fd_);
    323   if (nss_fd_ == NULL) {
    324     LogFailedNSSFunction(net_log_, "SSL_ImportFD", "");
    325     return ERR_OUT_OF_MEMORY;  // TODO(port): map NSPR/NSS error code.
    326   }
    327   // TODO(port): set more ssl options!  Check errors!
    328 
    329   int rv;
    330 
    331   rv = SSL_OptionSet(nss_fd_, SSL_SECURITY, PR_TRUE);
    332   if (rv != SECSuccess) {
    333     LogFailedNSSFunction(net_log_, "SSL_OptionSet", "SSL_SECURITY");
    334     return ERR_UNEXPECTED;
    335   }
    336 
    337   rv = SSL_OptionSet(nss_fd_, SSL_ENABLE_SSL2, PR_FALSE);
    338   if (rv != SECSuccess) {
    339     LogFailedNSSFunction(net_log_, "SSL_OptionSet", "SSL_ENABLE_SSL2");
    340     return ERR_UNEXPECTED;
    341   }
    342 
    343   SSLVersionRange version_range;
    344   version_range.min = ssl_config_.version_min;
    345   version_range.max = ssl_config_.version_max;
    346   rv = SSL_VersionRangeSet(nss_fd_, &version_range);
    347   if (rv != SECSuccess) {
    348     LogFailedNSSFunction(net_log_, "SSL_VersionRangeSet", "");
    349     return ERR_NO_SSL_VERSIONS_ENABLED;
    350   }
    351 
    352   for (std::vector<uint16>::const_iterator it =
    353            ssl_config_.disabled_cipher_suites.begin();
    354        it != ssl_config_.disabled_cipher_suites.end(); ++it) {
    355     // This will fail if the specified cipher is not implemented by NSS, but
    356     // the failure is harmless.
    357     SSL_CipherPrefSet(nss_fd_, *it, PR_FALSE);
    358   }
    359 
    360   // Server socket doesn't need session tickets.
    361   rv = SSL_OptionSet(nss_fd_, SSL_ENABLE_SESSION_TICKETS, PR_FALSE);
    362   if (rv != SECSuccess) {
    363     LogFailedNSSFunction(
    364         net_log_, "SSL_OptionSet", "SSL_ENABLE_SESSION_TICKETS");
    365   }
    366 
    367   // Doing this will force PR_Accept perform handshake as server.
    368   rv = SSL_OptionSet(nss_fd_, SSL_HANDSHAKE_AS_CLIENT, PR_FALSE);
    369   if (rv != SECSuccess) {
    370     LogFailedNSSFunction(net_log_, "SSL_OptionSet", "SSL_HANDSHAKE_AS_CLIENT");
    371     return ERR_UNEXPECTED;
    372   }
    373 
    374   rv = SSL_OptionSet(nss_fd_, SSL_HANDSHAKE_AS_SERVER, PR_TRUE);
    375   if (rv != SECSuccess) {
    376     LogFailedNSSFunction(net_log_, "SSL_OptionSet", "SSL_HANDSHAKE_AS_SERVER");
    377     return ERR_UNEXPECTED;
    378   }
    379 
    380   rv = SSL_OptionSet(nss_fd_, SSL_REQUEST_CERTIFICATE, PR_FALSE);
    381   if (rv != SECSuccess) {
    382     LogFailedNSSFunction(net_log_, "SSL_OptionSet", "SSL_REQUEST_CERTIFICATE");
    383     return ERR_UNEXPECTED;
    384   }
    385 
    386   rv = SSL_OptionSet(nss_fd_, SSL_REQUIRE_CERTIFICATE, PR_FALSE);
    387   if (rv != SECSuccess) {
    388     LogFailedNSSFunction(net_log_, "SSL_OptionSet", "SSL_REQUIRE_CERTIFICATE");
    389     return ERR_UNEXPECTED;
    390   }
    391 
    392   rv = SSL_AuthCertificateHook(nss_fd_, OwnAuthCertHandler, this);
    393   if (rv != SECSuccess) {
    394     LogFailedNSSFunction(net_log_, "SSL_AuthCertificateHook", "");
    395     return ERR_UNEXPECTED;
    396   }
    397 
    398   rv = SSL_HandshakeCallback(nss_fd_, HandshakeCallback, this);
    399   if (rv != SECSuccess) {
    400     LogFailedNSSFunction(net_log_, "SSL_HandshakeCallback", "");
    401     return ERR_UNEXPECTED;
    402   }
    403 
    404   // Get a certificate of CERTCertificate structure.
    405   std::string der_string;
    406   if (!X509Certificate::GetDEREncoded(cert_->os_cert_handle(), &der_string))
    407     return ERR_UNEXPECTED;
    408 
    409   SECItem der_cert;
    410   der_cert.data = reinterpret_cast<unsigned char*>(const_cast<char*>(
    411       der_string.data()));
    412   der_cert.len  = der_string.length();
    413   der_cert.type = siDERCertBuffer;
    414 
    415   // Parse into a CERTCertificate structure.
    416   CERTCertificate* cert = CERT_NewTempCertificate(
    417       CERT_GetDefaultCertDB(), &der_cert, NULL, PR_FALSE, PR_TRUE);
    418   if (!cert) {
    419     LogFailedNSSFunction(net_log_, "CERT_NewTempCertificate", "");
    420     return MapNSSError(PORT_GetError());
    421   }
    422 
    423   // Get a key of SECKEYPrivateKey* structure.
    424   std::vector<uint8> key_vector;
    425   if (!key_->ExportPrivateKey(&key_vector)) {
    426     CERT_DestroyCertificate(cert);
    427     return ERR_UNEXPECTED;
    428   }
    429 
    430   SECKEYPrivateKeyStr* private_key = NULL;
    431   PK11SlotInfo* slot = crypto::GetPrivateNSSKeySlot();
    432   if (!slot) {
    433     CERT_DestroyCertificate(cert);
    434     return ERR_UNEXPECTED;
    435   }
    436 
    437   SECItem der_private_key_info;
    438   der_private_key_info.data =
    439       const_cast<unsigned char*>(&key_vector.front());
    440   der_private_key_info.len = key_vector.size();
    441   // The server's RSA private key must be imported into NSS with the
    442   // following key usage bits:
    443   // - KU_KEY_ENCIPHERMENT, required for the RSA key exchange algorithm.
    444   // - KU_DIGITAL_SIGNATURE, required for the DHE_RSA and ECDHE_RSA key
    445   //   exchange algorithms.
    446   const unsigned int key_usage = KU_KEY_ENCIPHERMENT | KU_DIGITAL_SIGNATURE;
    447   rv =  PK11_ImportDERPrivateKeyInfoAndReturnKey(
    448       slot, &der_private_key_info, NULL, NULL, PR_FALSE, PR_FALSE,
    449       key_usage, &private_key, NULL);
    450   PK11_FreeSlot(slot);
    451   if (rv != SECSuccess) {
    452     CERT_DestroyCertificate(cert);
    453     return ERR_UNEXPECTED;
    454   }
    455 
    456   // Assign server certificate and private key.
    457   SSLKEAType cert_kea = NSS_FindCertKEAType(cert);
    458   rv = SSL_ConfigSecureServer(nss_fd_, cert, private_key, cert_kea);
    459   CERT_DestroyCertificate(cert);
    460   SECKEY_DestroyPrivateKey(private_key);
    461 
    462   if (rv != SECSuccess) {
    463     PRErrorCode prerr = PR_GetError();
    464     LOG(ERROR) << "Failed to config SSL server: " << prerr;
    465     LogFailedNSSFunction(net_log_, "SSL_ConfigureSecureServer", "");
    466     return ERR_UNEXPECTED;
    467   }
    468 
    469   // Tell SSL we're a server; needed if not letting NSPR do socket I/O
    470   rv = SSL_ResetHandshake(nss_fd_, PR_TRUE);
    471   if (rv != SECSuccess) {
    472     LogFailedNSSFunction(net_log_, "SSL_ResetHandshake", "");
    473     return ERR_UNEXPECTED;
    474   }
    475 
    476   return OK;
    477 }
    478 
    479 void SSLServerSocketNSS::OnSendComplete(int result) {
    480   if (next_handshake_state_ == STATE_HANDSHAKE) {
    481     // In handshake phase.
    482     OnHandshakeIOComplete(result);
    483     return;
    484   }
    485 
    486   if (!completed_handshake_)
    487     return;
    488 
    489   if (user_write_buf_.get()) {
    490     int rv = DoWriteLoop(result);
    491     if (rv != ERR_IO_PENDING)
    492       DoWriteCallback(rv);
    493   } else {
    494     // Ensure that any queued ciphertext is flushed.
    495     DoTransportIO();
    496   }
    497 }
    498 
    499 void SSLServerSocketNSS::OnRecvComplete(int result) {
    500   if (next_handshake_state_ == STATE_HANDSHAKE) {
    501     // In handshake phase.
    502     OnHandshakeIOComplete(result);
    503     return;
    504   }
    505 
    506   // Network layer received some data, check if client requested to read
    507   // decrypted data.
    508   if (!user_read_buf_.get() || !completed_handshake_)
    509     return;
    510 
    511   int rv = DoReadLoop(result);
    512   if (rv != ERR_IO_PENDING)
    513     DoReadCallback(rv);
    514 }
    515 
    516 void SSLServerSocketNSS::OnHandshakeIOComplete(int result) {
    517   int rv = DoHandshakeLoop(result);
    518   if (rv != ERR_IO_PENDING) {
    519     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SSL_SERVER_HANDSHAKE, rv);
    520     if (!user_handshake_callback_.is_null())
    521       DoHandshakeCallback(rv);
    522   }
    523 }
    524 
    525 // Return 0 for EOF,
    526 // > 0 for bytes transferred immediately,
    527 // < 0 for error (or the non-error ERR_IO_PENDING).
    528 int SSLServerSocketNSS::BufferSend(void) {
    529   if (transport_send_busy_)
    530     return ERR_IO_PENDING;
    531 
    532   const char* buf1;
    533   const char* buf2;
    534   unsigned int len1, len2;
    535   memio_GetWriteParams(nss_bufs_, &buf1, &len1, &buf2, &len2);
    536   const unsigned int len = len1 + len2;
    537 
    538   int rv = 0;
    539   if (len) {
    540     scoped_refptr<IOBuffer> send_buffer(new IOBuffer(len));
    541     memcpy(send_buffer->data(), buf1, len1);
    542     memcpy(send_buffer->data() + len1, buf2, len2);
    543     rv = transport_socket_->Write(
    544         send_buffer.get(),
    545         len,
    546         base::Bind(&SSLServerSocketNSS::BufferSendComplete,
    547                    base::Unretained(this)));
    548     if (rv == ERR_IO_PENDING) {
    549       transport_send_busy_ = true;
    550     } else {
    551       memio_PutWriteResult(nss_bufs_, MapErrorToNSS(rv));
    552     }
    553   }
    554 
    555   return rv;
    556 }
    557 
    558 void SSLServerSocketNSS::BufferSendComplete(int result) {
    559   memio_PutWriteResult(nss_bufs_, MapErrorToNSS(result));
    560   transport_send_busy_ = false;
    561   OnSendComplete(result);
    562 }
    563 
    564 int SSLServerSocketNSS::BufferRecv(void) {
    565   if (transport_recv_busy_) return ERR_IO_PENDING;
    566 
    567   char* buf;
    568   int nb = memio_GetReadParams(nss_bufs_, &buf);
    569   int rv;
    570   if (!nb) {
    571     // buffer too full to read into, so no I/O possible at moment
    572     rv = ERR_IO_PENDING;
    573   } else {
    574     recv_buffer_ = new IOBuffer(nb);
    575     rv = transport_socket_->Read(
    576         recv_buffer_.get(),
    577         nb,
    578         base::Bind(&SSLServerSocketNSS::BufferRecvComplete,
    579                    base::Unretained(this)));
    580     if (rv == ERR_IO_PENDING) {
    581       transport_recv_busy_ = true;
    582     } else {
    583       if (rv > 0)
    584         memcpy(buf, recv_buffer_->data(), rv);
    585       memio_PutReadResult(nss_bufs_, MapErrorToNSS(rv));
    586       recv_buffer_ = NULL;
    587     }
    588   }
    589   return rv;
    590 }
    591 
    592 void SSLServerSocketNSS::BufferRecvComplete(int result) {
    593   if (result > 0) {
    594     char* buf;
    595     memio_GetReadParams(nss_bufs_, &buf);
    596     memcpy(buf, recv_buffer_->data(), result);
    597   }
    598   recv_buffer_ = NULL;
    599   memio_PutReadResult(nss_bufs_, MapErrorToNSS(result));
    600   transport_recv_busy_ = false;
    601   OnRecvComplete(result);
    602 }
    603 
    604 // Do as much network I/O as possible between the buffer and the
    605 // transport socket. Return true if some I/O performed, false
    606 // otherwise (error or ERR_IO_PENDING).
    607 bool SSLServerSocketNSS::DoTransportIO() {
    608   bool network_moved = false;
    609   if (nss_bufs_ != NULL) {
    610     int rv;
    611     // Read and write as much data as we can. The loop is neccessary
    612     // because Write() may return synchronously.
    613     do {
    614       rv = BufferSend();
    615       if (rv > 0)
    616         network_moved = true;
    617     } while (rv > 0);
    618     if (BufferRecv() >= 0)
    619       network_moved = true;
    620   }
    621   return network_moved;
    622 }
    623 
    624 int SSLServerSocketNSS::DoPayloadRead() {
    625   DCHECK(user_read_buf_.get());
    626   DCHECK_GT(user_read_buf_len_, 0);
    627   int rv = PR_Read(nss_fd_, user_read_buf_->data(), user_read_buf_len_);
    628   if (rv >= 0)
    629     return rv;
    630   PRErrorCode prerr = PR_GetError();
    631   if (prerr == PR_WOULD_BLOCK_ERROR) {
    632     return ERR_IO_PENDING;
    633   }
    634   rv = MapNSSError(prerr);
    635   net_log_.AddEvent(NetLog::TYPE_SSL_READ_ERROR,
    636                     CreateNetLogSSLErrorCallback(rv, prerr));
    637   return rv;
    638 }
    639 
    640 int SSLServerSocketNSS::DoPayloadWrite() {
    641   DCHECK(user_write_buf_.get());
    642   int rv = PR_Write(nss_fd_, user_write_buf_->data(), user_write_buf_len_);
    643   if (rv >= 0)
    644     return rv;
    645   PRErrorCode prerr = PR_GetError();
    646   if (prerr == PR_WOULD_BLOCK_ERROR) {
    647     return ERR_IO_PENDING;
    648   }
    649   rv = MapNSSError(prerr);
    650   net_log_.AddEvent(NetLog::TYPE_SSL_WRITE_ERROR,
    651                     CreateNetLogSSLErrorCallback(rv, prerr));
    652   return rv;
    653 }
    654 
    655 int SSLServerSocketNSS::DoHandshakeLoop(int last_io_result) {
    656   int rv = last_io_result;
    657   do {
    658     // Default to STATE_NONE for next state.
    659     // (This is a quirk carried over from the windows
    660     // implementation.  It makes reading the logs a bit harder.)
    661     // State handlers can and often do call GotoState just
    662     // to stay in the current state.
    663     State state = next_handshake_state_;
    664     GotoState(STATE_NONE);
    665     switch (state) {
    666       case STATE_HANDSHAKE:
    667         rv = DoHandshake();
    668         break;
    669       case STATE_NONE:
    670       default:
    671         rv = ERR_UNEXPECTED;
    672         LOG(DFATAL) << "unexpected state " << state;
    673         break;
    674     }
    675 
    676     // Do the actual network I/O
    677     bool network_moved = DoTransportIO();
    678     if (network_moved && next_handshake_state_ == STATE_HANDSHAKE) {
    679       // In general we exit the loop if rv is ERR_IO_PENDING.  In this
    680       // special case we keep looping even if rv is ERR_IO_PENDING because
    681       // the transport IO may allow DoHandshake to make progress.
    682       rv = OK;  // This causes us to stay in the loop.
    683     }
    684   } while (rv != ERR_IO_PENDING && next_handshake_state_ != STATE_NONE);
    685   return rv;
    686 }
    687 
    688 int SSLServerSocketNSS::DoReadLoop(int result) {
    689   DCHECK(completed_handshake_);
    690   DCHECK(next_handshake_state_ == STATE_NONE);
    691 
    692   if (result < 0)
    693     return result;
    694 
    695   if (!nss_bufs_) {
    696     LOG(DFATAL) << "!nss_bufs_";
    697     int rv = ERR_UNEXPECTED;
    698     net_log_.AddEvent(NetLog::TYPE_SSL_READ_ERROR,
    699                       CreateNetLogSSLErrorCallback(rv, 0));
    700     return rv;
    701   }
    702 
    703   bool network_moved;
    704   int rv;
    705   do {
    706     rv = DoPayloadRead();
    707     network_moved = DoTransportIO();
    708   } while (rv == ERR_IO_PENDING && network_moved);
    709   return rv;
    710 }
    711 
    712 int SSLServerSocketNSS::DoWriteLoop(int result) {
    713   DCHECK(completed_handshake_);
    714   DCHECK(next_handshake_state_ == STATE_NONE);
    715 
    716   if (result < 0)
    717     return result;
    718 
    719   if (!nss_bufs_) {
    720     LOG(DFATAL) << "!nss_bufs_";
    721     int rv = ERR_UNEXPECTED;
    722     net_log_.AddEvent(NetLog::TYPE_SSL_WRITE_ERROR,
    723                       CreateNetLogSSLErrorCallback(rv, 0));
    724     return rv;
    725   }
    726 
    727   bool network_moved;
    728   int rv;
    729   do {
    730     rv = DoPayloadWrite();
    731     network_moved = DoTransportIO();
    732   } while (rv == ERR_IO_PENDING && network_moved);
    733   return rv;
    734 }
    735 
    736 int SSLServerSocketNSS::DoHandshake() {
    737   int net_error = OK;
    738   SECStatus rv = SSL_ForceHandshake(nss_fd_);
    739 
    740   if (rv == SECSuccess) {
    741     completed_handshake_ = true;
    742   } else {
    743     PRErrorCode prerr = PR_GetError();
    744     net_error = MapNSSError(prerr);
    745 
    746     // If not done, stay in this state
    747     if (net_error == ERR_IO_PENDING) {
    748       GotoState(STATE_HANDSHAKE);
    749     } else {
    750       LOG(ERROR) << "handshake failed; NSS error code " << prerr
    751                  << ", net_error " << net_error;
    752       net_log_.AddEvent(NetLog::TYPE_SSL_HANDSHAKE_ERROR,
    753                         CreateNetLogSSLErrorCallback(net_error, prerr));
    754     }
    755   }
    756   return net_error;
    757 }
    758 
    759 void SSLServerSocketNSS::DoHandshakeCallback(int rv) {
    760   DCHECK_NE(rv, ERR_IO_PENDING);
    761 
    762   CompletionCallback c = user_handshake_callback_;
    763   user_handshake_callback_.Reset();
    764   c.Run(rv > OK ? OK : rv);
    765 }
    766 
    767 void SSLServerSocketNSS::DoReadCallback(int rv) {
    768   DCHECK(rv != ERR_IO_PENDING);
    769   DCHECK(!user_read_callback_.is_null());
    770 
    771   // Since Run may result in Read being called, clear |user_read_callback_|
    772   // up front.
    773   CompletionCallback c = user_read_callback_;
    774   user_read_callback_.Reset();
    775   user_read_buf_ = NULL;
    776   user_read_buf_len_ = 0;
    777   c.Run(rv);
    778 }
    779 
    780 void SSLServerSocketNSS::DoWriteCallback(int rv) {
    781   DCHECK(rv != ERR_IO_PENDING);
    782   DCHECK(!user_write_callback_.is_null());
    783 
    784   // Since Run may result in Write being called, clear |user_write_callback_|
    785   // up front.
    786   CompletionCallback c = user_write_callback_;
    787   user_write_callback_.Reset();
    788   user_write_buf_ = NULL;
    789   user_write_buf_len_ = 0;
    790   c.Run(rv);
    791 }
    792 
    793 // static
    794 // NSS calls this if an incoming certificate needs to be verified.
    795 // Do nothing but return SECSuccess.
    796 // This is called only in full handshake mode.
    797 // Peer certificate is retrieved in HandshakeCallback() later, which is called
    798 // in full handshake mode or in resumption handshake mode.
    799 SECStatus SSLServerSocketNSS::OwnAuthCertHandler(void* arg,
    800                                                  PRFileDesc* socket,
    801                                                  PRBool checksig,
    802                                                  PRBool is_server) {
    803   // TODO(hclam): Implement.
    804   // Tell NSS to not verify the certificate.
    805   return SECSuccess;
    806 }
    807 
    808 // static
    809 // NSS calls this when handshake is completed.
    810 // After the SSL handshake is finished we need to verify the certificate.
    811 void SSLServerSocketNSS::HandshakeCallback(PRFileDesc* socket,
    812                                            void* arg) {
    813   // TODO(hclam): Implement.
    814 }
    815 
    816 int SSLServerSocketNSS::Init() {
    817   // Initialize the NSS SSL library in a threadsafe way.  This also
    818   // initializes the NSS base library.
    819   EnsureNSSSSLInit();
    820   if (!NSS_IsInitialized())
    821     return ERR_UNEXPECTED;
    822 
    823   EnableSSLServerSockets();
    824   return OK;
    825 }
    826 
    827 }  // namespace net
    828