gui.cpp

   1 #include "nssm.h"\r
   2 \r
   3 static enum { NSSM_TAB_APPLICATION, NSSM_TAB_DETAILS, NSSM_TAB_LOGON, NSSM_TAB_SHUTDOWN, NSSM_TAB_EXIT, NSSM_TAB_IO, NSSM_TAB_ROTATION, NSSM_TAB_ENVIRONMENT, NSSM_NUM_TABS };\r
   4 static HWND tablist[NSSM_NUM_TABS];\r
   5 static int selected_tab;\r
   6 \r
   7 int nssm_gui(int resource, nssm_service_t *service) {\r
   8   /* Create window */\r
   9   HWND dlg = CreateDialogParam(0, MAKEINTRESOURCE(resource), 0, nssm_dlg, (LPARAM) service);\r
  10   if (! dlg) {\r
  11     popup_message(MB_OK, NSSM_GUI_CREATEDIALOG_FAILED, error_string(GetLastError()));\r
  12     return 1;\r
  13   }\r
  14 \r
  15   /* Display the window */\r
  16   centre_window(dlg);\r
  17   ShowWindow(dlg, SW_SHOW);\r
  18 \r
  19   /* Set service name if given */\r
  20   if (service->name[0]) {\r
  21     SetDlgItemText(dlg, IDC_NAME, service->name);\r
  22     /* No point making user click remove if the name is already entered */\r
  23     if (resource == IDD_REMOVE) {\r
  24       HWND button = GetDlgItem(dlg, IDC_REMOVE);\r
  25       if (button) {\r
  26         SendMessage(button, WM_LBUTTONDOWN, 0, 0);\r
  27         SendMessage(button, WM_LBUTTONUP, 0, 0);\r
  28       }\r
  29     }\r
  30   }\r
  31 \r
  32   /* Go! */\r
  33   MSG message;\r
  34   while (GetMessage(&message, 0, 0, 0)) {\r
  35     if (IsDialogMessage(dlg, &message)) continue;\r
  36     TranslateMessage(&message);\r
  37     DispatchMessage(&message);\r
  38   }\r
  39 \r
  40   return (int) message.wParam;\r
  41 }\r
  42 \r
  43 void centre_window(HWND window) {\r
  44   HWND desktop;\r
  45   RECT size, desktop_size;\r
  46   unsigned long x, y;\r
  47 \r
  48   if (! window) return;\r
  49 \r
  50   /* Find window size */\r
  51   if (! GetWindowRect(window, &size)) return;\r
  52 \r
  53   /* Find desktop window */\r
  54   desktop = GetDesktopWindow();\r
  55   if (! desktop) return;\r
  56 \r
  57   /* Find desktop window size */\r
  58   if (! GetWindowRect(desktop, &desktop_size)) return;\r
  59 \r
  60   /* Centre window */\r
  61   x = (desktop_size.right - size.right) / 2;\r
  62   y = (desktop_size.bottom - size.bottom) / 2;\r
  63   MoveWindow(window, x, y, size.right - size.left, size.bottom - size.top, 0);\r
  64 }\r
  65 \r
  66 static inline void check_stop_method(nssm_service_t *service, unsigned long method, unsigned long control) {\r
  67   if (SendDlgItemMessage(tablist[NSSM_TAB_SHUTDOWN], control, BM_GETCHECK, 0, 0) & BST_CHECKED) return;\r
  68   service->stop_method &= ~method;\r
  69 }\r
  70 \r
  71 static inline void check_number(HWND tab, unsigned long control, unsigned long *timeout) {\r
  72   BOOL translated;\r
  73   unsigned long configured = GetDlgItemInt(tab, control, &translated, 0);\r
  74   if (translated) *timeout = configured;\r
  75 }\r
  76 \r
  77 static inline void set_timeout_enabled(unsigned long control, unsigned long dependent) {\r
  78   unsigned char enabled = 0;\r
  79   if (SendDlgItemMessage(tablist[NSSM_TAB_SHUTDOWN], control, BM_GETCHECK, 0, 0) & BST_CHECKED) enabled = 1;\r
  80   EnableWindow(GetDlgItem(tablist[NSSM_TAB_SHUTDOWN], dependent), enabled);\r
  81 }\r
  82 \r
  83 static inline void set_logon_enabled(unsigned char enabled) {\r
  84   EnableWindow(GetDlgItem(tablist[NSSM_TAB_LOGON], IDC_INTERACT), ! enabled);\r
  85   EnableWindow(GetDlgItem(tablist[NSSM_TAB_LOGON], IDC_USERNAME), enabled);\r
  86   EnableWindow(GetDlgItem(tablist[NSSM_TAB_LOGON], IDC_PASSWORD1), enabled);\r
  87   EnableWindow(GetDlgItem(tablist[NSSM_TAB_LOGON], IDC_PASSWORD2), enabled);\r
  88 }\r
  89 \r
  90 static inline void set_rotation_enabled(unsigned char enabled) {\r
  91   EnableWindow(GetDlgItem(tablist[NSSM_TAB_ROTATION], IDC_ROTATE_SECONDS), enabled);\r
  92   EnableWindow(GetDlgItem(tablist[NSSM_TAB_ROTATION], IDC_ROTATE_BYTES_LOW), enabled);\r
  93 }\r
  94 \r
  95 static inline void check_io(TCHAR *name, TCHAR *buffer, unsigned long len, unsigned long control) {\r
  96   if (! SendMessage(GetDlgItem(tablist[NSSM_TAB_IO], control), WM_GETTEXTLENGTH, 0, 0)) return;\r
  97   if (GetDlgItemText(tablist[NSSM_TAB_IO], control, buffer, (int) len)) return;\r
  98   popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_MESSAGE_PATH_TOO_LONG, name);\r
  99   ZeroMemory(buffer, len * sizeof(TCHAR));\r
 100 }\r
 101 \r
 102 /* Install the service. */\r
 103 int install(HWND window) {\r
 104   if (! window) return 1;\r
 105 \r
 106   nssm_service_t *service = alloc_nssm_service();\r
 107   if (service) {\r
 108     set_nssm_service_defaults(service);\r
 109 \r
 110     /* Get service name. */\r
 111     if (! GetDlgItemText(window, IDC_NAME, service->name, _countof(service->name))) {\r
 112       popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_MISSING_SERVICE_NAME);\r
 113       cleanup_nssm_service(service);\r
 114       return 2;\r
 115     }\r
 116 \r
 117     /* Get executable name */\r
 118     if (! GetDlgItemText(tablist[NSSM_TAB_APPLICATION], IDC_PATH, service->exe, _countof(service->exe))) {\r
 119       popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_MISSING_PATH);\r
 120       return 3;\r
 121     }\r
 122 \r
 123     /* Get startup directory. */\r
 124     if (! GetDlgItemText(tablist[NSSM_TAB_APPLICATION], IDC_DIR, service->dir, _countof(service->dir))) {\r
 125       _sntprintf_s(service->dir, _countof(service->dir), _TRUNCATE, _T("%s"), service->exe);\r
 126       strip_basename(service->dir);\r
 127     }\r
 128 \r
 129     /* Get flags. */\r
 130     if (SendMessage(GetDlgItem(tablist[NSSM_TAB_APPLICATION], IDC_FLAGS), WM_GETTEXTLENGTH, 0, 0)) {\r
 131       if (! GetDlgItemText(tablist[NSSM_TAB_APPLICATION], IDC_FLAGS, service->flags, _countof(service->flags))) {\r
 132         popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INVALID_OPTIONS);\r
 133         return 4;\r
 134       }\r
 135     }\r
 136 \r
 137     /* Get details. */\r
 138     if (SendMessage(GetDlgItem(tablist[NSSM_TAB_DETAILS], IDC_DISPLAYNAME), WM_GETTEXTLENGTH, 0, 0)) {\r
 139       if (! GetDlgItemText(tablist[NSSM_TAB_DETAILS], IDC_DISPLAYNAME, service->displayname, _countof(service->displayname))) {\r
 140         popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INVALID_DISPLAYNAME);\r
 141         return 5;\r
 142       }\r
 143     }\r
 144 \r
 145     if (SendMessage(GetDlgItem(tablist[NSSM_TAB_DETAILS], IDC_DESCRIPTION), WM_GETTEXTLENGTH, 0, 0)) {\r
 146       if (! GetDlgItemText(tablist[NSSM_TAB_DETAILS], IDC_DESCRIPTION, service->description, _countof(service->description))) {\r
 147         popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INVALID_DESCRIPTION);\r
 148         return 5;\r
 149       }\r
 150     }\r
 151 \r
 152     HWND combo = GetDlgItem(tablist[NSSM_TAB_DETAILS], IDC_STARTUP);\r
 153     service->startup = (unsigned long) SendMessage(combo, CB_GETCURSEL, 0, 0);\r
 154     if (service->startup == CB_ERR) service->startup = 0;\r
 155 \r
 156     /* Get logon stuff. */\r
 157     if (SendDlgItemMessage(tablist[NSSM_TAB_LOGON], IDC_LOCALSYSTEM, BM_GETCHECK, 0, 0) & BST_CHECKED) {\r
 158       if (SendDlgItemMessage(tablist[NSSM_TAB_LOGON], IDC_INTERACT, BM_GETCHECK, 0, 0) & BST_CHECKED) {\r
 159         service->type |= SERVICE_INTERACTIVE_PROCESS;\r
 160       }\r
 161     }\r
 162     else {\r
 163       /* Username. */\r
 164       service->usernamelen = SendMessage(GetDlgItem(tablist[NSSM_TAB_LOGON], IDC_USERNAME), WM_GETTEXTLENGTH, 0, 0);\r
 165       if (! service->usernamelen) {\r
 166         popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_MISSING_USERNAME);\r
 167         return 6;\r
 168       }\r
 169       service->usernamelen++;\r
 170 \r
 171       service->username = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, service->usernamelen * sizeof(TCHAR));\r
 172       if (! service->username) {\r
 173         popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_EVENT_OUT_OF_MEMORY, _T("account name"), _T("install()"));\r
 174         return 6;\r
 175       }\r
 176       if (! GetDlgItemText(tablist[NSSM_TAB_LOGON], IDC_USERNAME, service->username, (int) service->usernamelen)) {\r
 177         HeapFree(GetProcessHeap(), 0, service->username);\r
 178         service->username = 0;\r
 179         service->usernamelen = 0;\r
 180         popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INVALID_USERNAME);\r
 181         return 6;\r
 182       }\r
 183 \r
 184       /* Password. */\r
 185       service->passwordlen = SendMessage(GetDlgItem(tablist[NSSM_TAB_LOGON], IDC_PASSWORD1), WM_GETTEXTLENGTH, 0, 0);\r
 186       if (! service->passwordlen) {\r
 187         popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_MISSING_PASSWORD);\r
 188         return 6;\r
 189       }\r
 190       if (SendMessage(GetDlgItem(tablist[NSSM_TAB_LOGON], IDC_PASSWORD2), WM_GETTEXTLENGTH, 0, 0) != service->passwordlen) {\r
 191         popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_MISSING_PASSWORD);\r
 192         return 6;\r
 193       }\r
 194       service->passwordlen++;\r
 195 \r
 196       /* Temporary buffer for password validation. */\r
 197       TCHAR *password = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, service->passwordlen * sizeof(TCHAR));\r
 198       if (! password) {\r
 199         HeapFree(GetProcessHeap(), 0, service->username);\r
 200         service->username = 0;\r
 201         service->usernamelen = 0;\r
 202         popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_EVENT_OUT_OF_MEMORY, _T("password confirmation"), _T("install()"));\r
 203         return 6;\r
 204       }\r
 205 \r
 206       /* Actual password buffer. */\r
 207       service->password = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, service->passwordlen * sizeof(TCHAR));\r
 208       if (! service->password) {\r
 209         HeapFree(GetProcessHeap(), 0, password);\r
 210         HeapFree(GetProcessHeap(), 0, service->username);\r
 211         service->username = 0;\r
 212         service->usernamelen = 0;\r
 213         popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_EVENT_OUT_OF_MEMORY, _T("password"), _T("install()"));\r
 214         return 6;\r
 215       }\r
 216 \r
 217       /* Get first password. */\r
 218       if (! GetDlgItemText(tablist[NSSM_TAB_LOGON], IDC_PASSWORD1, service->password, (int) service->passwordlen)) {\r
 219         HeapFree(GetProcessHeap(), 0, password);\r
 220         SecureZeroMemory(service->password, service->passwordlen);\r
 221         HeapFree(GetProcessHeap(), 0, service->password);\r
 222         service->password = 0;\r
 223         service->passwordlen = 0;\r
 224         HeapFree(GetProcessHeap(), 0, service->username);\r
 225         service->username = 0;\r
 226         service->usernamelen = 0;\r
 227         popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INVALID_PASSWORD);\r
 228         return 6;\r
 229       }\r
 230 \r
 231       /* Get confirmation. */\r
 232       if (! GetDlgItemText(tablist[NSSM_TAB_LOGON], IDC_PASSWORD2, password, (int) service->passwordlen)) {\r
 233         SecureZeroMemory(password, service->passwordlen);\r
 234         HeapFree(GetProcessHeap(), 0, password);\r
 235         SecureZeroMemory(service->password, service->passwordlen);\r
 236         HeapFree(GetProcessHeap(), 0, service->password);\r
 237         service->password = 0;\r
 238         service->passwordlen = 0;\r
 239         HeapFree(GetProcessHeap(), 0, service->username);\r
 240         service->username = 0;\r
 241         service->usernamelen = 0;\r
 242         popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INVALID_PASSWORD);\r
 243         return 6;\r
 244       }\r
 245 \r
 246       /* Compare. */\r
 247       if (_tcsncmp(password, service->password, service->passwordlen)) {\r
 248         popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_MISSING_PASSWORD);\r
 249         SecureZeroMemory(password, service->passwordlen);\r
 250         HeapFree(GetProcessHeap(), 0, password);\r
 251         SecureZeroMemory(service->password, service->passwordlen);\r
 252         HeapFree(GetProcessHeap(), 0, service->password);\r
 253         service->password = 0;\r
 254         service->passwordlen = 0;\r
 255         HeapFree(GetProcessHeap(), 0, service->username);\r
 256         service->username = 0;\r
 257         service->usernamelen = 0;\r
 258         return 6;\r
 259       }\r
 260     }\r
 261 \r
 262     /* Get stop method stuff. */\r
 263     check_stop_method(service, NSSM_STOP_METHOD_CONSOLE, IDC_METHOD_CONSOLE);\r
 264     check_stop_method(service, NSSM_STOP_METHOD_WINDOW, IDC_METHOD_WINDOW);\r
 265     check_stop_method(service, NSSM_STOP_METHOD_THREADS, IDC_METHOD_THREADS);\r
 266     check_stop_method(service, NSSM_STOP_METHOD_TERMINATE, IDC_METHOD_TERMINATE);\r
 267     check_number(tablist[NSSM_TAB_SHUTDOWN], IDC_KILL_CONSOLE, &service->kill_console_delay);\r
 268     check_number(tablist[NSSM_TAB_SHUTDOWN], IDC_KILL_WINDOW, &service->kill_window_delay);\r
 269     check_number(tablist[NSSM_TAB_SHUTDOWN], IDC_KILL_THREADS, &service->kill_threads_delay);\r
 270 \r
 271     /* Get exit action stuff. */\r
 272     check_number(tablist[NSSM_TAB_EXIT], IDC_THROTTLE, &service->throttle_delay);\r
 273     combo = GetDlgItem(tablist[NSSM_TAB_EXIT], IDC_APPEXIT);\r
 274     service->default_exit_action = (unsigned long) SendMessage(combo, CB_GETCURSEL, 0, 0);\r
 275     if (service->default_exit_action == CB_ERR) service->default_exit_action = 0;\r
 276 \r
 277     /* Get I/O stuff. */\r
 278     check_io(_T("stdin"), service->stdin_path, _countof(service->stdin_path), IDC_STDIN);\r
 279     check_io(_T("stdout"), service->stdout_path, _countof(service->stdout_path), IDC_STDOUT);\r
 280     check_io(_T("stderr"), service->stderr_path, _countof(service->stderr_path), IDC_STDERR);\r
 281 \r
 282     /* Override stdout and/or stderr. */\r
 283     if (SendDlgItemMessage(tablist[NSSM_TAB_ROTATION], IDC_TRUNCATE, BM_GETCHECK, 0, 0) & BST_CHECKED) {\r
 284       if (service->stdout_path[0]) service->stdout_disposition = CREATE_ALWAYS;\r
 285       if (service->stderr_path[0]) service->stderr_disposition = CREATE_ALWAYS;\r
 286     }\r
 287 \r
 288     /* Get rotation stuff. */\r
 289     if (SendDlgItemMessage(tablist[NSSM_TAB_ROTATION], IDC_ROTATE, BM_GETCHECK, 0, 0) & BST_CHECKED) {\r
 290       service->rotate_files = true;\r
 291       check_number(tablist[NSSM_TAB_ROTATION], IDC_ROTATE_SECONDS, &service->rotate_seconds);\r
 292       check_number(tablist[NSSM_TAB_ROTATION], IDC_ROTATE_BYTES_LOW, &service->rotate_bytes_low);\r
 293     }\r
 294 \r
 295     /* Get environment. */\r
 296     unsigned long envlen = (unsigned long) SendMessage(GetDlgItem(tablist[NSSM_TAB_ENVIRONMENT], IDC_ENVIRONMENT), WM_GETTEXTLENGTH, 0, 0);\r
 297     if (envlen) {\r
 298       TCHAR *env = (TCHAR *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (envlen + 2) * sizeof(TCHAR));\r
 299       if (! env) {\r
 300         popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_EVENT_OUT_OF_MEMORY, _T("environment"), _T("install()"));\r
 301         cleanup_nssm_service(service);\r
 302         return 5;\r
 303       }\r
 304 \r
 305       if (! GetDlgItemText(tablist[NSSM_TAB_ENVIRONMENT], IDC_ENVIRONMENT, env, envlen + 1)) {\r
 306         popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INVALID_ENVIRONMENT);\r
 307         HeapFree(GetProcessHeap(), 0, env);\r
 308         cleanup_nssm_service(service);\r
 309         return 5;\r
 310       }\r
 311 \r
 312       /* Strip CR and replace LF with NULL. */\r
 313       unsigned long newlen = 0;\r
 314       unsigned long i, j;\r
 315       for (i = 0; i < envlen; i++) if (env[i] != _T('\r')) newlen++;\r
 316       /* Must end with two NULLs. */\r
 317       newlen += 2;\r
 318 \r
 319       TCHAR *newenv = (TCHAR *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, newlen * sizeof(TCHAR));\r
 320       if (! newenv) {\r
 321         HeapFree(GetProcessHeap(), 0, env);\r
 322         popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_EVENT_OUT_OF_MEMORY, _T("environment"), _T("install()"));\r
 323         cleanup_nssm_service(service);\r
 324         return 5;\r
 325       }\r
 326 \r
 327       for (i = 0, j = 0; i < envlen; i++) {\r
 328         if (env[i] == _T('\r')) continue;\r
 329         if (env[i] == _T('\n')) newenv[j] = _T('\0');\r
 330         else newenv[j] = env[i];\r
 331         j++;\r
 332       }\r
 333 \r
 334       HeapFree(GetProcessHeap(), 0, env);\r
 335       env = newenv;\r
 336       envlen = newlen;\r
 337 \r
 338       /* Test the environment is valid. */\r
 339       if (test_environment(env)) {\r
 340         popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INVALID_ENVIRONMENT);\r
 341         HeapFree(GetProcessHeap(), 0, env);\r
 342         cleanup_nssm_service(service);\r
 343         return 5;\r
 344       }\r
 345 \r
 346       if (SendDlgItemMessage(tablist[NSSM_TAB_ENVIRONMENT], IDC_ENVIRONMENT_REPLACE, BM_GETCHECK, 0, 0) & BST_CHECKED) {\r
 347         service->env = env;\r
 348         service->envlen = envlen;\r
 349       }\r
 350       else {\r
 351         service->env_extra = env;\r
 352         service->env_extralen = envlen;\r
 353       }\r
 354     }\r
 355   }\r
 356 \r
 357   /* See if it works. */\r
 358   switch (install_service(service)) {\r
 359     case 1:\r
 360       popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_EVENT_OUT_OF_MEMORY, _T("service"), _T("install()"));\r
 361       cleanup_nssm_service(service);\r
 362       return 1;\r
 363 \r
 364     case 2:\r
 365       popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_MESSAGE_OPEN_SERVICE_MANAGER_FAILED);\r
 366       cleanup_nssm_service(service);\r
 367       return 2;\r
 368 \r
 369     case 3:\r
 370       popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_MESSAGE_PATH_TOO_LONG, NSSM);\r
 371       cleanup_nssm_service(service);\r
 372       return 3;\r
 373 \r
 374     case 4:\r
 375       popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_OUT_OF_MEMORY_FOR_IMAGEPATH);\r
 376       cleanup_nssm_service(service);\r
 377       return 4;\r
 378 \r
 379     case 5:\r
 380       popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INSTALL_SERVICE_FAILED);\r
 381       cleanup_nssm_service(service);\r
 382       return 5;\r
 383 \r
 384     case 6:\r
 385       popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_CREATE_PARAMETERS_FAILED);\r
 386       cleanup_nssm_service(service);\r
 387       return 6;\r
 388   }\r
 389 \r
 390   popup_message(MB_OK, NSSM_MESSAGE_SERVICE_INSTALLED, service->name);\r
 391   cleanup_nssm_service(service);\r
 392   return 0;\r
 393 }\r
 394 \r
 395 /* Remove the service */\r
 396 int remove(HWND window) {\r
 397   if (! window) return 1;\r
 398 \r
 399   /* See if it works */\r
 400   nssm_service_t *service = alloc_nssm_service();\r
 401   if (service) {\r
 402     /* Get service name */\r
 403     if (! GetDlgItemText(window, IDC_NAME, service->name, _countof(service->name))) {\r
 404       popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_MISSING_SERVICE_NAME);\r
 405       cleanup_nssm_service(service);\r
 406       return 2;\r
 407     }\r
 408 \r
 409     /* Confirm */\r
 410     if (popup_message(MB_YESNO, NSSM_GUI_ASK_REMOVE_SERVICE, service->name) != IDYES) {\r
 411       cleanup_nssm_service(service);\r
 412       return 0;\r
 413     }\r
 414   }\r
 415 \r
 416   switch (remove_service(service)) {\r
 417     case 1:\r
 418       popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_EVENT_OUT_OF_MEMORY, _T("service"), _T("remove()"));\r
 419       cleanup_nssm_service(service);\r
 420       return 1;\r
 421 \r
 422     case 2:\r
 423       popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_MESSAGE_OPEN_SERVICE_MANAGER_FAILED);\r
 424       cleanup_nssm_service(service);\r
 425       return 2;\r
 426 \r
 427     case 3:\r
 428       popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_SERVICE_NOT_INSTALLED);\r
 429       return 3;\r
 430       cleanup_nssm_service(service);\r
 431 \r
 432     case 4:\r
 433       popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_REMOVE_SERVICE_FAILED);\r
 434       cleanup_nssm_service(service);\r
 435       return 4;\r
 436   }\r
 437 \r
 438   popup_message(MB_OK, NSSM_MESSAGE_SERVICE_REMOVED, service->name);\r
 439   cleanup_nssm_service(service);\r
 440   return 0;\r
 441 }\r
 442 \r
 443 static TCHAR *browse_filter(int message) {\r
 444   switch (message) {\r
 445     case NSSM_GUI_BROWSE_FILTER_APPLICATIONS: return _T("*.exe;*.bat;*.cmd");\r
 446     case NSSM_GUI_BROWSE_FILTER_DIRECTORIES: return _T(".");\r
 447     case NSSM_GUI_BROWSE_FILTER_ALL_FILES: /* Fall through. */\r
 448     default: return _T("*.*");\r
 449   }\r
 450 }\r
 451 \r
 452 UINT_PTR CALLBACK browse_hook(HWND dlg, UINT message, WPARAM w, LPARAM l) {\r
 453   switch (message) {\r
 454     case WM_INITDIALOG:\r
 455       return 1;\r
 456   }\r
 457 \r
 458   return 0;\r
 459 }\r
 460 \r
 461 /* Browse for application */\r
 462 void browse(HWND window, TCHAR *current, unsigned long flags, ...) {\r
 463   if (! window) return;\r
 464 \r
 465   va_list arg;\r
 466   size_t bufsize = 256;\r
 467   size_t len = bufsize;\r
 468   int i;\r
 469 \r
 470   OPENFILENAME ofn;\r
 471   ZeroMemory(&ofn, sizeof(ofn));\r
 472   ofn.lStructSize = sizeof(ofn);\r
 473   ofn.lpstrFilter = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, bufsize * sizeof(TCHAR));\r
 474   /* XXX: Escaping nulls with FormatMessage is tricky */\r
 475   if (ofn.lpstrFilter) {\r
 476     ZeroMemory((void *) ofn.lpstrFilter, bufsize);\r
 477     len = 0;\r
 478     /* "Applications" + NULL + "*.exe" + NULL */\r
 479     va_start(arg, flags);\r
 480     while (i = va_arg(arg, int)) {\r
 481       TCHAR *localised = message_string(i);\r
 482       _sntprintf_s((TCHAR *) ofn.lpstrFilter + len, bufsize, _TRUNCATE, localised);\r
 483       len += _tcslen(localised) + 1;\r
 484       LocalFree(localised);\r
 485       TCHAR *filter = browse_filter(i);\r
 486       _sntprintf_s((TCHAR *) ofn.lpstrFilter + len, bufsize - len, _TRUNCATE, _T("%s"), filter);\r
 487       len += _tcslen(filter) + 1;\r
 488     }\r
 489     va_end(arg);\r
 490     /* Remainder of the buffer is already zeroed */\r
 491   }\r
 492   ofn.lpstrFile = new TCHAR[MAX_PATH];\r
 493   if (flags & OFN_NOVALIDATE) {\r
 494     /* Directory hack. */\r
 495     _sntprintf_s(ofn.lpstrFile, MAX_PATH, _TRUNCATE, _T(":%s:"), message_string(NSSM_GUI_BROWSE_FILTER_DIRECTORIES));\r
 496   }\r
 497   else _sntprintf_s(ofn.lpstrFile, MAX_PATH, _TRUNCATE, _T("%s"), current);\r
 498   ofn.lpstrTitle = message_string(NSSM_GUI_BROWSE_TITLE);\r
 499   ofn.nMaxFile = MAX_PATH;\r
 500   ofn.Flags = OFN_EXPLORER | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST | flags;\r
 501 \r
 502   if (GetOpenFileName(&ofn)) {\r
 503     /* Directory hack. */\r
 504     if (flags & OFN_NOVALIDATE) strip_basename(ofn.lpstrFile);\r
 505     SendMessage(window, WM_SETTEXT, 0, (LPARAM) ofn.lpstrFile);\r
 506   }\r
 507   if (ofn.lpstrFilter) HeapFree(GetProcessHeap(), 0, (void *) ofn.lpstrFilter);\r
 508 \r
 509   delete[] ofn.lpstrFile;\r
 510 }\r
 511 \r
 512 INT_PTR CALLBACK tab_dlg(HWND tab, UINT message, WPARAM w, LPARAM l) {\r
 513   switch (message) {\r
 514     case WM_INITDIALOG:\r
 515       return 1;\r
 516 \r
 517     /* Button was pressed or control was controlled. */\r
 518     case WM_COMMAND:\r
 519       HWND dlg;\r
 520       TCHAR buffer[MAX_PATH];\r
 521       unsigned char enabled;\r
 522 \r
 523       switch (LOWORD(w)) {\r
 524         /* Browse for application. */\r
 525         case IDC_BROWSE:\r
 526           dlg = GetDlgItem(tab, IDC_PATH);\r
 527           GetDlgItemText(tab, IDC_PATH, buffer, _countof(buffer));\r
 528           browse(dlg, buffer, OFN_FILEMUSTEXIST, NSSM_GUI_BROWSE_FILTER_APPLICATIONS, NSSM_GUI_BROWSE_FILTER_ALL_FILES, 0);\r
 529           /* Fill in startup directory if it wasn't already specified. */\r
 530           GetDlgItemText(tab, IDC_DIR, buffer, _countof(buffer));\r
 531           if (! buffer[0]) {\r
 532             GetDlgItemText(tab, IDC_PATH, buffer, _countof(buffer));\r
 533             strip_basename(buffer);\r
 534             SetDlgItemText(tab, IDC_DIR, buffer);\r
 535           }\r
 536           break;\r
 537 \r
 538         /* Browse for startup directory. */\r
 539         case IDC_BROWSE_DIR:\r
 540           dlg = GetDlgItem(tab, IDC_DIR);\r
 541           GetDlgItemText(tab, IDC_DIR, buffer, _countof(buffer));\r
 542           browse(dlg, buffer, OFN_NOVALIDATE, NSSM_GUI_BROWSE_FILTER_DIRECTORIES, 0);\r
 543           break;\r
 544 \r
 545         /* Log on. */\r
 546         case IDC_LOCALSYSTEM:\r
 547           set_logon_enabled(0);\r
 548           break;\r
 549 \r
 550         case IDC_ACCOUNT:\r
 551           set_logon_enabled(1);\r
 552           break;\r
 553 \r
 554         /* Shutdown methods. */\r
 555         case IDC_METHOD_CONSOLE:\r
 556           set_timeout_enabled(LOWORD(w), IDC_KILL_CONSOLE);\r
 557           break;\r
 558 \r
 559         case IDC_METHOD_WINDOW:\r
 560           set_timeout_enabled(LOWORD(w), IDC_KILL_WINDOW);\r
 561           break;\r
 562 \r
 563         case IDC_METHOD_THREADS:\r
 564           set_timeout_enabled(LOWORD(w), IDC_KILL_THREADS);\r
 565           break;\r
 566 \r
 567         /* Browse for stdin. */\r
 568         case IDC_BROWSE_STDIN:\r
 569           dlg = GetDlgItem(tab, IDC_STDIN);\r
 570           GetDlgItemText(tab, IDC_STDIN, buffer, _countof(buffer));\r
 571           browse(dlg, buffer, 0, NSSM_GUI_BROWSE_FILTER_ALL_FILES, 0);\r
 572           break;\r
 573 \r
 574         /* Browse for stdout. */\r
 575         case IDC_BROWSE_STDOUT:\r
 576           dlg = GetDlgItem(tab, IDC_STDOUT);\r
 577           GetDlgItemText(tab, IDC_STDOUT, buffer, _countof(buffer));\r
 578           browse(dlg, buffer, 0, NSSM_GUI_BROWSE_FILTER_ALL_FILES, 0);\r
 579           /* Fill in stderr if it wasn't already specified. */\r
 580           GetDlgItemText(tab, IDC_STDERR, buffer, _countof(buffer));\r
 581           if (! buffer[0]) {\r
 582             GetDlgItemText(tab, IDC_STDOUT, buffer, _countof(buffer));\r
 583             SetDlgItemText(tab, IDC_STDERR, buffer);\r
 584           }\r
 585           break;\r
 586 \r
 587         /* Browse for stderr. */\r
 588         case IDC_BROWSE_STDERR:\r
 589           dlg = GetDlgItem(tab, IDC_STDERR);\r
 590           GetDlgItemText(tab, IDC_STDERR, buffer, _countof(buffer));\r
 591           browse(dlg, buffer, 0, NSSM_GUI_BROWSE_FILTER_ALL_FILES, 0);\r
 592           break;\r
 593 \r
 594         /* Rotation. */\r
 595         case IDC_ROTATE:\r
 596           if (SendDlgItemMessage(tab, LOWORD(w), BM_GETCHECK, 0, 0) & BST_CHECKED) enabled = 1;\r
 597           else enabled = 0;\r
 598           set_rotation_enabled(enabled);\r
 599           break;\r
 600       }\r
 601       return 1;\r
 602   }\r
 603 \r
 604   return 0;\r
 605 }\r
 606 \r
 607 /* Install/remove dialogue callback */\r
 608 INT_PTR CALLBACK nssm_dlg(HWND window, UINT message, WPARAM w, LPARAM l) {\r
 609   switch (message) {\r
 610     /* Creating the dialogue */\r
 611     case WM_INITDIALOG:\r
 612       SetFocus(GetDlgItem(window, IDC_NAME));\r
 613 \r
 614       HWND tabs;\r
 615       HWND combo;\r
 616       tabs = GetDlgItem(window, IDC_TAB1);\r
 617       if (! tabs) return 0;\r
 618 \r
 619       /* Set up tabs. */\r
 620       TCITEM tab;\r
 621       ZeroMemory(&tab, sizeof(tab));\r
 622       tab.mask = TCIF_TEXT;\r
 623 \r
 624       /* Application tab. */\r
 625       tab.pszText = message_string(NSSM_GUI_TAB_APPLICATION);\r
 626       tab.cchTextMax = (int) _tcslen(tab.pszText);\r
 627       SendMessage(tabs, TCM_INSERTITEM, NSSM_TAB_APPLICATION, (LPARAM) &tab);\r
 628       tablist[NSSM_TAB_APPLICATION] = CreateDialog(0, MAKEINTRESOURCE(IDD_APPLICATION), window, tab_dlg);\r
 629       ShowWindow(tablist[NSSM_TAB_APPLICATION], SW_SHOW);\r
 630 \r
 631       /* Details tab. */\r
 632       tab.pszText = message_string(NSSM_GUI_TAB_DETAILS);\r
 633       tab.cchTextMax = (int) _tcslen(tab.pszText);\r
 634       SendMessage(tabs, TCM_INSERTITEM, NSSM_TAB_DETAILS, (LPARAM) &tab);\r
 635       tablist[NSSM_TAB_DETAILS] = CreateDialog(0, MAKEINTRESOURCE(IDD_DETAILS), window, tab_dlg);\r
 636       ShowWindow(tablist[NSSM_TAB_DETAILS], SW_HIDE);\r
 637 \r
 638       /* Set defaults. */\r
 639       combo = GetDlgItem(tablist[NSSM_TAB_DETAILS], IDC_STARTUP);\r
 640       SendMessage(combo, CB_INSERTSTRING, NSSM_STARTUP_AUTOMATIC, (LPARAM) message_string(NSSM_GUI_STARTUP_AUTOMATIC));\r
 641       SendMessage(combo, CB_INSERTSTRING, NSSM_STARTUP_DELAYED, (LPARAM) message_string(NSSM_GUI_STARTUP_DELAYED));\r
 642       SendMessage(combo, CB_INSERTSTRING, NSSM_STARTUP_MANUAL, (LPARAM) message_string(NSSM_GUI_STARTUP_MANUAL));\r
 643       SendMessage(combo, CB_INSERTSTRING, NSSM_STARTUP_DISABLED, (LPARAM) message_string(NSSM_GUI_STARTUP_DISABLED));\r
 644       SendMessage(combo, CB_SETCURSEL, NSSM_STARTUP_AUTOMATIC, 0);\r
 645 \r
 646       /* Logon tab. */\r
 647       tab.pszText = message_string(NSSM_GUI_TAB_LOGON);\r
 648       tab.cchTextMax = (int) _tcslen(tab.pszText);\r
 649       SendMessage(tabs, TCM_INSERTITEM, NSSM_TAB_LOGON, (LPARAM) &tab);\r
 650       tablist[NSSM_TAB_LOGON] = CreateDialog(0, MAKEINTRESOURCE(IDD_LOGON), window, tab_dlg);\r
 651       ShowWindow(tablist[NSSM_TAB_LOGON], SW_HIDE);\r
 652 \r
 653       /* Set defaults. */\r
 654       CheckRadioButton(tablist[NSSM_TAB_LOGON], IDC_LOCALSYSTEM, IDC_ACCOUNT, IDC_LOCALSYSTEM);\r
 655       set_logon_enabled(0);\r
 656 \r
 657       /* Shutdown tab. */\r
 658       tab.pszText = message_string(NSSM_GUI_TAB_SHUTDOWN);\r
 659       tab.cchTextMax = (int) _tcslen(tab.pszText);\r
 660       SendMessage(tabs, TCM_INSERTITEM, NSSM_TAB_SHUTDOWN, (LPARAM) &tab);\r
 661       tablist[NSSM_TAB_SHUTDOWN] = CreateDialog(0, MAKEINTRESOURCE(IDD_SHUTDOWN), window, tab_dlg);\r
 662       ShowWindow(tablist[NSSM_TAB_SHUTDOWN], SW_HIDE);\r
 663 \r
 664       /* Set defaults. */\r
 665       SendDlgItemMessage(tablist[NSSM_TAB_SHUTDOWN], IDC_METHOD_CONSOLE, BM_SETCHECK, BST_CHECKED, 0);\r
 666       SetDlgItemInt(tablist[NSSM_TAB_SHUTDOWN], IDC_KILL_CONSOLE, NSSM_KILL_CONSOLE_GRACE_PERIOD, 0);\r
 667       SendDlgItemMessage(tablist[NSSM_TAB_SHUTDOWN], IDC_METHOD_WINDOW, BM_SETCHECK, BST_CHECKED, 0);\r
 668       SetDlgItemInt(tablist[NSSM_TAB_SHUTDOWN], IDC_KILL_WINDOW, NSSM_KILL_WINDOW_GRACE_PERIOD, 0);\r
 669       SendDlgItemMessage(tablist[NSSM_TAB_SHUTDOWN], IDC_METHOD_THREADS, BM_SETCHECK, BST_CHECKED, 0);\r
 670       SetDlgItemInt(tablist[NSSM_TAB_SHUTDOWN], IDC_KILL_THREADS, NSSM_KILL_THREADS_GRACE_PERIOD, 0);\r
 671       SendDlgItemMessage(tablist[NSSM_TAB_SHUTDOWN], IDC_METHOD_TERMINATE, BM_SETCHECK, BST_CHECKED, 0);\r
 672 \r
 673       /* Restart tab. */\r
 674       tab.pszText = message_string(NSSM_GUI_TAB_EXIT);\r
 675       tab.cchTextMax = (int) _tcslen(tab.pszText);\r
 676       SendMessage(tabs, TCM_INSERTITEM, NSSM_TAB_EXIT, (LPARAM) &tab);\r
 677       tablist[NSSM_TAB_EXIT] = CreateDialog(0, MAKEINTRESOURCE(IDD_APPEXIT), window, tab_dlg);\r
 678       ShowWindow(tablist[NSSM_TAB_EXIT], SW_HIDE);\r
 679 \r
 680       /* Set defaults. */\r
 681       SetDlgItemInt(tablist[NSSM_TAB_EXIT], IDC_THROTTLE, NSSM_RESET_THROTTLE_RESTART, 0);\r
 682       combo = GetDlgItem(tablist[NSSM_TAB_EXIT], IDC_APPEXIT);\r
 683       SendMessage(combo, CB_INSERTSTRING, NSSM_EXIT_RESTART, (LPARAM) message_string(NSSM_GUI_EXIT_RESTART));\r
 684       SendMessage(combo, CB_INSERTSTRING, NSSM_EXIT_IGNORE, (LPARAM) message_string(NSSM_GUI_EXIT_IGNORE));\r
 685       SendMessage(combo, CB_INSERTSTRING, NSSM_EXIT_REALLY, (LPARAM) message_string(NSSM_GUI_EXIT_REALLY));\r
 686       SendMessage(combo, CB_INSERTSTRING, NSSM_EXIT_UNCLEAN, (LPARAM) message_string(NSSM_GUI_EXIT_UNCLEAN));\r
 687       SendMessage(combo, CB_SETCURSEL, NSSM_EXIT_RESTART, 0);\r
 688 \r
 689       /* I/O tab. */\r
 690       tab.pszText = message_string(NSSM_GUI_TAB_IO);\r
 691       tab.cchTextMax = (int) _tcslen(tab.pszText) + 1;\r
 692       SendMessage(tabs, TCM_INSERTITEM, NSSM_TAB_IO, (LPARAM) &tab);\r
 693       tablist[NSSM_TAB_IO] = CreateDialog(0, MAKEINTRESOURCE(IDD_IO), window, tab_dlg);\r
 694       ShowWindow(tablist[NSSM_TAB_IO], SW_HIDE);\r
 695 \r
 696       /* Rotation tab. */\r
 697       tab.pszText = message_string(NSSM_GUI_TAB_ROTATION);\r
 698       tab.cchTextMax = (int) _tcslen(tab.pszText) + 1;\r
 699       SendMessage(tabs, TCM_INSERTITEM, NSSM_TAB_ROTATION, (LPARAM) &tab);\r
 700       tablist[NSSM_TAB_ROTATION] = CreateDialog(0, MAKEINTRESOURCE(IDD_ROTATION), window, tab_dlg);\r
 701       ShowWindow(tablist[NSSM_TAB_ROTATION], SW_HIDE);\r
 702 \r
 703       /* Set defaults. */\r
 704       SetDlgItemInt(tablist[NSSM_TAB_ROTATION], IDC_ROTATE_SECONDS, 0, 0);\r
 705       SetDlgItemInt(tablist[NSSM_TAB_ROTATION], IDC_ROTATE_BYTES_LOW, 0, 0);\r
 706       set_rotation_enabled(0);\r
 707 \r
 708       /* Environment tab. */\r
 709       tab.pszText = message_string(NSSM_GUI_TAB_ENVIRONMENT);\r
 710       tab.cchTextMax = (int) _tcslen(tab.pszText) + 1;\r
 711       SendMessage(tabs, TCM_INSERTITEM, NSSM_TAB_ENVIRONMENT, (LPARAM) &tab);\r
 712       tablist[NSSM_TAB_ENVIRONMENT] = CreateDialog(0, MAKEINTRESOURCE(IDD_ENVIRONMENT), window, tab_dlg);\r
 713       ShowWindow(tablist[NSSM_TAB_ENVIRONMENT], SW_HIDE);\r
 714 \r
 715       selected_tab = 0;\r
 716 \r
 717       return 1;\r
 718 \r
 719     /* Tab change. */\r
 720     case WM_NOTIFY:\r
 721       NMHDR *notification;\r
 722 \r
 723       notification = (NMHDR *) l;\r
 724       switch (notification->code) {\r
 725         case TCN_SELCHANGE:\r
 726           HWND tabs;\r
 727           int selection;\r
 728 \r
 729           tabs = GetDlgItem(window, IDC_TAB1);\r
 730           if (! tabs) return 0;\r
 731 \r
 732           selection = (int) SendMessage(tabs, TCM_GETCURSEL, 0, 0);\r
 733           if (selection != selected_tab) {\r
 734             ShowWindow(tablist[selected_tab], SW_HIDE);\r
 735             /*\r
 736               XXX: Sets focus to the service name which isn't ideal but is\r
 737                    better than leaving it in another tab.\r
 738             */\r
 739             ShowWindow(tablist[selection], SW_SHOWDEFAULT);\r
 740             SetFocus(tablist[selection]);\r
 741             selected_tab = selection;\r
 742           }\r
 743           return 1;\r
 744       }\r
 745 \r
 746       return 0;\r
 747 \r
 748     /* Button was pressed or control was controlled */\r
 749     case WM_COMMAND:\r
 750       switch (LOWORD(w)) {\r
 751         /* OK button */\r
 752         case IDOK:\r
 753           if (! install(window)) PostQuitMessage(0);\r
 754           break;\r
 755 \r
 756         /* Cancel button */\r
 757         case IDCANCEL:\r
 758           DestroyWindow(window);\r
 759           break;\r
 760 \r
 761         /* Remove button */\r
 762         case IDC_REMOVE:\r
 763           if (! remove(window)) PostQuitMessage(0);\r
 764           break;\r
 765       }\r
 766       return 1;\r
 767 \r
 768     /* Window closing */\r
 769     case WM_CLOSE:\r
 770       DestroyWindow(window);\r
 771       return 0;\r
 772     case WM_DESTROY:\r
 773       PostQuitMessage(0);\r
 774   }\r
 775   return 0;\r
 776 }\r