Fix dup and dup2 in nacl-mounts

libraries/nacl-mounts/base/KernelProxy.cc

 /*
  * Copyright (c) 2012 The Native Client 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 "base/KernelProxy.h"
 #include <assert.h>
 #ifndef __GLIBC__
 #include <nacl-mounts/net/newlib_compat.h>
 #else
@@ skipping 287 matching lines @@
   if (!(m_and_p.first)) {
     errno = ENOENT;
     return -1;
   }
 
   return OpenHandle(m_and_p.first, m_and_p.second, flags, mode);
 }
 
 int KernelProxy::close(int fd) {
   SimpleAutoLock lock(&kp_lock_);
+  return Close(fd);
+}
 
+int KernelProxy::Close(int fd) {
   FileDescriptor* file = fds_.At(fd);
   if (file == NULL) {
     errno = EBADF;
     return -1;
   }
   int h = file->handle;
   fds_.Free(fd);
   FileHandle* handle = open_files_.At(h);
   if (handle == NULL) {
     errno = EBADF;
     return -1;
   }
-  handle->use_count--;
-  ino_t node = handle->node;
-  if (handle->mount) {
-    Mount* mount = handle->mount;
-    if (handle->use_count <= 0) {
-      open_files_.Free(h);
-      mount->Unref(node);
+  if (--handle->use_count <= 0) {
+    if (handle->mount) {
+      Mount* mount = handle->mount;
+      mount->Unref(handle->node);
+      mount->Unref();
+    } else {
+      Socket* stream = handle->stream;
+      socket_subsystem_->close(stream);
     }
-    mount->Unref();
-  } else {
-    Socket* stream = handle->stream;
-    socket_subsystem_->close(stream);
-    if (handle->use_count <= 0) {
-      open_files_.Free(h);
-    }
-    return 0;
+    open_files_.Free(h);
   }
   return 0;
 }
 
 ssize_t KernelProxy::read(int fd, void *buf, size_t count) {
   FileHandle* handle;
   // check if fd is valid and handle exists
   if (!(handle = GetFileHandle(fd))) {
     errno = EBADF;
     return -1;
@@ skipping 114 matching lines @@
 int KernelProxy::isatty(int fd) {
   FileHandle* handle;
 
   if (!(handle = GetFileHandle(fd))) {
     errno = EBADF;
     return 0;
   }
   return handle->mount->Isatty(handle->node);
 }
 
-int KernelProxy::dup2(int fd, int newfd) {
+int KernelProxy::dup2(int oldfd, int newfd) {
   SimpleAutoLock lock(&kp_lock_);
-  int handle_slot = fds_.At(fd)->handle;
-  if (fds_.AllocAt(fd) != fd) return -1;
-  FileDescriptor* file = fds_.At(newfd);
-  file->handle = handle_slot;
-  return 0;
+
+  FileDescriptor* oldfile = fds_.At(oldfd);
+  if (!oldfile) {
+    errno = EBADF;
+    return -1;
+  }
+
+  // Do nothing if the file descriptors match.
+  if (newfd == oldfd)
+    return newfd;
+
+  // close newfd if it exists.
+  if (fds_.At(newfd))
+    Close(newfd);
+  if (fds_.AllocAt(newfd) != newfd) assert(0);
+  fds_.At(newfd)->handle = oldfile->handle;
+  open_files_.At(oldfile->handle)->use_count++;
+  return newfd;
 }
 
 int KernelProxy::IsReady(int nfds, fd_set* fds,
     bool (Socket::*is_ready)(), bool apply) {
   if (!fds)
     return 0;
 
   int nset = 0;
   for (int i = 0; i < nfds; i++) {
     if (FD_ISSET(i, fds)) {
@@ skipping 12 matching lines @@
           FD_CLR(i, fds);
       }
     }
   }
   return nset;
 }
 
 int KernelProxy::dup(int oldfd) {
   SimpleAutoLock lock(&kp_lock_);
 
-  FileHandle* fh = GetFileHandle(oldfd);
-  if (!fh) {
+  FileDescriptor* oldfile = fds_.At(oldfd);
+  if (!oldfile) {
     errno = EBADF;
     return -1;
   }
-  if (fh->mount == NULL) {
-    Socket* stream = GetFileHandle(oldfd) > 0
-      ? GetFileHandle(oldfd)->stream : NULL;
-    if (!stream)
-      return EBADF;
-    SimpleAutoLock lock(&kp_lock_);
-    int handle_slot = fds_.At(oldfd)->handle;
-    int newfd = fds_.Alloc();
-    FileDescriptor* file = fds_.At(newfd);
-    file->handle = handle_slot;
-    return newfd;
-  }
-  FileDescriptor* oldfile = fds_.At(oldfd);
-  if (oldfile == NULL) {
-    errno = EBADF;
-    return -1;
-  }
+
   int newfd = fds_.Alloc();
-  FileDescriptor *newfile = fds_.At(newfd);
-  int h = oldfile->handle;
-  newfile->handle = h;
-  FileHandle* handle = open_files_.At(h);
-  // init should be safe because we have the kernel proxy lock
-  if (pthread_mutex_init(&handle->lock, NULL)) assert(0);
-
-  if (handle == NULL) {
-    errno = EBADF;
-    return -1;
-  }
-  ++handle->use_count;
-  handle->mount->Ref(handle->node);
-  handle->mount->Ref();
+  fds_.At(newfd)->handle = oldfile->handle;
+  open_files_.At(oldfile->handle)->use_count++;
   return newfd;
 }
 
 off_t KernelProxy::lseek(int fd, off_t offset, int whence) {
   FileHandle* handle;
   // check if fd is valid and handle exists
   if (!(handle = GetFileHandle(fd))) {
     errno = EBADF;
     return -1;
   }
@@ skipping 475 matching lines @@
     return EBADF;
   return socket_subsystem_->shutdown(fh->stream, how);
 }
 
 int KernelProxy::socketpair(int domain, int type, int protocol, int sv[2]) {
   errno = ENOSYS;
   fprintf(stderr, "socketpair has not been implemented!\n");
   return -1;
 }