* Add rmdir, mkdir -p and umask to d8 on Unix....

src/d8-posix.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 11 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 #include <stdlib.h>
 #include <errno.h>
 #include <sys/types.h>
+#include <sys/stat.h>
 #include <sys/time.h>
 #include <time.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <sys/wait.h>
 #include <signal.h>
 
 
 #include "d8.h"
 #include "d8-debug.h"
@@ skipping 113 matching lines @@
   return false;
 }
 
 
 // A utility class that does a non-hanging waitpid on the child process if we
 // bail out of the System() function early.  If you don't ever do a waitpid on
 // a subprocess then it turns into one of those annoying 'zombie processes'.
 class ZombieProtector {
  public:
   explicit ZombieProtector(int pid): pid_(pid) { }
-  ~ZombieProtector() { if (pid_ != 0) waitpid(pid_, NULL, WNOHANG); }
+  ~ZombieProtector() { if (pid_ != 0) waitpid(pid_, NULL, 0); }
   void ChildIsDeadNow() { pid_ = 0; }
  private:
   int pid_;
 };
 
 
 // A utility class that closes a file descriptor when it goes out of scope.
 class OpenFDCloser {
  public:
   explicit OpenFDCloser(int fd): fd_(fd) { }
@@ skipping 211 matching lines @@
     waitid(P_PID, pid, &child_info, WEXITED | WNOHANG | WNOWAIT);
     usleep(useconds);
     if (useconds < 1000000) useconds <<= 1;
     if ((read_timeout != -1 && useconds / 1000 > read_timeout) ||
         (TimeIsOut(start_time, total_timeout))) {
       ThrowException(String::New("Timed out waiting for process to terminate"));
       kill(pid, SIGINT);
       return false;
     }
   }
-  child_waiter.ChildIsDeadNow();
   if (child_info.si_code == CLD_KILLED) {
     char message[999];
     snprintf(message,
              sizeof(message),
              "Child killed by signal %d",
              child_info.si_status);
     ThrowException(String::New(message));
     return false;
   }
   if (child_info.si_code == CLD_EXITED && child_info.si_status != 0) {
     char message[999];
     snprintf(message,
              sizeof(message),
              "Child exited with status %d",
              child_info.si_status);
     ThrowException(String::New(message));
     return false;
   }
 
 #else  // No waitid call.
 
   int child_status;
-  printf("waitpid");
   waitpid(pid, &child_status, 0);  // We hang here if the child doesn't exit.
   child_waiter.ChildIsDeadNow();
   if (WIFSIGNALED(child_status)) {
     char message[999];
     snprintf(message,
              sizeof(message),
              "Child killed by signal %d",
              WTERMSIG(child_status));
     ThrowException(String::New(message));
     return false;
@@ skipping 100 matching lines @@
     const char* message = "os.chdir(): String conversion of argument failed.";
     return ThrowException(String::New(message));
   }
   if (chdir(*directory) != 0) {
     return ThrowException(String::New(strerror(errno)));
   }
   return v8::Undefined();
 }
 
 
