Support passing an environment variable map to child processes.

runtime/bin/process_linux.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 "bin/process.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <poll.h>
 #include <signal.h>
@@ skipping 289 matching lines @@
   }
   TEMP_FAILURE_RETRY(close(exec_control_fd));
   exit(1);
 }
 
 
 int Process::Start(const char* path,
                    char* arguments[],
                    intptr_t arguments_length,
                    const char* working_directory,
+                   char* environment[],
+                   intptr_t environment_length,
                    intptr_t* in,
                    intptr_t* out,
                    intptr_t* err,
                    intptr_t* id,
                    intptr_t* exit_event,
                    char* os_error_message,
                    int os_error_message_len) {
   pid_t pid;
   int read_in[2];  // Pipe for stdout to child process.
   int read_err[2];  // Pipe for stderr to child process.
@@ skipping 63 matching lines @@
     TEMP_FAILURE_RETRY(close(read_err[1]));
     TEMP_FAILURE_RETRY(close(write_out[0]));
     TEMP_FAILURE_RETRY(close(write_out[1]));
     TEMP_FAILURE_RETRY(close(exec_control[0]));
     TEMP_FAILURE_RETRY(close(exec_control[1]));
     fprintf(stderr, "fcntl failed: %s\n", os_error_message);
     return errno;
   }
 
   char** program_arguments = new char*[arguments_length + 2];
-  program_arguments[0] = const_cast<char *>(path);
+  program_arguments[0] = const_cast<char*>(path);
   for (int i = 0; i < arguments_length; i++) {
     program_arguments[i + 1] = arguments[i];
   }
   program_arguments[arguments_length + 1] = NULL;
 
+  char** program_environment = NULL;
+  if (environment != NULL) {
+    program_environment = new char*[environment_length + 1];
+    for (int i = 0; i < environment_length; i++) {
+      program_environment[i] = environment[i];
+    }
+    program_environment[environment_length] = NULL;
+  }
+
   struct sigaction act;
   bzero(&act, sizeof(act));
   act.sa_sigaction = SigChldHandler;
   act.sa_flags = SA_NOCLDSTOP | SA_SIGINFO;
   if (sigaction(SIGCHLD, &act, 0) != 0) {
     perror("Process start: setting signal handler failed");
   }
   pid = TEMP_FAILURE_RETRY(fork());
   if (pid < 0) {
     SetChildOsErrorMessage(os_error_message, os_error_message_len);
@@ skipping 34 matching lines @@
     if (TEMP_FAILURE_RETRY(dup2(read_err[1], STDERR_FILENO)) == -1) {
       ReportChildError(exec_control[1]);
     }
     TEMP_FAILURE_RETRY(close(read_err[1]));
 
     if (working_directory != NULL &&
         TEMP_FAILURE_RETRY(chdir(working_directory)) == -1) {
       ReportChildError(exec_control[1]);
     }
 
-    TEMP_FAILURE_RETRY(
-        execvp(path, const_cast<char* const*>(program_arguments)));
+    if (environment != NULL) {
+      TEMP_FAILURE_RETRY(
+          execve(path,
+                 const_cast<char* const*>(program_arguments),
+                 program_environment));
+    } else {
+      TEMP_FAILURE_RETRY(
+          execvp(path, const_cast<char* const*>(program_arguments)));
+    }
     ReportChildError(exec_control[1]);
   }
 
-  // The arguments for the spawned process are not needed any longer.
+  // The arguments and environment for the spawned process are not needed
+  // any longer.
   delete[] program_arguments;
+  delete[] program_environment;
 
   int event_fds[2];
   result = TEMP_FAILURE_RETRY(pipe(event_fds));
   if (result < 0) {
     SetChildOsErrorMessage(os_error_message, os_error_message_len);
     TEMP_FAILURE_RETRY(close(read_in[0]));
     TEMP_FAILURE_RETRY(close(read_in[1]));
     TEMP_FAILURE_RETRY(close(read_err[0]));
     TEMP_FAILURE_RETRY(close(read_err[1]));
     TEMP_FAILURE_RETRY(close(write_out[0]));
@@ skipping 66 matching lines @@
   if (result == -1) {
     return false;
   }
   return true;
 }
 
 
 void Process::TerminateExitCodeHandler() {
   ExitCodeHandler::TerminateExitCodeThread();
 }