Timeout of os.system() in d8 was timing out too soon.

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 87 matching lines @@
     }
   }
   return 0;
 }
 
 
 // Suspends the thread until there is data available from the child process.
 // Returns false on timeout, true on data ready.
 static bool WaitOnFD(int fd,
                      int read_timeout,
-                     int* total_timeout,
+                     int total_timeout,
                      struct timeval& start_time) {
   fd_set readfds, writefds, exceptfds;
   struct timeval timeout;
-  if (*total_timeout != -1) {
+  int gone = 0;
+  if (total_timeout != -1) {
     struct timeval time_now;
     gettimeofday(&time_now, NULL);
     int seconds = time_now.tv_sec - start_time.tv_sec;
-    int gone = seconds * 1000 + (time_now.tv_usec - start_time.tv_usec) / 1000;
-    if (gone >= *total_timeout) return false;
-    *total_timeout -= gone;
+    gone = seconds * 1000 + (time_now.tv_usec - start_time.tv_usec) / 1000;
+    if (gone >= total_timeout) return false;
   }
   FD_ZERO(&readfds);
   FD_ZERO(&writefds);
   FD_ZERO(&exceptfds);
   FD_SET(fd, &readfds);
   FD_SET(fd, &exceptfds);
   if (read_timeout == -1 ||
-      (*total_timeout != -1 && *total_timeout < read_timeout)) {
-    read_timeout = *total_timeout;
+      (total_timeout != -1 && total_timeout - gone < read_timeout)) {
+    read_timeout = total_timeout - gone;
   }
   timeout.tv_usec = (read_timeout % 1000) * 1000;
   timeout.tv_sec = read_timeout / 1000;
   int number_of_fds_ready = select(fd + 1,
                                    &readfds,
                                    &writefds,
                                    &exceptfds,
                                    read_timeout != -1 ? &timeout : NULL);
   return number_of_fds_ready == 1;
 }
@@ skipping 161 matching lines @@
   }
   return true;
 }
 
 
 // Accumulates the output from the child in a string handle.  Returns true if it
 // succeeded or false if an exception was thrown.
 static Handle<Value> GetStdout(int child_fd,
                                struct timeval& start_time,
                                int read_timeout,
-                               int* total_timeout) {
+                               int total_timeout) {
   Handle<String> accumulator = String::Empty();
   const char* source = "function(a, b) { return a + b; }";
   Handle<Value> cons_as_obj(Script::Compile(String::New(source))->Run());
   Handle<Function> cons_function(Function::Cast(*cons_as_obj));
   Handle<Value> cons_args[2];
 
   int fullness = 0;
   static const int kStdoutReadBufferSize = 4096;
   char buffer[kStdoutReadBufferSize];
 
   if (fcntl(child_fd, F_SETFL, O_NONBLOCK) != 0) {
     return ThrowException(String::New(strerror(errno)));
   }
 
   int bytes_read;
   do {
     bytes_read = read(child_fd,
                       buffer + fullness,
                       kStdoutReadBufferSize - fullness);
     if (bytes_read == -1) {
       if (errno == EAGAIN) {
         if (!WaitOnFD(child_fd,
                       read_timeout,
                       total_timeout,
                       start_time) ||
-            (TimeIsOut(start_time, *total_timeout))) {
+            (TimeIsOut(start_time, total_timeout))) {
           return ThrowException(String::New("Timed out waiting for output"));
         }
         continue;
       } else if (errno == EINTR) {
         continue;
       } else {
         break;
       }
     }
     if (bytes_read + fullness > 0) {
@@ skipping 149 matching lines @@
   close(exec_error_fds[kWriteFD]);
   close(stdout_fds[kWriteFD]);
   OpenFDCloser error_read_closer(exec_error_fds[kReadFD]);
   OpenFDCloser stdout_read_closer(stdout_fds[kReadFD]);
 
   if (!ChildLaunchedOK(exec_error_fds)) return v8::Undefined();
 
   Handle<Value> accumulator = GetStdout(stdout_fds[kReadFD],
                                         start_time,
                                         read_timeout,
-                                        &total_timeout);
+                                        total_timeout);
   if (accumulator->IsUndefined()) {
     kill(pid, SIGINT);  // On timeout, kill the subprocess.
     return accumulator;
   }
 
   if (!WaitForChild(pid,
                     child_waiter,
                     start_time,
                     read_timeout,
                     total_timeout)) {
@@ skipping 143 matching lines @@
 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