gui.cpp

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