[dart:io] Namespaces for file IO

runtime/bin/process_android.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/globals.h"
 #if defined(HOST_OS_ANDROID)
 
 #include "bin/process.h"
 
 #include <errno.h>     // NOLINT
 #include <fcntl.h>     // NOLINT
 #include <poll.h>      // NOLINT
 #include <stdio.h>     // NOLINT
 #include <stdlib.h>    // NOLINT
 #include <string.h>    // NOLINT
 #include <sys/wait.h>  // NOLINT
 #include <unistd.h>    // NOLINT
 
 #include "bin/dartutils.h"
+#include "bin/directory.h"
 #include "bin/fdutils.h"
 #include "bin/file.h"
 #include "bin/lockers.h"
 #include "bin/log.h"
+#include "bin/namespace.h"
 #include "bin/reference_counting.h"
 #include "bin/thread.h"
 
 #include "platform/signal_blocker.h"
 #include "platform/utils.h"
 
 extern char** environ;
 
 namespace dart {
 namespace bin {
@@ skipping 201 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExitCodeHandler);
 };
 
 bool ExitCodeHandler::running_ = false;
 int ExitCodeHandler::process_count_ = 0;
 bool ExitCodeHandler::terminate_done_ = false;
 Monitor* ExitCodeHandler::monitor_ = new Monitor();
 
 class ProcessStarter {
  public:
-  ProcessStarter(const char* path,
+  ProcessStarter(Namespace* namespc,
+                 const char* path,
                  char* arguments[],
                  intptr_t arguments_length,
                  const char* working_directory,
                  char* environment[],
                  intptr_t environment_length,
                  ProcessStartMode mode,
                  intptr_t* in,
                  intptr_t* out,
                  intptr_t* err,
                  intptr_t* id,
                  intptr_t* exit_event,
                  char** os_error_message)
-      : path_(path),
+      : namespc_(namespc),
+        path_(path),
         working_directory_(working_directory),
         mode_(mode),
         in_(in),
         out_(out),
         err_(err),
         id_(id),
         exit_event_(exit_event),
         os_error_message_(os_error_message) {
     read_in_[0] = -1;
     read_in_[1] = -1;
@@ skipping 155 matching lines @@
       perror("Failed receiving notification message");
       exit(1);
     }
     if (mode_ == kNormal) {
       ExecProcess();
     } else {
       ExecDetachedProcess();
     }
   }
 
+  const char* ResolvePath() {
+    const char* resolved_path = File::GetCanonicalPath(namespc_, path_);
+    return resolved_path == NULL ? path_ : resolved_path;
+  }
+
   void ExecProcess() {
     if (TEMP_FAILURE_RETRY(dup2(write_out_[0], STDIN_FILENO)) == -1) {
       ReportChildError();
     }
 
     if (TEMP_FAILURE_RETRY(dup2(read_in_[1], STDOUT_FILENO)) == -1) {
       ReportChildError();
     }
 
     if (TEMP_FAILURE_RETRY(dup2(read_err_[1], STDERR_FILENO)) == -1) {
       ReportChildError();
     }
 
     if (working_directory_ != NULL &&
-        TEMP_FAILURE_RETRY(chdir(working_directory_)) == -1) {
+        !Directory::SetCurrent(namespc_, working_directory_)) {
       ReportChildError();
     }
 
     if (program_environment_ != NULL) {
       environ = program_environment_;
     }
 
+    const char* resolved_path = ResolvePath();
     VOID_TEMP_FAILURE_RETRY(
-        execvp(path_, const_cast<char* const*>(program_arguments_)));
+        execvp(resolved_path, const_cast<char* const*>(program_arguments_)));
 
     ReportChildError();
   }
 
   void ExecDetachedProcess() {
     if (mode_ == kDetached) {
       ASSERT(write_out_[0] == -1);
       ASSERT(write_out_[1] == -1);
       ASSERT(read_err_[0] == -1);
       ASSERT(read_err_[1] == -1);
@@ skipping 21 matching lines @@
         if (pid < 0) {
           ReportChildError();
         } else if (pid == 0) {
           if (mode_ == kDetached) {
             SetupDetached();
           } else {
             SetupDetachedWithStdio();
           }
 
           if ((working_directory_ != NULL) &&
-              (TEMP_FAILURE_RETRY(chdir(working_directory_)) == -1)) {
+              !Directory::SetCurrent(namespc_, working_directory_)) {
             ReportChildError();
           }
 
           // Report the final PID and do the exec.
           ReportPid(getpid());  // getpid cannot fail.
-          VOID_TEMP_FAILURE_RETRY(
-              execvp(path_, const_cast<char* const*>(program_arguments_)));
+          const char* resolved_path = ResolvePath();
+          VOID_TEMP_FAILURE_RETRY(execvp(
+              resolved_path, const_cast<char* const*>(program_arguments_)));
           ReportChildError();
         } else {
           // Exit the intermediate process.
           exit(0);
         }
       }
     } else {
       // Exit the intermediate process.
       exit(0);
     }
