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