service.cpp 67 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889
  1. #include "nssm.h"
  2. /* This is explicitly a wide string. */
  3. #define NSSM_LOGON_AS_SERVICE_RIGHT L"SeServiceLogonRight"
  4. bool is_admin;
  5. bool use_critical_section;
  6. extern imports_t imports;
  7. extern settings_t settings[];
  8. const TCHAR *exit_action_strings[] = { _T("Restart"), _T("Ignore"), _T("Exit"), _T("Suicide"), 0 };
  9. const TCHAR *startup_strings[] = { _T("SERVICE_AUTO_START"), _T("SERVICE_DELAYED_AUTO_START"), _T("SERVICE_DEMAND_START"), _T("SERVICE_DISABLED"), 0 };
  10. const TCHAR *priority_strings[] = { _T("REALTIME_PRIORITY_CLASS"), _T("HIGH_PRIORITY_CLASS"), _T("ABOVE_NORMAL_PRIORITY_CLASS"), _T("NORMAL_PRIORITY_CLASS"), _T("BELOW_NORMAL_PRIORITY_CLASS"), _T("IDLE_PRIORITY_CLASS"), 0 };
  11. typedef struct {
  12. int first;
  13. int last;
  14. } list_t;
  15. /*
  16. Check the status in response to a control.
  17. Returns: 1 if the status is expected, eg STOP following CONTROL_STOP.
  18. 0 if the status is desired, eg STOPPED following CONTROL_STOP.
  19. -1 if the status is undesired, eg STOPPED following CONTROL_START.
  20. */
  21. static inline int service_control_response(unsigned long control, unsigned long status) {
  22. switch (control) {
  23. case NSSM_SERVICE_CONTROL_START:
  24. switch (status) {
  25. case SERVICE_START_PENDING:
  26. return 1;
  27. case SERVICE_RUNNING:
  28. return 0;
  29. default:
  30. return -1;
  31. }
  32. case SERVICE_CONTROL_STOP:
  33. case SERVICE_CONTROL_SHUTDOWN:
  34. switch (status) {
  35. case SERVICE_STOP_PENDING:
  36. return 1;
  37. case SERVICE_STOPPED:
  38. return 0;
  39. default:
  40. return -1;
  41. }
  42. case SERVICE_CONTROL_PAUSE:
  43. switch (status) {
  44. case SERVICE_PAUSE_PENDING:
  45. return 1;
  46. case SERVICE_PAUSED:
  47. return 0;
  48. default:
  49. return -1;
  50. }
  51. case SERVICE_CONTROL_CONTINUE:
  52. switch (status) {
  53. case SERVICE_CONTINUE_PENDING:
  54. return 1;
  55. case SERVICE_RUNNING:
  56. return 0;
  57. default:
  58. return -1;
  59. }
  60. case SERVICE_CONTROL_INTERROGATE:
  61. return 0;
  62. }
  63. return 0;
  64. }
  65. static inline int await_service_control_response(unsigned long control, SC_HANDLE service_handle, SERVICE_STATUS *service_status, unsigned long initial_status) {
  66. int tries = 0;
  67. while (QueryServiceStatus(service_handle, service_status)) {
  68. int response = service_control_response(control, service_status->dwCurrentState);
  69. /* Alas we can't WaitForSingleObject() on an SC_HANDLE. */
  70. if (! response) return response;
  71. if (response > 0 || service_status->dwCurrentState == initial_status) {
  72. if (++tries > 10) return response;
  73. Sleep(50 * tries);
  74. }
  75. else return response;
  76. }
  77. return -1;
  78. }
  79. int affinity_mask_to_string(__int64 mask, TCHAR **string) {
  80. if (! string) return 1;
  81. if (! mask) {
  82. *string = 0;
  83. return 0;
  84. }
  85. __int64 i, n;
  86. /* SetProcessAffinityMask() accepts a mask of up to 64 processors. */
  87. list_t set[64];
  88. for (n = 0; n < _countof(set); n++) set[n].first = set[n].last = -1;
  89. for (i = 0, n = 0; i < _countof(set); i++) {
  90. if (mask & (1LL << i)) {
  91. if (set[n].first == -1) set[n].first = set[n].last = (int) i;
  92. else if (set[n].last == (int) i - 1) set[n].last = (int) i;
  93. else {
  94. n++;
  95. set[n].first = set[n].last = (int) i;
  96. }
  97. }
  98. }
  99. /* Worst case is 2x2 characters for first and last CPU plus - and/or , */
  100. size_t len = (size_t) (n + 1) * 6;
  101. *string = (TCHAR *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(TCHAR));
  102. if (! string) return 2;
  103. size_t s = 0;
  104. int ret;
  105. for (i = 0; i <= n; i++) {
  106. if (i) (*string)[s++] = _T(',');
  107. ret = _sntprintf_s(*string + s, 3, _TRUNCATE, _T("%u"), set[i].first);
  108. if (ret < 0) {
  109. HeapFree(GetProcessHeap(), 0, *string);
  110. *string = 0;
  111. return 3;
  112. }
  113. else s += ret;
  114. if (set[i].last != set[i].first) {
  115. ret =_sntprintf_s(*string + s, 4, _TRUNCATE, _T("%c%u"), (set[i].last == set[i].first + 1) ? _T(',') : _T('-'), set[i].last);
  116. if (ret < 0) {
  117. HeapFree(GetProcessHeap(), 0, *string);
  118. *string = 0;
  119. return 4;
  120. }
  121. else s += ret;
  122. }
  123. }
  124. return 0;
  125. }
  126. int affinity_string_to_mask(TCHAR *string, __int64 *mask) {
  127. if (! mask) return 1;
  128. *mask = 0LL;
  129. if (! string) return 0;
  130. list_t set[64];
  131. TCHAR *s = string;
  132. TCHAR *end;
  133. int ret;
  134. int i;
  135. int n = 0;
  136. unsigned long number;
  137. for (n = 0; n < _countof(set); n++) set[n].first = set[n].last = -1;
  138. n = 0;
  139. while (*s) {
  140. ret = str_number(s, &number, &end);
  141. s = end;
  142. if (ret == 0 || ret == 2) {
  143. if (number >= _countof(set)) return 2;
  144. set[n].first = set[n].last = (int) number;
  145. switch (*s) {
  146. case 0:
  147. break;
  148. case _T(','):
  149. n++;
  150. s++;
  151. break;
  152. case _T('-'):
  153. if (! *(++s)) return 3;
  154. ret = str_number(s, &number, &end);
  155. if (ret == 0 || ret == 2) {
  156. s = end;
  157. if (! *s || *s == _T(',')) {
  158. set[n].last = (int) number;
  159. if (! *s) break;
  160. n++;
  161. s++;
  162. }
  163. else return 3;
  164. }
  165. else return 3;
  166. break;
  167. default:
  168. return 3;
  169. }
  170. }
  171. else return 4;
  172. }
  173. for (i = 0; i <= n; i++) {
  174. for (int j = set[i].first; j <= set[i].last; j++) (__int64) *mask |= (1LL << (__int64) j);
  175. }
  176. return 0;
  177. }
  178. inline unsigned long priority_mask() {
  179. return REALTIME_PRIORITY_CLASS | HIGH_PRIORITY_CLASS | ABOVE_NORMAL_PRIORITY_CLASS | NORMAL_PRIORITY_CLASS | BELOW_NORMAL_PRIORITY_CLASS | IDLE_PRIORITY_CLASS;
  180. }
  181. int priority_constant_to_index(unsigned long constant) {
  182. switch (constant & priority_mask()) {
  183. case REALTIME_PRIORITY_CLASS: return NSSM_REALTIME_PRIORITY;
  184. case HIGH_PRIORITY_CLASS: return NSSM_HIGH_PRIORITY;
  185. case ABOVE_NORMAL_PRIORITY_CLASS: return NSSM_ABOVE_NORMAL_PRIORITY;
  186. case BELOW_NORMAL_PRIORITY_CLASS: return NSSM_BELOW_NORMAL_PRIORITY;
  187. case IDLE_PRIORITY_CLASS: return NSSM_IDLE_PRIORITY;
  188. }
  189. return NSSM_NORMAL_PRIORITY;
  190. }
  191. unsigned long priority_index_to_constant(int index) {
  192. switch (index) {
  193. case NSSM_REALTIME_PRIORITY: return REALTIME_PRIORITY_CLASS;
  194. case NSSM_HIGH_PRIORITY: return HIGH_PRIORITY_CLASS;
  195. case NSSM_ABOVE_NORMAL_PRIORITY: return ABOVE_NORMAL_PRIORITY_CLASS;
  196. case NSSM_BELOW_NORMAL_PRIORITY: return BELOW_NORMAL_PRIORITY_CLASS;
  197. case NSSM_IDLE_PRIORITY: return IDLE_PRIORITY_CLASS;
  198. }
  199. return NORMAL_PRIORITY_CLASS;
  200. }
  201. static inline unsigned long throttle_milliseconds(unsigned long throttle) {
  202. /* pow() operates on doubles. */
  203. unsigned long ret = 1; for (unsigned long i = 1; i < throttle; i++) ret *= 2;
  204. return ret * 1000;
  205. }
  206. /*
  207. Wrapper to be called in a new thread so that we can acknowledge a STOP
  208. control immediately.
  209. */
  210. static unsigned long WINAPI shutdown_service(void *arg) {
  211. return stop_service((nssm_service_t *) arg, 0, true, true);
  212. }
  213. /* Connect to the service manager */
  214. SC_HANDLE open_service_manager() {
  215. SC_HANDLE ret = OpenSCManager(0, SERVICES_ACTIVE_DATABASE, SC_MANAGER_ALL_ACCESS);
  216. if (! ret) {
  217. if (is_admin) log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OPENSCMANAGER_FAILED, 0);
  218. return 0;
  219. }
  220. return ret;
  221. }
  222. /* Open a service by name or display name. */
  223. SC_HANDLE open_service(SC_HANDLE services, TCHAR *service_name, TCHAR *canonical_name, unsigned long canonical_namelen) {
  224. SC_HANDLE service_handle = OpenService(services, service_name, SERVICE_ALL_ACCESS);
  225. if (service_handle) {
  226. if (canonical_name && canonical_name != service_name) {
  227. if (_sntprintf_s(canonical_name, canonical_namelen, _TRUNCATE, _T("%s"), service_name) < 0) {
  228. print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("canonical_name"), _T("open_service()"));
  229. return 0;
  230. }
  231. }
  232. return service_handle;
  233. }
  234. unsigned long error = GetLastError();
  235. if (error != ERROR_SERVICE_DOES_NOT_EXIST) {
  236. print_message(stderr, NSSM_MESSAGE_OPENSERVICE_FAILED, error_string(GetLastError()));
  237. return 0;
  238. }
  239. /* We can't look for a display name because there's no buffer to store it. */
  240. if (! canonical_name) {
  241. print_message(stderr, NSSM_MESSAGE_OPENSERVICE_FAILED, error_string(GetLastError()));
  242. return 0;
  243. }
  244. unsigned long bufsize, required, count, i;
  245. unsigned long resume = 0;
  246. EnumServicesStatus(services, SERVICE_DRIVER | SERVICE_FILE_SYSTEM_DRIVER | SERVICE_KERNEL_DRIVER | SERVICE_WIN32, SERVICE_STATE_ALL, 0, 0, &required, &count, &resume);
  247. error = GetLastError();
  248. if (error != ERROR_MORE_DATA) {
  249. print_message(stderr, NSSM_MESSAGE_ENUMSERVICESSTATUS_FAILED, error_string(GetLastError()));
  250. return 0;
  251. }
  252. ENUM_SERVICE_STATUS *status = (ENUM_SERVICE_STATUS *) HeapAlloc(GetProcessHeap(), 0, required);
  253. if (! status) {
  254. print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("ENUM_SERVICE_STATUS"), _T("open_service()"));
  255. return 0;
  256. }
  257. bufsize = required;
  258. while (true) {
  259. /*
  260. EnumServicesStatus() returns:
  261. 1 when it retrieved data and there's no more data to come.
  262. 0 and sets last error to ERROR_MORE_DATA when it retrieved data and
  263. there's more data to come.
  264. 0 and sets last error to something else on error.
  265. */
  266. int ret = EnumServicesStatus(services, SERVICE_DRIVER | SERVICE_FILE_SYSTEM_DRIVER | SERVICE_KERNEL_DRIVER | SERVICE_WIN32, SERVICE_STATE_ALL, status, bufsize, &required, &count, &resume);
  267. if (! ret) {
  268. error = GetLastError();
  269. if (error != ERROR_MORE_DATA) {
  270. HeapFree(GetProcessHeap(), 0, status);
  271. print_message(stderr, NSSM_MESSAGE_ENUMSERVICESSTATUS_FAILED, error_string(GetLastError()));
  272. return 0;
  273. }
  274. }
  275. for (i = 0; i < count; i++) {
  276. if (str_equiv(status[i].lpDisplayName, service_name)) {
  277. if (_sntprintf_s(canonical_name, canonical_namelen, _TRUNCATE, _T("%s"), status[i].lpServiceName) < 0) {
  278. HeapFree(GetProcessHeap(), 0, status);
  279. print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("canonical_name"), _T("open_service()"));
  280. return 0;
  281. }
  282. HeapFree(GetProcessHeap(), 0, status);
  283. return open_service(services, canonical_name, 0, 0);
  284. }
  285. }
  286. if (ret) break;
  287. }
  288. /* Recurse so we can get an error message. */
  289. return open_service(services, service_name, 0, 0);
  290. }
  291. QUERY_SERVICE_CONFIG *query_service_config(const TCHAR *service_name, SC_HANDLE service_handle) {
  292. QUERY_SERVICE_CONFIG *qsc;
  293. unsigned long bufsize;
  294. unsigned long error;
  295. QueryServiceConfig(service_handle, 0, 0, &bufsize);
  296. error = GetLastError();
  297. if (error == ERROR_INSUFFICIENT_BUFFER) {
  298. qsc = (QUERY_SERVICE_CONFIG *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bufsize);
  299. if (! qsc) {
  300. print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("QUERY_SERVICE_CONFIG"), _T("query_service_config()"), 0);
  301. return 0;
  302. }
  303. }
  304. else {
  305. print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG_FAILED, service_name, error_string(error), 0);
  306. return 0;
  307. }
  308. if (! QueryServiceConfig(service_handle, qsc, bufsize, &bufsize)) {
  309. HeapFree(GetProcessHeap(), 0, qsc);
  310. print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG_FAILED, service_name, error_string(GetLastError()), 0);
  311. return 0;
  312. }
  313. return qsc;
  314. }
  315. int set_service_description(const TCHAR *service_name, SC_HANDLE service_handle, TCHAR *buffer) {
  316. SERVICE_DESCRIPTION description;
  317. ZeroMemory(&description, sizeof(description));
  318. /*
  319. lpDescription must be NULL if we aren't changing, the new description
  320. or "".
  321. */
  322. if (buffer && buffer[0]) description.lpDescription = buffer;
  323. else description.lpDescription = _T("");
  324. if (ChangeServiceConfig2(service_handle, SERVICE_CONFIG_DESCRIPTION, &description)) return 0;
  325. log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SERVICE_CONFIG_DESCRIPTION_FAILED, service_name, error_string(GetLastError()), 0);
  326. return 1;
  327. }
  328. int get_service_description(const TCHAR *service_name, SC_HANDLE service_handle, unsigned long len, TCHAR *buffer) {
  329. if (! buffer) return 1;
  330. unsigned long bufsize;
  331. QueryServiceConfig2(service_handle, SERVICE_CONFIG_DESCRIPTION, 0, 0, &bufsize);
  332. unsigned long error = GetLastError();
  333. if (error == ERROR_INSUFFICIENT_BUFFER) {
  334. SERVICE_DESCRIPTION *description = (SERVICE_DESCRIPTION *) HeapAlloc(GetProcessHeap(), 0, bufsize);
  335. if (! description) {
  336. print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("SERVICE_CONFIG_DESCRIPTION"), _T("get_service_description()"));
  337. return 2;
  338. }
  339. if (QueryServiceConfig2(service_handle, SERVICE_CONFIG_DESCRIPTION, (unsigned char *) description, bufsize, &bufsize)) {
  340. if (description->lpDescription) _sntprintf_s(buffer, len, _TRUNCATE, _T("%s"), description->lpDescription);
  341. else ZeroMemory(buffer, len * sizeof(TCHAR));
  342. HeapFree(GetProcessHeap(), 0, description);
  343. return 0;
  344. }
  345. else {
  346. HeapFree(GetProcessHeap(), 0, description);
  347. print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG2_FAILED, service_name, _T("SERVICE_CONFIG_DESCRIPTION"), error_string(error));
  348. return 3;
  349. }
  350. }
  351. else {
  352. print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG2_FAILED, service_name, _T("SERVICE_CONFIG_DESCRIPTION"), error_string(error));
  353. return 4;
  354. }
  355. return 0;
  356. }
  357. int get_service_startup(const TCHAR *service_name, SC_HANDLE service_handle, const QUERY_SERVICE_CONFIG *qsc, unsigned long *startup) {
  358. if (! qsc) return 1;
  359. switch (qsc->dwStartType) {
  360. case SERVICE_DEMAND_START: *startup = NSSM_STARTUP_MANUAL; break;
  361. case SERVICE_DISABLED: *startup = NSSM_STARTUP_DISABLED; break;
  362. default: *startup = NSSM_STARTUP_AUTOMATIC;
  363. }
  364. if (*startup != NSSM_STARTUP_AUTOMATIC) return 0;
  365. /* Check for delayed start. */
  366. unsigned long bufsize;
  367. unsigned long error;
  368. QueryServiceConfig2(service_handle, SERVICE_CONFIG_DELAYED_AUTO_START_INFO, 0, 0, &bufsize);
  369. error = GetLastError();
  370. if (error == ERROR_INSUFFICIENT_BUFFER) {
  371. SERVICE_DELAYED_AUTO_START_INFO *info = (SERVICE_DELAYED_AUTO_START_INFO *) HeapAlloc(GetProcessHeap(), 0, bufsize);
  372. if (! info) {
  373. print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("SERVICE_DELAYED_AUTO_START_INFO"), _T("get_service_startup()"));
  374. return 2;
  375. }
  376. if (QueryServiceConfig2(service_handle, SERVICE_CONFIG_DELAYED_AUTO_START_INFO, (unsigned char *) info, bufsize, &bufsize)) {
  377. if (info->fDelayedAutostart) *startup = NSSM_STARTUP_DELAYED;
  378. HeapFree(GetProcessHeap(), 0, info);
  379. return 0;
  380. }
  381. else {
  382. error = GetLastError();
  383. if (error != ERROR_INVALID_LEVEL) {
  384. print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG2_FAILED, service_name, _T("SERVICE_CONFIG_DELAYED_AUTO_START_INFO"), error_string(error));
  385. return 3;
  386. }
  387. }
  388. }
  389. else if (error != ERROR_INVALID_LEVEL) {
  390. print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG2_FAILED, service_name, _T("SERVICE_DELAYED_AUTO_START_INFO"), error_string(error));
  391. return 3;
  392. }
  393. return 0;
  394. }
  395. int get_service_username(const TCHAR *service_name, const QUERY_SERVICE_CONFIG *qsc, TCHAR **username, size_t *usernamelen) {
  396. if (! username) return 1;
  397. if (! usernamelen) return 1;
  398. *username = 0;
  399. *usernamelen = 0;
  400. if (! qsc) return 1;
  401. if (str_equiv(qsc->lpServiceStartName, NSSM_LOCALSYSTEM_ACCOUNT)) return 0;
  402. size_t len = _tcslen(qsc->lpServiceStartName);
  403. *username = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(TCHAR));
  404. if (! *username) {
  405. print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("username"), _T("get_service_username()"));
  406. return 2;
  407. }
  408. memmove(*username, qsc->lpServiceStartName, (len + 1) * sizeof(TCHAR));
  409. *usernamelen = len;
  410. return 0;
  411. }
  412. int grant_logon_as_service(const TCHAR *username) {
  413. if (! username) return 0;
  414. if (str_equiv(username, NSSM_LOCALSYSTEM_ACCOUNT)) return 0;
  415. /* Open Policy object. */
  416. LSA_OBJECT_ATTRIBUTES attributes;
  417. ZeroMemory(&attributes, sizeof(attributes));
  418. LSA_HANDLE policy;
  419. NTSTATUS status = LsaOpenPolicy(0, &attributes, POLICY_ALL_ACCESS, &policy);
  420. if (status) {
  421. print_message(stderr, NSSM_MESSAGE_LSAOPENPOLICY_FAILED, error_string(LsaNtStatusToWinError(status)));
  422. return 1;
  423. }
  424. /* Look up SID for the account. */
  425. LSA_UNICODE_STRING lsa_username;
  426. #ifdef UNICODE
  427. lsa_username.Buffer = (wchar_t *) username;
  428. lsa_username.Length = (unsigned short) _tcslen(username) * sizeof(TCHAR);
  429. lsa_username.MaximumLength = lsa_username.Length + sizeof(TCHAR);
  430. #else
  431. size_t buflen;
  432. mbstowcs_s(&buflen, NULL, 0, username, _TRUNCATE);
  433. lsa_username.MaximumLength = (unsigned short) buflen * sizeof(wchar_t);
  434. lsa_username.Length = lsa_username.MaximumLength - sizeof(wchar_t);
  435. lsa_username.Buffer = (wchar_t *) HeapAlloc(GetProcessHeap(), 0, lsa_username.MaximumLength);
  436. if (lsa_username.Buffer) mbstowcs_s(&buflen, lsa_username.Buffer, lsa_username.MaximumLength, username, _TRUNCATE);
  437. else {
  438. LsaClose(policy);
  439. print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("LSA_UNICODE_STRING"), _T("grant_logon_as_service()"));
  440. return 2;
  441. }
  442. #endif
  443. LSA_REFERENCED_DOMAIN_LIST *translated_domains;
  444. LSA_TRANSLATED_SID *translated_sid;
  445. status = LsaLookupNames(policy, 1, &lsa_username, &translated_domains, &translated_sid);
  446. #ifndef UNICODE
  447. HeapFree(GetProcessHeap(), 0, lsa_username.Buffer);
  448. #endif
  449. if (status) {
  450. LsaFreeMemory(translated_domains);
  451. LsaFreeMemory(translated_sid);
  452. LsaClose(policy);
  453. print_message(stderr, NSSM_MESSAGE_LSALOOKUPNAMES_FAILED, username, error_string(LsaNtStatusToWinError(status)));
  454. return 3;
  455. }
  456. if (translated_sid->Use != SidTypeUser) {
  457. LsaFreeMemory(translated_domains);
  458. LsaFreeMemory(translated_sid);
  459. LsaClose(policy);
  460. print_message(stderr, NSSM_GUI_INVALID_USERNAME, username);
  461. return 4;
  462. }
  463. LSA_TRUST_INFORMATION *trust = &translated_domains->Domains[translated_sid->DomainIndex];
  464. if (! trust || ! IsValidSid(trust->Sid)) {
  465. LsaFreeMemory(translated_domains);
  466. LsaFreeMemory(translated_sid);
  467. LsaClose(policy);
  468. print_message(stderr, NSSM_GUI_INVALID_USERNAME, username);
  469. return 4;
  470. }
  471. /* GetSidSubAuthority*() return pointers! */
  472. unsigned char *n = GetSidSubAuthorityCount(trust->Sid);
  473. /* Convert translated SID to SID. */
  474. SID *sid = (SID *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, GetSidLengthRequired(*n + 1));
  475. if (! sid) {
  476. LsaFreeMemory(translated_domains);
  477. LsaFreeMemory(translated_sid);
  478. LsaClose(policy);
  479. print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("SID"), _T("grant_logon_as_service"));
  480. return 4;
  481. }
  482. unsigned long error;
  483. if (! InitializeSid(sid, GetSidIdentifierAuthority(trust->Sid), *n + 1)) {
  484. error = GetLastError();
  485. HeapFree(GetProcessHeap(), 0, sid);
  486. LsaFreeMemory(translated_domains);
  487. LsaFreeMemory(translated_sid);
  488. LsaClose(policy);
  489. print_message(stderr, NSSM_MESSAGE_INITIALIZESID_FAILED, username, error_string(error));
  490. return 5;
  491. }
  492. for (unsigned char i = 0; i <= *n; i++) {
  493. unsigned long *sub = GetSidSubAuthority(sid, i);
  494. if (i < *n) *sub = *GetSidSubAuthority(trust->Sid, i);
  495. else *sub = translated_sid->RelativeId;
  496. }
  497. LsaFreeMemory(translated_domains);
  498. LsaFreeMemory(translated_sid);
  499. /* Check if the SID has the "Log on as a service" right. */
  500. LSA_UNICODE_STRING lsa_right;
  501. lsa_right.Buffer = NSSM_LOGON_AS_SERVICE_RIGHT;
  502. lsa_right.Length = (unsigned short) wcslen(lsa_right.Buffer) * sizeof(wchar_t);
  503. lsa_right.MaximumLength = lsa_right.Length + sizeof(wchar_t);
  504. LSA_UNICODE_STRING *rights;
  505. unsigned long count = ~0;
  506. status = LsaEnumerateAccountRights(policy, sid, &rights, &count);
  507. if (status) {
  508. /*
  509. If the account has no rights set LsaEnumerateAccountRights() will return
  510. STATUS_OBJECT_NAME_NOT_FOUND and set count to 0.
  511. */
  512. error = LsaNtStatusToWinError(status);
  513. if (error != ERROR_FILE_NOT_FOUND) {
  514. HeapFree(GetProcessHeap(), 0, sid);
  515. LsaClose(policy);
  516. print_message(stderr, NSSM_MESSAGE_LSAENUMERATEACCOUNTRIGHTS_FAILED, username, error_string(error));
  517. return 4;
  518. }
  519. }
  520. for (unsigned long i = 0; i < count; i++) {
  521. if (rights[i].Length != lsa_right.Length) continue;
  522. if (_wcsnicmp(rights[i].Buffer, lsa_right.Buffer, lsa_right.MaximumLength)) continue;
  523. /* The SID has the right. */
  524. HeapFree(GetProcessHeap(), 0, sid);
  525. LsaFreeMemory(rights);
  526. LsaClose(policy);
  527. return 0;
  528. }
  529. LsaFreeMemory(rights);
  530. /* Add the right. */
  531. status = LsaAddAccountRights(policy, sid, &lsa_right, 1);
  532. HeapFree(GetProcessHeap(), 0, sid);
  533. LsaClose(policy);
  534. if (status) {
  535. print_message(stderr, NSSM_MESSAGE_LSAADDACCOUNTRIGHTS_FAILED, error_string(LsaNtStatusToWinError(status)));
  536. return 5;
  537. }
  538. print_message(stdout, NSSM_MESSAGE_GRANTED_LOGON_AS_SERVICE, username);
  539. return 0;
  540. }
  541. /* Set default values which aren't zero. */
  542. void set_nssm_service_defaults(nssm_service_t *service) {
  543. if (! service) return;
  544. service->type = SERVICE_WIN32_OWN_PROCESS;
  545. service->priority = NORMAL_PRIORITY_CLASS;
  546. service->stdin_sharing = NSSM_STDIN_SHARING;
  547. service->stdin_disposition = NSSM_STDIN_DISPOSITION;
  548. service->stdin_flags = NSSM_STDIN_FLAGS;
  549. service->stdout_sharing = NSSM_STDOUT_SHARING;
  550. service->stdout_disposition = NSSM_STDOUT_DISPOSITION;
  551. service->stdout_flags = NSSM_STDOUT_FLAGS;
  552. service->stderr_sharing = NSSM_STDERR_SHARING;
  553. service->stderr_disposition = NSSM_STDERR_DISPOSITION;
  554. service->stderr_flags = NSSM_STDERR_FLAGS;
  555. service->throttle_delay = NSSM_RESET_THROTTLE_RESTART;
  556. service->stop_method = ~0;
  557. service->kill_console_delay = NSSM_KILL_CONSOLE_GRACE_PERIOD;
  558. service->kill_window_delay = NSSM_KILL_WINDOW_GRACE_PERIOD;
  559. service->kill_threads_delay = NSSM_KILL_THREADS_GRACE_PERIOD;
  560. }
  561. /* Allocate and zero memory for a service. */
  562. nssm_service_t *alloc_nssm_service() {
  563. nssm_service_t *service = (nssm_service_t *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(nssm_service_t));
  564. if (! service) log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, _T("service"), _T("alloc_nssm_service()"), 0);
  565. return service;
  566. }
  567. /* Free memory for a service. */
  568. void cleanup_nssm_service(nssm_service_t *service) {
  569. if (! service) return;
  570. if (service->username) HeapFree(GetProcessHeap(), 0, service->username);
  571. if (service->password) {
  572. SecureZeroMemory(service->password, service->passwordlen);
  573. HeapFree(GetProcessHeap(), 0, service->password);
  574. }
  575. if (service->env) HeapFree(GetProcessHeap(), 0, service->env);
  576. if (service->env_extra) HeapFree(GetProcessHeap(), 0, service->env_extra);
  577. if (service->handle) CloseServiceHandle(service->handle);
  578. if (service->process_handle) CloseHandle(service->process_handle);
  579. if (service->wait_handle) UnregisterWait(service->process_handle);
  580. if (service->throttle_section_initialised) DeleteCriticalSection(&service->throttle_section);
  581. if (service->throttle_timer) CloseHandle(service->throttle_timer);
  582. if (service->initial_env) FreeEnvironmentStrings(service->initial_env);
  583. HeapFree(GetProcessHeap(), 0, service);
  584. }
  585. /* About to install the service */
  586. int pre_install_service(int argc, TCHAR **argv) {
  587. nssm_service_t *service = alloc_nssm_service();
  588. set_nssm_service_defaults(service);
  589. if (argc) _sntprintf_s(service->name, _countof(service->name), _TRUNCATE, _T("%s"), argv[0]);
  590. /* Show the dialogue box if we didn't give the service name and path */
  591. if (argc < 2) return nssm_gui(IDD_INSTALL, service);
  592. if (! service) {
  593. print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("service"), _T("pre_install_service()"));
  594. return 1;
  595. }
  596. _sntprintf_s(service->exe, _countof(service->exe), _TRUNCATE, _T("%s"), argv[1]);
  597. /* Arguments are optional */
  598. size_t flagslen = 0;
  599. size_t s = 0;
  600. int i;
  601. for (i = 2; i < argc; i++) flagslen += _tcslen(argv[i]) + 1;
  602. if (! flagslen) flagslen = 1;
  603. if (flagslen > _countof(service->flags)) {
  604. print_message(stderr, NSSM_MESSAGE_FLAGS_TOO_LONG);
  605. return 2;
  606. }
  607. for (i = 2; i < argc; i++) {
  608. size_t len = _tcslen(argv[i]);
  609. memmove(service->flags + s, argv[i], len * sizeof(TCHAR));
  610. s += len;
  611. if (i < argc - 1) service->flags[s++] = _T(' ');
  612. }
  613. /* Work out directory name */
  614. _sntprintf_s(service->dir, _countof(service->dir), _TRUNCATE, _T("%s"), service->exe);
  615. strip_basename(service->dir);
  616. int ret = install_service(service);
  617. cleanup_nssm_service(service);
  618. return ret;
  619. }
  620. /* About to edit the service. */
  621. int pre_edit_service(int argc, TCHAR **argv) {
  622. /* Require service name. */
  623. if (argc < 2) return usage(1);
  624. /* Are we editing on the command line? */
  625. enum { MODE_EDITING, MODE_GETTING, MODE_SETTING, MODE_RESETTING } mode = MODE_EDITING;
  626. const TCHAR *verb = argv[0];
  627. const TCHAR *service_name = argv[1];
  628. bool getting = false;
  629. bool unsetting = false;
  630. /* Minimum number of arguments. */
  631. int mandatory = 2;
  632. /* Index of first value. */
  633. int remainder = 3;
  634. int i;
  635. if (str_equiv(verb, _T("get"))) {
  636. mandatory = 3;
  637. mode = MODE_GETTING;
  638. }
  639. else if (str_equiv(verb, _T("set"))) {
  640. mandatory = 4;
  641. mode = MODE_SETTING;
  642. }
  643. else if (str_equiv(verb, _T("reset")) || str_equiv(verb, _T("unset"))) {
  644. mandatory = 3;
  645. mode = MODE_RESETTING;
  646. }
  647. if (argc < mandatory) return usage(1);
  648. const TCHAR *parameter = 0;
  649. settings_t *setting = 0;
  650. TCHAR *additional;
  651. /* Validate the parameter. */
  652. if (mandatory > 2) {
  653. bool additional_mandatory = false;
  654. parameter = argv[2];
  655. for (i = 0; settings[i].name; i++) {
  656. setting = &settings[i];
  657. if (! str_equiv(setting->name, parameter)) continue;
  658. if (((setting->additional & ADDITIONAL_GETTING) && mode == MODE_GETTING) || ((setting->additional & ADDITIONAL_SETTING) && mode == MODE_SETTING) || ((setting->additional & ADDITIONAL_RESETTING) && mode == MODE_RESETTING)) {
  659. additional_mandatory = true;
  660. mandatory++;
  661. }
  662. break;
  663. }
  664. if (! settings[i].name) {
  665. print_message(stderr, NSSM_MESSAGE_INVALID_PARAMETER, parameter);
  666. for (i = 0; settings[i].name; i++) _ftprintf(stderr, _T("%s\n"), settings[i].name);
  667. return 1;
  668. }
  669. additional = 0;
  670. if (additional_mandatory) {
  671. if (argc < mandatory) {
  672. print_message(stderr, NSSM_MESSAGE_MISSING_SUBPARAMETER, parameter);
  673. return 1;
  674. }
  675. additional = argv[3];
  676. remainder = 4;
  677. }
  678. else {
  679. additional = argv[remainder];
  680. if (argc < mandatory) return usage(1);
  681. }
  682. }
  683. nssm_service_t *service = alloc_nssm_service();
  684. _sntprintf_s(service->name, _countof(service->name), _TRUNCATE, _T("%s"), service_name);
  685. /* Open service manager */
  686. SC_HANDLE services = open_service_manager();
  687. if (! services) {
  688. print_message(stderr, NSSM_MESSAGE_OPEN_SERVICE_MANAGER_FAILED);
  689. return 2;
  690. }
  691. /* Try to open the service */
  692. service->handle = open_service(services, service->name, service->name, _countof(service->name));
  693. if (! service->handle) {
  694. CloseServiceHandle(services);
  695. return 3;
  696. }
  697. /* Get system details. */
  698. QUERY_SERVICE_CONFIG *qsc = query_service_config(service->name, service->handle);
  699. if (! qsc) {
  700. CloseHandle(service->handle);
  701. CloseServiceHandle(services);
  702. return 4;
  703. }
  704. service->type = qsc->dwServiceType;
  705. if (! (service->type & SERVICE_WIN32_OWN_PROCESS)) {
  706. if (mode != MODE_GETTING) {
  707. HeapFree(GetProcessHeap(), 0, qsc);
  708. CloseHandle(service->handle);
  709. CloseServiceHandle(services);
  710. print_message(stderr, NSSM_MESSAGE_CANNOT_EDIT, service->name, NSSM_WIN32_OWN_PROCESS, 0);
  711. return 3;
  712. }
  713. }
  714. if (get_service_startup(service->name, service->handle, qsc, &service->startup)) {
  715. if (mode != MODE_GETTING) {
  716. HeapFree(GetProcessHeap(), 0, qsc);
  717. CloseHandle(service->handle);
  718. CloseServiceHandle(services);
  719. return 4;
  720. }
  721. }
  722. if (get_service_username(service->name, qsc, &service->username, &service->usernamelen)) {
  723. if (mode != MODE_GETTING) {
  724. HeapFree(GetProcessHeap(), 0, qsc);
  725. CloseHandle(service->handle);
  726. CloseServiceHandle(services);
  727. return 5;
  728. }
  729. }
  730. _sntprintf_s(service->displayname, _countof(service->displayname), _TRUNCATE, _T("%s"), qsc->lpDisplayName);
  731. /* Get the canonical service name. We open it case insensitively. */
  732. unsigned long bufsize = _countof(service->name);
  733. GetServiceKeyName(services, service->displayname, service->name, &bufsize);
  734. /* Remember the executable in case it isn't NSSM. */
  735. _sntprintf_s(service->image, _countof(service->image), _TRUNCATE, _T("%s"), qsc->lpBinaryPathName);
  736. HeapFree(GetProcessHeap(), 0, qsc);
  737. /* Get extended system details. */
  738. if (get_service_description(service->name, service->handle, _countof(service->description), service->description)) {
  739. if (mode != MODE_GETTING) {
  740. CloseHandle(service->handle);
  741. CloseServiceHandle(services);
  742. return 6;
  743. }
  744. }
  745. /* Get NSSM details. */
  746. get_parameters(service, 0);
  747. CloseServiceHandle(services);
  748. if (! service->exe[0]) {
  749. service->native = true;
  750. if (mode != MODE_GETTING) print_message(stderr, NSSM_MESSAGE_INVALID_SERVICE, service->name, NSSM, service->image);
  751. }
  752. /* Editing with the GUI. */
  753. if (mode == MODE_EDITING) {
  754. nssm_gui(IDD_EDIT, service);
  755. return 0;
  756. }
  757. /* Trying to manage App* parameters for a non-NSSM service. */
  758. if (! setting->native && service->native) {
  759. CloseHandle(service->handle);
  760. print_message(stderr, NSSM_MESSAGE_NATIVE_PARAMETER, setting->name, NSSM);
  761. return 1;
  762. }
  763. HKEY key;
  764. value_t value;
  765. int ret;
  766. if (mode == MODE_GETTING) {
  767. if (! service->native) {
  768. key = open_registry(service->name, KEY_READ);
  769. if (! key) return 4;
  770. }
  771. if (setting->native) ret = get_setting(service->name, service->handle, setting, &value, additional);
  772. else ret = get_setting(service->name, key, setting, &value, additional);
  773. if (ret < 0) {
  774. CloseHandle(service->handle);
  775. return 5;
  776. }
  777. switch (setting->type) {
  778. case REG_EXPAND_SZ:
  779. case REG_MULTI_SZ:
  780. case REG_SZ:
  781. _tprintf(_T("%s\n"), value.string ? value.string : _T(""));
  782. HeapFree(GetProcessHeap(), 0, value.string);
  783. break;
  784. case REG_DWORD:
  785. _tprintf(_T("%u\n"), value.numeric);
  786. break;
  787. }
  788. if (! service->native) RegCloseKey(key);
  789. CloseHandle(service->handle);
  790. return 0;
  791. }
  792. /* Build the value. */
  793. if (mode == MODE_RESETTING) {
  794. /* Unset the parameter. */
  795. value.string = 0;
  796. }
  797. else {
  798. /* Set the parameter. */
  799. size_t len = 0;
  800. size_t delimiterlen = (setting->additional & ADDITIONAL_CRLF) ? 2 : 1;
  801. for (i = remainder; i < argc; i++) len += _tcslen(argv[i]) + delimiterlen;
  802. len++;
  803. value.string = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, len * sizeof(TCHAR));
  804. if (! value.string) {
  805. print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("value"), _T("edit_service()"));
  806. CloseHandle(service->handle);
  807. return 2;
  808. }
  809. size_t s = 0;
  810. for (i = remainder; i < argc; i++) {
  811. size_t len = _tcslen(argv[i]);
  812. memmove(value.string + s, argv[i], len * sizeof(TCHAR));
  813. s += len;
  814. if (i < argc - 1) {
  815. if (setting->additional & ADDITIONAL_CRLF) {
  816. value.string[s++] = _T('\r');
  817. value.string[s++] = _T('\n');
  818. }
  819. else value.string[s++] = _T(' ');
  820. }
  821. }
  822. value.string[s] = _T('\0');
  823. }
  824. if (! service->native) {
  825. key = open_registry(service->name, KEY_WRITE);
  826. if (! key) {
  827. if (value.string) HeapFree(GetProcessHeap(), 0, value.string);
  828. return 4;
  829. }
  830. }
  831. if (setting->native) ret = set_setting(service->name, service->handle, setting, &value, additional);
  832. else ret = set_setting(service->name, key, setting, &value, additional);
  833. if (value.string) HeapFree(GetProcessHeap(), 0, value.string);
  834. if (ret < 0) {
  835. if (! service->native) RegCloseKey(key);
  836. CloseHandle(service->handle);
  837. return 6;
  838. }
  839. if (! service->native) RegCloseKey(key);
  840. CloseHandle(service->handle);
  841. return 0;
  842. }
  843. /* About to remove the service */
  844. int pre_remove_service(int argc, TCHAR **argv) {
  845. nssm_service_t *service = alloc_nssm_service();
  846. set_nssm_service_defaults(service);
  847. if (argc) _sntprintf_s(service->name, _countof(service->name), _TRUNCATE, _T("%s"), argv[0]);
  848. /* Show dialogue box if we didn't pass service name and "confirm" */
  849. if (argc < 2) return nssm_gui(IDD_REMOVE, service);
  850. if (str_equiv(argv[1], _T("confirm"))) {
  851. int ret = remove_service(service);
  852. cleanup_nssm_service(service);
  853. return ret;
  854. }
  855. print_message(stderr, NSSM_MESSAGE_PRE_REMOVE_SERVICE);
  856. return 100;
  857. }
  858. /* Install the service */
  859. int install_service(nssm_service_t *service) {
  860. if (! service) return 1;
  861. /* Open service manager */
  862. SC_HANDLE services = open_service_manager();
  863. if (! services) {
  864. print_message(stderr, NSSM_MESSAGE_OPEN_SERVICE_MANAGER_FAILED);
  865. cleanup_nssm_service(service);
  866. return 2;
  867. }
  868. /* Get path of this program */
  869. GetModuleFileName(0, service->image, _countof(service->image));
  870. /* Create the service - settings will be changed in edit_service() */
  871. service->handle = CreateService(services, service->name, service->name, SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, service->image, 0, 0, 0, 0, 0);
  872. if (! service->handle) {
  873. print_message(stderr, NSSM_MESSAGE_CREATESERVICE_FAILED, error_string(GetLastError()));
  874. CloseServiceHandle(services);
  875. return 5;
  876. }
  877. if (edit_service(service, false)) {
  878. DeleteService(service->handle);
  879. CloseServiceHandle(services);
  880. return 6;
  881. }
  882. print_message(stdout, NSSM_MESSAGE_SERVICE_INSTALLED, service->name);
  883. /* Cleanup */
  884. CloseServiceHandle(services);
  885. return 0;
  886. }
  887. /* Edit the service. */
  888. int edit_service(nssm_service_t *service, bool editing) {
  889. if (! service) return 1;
  890. /*
  891. The only two valid flags for service type are SERVICE_WIN32_OWN_PROCESS
  892. and SERVICE_INTERACTIVE_PROCESS.
  893. */
  894. service->type &= SERVICE_INTERACTIVE_PROCESS;
  895. service->type |= SERVICE_WIN32_OWN_PROCESS;
  896. /* Startup type. */
  897. unsigned long startup;
  898. switch (service->startup) {
  899. case NSSM_STARTUP_MANUAL: startup = SERVICE_DEMAND_START; break;
  900. case NSSM_STARTUP_DISABLED: startup = SERVICE_DISABLED; break;
  901. default: startup = SERVICE_AUTO_START;
  902. }
  903. /* Display name. */
  904. if (! service->displayname[0]) _sntprintf_s(service->displayname, _countof(service->displayname), _TRUNCATE, _T("%s"), service->name);
  905. /*
  906. Username must be NULL if we aren't changing or an account name.
  907. We must explicitly use LOCALSYSTEM to change it when we are editing.
  908. Password must be NULL if we aren't changing, a password or "".
  909. Empty passwords are valid but we won't allow them in the GUI.
  910. */
  911. TCHAR *username = 0;
  912. TCHAR *password = 0;
  913. if (service->usernamelen) {
  914. username = service->username;
  915. if (service->passwordlen) password = service->password;
  916. else password = _T("");
  917. }
  918. else if (editing) username = NSSM_LOCALSYSTEM_ACCOUNT;
  919. if (grant_logon_as_service(username)) {
  920. print_message(stderr, NSSM_MESSAGE_GRANT_LOGON_AS_SERVICE_FAILED, username);
  921. return 5;
  922. }
  923. if (! ChangeServiceConfig(service->handle, service->type, startup, SERVICE_NO_CHANGE, 0, 0, 0, 0, username, password, service->displayname)) {
  924. print_message(stderr, NSSM_MESSAGE_CHANGESERVICECONFIG_FAILED, error_string(GetLastError()));
  925. return 5;
  926. }
  927. if (service->description[0] || editing) {
  928. set_service_description(service->name, service->handle, service->description);
  929. }
  930. SERVICE_DELAYED_AUTO_START_INFO delayed;
  931. ZeroMemory(&delayed, sizeof(delayed));
  932. if (service->startup == NSSM_STARTUP_DELAYED) delayed.fDelayedAutostart = 1;
  933. else delayed.fDelayedAutostart = 0;
  934. /* Delayed startup isn't supported until Vista. */
  935. if (! ChangeServiceConfig2(service->handle, SERVICE_CONFIG_DELAYED_AUTO_START_INFO, &delayed)) {
  936. unsigned long error = GetLastError();
  937. /* Pre-Vista we expect to fail with ERROR_INVALID_LEVEL */
  938. if (error != ERROR_INVALID_LEVEL) {
  939. log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SERVICE_CONFIG_DELAYED_AUTO_START_INFO_FAILED, service->name, error_string(error), 0);
  940. }
  941. }
  942. /* Don't mess with parameters which aren't ours. */
  943. if (! service->native) {
  944. /* Now we need to put the parameters into the registry */
  945. if (create_parameters(service, editing)) {
  946. print_message(stderr, NSSM_MESSAGE_CREATE_PARAMETERS_FAILED);
  947. return 6;
  948. }
  949. set_service_recovery(service);
  950. }
  951. return 0;
  952. }
  953. /* Control a service. */
  954. int control_service(unsigned long control, int argc, TCHAR **argv) {
  955. if (argc < 1) return usage(1);
  956. TCHAR *service_name = argv[0];
  957. TCHAR canonical_name[SERVICE_NAME_LENGTH];
  958. SC_HANDLE services = open_service_manager();
  959. if (! services) {
  960. print_message(stderr, NSSM_MESSAGE_OPEN_SERVICE_MANAGER_FAILED);
  961. return 2;
  962. }
  963. SC_HANDLE service_handle = open_service(services, service_name, canonical_name, _countof(canonical_name));
  964. if (! service_handle) {
  965. CloseServiceHandle(services);
  966. return 3;
  967. }
  968. int ret;
  969. unsigned long error;
  970. SERVICE_STATUS service_status;
  971. if (control == NSSM_SERVICE_CONTROL_START) {
  972. unsigned long initial_status = SERVICE_STOPPED;
  973. ret = StartService(service_handle, (unsigned long) argc, (const TCHAR **) argv);
  974. error = GetLastError();
  975. CloseServiceHandle(services);
  976. if (error == ERROR_IO_PENDING) {
  977. /*
  978. Older versions of Windows return immediately with ERROR_IO_PENDING
  979. indicate that the operation is still in progress. Newer versions
  980. will return it if there really is a delay.
  981. */
  982. ret = 1;
  983. error = ERROR_SUCCESS;
  984. }
  985. if (ret) {
  986. int response = await_service_control_response(control, service_handle, &service_status, initial_status);
  987. CloseHandle(service_handle);
  988. if (response) {
  989. print_message(stderr, NSSM_MESSAGE_BAD_CONTROL_RESPONSE, canonical_name, service_status_text(service_status.dwCurrentState), service_control_text(control));
  990. return 1;
  991. }
  992. else _tprintf(_T("%s: %s: %s"), canonical_name, service_control_text(control), error_string(error));
  993. return 0;
  994. }
  995. else {
  996. CloseHandle(service_handle);
  997. _ftprintf(stderr, _T("%s: %s: %s"), canonical_name, service_control_text(control), error_string(error));
  998. return 1;
  999. }
  1000. }
  1001. else if (control == SERVICE_CONTROL_INTERROGATE) {
  1002. /*
  1003. We could actually send an INTERROGATE control but that won't return
  1004. any information if the service is stopped and we don't care about
  1005. the extra details it might give us in any case. So we'll fake it.
  1006. */
  1007. ret = QueryServiceStatus(service_handle, &service_status);
  1008. error = GetLastError();
  1009. if (ret) {
  1010. _tprintf(_T("%s\n"), service_status_text(service_status.dwCurrentState));
  1011. return 0;
  1012. }
  1013. else {
  1014. _ftprintf(stderr, _T("%s: %s\n"), canonical_name, error_string(error));
  1015. return 1;
  1016. }
  1017. }
  1018. else {
  1019. ret = ControlService(service_handle, control, &service_status);
  1020. unsigned long initial_status = service_status.dwCurrentState;
  1021. error = GetLastError();
  1022. CloseServiceHandle(services);
  1023. if (error == ERROR_IO_PENDING) {
  1024. ret = 1;
  1025. error = ERROR_SUCCESS;
  1026. }
  1027. if (ret) {
  1028. int response = await_service_control_response(control, service_handle, &service_status, initial_status);
  1029. CloseHandle(service_handle);
  1030. if (response) {
  1031. print_message(stderr, NSSM_MESSAGE_BAD_CONTROL_RESPONSE, canonical_name, service_status_text(service_status.dwCurrentState), service_control_text(control));
  1032. return 1;
  1033. }
  1034. else _tprintf(_T("%s: %s: %s"), canonical_name, service_control_text(control), error_string(error));
  1035. return 0;
  1036. }
  1037. else {
  1038. CloseHandle(service_handle);
  1039. _ftprintf(stderr, _T("%s: %s: %s"), canonical_name, service_control_text(control), error_string(error));
  1040. if (error == ERROR_SERVICE_NOT_ACTIVE) {
  1041. if (control == SERVICE_CONTROL_SHUTDOWN || control == SERVICE_CONTROL_STOP) return 0;
  1042. }
  1043. return 1;
  1044. }
  1045. }
  1046. }
  1047. /* Remove the service */
  1048. int remove_service(nssm_service_t *service) {
  1049. if (! service) return 1;
  1050. /* Open service manager */
  1051. SC_HANDLE services = open_service_manager();
  1052. if (! services) {
  1053. print_message(stderr, NSSM_MESSAGE_OPEN_SERVICE_MANAGER_FAILED);
  1054. return 2;
  1055. }
  1056. /* Try to open the service */
  1057. service->handle = open_service(services, service->name, service->name, _countof(service->name));
  1058. if (! service->handle) {
  1059. CloseServiceHandle(services);
  1060. return 3;
  1061. }
  1062. /* Get the canonical service name. We open it case insensitively. */
  1063. unsigned long bufsize = _countof(service->displayname);
  1064. GetServiceDisplayName(services, service->name, service->displayname, &bufsize);
  1065. bufsize = _countof(service->name);
  1066. GetServiceKeyName(services, service->displayname, service->name, &bufsize);
  1067. /* Try to delete the service */
  1068. if (! DeleteService(service->handle)) {
  1069. print_message(stderr, NSSM_MESSAGE_DELETESERVICE_FAILED);
  1070. CloseServiceHandle(services);
  1071. return 4;
  1072. }
  1073. /* Cleanup */
  1074. CloseServiceHandle(services);
  1075. print_message(stdout, NSSM_MESSAGE_SERVICE_REMOVED, service->name);
  1076. return 0;
  1077. }
  1078. /* Service initialisation */
  1079. void WINAPI service_main(unsigned long argc, TCHAR **argv) {
  1080. nssm_service_t *service = alloc_nssm_service();
  1081. if (! service) return;
  1082. if (_sntprintf_s(service->name, _countof(service->name), _TRUNCATE, _T("%s"), argv[0]) < 0) {
  1083. log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, _T("service->name"), _T("service_main()"), 0);
  1084. return;
  1085. }
  1086. /* We can use a condition variable in a critical section on Vista or later. */
  1087. if (imports.SleepConditionVariableCS && imports.WakeConditionVariable) use_critical_section = true;
  1088. else use_critical_section = false;
  1089. /* Initialise status */
  1090. ZeroMemory(&service->status, sizeof(service->status));
  1091. service->status.dwServiceType = SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS;
  1092. service->status.dwControlsAccepted = SERVICE_ACCEPT_SHUTDOWN | SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_PAUSE_CONTINUE;
  1093. service->status.dwWin32ExitCode = NO_ERROR;
  1094. service->status.dwServiceSpecificExitCode = 0;
  1095. service->status.dwCheckPoint = 0;
  1096. service->status.dwWaitHint = NSSM_WAITHINT_MARGIN;
  1097. /* Signal we AREN'T running the server */
  1098. service->process_handle = 0;
  1099. service->pid = 0;
  1100. /* Register control handler */
  1101. service->status_handle = RegisterServiceCtrlHandlerEx(NSSM, service_control_handler, (void *) service);
  1102. if (! service->status_handle) {
  1103. log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_REGISTERSERVICECTRLHANDER_FAILED, error_string(GetLastError()), 0);
  1104. return;
  1105. }
  1106. log_service_control(service->name, 0, true);
  1107. service->status.dwCurrentState = SERVICE_START_PENDING;
  1108. service->status.dwWaitHint = service->throttle_delay + NSSM_WAITHINT_MARGIN;
  1109. SetServiceStatus(service->status_handle, &service->status);
  1110. if (is_admin) {
  1111. /* Try to create the exit action parameters; we don't care if it fails */
  1112. create_exit_action(service->name, exit_action_strings[0], false);
  1113. SC_HANDLE services = open_service_manager();
  1114. if (services) {
  1115. service->handle = OpenService(services, service->name, SC_MANAGER_ALL_ACCESS);
  1116. set_service_recovery(service);
  1117. CloseServiceHandle(services);
  1118. }
  1119. }
  1120. /* Used for signalling a resume if the service pauses when throttled. */
  1121. if (use_critical_section) {
  1122. InitializeCriticalSection(&service->throttle_section);
  1123. service->throttle_section_initialised = true;
  1124. }
  1125. else {
  1126. service->throttle_timer = CreateWaitableTimer(0, 1, 0);
  1127. if (! service->throttle_timer) {
  1128. log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_CREATEWAITABLETIMER_FAILED, service->name, error_string(GetLastError()), 0);
  1129. }
  1130. }
  1131. /* Remember our initial environment. */
  1132. service->initial_env = GetEnvironmentStrings();
  1133. monitor_service(service);
  1134. }
  1135. /* Make sure service recovery actions are taken where necessary */
  1136. void set_service_recovery(nssm_service_t *service) {
  1137. SERVICE_FAILURE_ACTIONS_FLAG flag;
  1138. ZeroMemory(&flag, sizeof(flag));
  1139. flag.fFailureActionsOnNonCrashFailures = true;
  1140. /* This functionality was added in Vista so the call may fail */
  1141. if (! ChangeServiceConfig2(service->handle, SERVICE_CONFIG_FAILURE_ACTIONS_FLAG, &flag)) {
  1142. unsigned long error = GetLastError();
  1143. /* Pre-Vista we expect to fail with ERROR_INVALID_LEVEL */
  1144. if (error != ERROR_INVALID_LEVEL) {
  1145. log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SERVICE_CONFIG_FAILURE_ACTIONS_FAILED, service->name, error_string(error), 0);
  1146. }
  1147. }
  1148. }
  1149. int monitor_service(nssm_service_t *service) {
  1150. /* Set service status to started */
  1151. int ret = start_service(service);
  1152. if (ret) {
  1153. TCHAR code[16];
  1154. _sntprintf_s(code, _countof(code), _TRUNCATE, _T("%d"), ret);
  1155. log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_START_SERVICE_FAILED, service->exe, service->name, ret, 0);
  1156. return ret;
  1157. }
  1158. log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_STARTED_SERVICE, service->exe, service->flags, service->name, service->dir, 0);
  1159. /* Monitor service */
  1160. if (! RegisterWaitForSingleObject(&service->wait_handle, service->process_handle, end_service, (void *) service, INFINITE, WT_EXECUTEONLYONCE | WT_EXECUTELONGFUNCTION)) {
  1161. log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_REGISTERWAITFORSINGLEOBJECT_FAILED, service->name, service->exe, error_string(GetLastError()), 0);
  1162. }
  1163. return 0;
  1164. }
  1165. TCHAR *service_control_text(unsigned long control) {
  1166. switch (control) {
  1167. /* HACK: there is no SERVICE_CONTROL_START constant */
  1168. case NSSM_SERVICE_CONTROL_START: return _T("START");
  1169. case SERVICE_CONTROL_STOP: return _T("STOP");
  1170. case SERVICE_CONTROL_SHUTDOWN: return _T("SHUTDOWN");
  1171. case SERVICE_CONTROL_PAUSE: return _T("PAUSE");
  1172. case SERVICE_CONTROL_CONTINUE: return _T("CONTINUE");
  1173. case SERVICE_CONTROL_INTERROGATE: return _T("INTERROGATE");
  1174. case NSSM_SERVICE_CONTROL_ROTATE: return _T("ROTATE");
  1175. default: return 0;
  1176. }
  1177. }
  1178. TCHAR *service_status_text(unsigned long status) {
  1179. switch (status) {
  1180. case SERVICE_STOPPED: return _T("SERVICE_STOPPED");
  1181. case SERVICE_START_PENDING: return _T("SERVICE_START_PENDING");
  1182. case SERVICE_STOP_PENDING: return _T("SERVICE_STOP_PENDING");
  1183. case SERVICE_RUNNING: return _T("SERVICE_RUNNING");
  1184. case SERVICE_CONTINUE_PENDING: return _T("SERVICE_CONTINUE_PENDING");
  1185. case SERVICE_PAUSE_PENDING: return _T("SERVICE_PAUSE_PENDING");
  1186. case SERVICE_PAUSED: return _T("SERVICE_PAUSED");
  1187. default: return 0;
  1188. }
  1189. }
  1190. void log_service_control(TCHAR *service_name, unsigned long control, bool handled) {
  1191. TCHAR *text = service_control_text(control);
  1192. unsigned long event;
  1193. if (! text) {
  1194. /* "0x" + 8 x hex + NULL */
  1195. text = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, 11 * sizeof(TCHAR));
  1196. if (! text) {
  1197. log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, _T("control code"), _T("log_service_control()"), 0);
  1198. return;
  1199. }
  1200. if (_sntprintf_s(text, 11, _TRUNCATE, _T("0x%08x"), control) < 0) {
  1201. log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, _T("control code"), _T("log_service_control()"), 0);
  1202. HeapFree(GetProcessHeap(), 0, text);
  1203. return;
  1204. }
  1205. event = NSSM_EVENT_SERVICE_CONTROL_UNKNOWN;
  1206. }
  1207. else if (handled) event = NSSM_EVENT_SERVICE_CONTROL_HANDLED;
  1208. else event = NSSM_EVENT_SERVICE_CONTROL_NOT_HANDLED;
  1209. log_event(EVENTLOG_INFORMATION_TYPE, event, service_name, text, 0);
  1210. if (event == NSSM_EVENT_SERVICE_CONTROL_UNKNOWN) {
  1211. HeapFree(GetProcessHeap(), 0, text);
  1212. }
  1213. }
  1214. /* Service control handler */
  1215. unsigned long WINAPI service_control_handler(unsigned long control, unsigned long event, void *data, void *context) {
  1216. nssm_service_t *service = (nssm_service_t *) context;
  1217. switch (control) {
  1218. case SERVICE_CONTROL_INTERROGATE:
  1219. /* We always keep the service status up-to-date so this is a no-op. */
  1220. return NO_ERROR;
  1221. case SERVICE_CONTROL_SHUTDOWN:
  1222. case SERVICE_CONTROL_STOP:
  1223. log_service_control(service->name, control, true);
  1224. /*
  1225. We MUST acknowledge the stop request promptly but we're committed to
  1226. waiting for the application to exit. Spawn a new thread to wait
  1227. while we acknowledge the request.
  1228. */
  1229. if (! CreateThread(NULL, 0, shutdown_service, context, 0, NULL)) {
  1230. log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATETHREAD_FAILED, error_string(GetLastError()), 0);
  1231. /*
  1232. We couldn't create a thread to tidy up so we'll have to force the tidyup
  1233. to complete in time in this thread.
  1234. */
  1235. service->kill_console_delay = NSSM_KILL_CONSOLE_GRACE_PERIOD;
  1236. service->kill_window_delay = NSSM_KILL_WINDOW_GRACE_PERIOD;
  1237. service->kill_threads_delay = NSSM_KILL_THREADS_GRACE_PERIOD;
  1238. stop_service(service, 0, true, true);
  1239. }
  1240. return NO_ERROR;
  1241. case SERVICE_CONTROL_CONTINUE:
  1242. log_service_control(service->name, control, true);
  1243. service->throttle = 0;
  1244. if (use_critical_section) imports.WakeConditionVariable(&service->throttle_condition);
  1245. else {
  1246. if (! service->throttle_timer) return ERROR_CALL_NOT_IMPLEMENTED;
  1247. ZeroMemory(&service->throttle_duetime, sizeof(service->throttle_duetime));
  1248. SetWaitableTimer(service->throttle_timer, &service->throttle_duetime, 0, 0, 0, 0);
  1249. }
  1250. /* We can't continue if the application is running! */
  1251. if (! service->process_handle) service->status.dwCurrentState = SERVICE_CONTINUE_PENDING;
  1252. service->status.dwWaitHint = throttle_milliseconds(service->throttle) + NSSM_WAITHINT_MARGIN;
  1253. log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_RESET_THROTTLE, service->name, 0);
  1254. SetServiceStatus(service->status_handle, &service->status);
  1255. return NO_ERROR;
  1256. case SERVICE_CONTROL_PAUSE:
  1257. /*
  1258. We don't accept pause messages but it isn't possible to register
  1259. only for continue messages so we have to handle this case.
  1260. */
  1261. log_service_control(service->name, control, false);
  1262. return ERROR_CALL_NOT_IMPLEMENTED;
  1263. case NSSM_SERVICE_CONTROL_ROTATE:
  1264. log_service_control(service->name, control, true);
  1265. if (service->rotate_stdout_online == NSSM_ROTATE_ONLINE) service->rotate_stdout_online = NSSM_ROTATE_ONLINE_ASAP;
  1266. if (service->rotate_stderr_online == NSSM_ROTATE_ONLINE) service->rotate_stderr_online = NSSM_ROTATE_ONLINE_ASAP;
  1267. return NO_ERROR;
  1268. }
  1269. /* Unknown control */
  1270. log_service_control(service->name, control, false);
  1271. return ERROR_CALL_NOT_IMPLEMENTED;
  1272. }
  1273. /* Start the service */
  1274. int start_service(nssm_service_t *service) {
  1275. service->stopping = false;
  1276. service->allow_restart = true;
  1277. if (service->process_handle) return 0;
  1278. /* Allocate a STARTUPINFO structure for a new process */
  1279. STARTUPINFO si;
  1280. ZeroMemory(&si, sizeof(si));
  1281. si.cb = sizeof(si);
  1282. /* Allocate a PROCESSINFO structure for the process */
  1283. PROCESS_INFORMATION pi;
  1284. ZeroMemory(&pi, sizeof(pi));
  1285. /* Get startup parameters */
  1286. int ret = get_parameters(service, &si);
  1287. if (ret) {
  1288. log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_GET_PARAMETERS_FAILED, service->name, 0);
  1289. return stop_service(service, 2, true, true);
  1290. }
  1291. /* Launch executable with arguments */
  1292. TCHAR cmd[CMD_LENGTH];
  1293. if (_sntprintf_s(cmd, _countof(cmd), _TRUNCATE, _T("\"%s\" %s"), service->exe, service->flags) < 0) {
  1294. log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, _T("command line"), _T("start_service"), 0);
  1295. return stop_service(service, 2, true, true);
  1296. }
  1297. throttle_restart(service);
  1298. /* Set the environment. */
  1299. if (service->env) duplicate_environment(service->env);
  1300. if (service->env_extra) set_environment_block(service->env_extra);
  1301. /* Set up I/O redirection. */
  1302. if (get_output_handles(service, &si)) {
  1303. log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_GET_OUTPUT_HANDLES_FAILED, service->name, 0);
  1304. if (! service->no_console) FreeConsole();
  1305. close_output_handles(&si);
  1306. return stop_service(service, 4, true, true);
  1307. }
  1308. bool inherit_handles = false;
  1309. if (si.dwFlags & STARTF_USESTDHANDLES) inherit_handles = true;
  1310. unsigned long flags = service->priority & priority_mask();
  1311. if (service->affinity) flags |= CREATE_SUSPENDED;
  1312. if (! CreateProcess(0, cmd, 0, 0, inherit_handles, flags, 0, service->dir, &si, &pi)) {
  1313. unsigned long exitcode = 3;
  1314. unsigned long error = GetLastError();
  1315. log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATEPROCESS_FAILED, service->name, service->exe, error_string(error), 0);
  1316. close_output_handles(&si);
  1317. duplicate_environment(service->initial_env);
  1318. return stop_service(service, exitcode, true, true);
  1319. }
  1320. service->process_handle = pi.hProcess;
  1321. service->pid = pi.dwProcessId;
  1322. if (get_process_creation_time(service->process_handle, &service->creation_time)) ZeroMemory(&service->creation_time, sizeof(service->creation_time));
  1323. close_output_handles(&si);
  1324. if (! service->no_console) FreeConsole();
  1325. /* Restore our environment. */
  1326. duplicate_environment(service->initial_env);
  1327. if (service->affinity) {
  1328. /*
  1329. We are explicitly storing service->affinity as a 64-bit unsigned integer
  1330. so that we can parse it regardless of whether we're running in 32-bit
  1331. or 64-bit mode. The arguments to SetProcessAffinityMask(), however, are
  1332. defined as type DWORD_PTR and hence limited to 32 bits on a 32-bit system
  1333. (or when running the 32-bit NSSM).
  1334. The result is a lot of seemingly-unnecessary casting throughout the code
  1335. and potentially confusion when we actually try to start the service.
  1336. Having said that, however, it's unlikely that we're actually going to
  1337. run in 32-bit mode on a system which has more than 32 CPUs so the
  1338. likelihood of seeing a confusing situation is somewhat diminished.
  1339. */
  1340. DWORD_PTR affinity, system_affinity;
  1341. if (GetProcessAffinityMask(service->process_handle, &affinity, &system_affinity)) affinity = service->affinity & system_affinity;
  1342. else {
  1343. affinity = (DWORD_PTR) service->affinity;
  1344. log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_GETPROCESSAFFINITYMASK_FAILED, service->name, error_string(GetLastError()), 0);
  1345. }
  1346. if (! SetProcessAffinityMask(service->process_handle, affinity)) {
  1347. log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_SETPROCESSAFFINITYMASK_FAILED, service->name, error_string(GetLastError()), 0);
  1348. }
  1349. ResumeThread(pi.hThread);
  1350. }
  1351. /*
  1352. Wait for a clean startup before changing the service status to RUNNING
  1353. but be mindful of the fact that we are blocking the service control manager
  1354. so abandon the wait before too much time has elapsed.
  1355. */
  1356. unsigned long delay = service->throttle_delay;
  1357. if (delay > NSSM_SERVICE_STATUS_DEADLINE) {
  1358. TCHAR delay_milliseconds[16];
  1359. _sntprintf_s(delay_milliseconds, _countof(delay_milliseconds), _TRUNCATE, _T("%lu"), delay);
  1360. TCHAR deadline_milliseconds[16];
  1361. _sntprintf_s(deadline_milliseconds, _countof(deadline_milliseconds), _TRUNCATE, _T("%lu"), NSSM_SERVICE_STATUS_DEADLINE);
  1362. log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_STARTUP_DELAY_TOO_LONG, service->name, delay_milliseconds, NSSM, deadline_milliseconds, 0);
  1363. delay = NSSM_SERVICE_STATUS_DEADLINE;
  1364. }
  1365. unsigned long deadline = WaitForSingleObject(service->process_handle, delay);
  1366. /* Signal successful start */
  1367. service->status.dwCurrentState = SERVICE_RUNNING;
  1368. SetServiceStatus(service->status_handle, &service->status);
  1369. /* Continue waiting for a clean startup. */
  1370. if (deadline == WAIT_TIMEOUT) {
  1371. if (service->throttle_delay > delay) {
  1372. if (WaitForSingleObject(service->process_handle, service->throttle_delay - delay) == WAIT_TIMEOUT) service->throttle = 0;
  1373. }
  1374. else service->throttle = 0;
  1375. }
  1376. /* Ensure the restart delay is always applied. */
  1377. if (service->restart_delay && ! service->throttle) service->throttle++;
  1378. return 0;
  1379. }
  1380. /* Stop the service */
  1381. int stop_service(nssm_service_t *service, unsigned long exitcode, bool graceful, bool default_action) {
  1382. service->allow_restart = false;
  1383. if (service->wait_handle) {
  1384. UnregisterWait(service->wait_handle);
  1385. service->wait_handle = 0;
  1386. }
  1387. service->rotate_stdout_online = service->rotate_stderr_online = NSSM_ROTATE_OFFLINE;
  1388. if (default_action && ! exitcode && ! graceful) {
  1389. log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_GRACEFUL_SUICIDE, service->name, service->exe, exit_action_strings[NSSM_EXIT_UNCLEAN], exit_action_strings[NSSM_EXIT_UNCLEAN], exit_action_strings[NSSM_EXIT_UNCLEAN], exit_action_strings[NSSM_EXIT_REALLY], 0);
  1390. graceful = true;
  1391. }
  1392. /* Signal we are stopping */
  1393. if (graceful) {
  1394. service->status.dwCurrentState = SERVICE_STOP_PENDING;
  1395. service->status.dwWaitHint = NSSM_WAITHINT_MARGIN;
  1396. SetServiceStatus(service->status_handle, &service->status);
  1397. }
  1398. /* Nothing to do if service isn't running */
  1399. if (service->pid) {
  1400. /* Shut down service */
  1401. log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_TERMINATEPROCESS, service->name, service->exe, 0);
  1402. kill_process(service, service->process_handle, service->pid, 0);
  1403. }
  1404. else log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_PROCESS_ALREADY_STOPPED, service->name, service->exe, 0);
  1405. end_service((void *) service, true);
  1406. /* Signal we stopped */
  1407. if (graceful) {
  1408. service->status.dwCurrentState = SERVICE_STOPPED;
  1409. if (exitcode) {
  1410. service->status.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR;
  1411. service->status.dwServiceSpecificExitCode = exitcode;
  1412. }
  1413. else {
  1414. service->status.dwWin32ExitCode = NO_ERROR;
  1415. service->status.dwServiceSpecificExitCode = 0;
  1416. }
  1417. SetServiceStatus(service->status_handle, &service->status);
  1418. }
  1419. return exitcode;
  1420. }
  1421. /* Callback function triggered when the server exits */
  1422. void CALLBACK end_service(void *arg, unsigned char why) {
  1423. nssm_service_t *service = (nssm_service_t *) arg;
  1424. if (service->stopping) return;
  1425. service->stopping = true;
  1426. service->rotate_stdout_online = service->rotate_stderr_online = NSSM_ROTATE_OFFLINE;
  1427. /* Check exit code */
  1428. unsigned long exitcode = 0;
  1429. TCHAR code[16];
  1430. if (service->process_handle) {
  1431. GetExitCodeProcess(service->process_handle, &exitcode);
  1432. if (exitcode == STILL_ACTIVE || get_process_exit_time(service->process_handle, &service->exit_time)) GetSystemTimeAsFileTime(&service->exit_time);
  1433. CloseHandle(service->process_handle);
  1434. }
  1435. else GetSystemTimeAsFileTime(&service->exit_time);
  1436. service->process_handle = 0;
  1437. /*
  1438. Log that the service ended BEFORE logging about killing the process
  1439. tree. See below for the possible values of the why argument.
  1440. */
  1441. if (! why) {
  1442. _sntprintf_s(code, _countof(code), _TRUNCATE, _T("%lu"), exitcode);
  1443. log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_ENDED_SERVICE, service->exe, service->name, code, 0);
  1444. }
  1445. /* Clean up. */
  1446. if (exitcode == STILL_ACTIVE) exitcode = 0;
  1447. if (service->pid) kill_process_tree(service, service->pid, exitcode, service->pid);
  1448. service->pid = 0;
  1449. /*
  1450. The why argument is true if our wait timed out or false otherwise.
  1451. Our wait is infinite so why will never be true when called by the system.
  1452. If it is indeed true, assume we were called from stop_service() because
  1453. this is a controlled shutdown, and don't take any restart action.
  1454. */
  1455. if (why) return;
  1456. if (! service->allow_restart) return;
  1457. /* What action should we take? */
  1458. int action = NSSM_EXIT_RESTART;
  1459. TCHAR action_string[ACTION_LEN];
  1460. bool default_action;
  1461. if (! get_exit_action(service->name, &exitcode, action_string, &default_action)) {
  1462. for (int i = 0; exit_action_strings[i]; i++) {
  1463. if (! _tcsnicmp((const TCHAR *) action_string, exit_action_strings[i], ACTION_LEN)) {
  1464. action = i;
  1465. break;
  1466. }
  1467. }
  1468. }
  1469. switch (action) {
  1470. /* Try to restart the service or return failure code to service manager */
  1471. case NSSM_EXIT_RESTART:
  1472. log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_EXIT_RESTART, service->name, code, exit_action_strings[action], service->exe, 0);
  1473. while (monitor_service(service)) {
  1474. log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_RESTART_SERVICE_FAILED, service->exe, service->name, 0);
  1475. Sleep(30000);
  1476. }
  1477. break;
  1478. /* Do nothing, just like srvany would */
  1479. case NSSM_EXIT_IGNORE:
  1480. log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_EXIT_IGNORE, service->name, code, exit_action_strings[action], service->exe, 0);
  1481. Sleep(INFINITE);
  1482. break;
  1483. /* Tell the service manager we are finished */
  1484. case NSSM_EXIT_REALLY:
  1485. log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_EXIT_REALLY, service->name, code, exit_action_strings[action], 0);
  1486. stop_service(service, exitcode, true, default_action);
  1487. break;
  1488. /* Fake a crash so pre-Vista service managers will run recovery actions. */
  1489. case NSSM_EXIT_UNCLEAN:
  1490. log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_EXIT_UNCLEAN, service->name, code, exit_action_strings[action], 0);
  1491. stop_service(service, exitcode, false, default_action);
  1492. free_imports();
  1493. exit(exitcode);
  1494. break;
  1495. }
  1496. }
  1497. void throttle_restart(nssm_service_t *service) {
  1498. /* This can't be a restart if the service is already running. */
  1499. if (! service->throttle++) return;
  1500. unsigned long ms;
  1501. unsigned long throttle_ms = throttle_milliseconds(service->throttle);
  1502. TCHAR threshold[8], milliseconds[8];
  1503. if (service->restart_delay > throttle_ms) ms = service->restart_delay;
  1504. else ms = throttle_ms;
  1505. if (service->throttle > 7) service->throttle = 8;
  1506. _sntprintf_s(milliseconds, _countof(milliseconds), _TRUNCATE, _T("%lu"), ms);
  1507. if (service->throttle == 1 && service->restart_delay > throttle_ms) log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_RESTART_DELAY, service->name, milliseconds, 0);
  1508. else {
  1509. _sntprintf_s(threshold, _countof(threshold), _TRUNCATE, _T("%lu"), service->throttle_delay);
  1510. log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_THROTTLED, service->name, threshold, milliseconds, 0);
  1511. }
  1512. if (use_critical_section) EnterCriticalSection(&service->throttle_section);
  1513. else if (service->throttle_timer) {
  1514. ZeroMemory(&service->throttle_duetime, sizeof(service->throttle_duetime));
  1515. service->throttle_duetime.QuadPart = 0 - (ms * 10000LL);
  1516. SetWaitableTimer(service->throttle_timer, &service->throttle_duetime, 0, 0, 0, 0);
  1517. }
  1518. service->status.dwCurrentState = SERVICE_PAUSED;
  1519. SetServiceStatus(service->status_handle, &service->status);
  1520. if (use_critical_section) {
  1521. imports.SleepConditionVariableCS(&service->throttle_condition, &service->throttle_section, ms);
  1522. LeaveCriticalSection(&service->throttle_section);
  1523. }
  1524. else {
  1525. if (service->throttle_timer) WaitForSingleObject(service->throttle_timer, INFINITE);
  1526. else Sleep(ms);
  1527. }
  1528. }
  1529. /*
  1530. When responding to a stop (or any other) request we need to set dwWaitHint to
  1531. the number of milliseconds we expect the operation to take, and optionally
  1532. increase dwCheckPoint. If dwWaitHint milliseconds elapses without the
  1533. operation completing or dwCheckPoint increasing, the system will consider the
  1534. service to be hung.
  1535. However the system will consider the service to be hung after 30000
  1536. milliseconds regardless of the value of dwWaitHint if dwCheckPoint has not
  1537. changed. Therefore if we want to wait longer than that we must periodically
  1538. increase dwCheckPoint.
  1539. Furthermore, it will consider the service to be hung after 60000 milliseconds
  1540. regardless of the value of dwCheckPoint unless dwWaitHint is increased every
  1541. time dwCheckPoint is also increased.
  1542. Our strategy then is to retrieve the initial dwWaitHint and wait for
  1543. NSSM_SERVICE_STATUS_DEADLINE milliseconds. If the process is still running
  1544. and we haven't finished waiting we increment dwCheckPoint and add whichever is
  1545. smaller of NSSM_SERVICE_STATUS_DEADLINE or the remaining timeout to
  1546. dwWaitHint.
  1547. Only doing both these things will prevent the system from killing the service.
  1548. Returns: 1 if the wait timed out.
  1549. 0 if the wait completed.
  1550. -1 on error.
  1551. */
  1552. int await_shutdown(nssm_service_t *service, TCHAR *function_name, unsigned long timeout) {
  1553. unsigned long interval;
  1554. unsigned long waithint;
  1555. unsigned long ret;
  1556. unsigned long waited;
  1557. TCHAR interval_milliseconds[16];
  1558. TCHAR timeout_milliseconds[16];
  1559. TCHAR waited_milliseconds[16];
  1560. TCHAR *function = function_name;
  1561. /* Add brackets to function name. */
  1562. size_t funclen = _tcslen(function_name) + 3;
  1563. TCHAR *func = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, funclen * sizeof(TCHAR));
  1564. if (func) {
  1565. if (_sntprintf_s(func, funclen, _TRUNCATE, _T("%s()"), function_name) > -1) function = func;
  1566. }
  1567. _sntprintf_s(timeout_milliseconds, _countof(timeout_milliseconds), _TRUNCATE, _T("%lu"), timeout);
  1568. waithint = service->status.dwWaitHint;
  1569. waited = 0;
  1570. while (waited < timeout) {
  1571. interval = timeout - waited;
  1572. if (interval > NSSM_SERVICE_STATUS_DEADLINE) interval = NSSM_SERVICE_STATUS_DEADLINE;
  1573. service->status.dwCurrentState = SERVICE_STOP_PENDING;
  1574. service->status.dwWaitHint += interval;
  1575. service->status.dwCheckPoint++;
  1576. SetServiceStatus(service->status_handle, &service->status);
  1577. if (waited) {
  1578. _sntprintf_s(waited_milliseconds, _countof(waited_milliseconds), _TRUNCATE, _T("%lu"), waited);
  1579. _sntprintf_s(interval_milliseconds, _countof(interval_milliseconds), _TRUNCATE, _T("%lu"), interval);
  1580. log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_AWAITING_SHUTDOWN, function, service->name, waited_milliseconds, interval_milliseconds, timeout_milliseconds, 0);
  1581. }
  1582. switch (WaitForSingleObject(service->process_handle, interval)) {
  1583. case WAIT_OBJECT_0:
  1584. ret = 0;
  1585. goto awaited;
  1586. case WAIT_TIMEOUT:
  1587. ret = 1;
  1588. break;
  1589. default:
  1590. ret = -1;
  1591. goto awaited;
  1592. }
  1593. waited += interval;
  1594. }
  1595. awaited:
  1596. if (func) HeapFree(GetProcessHeap(), 0, func);
  1597. return ret;
  1598. }