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_config_strings(QUERY_SERVICE_CONFIGW *old_cfg, QUERY_SERVICE_CONFIGW *new_cfg)
88 {
89 if (old_cfg->lpBinaryPathName != new_cfg->lpBinaryPathName)
90 HeapFree(GetProcessHeap(), 0, old_cfg->lpBinaryPathName);
91
92 if (old_cfg->lpLoadOrderGroup != new_cfg->lpLoadOrderGroup)
93 HeapFree(GetProcessHeap(), 0, old_cfg->lpLoadOrderGroup);
94
95 if (old_cfg->lpServiceStartName != new_cfg->lpServiceStartName)
96 HeapFree(GetProcessHeap(), 0, old_cfg->lpServiceStartName);
97
98 if (old_cfg->lpDisplayName != new_cfg->lpDisplayName)
99 HeapFree(GetProcessHeap(), 0, old_cfg->lpDisplayName);
100 }
101
102 /* Check if the given handle is of the required type and allows the requested access. */
103 static DWORD validate_context_handle(SC_RPC_HANDLE handle, DWORD type, DWORD needed_access, struct sc_handle **out_hdr)
104 {
105 struct sc_handle *hdr = handle;
106
107 if (type != SC_HTYPE_DONT_CARE && hdr->type != type)
108 {
109 WINE_ERR("Handle is of an invalid type (%d, %d)\n", hdr->type, type);
110 return ERROR_INVALID_HANDLE;
111 }
112
113 if ((needed_access & hdr->access) != needed_access)
114 {
115 WINE_ERR("Access denied - handle created with access %x, needed %x\n", hdr->access, needed_access);
116 return ERROR_ACCESS_DENIED;
117 }
118
119 *out_hdr = hdr;
120 return ERROR_SUCCESS;
121 }
122
123 static DWORD validate_scm_handle(SC_RPC_HANDLE handle, DWORD needed_access, struct sc_manager_handle **manager)
124 {
125 struct sc_handle *hdr;
126 DWORD err = validate_context_handle(handle, SC_HTYPE_MANAGER, needed_access, &hdr);
127 if (err == ERROR_SUCCESS)
128 *manager = (struct sc_manager_handle *)hdr;
129 return err;
130 }
131
132 static DWORD validate_service_handle(SC_RPC_HANDLE handle, DWORD needed_access, struct sc_service_handle **service)
133 {
134 struct sc_handle *hdr;
135 DWORD err = validate_context_handle(handle, SC_HTYPE_SERVICE, needed_access, &hdr);
136 if (err == ERROR_SUCCESS)
137 *service = (struct sc_service_handle *)hdr;
138 return err;
139 }
140
141 DWORD svcctl_OpenSCManagerW(
142 MACHINE_HANDLEW MachineName, /* Note: this parameter is ignored */
143 LPCWSTR DatabaseName,
144 DWORD dwAccessMask,
145 SC_RPC_HANDLE *handle)
146 {
147 struct sc_manager_handle *manager;
148
149 WINE_TRACE("(%s, %s, %x)\n", wine_dbgstr_w(MachineName), wine_dbgstr_w(DatabaseName), dwAccessMask);
150
151 if (DatabaseName != NULL && DatabaseName[0])
152 {
153 if (strcmpW(DatabaseName, SERVICES_FAILED_DATABASEW) == 0)
154 return ERROR_DATABASE_DOES_NOT_EXIST;
155 if (strcmpW(DatabaseName, SERVICES_ACTIVE_DATABASEW) != 0)
156 return ERROR_INVALID_NAME;
157 }
158
159 if (!(manager = HeapAlloc(GetProcessHeap(), 0, sizeof(*manager))))
160 return ERROR_NOT_ENOUGH_SERVER_MEMORY;
161
162 manager->hdr.type = SC_HTYPE_MANAGER;
163
164 if (dwAccessMask & MAXIMUM_ALLOWED)
165 dwAccessMask |= SC_MANAGER_ALL_ACCESS;
166 manager->hdr.access = dwAccessMask;
167 RtlMapGenericMask(&manager->hdr.access, &g_scm_generic);
168 manager->db = active_database;
169 *handle = &manager->hdr;
170
171 return ERROR_SUCCESS;
172 }
173
174 static void SC_RPC_HANDLE_destroy(SC_RPC_HANDLE handle)
175 {
176 struct sc_handle *hdr = handle;
177 switch (hdr->type)
178 {
179 case SC_HTYPE_MANAGER:
180 {
181 struct sc_manager_handle *manager = (struct sc_manager_handle *)hdr;
182 HeapFree(GetProcessHeap(), 0, manager);
183 break;
184 }
185 case SC_HTYPE_SERVICE:
186 {
187 struct sc_service_handle *service = (struct sc_service_handle *)hdr;
188 release_service(service->service_entry);
189 HeapFree(GetProcessHeap(), 0, service);
190 break;
191 }
192 default:
193 WINE_ERR("invalid handle type %d\n", hdr->type);
194 RpcRaiseException(ERROR_INVALID_HANDLE);
195 }
196 }
197
198 DWORD svcctl_GetServiceDisplayNameW(
199 SC_RPC_HANDLE hSCManager,
200 LPCWSTR lpServiceName,
201 WCHAR *lpBuffer,
202 DWORD *cchBufSize)
203 {
204 struct sc_manager_handle *manager;
205 struct service_entry *entry;
206 DWORD err;
207
208 WINE_TRACE("(%s, %d)\n", wine_dbgstr_w(lpServiceName), *cchBufSize);
209
210 if ((err = validate_scm_handle(hSCManager, 0, &manager)) != ERROR_SUCCESS)
211 return err;
212
213 scmdatabase_lock_shared(manager->db);
214
215 entry = scmdatabase_find_service(manager->db, lpServiceName);
216 if (entry != NULL)
217 {
218 LPCWSTR name;
219 int len;
220 service_lock_shared(entry);
221 name = get_display_name(entry);
222 len = strlenW(name);
223 if (len <= *cchBufSize)
224 {
225 err = ERROR_SUCCESS;
226 memcpy(lpBuffer, name, (len + 1)*sizeof(*name));
227 }
228 else
229 err = ERROR_INSUFFICIENT_BUFFER;
230 *cchBufSize = len;
231 service_unlock(entry);
232 }
233 else
234 err = ERROR_SERVICE_DOES_NOT_EXIST;
235
236 scmdatabase_unlock(manager->db);
237
238 if (err != ERROR_SUCCESS)
239 lpBuffer[0] = 0;
240
241 return err;
242 }
243
244 DWORD svcctl_GetServiceKeyNameW(
245 SC_RPC_HANDLE hSCManager,
246 LPCWSTR lpServiceDisplayName,
247 WCHAR *lpBuffer,
248 DWORD *cchBufSize)
249 {
250 struct service_entry *entry;
251 struct sc_manager_handle *manager;
252 DWORD err;
253
254 WINE_TRACE("(%s, %d)\n", wine_dbgstr_w(lpServiceDisplayName), *cchBufSize);
255
256 if ((err = validate_scm_handle(hSCManager, 0, &manager)) != ERROR_SUCCESS)
257 return err;
258
259 scmdatabase_lock_shared(manager->db);
260
261 entry = scmdatabase_find_service_by_displayname(manager->db, lpServiceDisplayName);
262 if (entry != NULL)
263 {
264 int len;
265 service_lock_shared(entry);
266 len = strlenW(entry->name);
267 if (len <= *cchBufSize)
268 {
269 err = ERROR_SUCCESS;
270 memcpy(lpBuffer, entry->name, (len + 1)*sizeof(*entry->name));
271 }
272 else
273 err = ERROR_INSUFFICIENT_BUFFER;
274 *cchBufSize = len;
275 service_unlock(entry);
276 }
277 else
278 err = ERROR_SERVICE_DOES_NOT_EXIST;
279
280 scmdatabase_unlock(manager->db);
281
282 if (err != ERROR_SUCCESS)
283 lpBuffer[0] = 0;
284
285 return err;
286 }
287
288 static DWORD create_handle_for_service(struct service_entry *entry, DWORD dwDesiredAccess, SC_RPC_HANDLE *phService)
289 {
290 struct sc_service_handle *service;
291
292 if (!(service = HeapAlloc(GetProcessHeap(), 0, sizeof(*service))))
293 {
294 release_service(entry);
295 return ERROR_NOT_ENOUGH_SERVER_MEMORY;
296 }
297
298 service->hdr.type = SC_HTYPE_SERVICE;
299 service->hdr.access = dwDesiredAccess;
300 RtlMapGenericMask(&service->hdr.access, &g_svc_generic);
301 service->service_entry = entry;
302 if (dwDesiredAccess & MAXIMUM_ALLOWED)
303 dwDesiredAccess |= SERVICE_ALL_ACCESS;
304
305 *phService = &service->hdr;
306 return ERROR_SUCCESS;
307 }
308
309 DWORD svcctl_OpenServiceW(
310 SC_RPC_HANDLE hSCManager,
311 LPCWSTR lpServiceName,
312 DWORD dwDesiredAccess,
313 SC_RPC_HANDLE *phService)
314 {
315 struct sc_manager_handle *manager;
316 struct service_entry *entry;
317 DWORD err;
318
319 WINE_TRACE("(%s, 0x%x)\n", wine_dbgstr_w(lpServiceName), dwDesiredAccess);
320
321 if ((err = validate_scm_handle(hSCManager, 0, &manager)) != ERROR_SUCCESS)
322 return err;
323 if (!validate_service_name(lpServiceName))
324 return ERROR_INVALID_NAME;
325
326 scmdatabase_lock_shared(manager->db);
327 entry = scmdatabase_find_service(manager->db, lpServiceName);
328 if (entry != NULL)
329 InterlockedIncrement(&entry->ref_count);
330 scmdatabase_unlock(manager->db);
331
332 if (entry == NULL)
333 return ERROR_SERVICE_DOES_NOT_EXIST;
334
335 return create_handle_for_service(entry, dwDesiredAccess, phService);
336 }
337
338 DWORD svcctl_CreateServiceW(
339 SC_RPC_HANDLE hSCManager,
340 LPCWSTR lpServiceName,
341 LPCWSTR lpDisplayName,
342 DWORD dwDesiredAccess,
343 DWORD dwServiceType,
344 DWORD dwStartType,
345 DWORD dwErrorControl,
346 LPCWSTR lpBinaryPathName,
347 LPCWSTR lpLoadOrderGroup,
348 DWORD *lpdwTagId,
349 const BYTE *lpDependencies,
350 DWORD dwDependenciesSize,
351 LPCWSTR lpServiceStartName,
352 const BYTE *lpPassword,
353 DWORD dwPasswordSize,
354 SC_RPC_HANDLE *phService)
355 {
356 struct sc_manager_handle *manager;
357 struct service_entry *entry;
358 DWORD err;
359
360 WINE_TRACE("(%s, %s, 0x%x, %s)\n", wine_dbgstr_w(lpServiceName), wine_dbgstr_w(lpDisplayName), dwDesiredAccess, wine_dbgstr_w(lpBinaryPathName));
361
362 if ((err = validate_scm_handle(hSCManager, SC_MANAGER_CREATE_SERVICE, &manager)) != ERROR_SUCCESS)
363 return err;
364
365 if (!validate_service_name(lpServiceName))
366 return ERROR_INVALID_NAME;
367 if (!check_multisz((LPCWSTR)lpDependencies, dwDependenciesSize) || !lpServiceName[0] || !lpBinaryPathName[0])
368 return ERROR_INVALID_PARAMETER;
369
370 if (lpPassword)
371 WINE_FIXME("Don't know how to add a password\n"); /* I always get ERROR_GEN_FAILURE */
372 if (lpDependencies)
373 WINE_FIXME("Dependencies not supported yet\n");
374
375 err = service_create(lpServiceName, &entry);
376 if (err != ERROR_SUCCESS)
377 return err;
378 entry->ref_count = 1;
379 entry->config.dwServiceType = entry->status.dwServiceType = dwServiceType;
380 entry->config.dwStartType = dwStartType;
381 entry->config.dwErrorControl = dwErrorControl;
382 entry->config.lpBinaryPathName = strdupW(lpBinaryPathName);
383 entry->config.lpLoadOrderGroup = strdupW(lpLoadOrderGroup);
384 entry->config.lpServiceStartName = strdupW(lpServiceStartName);
385 entry->config.lpDisplayName = strdupW(lpDisplayName);
386
387 if (lpdwTagId) /* TODO: In most situations a non-NULL TagId will generate an ERROR_INVALID_PARAMETER. */
388 entry->config.dwTagId = *lpdwTagId;
389 else
390 entry->config.dwTagId = 0;
391
392 /* other fields NULL*/
393
394 if (!validate_service_config(entry))
395 {
396 WINE_ERR("Invalid data while trying to create service\n");
397 free_service_entry(entry);
398 return ERROR_INVALID_PARAMETER;
399 }
400
401 scmdatabase_lock_exclusive(manager->db);
402
403 if (scmdatabase_find_service(manager->db, lpServiceName))
404 {
405 scmdatabase_unlock(manager->db);
406 free_service_entry(entry);
407 return ERROR_SERVICE_EXISTS;
408 }
409
410 if (scmdatabase_find_service_by_displayname(manager->db, get_display_name(entry)))
411 {
412 scmdatabase_unlock(manager->db);
413 free_service_entry(entry);
414 return ERROR_DUPLICATE_SERVICE_NAME;
415 }
416
417 err = scmdatabase_add_service(manager->db, entry);
418 if (err != ERROR_SUCCESS)
419 {
420 scmdatabase_unlock(manager->db);
421 free_service_entry(entry);
422 return err;
423 }
424 scmdatabase_unlock(manager->db);
425
426 return create_handle_for_service(entry, dwDesiredAccess, phService);
427 }
428
429 DWORD svcctl_DeleteService(
430 SC_RPC_HANDLE hService)
431 {
432 struct sc_service_handle *service;
433 DWORD err;
434
435 if ((err = validate_service_handle(hService, DELETE, &service)) != ERROR_SUCCESS)
436 return err;
437
438 scmdatabase_lock_exclusive(service->service_entry->db);
439 service_lock_exclusive(service->service_entry);
440
441 if (!is_marked_for_delete(service->service_entry))
442 err = scmdatabase_remove_service(service->service_entry->db, service->service_entry);
443 else
444 err = ERROR_SERVICE_MARKED_FOR_DELETE;
445
446 service_unlock(service->service_entry);
447 scmdatabase_unlock(service->service_entry->db);
448
449 return err;
450 }
451
452 DWORD svcctl_QueryServiceConfigW(
453 SC_RPC_HANDLE hService,
454 QUERY_SERVICE_CONFIGW *config)
455 {
456 struct sc_service_handle *service;
457 DWORD err;
458
459 WINE_TRACE("(%p)\n", config);
460
461 if ((err = validate_service_handle(hService, SERVICE_QUERY_CONFIG, &service)) != 0)
462 return err;
463
464 service_lock_shared(service->service_entry);
465 config->dwServiceType = service->service_entry->config.dwServiceType;
466 config->dwStartType = service->service_entry->config.dwStartType;
467 config->dwErrorControl = service->service_entry->config.dwErrorControl;
468 config->lpBinaryPathName = strdupW(service->service_entry->config.lpBinaryPathName);
469 config->lpLoadOrderGroup = strdupW(service->service_entry->config.lpLoadOrderGroup);
470 config->dwTagId = service->service_entry->config.dwTagId;
471 config->lpDependencies = NULL; /* TODO */
472 config->lpServiceStartName = strdupW(service->service_entry->config.lpServiceStartName);
473 config->lpDisplayName = strdupW(service->service_entry->config.lpDisplayName);
474 service_unlock(service->service_entry);
475
476 return ERROR_SUCCESS;
477 }
478
479 DWORD svcctl_ChangeServiceConfigW(
480 SC_RPC_HANDLE hService,
481 DWORD dwServiceType,
482 DWORD dwStartType,
483 DWORD dwErrorControl,
484 LPCWSTR lpBinaryPathName,
485 LPCWSTR lpLoadOrderGroup,
486 DWORD *lpdwTagId,
487 const BYTE *lpDependencies,
488 DWORD dwDependenciesSize,
489 LPCWSTR lpServiceStartName,
490 const BYTE *lpPassword,
491 DWORD dwPasswordSize,
492 LPCWSTR lpDisplayName)
493 {
494 struct service_entry new_entry, *entry;
495 struct sc_service_handle *service;
496 DWORD err;
497
498 WINE_TRACE("\n");
499
500 if ((err = validate_service_handle(hService, SERVICE_CHANGE_CONFIG, &service)) != 0)
501 return err;
502
503 if (!check_multisz((LPCWSTR)lpDependencies, dwDependenciesSize))
504 return ERROR_INVALID_PARAMETER;
505
506 /* first check if the new configuration is correct */
507 service_lock_exclusive(service->service_entry);
508
509 if (is_marked_for_delete(service->service_entry))
510 {
511 service_unlock(service->service_entry);
512 return ERROR_SERVICE_MARKED_FOR_DELETE;
513 }
514
515 if (lpDisplayName != NULL &&
516 (entry = scmdatabase_find_service_by_displayname(service->service_entry->db, lpDisplayName)) &&
517 (entry != service->service_entry))
518 {
519 service_unlock(service->service_entry);
520 return ERROR_DUPLICATE_SERVICE_NAME;
521 }
522
523 new_entry = *service->service_entry;
524
525 if (dwServiceType != SERVICE_NO_CHANGE)
526 new_entry.config.dwServiceType = dwServiceType;
527
528 if (dwStartType != SERVICE_NO_CHANGE)
529 new_entry.config.dwStartType = dwStartType;
530
531 if (dwErrorControl != SERVICE_NO_CHANGE)
532 new_entry.config.dwErrorControl = dwErrorControl;
533
534 if (lpBinaryPathName != NULL)
535 new_entry.config.lpBinaryPathName = (LPWSTR)lpBinaryPathName;
536
537 if (lpLoadOrderGroup != NULL)
538 new_entry.config.lpLoadOrderGroup = (LPWSTR)lpLoadOrderGroup;
539
540 if (lpdwTagId != NULL)
541 WINE_FIXME("Changing tag id not supported\n");
542
543 if (lpDependencies != NULL)
544 WINE_FIXME("Changing dependencies not supported\n");
545
546 if (lpServiceStartName != NULL)
547 new_entry.config.lpServiceStartName = (LPWSTR)lpServiceStartName;
548
549 if (lpPassword != NULL)
550 WINE_FIXME("Setting password not supported\n");
551
552 if (lpDisplayName != NULL)
553 new_entry.config.lpDisplayName = (LPWSTR)lpDisplayName;
554
555 if (!validate_service_config(&new_entry))
556 {
557 WINE_ERR("The configuration after the change wouldn't be valid\n");
558 service_unlock(service->service_entry);
559 return ERROR_INVALID_PARAMETER;
560 }
561
562 /* configuration OK. The strings needs to be duplicated */
563 if (lpBinaryPathName != NULL)
564 new_entry.config.lpBinaryPathName = strdupW(lpBinaryPathName);
565
566 if (lpLoadOrderGroup != NULL)
567 new_entry.config.lpLoadOrderGroup = strdupW(lpLoadOrderGroup);
568
569 if (lpServiceStartName != NULL)
570 new_entry.config.lpServiceStartName = strdupW(lpServiceStartName);
571
572 if (lpDisplayName != NULL)
573 new_entry.config.lpDisplayName = strdupW(lpDisplayName);
574
575 /* try to save to Registry, commit or rollback depending on success */
576 err = save_service_config(&new_entry);
577 if (ERROR_SUCCESS == err)
578 {
579 free_config_strings(&service->service_entry->config,&new_entry.config);
580 *service->service_entry = new_entry;
581 }
582 else free_config_strings(&new_entry.config,&service->service_entry->config);
583 service_unlock(service->service_entry);
584
585 return err;
586 }
587
588 DWORD svcctl_SetServiceStatus(
589 SC_RPC_HANDLE hServiceStatus,
590 LPSERVICE_STATUS lpServiceStatus)
591 {
592 struct sc_service_handle *service;
593 DWORD err;
594
595 WINE_TRACE("(%p, %p)\n", hServiceStatus, lpServiceStatus);
596
597 if ((err = validate_service_handle(hServiceStatus, SERVICE_SET_STATUS, &service)) != 0)
598 return err;
599
600 service_lock_exclusive(service->service_entry);
601 /* FIXME: be a bit more discriminant about what parts of the status we set
602 * and check that fields are valid */
603 service->service_entry->status.dwServiceType = lpServiceStatus->dwServiceType;
604 service->service_entry->status.dwCurrentState = lpServiceStatus->dwCurrentState;
605 service->service_entry->status.dwControlsAccepted = lpServiceStatus->dwControlsAccepted;
606 service->service_entry->status.dwWin32ExitCode = lpServiceStatus->dwWin32ExitCode;
607 service->service_entry->status.dwServiceSpecificExitCode = lpServiceStatus->dwServiceSpecificExitCode;
608 service->service_entry->status.dwCheckPoint = lpServiceStatus->dwCheckPoint;
609 service->service_entry->status.dwWaitHint = lpServiceStatus->dwWaitHint;
610 service_unlock(service->service_entry);
611
612 if (service->service_entry->status_changed_event)
613 SetEvent(service->service_entry->status_changed_event);
614
615 return ERROR_SUCCESS;
616 }
617
618 DWORD svcctl_ChangeServiceConfig2W( SC_RPC_HANDLE hService, DWORD level, SERVICE_CONFIG2W *config )
619 {
620 struct sc_service_handle *service;
621 DWORD err;
622
623 if ((err = validate_service_handle(hService, SERVICE_CHANGE_CONFIG, &service)) != 0)
624 return err;
625
626 switch (level)
627 {
628 case SERVICE_CONFIG_DESCRIPTION:
629 {
630 WCHAR *descr = NULL;
631
632 if (config->descr.lpDescription[0])
633 {
634 if (!(descr = strdupW( config->descr.lpDescription )))
635 return ERROR_NOT_ENOUGH_MEMORY;
636 }
637
638 WINE_TRACE( "changing service %p descr to %s\n", service, wine_dbgstr_w(descr) );
639 service_lock_exclusive( service->service_entry );
640 HeapFree( GetProcessHeap(), 0, service->service_entry->description );
641 service->service_entry->description = descr;
642 save_service_config( service->service_entry );
643 service_unlock( service->service_entry );
644 }
645 break;
646 case SERVICE_CONFIG_FAILURE_ACTIONS:
647 WINE_FIXME( "SERVICE_CONFIG_FAILURE_ACTIONS not implemented: period %u msg %s cmd %s\n",
648 config->actions.dwResetPeriod,
649 wine_dbgstr_w(config->actions.lpRebootMsg),
650 wine_dbgstr_w(config->actions.lpCommand) );
651 break;
652 default:
653 WINE_FIXME("level %u not implemented\n", level);
654 err = ERROR_INVALID_LEVEL;
655 break;
656 }
657 return err;
658 }
659
660 DWORD svcctl_QueryServiceConfig2W( SC_RPC_HANDLE hService, DWORD level,
661 BYTE *buffer, DWORD size, LPDWORD needed )
662 {
663 struct sc_service_handle *service;
664 DWORD err;
665
666 memset(buffer, 0, size);
667
668 if ((err = validate_service_handle(hService, SERVICE_QUERY_STATUS, &service)) != 0)
669 return err;
670
671 switch (level)
672 {
673 case SERVICE_CONFIG_DESCRIPTION:
674 {
675 SERVICE_DESCRIPTIONW *descr = (SERVICE_DESCRIPTIONW *)buffer;
676
677 service_lock_shared(service->service_entry);
678 *needed = sizeof(*descr);
679 if (service->service_entry->description)
680 *needed += (strlenW(service->service_entry->description) + 1) * sizeof(WCHAR);
681 if (size >= *needed)
682 {
683 if (service->service_entry->description)
684 {
685 /* store a buffer offset instead of a pointer */
686 descr->lpDescription = (WCHAR *)((BYTE *)(descr + 1) - buffer);
687 strcpyW( (WCHAR *)(descr + 1), service->service_entry->description );
688 }
689 else descr->lpDescription = NULL;
690 }
691 else err = ERROR_INSUFFICIENT_BUFFER;
692 service_unlock(service->service_entry);
693 }
694 break;
695
696 default:
697 WINE_FIXME("level %u not implemented\n", level);
698 err = ERROR_INVALID_LEVEL;
699 break;
700 }
701 return err;
702 }
703
704 DWORD svcctl_QueryServiceStatusEx(
705 SC_RPC_HANDLE hService,
706 SC_STATUS_TYPE InfoLevel,
707 BYTE *lpBuffer,
708 DWORD cbBufSize,
709 LPDWORD pcbBytesNeeded)
710 {
711 struct sc_service_handle *service;
712 DWORD err;
713 LPSERVICE_STATUS_PROCESS pSvcStatusData;
714
715 memset(lpBuffer, 0, cbBufSize);
716
717 if ((err = validate_service_handle(hService, SERVICE_QUERY_STATUS, &service)) != 0)
718 return err;
719
720 if (InfoLevel != SC_STATUS_PROCESS_INFO)
721 return ERROR_INVALID_LEVEL;
722
723 pSvcStatusData = (LPSERVICE_STATUS_PROCESS) lpBuffer;
724 if (pSvcStatusData == NULL)
725 return ERROR_INVALID_PARAMETER;
726
727 if (cbBufSize < sizeof(SERVICE_STATUS_PROCESS))
728 {
729 if( pcbBytesNeeded != NULL)
730 *pcbBytesNeeded = sizeof(SERVICE_STATUS_PROCESS);
731
732 return ERROR_INSUFFICIENT_BUFFER;
733 }
734
735 service_lock_shared(service->service_entry);
736
737 pSvcStatusData->dwServiceType = service->service_entry->status.dwServiceType;
738 pSvcStatusData->dwCurrentState = service->service_entry->status.dwCurrentState;
739 pSvcStatusData->dwControlsAccepted = service->service_entry->status.dwControlsAccepted;
740 pSvcStatusData->dwWin32ExitCode = service->service_entry->status.dwWin32ExitCode;
741 pSvcStatusData->dwServiceSpecificExitCode = service->service_entry->status.dwServiceSpecificExitCode;
742 pSvcStatusData->dwCheckPoint = service->service_entry->status.dwCheckPoint;
743 pSvcStatusData->dwWaitHint = service->service_entry->status.dwWaitHint;
744 pSvcStatusData->dwProcessId = service->service_entry->status.dwProcessId;
745 pSvcStatusData->dwServiceFlags = service->service_entry->status.dwServiceFlags;
746
747 service_unlock(service->service_entry);
748
749 return ERROR_SUCCESS;
750 }
751
752 /******************************************************************************
753 * service_accepts_control
754 */
755 static BOOL service_accepts_control(const struct service_entry *service, DWORD dwControl)
756 {
757 DWORD a = service->status.dwControlsAccepted;
758
759 switch (dwControl)
760 {
761 case SERVICE_CONTROL_INTERROGATE:
762 return TRUE;
763 case SERVICE_CONTROL_STOP:
764 if (a&SERVICE_ACCEPT_STOP)
765 return TRUE;
766 break;
767 case SERVICE_CONTROL_SHUTDOWN:
768 if (a&SERVICE_ACCEPT_SHUTDOWN)
769 return TRUE;
770 break;
771 case SERVICE_CONTROL_PAUSE:
772 case SERVICE_CONTROL_CONTINUE:
773 if (a&SERVICE_ACCEPT_PAUSE_CONTINUE)
774 return TRUE;
775 break;
776 case SERVICE_CONTROL_PARAMCHANGE:
777 if (a&SERVICE_ACCEPT_PARAMCHANGE)
778 return TRUE;
779 break;
780 case SERVICE_CONTROL_NETBINDADD:
781 case SERVICE_CONTROL_NETBINDREMOVE:
782 case SERVICE_CONTROL_NETBINDENABLE:
783 case SERVICE_CONTROL_NETBINDDISABLE:
784 if (a&SERVICE_ACCEPT_NETBINDCHANGE)
785 return TRUE;
786 case SERVICE_CONTROL_HARDWAREPROFILECHANGE:
787 if (a&SERVICE_ACCEPT_HARDWAREPROFILECHANGE)
788 return TRUE;
789 break;
790 case SERVICE_CONTROL_POWEREVENT:
791 if (a&SERVICE_ACCEPT_POWEREVENT)
792 return TRUE;
793 break;
794 case SERVICE_CONTROL_SESSIONCHANGE:
795 if (a&SERVICE_ACCEPT_SESSIONCHANGE)
796 return TRUE;
797 break;
798 }
799 return FALSE;
800 }
801
802 /******************************************************************************
803 * service_send_control
804 */
805 static BOOL service_send_control(struct service_entry *service, HANDLE pipe, DWORD dwControl, DWORD *result)
806 {
807 service_start_info *ssi;
808 DWORD len, count = 0;
809 BOOL r;
810
811 /* calculate how much space we need to send the startup info */
812 len = strlenW(service->name) + 1;
813
814 ssi = HeapAlloc(GetProcessHeap(),0,FIELD_OFFSET(service_start_info, data[len]));
815 ssi->cmd = WINESERV_SENDCONTROL;
816 ssi->control = dwControl;
817 ssi->total_size = FIELD_OFFSET(service_start_info, data[len]);
818 ssi->name_size = strlenW(service->name) + 1;
819 strcpyW( ssi->data, service->name );
820
821 r = WriteFile(pipe, ssi, ssi->total_size, &count, NULL);
822 if (!r || count != ssi->total_size)
823 {
824 WINE_ERR("service protocol error - failed to write pipe!\n");
825 return r;
826 }
827 r = ReadFile(pipe, result, sizeof *result, &count, NULL);
828 if (!r || count != sizeof *result)
829 WINE_ERR("service protocol error - failed to read pipe "
830 "r = %d count = %d!\n", r, count);
831 return r;
832 }
833
834 DWORD svcctl_StartServiceW(
835 SC_RPC_HANDLE hService,
836 DWORD dwNumServiceArgs,
837 LPCWSTR *lpServiceArgVectors)
838 {
839 struct sc_service_handle *service;
840 DWORD err;
841
842 WINE_TRACE("(%p, %d, %p)\n", hService, dwNumServiceArgs, lpServiceArgVectors);
843
844 if ((err = validate_service_handle(hService, SERVICE_START, &service)) != 0)
845 return err;
846
847 err = service_start(service->service_entry, dwNumServiceArgs, lpServiceArgVectors);
848
849 return err;
850 }
851
852 DWORD svcctl_ControlService(
853 SC_RPC_HANDLE hService,
854 DWORD dwControl,
855 SERVICE_STATUS *lpServiceStatus)
856 {
857 DWORD access_required;
858 struct sc_service_handle *service;
859 DWORD err;
860 BOOL ret;
861 HANDLE control_mutex;
862 HANDLE control_pipe;
863
864 WINE_TRACE("(%p, %d, %p)\n", hService, dwControl, lpServiceStatus);
865
866 switch (dwControl)
867 {
868 case SERVICE_CONTROL_CONTINUE:
869 case SERVICE_CONTROL_NETBINDADD:
870 case SERVICE_CONTROL_NETBINDDISABLE:
871 case SERVICE_CONTROL_NETBINDENABLE:
872 case SERVICE_CONTROL_NETBINDREMOVE:
873 case SERVICE_CONTROL_PARAMCHANGE:
874 case SERVICE_CONTROL_PAUSE:
875 access_required = SERVICE_PAUSE_CONTINUE;
876 break;
877 case SERVICE_CONTROL_INTERROGATE:
878 access_required = SERVICE_INTERROGATE;
879 break;
880 case SERVICE_CONTROL_STOP:
881 access_required = SERVICE_STOP;
882 break;
883 default:
884 if (dwControl >= 128 && dwControl <= 255)
885 access_required = SERVICE_USER_DEFINED_CONTROL;
886 else
887 return ERROR_INVALID_PARAMETER;
888 }
889
890 if ((err = validate_service_handle(hService, access_required, &service)) != 0)
891 return err;
892
893 service_lock_exclusive(service->service_entry);
894
895 if (lpServiceStatus)
896 {
897 lpServiceStatus->dwServiceType = service->service_entry->status.dwServiceType;
898 lpServiceStatus->dwCurrentState = service->service_entry->status.dwCurrentState;
899 lpServiceStatus->dwControlsAccepted = service->service_entry->status.dwControlsAccepted;
900 lpServiceStatus->dwWin32ExitCode = service->service_entry->status.dwWin32ExitCode;
901 lpServiceStatus->dwServiceSpecificExitCode = service->service_entry->status.dwServiceSpecificExitCode;
902 lpServiceStatus->dwCheckPoint = service->service_entry->status.dwCheckPoint;
903 lpServiceStatus->dwWaitHint = service->service_entry->status.dwWaitHint;
904 }
905
906 if (!service_accepts_control(service->service_entry, dwControl))
907 {
908 service_unlock(service->service_entry);
909 return ERROR_INVALID_SERVICE_CONTROL;
910 }
911
912 switch (service->service_entry->status.dwCurrentState)
913 {
914 case SERVICE_STOPPED:
915 service_unlock(service->service_entry);
916 return ERROR_SERVICE_NOT_ACTIVE;
917 case SERVICE_START_PENDING:
918 if (dwControl==SERVICE_CONTROL_STOP)
919 break;
920 /* fall thru */
921 case SERVICE_STOP_PENDING:
922 service_unlock(service->service_entry);
923 return ERROR_SERVICE_CANNOT_ACCEPT_CTRL;
924 }
925
926 /* prevent races by caching these variables and clearing them on
927 * stop here instead of outside the services lock */
928 control_mutex = service->service_entry->control_mutex;
929 control_pipe = service->service_entry->control_pipe;
930 if (dwControl == SERVICE_CONTROL_STOP)
931 {
932 service->service_entry->control_mutex = NULL;
933 service->service_entry->control_pipe = INVALID_HANDLE_VALUE;
934 }
935
936 service_unlock(service->service_entry);
937
938 ret = WaitForSingleObject(control_mutex, 30000);
939 if (ret == WAIT_OBJECT_0)
940 {
941 DWORD result = ERROR_SUCCESS;
942
943 ret = service_send_control(service->service_entry, control_pipe, dwControl, &result);
944
945 if (dwControl == SERVICE_CONTROL_STOP)
946 {
947 CloseHandle(control_mutex);
948 CloseHandle(control_pipe);
949 }
950 else
951 ReleaseMutex(control_mutex);
952
953 return result;
954 }
955 else
956 {
957 if (dwControl == SERVICE_CONTROL_STOP)
958 {
959 CloseHandle(control_mutex);
960 CloseHandle(control_pipe);
961 }
962 return ERROR_SERVICE_REQUEST_TIMEOUT;
963 }
964 }
965
966 DWORD svcctl_CloseServiceHandle(
967 SC_RPC_HANDLE *handle)
968 {
969 WINE_TRACE("(&%p)\n", *handle);
970
971 SC_RPC_HANDLE_destroy(*handle);
972 *handle = NULL;
973
974 return ERROR_SUCCESS;
975 }
976
977 static void SC_RPC_LOCK_destroy(SC_RPC_LOCK hLock)
978 {
979 struct sc_lock *lock = hLock;
980 scmdatabase_unlock_startup(lock->db);
981 HeapFree(GetProcessHeap(), 0, lock);
982 }
983
984 void __RPC_USER SC_RPC_LOCK_rundown(SC_RPC_LOCK hLock)
985 {
986 SC_RPC_LOCK_destroy(hLock);
987 }
988
989 DWORD svcctl_LockServiceDatabase(
990 SC_RPC_HANDLE hSCManager,
991 SC_RPC_LOCK *phLock)
992 {
993 struct sc_manager_handle *manager;
994 struct sc_lock *lock;
995 DWORD err;
996
997 WINE_TRACE("(%p, %p)\n", hSCManager, phLock);
998
999 if ((err = validate_scm_handle(hSCManager, SC_MANAGER_LOCK, &manager)) != ERROR_SUCCESS)
1000 return err;
1001
1002 err = scmdatabase_lock_startup(manager->db);
1003 if (err != ERROR_SUCCESS)
1004 return err;
1005
1006 lock = HeapAlloc(GetProcessHeap(), 0, sizeof(struct sc_lock));
1007 if (!lock)
1008 {
1009 scmdatabase_unlock_startup(manager->db);
1010 return ERROR_NOT_ENOUGH_SERVER_MEMORY;
1011 }
1012
1013 lock->db = manager->db;
1014 *phLock = lock;
1015
1016 return ERROR_SUCCESS;
1017 }
1018
1019 DWORD svcctl_UnlockServiceDatabase(
1020 SC_RPC_LOCK *phLock)
1021 {
1022 WINE_TRACE("(&%p)\n", *phLock);
1023
1024 SC_RPC_LOCK_destroy(*phLock);
1025 *phLock = NULL;
1026
1027 return ERROR_SUCCESS;
1028 }
1029
1030 DWORD svcctl_QueryServiceObjectSecurity(
1031 void)
1032 {
1033 WINE_FIXME("\n");
1034 return ERROR_CALL_NOT_IMPLEMENTED;
1035 }
1036
1037 DWORD svcctl_SetServiceObjectSecurity(
1038 void)
1039 {
1040 WINE_FIXME("\n");
1041 return ERROR_CALL_NOT_IMPLEMENTED;
1042 }
1043
1044 DWORD svcctl_QueryServiceStatus(
1045 void)
1046 {
1047 WINE_FIXME("\n");
1048 return ERROR_CALL_NOT_IMPLEMENTED;
1049 }
1050
1051
1052 DWORD svcctl_NotifyBootConfigStatus(
1053 void)
1054 {
1055 WINE_FIXME("\n");
1056 return ERROR_CALL_NOT_IMPLEMENTED;
1057 }
1058
1059 DWORD svcctl_SCSetServiceBitsW(
1060 void)
1061 {
1062 WINE_FIXME("\n");
1063 return ERROR_CALL_NOT_IMPLEMENTED;
1064 }
1065
1066
1067 DWORD svcctl_EnumDependentServicesW(
1068 void)
1069 {
1070 WINE_FIXME("\n");
1071 return ERROR_CALL_NOT_IMPLEMENTED;
1072 }
1073
1074 DWORD svcctl_EnumServicesStatusW(
1075 void)
1076 {
1077 WINE_FIXME("\n");
1078 return ERROR_CALL_NOT_IMPLEMENTED;
1079 }
1080
1081
1082 DWORD svcctl_QueryServiceLockStatusW(
1083 void)
1084 {
1085 WINE_FIXME("\n");
1086 return ERROR_CALL_NOT_IMPLEMENTED;
1087 }
1088
1089 DWORD svcctl_SCSetServiceBitsA(
1090 void)
1091 {
1092 WINE_FIXME("\n");
1093 return ERROR_CALL_NOT_IMPLEMENTED;
1094 }
1095
1096 DWORD svcctl_ChangeServiceConfigA(
1097 void)
1098 {
1099 WINE_FIXME("\n");
1100 return ERROR_CALL_NOT_IMPLEMENTED;
1101 }
1102
1103 DWORD svcctl_CreateServiceA(
1104 void)
1105 {
1106 WINE_FIXME("\n");
1107 return ERROR_CALL_NOT_IMPLEMENTED;
1108 }
1109
1110 DWORD svcctl_EnumDependentServicesA(
1111 void)
1112 {
1113 WINE_FIXME("\n");
1114 return ERROR_CALL_NOT_IMPLEMENTED;
1115 }
1116
1117 DWORD svcctl_EnumServicesStatusA(
1118 void)
1119 {
1120 WINE_FIXME("\n");
1121 return ERROR_CALL_NOT_IMPLEMENTED;
1122 }
1123
1124 DWORD svcctl_OpenSCManagerA(
1125 void)
1126 {
1127 WINE_FIXME("\n");
1128 return ERROR_CALL_NOT_IMPLEMENTED;
1129 }
1130
1131 DWORD svcctl_OpenServiceA(
1132 void)
1133 {
1134 WINE_FIXME("\n");
1135 return ERROR_CALL_NOT_IMPLEMENTED;
1136 }
1137
1138 DWORD svcctl_QueryServiceConfigA(
1139 void)
1140 {
1141 WINE_FIXME("\n");
1142 return ERROR_CALL_NOT_IMPLEMENTED;
1143 }
1144
1145 DWORD svcctl_QueryServiceLockStatusA(
1146 void)
1147 {
1148 WINE_FIXME("\n");
1149 return ERROR_CALL_NOT_IMPLEMENTED;
1150 }
1151
1152 DWORD svcctl_StartServiceA(
1153 void)
1154 {
1155 WINE_FIXME("\n");
1156 return ERROR_CALL_NOT_IMPLEMENTED;
1157 }
1158
1159 DWORD svcctl_GetServiceDisplayNameA(
1160 void)
1161 {
1162 WINE_FIXME("\n");
1163 return ERROR_CALL_NOT_IMPLEMENTED;
1164 }
1165
1166 DWORD svcctl_GetServiceKeyNameA(
1167 void)
1168 {
1169 WINE_FIXME("\n");
1170 return ERROR_CALL_NOT_IMPLEMENTED;
1171 }
1172
1173 DWORD svcctl_GetCurrentGroupStateW(
1174 void)
1175 {
1176 WINE_FIXME("\n");
1177 return ERROR_CALL_NOT_IMPLEMENTED;
1178 }
1179
1180 DWORD svcctl_EnumServiceGroupW(
1181 void)
1182 {
1183 WINE_FIXME("\n");
1184 return ERROR_CALL_NOT_IMPLEMENTED;
1185 }
1186
1187 DWORD svcctl_ChangeServiceConfig2A(
1188 void)
1189 {
1190 WINE_FIXME("\n");
1191 return ERROR_CALL_NOT_IMPLEMENTED;
1192 }
1193
1194 DWORD svcctl_QueryServiceConfig2A(
1195 void)
1196 {
1197 WINE_FIXME("\n");
1198 return ERROR_CALL_NOT_IMPLEMENTED;
1199 }
1200
1201
1202 DWORD RPC_Init(void)
1203 {
1204 WCHAR transport[] = SVCCTL_TRANSPORT;
1205 WCHAR endpoint[] = SVCCTL_ENDPOINT;
1206 DWORD err;
1207
1208 if ((err = RpcServerUseProtseqEpW(transport, 0, endpoint, NULL)) != ERROR_SUCCESS)
1209 {
1210 WINE_ERR("RpcServerUseProtseq failed with error %u\n", err);
1211 return err;
1212 }
1213
1214 if ((err = RpcServerRegisterIf(svcctl_v2_0_s_ifspec, 0, 0)) != ERROR_SUCCESS)
1215 {
1216 WINE_ERR("RpcServerRegisterIf failed with error %u\n", err);
1217 return err;
1218 }
1219
1220 if ((err = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, TRUE)) != ERROR_SUCCESS)
1221 {
1222 WINE_ERR("RpcServerListen failed with error %u\n", err);
1223 return err;
1224 }
1225 return ERROR_SUCCESS;
1226 }
1227
1228 DWORD RPC_MainLoop(void)
1229 {
1230 DWORD err;
1231 HANDLE hExitEvent = __wine_make_process_system();
1232
1233 SetEvent(g_hStartedEvent);
1234
1235 WINE_TRACE("Entered main loop\n");
1236
1237 do
1238 {
1239 err = WaitForSingleObjectEx(hExitEvent, INFINITE, TRUE);
1240 WINE_TRACE("Wait returned %d\n", err);
1241 } while (err != WAIT_OBJECT_0);
1242
1243 WINE_TRACE("Object signaled - wine shutdown\n");
1244 CloseHandle(hExitEvent);
1245 return ERROR_SUCCESS;
1246 }
1247
1248 void __RPC_USER SC_RPC_HANDLE_rundown(SC_RPC_HANDLE handle)
1249 {
1250 SC_RPC_HANDLE_destroy(handle);
1251 }
1252
1253 void __RPC_FAR * __RPC_USER MIDL_user_allocate(SIZE_T len)
1254 {
1255 return HeapAlloc(GetProcessHeap(), 0, len);
1256 }
1257
1258 void __RPC_USER MIDL_user_free(void __RPC_FAR * ptr)
1259 {
1260 HeapFree(GetProcessHeap(), 0, ptr);
1261 }
1262
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.