Socket subsystem implementation

libraries/nacl-mounts/net/SocketSubSystem.cc

+// Copyright (c) 2012 The Chromium OS 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 <arpa/inet.h>
+#include <irt.h>
+#include <netinet/in.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/socket.h>
+
+#include "net/SocketSubSystem.h"
+#include "net/TcpServerSocket.h"
+#include "net/TcpSocket.h"
+#include "ppapi/cpp/file_ref.h"
+#include "util/DebugPrint.h"
+
+
+SocketSubSystem::SocketSubSystem(pp::Instance* instance)
+    : pp_instance_(instance)
+    , first_unused_addr_(kFirstAddr) {
+  AddHostAddress("localhost", 0x7F000001);
+}
+
+void SocketSubSystem::AddHostAddress(const char* name, unsigned long addr) {
+  addr = htonl(addr);
+  hosts_[name] = addr;
+  addrs_[addr] = name;
+}
+
+unsigned long SocketSubSystem::gethostbyname(const char* name) {
+  Mutex::Lock lock(mutex_);
+  HostMap::iterator it = hosts_.find(name);
+  if (it != hosts_.end())
+    return it->second;
+
+  int addr = htonl(first_unused_addr_++);
+  hosts_[name] = addr;
+  addrs_[addr] = name;
+  return addr;
+}
+
+std::string SocketSubSystem::GetHostByAddr(unsigned long addr) {
+  std::string host;
+  AddressMap::iterator it = addrs_.find(addr);
+  if (it != addrs_.end()) {
+    host = it->second;
+  } else {
+    in_addr iaddr;
+    iaddr.s_addr = addr;
+    host = inet_ntoa(iaddr);
+  }
+  return host;
+}
+
+int SocketSubSystem::bind(FileStream** stream, unsigned long addr,
+    unsigned short port) {
+  Mutex::Lock lock(mutex_);
+
+  *stream = new TCPServerSocket(this, 0, GetHostByAddr(addr).c_str(), port);
+  return 0;
+}
+
+int SocketSubSystem::connect(FileStream** stream, unsigned long addr,
+    unsigned short port) {
+  Mutex::Lock lock(mutex_);
+
+  FileStream* new_stream = NULL;
+  TCPSocket* socket = new TCPSocket(this, O_RDWR);
+  if (!socket->connect(GetHostByAddr(addr).c_str(), port)) {
+    errno = ECONNREFUSED;
+    socket->release();
+    return -1;
+  }
+  new_stream = socket;
+
+  *stream = new_stream;
+  return 0;
+}
+
+SocketSubSystem::~SocketSubSystem() {
+}
+
+int SocketSubSystem::shutdown(FileStream* stream, int how) {
+  Mutex::Lock lock(mutex_);
+  if (stream) {
+    // Actually shutdown should be something more complicated by for now
+    // it works. Method close can be called multiple time.
+    stream->close();
+    return 0;
+  } else {
+    errno = EBADF;
+    return -1;
+  }
+}
+
+int SocketSubSystem::close(FileStream* stream) {
+  Mutex::Lock lock(mutex_);
+
+  if (stream) {
+    stream->close();
+    stream->release();
+  }
+  return 0;
+}
+
+int SocketSubSystem::read(FileStream* stream, char* buf, size_t count,
+    size_t* nread) {
+  Mutex::Lock lock(mutex_);
+  if (stream)
+    return stream->read(buf, count, nread);
+  else
+    return EBADF;
+}
+
+int SocketSubSystem::write(FileStream* stream, const char* buf, size_t count,
+    size_t* nwrote) {
+  Mutex::Lock lock(mutex_);
+  if (stream)
+    return stream->write(buf, count, nwrote);
+  else
+    return EBADF;
+}
+
+int SocketSubSystem::seek(FileStream* stream, nacl_abi_off_t offset, int whence,
+                     nacl_abi_off_t* new_offset) {
+  Mutex::Lock lock(mutex_);
+  if (stream)
+    return stream->seek(offset, whence, new_offset);
+  else
+    return EBADF;
+}
+
+int SocketSubSystem::fstat(FileStream* stream, nacl_abi_stat* out) {
+  Mutex::Lock lock(mutex_);
+  if (stream)
+    return stream->fstat(out);
+  else
+    return EBADF;
+}
+
+int SocketSubSystem::fcntl(FileStream* stream, int cmd, va_list ap) {
+  Mutex::Lock lock(mutex_);
+  if (stream) {
+    return stream->fcntl(cmd, ap);
+  } else {
+    errno = EBADF;
+    return -1;
+  }
+}
+
+int SocketSubSystem::ioctl(FileStream* stream, int request, va_list ap) {
+  Mutex::Lock lock(mutex_);
+  if (stream) {
+    return stream->ioctl(request, ap);
+  } else {
+    errno = EBADF;
+    return -1;
+  }
+}
+
+int SocketSubSystem::listen(FileStream* stream, int backlog) {
+  Mutex::Lock lock(mutex_);
+  if (stream) {
+    if (static_cast<TCPServerSocket*>(stream)->listen(backlog)) {
+      return 0;
+    } else {
+      errno = EACCES;
+      return -1;
+    }
+  } else {
+    errno = EBADF;
+    return -1;
+  }
+}
+
+FileStream* SocketSubSystem::accept(FileStream* stream, struct sockaddr *addr,
+    socklen_t* addrlen) {
+  Mutex::Lock lock(mutex_);
+  if (stream) {
+    PP_Resource resource = static_cast<TCPServerSocket*>(stream)->accept();
+    if (resource) {
+      TCPSocket* socket = new TCPSocket(this, O_RDWR);
+      if (socket->acceptFrom(resource)) {
+        return socket;
+      } else {
+        socket->release();
+      }
+    }
+    errno = EINVAL;
+    return 0;
+  } else {
+    errno = EBADF;
+    return 0;
+  }
+}
+