process.cpp

   1 #include "nssm.h"
   2
   3 extern imports_t imports;
   4
   5 int get_process_creation_time(HANDLE process_handle, FILETIME *ft) {
   6   FILETIME creation_time, exit_time, kernel_time, user_time;
   7
   8   if (! GetProcessTimes(process_handle, &creation_time, &exit_time, &kernel_time, &user_time)) {
   9     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_GETPROCESSTIMES_FAILED, error_string(GetLastError()), 0);
  10     return 1;
  11   }
  12
  13   memmove(ft, &creation_time, sizeof(creation_time));
  14
  15   return 0;
  16 }
  17
  18 int get_process_exit_time(HANDLE process_handle, FILETIME *ft) {
  19   FILETIME creation_time, exit_time, kernel_time, user_time;
  20
  21   if (! GetProcessTimes(process_handle, &creation_time, &exit_time, &kernel_time, &user_time)) {
  22     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_GETPROCESSTIMES_FAILED, error_string(GetLastError()), 0);
  23     return 1;
  24   }
  25
  26   memmove(ft, &exit_time, sizeof(exit_time));
  27
  28   return 0;
  29 }
  30
  31 int check_parent(nssm_service_t *service, PROCESSENTRY32 *pe, unsigned long ppid) {
  32   /* Check parent process ID matches. */
  33   if (pe->th32ParentProcessID != ppid) return 1;
  34
  35   /*
  36     Process IDs can be reused so do a sanity check by making sure the child
  37     has been running for less time than the parent.
  38     Though unlikely, it's possible that the parent exited and its process ID
  39     was already reused, so we'll also compare against its exit time.
  40   */
  41   HANDLE process_handle = OpenProcess(PROCESS_QUERY_INFORMATION, false, pe->th32ProcessID);
  42   if (! process_handle) {
  43     TCHAR pid_string[16];
  44     _sntprintf_s(pid_string, _countof(pid_string), _TRUNCATE, _T("%lu"), pe->th32ProcessID);
  45     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OPENPROCESS_FAILED, pid_string, service->name, error_string(GetLastError()), 0);
  46     return 2;
  47   }
  48
  49   FILETIME ft;
  50   if (get_process_creation_time(process_handle, &ft)) {
  51     CloseHandle(process_handle);
  52     return 3;
  53   }
  54
  55   CloseHandle(process_handle);
  56
  57   /* Verify that the parent's creation time is not later. */
  58   if (CompareFileTime(&service->creation_time, &ft) > 0) return 4;
  59
  60   /* Verify that the parent's exit time is not earlier. */
  61   if (CompareFileTime(&service->exit_time, &ft) < 0) return 5;
  62
  63   return 0;
  64 }
  65
  66 /* Send some window messages and hope the window respects one or more. */
  67 int CALLBACK kill_window(HWND window, LPARAM arg) {
  68   kill_t *k = (kill_t *) arg;
  69
  70   unsigned long pid;
  71   if (! GetWindowThreadProcessId(window, &pid)) return 1;
  72   if (pid != k->pid) return 1;
  73
  74   /* First try sending WM_CLOSE to request that the window close. */
  75   k->signalled |= PostMessage(window, WM_CLOSE, k->exitcode, 0);
  76
  77   /*
  78     Then tell the window that the user is logging off and it should exit
  79     without worrying about saving any data.
  80   */
  81   k->signalled |= PostMessage(window, WM_ENDSESSION, 1, ENDSESSION_CLOSEAPP | ENDSESSION_CRITICAL | ENDSESSION_LOGOFF);
  82
  83   return 1;
  84 }
  85
  86 /*
  87   Try to post a message to the message queues of threads associated with the
  88   given process ID.  Not all threads have message queues so there's no
  89   guarantee of success, and we don't want to be left waiting for unsignalled
  90   processes so this function returns only true if at least one thread was
  91   successfully prodded.
  92 */
  93 int kill_threads(TCHAR *service_name, kill_t *k) {
  94   int ret = 0;
  95
  96   /* Get a snapshot of all threads in the system. */
  97   HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
  98   if (! snapshot) {
  99     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATETOOLHELP32SNAPSHOT_THREAD_FAILED, service_name, error_string(GetLastError()), 0);
 100     return 0;
 101   }
 102
 103   THREADENTRY32 te;
 104   ZeroMemory(&te, sizeof(te));
 105   te.dwSize = sizeof(te);
 106
 107   if (! Thread32First(snapshot, &te)) {
 108     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_THREAD_ENUMERATE_FAILED, service_name, error_string(GetLastError()), 0);
 109     CloseHandle(snapshot);
 110     return 0;
 111   }
 112
 113   /* This thread belongs to the doomed process so signal it. */
 114   if (te.th32OwnerProcessID == k->pid) {
 115     ret |= PostThreadMessage(te.th32ThreadID, WM_QUIT, k->exitcode, 0);
 116   }
 117
 118   while (true) {
 119     /* Try to get the next thread. */
 120     if (! Thread32Next(snapshot, &te)) {
 121       unsigned long error = GetLastError();
 122       if (error == ERROR_NO_MORE_FILES) break;
 123       log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_THREAD_ENUMERATE_FAILED, service_name, error_string(GetLastError()), 0);
 124       CloseHandle(snapshot);
 125       return ret;
 126     }
 127
 128     if (te.th32OwnerProcessID == k->pid) {
 129       ret |= PostThreadMessage(te.th32ThreadID, WM_QUIT, k->exitcode, 0);
 130     }
 131   }
 132
 133   CloseHandle(snapshot);
 134
 135   return ret;
 136 }
 137
 138 /* Give the process a chance to die gracefully. */
 139 int kill_process(nssm_service_t *service, HANDLE process_handle, unsigned long pid, unsigned long exitcode) {
 140   /* Shouldn't happen. */
 141   if (! service) return 1;
 142   if (! pid) return 1;
 143   if (! process_handle) return 1;
 144
 145   unsigned long ret;
 146   if (GetExitCodeProcess(process_handle, &ret)) {
 147     if (ret != STILL_ACTIVE) return 1;
 148   }
 149
 150   kill_t k = { pid, exitcode, 0 };
 151
 152   /* Try to send a Control-C event to the console. */
 153   if (service->stop_method & NSSM_STOP_METHOD_CONSOLE) {
 154     if (! kill_console(service)) return 1;
 155   }
 156
 157   /*
 158     Try to post messages to the windows belonging to the given process ID.
 159     If the process is a console application it won't have any windows so there's
 160     no guarantee of success.
 161   */
 162   if (service->stop_method & NSSM_STOP_METHOD_WINDOW) {
 163     EnumWindows((WNDENUMPROC) kill_window, (LPARAM) &k);
 164     if (k.signalled) {
 165       if (! await_shutdown(service, _T(__FUNCTION__), service->kill_window_delay)) return 1;
 166     }
 167   }
 168
 169   /*
 170     Try to post messages to any thread message queues associated with the
 171     process.  Console applications might have them (but probably won't) so
 172     there's still no guarantee of success.
 173   */
 174   if (service->stop_method & NSSM_STOP_METHOD_THREADS) {
 175     if (kill_threads(service->name, &k)) {
 176       if (! await_shutdown(service, _T(__FUNCTION__), service->kill_threads_delay)) return 1;
 177     }
 178   }
 179
 180   /* We tried being nice.  Time for extreme prejudice. */
 181   if (service->stop_method & NSSM_STOP_METHOD_TERMINATE) {
 182     return TerminateProcess(service->process_handle, exitcode);
 183   }
 184
 185   return 0;
 186 }
 187
 188 /* Simulate a Control-C event to our console (shared with the app). */
 189 int kill_console(nssm_service_t *service) {
 190   unsigned long ret;
 191
 192   if (! service) return 1;
 193
 194   /* Check we loaded AttachConsole(). */
 195   if (! imports.AttachConsole) return 4;
 196
 197   /* Try to attach to the process's console. */
 198   if (! imports.AttachConsole(service->pid)) {
 199     ret = GetLastError();
 200
 201     switch (ret) {
 202       case ERROR_INVALID_HANDLE:
 203         /* The app doesn't have a console. */
 204         return 1;
 205
 206       case ERROR_GEN_FAILURE:
 207         /* The app already exited. */
 208         return 2;
 209
 210       case ERROR_ACCESS_DENIED:
 211       default:
 212         /* We already have a console. */
 213         log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_ATTACHCONSOLE_FAILED, service->name, error_string(ret), 0);
 214         return 3;
 215     }
 216   }
 217
 218   /* Ignore the event ourselves. */
 219   ret = 0;
 220   if (! SetConsoleCtrlHandler(0, TRUE)) {
 221     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SETCONSOLECTRLHANDLER_FAILED, service->name, error_string(GetLastError()), 0);
 222     ret = 4;
 223   }
 224
 225   /* Send the event. */
 226   if (! ret) {
 227     if (! GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0)) {
 228       log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_GENERATECONSOLECTRLEVENT_FAILED, service->name, error_string(GetLastError()), 0);
 229       ret = 5;
 230     }
 231   }
 232
 233   /* Detach from the console. */
 234   if (! FreeConsole()) {
 235     log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_FREECONSOLE_FAILED, service->name, error_string(GetLastError()), 0);
 236   }
 237
 238   /* Wait for process to exit. */
 239   if (await_shutdown(service, _T(__FUNCTION__), service->kill_console_delay)) ret = 6;
 240
 241   return ret;
 242 }
 243
 244 void kill_process_tree(nssm_service_t *service, unsigned long pid, unsigned long exitcode, unsigned long ppid) {
 245   /* Shouldn't happen unless the service failed to start. */
 246   if (! pid) return;
 247
 248   TCHAR pid_string[16], code[16];
 249   _sntprintf_s(pid_string, _countof(pid_string), _TRUNCATE, _T("%lu"), pid);
 250   _sntprintf_s(code, _countof(code), _TRUNCATE, _T("%lu"), exitcode);
 251   log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_KILLING, service->name, pid_string, code, 0);
 252
 253   /* Get a snapshot of all processes in the system. */
 254   HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
 255   if (! snapshot) {
 256     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATETOOLHELP32SNAPSHOT_PROCESS_FAILED, service->name, error_string(GetLastError()), 0);
 257     return;
 258   }
 259
 260   PROCESSENTRY32 pe;
 261   ZeroMemory(&pe, sizeof(pe));
 262   pe.dwSize = sizeof(pe);
 263
 264   if (! Process32First(snapshot, &pe)) {
 265     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_PROCESS_ENUMERATE_FAILED, service->name, error_string(GetLastError()), 0);
 266     CloseHandle(snapshot);
 267     return;
 268   }
 269
 270   /* This is a child of the doomed process so kill it. */
 271   if (! check_parent(service, &pe, pid)) kill_process_tree(service, pe.th32ProcessID, exitcode, ppid);
 272
 273   while (true) {
 274     /* Try to get the next process. */
 275     if (! Process32Next(snapshot, &pe)) {
 276       unsigned long ret = GetLastError();
 277       if (ret == ERROR_NO_MORE_FILES) break;
 278       log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_PROCESS_ENUMERATE_FAILED, service->name, error_string(GetLastError()), 0);
 279       CloseHandle(snapshot);
 280       return;
 281     }
 282
 283     if (! check_parent(service, &pe, pid)) kill_process_tree(service, pe.th32ProcessID, exitcode, ppid);
 284   }
 285
 286   CloseHandle(snapshot);
 287
 288   /* We will need a process handle in order to call TerminateProcess() later. */
 289   HANDLE process_handle = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_INFORMATION | PROCESS_VM_READ | PROCESS_TERMINATE, false, pid);
 290   if (! process_handle) {
 291     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OPENPROCESS_FAILED, pid_string, service->name, error_string(GetLastError()), 0);
 292     return;
 293   }
 294
 295   TCHAR ppid_string[16];
 296   _sntprintf_s(ppid_string, _countof(ppid_string), _TRUNCATE, _T("%lu"), ppid);
 297   log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_KILL_PROCESS_TREE, pid_string, ppid_string, service->name, 0);
 298   if (! kill_process(service, process_handle, pid, exitcode)) {
 299     /* Maybe it already died. */
 300     unsigned long ret;
 301     if (! GetExitCodeProcess(process_handle, &ret) || ret == STILL_ACTIVE) {
 302       if (service->stop_method & NSSM_STOP_METHOD_TERMINATE) log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_TERMINATEPROCESS_FAILED, pid_string, service->name, error_string(GetLastError()), 0);
 303       else log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_PROCESS_STILL_ACTIVE, service->name, pid_string, NSSM, NSSM_REG_STOP_METHOD_SKIP, 0);
 304     }
 305   }
 306
 307   CloseHandle(process_handle);
 308 }