ppapi: PPB_VpnProvider: Bind VpnService to the PPAPI Resource Host

extensions/browser/api/vpn_provider/vpn_service.cc

 // Copyright 2014 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 "extensions/browser/api/vpn_provider/vpn_service.h"
 
 #include <stdint.h>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chromeos/dbus/shill_third_party_vpn_driver_client.h"
 #include "chromeos/dbus/shill_third_party_vpn_observer.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_type_pattern.h"
+#include "content/public/browser/pepper_vpn_provider_service_helper.h"
 #include "crypto/sha2.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 namespace api_vpn = extensions::api::vpn_provider;
@@ skipping 15 matching lines @@
 
   const std::string& extension_id() const { return extension_id_; }
   const std::string& configuration_name() const { return configuration_name_; }
   const std::string& key() const { return key_; }
   const std::string& service_path() const { return service_path_; }
   void set_service_path(const std::string& service_path) {
     service_path_ = service_path;
   }
   const std::string& object_path() const { return object_path_; }
 
+  void set_nacl_bound(bool nacl_bound) { nacl_bound_ = nacl_bound; }
+
   // ShillThirdPartyVpnObserver:
   void OnPacketReceived(const std::vector<char>& data) override;
   void OnPlatformMessage(uint32_t message) override;
 
  private:
   const std::string extension_id_;
   const std::string configuration_name_;
   const std::string key_;
   const std::string object_path_;
 
+  bool nacl_bound_;
+
   std::string service_path_;
 
   base::WeakPtr<VpnService> vpn_service_;
 
   DISALLOW_COPY_AND_ASSIGN(VpnConfiguration);
 };
 
 VpnService::VpnConfiguration::VpnConfiguration(
     const std::string& extension_id,
     const std::string& configuration_name,
     const std::string& key,
     base::WeakPtr<VpnService> vpn_service)
     : extension_id_(extension_id),
       configuration_name_(configuration_name),
       key_(key),
       object_path_(shill::kObjectPathBase + key_),
-      vpn_service_(vpn_service) {
-}
+      nacl_bound_(false),
+      vpn_service_(vpn_service) {}
 
 VpnService::VpnConfiguration::~VpnConfiguration() {
 }
 
 void VpnService::VpnConfiguration::OnPacketReceived(
     const std::vector<char>& data) {
   if (!vpn_service_) {
     return;
   }
-  std::unique_ptr<base::ListValue> event_args =
-      api_vpn::OnPacketReceived::Create(data);
-  vpn_service_->SendSignalToExtension(
-      extension_id_, extensions::events::VPN_PROVIDER_ON_PACKET_RECEIVED,
-      api_vpn::OnPacketReceived::kEventName, std::move(event_args));
+  // If the configrataion was added via a PPAPI plugin

[ncarter (slow), 2016/05/17 17:15:40]

"configuration"

[adrian.belgun, 2016/05/17 17:18:55]

Done.

+  if (nacl_bound_) {
+    content::VpnProviderServiceHelper::GetInstance()->OnPacketReceived(
+        extension_id_, data);
+  } else {
+    std::unique_ptr<base::ListValue> event_args =
+        api_vpn::OnPacketReceived::Create(data);
+    vpn_service_->SendSignalToExtension(
+        extension_id_, extensions::events::VPN_PROVIDER_ON_PACKET_RECEIVED,
+        api_vpn::OnPacketReceived::kEventName, std::move(event_args));
+  }
 }
 
 void VpnService::VpnConfiguration::OnPlatformMessage(uint32_t message) {
   if (!vpn_service_) {
     return;
   }
   DCHECK_GE(api_vpn::PLATFORM_MESSAGE_LAST, message);
 
   api_vpn::PlatformMessage platform_message =
       static_cast<api_vpn::PlatformMessage>(message);
 
   if (platform_message == api_vpn::PLATFORM_MESSAGE_CONNECTED) {
     vpn_service_->SetActiveConfiguration(this);
   } else if (platform_message == api_vpn::PLATFORM_MESSAGE_DISCONNECTED ||
              platform_message == api_vpn::PLATFORM_MESSAGE_ERROR) {
     vpn_service_->SetActiveConfiguration(nullptr);
+
+    // Disconnect NaCl-bound configuration
+    if (nacl_bound_) {
+      nacl_bound_ = false;
+      content::VpnProviderServiceHelper::GetInstance()->OnUnbind(extension_id_);
+    }
   }
 
   // TODO(kaliamoorthi): Update the lower layers to get the error message and
   // pass in the error instead of std::string().
   std::unique_ptr<base::ListValue> event_args =
       api_vpn::OnPlatformMessage::Create(configuration_name_, platform_message,
                                          std::string());
 
   vpn_service_->SendSignalToExtension(
       extension_id_, extensions::events::VPN_PROVIDER_ON_PLATFORM_MESSAGE,
       api_vpn::OnPlatformMessage::kEventName, std::move(event_args));
 }
 
