Support socket endpoint permissions for AppsV2 Socket API.

chrome/browser/extensions/api/socket/socket_api.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 "chrome/browser/extensions/api/socket/socket_api.h"
 
 #include "base/bind.h"
+#include "chrome/common/extensions/permissions/socket_permission.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/dns/host_resolver_wrapper.h"
 #include "chrome/browser/extensions/api/socket/socket.h"
 #include "chrome/browser/extensions/api/socket/tcp_socket.h"
 #include "chrome/browser/extensions/api/socket/udp_socket.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/io_thread.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 
 namespace extensions {
 
 const char kAddressKey[] = "address";
 const char kPortKey[] = "port";
 const char kBytesWrittenKey[] = "bytesWritten";
 const char kDataKey[] = "data";
 const char kResultCodeKey[] = "resultCode";
 const char kSocketIdKey[] = "socketId";
 const char kTCPOption[] = "tcp";
 const char kUDPOption[] = "udp";
+const char kUnknown[] = "unknown";
 
 const char kSocketNotFoundError[] = "Socket not found";
 const char kSocketTypeInvalidError[] = "Socket type is not supported";
 const char kDnsLookupFailedError[] = "DNS resolution failed";
+const char kPermissionError[] = "Caller does not have permission";
 
 SocketAsyncApiFunction::SocketAsyncApiFunction()
     : manager_(NULL) {
 }
 
 SocketAsyncApiFunction::~SocketAsyncApiFunction() {
 }
 
 bool SocketAsyncApiFunction::PrePrepare() {
   manager_ = ExtensionSystem::Get(profile())->socket_manager();
@@ skipping 111 matching lines @@
 }
 
 bool SocketConnectFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &hostname_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(2, &port_));
   return true;
 }
 
 void SocketConnectFunction::AsyncWorkStart() {
+  socket_ = manager_->Get(socket_id_);
+  if (!socket_) {
+    error_ = kSocketNotFoundError;
+    SetResult(Value::CreateIntegerValue(-1));
+    AsyncWorkCompleted();
+    return;
+  }
+
+  SocketPermissionData::OperationType operation_type;
+  switch (socket_->socket_type()) {
+    case Socket::TYPE_TCP:
+      operation_type = SocketPermissionData::TCP_CONNECT;
+      break;
+    case Socket::TYPE_UDP:
+      operation_type = SocketPermissionData::UDP_SEND_TO;
+      break;
+    default:
+      NOTREACHED() << "Unknown socket type.";
+      operation_type = SocketPermissionData::NONE;
+      break;
+  }
+
+  SocketPermission::CheckParam param(operation_type, hostname_, port_);
+  if (!GetExtension()->CheckAPIPermissionWithDetail(APIPermission::kSocket,
+        &param)) {
+    error_ = kPermissionError;
+    SetResult(Value::CreateIntegerValue(-1));
+    AsyncWorkCompleted();
+    return;
+  }
+
   StartDnsLookup(hostname_);
 }
 
 void SocketConnectFunction::AfterDnsLookup(int lookup_result) {
   if (lookup_result == net::OK) {
     StartConnect();
   } else {
     SetResult(Value::CreateIntegerValue(lookup_result));
     AsyncWorkCompleted();
   }
 }
 
 void SocketConnectFunction::StartConnect() {
-  Socket* socket = manager_->Get(socket_id_);
-  if (!socket) {
-    error_ = kSocketNotFoundError;
-    OnConnect(-1);
-    return;
-  }
-
-  socket->Connect(resolved_address_, port_,
-                  base::Bind(&SocketConnectFunction::OnConnect, this));
+  socket_->Connect(resolved_address_, port_,
+                   base::Bind(&SocketConnectFunction::OnConnect, this));
 }
 
 void SocketConnectFunction::OnConnect(int result) {
   SetResult(Value::CreateIntegerValue(result));
   AsyncWorkCompleted();
 }
 
 bool SocketDisconnectFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   return true;
