Build remoting for PNaCl

remoting/protocol/ssl_hmac_channel_authenticator.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 "remoting/protocol/ssl_hmac_channel_authenticator.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "crypto/secure_util.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
-#include "net/cert/cert_verifier.h"
 #include "net/cert/x509_certificate.h"
 #include "net/http/transport_security_state.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/ssl_client_socket.h"
+#include "net/socket/ssl_client_socket_openssl.h"
 #include "net/socket/ssl_server_socket.h"
 #include "net/ssl/ssl_config_service.h"
 #include "remoting/base/rsa_key_pair.h"
 #include "remoting/protocol/auth_util.h"
 
 namespace remoting {
 namespace protocol {
 
 // static
 scoped_ptr<SslHmacChannelAuthenticator>
@@ skipping 28 matching lines @@
 
 void SslHmacChannelAuthenticator::SecureAndAuthenticate(
     scoped_ptr<net::StreamSocket> socket, const DoneCallback& done_callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(socket->IsConnected());
 
   done_callback_ = done_callback;
 
   int result;
   if (is_ssl_server()) {
+#if defined(OS_NACL)
+    // Client plugin uses only client SSL sockets.

[Jamie, 2014/04/14 22:23:42]

s/Client plugin/NaCl client/?

[Sergey Ulanov, 2014/04/14 23:16:51]

The comment is correct. Updated it to make it clear why this code needs to be
disabled for NaCl.

+    NOTREACHED();
+    result = net::ERR_FAILED;
+#else
     scoped_refptr<net::X509Certificate> cert =
         net::X509Certificate::CreateFromBytes(
             local_cert_.data(), local_cert_.length());
     if (!cert.get()) {
       LOG(ERROR) << "Failed to parse X509Certificate";
       NotifyError(net::ERR_FAILED);
       return;
     }
 
     net::SSLConfig ssl_config;
     ssl_config.require_forward_secrecy = true;
 
     scoped_ptr<net::SSLServerSocket> server_socket =
         net::CreateSSLServerSocket(socket.Pass(),
                                    cert.get(),
                                    local_key_pair_->private_key(),
                                    ssl_config);
     net::SSLServerSocket* raw_server_socket = server_socket.get();
     socket_ = server_socket.Pass();
     result = raw_server_socket->Handshake(
         base::Bind(&SslHmacChannelAuthenticator::OnConnected,
                    base::Unretained(this)));
+#endif
   } else {
-    cert_verifier_.reset(net::CertVerifier::CreateDefault());
     transport_security_state_.reset(new net::TransportSecurityState);
 
     net::SSLConfig::CertAndStatus cert_and_status;
     cert_and_status.cert_status = net::CERT_STATUS_AUTHORITY_INVALID;
     cert_and_status.der_cert = remote_cert_;
 
     net::SSLConfig ssl_config;
     // Certificate verification and revocation checking are not needed
     // because we use self-signed certs. Disable it so that the SSL
     // layer doesn't try to initialize OCSP (OCSP works only on the IO
     // thread).
     ssl_config.cert_io_enabled = false;
     ssl_config.rev_checking_enabled = false;
     ssl_config.allowed_bad_certs.push_back(cert_and_status);
 
     net::HostPortPair host_and_port(kSslFakeHostName, 0);
     net::SSLClientSocketContext context;
-    context.cert_verifier = cert_verifier_.get();
+    // Don't need cert verifier.
+    context.cert_verifier = NULL;
     context.transport_security_state = transport_security_state_.get();
-    scoped_ptr<net::ClientSocketHandle> connection(new net::ClientSocketHandle);
-    connection->SetSocket(socket.Pass());
+    scoped_ptr<net::ClientSocketHandle> socket_handle(
+        new net::ClientSocketHandle);
+    socket_handle->SetSocket(socket.Pass());
+
+#if defined(OS_NACL)
+    // net_nacl doesn't include ClientSocketFactory.
+    socket_.reset(new net::SSLClientSocketOpenSSL(
+        socket_handle.Pass(), host_and_port, ssl_config, context));
+#else
     socket_ =
         net::ClientSocketFactory::GetDefaultFactory()->CreateSSLClientSocket(
-            connection.Pass(), host_and_port, ssl_config, context);
+            socket_handle.Pass(), host_and_port, ssl_config, context);
+#endif
 
     result = socket_->Connect(
         base::Bind(&SslHmacChannelAuthenticator::OnConnected,
                    base::Unretained(this)));
   }
 
   if (result == net::ERR_IO_PENDING)
     return;
 
   OnConnected(result);
@@ skipping 145 matching lines @@
   }
 }
 
 void SslHmacChannelAuthenticator::NotifyError(int error) {
   done_callback_.Run(static_cast<net::Error>(error),
                      scoped_ptr<net::StreamSocket>());
 }
 
 }  // namespace protocol
 }  // namespace remoting