Use FormatMessageW for Windows error messages to handle internationalized messages correctly.

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 241 matching lines @@
 };
 
 
 dart::Mutex ExitCodeHandler::mutex_;
 bool ExitCodeHandler::initialized_ = false;
 int ExitCodeHandler::sig_chld_fds_[2] = { 0, 0 };
 bool ExitCodeHandler::thread_terminated_ = false;
 dart::Monitor ExitCodeHandler::thread_terminate_monitor_;
 
 
-static char* SafeStrNCpy(char* dest, const char* src, size_t n) {
-  strncpy(dest, src, n);
-  dest[n - 1] = '\0';
-  return dest;
+static void SetChildOsErrorMessage(char** os_error_message) {
+  *os_error_message = strdup(strerror(errno));
 }
 
 
-static void SetChildOsErrorMessage(char* os_error_message,
-                                   int os_error_message_len) {
-  SafeStrNCpy(os_error_message, strerror(errno), os_error_message_len);
-}
-
-
 static void SigChldHandler(int process_signal, siginfo_t* siginfo, void* tmp) {
   // Save errno so it can be restored at the end.
   int entry_errno = errno;
   // Signal the exit code handler where the actual processing takes
   // place.
   ssize_t result =
       TEMP_FAILURE_RETRY(write(ExitCodeHandler::WakeUpFd(), "", 1));
   if (result < 1) {
     perror("Failed to write to wake-up fd in SIGCHLD handler");
   }
@@ skipping 24 matching lines @@
                    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) {
+                   char** os_error_message) {
   pid_t pid;
   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.
   int result;
 
   bool initialized = ExitCodeHandler::EnsureInitialized();
   if (!initialized) {
-    SetChildOsErrorMessage(os_error_message, os_error_message_len);
+    SetChildOsErrorMessage(os_error_message);
     Log::PrintErr(
             "Error initializing exit code handler: %s\n",
-            os_error_message);
+            *os_error_message);
     return errno;
   }
 
   result = TEMP_FAILURE_RETRY(pipe(read_in));
   if (result < 0) {
-    SetChildOsErrorMessage(os_error_message, os_error_message_len);
-    Log::PrintErr("Error pipe creation failed: %s\n", os_error_message);
+    SetChildOsErrorMessage(os_error_message);
+    Log::PrintErr("Error pipe creation failed: %s\n", *os_error_message);
     return errno;
   }
 
   result = TEMP_FAILURE_RETRY(pipe(read_err));
   if (result < 0) {
-    SetChildOsErrorMessage(os_error_message, os_error_message_len);
+    SetChildOsErrorMessage(os_error_message);
     TEMP_FAILURE_RETRY(close(read_in[0]));
     TEMP_FAILURE_RETRY(close(read_in[1]));
-    Log::PrintErr("Error pipe creation failed: %s\n", os_error_message);
+    Log::PrintErr("Error pipe creation failed: %s\n", *os_error_message);
     return errno;
   }
 
   result = TEMP_FAILURE_RETRY(pipe(write_out));
   if (result < 0) {
-    SetChildOsErrorMessage(os_error_message, os_error_message_len);
+    SetChildOsErrorMessage(os_error_message);
     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]));
-    Log::PrintErr("Error pipe creation failed: %s\n", os_error_message);
+    Log::PrintErr("Error pipe creation failed: %s\n", *os_error_message);
     return errno;
   }
 
   result = TEMP_FAILURE_RETRY(pipe(exec_control));
   if (result < 0) {
-    SetChildOsErrorMessage(os_error_message, os_error_message_len);
+    SetChildOsErrorMessage(os_error_message);
     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]));
     TEMP_FAILURE_RETRY(close(write_out[1]));
-    Log::PrintErr("Error pipe creation failed: %s\n", os_error_message);
+    Log::PrintErr("Error pipe creation failed: %s\n", *os_error_message);
     return errno;
   }
 
   // Set close on exec on the write file descriptor of the exec control pipe.
   result = TEMP_FAILURE_RETRY(
       fcntl(exec_control[1],
             F_SETFD,
             TEMP_FAILURE_RETRY(fcntl(exec_control[1], F_GETFD)) | FD_CLOEXEC));
   if (result < 0) {
-    SetChildOsErrorMessage(os_error_message, os_error_message_len);
+    SetChildOsErrorMessage(os_error_message);
     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]));
     TEMP_FAILURE_RETRY(close(write_out[1]));
     TEMP_FAILURE_RETRY(close(exec_control[0]));
     TEMP_FAILURE_RETRY(close(exec_control[1]));
-    Log::PrintErr("fcntl failed: %s\n", os_error_message);
+    Log::PrintErr("fcntl failed: %s\n", *os_error_message);
     return errno;
   }
 
   char** program_arguments = new char*[arguments_length + 2];
   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);
+    SetChildOsErrorMessage(os_error_message);
     delete[] program_arguments;
     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]));
     TEMP_FAILURE_RETRY(close(write_out[1]));
     TEMP_FAILURE_RETRY(close(exec_control[0]));
     TEMP_FAILURE_RETRY(close(exec_control[1]));
     return errno;
@@ skipping 42 matching lines @@
   }
 
   // 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);
+    SetChildOsErrorMessage(os_error_message);
     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]));
     TEMP_FAILURE_RETRY(close(write_out[1]));
-    Log::PrintErr("Error pipe creation failed: %s\n", os_error_message);
+    Log::PrintErr("Error pipe creation failed: %s\n", *os_error_message);
     return errno;
   }
 
   ProcessInfoList::AddProcess(pid, event_fds[1]);
   *exit_event = event_fds[0];
   FDUtils::SetNonBlocking(event_fds[0]);
 
   // Notify child process to start.
   char msg = '1';
   result = FDUtils::WriteToBlocking(read_in[1], &msg, sizeof(msg));
   if (result != sizeof(msg)) {
     perror("Failed sending notification message");
   }
 
   // Read exec result from child. If no data is returned the exec was
   // successful and the exec call closed the pipe. Otherwise the errno
   // is written to the pipe.
   TEMP_FAILURE_RETRY(close(exec_control[1]));
   int child_errno;
   int bytes_read = -1;
   ASSERT(sizeof(child_errno) == sizeof(errno));
   bytes_read =
       FDUtils::ReadFromBlocking(
           exec_control[0], &child_errno, sizeof(child_errno));
   if (bytes_read == sizeof(child_errno)) {
-      bytes_read = FDUtils::ReadFromBlocking(exec_control[0],
-                                             os_error_message,
-                                             os_error_message_len);
-      os_error_message[os_error_message_len - 1] = '\0';
+    static const int kMaxMessageSize = 256;
+    char* message = static_cast<char*>(malloc(kMaxMessageSize));
+    bytes_read = FDUtils::ReadFromBlocking(exec_control[0],
+                                           message,
+                                           kMaxMessageSize);
+    message[kMaxMessageSize - 1] = '\0';
+    *os_error_message = message;
   }
   TEMP_FAILURE_RETRY(close(exec_control[0]));
 
   // Return error code if any failures.
   if (bytes_read != 0) {
     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 26 matching lines @@
 
 
 void Process::TerminateExitCodeHandler() {
   ExitCodeHandler::TerminateExitCodeThread();
 }
 
 
 intptr_t Process::CurrentProcessId() {
   return static_cast<intptr_t>(getpid());
 }