gui.cpp 56 KB

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