Implement chrome.socket.bind/listen/accept for TCP server socket.

chrome/browser/extensions/api/socket/tcp_socket.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/tcp_socket.h"
 
 #include "chrome/browser/extensions/api/api_resource.h"
 #include "chrome/browser/extensions/api/api_resource_event_notifier.h"
 #include "net/base/address_list.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/rand_callback.h"
 #include "net/socket/tcp_client_socket.h"
 
 namespace extensions {
 
 TCPSocket::TCPSocket(ApiResourceEventNotifier* event_notifier)
-    : Socket(event_notifier) {
+    : Socket(event_notifier),
+      is_client_socket_(false),
+      is_server_socket_(false) {
+}
+
+TCPSocket::TCPSocket(ApiResourceEventNotifier* event_notifier,
+                     net::TCPClientSocket* client_socket)
+    : Socket(event_notifier),
+      socket_(client_socket),
+      is_client_socket_(true),
+      is_server_socket_(false) {
+  this->is_connected_ = true;
 }
 
 // For testing.
 TCPSocket::TCPSocket(net::TCPClientSocket* tcp_client_socket,
                      ApiResourceEventNotifier* event_notifier)
     : Socket(event_notifier),
-      socket_(tcp_client_socket) {
+      socket_(tcp_client_socket),
+      is_client_socket_(false),
+      is_server_socket_(false) {
 }
 
 // static
 TCPSocket* TCPSocket::CreateSocketForTesting(
     net::TCPClientSocket* tcp_client_socket,
     ApiResourceEventNotifier* event_notifier) {
   return new TCPSocket(tcp_client_socket, event_notifier);
 }
 
 TCPSocket::~TCPSocket() {
   if (is_connected_) {
     Disconnect();
   }
 }
 
 void TCPSocket::Connect(const std::string& address,
                         int port,
                         const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
 
-  if (!connect_callback_.is_null()) {
+  if (!connect_callback_.is_null() || is_server_socket_) {
     callback.Run(net::ERR_CONNECTION_FAILED);
     return;
   }
+  DCHECK(server_socket_.get() == NULL);
+  is_client_socket_ = true;
   connect_callback_ = callback;
+  // TODO(justinlin): I think this should destroy any previously connected
+  // socket, otherwise we might run into binding issues.
 
   int result = net::ERR_CONNECTION_FAILED;
   do {
     if (is_connected_)
       break;
 
     net::AddressList address_list;
     if (!StringAndPortToAddressList(address, port, &address_list)) {
       result = net::ERR_ADDRESS_INVALID;
       break;
     }
 
     socket_.reset(new net::TCPClientSocket(address_list, NULL,
                                            net::NetLog::Source()));
+
+    if (bind_address_.get() != NULL) {
+      if (socket_->Bind(*bind_address_) != 0) {
+        socket_.reset();
+        OnConnectComplete(net::ERR_ADDRESS_IN_USE);
+        return;
+      };
+    }
+
     connect_callback_ = callback;
     result = socket_->Connect(base::Bind(
         &TCPSocket::OnConnectComplete, base::Unretained(this)));
   } while (false);
 
   if (result != net::ERR_IO_PENDING)
     OnConnectComplete(result);
 }
 
 void TCPSocket::Disconnect() {
   is_connected_ = false;
   socket_->Disconnect();
 }
 
 int TCPSocket::Bind(const std::string& address, int port) {
-  // TODO(penghuang): Supports bind for tcp?
-  return net::ERR_FAILED;
+  // TODO(justinlin): Allow binding to multiple interfaces?
+  if (bind_address_.get() != NULL) {
+    return net::ERR_FAILED;
+  }
+
+  scoped_ptr<net::IPEndPoint> ip_end_point(new net::IPEndPoint());
+  if (!StringAndPortToIPEndPoint(address, port, ip_end_point.get()))
+    return net::ERR_INVALID_ARGUMENT;
+
+  bind_address_.swap(ip_end_point);
+  return true;
 }
 
 void TCPSocket::Read(int count,
                      const ReadCompletionCallback& callback) {
   DCHECK(!callback.is_null());
 
+  if (!is_client_socket_) {
+    callback.Run(net::ERR_FAILED, NULL);
+    return;
+  }
+
   if (!read_callback_.is_null()) {
     callback.Run(net::ERR_IO_PENDING, NULL);
     return;
   } else {
     read_callback_ = callback;
   }
 
   int result = net::ERR_FAILED;
   scoped_refptr<net::IOBuffer> io_buffer;
   do {
@@ skipping 35 matching lines @@
     return false;
   return socket_->SetKeepAlive(enable, delay);
 }
 
 bool TCPSocket::SetNoDelay(bool no_delay) {
   if (!socket_.get())
     return false;
   return socket_->SetNoDelay(no_delay);
 }
 
+bool TCPSocket::Listen(int backlog) {
+  if (is_client_socket_) {
+    return false;

[miket_OOO, 2012/08/31 23:18:01]

An error message would be nice.

[justinlin, 2012/09/11 04:32:32]

Done.

+  }
+  DCHECK(socket_.get() == NULL);
+  is_server_socket_ = true;
+
+  if (bind_address_.get() == NULL) {
+    return net::ERR_FAILED;
+  }
+
+  server_socket_.reset(new net::TCPServerSocket(NULL,
+                                                net::NetLog::Source()));
+  return server_socket_->Listen(*bind_address_, backlog);
+}
+
+void TCPSocket::Accept(const AcceptCompletionCallback &callback) {
+  // This also makes it so you can't accept before listening, but that's
+  // probably OK?
+  if (!is_server_socket_ || server_socket_.get() == NULL) {
+    callback.Run(net::ERR_FAILED, NULL);
+    return;
+  }
+
+  // Limits to only 1 blocked accept call.

[miket_OOO, 2012/08/31 23:18:01]

Should this be a TODO to allow multiple? (I'm not clear whether this means that
multiple concurrent connection attempts will fail. Does the queueing up happen
lower, at the socket level? Probably.)

[justinlin, 2012/09/11 04:32:32]

Yea, the number of connections held in the queue is determined by the backlog
argument to the Listen function. I think client-side code would get messy if you
allow multiple and js is single threaded anyway, so I'm not sure there's any
point to allow this.

On 2012/08/31 23:18:01, miket wrote:

+  if (!accept_callback_.is_null()) {
+    callback.Run(net::ERR_FAILED, NULL);
+    return;
+  }
+
+  int result = server_socket_->Accept(&accept_socket_, base::Bind(
+          &TCPSocket::OnAccept, base::Unretained(this)));
+  if (result == net::ERR_IO_PENDING) {
+    accept_callback_ = callback;
+    return;
+  } else if (result == net::OK) {
+    accept_callback_ = callback;
+    this->OnAccept(result);
+    return;
+  } else {
+    callback.Run(result, NULL);
+    return;
+  }
+}
+
 bool TCPSocket::IsTCPSocket() {
   return true;
 }
 
 bool TCPSocket::GetPeerAddress(net::IPEndPoint* address) {
   if (!socket_.get())
     return false;
   return !socket_->GetPeerAddress(address);
 }
 
 bool TCPSocket::GetLocalAddress(net::IPEndPoint* address) {
-  if (!socket_.get())
+  if (socket_.get() != NULL) {
+    return !socket_->GetLocalAddress(address);
+  } else if (server_socket_.get() != NULL) {
+    return !server_socket_->GetLocalAddress(address);
+  } else {
     return false;
-  return !socket_->GetLocalAddress(address);
+  }
 }
 
 
 int TCPSocket::WriteImpl(net::IOBuffer* io_buffer,
                          int io_buffer_size,
                          const net::CompletionCallback& callback) {
-  if (!socket_.get() || !socket_->IsConnected())
+  if (!is_client_socket_) {
+    return net::ERR_FAILED;
+  } else if (!socket_.get() || !socket_->IsConnected())
     return net::ERR_SOCKET_NOT_CONNECTED;
   else
     return socket_->Write(io_buffer, io_buffer_size, callback);
 }
 
 void TCPSocket::OnConnectComplete(int result) {
   DCHECK(!connect_callback_.is_null());
   DCHECK(!is_connected_);
   is_connected_ = result == net::OK;
   connect_callback_.Run(result);
   connect_callback_.Reset();
 }
 
 void TCPSocket::OnReadComplete(scoped_refptr<net::IOBuffer> io_buffer,
                                int result) {
   DCHECK(!read_callback_.is_null());
   read_callback_.Run(result, io_buffer);
   read_callback_.Reset();
 }
 
+void TCPSocket::OnAccept(int result) {
+  DCHECK(!accept_callback_.is_null());
+  if (result == net::OK) {
+    DCHECK(accept_socket_.get() != NULL);
+
+    accept_callback_.Run(
+        result, static_cast<net::TCPClientSocket*>(accept_socket_.release()));
+  } else {
+    accept_callback_.Run(result, NULL);
+  }
+  accept_callback_.Reset();
+}
+
 }  // namespace extensions