Use extensions socket permission for TCP/UDP socket APIs in Pepper

content/browser/renderer_host/pepper/pepper_message_filter.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 "content/browser/renderer_host/pepper/pepper_message_filter.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ skipping 99 matching lines @@
       host_resolver_(host_resolver),
       next_socket_id_(1),
       incognito_(false) {
   DCHECK(type == PLUGIN);
   DCHECK(host_resolver);
 }
 
 void PepperMessageFilter::OverrideThreadForMessage(
     const IPC::Message& message,
     BrowserThread::ID* thread) {
-  if (message.type() == PpapiHostMsg_PPBTCPSocket_Connect::ID ||
+  if (message.type() == PpapiHostMsg_PPBTCPServerSocket_Listen::ID ||
+      message.type() == PpapiHostMsg_PPBTCPSocket_Connect::ID ||
       message.type() == PpapiHostMsg_PPBTCPSocket_ConnectWithNetAddress::ID ||
       message.type() == PpapiHostMsg_PPBUDPSocket_Bind::ID ||
-      message.type() == PpapiHostMsg_PPBTCPServerSocket_Listen::ID ||
-      message.type() == PpapiHostMsg_PPBHostResolver_Resolve::ID) {
+      message.type() == PpapiHostMsg_PPBUDPSocket_SendTo::ID) {
     *thread = BrowserThread::UI;
   } else if (message.type() == PepperMsg_GetDeviceID::ID) {
     *thread = BrowserThread::FILE;
   }
 }
 
 bool PepperMessageFilter::OnMessageReceived(const IPC::Message& msg,
                                             bool* message_was_ok) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(PepperMessageFilter, msg, *message_was_ok)
@@ skipping 143 matching lines @@
 
   tcp_sockets_[*socket_id] = linked_ptr<PepperTCPSocket>(
       new PepperTCPSocket(this, routing_id, plugin_dispatcher_id, *socket_id));
 }
 
 void PepperMessageFilter::OnTCPConnect(int32 routing_id,
                                        uint32 socket_id,
                                        const std::string& host,
                                        uint16_t port) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  content::SocketPermissionRequest params(
+      content::SocketPermissionRequest::TCP_CONNECT, host, port);
+  bool allowed = CanUseSocketAPIs(routing_id, params);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
       base::Bind(&PepperMessageFilter::DoTCPConnect, this,
-          CanUseSocketAPIs(routing_id), routing_id, socket_id, host, port));
+          allowed, routing_id, socket_id, host, port));
 }
 
 void PepperMessageFilter::DoTCPConnect(bool allowed,
                                        int32 routing_id,
                                        uint32 socket_id,
                                        const std::string& host,
                                        uint16_t port) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   TCPSocketMap::iterator iter = tcp_sockets_.find(socket_id);
   if (iter == tcp_sockets_.end()) {
     NOTREACHED();
     return;
   }
 
   if (routing_id == iter->second->routing_id() && allowed)
     iter->second->Connect(host, port);
   else
     iter->second->SendConnectACKError();
 }
 
 void PepperMessageFilter::OnTCPConnectWithNetAddress(
     int32 routing_id,
     uint32 socket_id,
     const PP_NetAddress_Private& net_addr) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  bool allowed = CanUseSocketAPIs(routing_id, CreateSocketPermissionRequest(
+      content::SocketPermissionRequest::TCP_CONNECT, net_addr));
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
       base::Bind(&PepperMessageFilter::DoTCPConnectWithNetAddress, this,
-          CanUseSocketAPIs(routing_id), routing_id, socket_id, net_addr));
+          allowed, routing_id, socket_id, net_addr));
 }
 
 void PepperMessageFilter::DoTCPConnectWithNetAddress(
     bool allowed,
     int32 routing_id,
     uint32 socket_id,
     const PP_NetAddress_Private& net_addr) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   TCPSocketMap::iterator iter = tcp_sockets_.find(socket_id);
   if (iter == tcp_sockets_.end()) {
@@ skipping 95 matching lines @@
     default:
       NOTREACHED();
       break;
   }
 }
 
 void PepperMessageFilter::OnUDPBind(int32 routing_id,
                                     uint32 socket_id,
                                     const PP_NetAddress_Private& addr) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  bool allowed = CanUseSocketAPIs(routing_id, CreateSocketPermissionRequest(
+      content::SocketPermissionRequest::UDP_BIND, addr));
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
       base::Bind(&PepperMessageFilter::DoUDPBind, this,
-          CanUseSocketAPIs(routing_id), routing_id, socket_id, addr));
+          allowed, routing_id, socket_id, addr));
 }
 
 void PepperMessageFilter::DoUDPBind(bool allowed,
                                     int32 routing_id,
                                     uint32 socket_id,
                                     const PP_NetAddress_Private& addr) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   UDPSocketMap::iterator iter = udp_sockets_.find(socket_id);
   if (iter == udp_sockets_.end()) {
     NOTREACHED();
     return;
   }
 
   if (routing_id == iter->second->routing_id() && allowed)
     iter->second->Bind(addr);
   else
     iter->second->SendBindACKError();
 }
 
 void PepperMessageFilter::OnUDPRecvFrom(uint32 socket_id, int32_t num_bytes) {
   UDPSocketMap::iterator iter = udp_sockets_.find(socket_id);
   if (iter == udp_sockets_.end()) {
     NOTREACHED();
     return;
   }
 
   iter->second->RecvFrom(num_bytes);
 }
 
