1 /*
2 * Services.exe - RPC functions
3 *
4 * Copyright 2007 Google (Mikolaj Zalewski)
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #define WIN32_LEAN_AND_MEAN
22
23 #include <stdarg.h>
24 #include <windows.h>
25 #include <winternl.h>
26 #include <winsvc.h>
27 #include <ntsecapi.h>
28 #include <rpc.h>
29
30 #include "wine/list.h"
31 #include "wine/unicode.h"
32 #include "wine/debug.h"
33
34 #include "services.h"
35 #include "svcctl.h"
36
37 extern HANDLE CDECL __wine_make_process_system(void);
38
39 WINE_DEFAULT_DEBUG_CHANNEL(service);
40
41 static const GENERIC_MAPPING g_scm_generic =
42 {
43 (STANDARD_RIGHTS_READ | SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_QUERY_LOCK_STATUS),
44 (STANDARD_RIGHTS_WRITE | SC_MANAGER_CREATE_SERVICE | SC_MANAGER_MODIFY_BOOT_CONFIG),
45 (STANDARD_RIGHTS_EXECUTE | SC_MANAGER_CONNECT | SC_MANAGER_LOCK),
46 SC_MANAGER_ALL_ACCESS
47 };
48
49 static const GENERIC_MAPPING g_svc_generic =
50 {
51 (STANDARD_RIGHTS_READ | SERVICE_QUERY_CONFIG | SERVICE_QUERY_STATUS | SERVICE_INTERROGATE | SERVICE_ENUMERATE_DEPENDENTS),
52 (STANDARD_RIGHTS_WRITE | SERVICE_CHANGE_CONFIG),
53 (STANDARD_RIGHTS_EXECUTE | SERVICE_START | SERVICE_STOP | SERVICE_PAUSE_CONTINUE | SERVICE_USER_DEFINED_CONTROL),
54 SERVICE_ALL_ACCESS
55 };
56
57 typedef enum
58 {
59 SC_HTYPE_DONT_CARE = 0,
60 SC_HTYPE_MANAGER,
61 SC_HTYPE_SERVICE
62 } SC_HANDLE_TYPE;
63
64 struct sc_handle
65 {
66 SC_HANDLE_TYPE type;
67 DWORD access;
68 };
69
70 struct sc_manager_handle /* service control manager handle */
71 {
72 struct sc_handle hdr;
73 struct scmdatabase *db;
74 };
75
76 struct sc_service_handle /* service handle */
77 {
78 struct sc_handle hdr;
79 struct service_entry *service_entry;
80 };
81
82 struct sc_lock
83 {
84 struct scmdatabase *db;
85 };
86
87 static void free_service_strings(struct service_entry *old, struct service_entry *new)
88 {
89 QUERY_SERVICE_CONFIGW *old_cfg = &old->config;
90 QUERY_SERVICE_CONFIGW *new_cfg = &new->config;
91
92 if (old_cfg->lpBinaryPathName != new_cfg->lpBinaryPathName)
93 HeapFree(GetProcessHeap(), 0, old_cfg->lpBinaryPathName);
94
95 if (old_cfg->lpLoadOrderGroup != new_cfg->lpLoadOrderGroup)
96 HeapFree(GetProcessHeap(), 0, old_cfg->lpLoadOrderGroup);
97
98 if (old_cfg->lpServiceStartName != new_cfg->lpServiceStartName)
99 HeapFree(GetProcessHeap(), 0, old_cfg->lpServiceStartName);
100
101 if (old_cfg->lpDisplayName != new_cfg->lpDisplayName)
102 HeapFree(GetProcessHeap(), 0, old_cfg->lpDisplayName);
103
104 if (old->dependOnServices != new->dependOnServices)
105 HeapFree(GetProcessHeap(), 0, old->dependOnServices);
106
107 if (old->dependOnGroups != new->dependOnGroups)
108 HeapFree(GetProcessHeap(), 0, old->dependOnGroups);
109 }
110
111 /* Check if the given handle is of the required type and allows the requested access. */
112 static DWORD validate_context_handle(SC_RPC_HANDLE handle, DWORD type, DWORD needed_access, struct sc_handle **out_hdr)
113 {
114 struct sc_handle *hdr = handle;
115
116 if (type != SC_HTYPE_DONT_CARE && hdr->type != type)
117 {
118 WINE_ERR("Handle is of an invalid type (%d, %d)\n", hdr->type, type);
119 return ERROR_INVALID_HANDLE;
120 }
121
122 if ((needed_access & hdr->access) != needed_access)
123 {
124 WINE_ERR("Access denied - handle created with access %x, needed %x\n", hdr->access, needed_access);
125 return ERROR_ACCESS_DENIED;
126 }
127
128 *out_hdr = hdr;
129 return ERROR_SUCCESS;
130 }
131
132 static DWORD validate_scm_handle(SC_RPC_HANDLE handle, DWORD needed_access, struct sc_manager_handle **manager)
133 {
134 struct sc_handle *hdr;
135 DWORD err = validate_context_handle(handle, SC_HTYPE_MANAGER, needed_access, &hdr);
136 if (err == ERROR_SUCCESS)
137 *manager = (struct sc_manager_handle *)hdr;
138 return err;
139 }
140
141 static DWORD validate_service_handle(SC_RPC_HANDLE handle, DWORD needed_access, struct sc_service_handle **service)
142 {
143 struct sc_handle *hdr;
144 DWORD err = validate_context_handle(handle, SC_HTYPE_SERVICE, needed_access, &hdr);
145 if (err == ERROR_SUCCESS)
146 *service = (struct sc_service_handle *)hdr;
147 return err;
148 }
149
150 DWORD __cdecl svcctl_OpenSCManagerW(
151 MACHINE_HANDLEW MachineName, /* Note: this parameter is ignored */
152 LPCWSTR DatabaseName,
153 DWORD dwAccessMask,
154 SC_RPC_HANDLE *handle)
155 {
156 struct sc_manager_handle *manager;
157
158 WINE_TRACE("(%s, %s, %x)\n", wine_dbgstr_w(MachineName), wine_dbgstr_w(DatabaseName), dwAccessMask);
159
160 if (DatabaseName != NULL && DatabaseName[0])
161 {
162 if (strcmpW(DatabaseName, SERVICES_FAILED_DATABASEW) == 0)
163 return ERROR_DATABASE_DOES_NOT_EXIST;
164 if (strcmpW(DatabaseName, SERVICES_ACTIVE_DATABASEW) != 0)
165 return ERROR_INVALID_NAME;
166 }
167
168 if (!(manager = HeapAlloc(GetProcessHeap(), 0, sizeof(*manager))))
169 return ERROR_NOT_ENOUGH_SERVER_MEMORY;
170
171 manager->hdr.type = SC_HTYPE_MANAGER;
172
173 if (dwAccessMask & MAXIMUM_ALLOWED)
174 dwAccessMask |= SC_MANAGER_ALL_ACCESS;
175 manager->hdr.access = dwAccessMask;
176 RtlMapGenericMask(&manager->hdr.access, &g_scm_generic);
177 manager->db = active_database;
178 *handle = &manager->hdr;
179
180 return ERROR_SUCCESS;
181 }
182
183 static void SC_RPC_HANDLE_destroy(SC_RPC_HANDLE handle)
184 {
185 struct sc_handle *hdr = handle;
186 switch (hdr->type)
187 {
188 case SC_HTYPE_MANAGER:
189 {
190 struct sc_manager_handle *manager = (struct sc_manager_handle *)hdr;
191 HeapFree(GetProcessHeap(), 0, manager);
192 break;
193 }
194 case SC_HTYPE_SERVICE:
195 {
196 struct sc_service_handle *service = (struct sc_service_handle *)hdr;
197 release_service(service->service_entry);
198 HeapFree(GetProcessHeap(), 0, service);
199 break;
200 }
201 default:
202 WINE_ERR("invalid handle type %d\n", hdr->type);
203 RpcRaiseException(ERROR_INVALID_HANDLE);
204 }
205 }
206
207 DWORD __cdecl svcctl_GetServiceDisplayNameW(
208 SC_RPC_HANDLE hSCManager,
209 LPCWSTR lpServiceName,
210 WCHAR *lpBuffer,
211 DWORD *cchBufSize)
212 {
213 struct sc_manager_handle *manager;
214 struct service_entry *entry;
215 DWORD err;
216
217 WINE_TRACE("(%s, %d)\n", wine_dbgstr_w(lpServiceName), *cchBufSize);
218
219 if ((err = validate_scm_handle(hSCManager, 0, &manager)) != ERROR_SUCCESS)
220 return err;
221
222 scmdatabase_lock_shared(manager->db);
223
224 entry = scmdatabase_find_service(manager->db, lpServiceName);
225 if (entry != NULL)
226 {
227 LPCWSTR name;
228 int len;
229 service_lock_shared(entry);
230 name = get_display_name(entry);
231 len = strlenW(name);
232 if (len <= *cchBufSize)
233 {
234 err = ERROR_SUCCESS;
235 memcpy(lpBuffer, name, (len + 1)*sizeof(*name));
236 }
237 else
238 err = ERROR_INSUFFICIENT_BUFFER;
239 *cchBufSize = len;
240 service_unlock(entry);
241 }
242 else
243 err = ERROR_SERVICE_DOES_NOT_EXIST;
244
245 scmdatabase_unlock(manager->db);
246
247 if (err != ERROR_SUCCESS)
248 lpBuffer[0] = 0;
249
250 return err;
251 }
252
253 DWORD __cdecl svcctl_GetServiceKeyNameW(
254 SC_RPC_HANDLE hSCManager,
255 LPCWSTR lpServiceDisplayName,
256 WCHAR *lpBuffer,
257 DWORD *cchBufSize)
258 {
259 struct service_entry *entry;
260 struct sc_manager_handle *manager;
261 DWORD err;
262
263 WINE_TRACE("(%s, %d)\n", wine_dbgstr_w(lpServiceDisplayName), *cchBufSize);
264
265 if ((err = validate_scm_handle(hSCManager, 0, &manager)) != ERROR_SUCCESS)
266 return err;
267
268 scmdatabase_lock_shared(manager->db);
269
270 entry = scmdatabase_find_service_by_displayname(manager->db, lpServiceDisplayName);
271 if (entry != NULL)
272 {
273 int len;
274 service_lock_shared(entry);
275 len = strlenW(entry->name);
276 if (len <= *cchBufSize)
277 {
278 err = ERROR_SUCCESS;
279 memcpy(lpBuffer, entry->name, (len + 1)*sizeof(*entry->name));
280 }
281 else
282 err = ERROR_INSUFFICIENT_BUFFER;
283 *cchBufSize = len;
284 service_unlock(entry);
285 }
286 else
287 err = ERROR_SERVICE_DOES_NOT_EXIST;
288
289 scmdatabase_unlock(manager->db);
290
291 if (err != ERROR_SUCCESS)
292 lpBuffer[0] = 0;
293
294 return err;
295 }
296
297 static DWORD create_handle_for_service(struct service_entry *entry, DWORD dwDesiredAccess, SC_RPC_HANDLE *phService)
298 {
299 struct sc_service_handle *service;
300
301 if (!(service = HeapAlloc(GetProcessHeap(), 0, sizeof(*service))))
302 {
303 release_service(entry);
304 return ERROR_NOT_ENOUGH_SERVER_MEMORY;
305 }
306
307 service->hdr.type = SC_HTYPE_SERVICE;
308 service->hdr.access = dwDesiredAccess;
309 RtlMapGenericMask(&service->hdr.access, &g_svc_generic);
310 service->service_entry = entry;
311 if (dwDesiredAccess & MAXIMUM_ALLOWED)
312 dwDesiredAccess |= SERVICE_ALL_ACCESS;
313
314 *phService = &service->hdr;
315 return ERROR_SUCCESS;
316 }
317
318 DWORD __cdecl svcctl_OpenServiceW(
319 SC_RPC_HANDLE hSCManager,
320 LPCWSTR lpServiceName,
321 DWORD dwDesiredAccess,
322 SC_RPC_HANDLE *phService)
323 {
324 struct sc_manager_handle *manager;
325 struct service_entry *entry;
326 DWORD err;
327
328 WINE_TRACE("(%s, 0x%x)\n", wine_dbgstr_w(lpServiceName), dwDesiredAccess);
329
330 if ((err = validate_scm_handle(hSCManager, 0, &manager)) != ERROR_SUCCESS)
331 return err;
332 if (!validate_service_name(lpServiceName))
333 return ERROR_INVALID_NAME;
334
335 scmdatabase_lock_shared(manager->db);
336 entry = scmdatabase_find_service(manager->db, lpServiceName);
337 if (entry != NULL)
338 InterlockedIncrement(&entry->ref_count);
339 scmdatabase_unlock(manager->db);
340
341 if (entry == NULL)
342 return ERROR_SERVICE_DOES_NOT_EXIST;
343
344 return create_handle_for_service(entry, dwDesiredAccess, phService);
345 }
346
347 static DWORD parse_dependencies(const WCHAR *dependencies, struct service_entry *entry)
348 {
349 WCHAR *services = NULL, *groups, *s;
350 DWORD len, len_services = 0, len_groups = 0;
351 const WCHAR *ptr = dependencies;
352
353 if (!dependencies || !dependencies[0])
354 {
355 entry->dependOnServices = NULL;
356 entry->dependOnGroups = NULL;
357 return ERROR_SUCCESS;
358 }
359
360 while (*ptr)
361 {
362 len = strlenW(ptr) + 1;
363 if (ptr[0] == '+' && ptr[1])
364 len_groups += len - 1;
365 else
366 len_services += len;
367 ptr += len;
368 }
369 if (!len_services) entry->dependOnServices = NULL;
370 else
371 {
372 services = HeapAlloc(GetProcessHeap(), 0, (len_services + 1) * sizeof(WCHAR));
373 if (!services)
374 return ERROR_OUTOFMEMORY;
375
376 s = services;
377 ptr = dependencies;
378 while (*ptr)
379 {
380 len = strlenW(ptr) + 1;
381 if (*ptr != '+')
382 {
383 strcpyW(s, ptr);
384 s += len;
385 }
386 ptr += len;
387 }
388 *s = 0;
389 entry->dependOnServices = services;
390 }
391 if (!len_groups) entry->dependOnGroups = NULL;
392 else
393 {
394 groups = HeapAlloc(GetProcessHeap(), 0, (len_groups + 1) * sizeof(WCHAR));
395 if (!groups)
396 {
397 HeapFree(GetProcessHeap(), 0, services);
398 return ERROR_OUTOFMEMORY;
399 }
400 s = groups;
401 ptr = dependencies;
402 while (*ptr)
403 {
404 len = strlenW(ptr) + 1;
405 if (ptr[0] == '+' && ptr[1])
406 {
407 strcpyW(s, ptr + 1);
408 s += len - 1;
409 }
410 ptr += len;
411 }
412 *s = 0;
413 entry->dependOnGroups = groups;
414 }
415
416 return ERROR_SUCCESS;
417 }
418
419 DWORD __cdecl svcctl_CreateServiceW(
420 SC_RPC_HANDLE hSCManager,
421 LPCWSTR lpServiceName,
422 LPCWSTR lpDisplayName,
423 DWORD dwDesiredAccess,
424 DWORD dwServiceType,
425 DWORD dwStartType,
426 DWORD dwErrorControl,
427 LPCWSTR lpBinaryPathName,
428 LPCWSTR lpLoadOrderGroup,
429 DWORD *lpdwTagId,
430 const BYTE *lpDependencies,
431 DWORD dwDependenciesSize,
432 LPCWSTR lpServiceStartName,
433 const BYTE *lpPassword,
434 DWORD dwPasswordSize,
435 SC_RPC_HANDLE *phService)
436 {
437 struct sc_manager_handle *manager;
438 struct service_entry *entry;
439 DWORD err;
440
441 WINE_TRACE("(%s, %s, 0x%x, %s)\n", wine_dbgstr_w(lpServiceName), wine_dbgstr_w(lpDisplayName), dwDesiredAccess, wine_dbgstr_w(lpBinaryPathName));
442
443 if ((err = validate_scm_handle(hSCManager, SC_MANAGER_CREATE_SERVICE, &manager)) != ERROR_SUCCESS)
444 return err;
445
446 if (!validate_service_name(lpServiceName))
447 return ERROR_INVALID_NAME;
448 if (!check_multisz((LPCWSTR)lpDependencies, dwDependenciesSize) || !lpServiceName[0] || !lpBinaryPathName[0])
449 return ERROR_INVALID_PARAMETER;
450
451 if (lpPassword)
452 WINE_FIXME("Don't know how to add a password\n"); /* I always get ERROR_GEN_FAILURE */
453
454 err = service_create(lpServiceName, &entry);
455 if (err != ERROR_SUCCESS)
456 return err;
457
458 err = parse_dependencies((LPCWSTR)lpDependencies, entry);
459 if (err != ERROR_SUCCESS)
460 return err;
461
462 entry->ref_count = 1;
463 entry->config.dwServiceType = entry->status.dwServiceType = dwServiceType;
464 entry->config.dwStartType = dwStartType;
465 entry->config.dwErrorControl = dwErrorControl;
466 entry->config.lpBinaryPathName = strdupW(lpBinaryPathName);
467 entry->config.lpLoadOrderGroup = strdupW(lpLoadOrderGroup);
468 entry->config.lpServiceStartName = strdupW(lpServiceStartName);
469 entry->config.lpDisplayName = strdupW(lpDisplayName);
470
471 if (lpdwTagId) /* TODO: In most situations a non-NULL TagId will generate an ERROR_INVALID_PARAMETER. */
472 entry->config.dwTagId = *lpdwTagId;
473 else
474 entry->config.dwTagId = 0;
475
476 /* other fields NULL*/
477
478 if (!validate_service_config(entry))
479 {
480 WINE_ERR("Invalid data while trying to create service\n");
481 free_service_entry(entry);
482 return ERROR_INVALID_PARAMETER;
483 }
484
485 scmdatabase_lock_exclusive(manager->db);
486
487 if (scmdatabase_find_service(manager->db, lpServiceName))
488 {
489 scmdatabase_unlock(manager->db);
490 free_service_entry(entry);
491 return ERROR_SERVICE_EXISTS;
492 }
493
494 if (scmdatabase_find_service_by_displayname(manager->db, get_display_name(entry)))
495 {
496 scmdatabase_unlock(manager->db);
497 free_service_entry(entry);
498 return ERROR_DUPLICATE_SERVICE_NAME;
499 }
500
501 err = scmdatabase_add_service(manager->db, entry);
502 if (err != ERROR_SUCCESS)
503 {
504 scmdatabase_unlock(manager->db);
505 free_service_entry(entry);
506 return err;
507 }
508 scmdatabase_unlock(manager->db);
509
510 return create_handle_for_service(entry, dwDesiredAccess, phService);
511 }
512
513 DWORD __cdecl svcctl_DeleteService(
514 SC_RPC_HANDLE hService)
515 {
516 struct sc_service_handle *service;
517 DWORD err;
518
519 if ((err = validate_service_handle(hService, DELETE, &service)) != ERROR_SUCCESS)
520 return err;
521
522 scmdatabase_lock_exclusive(service->service_entry->db);
523 service_lock_exclusive(service->service_entry);
524
525 if (!is_marked_for_delete(service->service_entry))
526 err = scmdatabase_remove_service(service->service_entry->db, service->service_entry);
527 else
528 err = ERROR_SERVICE_MARKED_FOR_DELETE;
529
530 service_unlock(service->service_entry);
531 scmdatabase_unlock(service->service_entry->db);
532
533 return err;
534 }
535
536 DWORD __cdecl svcctl_QueryServiceConfigW(
537 SC_RPC_HANDLE hService,
538 QUERY_SERVICE_CONFIGW *config)
539 {
540 struct sc_service_handle *service;
541 DWORD err;
542
543 WINE_TRACE("(%p)\n", config);
544
545 if ((err = validate_service_handle(hService, SERVICE_QUERY_CONFIG, &service)) != 0)
546 return err;
547
548 service_lock_shared(service->service_entry);
549 config->dwServiceType = service->service_entry->config.dwServiceType;
550 config->dwStartType = service->service_entry->config.dwStartType;
551 config->dwErrorControl = service->service_entry->config.dwErrorControl;
552 config->lpBinaryPathName = strdupW(service->service_entry->config.lpBinaryPathName);
553 config->lpLoadOrderGroup = strdupW(service->service_entry->config.lpLoadOrderGroup);
554 config->dwTagId = service->service_entry->config.dwTagId;
555 config->lpDependencies = NULL; /* TODO */
556 config->lpServiceStartName = strdupW(service->service_entry->config.lpServiceStartName);
557 config->lpDisplayName = strdupW(service->service_entry->config.lpDisplayName);
558 service_unlock(service->service_entry);
559
560 return ERROR_SUCCESS;
561 }
562
563 DWORD __cdecl svcctl_ChangeServiceConfigW(
564 SC_RPC_HANDLE hService,
565 DWORD dwServiceType,
566 DWORD dwStartType,
567 DWORD dwErrorControl,
568 LPCWSTR lpBinaryPathName,
569 LPCWSTR lpLoadOrderGroup,
570 DWORD *lpdwTagId,
571 const BYTE *lpDependencies,
572 DWORD dwDependenciesSize,
573 LPCWSTR lpServiceStartName,
574 const BYTE *lpPassword,
575 DWORD dwPasswordSize,
576 LPCWSTR lpDisplayName)
577 {
578 struct service_entry new_entry, *entry;
579 struct sc_service_handle *service;
580 DWORD err;
581
582 WINE_TRACE("\n");
583
584 if ((err = validate_service_handle(hService, SERVICE_CHANGE_CONFIG, &service)) != 0)
585 return err;
586
587 if (!check_multisz((LPCWSTR)lpDependencies, dwDependenciesSize))
588 return ERROR_INVALID_PARAMETER;
589
590 /* first check if the new configuration is correct */
591 service_lock_exclusive(service->service_entry);
592
593 if (is_marked_for_delete(service->service_entry))
594 {
595 service_unlock(service->service_entry);
596 return ERROR_SERVICE_MARKED_FOR_DELETE;
597 }
598
599 if (lpDisplayName != NULL &&
600 (entry = scmdatabase_find_service_by_displayname(service->service_entry->db, lpDisplayName)) &&
601 (entry != service->service_entry))
602 {
603 service_unlock(service->service_entry);
604 return ERROR_DUPLICATE_SERVICE_NAME;
605 }
606
607 new_entry = *service->service_entry;
608
609 if (dwServiceType != SERVICE_NO_CHANGE)
610 new_entry.config.dwServiceType = dwServiceType;
611
612 if (dwStartType != SERVICE_NO_CHANGE)
613 new_entry.config.dwStartType = dwStartType;
614
615 if (dwErrorControl != SERVICE_NO_CHANGE)
616 new_entry.config.dwErrorControl = dwErrorControl;
617
618 if (lpBinaryPathName != NULL)
619 new_entry.config.lpBinaryPathName = (LPWSTR)lpBinaryPathName;
620
621 if (lpLoadOrderGroup != NULL)
622 new_entry.config.lpLoadOrderGroup = (LPWSTR)lpLoadOrderGroup;
623
624 if (lpdwTagId != NULL)
625 WINE_FIXME("Changing tag id not supported\n");
626
627 if (lpServiceStartName != NULL)
628 new_entry.config.lpServiceStartName = (LPWSTR)lpServiceStartName;
629
630 if (lpPassword != NULL)
631 WINE_FIXME("Setting password not supported\n");
632
633 if (lpDisplayName != NULL)
634 new_entry.config.lpDisplayName = (LPWSTR)lpDisplayName;
635
636 err = parse_dependencies((LPCWSTR)lpDependencies, &new_entry);
637 if (err != ERROR_SUCCESS)
638 {
639 service_unlock(service->service_entry);
640 return err;
641 }
642
643 if (!validate_service_config(&new_entry))
644 {
645 WINE_ERR("The configuration after the change wouldn't be valid\n");
646 service_unlock(service->service_entry);
647 return ERROR_INVALID_PARAMETER;
648 }
649
650 /* configuration OK. The strings needs to be duplicated */
651 if (lpBinaryPathName != NULL)
652 new_entry.config.lpBinaryPathName = strdupW(lpBinaryPathName);
653
654 if (lpLoadOrderGroup != NULL)
655 new_entry.config.lpLoadOrderGroup = strdupW(lpLoadOrderGroup);
656
657 if (lpServiceStartName != NULL)
658 new_entry.config.lpServiceStartName = strdupW(lpServiceStartName);
659
660 if (lpDisplayName != NULL)
661 new_entry.config.lpDisplayName = strdupW(lpDisplayName);
662
663 /* try to save to Registry, commit or rollback depending on success */
664 err = save_service_config(&new_entry);
665 if (ERROR_SUCCESS == err)
666 {
667 free_service_strings(service->service_entry, &new_entry);
668 *service->service_entry = new_entry;
669 }
670 else free_service_strings(&new_entry, service->service_entry);
671 service_unlock(service->service_entry);
672
673 return err;
674 }
675
676 DWORD __cdecl svcctl_SetServiceStatus(
677 SC_RPC_HANDLE hServiceStatus,
678 LPSERVICE_STATUS lpServiceStatus)
679 {
680 struct sc_service_handle *service;
681 DWORD err;
682
683 WINE_TRACE("(%p, %p)\n", hServiceStatus, lpServiceStatus);
684
685 if ((err = validate_service_handle(hServiceStatus, SERVICE_SET_STATUS, &service)) != 0)
686 return err;
687
688 service_lock_exclusive(service->service_entry);
689 /* FIXME: be a bit more discriminant about what parts of the status we set
690 * and check that fields are valid */
691 service->service_entry->status.dwServiceType = lpServiceStatus->dwServiceType;
692 service->service_entry->status.dwCurrentState = lpServiceStatus->dwCurrentState;
693 service->service_entry->status.dwControlsAccepted = lpServiceStatus->dwControlsAccepted;
694 service->service_entry->status.dwWin32ExitCode = lpServiceStatus->dwWin32ExitCode;
695 service->service_entry->status.dwServiceSpecificExitCode = lpServiceStatus->dwServiceSpecificExitCode;
696 service->service_entry->status.dwCheckPoint = lpServiceStatus->dwCheckPoint;
697 service->service_entry->status.dwWaitHint = lpServiceStatus->dwWaitHint;
698 service_unlock(service->service_entry);
699
700 if (service->service_entry->status_changed_event)
701 SetEvent(service->service_entry->status_changed_event);
702
703 return ERROR_SUCCESS;
704 }
705
706 DWORD __cdecl svcctl_ChangeServiceConfig2W( SC_RPC_HANDLE hService, DWORD level, SERVICE_CONFIG2W *config )
707 {
708 struct sc_service_handle *service;
709 DWORD err;
710
711 if ((err = validate_service_handle(hService, SERVICE_CHANGE_CONFIG, &service)) != 0)
712 return err;
713
714 switch (level)
715 {
716 case SERVICE_CONFIG_DESCRIPTION:
717 {
718 WCHAR *descr = NULL;
719
720 if (config->descr.lpDescription[0])
721 {
722 if (!(descr = strdupW( config->descr.lpDescription )))
723 return ERROR_NOT_ENOUGH_MEMORY;
724 }
725
726 WINE_TRACE( "changing service %p descr to %s\n", service, wine_dbgstr_w(descr) );
727 service_lock_exclusive( service->service_entry );
728 HeapFree( GetProcessHeap(), 0, service->service_entry->description );
729 service->service_entry->description = descr;
730 save_service_config( service->service_entry );
731 service_unlock( service->service_entry );
732 }
733 break;
734 case SERVICE_CONFIG_FAILURE_ACTIONS:
735 WINE_FIXME( "SERVICE_CONFIG_FAILURE_ACTIONS not implemented: period %u msg %s cmd %s\n",
736 config->actions.dwResetPeriod,
737 wine_dbgstr_w(config->actions.lpRebootMsg),
738 wine_dbgstr_w(config->actions.lpCommand) );
739 break;
740 default:
741 WINE_FIXME("level %u not implemented\n", level);
742 err = ERROR_INVALID_LEVEL;
743 break;
744 }
745 return err;
746 }
747
748 DWORD __cdecl svcctl_QueryServiceConfig2W( SC_RPC_HANDLE hService, DWORD level,
749 BYTE *buffer, DWORD size, LPDWORD needed )
750 {
751 struct sc_service_handle *service;
752 DWORD err;
753
754 memset(buffer, 0, size);
755
756 if ((err = validate_service_handle(hService, SERVICE_QUERY_STATUS, &service)) != 0)
757 return err;
758
759 switch (level)
760 {
761 case SERVICE_CONFIG_DESCRIPTION:
762 {
763 SERVICE_DESCRIPTIONW *descr = (SERVICE_DESCRIPTIONW *)buffer;
764
765 service_lock_shared(service->service_entry);
766 *needed = sizeof(*descr);
767 if (service->service_entry->description)
768 *needed += (strlenW(service->service_entry->description) + 1) * sizeof(WCHAR);
769 if (size >= *needed)
770 {
771 if (service->service_entry->description)
772 {
773 /* store a buffer offset instead of a pointer */
774 descr->lpDescription = (WCHAR *)((BYTE *)(descr + 1) - buffer);
775 strcpyW( (WCHAR *)(descr + 1), service->service_entry->description );
776 }
777 else descr->lpDescription = NULL;
778 }
779 else err = ERROR_INSUFFICIENT_BUFFER;
780 service_unlock(service->service_entry);
781 }
782 break;
783
784 default:
785 WINE_FIXME("level %u not implemented\n", level);
786 err = ERROR_INVALID_LEVEL;
787 break;
788 }
789 return err;
790 }
791
792 DWORD __cdecl svcctl_QueryServiceStatusEx(
793 SC_RPC_HANDLE hService,
794 SC_STATUS_TYPE InfoLevel,
795 BYTE *lpBuffer,
796 DWORD cbBufSize,
797 LPDWORD pcbBytesNeeded)
798 {
799 struct sc_service_handle *service;
800 DWORD err;
801 LPSERVICE_STATUS_PROCESS pSvcStatusData;
802
803 memset(lpBuffer, 0, cbBufSize);
804
805 if ((err = validate_service_handle(hService, SERVICE_QUERY_STATUS, &service)) != 0)
806 return err;
807
808 if (InfoLevel != SC_STATUS_PROCESS_INFO)
809 return ERROR_INVALID_LEVEL;
810
811 pSvcStatusData = (LPSERVICE_STATUS_PROCESS) lpBuffer;
812 if (pSvcStatusData == NULL)
813 return ERROR_INVALID_PARAMETER;
814
815 if (cbBufSize < sizeof(SERVICE_STATUS_PROCESS))
816 {
817 if( pcbBytesNeeded != NULL)
818 *pcbBytesNeeded = sizeof(SERVICE_STATUS_PROCESS);
819
820 return ERROR_INSUFFICIENT_BUFFER;
821 }
822
823 service_lock_shared(service->service_entry);
824
825 pSvcStatusData->dwServiceType = service->service_entry->status.dwServiceType;
826 pSvcStatusData->dwCurrentState = service->service_entry->status.dwCurrentState;
827 pSvcStatusData->dwControlsAccepted = service->service_entry->status.dwControlsAccepted;
828 pSvcStatusData->dwWin32ExitCode = service->service_entry->status.dwWin32ExitCode;
829 pSvcStatusData->dwServiceSpecificExitCode = service->service_entry->status.dwServiceSpecificExitCode;
830 pSvcStatusData->dwCheckPoint = service->service_entry->status.dwCheckPoint;
831 pSvcStatusData->dwWaitHint = service->service_entry->status.dwWaitHint;
832 pSvcStatusData->dwProcessId = service->service_entry->status.dwProcessId;
833 pSvcStatusData->dwServiceFlags = service->service_entry->status.dwServiceFlags;
834
835 service_unlock(service->service_entry);
836
837 return ERROR_SUCCESS;
838 }
839
840 /******************************************************************************
841 * service_accepts_control
842 */
843 static BOOL service_accepts_control(const struct service_entry *service, DWORD dwControl)
844 {
845 DWORD a = service->status.dwControlsAccepted;
846
847 switch (dwControl)
848 {
849 case SERVICE_CONTROL_INTERROGATE:
850 return TRUE;
851 case SERVICE_CONTROL_STOP:
852 if (a&SERVICE_ACCEPT_STOP)
853 return TRUE;
854 break;
855 case SERVICE_CONTROL_SHUTDOWN:
856 if (a&SERVICE_ACCEPT_SHUTDOWN)
857 return TRUE;
858 break;
859 case SERVICE_CONTROL_PAUSE:
860 case SERVICE_CONTROL_CONTINUE:
861 if (a&SERVICE_ACCEPT_PAUSE_CONTINUE)
862 return TRUE;
863 break;
864 case SERVICE_CONTROL_PARAMCHANGE:
865 if (a&SERVICE_ACCEPT_PARAMCHANGE)
866 return TRUE;
867 break;
868 case SERVICE_CONTROL_NETBINDADD:
869 case SERVICE_CONTROL_NETBINDREMOVE:
870 case SERVICE_CONTROL_NETBINDENABLE:
871 case SERVICE_CONTROL_NETBINDDISABLE:
872 if (a&SERVICE_ACCEPT_NETBINDCHANGE)
873 return TRUE;
874 case SERVICE_CONTROL_HARDWAREPROFILECHANGE:
875 if (a&SERVICE_ACCEPT_HARDWAREPROFILECHANGE)
876 return TRUE;
877 break;
878 case SERVICE_CONTROL_POWEREVENT:
879 if (a&SERVICE_ACCEPT_POWEREVENT)
880 return TRUE;
881 break;
882 case SERVICE_CONTROL_SESSIONCHANGE:
883 if (a&SERVICE_ACCEPT_SESSIONCHANGE)
884 return TRUE;
885 break;
886 }
887 return FALSE;
888 }
889
890 /******************************************************************************
891 * service_send_command
892 */
893 BOOL service_send_command( struct service_entry *service, HANDLE pipe,
894 const void *data, DWORD size, DWORD *result )
895 {
896 OVERLAPPED overlapped;
897 DWORD count;
898 BOOL r;
899
900 overlapped.hEvent = service->overlapped_event;
901 r = WriteFile(pipe, data, size, &count, &overlapped);
902 if (!r && GetLastError() == ERROR_IO_PENDING)
903 {
904 WaitForSingleObject( service->overlapped_event, service_pipe_timeout );
905 r = GetOverlappedResult( pipe, &overlapped, &count, FALSE );
906 }
907 if (!r || count != size)
908 {
909 WINE_ERR("service protocol error - failed to write pipe!\n");
910 return FALSE;
911 }
912 r = ReadFile(pipe, result, sizeof *result, &count, &overlapped);
913 if (!r && GetLastError() == ERROR_IO_PENDING)
914 {
915 WaitForSingleObject( service->overlapped_event, service_pipe_timeout );
916 r = GetOverlappedResult( pipe, &overlapped, &count, FALSE );
917 }
918 if (!r || count != sizeof *result)
919 {
920 WINE_ERR("service protocol error - failed to read pipe "
921 "r = %d count = %d!\n", r, count);
922 return FALSE;
923 }
924 return r;
925 }
926
927 /******************************************************************************
928 * service_send_control
929 */
930 static BOOL service_send_control(struct service_entry *service, HANDLE pipe, DWORD dwControl, DWORD *result)
931 {
932 service_start_info *ssi;
933 DWORD len;
934 BOOL r;
935
936 /* calculate how much space we need to send the startup info */
937 len = strlenW(service->name) + 1;
938
939 ssi = HeapAlloc(GetProcessHeap(),0,FIELD_OFFSET(service_start_info, data[len]));
940 ssi->cmd = WINESERV_SENDCONTROL;
941 ssi->control = dwControl;
942 ssi->total_size = FIELD_OFFSET(service_start_info, data[len]);
943 ssi->name_size = strlenW(service->name) + 1;
944 strcpyW( ssi->data, service->name );
945
946 r = service_send_command( service, pipe, ssi, ssi->total_size, result );
947 HeapFree( GetProcessHeap(), 0, ssi );
948 return r;
949 }
950
951 DWORD __cdecl svcctl_StartServiceW(
952 SC_RPC_HANDLE hService,
953 DWORD dwNumServiceArgs,
954 LPCWSTR *lpServiceArgVectors)
955 {
956 struct sc_service_handle *service;
957 DWORD err;
958
959 WINE_TRACE("(%p, %d, %p)\n", hService, dwNumServiceArgs, lpServiceArgVectors);
960
961 if ((err = validate_service_handle(hService, SERVICE_START, &service)) != 0)
962 return err;
963
964 if (service->service_entry->config.dwStartType == SERVICE_DISABLED)
965 return ERROR_SERVICE_DISABLED;
966
967 err = service_start(service->service_entry, dwNumServiceArgs, lpServiceArgVectors);
968
969 return err;
970 }
971
972 DWORD __cdecl svcctl_ControlService(
973 SC_RPC_HANDLE hService,
974 DWORD dwControl,
975 SERVICE_STATUS *lpServiceStatus)
976 {
977 DWORD access_required;
978 struct sc_service_handle *service;
979 DWORD err;
980 BOOL ret;
981 HANDLE control_mutex;
982 HANDLE control_pipe;
983
984 WINE_TRACE("(%p, %d, %p)\n", hService, dwControl, lpServiceStatus);
985
986 switch (dwControl)
987 {
988 case SERVICE_CONTROL_CONTINUE:
989 case SERVICE_CONTROL_NETBINDADD:
990 case SERVICE_CONTROL_NETBINDDISABLE:
991 case SERVICE_CONTROL_NETBINDENABLE:
992 case SERVICE_CONTROL_NETBINDREMOVE:
993 case SERVICE_CONTROL_PARAMCHANGE:
994 case SERVICE_CONTROL_PAUSE:
995 access_required = SERVICE_PAUSE_CONTINUE;
996 break;
997 case SERVICE_CONTROL_INTERROGATE:
998 access_required = SERVICE_INTERROGATE;
999 break;
1000 case SERVICE_CONTROL_STOP:
1001 access_required = SERVICE_STOP;
1002 break;
1003 default:
1004 if (dwControl >= 128 && dwControl <= 255)
1005 access_required = SERVICE_USER_DEFINED_CONTROL;
1006 else
1007 return ERROR_INVALID_PARAMETER;
1008 }
1009
1010 if ((err = validate_service_handle(hService, access_required, &service)) != 0)
1011 return err;
1012
1013 service_lock_exclusive(service->service_entry);
1014
1015 if (lpServiceStatus)
1016 {
1017 lpServiceStatus->dwServiceType = service->service_entry->status.dwServiceType;
1018 lpServiceStatus->dwCurrentState = service->service_entry->status.dwCurrentState;
1019 lpServiceStatus->dwControlsAccepted = service->service_entry->status.dwControlsAccepted;
1020 lpServiceStatus->dwWin32ExitCode = service->service_entry->status.dwWin32ExitCode;
1021 lpServiceStatus->dwServiceSpecificExitCode = service->service_entry->status.dwServiceSpecificExitCode;
1022 lpServiceStatus->dwCheckPoint = service->service_entry->status.dwCheckPoint;
1023 lpServiceStatus->dwWaitHint = service->service_entry->status.dwWaitHint;
1024 }
1025
1026 switch (service->service_entry->status.dwCurrentState)
1027 {
1028 case SERVICE_STOPPED:
1029 service_unlock(service->service_entry);
1030 return ERROR_SERVICE_NOT_ACTIVE;
1031 case SERVICE_START_PENDING:
1032 if (dwControl==SERVICE_CONTROL_STOP)
1033 break;
1034 /* fall thru */
1035 case SERVICE_STOP_PENDING:
1036 service_unlock(service->service_entry);
1037 return ERROR_SERVICE_CANNOT_ACCEPT_CTRL;
1038 }
1039
1040 if (!service_accepts_control(service->service_entry, dwControl))
1041 {
1042 service_unlock(service->service_entry);
1043 return ERROR_INVALID_SERVICE_CONTROL;
1044 }
1045
1046 /* prevent races by caching these variables and clearing them on
1047 * stop here instead of outside the services lock */
1048 control_mutex = service->service_entry->control_mutex;
1049 control_pipe = service->service_entry->control_pipe;
1050 if (dwControl == SERVICE_CONTROL_STOP)
1051 {
1052 service->service_entry->control_mutex = NULL;
1053 service->service_entry->control_pipe = INVALID_HANDLE_VALUE;
1054 }
1055
1056 service_unlock(service->service_entry);
1057
1058 ret = WaitForSingleObject(control_mutex, 30000);
1059 if (ret == WAIT_OBJECT_0)
1060 {
1061 DWORD result = ERROR_SUCCESS;
1062
1063 ret = service_send_control(service->service_entry, control_pipe, dwControl, &result);
1064
1065 if (dwControl == SERVICE_CONTROL_STOP)
1066 {
1067 CloseHandle(control_mutex);
1068 CloseHandle(control_pipe);
1069 }
1070 else
1071 ReleaseMutex(control_mutex);
1072
1073 return result;
1074 }
1075 else
1076 {
1077 if (dwControl == SERVICE_CONTROL_STOP)
1078 {
1079 CloseHandle(control_mutex);
1080 CloseHandle(control_pipe);
1081 }
1082 return ERROR_SERVICE_REQUEST_TIMEOUT;
1083 }
1084 }
1085
1086 DWORD __cdecl svcctl_CloseServiceHandle(
1087 SC_RPC_HANDLE *handle)
1088 {
1089 WINE_TRACE("(&%p)\n", *handle);
1090
1091 SC_RPC_HANDLE_destroy(*handle);
1092 *handle = NULL;
1093
1094 return ERROR_SUCCESS;
1095 }
1096
1097 static void SC_RPC_LOCK_destroy(SC_RPC_LOCK hLock)
1098 {
1099 struct sc_lock *lock = hLock;
1100 scmdatabase_unlock_startup(lock->db);
1101 HeapFree(GetProcessHeap(), 0, lock);
1102 }
1103
1104 void __RPC_USER SC_RPC_LOCK_rundown(SC_RPC_LOCK hLock)
1105 {
1106 SC_RPC_LOCK_destroy(hLock);
1107 }
1108
1109 DWORD __cdecl svcctl_LockServiceDatabase(
1110 SC_RPC_HANDLE hSCManager,
1111 SC_RPC_LOCK *phLock)
1112 {
1113 struct sc_manager_handle *manager;
1114 struct sc_lock *lock;
1115 DWORD err;
1116
1117 WINE_TRACE("(%p, %p)\n", hSCManager, phLock);
1118
1119 if ((err = validate_scm_handle(hSCManager, SC_MANAGER_LOCK, &manager)) != ERROR_SUCCESS)
1120 return err;
1121
1122 err = scmdatabase_lock_startup(manager->db);
1123 if (err != ERROR_SUCCESS)
1124 return err;
1125
1126 lock = HeapAlloc(GetProcessHeap(), 0, sizeof(struct sc_lock));
1127 if (!lock)
1128 {
1129 scmdatabase_unlock_startup(manager->db);
1130 return ERROR_NOT_ENOUGH_SERVER_MEMORY;
1131 }
1132
1133 lock->db = manager->db;
1134 *phLock = lock;
1135
1136 return ERROR_SUCCESS;
1137 }
1138
1139 DWORD __cdecl svcctl_UnlockServiceDatabase(
1140 SC_RPC_LOCK *phLock)
1141 {
1142 WINE_TRACE("(&%p)\n", *phLock);
1143
1144 SC_RPC_LOCK_destroy(*phLock);
1145 *phLock = NULL;
1146
1147 return ERROR_SUCCESS;
1148 }
1149
1150 static BOOL map_state(DWORD state, DWORD mask)
1151 {
1152 switch (state)
1153 {
1154 case SERVICE_START_PENDING:
1155 case SERVICE_STOP_PENDING:
1156 case SERVICE_RUNNING:
1157 case SERVICE_CONTINUE_PENDING:
1158 case SERVICE_PAUSE_PENDING:
1159 case SERVICE_PAUSED:
1160 if (SERVICE_ACTIVE & mask) return TRUE;
1161 break;
1162 case SERVICE_STOPPED:
1163 if (SERVICE_INACTIVE & mask) return TRUE;
1164 break;
1165 default:
1166 WINE_ERR("unknown state %u\n", state);
1167 break;
1168 }
1169 return FALSE;
1170 }
1171
1172 DWORD __cdecl svcctl_EnumServicesStatusW(
1173 SC_RPC_HANDLE hmngr,
1174 DWORD type,
1175 DWORD state,
1176 BYTE *buffer,
1177 DWORD size,
1178 LPDWORD needed,
1179 LPDWORD returned)
1180 {
1181 DWORD err, sz, total_size, num_services;
1182 DWORD_PTR offset;
1183 struct sc_manager_handle *manager;
1184 struct service_entry *service;
1185 ENUM_SERVICE_STATUSW *s;
1186
1187 WINE_TRACE("(%p, 0x%x, 0x%x, %p, %u, %p, %p)\n", hmngr, type, state, buffer, size, needed, returned);
1188
1189 if (!type || !state)
1190 return ERROR_INVALID_PARAMETER;
1191
1192 if ((err = validate_scm_handle(hmngr, SC_MANAGER_ENUMERATE_SERVICE, &manager)) != ERROR_SUCCESS)
1193 return err;
1194
1195 scmdatabase_lock_exclusive(manager->db);
1196
1197 total_size = num_services = 0;
1198 LIST_FOR_EACH_ENTRY(service, &manager->db->services, struct service_entry, entry)
1199 {
1200 if ((service->status.dwServiceType & type) && map_state(service->status.dwCurrentState, state))
1201 {
1202 total_size += sizeof(ENUM_SERVICE_STATUSW);
1203 total_size += (strlenW(service->name) + 1) * sizeof(WCHAR);
1204 if (service->config.lpDisplayName)
1205 {
1206 total_size += (strlenW(service->config.lpDisplayName) + 1) * sizeof(WCHAR);
1207 }
1208 num_services++;
1209 }
1210 }
1211 *returned = 0;
1212 *needed = total_size;
1213 if (total_size > size)
1214 {
1215 scmdatabase_unlock(manager->db);
1216 return ERROR_MORE_DATA;
1217 }
1218 s = (ENUM_SERVICE_STATUSW *)buffer;
1219 offset = num_services * sizeof(ENUM_SERVICE_STATUSW);
1220 LIST_FOR_EACH_ENTRY(service, &manager->db->services, struct service_entry, entry)
1221 {
1222 if ((service->status.dwServiceType & type) && map_state(service->status.dwCurrentState, state))
1223 {
1224 sz = (strlenW(service->name) + 1) * sizeof(WCHAR);
1225 memcpy(buffer + offset, service->name, sz);
1226 s->lpServiceName = (WCHAR *)offset; /* store a buffer offset instead of a pointer */
1227 offset += sz;
1228
1229 if (!service->config.lpDisplayName) s->lpDisplayName = NULL;
1230 else
1231 {
1232 sz = (strlenW(service->config.lpDisplayName) + 1) * sizeof(WCHAR);
1233 memcpy(buffer + offset, service->config.lpDisplayName, sz);
1234 s->lpDisplayName = (WCHAR *)offset;
1235 offset += sz;
1236 }
1237 memcpy(&s->ServiceStatus, &service->status, sizeof(SERVICE_STATUS));
1238 s++;
1239 }
1240 }
1241 *returned = num_services;
1242 *needed = 0;
1243 scmdatabase_unlock(manager->db);
1244 return ERROR_SUCCESS;
1245 }
1246
1247 static struct service_entry *find_service_by_group(struct scmdatabase *db, const WCHAR *group)
1248 {
1249 struct service_entry *service;
1250 LIST_FOR_EACH_ENTRY(service, &db->services, struct service_entry, entry)
1251 {
1252 if (service->config.lpLoadOrderGroup && !strcmpiW(group, service->config.lpLoadOrderGroup))
1253 return service;
1254 }
1255 return NULL;
1256 }
1257
1258 static BOOL match_group(const WCHAR *g1, const WCHAR *g2)
1259 {
1260 if (!g2) return TRUE;
1261 if (!g2[0] && (!g1 || !g1[0])) return TRUE;
1262 if (g1 && !strcmpW(g1, g2)) return TRUE;
1263 return FALSE;
1264 }
1265
1266 DWORD __cdecl svcctl_EnumServicesStatusExW(
1267 SC_RPC_HANDLE hmngr,
1268 DWORD type,
1269 DWORD state,
1270 BYTE *buffer,
1271 DWORD size,
1272 LPDWORD needed,
1273 LPDWORD returned,
1274 LPCWSTR group)
1275 {
1276 DWORD err, sz, total_size, num_services;
1277 DWORD_PTR offset;
1278 struct sc_manager_handle *manager;
1279 struct service_entry *service;
1280 ENUM_SERVICE_STATUS_PROCESSW *s;
1281
1282 WINE_TRACE("(%p, 0x%x, 0x%x, %p, %u, %p, %p, %s)\n", hmngr, type, state, buffer, size,
1283 needed, returned, wine_dbgstr_w(group));
1284
1285 if (!type || !state)
1286 return ERROR_INVALID_PARAMETER;
1287
1288 if ((err = validate_scm_handle(hmngr, SC_MANAGER_ENUMERATE_SERVICE, &manager)) != ERROR_SUCCESS)
1289 return err;
1290
1291 scmdatabase_lock_exclusive(manager->db);
1292
1293 if (group && !find_service_by_group(manager->db, group))
1294 {
1295 scmdatabase_unlock(manager->db);
1296 return ERROR_SERVICE_DOES_NOT_EXIST;
1297 }
1298
1299 total_size = num_services = 0;
1300 LIST_FOR_EACH_ENTRY(service, &manager->db->services, struct service_entry, entry)
1301 {
1302 if ((service->status.dwServiceType & type) && map_state(service->status.dwCurrentState, state)
1303 && match_group(service->config.lpLoadOrderGroup, group))
1304 {
1305 total_size += sizeof(ENUM_SERVICE_STATUS_PROCESSW);
1306 total_size += (strlenW(service->name) + 1) * sizeof(WCHAR);
1307 if (service->config.lpDisplayName)
1308 {
1309 total_size += (strlenW(service->config.lpDisplayName) + 1) * sizeof(WCHAR);
1310 }
1311 num_services++;
1312 }
1313 }
1314 *returned = 0;
1315 *needed = total_size;
1316 if (total_size > size)
1317 {
1318 scmdatabase_unlock(manager->db);
1319 return ERROR_MORE_DATA;
1320 }
1321 s = (ENUM_SERVICE_STATUS_PROCESSW *)buffer;
1322 offset = num_services * sizeof(ENUM_SERVICE_STATUS_PROCESSW);
1323 LIST_FOR_EACH_ENTRY(service, &manager->db->services, struct service_entry, entry)
1324 {
1325 if ((service->status.dwServiceType & type) && map_state(service->status.dwCurrentState, state)
1326 && match_group(service->config.lpLoadOrderGroup, group))
1327 {
1328 sz = (strlenW(service->name) + 1) * sizeof(WCHAR);
1329 memcpy(buffer + offset, service->name, sz);
1330 s->lpServiceName = (WCHAR *)offset; /* store a buffer offset instead of a pointer */
1331 offset += sz;
1332
1333 if (!service->config.lpDisplayName) s->lpDisplayName = NULL;
1334 else
1335 {
1336 sz = (strlenW(service->config.lpDisplayName) + 1) * sizeof(WCHAR);
1337 memcpy(buffer + offset, service->config.lpDisplayName, sz);
1338 s->lpDisplayName = (WCHAR *)offset;
1339 offset += sz;
1340 }
1341 s->ServiceStatusProcess = service->status;
1342 s++;
1343 }
1344 }
1345 *returned = num_services;
1346 *needed = 0;
1347 scmdatabase_unlock(manager->db);
1348 return ERROR_SUCCESS;
1349 }
1350
1351 DWORD __cdecl svcctl_QueryServiceObjectSecurity(void)
1352 {
1353 WINE_FIXME("\n");
1354 return ERROR_CALL_NOT_IMPLEMENTED;
1355 }
1356
1357 DWORD __cdecl svcctl_SetServiceObjectSecurity(void)
1358 {
1359 WINE_FIXME("\n");
1360 return ERROR_CALL_NOT_IMPLEMENTED;
1361 }
1362
1363 DWORD __cdecl svcctl_QueryServiceStatus(void)
1364 {
1365 WINE_FIXME("\n");
1366 return ERROR_CALL_NOT_IMPLEMENTED;
1367 }
1368
1369
1370 DWORD __cdecl svcctl_NotifyBootConfigStatus(void)
1371 {
1372 WINE_FIXME("\n");
1373 return ERROR_CALL_NOT_IMPLEMENTED;
1374 }
1375
1376 DWORD __cdecl svcctl_SCSetServiceBitsW(void)
1377 {
1378 WINE_FIXME("\n");
1379 return ERROR_CALL_NOT_IMPLEMENTED;
1380 }
1381
1382
1383 DWORD __cdecl svcctl_EnumDependentServicesW(void)
1384 {
1385 WINE_FIXME("\n");
1386 return ERROR_CALL_NOT_IMPLEMENTED;
1387 }
1388
1389 DWORD __cdecl svcctl_QueryServiceLockStatusW(void)
1390 {
1391 WINE_FIXME("\n");
1392 return ERROR_CALL_NOT_IMPLEMENTED;
1393 }
1394
1395 DWORD __cdecl svcctl_SCSetServiceBitsA(void)
1396 {
1397 WINE_FIXME("\n");
1398 return ERROR_CALL_NOT_IMPLEMENTED;
1399 }
1400
1401 DWORD __cdecl svcctl_ChangeServiceConfigA(void)
1402 {
1403 WINE_FIXME("\n");
1404 return ERROR_CALL_NOT_IMPLEMENTED;
1405 }
1406
1407 DWORD __cdecl svcctl_CreateServiceA(void)
1408 {
1409 WINE_FIXME("\n");
1410 return ERROR_CALL_NOT_IMPLEMENTED;
1411 }
1412
1413 DWORD __cdecl svcctl_EnumDependentServicesA(void)
1414 {
1415 WINE_FIXME("\n");
1416 return ERROR_CALL_NOT_IMPLEMENTED;
1417 }
1418
1419 DWORD __cdecl svcctl_EnumServicesStatusA(void)
1420 {
1421 WINE_FIXME("\n");
1422 return ERROR_CALL_NOT_IMPLEMENTED;
1423 }
1424
1425 DWORD __cdecl svcctl_OpenSCManagerA(void)
1426 {
1427 WINE_FIXME("\n");
1428 return ERROR_CALL_NOT_IMPLEMENTED;
1429 }
1430
1431 DWORD __cdecl svcctl_OpenServiceA(void)
1432 {
1433 WINE_FIXME("\n");
1434 return ERROR_CALL_NOT_IMPLEMENTED;
1435 }
1436
1437 DWORD __cdecl svcctl_QueryServiceConfigA(void)
1438 {
1439 WINE_FIXME("\n");
1440 return ERROR_CALL_NOT_IMPLEMENTED;
1441 }
1442
1443 DWORD __cdecl svcctl_QueryServiceLockStatusA(void)
1444 {
1445 WINE_FIXME("\n");
1446 return ERROR_CALL_NOT_IMPLEMENTED;
1447 }
1448
1449 DWORD __cdecl svcctl_StartServiceA(void)
1450 {
1451 WINE_FIXME("\n");
1452 return ERROR_CALL_NOT_IMPLEMENTED;
1453 }
1454
1455 DWORD __cdecl svcctl_GetServiceDisplayNameA(void)
1456 {
1457 WINE_FIXME("\n");
1458 return ERROR_CALL_NOT_IMPLEMENTED;
1459 }
1460
1461 DWORD __cdecl svcctl_GetServiceKeyNameA(void)
1462 {
1463 WINE_FIXME("\n");
1464 return ERROR_CALL_NOT_IMPLEMENTED;
1465 }
1466
1467 DWORD __cdecl svcctl_GetCurrentGroupStateW(void)
1468 {
1469 WINE_FIXME("\n");
1470 return ERROR_CALL_NOT_IMPLEMENTED;
1471 }
1472
1473 DWORD __cdecl svcctl_EnumServiceGroupW(void)
1474 {
1475 WINE_FIXME("\n");
1476 return ERROR_CALL_NOT_IMPLEMENTED;
1477 }
1478
1479 DWORD __cdecl svcctl_ChangeServiceConfig2A(void)
1480 {
1481 WINE_FIXME("\n");
1482 return ERROR_CALL_NOT_IMPLEMENTED;
1483 }
1484
1485 DWORD __cdecl svcctl_QueryServiceConfig2A(void)
1486 {
1487 WINE_FIXME("\n");
1488 return ERROR_CALL_NOT_IMPLEMENTED;
1489 }
1490
1491
1492 DWORD RPC_Init(void)
1493 {
1494 WCHAR transport[] = SVCCTL_TRANSPORT;
1495 WCHAR endpoint[] = SVCCTL_ENDPOINT;
1496 DWORD err;
1497
1498 if ((err = RpcServerUseProtseqEpW(transport, 0, endpoint, NULL)) != ERROR_SUCCESS)
1499 {
1500 WINE_ERR("RpcServerUseProtseq failed with error %u\n", err);
1501 return err;
1502 }
1503
1504 if ((err = RpcServerRegisterIf(svcctl_v2_0_s_ifspec, 0, 0)) != ERROR_SUCCESS)
1505 {
1506 WINE_ERR("RpcServerRegisterIf failed with error %u\n", err);
1507 return err;
1508 }
1509
1510 if ((err = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, TRUE)) != ERROR_SUCCESS)
1511 {
1512 WINE_ERR("RpcServerListen failed with error %u\n", err);
1513 return err;
1514 }
1515 return ERROR_SUCCESS;
1516 }
1517
1518 DWORD RPC_MainLoop(void)
1519 {
1520 DWORD err;
1521 HANDLE hExitEvent = __wine_make_process_system();
1522
1523 SetEvent(g_hStartedEvent);
1524
1525 WINE_TRACE("Entered main loop\n");
1526
1527 do
1528 {
1529 err = WaitForSingleObjectEx(hExitEvent, INFINITE, TRUE);
1530 WINE_TRACE("Wait returned %d\n", err);
1531 } while (err != WAIT_OBJECT_0);
1532
1533 WINE_TRACE("Object signaled - wine shutdown\n");
1534 CloseHandle(hExitEvent);
1535 return ERROR_SUCCESS;
1536 }
1537
1538 void __RPC_USER SC_RPC_HANDLE_rundown(SC_RPC_HANDLE handle)
1539 {
1540 SC_RPC_HANDLE_destroy(handle);
1541 }
1542
1543 void __RPC_FAR * __RPC_USER MIDL_user_allocate(SIZE_T len)
1544 {
1545 return HeapAlloc(GetProcessHeap(), 0, len);
1546 }
1547
1548 void __RPC_USER MIDL_user_free(void __RPC_FAR * ptr)
1549 {
1550 HeapFree(GetProcessHeap(), 0, ptr);
1551 }
1552
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.