Send API error response when chrome.socket.* API receives an invalid port number.

extensions/browser/api/socket/socket_api.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/socket/socket_api.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 22 matching lines @@
 #include "net/log/net_log.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 #if defined(OS_CHROMEOS)
 #include "content/public/browser/browser_thread.h"
 #endif  // OS_CHROMEOS
 
 namespace extensions {
 
-using content::BrowserThread;
-using content::SocketPermissionRequest;
+namespace {
 
 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 kSocketNotFoundError[] = "Socket not found";
 const char kDnsLookupFailedError[] = "DNS resolution failed";
 const char kPermissionError[] = "App does not have permission";
+const char kPortInvalidError[] = "Port must be a value between 0 and 65535.";
 const char kNetworkListError[] = "Network lookup failed or unsupported";
 const char kTCPSocketBindError[] =
     "TCP socket does not support bind. For TCP server please use listen.";
 const char kMulticastSocketTypeError[] = "Only UDP socket supports multicast.";
 const char kSecureSocketTypeError[] = "Only TCP sockets are supported for TLS.";
 const char kSocketNotConnectedError[] = "Socket not connected";
 const char kWildcardAddress[] = "*";
 const uint16_t kWildcardPort = 0;
 
 #if defined(OS_CHROMEOS)
 const char kFirewallFailure[] = "Failed to open firewall port";
 #endif  // OS_CHROMEOS
 
+bool IsPortValid(int port) {
+  return port >= 0 && port <= 65535;
+}
+
+}  // namespace
+
+using content::BrowserThread;
+using content::SocketPermissionRequest;
+
 SocketAsyncApiFunction::SocketAsyncApiFunction() {}
 
 SocketAsyncApiFunction::~SocketAsyncApiFunction() {}
 
 bool SocketAsyncApiFunction::PrePrepare() {
   manager_ = CreateSocketResourceManager();
   return manager_->SetBrowserContext(browser_context());
 }
 
 bool SocketAsyncApiFunction::Respond() { return error_.empty(); }
@@ skipping 185 matching lines @@
 SocketConnectFunction::SocketConnectFunction()
     : socket_id_(0), hostname_(), port_(0) {
 }
 
 SocketConnectFunction::~SocketConnectFunction() {}
 
 bool SocketConnectFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &hostname_));
   int port;
-  EXTENSION_FUNCTION_VALIDATE(
-      args_->GetInteger(2, &port) && port >= 0 && port <= 65535);
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(2, &port));
+  if (!IsPortValid(port)) {
+    error_ = kPortInvalidError;
+    return false;
+  }
   port_ = static_cast<uint16_t>(port);
   return true;
 }
 
 void SocketConnectFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(socket_id_);
   if (!socket) {
     error_ = kSocketNotFoundError;
     SetResult(base::MakeUnique<base::FundamentalValue>(-1));
     AsyncWorkCompleted();
@@ skipping 66 matching lines @@
     socket->Disconnect();
   else
     error_ = kSocketNotFoundError;
   SetResult(base::Value::CreateNullValue());
 }
 
 bool SocketBindFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &address_));
   int port;
-  EXTENSION_FUNCTION_VALIDATE(
-      args_->GetInteger(2, &port) && port >= 0 && port <= 65535);
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(2, &port));
+  if (!IsPortValid(port)) {
+    error_ = kPortInvalidError;
+    return false;
+  }
   port_ = static_cast<uint16_t>(port);
   return true;
 }
 
 void SocketBindFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(socket_id_);
   if (!socket) {
     error_ = kSocketNotFoundError;
     SetResult(base::MakeUnique<base::FundamentalValue>(-1));
     AsyncWorkCompleted();
@@ skipping 226 matching lines @@
 }
 
 SocketSendToFunction::~SocketSendToFunction() {}
 
 bool SocketSendToFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   base::BinaryValue* data = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetBinary(1, &data));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &hostname_));
   int port;
-  EXTENSION_FUNCTION_VALIDATE(
-      args_->GetInteger(3, &port) && port >= 0 && port <= 65535);
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(3, &port));
+  if (!IsPortValid(port)) {
+    error_ = kPortInvalidError;
+    return false;
+  }
   port_ = static_cast<uint16_t>(port);
 
   io_buffer_size_ = data->GetSize();
   io_buffer_ = new net::WrappedIOBuffer(data->GetBuffer());
   return true;
 }
 
 void SocketSendToFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(socket_id_);
   if (!socket) {
@@ skipping 452 matching lines @@
   } else {
     RemoveSocket(params_->socket_id);
     error_ = net::ErrorToString(result);
   }
 
   results_ = api::socket::Secure::Results::Create(result);
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions