[NaCl SDK] Add UDP and TCP Sockets

native_client_sdk/src/libraries/nacl_io/mount_node_tcp.cc

Index: native_client_sdk/src/libraries/nacl_io/mount_node_tcp.cc
diff --git a/native_client_sdk/src/libraries/nacl_io/mount_node_tcp.cc b/native_client_sdk/src/libraries/nacl_io/mount_node_tcp.cc
new file mode 100644
index 0000000000000000000000000000000000000000..419f17aacf0e32da1e95eb9e320ca6e229c8fe1c
--- /dev/null
+++ b/native_client_sdk/src/libraries/nacl_io/mount_node_tcp.cc
@@ -0,0 +1,142 @@
+// Copyright (c) 2013 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 "nacl_io/ossocket.h"
+#ifdef PROVIDES_SOCKET_API
+
+#include <errno.h>
+#include <string.h>
+
+#include "nacl_io/mount.h"
+#include "nacl_io/mount_node_socket.h"
+#include "nacl_io/mount_node_tcp.h"
+#include "nacl_io/pepper_interface.h"
+
+namespace nacl_io {
+
+MountNodeTCP::MountNodeTCP(Mount* mount) : MountNodeSocket(mount) {}
+
+
+TCPSocketInterface* MountNodeTCP::TCPSocket() {
+  if (mount_->ppapi() == NULL)
+    return NULL;
+
+  return mount_->ppapi()->GetTCPSocketInterface();
+}
+
+Error MountNodeTCP::Init(int flags) {
+  if (TCPSocket() == NULL)
+    return EACCES;
+
+  socket_resource_ = TCPSocket()->Create(mount_->ppapi()->GetInstance());
+  if (0 == socket_resource_)
+    return EACCES;
+
+  return 0;
+}
+
+Error MountNodeTCP::Bind(const struct sockaddr* addr, socklen_t len) {
+  AUTO_LOCK(node_lock_);
+
+  if (0 == socket_resource_)
+    return EBADF;
+
+  /* Only bind once. */
+  if (local_addr_ != 0)
+    return EINVAL;
+
+  /* Lie, we won't known until we connect. */

[binji, 2013/08/09 19:28:06]

s/known/know/

[noelallen1, 2013/08/09 22:53:22]

Done.

+  return 0;
+}
+
+Error MountNodeTCP::Connect(const struct sockaddr* addr, socklen_t len) {
+  AUTO_LOCK(node_lock_);
+
+  if (0 == socket_resource_)
+    return EBADF;
+
+  if (remote_addr_ != 0)
+    return EISCONN;
+
+  remote_addr_ = SockAddrToResource(addr, len);
+  if (0 == remote_addr_)
+    return EINVAL;
+
+  int err = TCPSocket()->Connect(socket_resource_,
+                                 remote_addr_,
+                                 PP_BlockUntilComplete());
+
+  if (err == PP_OK) {
+    local_addr_ = TCPSocket()->GetLocalAddress(socket_resource_);
+    mount_->ppapi()->AddRefResource(local_addr_);

[binji, 2013/08/09 19:28:06]

did you mean to return early here? Otherwise this falls through and clears the
remote_addr_.

I think it would be clearer if you inverted the if (check for error instead of
success).

[noelallen1, 2013/08/09 22:53:22]

Done.

+  }
+
+  mount_->ppapi()->ReleaseResource(remote_addr_);
+  remote_addr_ = 0;
+  return PPErrorToErrno(err);
+}
+
+Error MountNodeTCP::Recv(void* buf, size_t len, int flags, int* out_len) {
+  AUTO_LOCK(node_lock_);
+  if (0 == socket_resource_)
+    return EBADF;
+
+  int err =  TCPSocket()->Read(socket_resource_,

[binji, 2013/08/09 19:28:06]

nit: extra space after =

+                               static_cast<char*>(buf),
+                               len & 0xFFFF,  /* Max 64K at a time. */

[binji, 2013/08/09 19:28:06]

this seems arbitrary, why?

[noelallen1, 2013/08/09 22:53:22]

Max IP "packet" size is 64K.

Until we support streaming, it seemed a reasonable limit size Pepper doesn't
publish it's limit.
It is always okay to return < len when using read/write although people are lazy
about checking on real files.  On sockets, it's expected to return less based on
buffering behavior.

[binji, 2013/08/09 23:08:27]

OK, but you may want to use std::min then, this will behave strangely for len ==
0x10000

+                               PP_BlockUntilComplete());
+  if (err < 0)
+    return PPErrorToErrno(err);
+
+  *out_len = err;
+  return 0;
+}
+
+Error MountNodeTCP::RecvFrom(void* buf,
+                             size_t len,
+                             int flags,
+                             struct sockaddr* src_addr,
+                             socklen_t* addrlen,
+                             int* out_len) {
+  Error err = Recv(buf, len, flags, out_len);
+  if (err == 0)
+    GetPeerName(src_addr, addrlen);
+  return err;
+}
+
+
+Error MountNodeTCP::Send(const void* buf, size_t len, int flags, int* out_len) {
+  AUTO_LOCK(node_lock_);
+
+  if (0 == socket_resource_)
+    return EBADF;
+
+  if (0 == remote_addr_)
+    return ENOTCONN;
+
+  int err = TCPSocket()->Write(socket_resource_,
+                               static_cast<const char*>(buf),
+                               len & 0xFFFF, /* Max 64K at a time. */
+                               PP_BlockUntilComplete());
+  if (err >= 0) {

[binji, 2013/08/09 19:28:06]

Invert this to match similar check in Recv() above?

[noelallen1, 2013/08/09 22:53:22]

Done.

+    *out_len = err;
+    return 0;
+  }
+
+  return PPErrorToErrno(err);
+}
+
+Error MountNodeTCP::SendTo(const void* buf,
+                           size_t len,
+                           int flags,
+                           const struct sockaddr* dest_addr,
+                           socklen_t addrlen,
+                           int* out_len) {
+  return Send(buf, len, flags, out_len);
+}
+
+}  // namespace nacl_io
+
+#endif  // PROVIDES_SOCKET_API