gui.cpp 46 KB

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