+typedef struct {\r
+ int first;\r
+ int last;\r
+} list_t;\r
+\r
+/*\r
+ Check the status in response to a control.\r
+ Returns: 1 if the status is expected, eg STOP following CONTROL_STOP.\r
+ 0 if the status is desired, eg STOPPED following CONTROL_STOP.\r
+ -1 if the status is undesired, eg STOPPED following CONTROL_START.\r
+*/\r
+static inline int service_control_response(unsigned long control, unsigned long status) {\r
+ switch (control) {\r
+ case NSSM_SERVICE_CONTROL_START:\r
+ switch (status) {\r
+ case SERVICE_START_PENDING:\r
+ return 1;\r
+\r
+ case SERVICE_RUNNING:\r
+ return 0;\r
+\r
+ default:\r
+ return -1;\r
+ }\r
+\r
+ case SERVICE_CONTROL_STOP:\r
+ case SERVICE_CONTROL_SHUTDOWN:\r
+ switch (status) {\r
+ case SERVICE_STOP_PENDING:\r
+ return 1;\r
+\r
+ case SERVICE_STOPPED:\r
+ return 0;\r
+\r
+ default:\r
+ return -1;\r
+ }\r
+\r
+ case SERVICE_CONTROL_PAUSE:\r
+ switch (status) {\r
+ case SERVICE_PAUSE_PENDING:\r
+ return 1;\r
+\r
+ case SERVICE_PAUSED:\r
+ return 0;\r
+\r
+ default:\r
+ return -1;\r
+ }\r
+\r
+ case SERVICE_CONTROL_CONTINUE:\r
+ switch (status) {\r
+ case SERVICE_CONTINUE_PENDING:\r
+ return 1;\r
+\r
+ case SERVICE_RUNNING:\r
+ return 0;\r
+\r
+ default:\r
+ return -1;\r
+ }\r
+\r
+ case SERVICE_CONTROL_INTERROGATE:\r
+ return 0;\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+static inline int await_service_control_response(unsigned long control, SC_HANDLE service_handle, SERVICE_STATUS *service_status, unsigned long initial_status) {\r
+ int tries = 0;\r
+ while (QueryServiceStatus(service_handle, service_status)) {\r
+ int response = service_control_response(control, service_status->dwCurrentState);\r
+ /* Alas we can't WaitForSingleObject() on an SC_HANDLE. */\r
+ if (! response) return response;\r
+ if (response > 0 || service_status->dwCurrentState == initial_status) {\r
+ if (++tries > 10) return response;\r
+ Sleep(50 * tries);\r
+ }\r
+ else return response;\r
+ }\r
+ return -1;\r
+}\r
+\r
+int affinity_mask_to_string(__int64 mask, TCHAR **string) {\r
+ if (! string) return 1;\r
+ if (! mask) {\r
+ *string = 0;\r
+ return 0;\r
+ }\r
+\r
+ __int64 i, n;\r
+\r
+ /* SetProcessAffinityMask() accepts a mask of up to 64 processors. */\r
+ list_t set[64];\r
+ for (n = 0; n < _countof(set); n++) set[n].first = set[n].last = -1;\r
+\r
+ for (i = 0, n = 0; i < _countof(set); i++) {\r
+ if (mask & (1LL << i)) {\r
+ if (set[n].first == -1) set[n].first = set[n].last = (int) i;\r
+ else if (set[n].last == (int) i - 1) set[n].last = (int) i;\r
+ else {\r
+ n++;\r
+ set[n].first = set[n].last = (int) i;\r
+ }\r
+ }\r
+ }\r
+\r
+ /* Worst case is 2x2 characters for first and last CPU plus - and/or , */\r
+ size_t len = (size_t) (n + 1) * 6;\r
+ *string = (TCHAR *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(TCHAR));\r
+ if (! string) return 2;\r
+\r
+ size_t s = 0;\r
+ int ret;\r
+ for (i = 0; i <= n; i++) {\r
+ if (i) (*string)[s++] = _T(',');\r
+ ret = _sntprintf_s(*string + s, 3, _TRUNCATE, _T("%u"), set[i].first);\r
+ if (ret < 0) {\r
+ HeapFree(GetProcessHeap(), 0, *string);\r
+ *string = 0;\r
+ return 3;\r
+ }\r
+ else s += ret;\r
+ if (set[i].last != set[i].first) {\r
+ ret =_sntprintf_s(*string + s, 4, _TRUNCATE, _T("%c%u"), (set[i].last == set[i].first + 1) ? _T(',') : _T('-'), set[i].last);\r
+ if (ret < 0) {\r
+ HeapFree(GetProcessHeap(), 0, *string);\r
+ *string = 0;\r
+ return 4;\r
+ }\r
+ else s += ret;\r
+ }\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+int affinity_string_to_mask(TCHAR *string, __int64 *mask) {\r
+ if (! mask) return 1;\r
+\r
+ *mask = 0LL;\r
+ if (! string) return 0;\r
+\r
+ list_t set[64];\r
+\r
+ TCHAR *s = string;\r
+ TCHAR *end;\r
+ int ret;\r
+ int i;\r
+ int n = 0;\r
+ unsigned long number;\r
+\r
+ for (n = 0; n < _countof(set); n++) set[n].first = set[n].last = -1;\r
+ n = 0;\r
+\r
+ while (*s) {\r
+ ret = str_number(s, &number, &end);\r
+ s = end;\r
+ if (ret == 0 || ret == 2) {\r
+ if (number >= _countof(set)) return 2;\r
+ set[n].first = set[n].last = (int) number;\r
+\r
+ switch (*s) {\r
+ case 0:\r
+ break;\r
+\r
+ case _T(','):\r
+ n++;\r
+ s++;\r
+ break;\r
+\r
+ case _T('-'):\r
+ if (! *(++s)) return 3;\r
+ ret = str_number(s, &number, &end);\r
+ if (ret == 0 || ret == 2) {\r
+ s = end;\r
+ if (! *s || *s == _T(',')) {\r
+ set[n].last = (int) number;\r
+ if (! *s) break;\r
+ n++;\r
+ s++;\r
+ }\r
+ else return 3;\r
+ }\r
+ else return 3;\r
+ break;\r
+\r
+ default:\r
+ return 3;\r
+ }\r
+ }\r
+ else return 4;\r
+ }\r
+\r
+ for (i = 0; i <= n; i++) {\r
+ for (int j = set[i].first; j <= set[i].last; j++) (__int64) *mask |= (1LL << (__int64) j);\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+inline unsigned long priority_mask() {\r
+ return REALTIME_PRIORITY_CLASS | HIGH_PRIORITY_CLASS | ABOVE_NORMAL_PRIORITY_CLASS | NORMAL_PRIORITY_CLASS | BELOW_NORMAL_PRIORITY_CLASS | IDLE_PRIORITY_CLASS;\r
+}\r
+\r
+int priority_constant_to_index(unsigned long constant) {\r
+ switch (constant & priority_mask()) {\r
+ case REALTIME_PRIORITY_CLASS: return NSSM_REALTIME_PRIORITY;\r
+ case HIGH_PRIORITY_CLASS: return NSSM_HIGH_PRIORITY;\r
+ case ABOVE_NORMAL_PRIORITY_CLASS: return NSSM_ABOVE_NORMAL_PRIORITY;\r
+ case BELOW_NORMAL_PRIORITY_CLASS: return NSSM_BELOW_NORMAL_PRIORITY;\r
+ case IDLE_PRIORITY_CLASS: return NSSM_IDLE_PRIORITY;\r
+ }\r
+ return NSSM_NORMAL_PRIORITY;\r
+}\r
+\r
+unsigned long priority_index_to_constant(int index) {\r
+ switch (index) {\r
+ case NSSM_REALTIME_PRIORITY: return REALTIME_PRIORITY_CLASS;\r
+ case NSSM_HIGH_PRIORITY: return HIGH_PRIORITY_CLASS;\r
+ case NSSM_ABOVE_NORMAL_PRIORITY: return ABOVE_NORMAL_PRIORITY_CLASS;\r
+ case NSSM_BELOW_NORMAL_PRIORITY: return BELOW_NORMAL_PRIORITY_CLASS;\r
+ case NSSM_IDLE_PRIORITY: return IDLE_PRIORITY_CLASS;\r
+ }\r
+ return NORMAL_PRIORITY_CLASS;\r
+}\r
+\r
+static inline unsigned long throttle_milliseconds(unsigned long throttle) {\r