@@ skipping 131 matching lines @@
     char* error_message = DartUtils::ScopedCString(kBufferSize);
     Utils::StrError(errno, error_message, kBufferSize);
     *os_error_message_ = error_message;
   }
 
   void ReportChildError() {
     // In the case of failure in the child process write the errno and
     // the OS error message to the exec control pipe and exit.
     int child_errno = errno;
     const int kBufferSize = 1024;
-    char os_error_message[kBufferSize];
-    Utils::StrError(errno, os_error_message, kBufferSize);
+    char error_buf[kBufferSize];
+    char* os_error_message = Utils::StrError(errno, error_buf, kBufferSize);
     int bytes_written = FDUtils::WriteToBlocking(exec_control_[1], &child_errno,
                                                  sizeof(child_errno));
     if (bytes_written == sizeof(child_errno)) {
       FDUtils::WriteToBlocking(exec_control_[1], os_error_message,
                                strlen(os_error_message) + 1);
     }
     VOID_TEMP_FAILURE_RETRY(close(exec_control_[1]));
 
     // We avoid running through registered atexit() handlers because that is
     // unnecessary work.
@@ skipping 39 matching lines @@
   }
 
   int read_in_[2];       // Pipe for stdout to child process.
   int read_err_[2];      // Pipe for stderr to child process.
   int write_out_[2];     // Pipe for stdin to child process.
   int exec_control_[2];  // Pipe to get the result from exec.
 
   char** program_arguments_;
   char** program_environment_;
 
+  Namespace* namespc_;
   const char* path_;
   const char* working_directory_;
   ProcessStartMode mode_;
   intptr_t* in_;
   intptr_t* out_;
   intptr_t* err_;
   intptr_t* id_;
   intptr_t* exit_event_;
   char** os_error_message_;
 
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(ProcessStarter);
 };
 
-int Process::Start(const char* path,
+int Process::Start(Namespace* namespc,
+                   const char* path,
                    char* arguments[],
                    intptr_t arguments_length,
                    const char* working_directory,
                    char* environment[],
                    intptr_t environment_length,
                    ProcessStartMode mode,
                    intptr_t* in,
                    intptr_t* out,
                    intptr_t* err,
                    intptr_t* id,
                    intptr_t* exit_event,
                    char** os_error_message) {
-  ProcessStarter starter(path, arguments, arguments_length, working_directory,
-                         environment, environment_length, mode, in, out, err,
-                         id, exit_event, os_error_message);
+  ProcessStarter starter(namespc, path, arguments, arguments_length,
+                         working_directory, environment, environment_length,
+                         mode, in, out, err, id, exit_event, os_error_message);
   return starter.Start();
 }
 
 static bool CloseProcessBuffers(struct pollfd fds[3]) {
   int e = errno;
   VOID_TEMP_FAILURE_RETRY(close(fds[0].fd));
   VOID_TEMP_FAILURE_RETRY(close(fds[1].fd));
   VOID_TEMP_FAILURE_RETRY(close(fds[2].fd));
   errno = e;
   return false;
@@ skipping 238 matching lines @@
     bzero(&act, sizeof(act));
     act.sa_handler = SIG_DFL;
     VOID_NO_RETRY_EXPECTED(sigaction(signal, &act, NULL));
   }
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(HOST_OS_ANDROID)