3390aa666ecd13d68cd4a38e1013935497a9c055
[reactos.git] / reactos / base / services / svchost / svchost.c
1 /*
2 * PROJECT: ReactOS SvcHost
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: /base/services/svchost/svchost.c
5 * PURPOSE: Provide dll service loader
6 * PROGRAMMERS: Gregor Brunmar (gregor.brunmar@home.se)
7 */
8
9 /* INCLUDES ******************************************************************/
10
11 #include "svchost.h"
12
13 #define NDEBUG
14 #include <debug.h>
15
16 #ifdef _MSC_VER
17 #undef DPRINT1
18 #define DPRINT1
19 #endif
20
21 /* DEFINES *******************************************************************/
22
23 static LPCTSTR SVCHOST_REG_KEY = _T("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\SvcHost");
24 static LPCTSTR SERVICE_KEY = _T("SYSTEM\\CurrentControlSet\\Services\\");
25 static LPCTSTR PARAMETERS_KEY = _T("\\Parameters");
26
27 #define SERVICE_KEY_LENGTH _tcslen(SERVICE_KEY);
28 #define REG_MAX_DATA_SIZE 2048
29
30 static PSERVICE FirstService = NULL;
31
32 /* FUNCTIONS *****************************************************************/
33
34 BOOL PrepareService(LPCTSTR ServiceName)
35 {
36 HKEY hServiceKey;
37 TCHAR ServiceKeyBuffer[MAX_PATH + 1];
38 DWORD LeftOfBuffer = sizeof(ServiceKeyBuffer) / sizeof(ServiceKeyBuffer[0]);
39 DWORD KeyType;
40 PTSTR Buffer = NULL;
41 DWORD BufferSize = MAX_PATH + 1;
42 LONG RetVal;
43 HINSTANCE hServiceDll;
44 TCHAR DllPath[MAX_PATH + 2]; /* See MSDN on ExpandEnvironmentStrings() for ANSI strings for more details on + 2 */
45 LPSERVICE_MAIN_FUNCTION ServiceMainFunc;
46 PSERVICE Service;
47
48 /* Compose the registry path to the service's "Parameter" key */
49 _tcsncpy(ServiceKeyBuffer, SERVICE_KEY, LeftOfBuffer);
50 LeftOfBuffer -= _tcslen(SERVICE_KEY);
51 _tcsncat(ServiceKeyBuffer, ServiceName, LeftOfBuffer);
52 LeftOfBuffer -= _tcslen(ServiceName);
53 _tcsncat(ServiceKeyBuffer, PARAMETERS_KEY, LeftOfBuffer);
54 LeftOfBuffer -= _tcslen(PARAMETERS_KEY);
55
56 if (LeftOfBuffer < 0)
57 {
58 DPRINT1("Buffer overflow for service name: '%s'\n", ServiceName);
59 return FALSE;
60 }
61
62 /* Open the service registry key to find the dll name */
63 if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, ServiceKeyBuffer, 0, KEY_READ, &hServiceKey))
64 {
65 DPRINT1("Could not open service key (%s)\n", ServiceKeyBuffer);
66 return FALSE;
67 }
68
69 do
70 {
71 if (Buffer)
72 HeapFree(GetProcessHeap(), 0, Buffer);
73
74 Buffer = HeapAlloc(GetProcessHeap(), 0, BufferSize);
75 if (NULL == Buffer)
76 {
77 DPRINT1("Not enough memory for service: %s\n", ServiceName);
78 return FALSE;
79 }
80
81 RetVal = RegQueryValueEx(hServiceKey, _T("ServiceDll"), NULL, &KeyType, (LPBYTE)Buffer, &BufferSize);
82
83 } while (ERROR_MORE_DATA == RetVal);
84
85
86 RegCloseKey(hServiceKey);
87
88 if (ERROR_SUCCESS != RetVal || 0 == BufferSize)
89 {
90 DPRINT1("Could not read 'ServiceDll' value from service: %s, ErrorCode: 0x%x\n", ServiceName, RetVal);
91 HeapFree(GetProcessHeap(), 0, Buffer);
92 return FALSE;
93 }
94
95 /* Convert possible %SystemRoot% to a real path */
96 BufferSize = ExpandEnvironmentStrings(Buffer, DllPath, sizeof(DllPath));
97 if (0 == BufferSize)
98 {
99 DPRINT1("Invalid ServiceDll path: %s\n", Buffer);
100 HeapFree(GetProcessHeap(), 0, Buffer);
101 return FALSE;
102 }
103
104 HeapFree(GetProcessHeap(), 0, Buffer);
105
106 /* Load the service dll */
107 DPRINT1("Trying to load dll\n");
108 hServiceDll = LoadLibrary(DllPath);
109
110 if (NULL == hServiceDll)
111 {
112 DPRINT1("Unable to load ServiceDll: %s, ErrorCode: %u\n", DllPath, GetLastError());
113 return FALSE;
114 }
115
116 ServiceMainFunc = (LPSERVICE_MAIN_FUNCTION)GetProcAddress(hServiceDll, "ServiceMain");
117
118 /* Allocate a service node in the linked list */
119 Service = HeapAlloc(GetProcessHeap(), 0, sizeof(SERVICE));
120 if (NULL == Service)
121 {
122 DPRINT1("Not enough memory for service: %s\n", ServiceName);
123 return FALSE;
124 }
125
126 memset(Service, 0, sizeof(SERVICE));
127 Service->Name = HeapAlloc(GetProcessHeap(), 0, _tcslen(ServiceName) + sizeof(TCHAR));
128 if (NULL == Service->Name)
129 {
130 DPRINT1("Not enough memory for service: %s\n", ServiceName);
131 HeapFree(GetProcessHeap(), 0, Service);
132 return FALSE;
133 }
134 _tcscpy(Service->Name, ServiceName);
135
136 Service->hServiceDll = hServiceDll;
137 Service->ServiceMainFunc = ServiceMainFunc;
138
139 Service->Next = FirstService;
140 FirstService = Service;
141
142 return TRUE;
143 }
144
145 VOID FreeServices()
146 {
147 while (FirstService)
148 {
149 PSERVICE Service = FirstService;
150 FirstService = Service->Next;
151
152 FreeLibrary(Service->hServiceDll);
153
154 HeapFree(GetProcessHeap(), 0, Service->Name);
155 HeapFree(GetProcessHeap(), 0, Service);
156 }
157 }
158
159 /*
160 * Returns the number of services successfully loaded from the category
161 */
162 DWORD LoadServiceCategory(LPCTSTR ServiceCategory)
163 {
164 HKEY hServicesKey;
165 DWORD KeyType;
166 DWORD BufferSize = REG_MAX_DATA_SIZE;
167 TCHAR Buffer[REG_MAX_DATA_SIZE];
168 LPCTSTR ServiceName;
169 DWORD BufferIndex = 0;
170 DWORD NrOfServices = 0;
171
172 /* Get all the services in this category */
173 if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, SVCHOST_REG_KEY, 0, KEY_READ, &hServicesKey))
174 {
175 DPRINT1("Could not open service category: %s\n", ServiceCategory);
176 return 0;
177 }
178
179 if (ERROR_SUCCESS != RegQueryValueEx(hServicesKey, ServiceCategory, NULL, &KeyType, (LPBYTE)Buffer, &BufferSize))
180 {
181 DPRINT1("Could not open service category (2): %s\n", ServiceCategory);
182 RegCloseKey(hServicesKey);
183 return 0;
184 }
185
186 /* Clean up */
187 RegCloseKey(hServicesKey);
188
189 /* Load services in the category */
190 ServiceName = Buffer;
191 while (_T('\0') != ServiceName[0])
192 {
193 size_t Length;
194
195 Length = _tcslen(ServiceName);
196 if (0 == Length)
197 break;
198
199 if (TRUE == PrepareService(ServiceName))
200 ++NrOfServices;
201
202 BufferIndex += (Length + 1) * sizeof(TCHAR);
203
204 ServiceName = &Buffer[BufferIndex];
205 }
206
207 return NrOfServices;
208 }
209
210 int _tmain (int argc, LPTSTR argv [])
211 {
212 DWORD NrOfServices;
213 LPSERVICE_TABLE_ENTRY ServiceTable;
214
215 if (argc < 3)
216 {
217 /* MS svchost.exe doesn't seem to print help, should we? */
218 return 0;
219 }
220
221 if (_tcscmp(argv[1], _T("-k")) != 0)
222 {
223 /* For now, we only handle "-k" */
224 return 0;
225 }
226
227 NrOfServices = LoadServiceCategory(argv[2]);
228
229 DPRINT1("NrOfServices: %lu\n", NrOfServices);
230 if (0 == NrOfServices)
231 return 0;
232
233 ServiceTable = HeapAlloc(GetProcessHeap(), 0, sizeof(SERVICE_TABLE_ENTRY) * (NrOfServices + 1));
234
235 if (NULL != ServiceTable)
236 {
237 DWORD i;
238 PSERVICE Service = FirstService;
239
240 /* Fill the service table */
241 for (i = 0; i < NrOfServices; ++i)
242 {
243 DPRINT1("Loading service: %s\n", Service->Name);
244 ServiceTable[i].lpServiceName = Service->Name;
245 ServiceTable[i].lpServiceProc = Service->ServiceMainFunc;
246 Service = Service->Next;
247 }
248
249 /* Set a NULL entry to end the service table */
250 ServiceTable[i].lpServiceName = NULL;
251 ServiceTable[i].lpServiceProc = NULL;
252
253 if (FALSE == StartServiceCtrlDispatcher(ServiceTable))
254 printf("Failed to start service control dispatcher, ErrorCode: %lu\n", GetLastError());
255
256 HeapFree(GetProcessHeap(), 0, ServiceTable);
257 }
258 else
259 {
260 DPRINT1("Not enough memory for the service table, trying to allocate %u bytes\n", sizeof(SERVICE_TABLE_ENTRY) * (NrOfServices + 1));
261 }
262
263 DPRINT1("Freeing services...\n");
264 FreeServices();
265
266 return 0;
267 }
268
269 /* EOF */