Fixed arguments when installing a service.
[nssm.git] / registry.cpp
1 #include "nssm.h"\r
2 \r
3 int create_messages() {\r
4   HKEY key;\r
5 \r
6   char registry[KEY_LENGTH];\r
7   if (_snprintf(registry, sizeof(registry), "SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\%s", NSSM) < 0) {\r
8     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, "eventlog registry", "create_messages()", 0);\r
9     return 1;\r
10   }\r
11 \r
12   if (RegCreateKeyEx(HKEY_LOCAL_MACHINE, registry, 0, 0, REG_OPTION_NON_VOLATILE, KEY_WRITE, 0, &key, 0) != ERROR_SUCCESS) {\r
13     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OPENKEY_FAILED, registry, GetLastError(), 0);\r
14     return 2;\r
15   }\r
16 \r
17   /* Get path of this program */\r
18   char path[MAX_PATH];\r
19   GetModuleFileName(0, path, MAX_PATH);\r
20 \r
21   /* Try to register the module but don't worry so much on failure */\r
22   RegSetValueEx(key, "EventMessageFile", 0, REG_SZ, (const unsigned char *) path, strlen(path) + 1);\r
23   unsigned long types = EVENTLOG_INFORMATION_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_ERROR_TYPE;\r
24   RegSetValueEx(key, "TypesSupported", 0, REG_DWORD, /*XXX*/(PBYTE) &types, sizeof(types));\r
25 \r
26   return 0;\r
27 }\r
28 \r
29 int create_parameters(char *service_name, char *exe, char *flags, char *dir) {\r
30   /* Get registry */\r
31   char registry[KEY_LENGTH];\r
32   if (_snprintf(registry, sizeof(registry), NSSM_REGISTRY, service_name) < 0) {\r
33     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, "NSSM_REGISTRY", "create_parameters()", 0);\r
34     return 1;\r
35   }\r
36 \r
37   /* Try to open the registry */\r
38   HKEY key;\r
39   if (RegCreateKeyEx(HKEY_LOCAL_MACHINE, registry, 0, 0, REG_OPTION_NON_VOLATILE, KEY_WRITE, 0, &key, 0) != ERROR_SUCCESS) {\r
40     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OPENKEY_FAILED, registry, GetLastError(), 0);\r
41     return 2;\r
42   }\r
43 \r
44   /* Try to create the parameters */\r
45   if (RegSetValueEx(key, NSSM_REG_EXE, 0, REG_EXPAND_SZ, (const unsigned char *) exe, strlen(exe) + 1) != ERROR_SUCCESS) {\r
46     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SETVALUE_FAILED, NSSM_REG_EXE, GetLastError(), 0);\r
47     RegDeleteKey(HKEY_LOCAL_MACHINE, NSSM_REGISTRY);\r
48     RegCloseKey(key);\r
49     return 3;\r
50   }\r
51   if (RegSetValueEx(key, NSSM_REG_FLAGS, 0, REG_EXPAND_SZ, (const unsigned char *) flags, strlen(flags) + 1) != ERROR_SUCCESS) {\r
52     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SETVALUE_FAILED, NSSM_REG_FLAGS, GetLastError(), 0);\r
53     RegDeleteKey(HKEY_LOCAL_MACHINE, NSSM_REGISTRY);\r
54     RegCloseKey(key);\r
55     return 4;\r
56   }\r
57   if (RegSetValueEx(key, NSSM_REG_DIR, 0, REG_EXPAND_SZ, (const unsigned char *) dir, strlen(dir) + 1) != ERROR_SUCCESS) {\r
58     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SETVALUE_FAILED, NSSM_REG_DIR, GetLastError(), 0);\r
59     RegDeleteKey(HKEY_LOCAL_MACHINE, NSSM_REGISTRY);\r
60     RegCloseKey(key);\r
61     return 5;\r
62   }\r
63 \r
64   /* Close registry */\r
65   RegCloseKey(key);\r
66 \r
67   return 0;\r
68 }\r
69 \r
70 int create_exit_action(char *service_name, const char *action_string) {\r
71   /* Get registry */\r
72   char registry[KEY_LENGTH];\r
73   if (_snprintf(registry, sizeof(registry), NSSM_REGISTRY "\\%s", service_name, NSSM_REG_EXIT) < 0) {\r
74     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, "NSSM_REG_EXIT", "create_exit_action()", 0);\r
75     return 1;\r
76   }\r
77 \r
78   /* Try to open the registry */\r
79   HKEY key;\r
80   unsigned long disposition;\r
81   if (RegCreateKeyEx(HKEY_LOCAL_MACHINE, registry, 0, 0, REG_OPTION_NON_VOLATILE, KEY_WRITE, 0, &key, &disposition) != ERROR_SUCCESS) {\r
82     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OPENKEY_FAILED, registry, GetLastError(), 0);\r
83     return 2;\r
84   }\r
85 \r
86   /* Do nothing if the key already existed */\r
87   if (disposition == REG_OPENED_EXISTING_KEY) {\r
88     RegCloseKey(key);\r
89     return 0;\r
90   }\r
91 \r
92   /* Create the default value */\r
93   if (RegSetValueEx(key, 0, 0, REG_SZ, (const unsigned char *) action_string, strlen(action_string) + 1) != ERROR_SUCCESS) {\r
94     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SETVALUE_FAILED, NSSM_REG_EXIT, GetLastError(), 0);\r
95     RegCloseKey(key);\r
96     return 3;\r
97   }\r
98 \r
99   /* Close registry */\r
100   RegCloseKey(key);\r
101 \r
102   return 0;\r
103 }\r
104 \r
105 int expand_parameter(HKEY key, char *value, char *data, unsigned long datalen) {\r
106   unsigned char *buffer = (unsigned char *) HeapAlloc(GetProcessHeap(), 0, datalen);\r
107   if (! buffer) {\r
108     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, value, "expand_parameter()", 0);\r
109     return 1;\r
110   }\r
111 \r
112   unsigned long type = REG_EXPAND_SZ;\r
113   unsigned long buflen = datalen;\r
114 \r
115   unsigned long ret = RegQueryValueEx(key, value, 0, &type, buffer, &buflen);\r
116   if (ret != ERROR_SUCCESS) {\r
117     if (ret != ERROR_FILE_NOT_FOUND) log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_QUERYVALUE_FAILED, value, GetLastError(), 0);\r
118     HeapFree(GetProcessHeap(), 0, buffer);\r
119     return 2;\r
120   }\r
121 \r
122   ZeroMemory(data, datalen);\r
123 \r
124   /* Technically we shouldn't expand environment strings from REG_SZ values */\r
125   if (type != REG_EXPAND_SZ) {\r
126     memmove(data, buffer, buflen);\r
127     HeapFree(GetProcessHeap(), 0, buffer);\r
128     return 0;\r
129   }\r
130 \r
131   ret = ExpandEnvironmentStrings((char *) buffer, data, datalen);\r
132   if (! ret || ret > datalen) {\r
133     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_EXPANDENVIRONMENTSTRINGS_FAILED, value, buffer, GetLastError(), 0);\r
134     HeapFree(GetProcessHeap(), 0, buffer);\r
135     return 3;\r
136   }\r
137 \r
138   HeapFree(GetProcessHeap(), 0, buffer);\r
139   return 0;\r
140 }\r
141 \r
142 int get_parameters(char *service_name, char *exe, int exelen, char *flags, int flagslen, char *dir, int dirlen) {\r
143   /* Get registry */\r
144   char registry[KEY_LENGTH];\r
145   if (_snprintf(registry, sizeof(registry), NSSM_REGISTRY, service_name) < 0) {\r
146     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, "NSSM_REGISTRY", "get_parameters()", 0);\r
147     return 1;\r
148   }\r
149 \r
150   /* Try to open the registry */\r
151   HKEY key;\r
152   if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, registry, 0, KEY_READ, &key) != ERROR_SUCCESS) {\r
153     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OPENKEY_FAILED, registry, GetLastError(), 0);\r
154     return 2;\r
155   }\r
156 \r
157   /* Try to get executable file - MUST succeed */\r
158   if (expand_parameter(key, NSSM_REG_EXE, exe, exelen)) {\r
159     RegCloseKey(key);\r
160     return 3;\r
161   }\r
162 \r
163   /* Try to get flags - may fail and we don't care */\r
164   if (expand_parameter(key, NSSM_REG_FLAGS, flags, flagslen)) {\r
165     log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_NO_FLAGS, NSSM_REG_FLAGS, service_name, exe, 0);\r
166     ZeroMemory(flags, flagslen);\r
167   }\r
168 \r
169   /* Try to get startup directory - may fail and we fall back to a default */\r
170   if (expand_parameter(key, NSSM_REG_DIR, dir, dirlen) || ! dir[0]) {\r
171     /* Our buffers are defined to be long enough for this to be safe */\r
172     size_t i;\r
173     for (i = strlen(exe); i && exe[i] != '\\' && exe[i] != '/'; i--);\r
174     if (i) {\r
175       memmove(dir, exe, i);\r
176       dir[i] = '\0';\r
177     }\r
178     else {\r
179       /* Help! */\r
180       unsigned long ret = ExpandEnvironmentStrings("%SYSTEMROOT%", dir, dirlen);\r
181       if (! ret || ret > dirlen) {\r
182         log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_NO_DIR_AND_NO_FALLBACK, NSSM_REG_DIR, service_name, 0);\r
183         RegCloseKey(key);\r
184         return 4;\r
185       }\r
186     }\r
187     log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_NO_DIR, NSSM_REG_DIR, service_name, dir, 0);\r
188   }\r
189 \r
190   /* Close registry */\r
191   RegCloseKey(key);\r
192 \r
193   return 0;\r
194 }\r
195 \r
196 int get_exit_action(char *service_name, unsigned long *ret, unsigned char *action, bool *default_action) {\r
197   /* Are we returning the default action or a status-specific one? */\r
198   *default_action = ! ret;\r
199 \r
200   /* Get registry */\r
201   char registry[KEY_LENGTH];\r
202   if (_snprintf(registry, sizeof(registry), NSSM_REGISTRY "\\%s", service_name, NSSM_REG_EXIT) < 0) {\r
203     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, "NSSM_REG_EXIT", "get_exit_action()", 0);\r
204     return 1;\r
205   }\r
206 \r
207   /* Try to open the registry */\r
208   HKEY key;\r
209   long error = RegOpenKeyEx(HKEY_LOCAL_MACHINE, registry, 0, KEY_READ, &key);\r
210   if (error != ERROR_SUCCESS && error != ERROR_FILE_NOT_FOUND) {\r
211     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OPENKEY_FAILED, registry, GetLastError(), 0);\r
212     return 2;\r
213   }\r
214 \r
215   unsigned long type = REG_SZ;\r
216   unsigned long action_len = ACTION_LEN;\r
217 \r
218   char code[64];\r
219   if (! ret) code[0] = '\0';\r
220   else if (_snprintf(code, sizeof(code), "%lu", *ret) < 0) {\r
221     RegCloseKey(key);\r
222     return get_exit_action(service_name, 0, action, default_action);\r
223   }\r
224   if (RegQueryValueEx(key, code, 0, &type, action, &action_len) != ERROR_SUCCESS) {\r
225     RegCloseKey(key);\r
226     /* Try again with * as the key if an exit code was defined */\r
227     if (ret) return get_exit_action(service_name, 0, action, default_action);\r
228     return 0;\r
229   }\r
230 \r
231   /* Close registry */\r
232   RegCloseKey(key);\r
233 \r
234   return 0;\r
235 }\r