Signal handling.

runtime/bin/process_win.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(TARGET_OS_WINDOWS)
 
 #include <process.h>  // NOLINT
 
 #include "bin/builtin.h"
 #include "bin/process.h"
 #include "bin/eventhandler.h"
 #include "bin/log.h"
+#include "bin/socket.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 #include "bin/utils_win.h"
 
 
 namespace dart {
 namespace bin {
 
 static const int kReadHandle = 0;
 static const int kWriteHandle = 1;
@@ skipping 318 matching lines @@
             GetProcAddress(kernel32_module, "UpdateProcThreadAttribute"));
     delete_proc_thread_attr_list = reinterpret_cast<DeleteProcThreadAttrListFn>(
         reinterpret_cast<DeleteProcThreadAttrListFn>(
             GetProcAddress(kernel32_module, "DeleteProcThreadAttributeList")));
     load_attempted = true;
     return delete_proc_thread_attr_list != NULL;
   }
   return delete_proc_thread_attr_list != NULL;
 }
 
-
-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_handler,
-                   char** os_error_message) {
-  HANDLE stdin_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
-  HANDLE stdout_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
-  HANDLE stderr_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
-  HANDLE exit_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
-
-  // Generate unique pipe names for the four named pipes needed.
-  static const int kMaxPipeNameSize = 80;
-  wchar_t pipe_names[4][kMaxPipeNameSize];
+int GenerateNames(int count, wchar_t* pipe_names[], int max_length) {
   UUID uuid;
   RPC_STATUS status = UuidCreateSequential(&uuid);
   if (status != RPC_S_OK && status != RPC_S_UUID_LOCAL_ONLY) {
     SetOsErrorMessage(os_error_message);
     Log::PrintErr("UuidCreateSequential failed %d\n", status);
     return status;
   }
   RPC_WSTR uuid_string;
   status = UuidToStringW(&uuid, &uuid_string);
   if (status != RPC_S_OK) {
     SetOsErrorMessage(os_error_message);
     Log::PrintErr("UuidToString failed %d\n", status);
     return status;
   }
-  for (int i = 0; i < 4; i++) {
+  for (int i = 0; i < count; i++) {
     static const wchar_t* prefix = L"\\\\.\\Pipe\\dart";
     _snwprintf(pipe_names[i],
-               kMaxPipeNameSize,
+               max_length,
                L"%s_%s_%d", prefix, uuid_string, i + 1);
   }
   status = RpcStringFreeW(&uuid_string);
   if (status != RPC_S_OK) {
     SetOsErrorMessage(os_error_message);
     Log::PrintErr("RpcStringFree failed %d\n", status);
     return status;
   }
+  return 0;
+}
+
+
+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_handler,
+                   char** os_error_message) {
+  HANDLE stdin_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
+  HANDLE stdout_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
+  HANDLE stderr_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
+  HANDLE exit_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
+
+  // Generate unique pipe names for the four named pipes needed.
+  static const int kMaxPipeNameSize = 80;
+  wchar_t pipe_names[4][kMaxPipeNameSize];
+  int status = GenerateNames(4, pipe_names, kMaxPipeNameSize);
+  if (status != 0) return status;
 
   if (!CreateProcessPipe(stdin_handles, pipe_names[0], kInheritRead)) {
     int error_code = SetOsErrorMessage(os_error_message);
     CloseProcessPipes(
         stdin_handles, stdout_handles, stderr_handles, exit_handles);
     return error_code;
   }
   if (!CreateProcessPipe(stdout_handles, pipe_names[1], kInheritWrite)) {
     int error_code = SetOsErrorMessage(os_error_message);
     CloseProcessPipes(
@@ skipping 433 matching lines @@
 
 void Process::TerminateExitCodeHandler() {
   // Nothing needs to be done on Windows.
 }
 
 
 intptr_t Process::CurrentProcessId() {
   return static_cast<intptr_t>(GetCurrentProcessId());
 }
 
+
+static SignalInfo* signal_handlers = NULL;
+static Mutex* signal_mutex = new Mutex();
+
+
+SignalInfo::~SignalInfo() {
+  reinterpret_cast<FileHandle*>(fd_)->Close();
+}
+
+
+BOOL WINAPI SignalHandler(DWORD signal) {
+  MutexLocker lock(signal_mutex);
+  const SignalInfo* handler = signal_handlers;
+  bool handled = false;
+  while (handler != NULL) {
+    if (handler->signal() == signal) {
+      int value = 0;
+      Socket::Write(handler->fd(), &value, 1);
+      handled = true;
+    }
+    handler = handler->next();
+  }
+  return handled;
+}
+
+
+intptr_t GetWinSignal(intptr_t signal) {
+  switch (signal) {
+    case 1:  // SIGHUP
+      return CTRL_CLOSE_EVENT;
+    case 2:  // SIGINT
+      return CTRL_C_EVENT;
+    default:
+      return -1;
+  }
+}
+
+
+intptr_t Process::SetSignalHandler(intptr_t signal) {
+  signal = GetWinSignal(signal);
+  if (signal == -1) return -1;
+
+  // Generate a unique pipe name for the named pipe.
+  static const int kMaxPipeNameSize = 80;
+  wchar_t pipe_name[kMaxPipeNameSize];
+  GenerateNames(1, &pipe_name, kMaxPipeNameSize);
+  if (status != 0) return status;
+
+  HANDLE fds[2];
+  if (!CreateProcessPipe(fds, pipe_name, kInheritNone)) {
+    int error_code = GetLastError();
+    CloseProcessPipe(fds);
+    SetLastError(error_code);
+    return -1;
+  }
+  MutexLocker lock(signal_mutex);
+  FileHandle* write_handle = new FileHandle(fds[kWriteHandle]);
+  write_handle->EnsureInitialized(EventHandler::delegate());
+  intptr_t write_fd = reinterpret_cast<intptr_t>(write_handle);
+  if (signal_handlers == NULL) {
+    if (SetConsoleCtrlHandler(SignalHandler, true) == 0) {
+      int error_code = GetLastError();
+      delete write_handle;
+      CloseProcessPipe(fds);
+      SetLastError(error_code);
+      return -1;
+    }
+    signal_handlers = new SignalInfo(write_fd, signal);
+  } else {
+    new SignalInfo(write_fd, signal, signal_handlers);
+  }
+  return reinterpret_cast<intptr_t>(new FileHandle(fds[kReadHandle]));
+}
+
+
+void Process::ClearSignalHandler(intptr_t signal) {
+  signal = GetWinSignal(signal);
+  if (signal == -1) return;
+  MutexLocker lock(signal_mutex);
+  SignalInfo* handler = signal_handlers;
+  while (handler != NULL) {
+    if (handler->port() == Dart_GetMainPortId() &&
+        handler->signal() == signal) {
+      handler->Unlink();
+      break;
+    }
+    handler = handler->next();
+  }
+  if (handler != NULL) {
+    if (signal_handlers == handler) {
+      signal_handlers = handler->next();
+    }
+    if (signal_handlers == NULL) {
+      USE(SetConsoleCtrlHandler(SignalHandler, false));
+    }
+  }
+  delete handler;
+}
+
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)