[NaCl SDK] Map active fds to absolute paths.

native_client_sdk/src/libraries/nacl_io/kernel_proxy.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 "nacl_io/kernel_proxy.h"
 
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
@@ skipping 154 matching lines @@
     }
   }
 
   ScopedKernelHandle handle(new KernelHandle(fs, node));
   error = handle->Init(O_RDONLY);
   if (error) {
     errno = error;
     return -1;
   }
 
-  return AllocateFD(handle);
+  int fd = AllocateFD(handle, path);

[binji, 2014/01/07 21:40:29]

return AllocateFD(handle, path);

is fine. Here and below

+  return fd;
 }
 
 int KernelProxy::open(const char* path, int open_flags) {
   ScopedFilesystem fs;
   ScopedNode node;
 
   Error error = AcquireFsAndNode(path, open_flags, &fs, &node);
   if (error) {
     errno = error;
     return -1;
   }
 
   ScopedKernelHandle handle(new KernelHandle(fs, node));
   error = handle->Init(open_flags);
   if (error) {
     errno = error;
     return -1;
   }
 
-  return AllocateFD(handle);
+  int fd = AllocateFD(handle, path);
+  return fd;
 }
 
 int KernelProxy::pipe(int pipefds[2]) {
   PipeNode* pipe = new PipeNode(stream_mount_.get());
   ScopedNode node(pipe);
 
   if (pipe->Init(O_RDWR) == 0) {
     ScopedKernelHandle handle0(new KernelHandle(stream_mount_, node));
     ScopedKernelHandle handle1(new KernelHandle(stream_mount_, node));
 
     // Should never fail, but...
     if (handle0->Init(O_RDONLY) || handle1->Init(O_WRONLY)) {
       errno = EACCES;
       return -1;
     }
 
-    pipefds[0] = AllocateFD(handle0);
-    pipefds[1] = AllocateFD(handle1);
+    pipefds[0] = AllocateFD(handle0, "");

[binji, 2014/01/07 21:40:29]

I think I'd prefer having the second parameter default to std::string(), and
making this just AllocateFD(handle0);

+    pipefds[1] = AllocateFD(handle1, "");
     return 0;
   }
 
   errno = ENOSYS;
   return -1;
 }
 
 int KernelProxy::close(int fd) {
   ScopedKernelHandle handle;
   Error error = AcquireHandle(fd, &handle);
   if (error) {
     errno = error;
     return -1;
   }
 
   // Remove the FD from the process open file descriptor map
   FreeFD(fd);
   return 0;
 }
 
 int KernelProxy::dup(int oldfd) {
   ScopedKernelHandle handle;
   Error error = AcquireHandle(oldfd, &handle);
   if (error) {
     errno = error;
     return -1;
   }
-
-  return AllocateFD(handle);
+  // Return value will be NULL if fd is not a path, which matches with the
+  // appropriate argument to AllocateFD.  Note that this will be a normalized
+  // Path.
+  std::string path = GetFDPath(oldfd);

[binji, 2014/01/07 21:40:29]

hm, I think there's a race here. The oldfd mapping can change between this call
and the handle acquired above from oldfd; this will make the dup'd fd have a
mismatched handle and path.

Here's a thought: add KernelObject::AcquireHandleAndPath that retrieves both in
the same locking of handle_lock_. You can use the same call below in fchdir.

+  int fd = AllocateFD(handle, path);
+  return fd;
 }
 
 int KernelProxy::dup2(int oldfd, int newfd) {
   // If it's the same file handle, just return
   if (oldfd == newfd)
     return newfd;
 
   ScopedKernelHandle old_handle;
   Error error = AcquireHandle(oldfd, &old_handle);
   if (error) {
@@ skipping 254 matching lines @@
 
   int cnt = 0;
   error = handle->GetDents(static_cast<dirent*>(buf), count, &cnt);
   if (error)
     errno = error;
 
   return cnt;
 }
 
 int KernelProxy::fchdir(int fd) {
-  errno = ENOSYS;
-  return -1;
+  ScopedKernelHandle handle;
+  Error error = AcquireHandle(fd, &handle);
+  if (error) {
+    errno = error;
+    return -1;
+  }
+
+  if (!handle->node()->IsaDir()) {
+    errno = ENOTDIR;
+    return -1;
+  }
+
+  std::string path = GetFDPath(fd);
+  if (path.empty()) {
+    errno = EBADF;
+    return -1;
+  }
+
+  error = SetCWD(path);
+  if (error) {
+    // errno is return value from SetCWD
+    errno = error;
+    return -1;
+  }
+  return 0;
 }
 
 int KernelProxy::ftruncate(int fd, off_t length) {
   ScopedKernelHandle handle;
   Error error = AcquireHandle(fd, &handle);
   if (error) {
     errno = error;
     return -1;
   }
 
@@ skipping 666 matching lines @@
   }
 
   ScopedNode node(sock);
   ScopedKernelHandle new_handle(new KernelHandle(stream_mount_, node));
   error = new_handle->Init(O_RDWR);
   if (error != 0) {
     errno = error;
     return -1;
   }
 
-  return AllocateFD(new_handle);
+  return AllocateFD(new_handle, "");
 }
 
 int KernelProxy::bind(int fd, const struct sockaddr* addr, socklen_t len) {
   if (NULL == addr) {
     errno = EFAULT;
     return -1;
   }
 
   ScopedKernelHandle handle;
   if (AcquireSocketHandle(fd, &handle) == -1)
@@ skipping 340 matching lines @@
     return -1;
   }
 
   ScopedKernelHandle handle(new KernelHandle(stream_mount_, node));
   rtn = handle->Init(open_flags);
   if (rtn != 0) {
     errno = rtn;
     return -1;
   }
 
-  return AllocateFD(handle);
+  return AllocateFD(handle, "");
 }
 
 int KernelProxy::socketpair(int domain, int type, int protocol, int* sv) {
   if (NULL == sv) {
     errno = EFAULT;
     return -1;
   }
 
   // Catch-22: We don't support AF_UNIX, but any other AF doesn't support
   // socket pairs. Thus, this function always fails.
@@ skipping 24 matching lines @@
     errno = ENOTSOCK;
     return -1;
   }
 
   return 0;
 }
 
 #endif  // PROVIDES_SOCKET_API
 
 }  // namespace_nacl_io