-void PepperMessageFilter::OnUDPSendTo(uint32 socket_id,
+void PepperMessageFilter::OnUDPSendTo(int32 routing_id,
+                                      uint32 socket_id,
                                       const std::string& data,
                                       const PP_NetAddress_Private& addr) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  bool allowed = CanUseSocketAPIs(routing_id, CreateSocketPermissionRequest(
+      content::SocketPermissionRequest::UDP_SEND_TO, addr));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&PepperMessageFilter::DoUDPSendTo, this,
+          allowed, routing_id, socket_id, data, addr));
+
+}
+
+void PepperMessageFilter::DoUDPSendTo(bool allowed,
+                                      int32 routing_id,
+                                      uint32 socket_id,
+                                      const std::string& data,
+                                      const PP_NetAddress_Private& addr) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   UDPSocketMap::iterator iter = udp_sockets_.find(socket_id);
   if (iter == udp_sockets_.end()) {
     NOTREACHED();
     return;
   }
 
-  iter->second->SendTo(data, addr);
+  if (routing_id == iter->second->routing_id() && allowed)
+    iter->second->SendTo(data, addr);
+  else
+    iter->second->SendSendToACKError();
 }
 
 void PepperMessageFilter::OnUDPClose(uint32 socket_id) {
   UDPSocketMap::iterator iter = udp_sockets_.find(socket_id);
   if (iter == udp_sockets_.end()) {
     NOTREACHED();
     return;
   }
 
   // Destroy the UDPSocket instance will cancel any pending completion
   // callback. From this point on, there won't be any messages associated with
   // this socket sent to the plugin side.
   udp_sockets_.erase(iter);
 }
 
 void PepperMessageFilter::OnTCPServerListen(int32 routing_id,
                                             uint32 plugin_dispatcher_id,
                                             PP_Resource socket_resource,
                                             const PP_NetAddress_Private& addr,
                                             int32_t backlog) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  bool allowed = CanUseSocketAPIs(routing_id, CreateSocketPermissionRequest(
+      content::SocketPermissionRequest::TCP_LISTEN, addr));
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&PepperMessageFilter::DoTCPServerListen,
                                      this,
-                                     CanUseSocketAPIs(routing_id),
+                                     allowed,
                                      routing_id,
                                      plugin_dispatcher_id,
                                      socket_resource,
                                      addr,
                                      backlog));
 }
 
 void PepperMessageFilter::DoTCPServerListen(bool allowed,
                                             int32 routing_id,
                                             uint32 plugin_dispatcher_id,
@@ skipping 34 matching lines @@
   }
   iter->second->Accept(tcp_client_socket_routing_id);
 }
 
 void PepperMessageFilter::OnHostResolverResolve(
     int32 routing_id,
     uint32 plugin_dispatcher_id,
     uint32 host_resolver_id,
     const ppapi::HostPortPair& host_port,
     const PP_HostResolver_Private_Hint& hint) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&PepperMessageFilter::DoHostResolverResolve, this,