+Handle<Value> Shell::SetUMask(const Arguments& args) {
+  if (args.Length() != 1) {
+    const char* message = "umask() takes one argument";
+    return ThrowException(String::New(message));
+  }
+  if (args[0]->IsNumber()) {
+    mode_t mask = args[0]->Int32Value();
+    int previous = umask(mask);
+    return Number::New(previous);
+  } else {
+    const char* message = "umask() argument must be numeric";
+    return ThrowException(String::New(message));
+  }
+}
+
+
+static bool CheckItsADirectory(char* directory) {
+  struct stat stat_buf;
+  int stat_result = stat(directory, &stat_buf);
+  if (stat_result != 0) {
+    ThrowException(String::New(strerror(errno)));
+    return false;
+  }
+  if ((stat_buf.st_mode & S_IFDIR) != 0) return true;
+  ThrowException(String::New(strerror(EEXIST)));
+  return false;
+}
+
+
+// Returns true for success.  Creates intermediate directories as needed.  No
+// error if the directory exists already.
+static bool mkdirp(char* directory, mode_t mask) {
+  int result = mkdir(directory, mask);
+  if (result == 0) return true;
+  if (errno == EEXIST) {
+    return CheckItsADirectory(directory);
+  } else if (errno == ENOENT) {  // Intermediate path element is missing.
+    char* last_slash = strrchr(directory, '/');
+    if (last_slash == NULL) {
+      ThrowException(String::New(strerror(errno)));
+      return false;
+    }
+    *last_slash = 0;
+    if (!mkdirp(directory, mask)) return false;
+    *last_slash = '/';
+    result = mkdir(directory, mask);
+    if (result == 0) return true;
+    if (errno == EEXIST) {

[Søren Thygesen Gjesse, 2009/03/31 12:28:02]

Is this is to handle from paths with '..' e.g. xxx/yyy/../yyy, or is it not
supposed to happen?

[Erik Corry, 2009/03/31 12:36:31]

Can I just pretend that's what I was thinking about all along?

Test added to ensure that it actually works this way.

+      return CheckItsADirectory(directory);
+    }
+    ThrowException(String::New(strerror(errno)));
+    return false;
+  } else {
+    ThrowException(String::New(strerror(errno)));
+    return false;
+  }
+}
+
+
+Handle<Value> Shell::MakeDirectory(const Arguments& args) {
+  mode_t mask = 0777;
+  if (args.Length() == 2) {
+    if (args[1]->IsNumber()) {
+      mask = args[1]->Int32Value();
+    } else {
+      const char* message = "mkdirp() second argument must be numeric";
+      return ThrowException(String::New(message));
+    }
+  } else if (args.Length() != 1) {
+    const char* message = "mkdirp() takes one or two arguments";
+    return ThrowException(String::New(message));
+  }
+  String::Utf8Value directory(args[0]);
+  if (*directory == NULL) {
+    const char* message = "os.mkdirp(): String conversion of argument failed.";
+    return ThrowException(String::New(message));
+  }
+  mkdirp(*directory, mask);
+  return v8::Undefined();
+}
+
+
+Handle<Value> Shell::RemoveDirectory(const Arguments& args) {
+  if (args.Length() != 1) {
+    const char* message = "rmdir() takes one or two arguments";
+    return ThrowException(String::New(message));
+  }
+  String::Utf8Value directory(args[0]);
+  if (*directory == NULL) {
+    const char* message = "os.rmdir(): String conversion of argument failed.";
+    return ThrowException(String::New(message));
+  }
+  rmdir(*directory);
+  return v8::Undefined();
+}
+
+
 Handle<Value> Shell::SetEnvironment(const Arguments& args) {
   if (args.Length() != 2) {
     const char* message = "setenv() takes two arguments";
     return ThrowException(String::New(message));
   }
   String::Utf8Value var(args[0]);
   String::Utf8Value value(args[1]);
   if (*var == NULL) {
     const char* message =
         "os.setenv(): String conversion of variable name failed.";
     return ThrowException(String::New(message));
   }
   if (*value == NULL) {
     const char* message =
         "os.setenv(): String conversion of variable contents failed.";
     return ThrowException(String::New(message));
   }
   setenv(*var, *value, 1);
   return v8::Undefined();
 }
 
 
+void Shell::AddOSMethods(Handle<ObjectTemplate> os_templ) {
+  os_templ->Set(String::New("system"), FunctionTemplate::New(System));
+  os_templ->Set(String::New("chdir"), FunctionTemplate::New(ChangeDirectory));
+  os_templ->Set(String::New("setenv"), FunctionTemplate::New(SetEnvironment));
+  os_templ->Set(String::New("umask"), FunctionTemplate::New(SetUMask));
+  os_templ->Set(String::New("mkdirp"), FunctionTemplate::New(MakeDirectory));
+  os_templ->Set(String::New("rmdir"), FunctionTemplate::New(RemoveDirectory));
+}
+
 }  // namespace v8