@@ skipping 11 matching lines @@
 bool SocketBindFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &address_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(2, &port_));
   return true;
 }
 
 void SocketBindFunction::Work() {
   int result = -1;
   Socket* socket = manager_->Get(socket_id_);
-  if (socket)
-    result = socket->Bind(address_, port_);
-  else
+
+  if (!socket) {
     error_ = kSocketNotFoundError;
+    SetResult(Value::CreateIntegerValue(result));
+    return;
+  }
 
+  if (socket->socket_type() == Socket::TYPE_UDP) {
+    SocketPermission::CheckParam param(
+        SocketPermissionData::UDP_BIND, address_, port_);
+    if (!GetExtension()->CheckAPIPermissionWithDetail(APIPermission::kSocket,
+          &param)) {
+      error_ = kPermissionError;
+      SetResult(Value::CreateIntegerValue(result));
+      return;
+    }
+  }
+
+  result = socket->Bind(address_, port_);
   SetResult(Value::CreateIntegerValue(result));
 }
 
 SocketReadFunction::SocketReadFunction()
     : params_(NULL) {
 }
 
 SocketReadFunction::~SocketReadFunction() {}
 
 bool SocketReadFunction::Prepare() {
@@ skipping 132 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(args_->GetBinary(1, &data));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &hostname_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(3, &port_));
 
   io_buffer_size_ = data->GetSize();
   io_buffer_ = new net::WrappedIOBuffer(data->GetBuffer());
   return true;
 }
 
 void SocketSendToFunction::AsyncWorkStart() {
+  socket_ = manager_->Get(socket_id_);
+  if (!socket_) {
+    error_ = kSocketNotFoundError;
+    SetResult(Value::CreateIntegerValue(-1));
+    AsyncWorkCompleted();
+    return;
+  }
+
+  if (socket_->socket_type() == Socket::TYPE_UDP) {
+    SocketPermission::CheckParam param(SocketPermissionData::UDP_SEND_TO,
+        hostname_, port_);
+    if (!GetExtension()->CheckAPIPermissionWithDetail(APIPermission::kSocket,
+          &param)) {
+      error_ = kPermissionError;
+      SetResult(Value::CreateIntegerValue(-1));
+      AsyncWorkCompleted();
+      return;
+    }
+  }
+
   StartDnsLookup(hostname_);
 }
 
 void SocketSendToFunction::AfterDnsLookup(int lookup_result) {
   if (lookup_result == net::OK) {
     StartSendTo();
   } else {
     SetResult(Value::CreateIntegerValue(lookup_result));
     AsyncWorkCompleted();
   }
 }
 
 void SocketSendToFunction::StartSendTo() {
-  Socket* socket = manager_->Get(socket_id_);
-  if (!socket) {
-    error_ = kSocketNotFoundError;
-    OnCompleted(-1);
-    return;
-  }
-
-  socket->SendTo(io_buffer_, io_buffer_size_, resolved_address_, port_,
-                 base::Bind(&SocketSendToFunction::OnCompleted, this));
+  socket_->SendTo(io_buffer_, io_buffer_size_, resolved_address_, port_,
+                  base::Bind(&SocketSendToFunction::OnCompleted, this));
 }
 
 void SocketSendToFunction::OnCompleted(int bytes_written) {
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(kBytesWrittenKey, bytes_written);
   SetResult(result);
 
   AsyncWorkCompleted();
 }
 
@@ skipping 55 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketGetInfoFunction::Work() {
   api::socket::SocketInfo info;
   Socket* socket = manager_->Get(params_->socket_id);
   if (socket) {
     // This represents what we know about the socket, and does not call through
     // to the system.
-    info.socket_type = (socket->IsTCPSocket() ? kTCPOption : kUDPOption);
+    switch (socket->socket_type()) {
+      case Socket::TYPE_TCP:
+        info.socket_type = kTCPOption;
+        break;
+      case Socket::TYPE_UDP:
+        info.socket_type = kUDPOption;
+        break;
+      default:
+        NOTREACHED() << "Unknown socket type.";
+        info.socket_type = kUnknown;
+        break;
+    }
     info.connected = socket->IsConnected();
 
     // Grab the peer address as known by the OS. This and the call below will
     // always succeed while the socket is connected, even if the socket has
     // been remotely closed by the peer; only reading the socket will reveal
     // that it should be closed locally.
     net::IPEndPoint peerAddress;
     if (socket->GetPeerAddress(&peerAddress)) {
       info.peer_address.reset(
           new std::string(peerAddress.ToStringWithoutPort()));
       info.peer_port.reset(new int(peerAddress.port()));
     }
 
     // Grab the local address as known by the OS.
     net::IPEndPoint localAddress;
     if (socket->GetLocalAddress(&localAddress)) {
       info.local_address.reset(
           new std::string(localAddress.ToStringWithoutPort()));
       info.local_port.reset(new int(localAddress.port()));
     }
   } else {
     error_ = kSocketNotFoundError;
   }
   SetResult(info.ToValue().release());
 }
 
 }  // namespace extensions