-                 CanUseSocketAPIs(routing_id),
-                 routing_id,
-                 plugin_dispatcher_id,
-                 host_resolver_id,
-                 host_port,
-                 hint));
-}
-
-void PepperMessageFilter::DoHostResolverResolve(
-    bool allowed,
-    int32 routing_id,
-    uint32 plugin_dispatcher_id,
-    uint32 host_resolver_id,
-    const ppapi::HostPortPair& host_port,
-    const PP_HostResolver_Private_Hint& hint) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (!allowed) {
-    SendHostResolverResolveACKError(routing_id,
-                                    plugin_dispatcher_id,
-                                    host_resolver_id);
-    return;
-  }
-
   net::HostResolver::RequestInfo request_info(
       net::HostPortPair(host_port.host, host_port.port));
 
   net::AddressFamily address_family;
   switch (hint.family) {
     case PP_NETADDRESSFAMILY_IPV4:
       address_family = net::ADDRESS_FAMILY_IPV4;
       break;
     case PP_NETADDRESSFAMILY_IPV6:
       address_family = net::ADDRESS_FAMILY_IPV6;
@@ skipping 210 matching lines @@
     // the counter overflows.
     socket_id = next_socket_id_++;
   } while (socket_id == kInvalidSocketID ||
            tcp_sockets_.find(socket_id) != tcp_sockets_.end() ||
            udp_sockets_.find(socket_id) != udp_sockets_.end() ||
            tcp_server_sockets_.find(socket_id) != tcp_server_sockets_.end());
 
   return socket_id;
 }
 
-bool PepperMessageFilter::CanUseSocketAPIs(int32 render_id) {
+bool PepperMessageFilter::CanUseSocketAPIs(int32 render_id,
+    const content::SocketPermissionRequest& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (process_type_ == PLUGIN) {
     // Always allow socket APIs for out-process plugins.
     return true;
   }
 
   RenderViewHostImpl* render_view_host =
       RenderViewHostImpl::FromID(process_id_, render_id);
   if (!render_view_host)
     return false;
 
   SiteInstance* site_instance = render_view_host->GetSiteInstance();
   if (!site_instance)
     return false;
 
   if (!GetContentClient()->browser()->AllowPepperSocketAPI(
           site_instance->GetBrowserContext(),
-          site_instance->GetSiteURL())) {
+          site_instance->GetSiteURL(),
+          params)) {
     LOG(ERROR) << "Host " << site_instance->GetSiteURL().host()
-               << " cannot use socket API";
+               << " cannot use socket API or destination is not allowed";
     return false;
   }
 
   return true;
 }
 
+content::SocketPermissionRequest
+PepperMessageFilter::CreateSocketPermissionRequest(
+    content::SocketPermissionRequest::OperationType type,
+    const PP_NetAddress_Private& net_addr) {
+  std::string host = NetAddressPrivateImpl::DescribeNetAddress(net_addr, false);
+  int port = 0;
+  std::vector<unsigned char> address;
+  NetAddressPrivateImpl::NetAddressToIPEndPoint(net_addr, &address, &port);
+  return content::SocketPermissionRequest(type, host, port);
+}
+
 void PepperMessageFilter::GetAndSendNetworkList() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   BrowserThread::PostBlockingPoolTask(
       FROM_HERE, base::Bind(&PepperMessageFilter::DoGetNetworkList, this));
 }
 
 void PepperMessageFilter::DoGetNetworkList() {
   scoped_ptr<net::NetworkInterfaceList> list(new net::NetworkInterfaceList());
   net::GetNetworkList(list.get());
@@ skipping 28 matching lines @@
     network_copy.mtu = 0;
   }
   for (NetworkMonitorIdSet::iterator it = network_monitor_ids_.begin();
        it != network_monitor_ids_.end(); ++it) {
     Send(new PpapiMsg_PPBNetworkMonitor_NetworkList(
         ppapi::API_ID_PPB_NETWORKMANAGER_PRIVATE, *it, *list_copy));
   }
 }
 
 }  // namespace content