+class VpnService::VpnServiceDelegateImpl : public content::VpnServiceDelegate {
+ public:
+  VpnServiceDelegateImpl(base::WeakPtr<VpnService> vpn_service);
+  ~VpnServiceDelegateImpl() override;
+
+  void Bind(const std::string& extension_id,
+            const std::string& configuration_id,
+            const std::string& configuration_name,
+            const SuccessCallback& success,
+            const FailureCallback& failure) override;
+  void SendPacket(const std::string& extension_id,
+                  const std::vector<char>& data,
+                  const SuccessCallback& success,
+                  const FailureCallback& failure) override;
+
+ private:
+  base::WeakPtr<VpnService> vpn_service_;
+
+  DISALLOW_COPY_AND_ASSIGN(VpnServiceDelegateImpl);
+};
+
+VpnService::VpnServiceDelegateImpl::VpnServiceDelegateImpl(
+    base::WeakPtr<VpnService> vpn_service)
+    : vpn_service_(vpn_service) {}
+
+VpnService::VpnServiceDelegateImpl::~VpnServiceDelegateImpl() {}
+
+void VpnService::VpnServiceDelegateImpl::Bind(
+    const std::string& extension_id,
+    const std::string& configuration_id,
+    const std::string& configuration_name,
+    const SuccessCallback& success,
+    const FailureCallback& failure) {
+  if (!vpn_service_) {
+    NOTREACHED();
+    return;
+  }
+
+  vpn_service_->Bind(extension_id, configuration_id, configuration_name,
+                     success, failure);
+}
+
+void VpnService::VpnServiceDelegateImpl::SendPacket(
+    const std::string& extension_id,
+    const std::vector<char>& data,
+    const SuccessCallback& success,
+    const FailureCallback& failure) {
+  if (!vpn_service_) {
+    NOTREACHED();
+    return;
+  }
+
+  vpn_service_->SendPacket(extension_id, data, success, failure);
+}
+
 VpnService::VpnService(
     content::BrowserContext* browser_context,
     const std::string& userid_hash,
     extensions::ExtensionRegistry* extension_registry,
     extensions::EventRouter* event_router,
     ShillThirdPartyVpnDriverClient* shill_client,
     NetworkConfigurationHandler* network_configuration_handler,
     NetworkProfileHandler* network_profile_handler,
     NetworkStateHandler* network_state_handler)
     : browser_context_(browser_context),
       userid_hash_(userid_hash),
       extension_registry_(extension_registry),
       event_router_(event_router),
       shill_client_(shill_client),
       network_configuration_handler_(network_configuration_handler),
       network_profile_handler_(network_profile_handler),
       network_state_handler_(network_state_handler),
       active_configuration_(nullptr),
       weak_factory_(this) {
   extension_registry_->AddObserver(this);
   network_state_handler_->AddObserver(this, FROM_HERE);
   network_configuration_handler_->AddObserver(this);
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&VpnService::NetworkListChanged, weak_factory_.GetWeakPtr()));
+  content::VpnProviderServiceHelper::GetInstance()->RegisterDelegate(
+      browser_context,
+      base::WrapUnique(new VpnServiceDelegateImpl(weak_factory_.GetWeakPtr())));
 }
 
 VpnService::~VpnService() {
   network_configuration_handler_->RemoveObserver(this);
   network_state_handler_->RemoveObserver(this, FROM_HERE);
   extension_registry_->RemoveObserver(this);
   STLDeleteContainerPairSecondPointers(key_to_configuration_map_.begin(),
                                        key_to_configuration_map_.end());
 }
 
@@ skipping 397 matching lines @@
   }
   delete configuration;
 }
 
 bool VpnService::DoesActiveConfigurationExistAndIsAccessAuthorized(
     const std::string& extension_id) {
   return active_configuration_ &&
          active_configuration_->extension_id() == extension_id;
 }
 
+void VpnService::Bind(const std::string& extension_id,
+                      const std::string& configuration_id,
+                      const std::string& configuration_name,
+                      const SuccessCallback& success,
+                      const FailureCallback& failure) {
+  // The ID is the configuration name for now. This may change in the future.
+  const std::string key = GetKey(extension_id, configuration_id);
+  if (!ContainsKey(key_to_configuration_map_, key)) {
+    failure.Run(std::string(), std::string("Unauthorized access 1."));
+    return;
+  }
+
+  VpnConfiguration* configuration = key_to_configuration_map_[key];
+  if (active_configuration_ != configuration) {
+    failure.Run(std::string(), std::string("Unauthorized access 2."));
+    return;
+  }
+
+  if (configuration->extension_id() != extension_id ||
+      configuration->configuration_name() != configuration_name) {
+    failure.Run(std::string(), std::string("Unauthorized access 3."));
+    return;
+  }
+
+  const std::string service_path = configuration->service_path();
+  if (service_path.empty()) {
+    failure.Run(std::string(), std::string("Pending create."));
+    return;
+  }
+
+  // Connection authorized. All packets will be routed through NaCl.
+  configuration->set_nacl_bound(true);
+
+  success.Run();
+}
+
 }  // namespace chromeos