Add functionality to pppapi TCPSocket to support secure sockets in flash

ppapi/shared_impl/private/tcp_socket_private_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 "ppapi/shared_impl/private/tcp_socket_private_impl.h"
 
 #include <string.h>
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
+#include "ppapi/shared_impl/private/ppb_flash_x509_certificate_shared.h"
+#include "ppapi/shared_impl/ppapi_globals.h"
+#include "ppapi/shared_impl/resource_tracker.h"
+#include "ppapi/shared_impl/var.h"
+#include "ppapi/thunk/ppb_flash_x509_certificate_api.h"
 
 namespace ppapi {
 
 const int32_t TCPSocketPrivateImpl::kMaxReadSize = 1024 * 1024;
 const int32_t TCPSocketPrivateImpl::kMaxWriteSize = 1024 * 1024;
 
 TCPSocketPrivateImpl::TCPSocketPrivateImpl(PP_Instance instance,
                                            uint32 socket_id)
-    : Resource(OBJECT_IS_IMPL, instance) {
+    : Resource(OBJECT_IS_IMPL, instance),
+      resource_type(OBJECT_IS_IMPL) {
   Init(socket_id);
 }
 
 TCPSocketPrivateImpl::TCPSocketPrivateImpl(const HostResource& resource,
                                            uint32 socket_id)
-    : Resource(OBJECT_IS_PROXY, resource) {
+    : Resource(OBJECT_IS_PROXY, resource),
+      resource_type(OBJECT_IS_PROXY) {
   Init(socket_id);
 }
 
 TCPSocketPrivateImpl::~TCPSocketPrivateImpl() {
 }
 
 thunk::PPB_TCPSocket_Private_API*
 TCPSocketPrivateImpl::AsPPB_TCPSocket_Private_API() {
   return this;
 }
@@ skipping 63 matching lines @@
   if (connection_state_ != CONNECTED)
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(ssl_handshake_callback_) ||
       TrackedCallback::IsPending(read_callback_) ||
       TrackedCallback::IsPending(write_callback_))
     return PP_ERROR_INPROGRESS;
 
   ssl_handshake_callback_ = new TrackedCallback(this, callback);
 
   // Send the request, the browser will call us back via SSLHandshakeACK.
-  SendSSLHandshake(server_name, server_port);
+  SendSSLHandshake(server_name, server_port,
+      trusted_certificates_, untrusted_certificates_);
   return PP_OK_COMPLETIONPENDING;
 }
 
+PP_Resource TCPSocketPrivateImpl::GetServerCertificate() {
+  if (!server_certificate_.get())
+    return 0;
+  return server_certificate_->GetReference();
+}
+
+PP_Bool TCPSocketPrivateImpl::AddChainBuildingCertificate(
+    PP_Resource certificate,
+    PP_Bool trusted) {
+  // TODO(raymes): The plumbing for this functionality is implemented but the
+  // certificates aren't yet used for the connection, so just return false for
+  // now.
+  return PP_FALSE;
+
+  ppapi::thunk::PPB_Flash_X509Certificate_API* resource =
+      PpapiGlobals::Get()->GetResourceTracker()->
+      GetResource(certificate)->AsPPB_Flash_X509Certificate_API();
+  if (!resource)
+    return PP_FALSE;
+
+  PP_Var der_var = resource->GetField(PP_FLASH_X509CERTIFICATE_RAW);
+  ArrayBufferVar* der_array_buffer = ArrayBufferVar::FromPPVar(der_var);
+  if (!der_array_buffer)
+    return PP_FALSE;
+
+  char* der_bytes = static_cast<char*>(der_array_buffer->Map());
+  uint32_t der_length = der_array_buffer->ByteLength();
+  std::vector<char> der(der_bytes, der_bytes + der_length);
+  if (PP_ToBool(trusted))
+    trusted_certificates_.push_back(der);
+  else
+    untrusted_certificates_.push_back(der);
+
+  return PP_TRUE;
+}
+
 int32_t TCPSocketPrivateImpl::Read(char* buffer,
                                    int32_t bytes_to_read,
                                    PP_CompletionCallback callback) {
   if (!buffer || bytes_to_read <= 0)
     return PP_ERROR_BADARGUMENT;
   if (!callback.func)
     return PP_ERROR_BLOCKS_MAIN_THREAD;
 
   if (!IsConnected())
     return PP_ERROR_FAILED;
@@ skipping 43 matching lines @@
 
   SendDisconnect();
   socket_id_ = 0;
 
   PostAbortIfNecessary(&connect_callback_);
   PostAbortIfNecessary(&ssl_handshake_callback_);
   PostAbortIfNecessary(&read_callback_);
   PostAbortIfNecessary(&write_callback_);
   read_buffer_ = NULL;
   bytes_to_read_ = -1;
+  server_certificate_ = NULL;
 }
 
 void TCPSocketPrivateImpl::OnConnectCompleted(
     bool succeeded,
     const PP_NetAddress_Private& local_addr,
     const PP_NetAddress_Private& remote_addr) {
   if (connection_state_ != BEFORE_CONNECT ||
       !TrackedCallback::IsPending(connect_callback_)) {
     NOTREACHED();
     return;
   }
 
   if (succeeded) {
     local_addr_ = local_addr;
     remote_addr_ = remote_addr;
     connection_state_ = CONNECTED;
   }
   TrackedCallback::ClearAndRun(&connect_callback_,
                                succeeded ? PP_OK : PP_ERROR_FAILED);
 }
 
-void TCPSocketPrivateImpl::OnSSLHandshakeCompleted(bool succeeded) {
+void TCPSocketPrivateImpl::OnSSLHandshakeCompleted(
+    bool succeeded,
+    const PPB_X509Certificate_Fields& certificate_fields) {
   if (connection_state_ != CONNECTED ||
       !TrackedCallback::IsPending(ssl_handshake_callback_)) {
     NOTREACHED();
     return;
   }
 
   if (succeeded) {
     connection_state_ = SSL_CONNECTED;
+    server_certificate_ = new PPB_Flash_X509Certificate_Shared(
+        resource_type,
+        pp_instance(),
+        certificate_fields);
     TrackedCallback::ClearAndRun(&ssl_handshake_callback_, PP_OK);
   } else {
     TrackedCallback::ClearAndRun(&ssl_handshake_callback_, PP_ERROR_FAILED);
     Disconnect();
   }
 }
 
 void TCPSocketPrivateImpl::OnReadCompleted(bool succeeded,
                                            const std::string& data) {
   if (!TrackedCallback::IsPending(read_callback_) || !read_buffer_) {
@@ skipping 47 matching lines @@
   return connection_state_ == CONNECTED || connection_state_ == SSL_CONNECTED;
 }
 
 void TCPSocketPrivateImpl::PostAbortIfNecessary(
     scoped_refptr<TrackedCallback>* callback) {
   if (callback->get())
     (*callback)->PostAbort();
 }
 
 }  // namespace ppapi