2 * Services.exe - RPC functions
4 * Copyright 2007 Google (Mikolaj Zalewski)
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.
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.
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
21 #define WIN32_LEAN_AND_MEAN
30 #include "wine/list.h"
31 #include "wine/unicode.h"
32 #include "wine/debug.h"
37 extern HANDLE CDECL
__wine_make_process_system(void);
39 WINE_DEFAULT_DEBUG_CHANNEL(service
);
41 static const GENERIC_MAPPING g_scm_generic
=
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
),
49 static const GENERIC_MAPPING g_svc_generic
=
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
),
59 SC_HTYPE_DONT_CARE
= 0,
70 struct sc_manager_handle
/* service control manager handle */
73 struct scmdatabase
*db
;
76 struct sc_service_handle
/* service handle */
79 struct service_entry
*service_entry
;
84 struct scmdatabase
*db
;
87 /* Check if the given handle is of the required type and allows the requested access. */
88 static DWORD
validate_context_handle(SC_RPC_HANDLE handle
, DWORD type
, DWORD needed_access
, struct sc_handle
**out_hdr
)
90 struct sc_handle
*hdr
= handle
;
92 if (type
!= SC_HTYPE_DONT_CARE
&& hdr
->type
!= type
)
94 WINE_ERR("Handle is of an invalid type (%d, %d)\n", hdr
->type
, type
);
95 return ERROR_INVALID_HANDLE
;
98 if ((needed_access
& hdr
->access
) != needed_access
)
100 WINE_ERR("Access denied - handle created with access %x, needed %x\n", hdr
->access
, needed_access
);
101 return ERROR_ACCESS_DENIED
;
105 return ERROR_SUCCESS
;
108 static DWORD
validate_scm_handle(SC_RPC_HANDLE handle
, DWORD needed_access
, struct sc_manager_handle
**manager
)
110 struct sc_handle
*hdr
;
111 DWORD err
= validate_context_handle(handle
, SC_HTYPE_MANAGER
, needed_access
, &hdr
);
112 if (err
== ERROR_SUCCESS
)
113 *manager
= (struct sc_manager_handle
*)hdr
;
117 static DWORD
validate_service_handle(SC_RPC_HANDLE handle
, DWORD needed_access
, struct sc_service_handle
**service
)
119 struct sc_handle
*hdr
;
120 DWORD err
= validate_context_handle(handle
, SC_HTYPE_SERVICE
, needed_access
, &hdr
);
121 if (err
== ERROR_SUCCESS
)
122 *service
= (struct sc_service_handle
*)hdr
;
126 DWORD
svcctl_OpenSCManagerW(
127 MACHINE_HANDLEW MachineName
, /* Note: this parameter is ignored */
128 LPCWSTR DatabaseName
,
130 SC_RPC_HANDLE
*handle
)
132 struct sc_manager_handle
*manager
;
134 WINE_TRACE("(%s, %s, %x)\n", wine_dbgstr_w(MachineName
), wine_dbgstr_w(DatabaseName
), dwAccessMask
);
136 if (DatabaseName
!= NULL
&& DatabaseName
[0])
138 if (strcmpW(DatabaseName
, SERVICES_FAILED_DATABASEW
) == 0)
139 return ERROR_DATABASE_DOES_NOT_EXIST
;
140 if (strcmpW(DatabaseName
, SERVICES_ACTIVE_DATABASEW
) != 0)
141 return ERROR_INVALID_NAME
;
144 if (!(manager
= HeapAlloc(GetProcessHeap(), 0, sizeof(*manager
))))
145 return ERROR_NOT_ENOUGH_SERVER_MEMORY
;
147 manager
->hdr
.type
= SC_HTYPE_MANAGER
;
149 if (dwAccessMask
& MAXIMUM_ALLOWED
)
150 dwAccessMask
|= SC_MANAGER_ALL_ACCESS
;
151 manager
->hdr
.access
= dwAccessMask
;
152 RtlMapGenericMask(&manager
->hdr
.access
, &g_scm_generic
);
153 manager
->db
= active_database
;
154 *handle
= &manager
->hdr
;
156 return ERROR_SUCCESS
;
159 static void SC_RPC_HANDLE_destroy(SC_RPC_HANDLE handle
)
161 struct sc_handle
*hdr
= handle
;
164 case SC_HTYPE_MANAGER
:
166 struct sc_manager_handle
*manager
= (struct sc_manager_handle
*)hdr
;
167 HeapFree(GetProcessHeap(), 0, manager
);
170 case SC_HTYPE_SERVICE
:
172 struct sc_service_handle
*service
= (struct sc_service_handle
*)hdr
;
173 release_service(service
->service_entry
);
174 HeapFree(GetProcessHeap(), 0, service
);
178 WINE_ERR("invalid handle type %d\n", hdr
->type
);
179 RpcRaiseException(ERROR_INVALID_HANDLE
);
183 DWORD
svcctl_GetServiceDisplayNameW(
184 SC_RPC_HANDLE hSCManager
,
185 LPCWSTR lpServiceName
,
190 struct sc_manager_handle
*manager
;
191 struct service_entry
*entry
;
194 WINE_TRACE("(%s, %d)\n", wine_dbgstr_w(lpServiceName
), cchBufSize
);
196 if ((err
= validate_scm_handle(hSCManager
, 0, &manager
)) != ERROR_SUCCESS
)
199 scmdatabase_lock_shared(manager
->db
);
201 entry
= scmdatabase_find_service(manager
->db
, lpServiceName
);
205 service_lock_shared(entry
);
206 name
= get_display_name(entry
);
207 *cchLength
= strlenW(name
);
208 if (*cchLength
< cchBufSize
)
211 lstrcpyW(lpBuffer
, name
);
214 err
= ERROR_INSUFFICIENT_BUFFER
;
215 service_unlock(entry
);
218 err
= ERROR_SERVICE_DOES_NOT_EXIST
;
220 scmdatabase_unlock(manager
->db
);
222 if (err
!= ERROR_SUCCESS
&& cchBufSize
> 0)
228 DWORD
svcctl_GetServiceKeyNameW(
229 SC_RPC_HANDLE hSCManager
,
230 LPCWSTR lpServiceDisplayName
,
235 struct service_entry
*entry
;
236 struct sc_manager_handle
*manager
;
239 WINE_TRACE("(%s, %d)\n", wine_dbgstr_w(lpServiceDisplayName
), cchBufSize
);
241 if ((err
= validate_scm_handle(hSCManager
, 0, &manager
)) != ERROR_SUCCESS
)
244 scmdatabase_lock_shared(manager
->db
);
246 entry
= scmdatabase_find_service_by_displayname(manager
->db
, lpServiceDisplayName
);
249 service_lock_shared(entry
);
250 *cchLength
= strlenW(entry
->name
);
251 if (*cchLength
< cchBufSize
)
254 lstrcpyW(lpBuffer
, entry
->name
);
257 err
= ERROR_INSUFFICIENT_BUFFER
;
258 service_unlock(entry
);
261 err
= ERROR_SERVICE_DOES_NOT_EXIST
;
263 scmdatabase_unlock(manager
->db
);
265 if (err
!= ERROR_SUCCESS
&& cchBufSize
> 0)
271 static DWORD
create_handle_for_service(struct service_entry
*entry
, DWORD dwDesiredAccess
, SC_RPC_HANDLE
*phService
)
273 struct sc_service_handle
*service
;
275 if (!(service
= HeapAlloc(GetProcessHeap(), 0, sizeof(*service
))))
277 release_service(entry
);
278 return ERROR_NOT_ENOUGH_SERVER_MEMORY
;
281 service
->hdr
.type
= SC_HTYPE_SERVICE
;
282 service
->hdr
.access
= dwDesiredAccess
;
283 RtlMapGenericMask(&service
->hdr
.access
, &g_svc_generic
);
284 service
->service_entry
= entry
;
285 if (dwDesiredAccess
& MAXIMUM_ALLOWED
)
286 dwDesiredAccess
|= SERVICE_ALL_ACCESS
;
288 *phService
= &service
->hdr
;
289 return ERROR_SUCCESS
;
292 DWORD
svcctl_OpenServiceW(
293 SC_RPC_HANDLE hSCManager
,
294 LPCWSTR lpServiceName
,
295 DWORD dwDesiredAccess
,
296 SC_RPC_HANDLE
*phService
)
298 struct sc_manager_handle
*manager
;
299 struct service_entry
*entry
;
302 WINE_TRACE("(%s, 0x%x)\n", wine_dbgstr_w(lpServiceName
), dwDesiredAccess
);
304 if ((err
= validate_scm_handle(hSCManager
, 0, &manager
)) != ERROR_SUCCESS
)
306 if (!validate_service_name(lpServiceName
))
307 return ERROR_INVALID_NAME
;
309 scmdatabase_lock_shared(manager
->db
);
310 entry
= scmdatabase_find_service(manager
->db
, lpServiceName
);
313 scmdatabase_unlock(manager
->db
);
316 return ERROR_SERVICE_DOES_NOT_EXIST
;
318 return create_handle_for_service(entry
, dwDesiredAccess
, phService
);
321 DWORD
svcctl_CreateServiceW(
322 SC_RPC_HANDLE hSCManager
,
323 LPCWSTR lpServiceName
,
324 LPCWSTR lpDisplayName
,
325 DWORD dwDesiredAccess
,
328 DWORD dwErrorControl
,
329 LPCWSTR lpBinaryPathName
,
330 LPCWSTR lpLoadOrderGroup
,
332 const BYTE
*lpDependencies
,
333 DWORD dwDependenciesSize
,
334 LPCWSTR lpServiceStartName
,
335 const BYTE
*lpPassword
,
336 DWORD dwPasswordSize
,
337 SC_RPC_HANDLE
*phService
)
339 struct sc_manager_handle
*manager
;
340 struct service_entry
*entry
;
343 WINE_TRACE("(%s, %s, 0x%x, %s)\n", wine_dbgstr_w(lpServiceName
), wine_dbgstr_w(lpDisplayName
), dwDesiredAccess
, wine_dbgstr_w(lpBinaryPathName
));
345 if ((err
= validate_scm_handle(hSCManager
, SC_MANAGER_CREATE_SERVICE
, &manager
)) != ERROR_SUCCESS
)
348 if (!validate_service_name(lpServiceName
))
349 return ERROR_INVALID_NAME
;
350 if (!check_multisz((LPCWSTR
)lpDependencies
, dwDependenciesSize
) || !lpServiceName
[0] || !lpBinaryPathName
[0])
351 return ERROR_INVALID_PARAMETER
;
354 WINE_FIXME("Don't know how to add a password\n"); /* I always get ERROR_GEN_FAILURE */
356 WINE_FIXME("Dependencies not supported yet\n");
358 err
= service_create(lpServiceName
, &entry
);
359 if (err
!= ERROR_SUCCESS
)
361 entry
->config
.dwServiceType
= entry
->status
.dwServiceType
= dwServiceType
;
362 entry
->config
.dwStartType
= dwStartType
;
363 entry
->config
.dwErrorControl
= dwErrorControl
;
364 entry
->config
.lpBinaryPathName
= strdupW(lpBinaryPathName
);
365 entry
->config
.lpLoadOrderGroup
= strdupW(lpLoadOrderGroup
);
366 entry
->config
.lpServiceStartName
= strdupW(lpServiceStartName
);
367 entry
->config
.lpDisplayName
= strdupW(lpDisplayName
);
369 if (lpdwTagId
) /* TODO: In most situations a non-NULL TagId will generate an ERROR_INVALID_PARAMETER. */
370 entry
->config
.dwTagId
= *lpdwTagId
;
372 entry
->config
.dwTagId
= 0;
374 /* other fields NULL*/
376 if (!validate_service_config(entry
))
378 WINE_ERR("Invalid data while trying to create service\n");
379 free_service_entry(entry
);
380 return ERROR_INVALID_PARAMETER
;
383 scmdatabase_lock_exclusive(manager
->db
);
385 if (scmdatabase_find_service(manager
->db
, lpServiceName
))
387 scmdatabase_unlock(manager
->db
);
388 free_service_entry(entry
);
389 return ERROR_SERVICE_EXISTS
;
392 if (scmdatabase_find_service_by_displayname(manager
->db
, get_display_name(entry
)))
394 scmdatabase_unlock(manager
->db
);
395 free_service_entry(entry
);
396 return ERROR_DUPLICATE_SERVICE_NAME
;
399 err
= scmdatabase_add_service(manager
->db
, entry
);
400 if (err
!= ERROR_SUCCESS
)
402 scmdatabase_unlock(manager
->db
);
403 free_service_entry(entry
);
406 scmdatabase_unlock(manager
->db
);
408 return create_handle_for_service(entry
, dwDesiredAccess
, phService
);
411 DWORD
svcctl_DeleteService(
412 SC_RPC_HANDLE hService
)
414 struct sc_service_handle
*service
;
417 if ((err
= validate_service_handle(hService
, DELETE
, &service
)) != ERROR_SUCCESS
)
420 scmdatabase_lock_exclusive(service
->service_entry
->db
);
421 service_lock_exclusive(service
->service_entry
);
423 if (!is_marked_for_delete(service
->service_entry
))
424 err
= scmdatabase_remove_service(service
->service_entry
->db
, service
->service_entry
);
426 err
= ERROR_SERVICE_MARKED_FOR_DELETE
;
428 service_unlock(service
->service_entry
);
429 scmdatabase_unlock(service
->service_entry
->db
);
434 DWORD
svcctl_QueryServiceConfigW(
435 SC_RPC_HANDLE hService
,
436 QUERY_SERVICE_CONFIGW
*config
)
438 struct sc_service_handle
*service
;
441 WINE_TRACE("(%p)\n", config
);
443 if ((err
= validate_service_handle(hService
, SERVICE_QUERY_CONFIG
, &service
)) != 0)
446 service_lock_shared(service
->service_entry
);
447 config
->dwServiceType
= service
->service_entry
->config
.dwServiceType
;
448 config
->dwStartType
= service
->service_entry
->config
.dwStartType
;
449 config
->dwErrorControl
= service
->service_entry
->config
.dwErrorControl
;
450 config
->lpBinaryPathName
= strdupW(service
->service_entry
->config
.lpBinaryPathName
);
451 config
->lpLoadOrderGroup
= strdupW(service
->service_entry
->config
.lpLoadOrderGroup
);
452 config
->dwTagId
= service
->service_entry
->config
.dwTagId
;
453 config
->lpDependencies
= NULL
; /* TODO */
454 config
->lpServiceStartName
= strdupW(service
->service_entry
->config
.lpServiceStartName
);
455 config
->lpDisplayName
= strdupW(service
->service_entry
->config
.lpDisplayName
);
456 service_unlock(service
->service_entry
);
458 return ERROR_SUCCESS
;
461 DWORD
svcctl_ChangeServiceConfigW(
462 SC_RPC_HANDLE hService
,
465 DWORD dwErrorControl
,
466 LPCWSTR lpBinaryPathName
,
467 LPCWSTR lpLoadOrderGroup
,
469 const BYTE
*lpDependencies
,
470 DWORD dwDependenciesSize
,
471 LPCWSTR lpServiceStartName
,
472 const BYTE
*lpPassword
,
473 DWORD dwPasswordSize
,
474 LPCWSTR lpDisplayName
)
476 struct service_entry new_entry
, *entry
;
477 struct sc_service_handle
*service
;
482 if ((err
= validate_service_handle(hService
, SERVICE_CHANGE_CONFIG
, &service
)) != 0)
485 if (!check_multisz((LPCWSTR
)lpDependencies
, dwDependenciesSize
))
486 return ERROR_INVALID_PARAMETER
;
488 /* first check if the new configuration is correct */
489 service_lock_exclusive(service
->service_entry
);
491 if (is_marked_for_delete(service
->service_entry
))
493 service_unlock(service
->service_entry
);
494 return ERROR_SERVICE_MARKED_FOR_DELETE
;
497 if (lpDisplayName
!= NULL
&&
498 (entry
= scmdatabase_find_service_by_displayname(service
->service_entry
->db
, lpDisplayName
)) &&
499 (entry
!= service
->service_entry
))
501 service_unlock(service
->service_entry
);
502 return ERROR_DUPLICATE_SERVICE_NAME
;
505 new_entry
= *service
->service_entry
;
507 if (dwServiceType
!= SERVICE_NO_CHANGE
)
508 new_entry
.config
.dwServiceType
= dwServiceType
;
510 if (dwStartType
!= SERVICE_NO_CHANGE
)
511 new_entry
.config
.dwStartType
= dwStartType
;
513 if (dwErrorControl
!= SERVICE_NO_CHANGE
)
514 new_entry
.config
.dwErrorControl
= dwErrorControl
;
516 if (lpBinaryPathName
!= NULL
)
517 new_entry
.config
.lpBinaryPathName
= (LPWSTR
)lpBinaryPathName
;
519 if (lpLoadOrderGroup
!= NULL
)
520 new_entry
.config
.lpLoadOrderGroup
= (LPWSTR
)lpLoadOrderGroup
;
522 if (lpdwTagId
!= NULL
)
523 WINE_FIXME("Changing tag id not supported\n");
525 if (lpDependencies
!= NULL
)
526 WINE_FIXME("Chainging dependencies not supported\n");
528 if (lpServiceStartName
!= NULL
)
529 new_entry
.config
.lpServiceStartName
= (LPWSTR
)lpServiceStartName
;
531 if (lpPassword
!= NULL
)
532 WINE_FIXME("Setting password not supported\n");
534 if (lpDisplayName
!= NULL
)
535 new_entry
.config
.lpDisplayName
= (LPWSTR
)lpDisplayName
;
537 if (!validate_service_config(&new_entry
))
539 WINE_ERR("The configuration after the change wouldn't be valid\n");
540 service_unlock(service
->service_entry
);
541 return ERROR_INVALID_PARAMETER
;
544 /* configuration OK. The strings needs to be duplicated */
545 if (lpBinaryPathName
!= NULL
)
547 HeapFree(GetProcessHeap(), 0, service
->service_entry
->config
.lpBinaryPathName
);
548 new_entry
.config
.lpBinaryPathName
= strdupW(lpBinaryPathName
);
551 if (lpLoadOrderGroup
!= NULL
)
553 HeapFree(GetProcessHeap(), 0, service
->service_entry
->config
.lpLoadOrderGroup
);
554 new_entry
.config
.lpLoadOrderGroup
= strdupW(lpLoadOrderGroup
);
557 if (lpServiceStartName
!= NULL
)
559 HeapFree(GetProcessHeap(), 0, service
->service_entry
->config
.lpServiceStartName
);
560 new_entry
.config
.lpServiceStartName
= strdupW(lpServiceStartName
);
563 if (lpDisplayName
!= NULL
)
565 HeapFree(GetProcessHeap(), 0, service
->service_entry
->config
.lpDisplayName
);
566 new_entry
.config
.lpDisplayName
= strdupW(lpDisplayName
);
569 *service
->service_entry
= new_entry
;
570 save_service_config(service
->service_entry
);
571 service_unlock(service
->service_entry
);
573 return ERROR_SUCCESS
;
576 DWORD
svcctl_SetServiceStatus(
577 SC_RPC_HANDLE hServiceStatus
,
578 LPSERVICE_STATUS lpServiceStatus
)
580 struct sc_service_handle
*service
;
583 WINE_TRACE("(%p, %p)\n", hServiceStatus
, lpServiceStatus
);
585 if ((err
= validate_service_handle(hServiceStatus
, SERVICE_SET_STATUS
, &service
)) != 0)
588 service_lock_exclusive(service
->service_entry
);
589 /* FIXME: be a bit more discriminant about what parts of the status we set
590 * and check that fields are valid */
591 service
->service_entry
->status
.dwServiceType
= lpServiceStatus
->dwServiceType
;
592 service
->service_entry
->status
.dwCurrentState
= lpServiceStatus
->dwCurrentState
;
593 service
->service_entry
->status
.dwControlsAccepted
= lpServiceStatus
->dwControlsAccepted
;
594 service
->service_entry
->status
.dwWin32ExitCode
= lpServiceStatus
->dwWin32ExitCode
;
595 service
->service_entry
->status
.dwServiceSpecificExitCode
= lpServiceStatus
->dwServiceSpecificExitCode
;
596 service
->service_entry
->status
.dwCheckPoint
= lpServiceStatus
->dwCheckPoint
;
597 service
->service_entry
->status
.dwWaitHint
= lpServiceStatus
->dwWaitHint
;
598 service_unlock(service
->service_entry
);
600 if (service
->service_entry
->status_changed_event
)
601 SetEvent(service
->service_entry
->status_changed_event
);
603 return ERROR_SUCCESS
;
606 DWORD
svcctl_ChangeServiceConfig2W( SC_RPC_HANDLE hService
, DWORD level
, SERVICE_CONFIG2W
*config
)
608 struct sc_service_handle
*service
;
611 if ((err
= validate_service_handle(hService
, SERVICE_CHANGE_CONFIG
, &service
)) != 0)
616 case SERVICE_CONFIG_DESCRIPTION
:
620 if (config
->descr
.lpDescription
[0])
622 if (!(descr
= strdupW( config
->descr
.lpDescription
)))
623 return ERROR_NOT_ENOUGH_MEMORY
;
626 WINE_TRACE( "changing service %p descr to %s\n", service
, wine_dbgstr_w(descr
) );
627 service_lock_exclusive( service
->service_entry
);
628 HeapFree( GetProcessHeap(), 0, service
->service_entry
->description
);
629 service
->service_entry
->description
= descr
;
630 save_service_config( service
->service_entry
);
631 service_unlock( service
->service_entry
);
634 case SERVICE_CONFIG_FAILURE_ACTIONS
:
635 WINE_FIXME( "SERVICE_CONFIG_FAILURE_ACTIONS not implemented: period %u msg %s cmd %s\n",
636 config
->actions
.dwResetPeriod
,
637 wine_dbgstr_w(config
->actions
.lpRebootMsg
),
638 wine_dbgstr_w(config
->actions
.lpCommand
) );
641 WINE_FIXME("level %u not implemented\n", level
);
642 err
= ERROR_INVALID_LEVEL
;
648 DWORD
svcctl_QueryServiceConfig2W( SC_RPC_HANDLE hService
, DWORD level
,
649 BYTE
*buffer
, DWORD size
, LPDWORD needed
)
651 struct sc_service_handle
*service
;
654 if ((err
= validate_service_handle(hService
, SERVICE_QUERY_STATUS
, &service
)) != 0)
659 case SERVICE_CONFIG_DESCRIPTION
:
661 SERVICE_DESCRIPTIONW
*descr
= (SERVICE_DESCRIPTIONW
*)buffer
;
663 service_lock_shared(service
->service_entry
);
664 *needed
= sizeof(*descr
);
665 if (service
->service_entry
->description
)
666 *needed
+= (strlenW(service
->service_entry
->description
) + 1) * sizeof(WCHAR
);
669 if (service
->service_entry
->description
)
671 /* store a buffer offset instead of a pointer */
672 descr
->lpDescription
= (WCHAR
*)((BYTE
*)(descr
+ 1) - buffer
);
673 strcpyW( (WCHAR
*)(descr
+ 1), service
->service_entry
->description
);
675 else descr
->lpDescription
= NULL
;
677 else err
= ERROR_INSUFFICIENT_BUFFER
;
678 service_unlock(service
->service_entry
);
683 WINE_FIXME("level %u not implemented\n", level
);
684 err
= ERROR_INVALID_LEVEL
;
690 DWORD
svcctl_QueryServiceStatusEx(
691 SC_RPC_HANDLE hService
,
692 SC_STATUS_TYPE InfoLevel
,
695 LPDWORD pcbBytesNeeded
)
697 struct sc_service_handle
*service
;
699 LPSERVICE_STATUS_PROCESS pSvcStatusData
;
701 if ((err
= validate_service_handle(hService
, SERVICE_QUERY_STATUS
, &service
)) != 0)
704 if (InfoLevel
!= SC_STATUS_PROCESS_INFO
)
705 return ERROR_INVALID_LEVEL
;
707 pSvcStatusData
= (LPSERVICE_STATUS_PROCESS
) lpBuffer
;
708 if (pSvcStatusData
== NULL
)
709 return ERROR_INVALID_PARAMETER
;
711 if (cbBufSize
< sizeof(SERVICE_STATUS_PROCESS
))
713 if( pcbBytesNeeded
!= NULL
)
714 *pcbBytesNeeded
= sizeof(SERVICE_STATUS_PROCESS
);
716 return ERROR_INSUFFICIENT_BUFFER
;
719 service_lock_shared(service
->service_entry
);
721 pSvcStatusData
->dwServiceType
= service
->service_entry
->status
.dwServiceType
;
722 pSvcStatusData
->dwCurrentState
= service
->service_entry
->status
.dwCurrentState
;
723 pSvcStatusData
->dwControlsAccepted
= service
->service_entry
->status
.dwControlsAccepted
;
724 pSvcStatusData
->dwWin32ExitCode
= service
->service_entry
->status
.dwWin32ExitCode
;
725 pSvcStatusData
->dwServiceSpecificExitCode
= service
->service_entry
->status
.dwServiceSpecificExitCode
;
726 pSvcStatusData
->dwCheckPoint
= service
->service_entry
->status
.dwCheckPoint
;
727 pSvcStatusData
->dwWaitHint
= service
->service_entry
->status
.dwWaitHint
;
728 pSvcStatusData
->dwProcessId
= service
->service_entry
->status
.dwProcessId
;
729 pSvcStatusData
->dwServiceFlags
= service
->service_entry
->status
.dwServiceFlags
;
731 service_unlock(service
->service_entry
);
733 return ERROR_SUCCESS
;
736 /******************************************************************************
737 * service_accepts_control
739 static BOOL
service_accepts_control(const struct service_entry
*service
, DWORD dwControl
)
741 DWORD a
= service
->status
.dwControlsAccepted
;
745 case SERVICE_CONTROL_INTERROGATE
:
747 case SERVICE_CONTROL_STOP
:
748 if (a
&SERVICE_ACCEPT_STOP
)
751 case SERVICE_CONTROL_SHUTDOWN
:
752 if (a
&SERVICE_ACCEPT_SHUTDOWN
)
755 case SERVICE_CONTROL_PAUSE
:
756 case SERVICE_CONTROL_CONTINUE
:
757 if (a
&SERVICE_ACCEPT_PAUSE_CONTINUE
)
760 case SERVICE_CONTROL_PARAMCHANGE
:
761 if (a
&SERVICE_ACCEPT_PARAMCHANGE
)
764 case SERVICE_CONTROL_NETBINDADD
:
765 case SERVICE_CONTROL_NETBINDREMOVE
:
766 case SERVICE_CONTROL_NETBINDENABLE
:
767 case SERVICE_CONTROL_NETBINDDISABLE
:
768 if (a
&SERVICE_ACCEPT_NETBINDCHANGE
)
770 case SERVICE_CONTROL_HARDWAREPROFILECHANGE
:
771 if (a
&SERVICE_ACCEPT_HARDWAREPROFILECHANGE
)
774 case SERVICE_CONTROL_POWEREVENT
:
775 if (a
&SERVICE_ACCEPT_POWEREVENT
)
778 case SERVICE_CONTROL_SESSIONCHANGE
:
779 if (a
&SERVICE_ACCEPT_SESSIONCHANGE
)
786 /******************************************************************************
787 * service_send_control
789 static BOOL
service_send_control(struct service_entry
*service
, HANDLE pipe
, DWORD dwControl
, DWORD
*result
)
791 service_start_info
*ssi
;
792 DWORD len
, count
= 0;
795 /* calculate how much space we need to send the startup info */
796 len
= strlenW(service
->name
) + 1;
798 ssi
= HeapAlloc(GetProcessHeap(),0,FIELD_OFFSET(service_start_info
, data
[len
]));
799 ssi
->cmd
= WINESERV_SENDCONTROL
;
800 ssi
->control
= dwControl
;
801 ssi
->total_size
= FIELD_OFFSET(service_start_info
, data
[len
]);
802 ssi
->name_size
= strlenW(service
->name
) + 1;
803 strcpyW( ssi
->data
, service
->name
);
805 r
= WriteFile(pipe
, ssi
, ssi
->total_size
, &count
, NULL
);
806 if (!r
|| count
!= ssi
->total_size
)
808 WINE_ERR("service protocol error - failed to write pipe!\n");
811 r
= ReadFile(pipe
, result
, sizeof *result
, &count
, NULL
);
812 if (!r
|| count
!= sizeof *result
)
813 WINE_ERR("service protocol error - failed to read pipe "
814 "r = %d count = %d!\n", r
, count
);
818 DWORD
svcctl_StartServiceW(
819 SC_RPC_HANDLE hService
,
820 DWORD dwNumServiceArgs
,
821 LPCWSTR
*lpServiceArgVectors
)
823 struct sc_service_handle
*service
;
826 WINE_TRACE("(%p, %d, %p)\n", hService
, dwNumServiceArgs
, lpServiceArgVectors
);
828 if ((err
= validate_service_handle(hService
, SERVICE_START
, &service
)) != 0)
831 err
= service_start(service
->service_entry
, dwNumServiceArgs
, lpServiceArgVectors
);
836 DWORD
svcctl_ControlService(
837 SC_RPC_HANDLE hService
,
839 SERVICE_STATUS
*lpServiceStatus
)
841 DWORD access_required
;
842 struct sc_service_handle
*service
;
845 HANDLE control_mutex
;
848 WINE_TRACE("(%p, %d, %p)\n", hService
, dwControl
, lpServiceStatus
);
852 case SERVICE_CONTROL_CONTINUE
:
853 case SERVICE_CONTROL_NETBINDADD
:
854 case SERVICE_CONTROL_NETBINDDISABLE
:
855 case SERVICE_CONTROL_NETBINDENABLE
:
856 case SERVICE_CONTROL_NETBINDREMOVE
:
857 case SERVICE_CONTROL_PARAMCHANGE
:
858 case SERVICE_CONTROL_PAUSE
:
859 access_required
= SERVICE_PAUSE_CONTINUE
;
861 case SERVICE_CONTROL_INTERROGATE
:
862 access_required
= SERVICE_INTERROGATE
;
864 case SERVICE_CONTROL_STOP
:
865 access_required
= SERVICE_STOP
;
868 if (dwControl
>= 128 && dwControl
<= 255)
869 access_required
= SERVICE_USER_DEFINED_CONTROL
;
871 return ERROR_INVALID_PARAMETER
;
874 if ((err
= validate_service_handle(hService
, access_required
, &service
)) != 0)
877 service_lock_exclusive(service
->service_entry
);
881 lpServiceStatus
->dwServiceType
= service
->service_entry
->status
.dwServiceType
;
882 lpServiceStatus
->dwCurrentState
= service
->service_entry
->status
.dwCurrentState
;
883 lpServiceStatus
->dwControlsAccepted
= service
->service_entry
->status
.dwControlsAccepted
;
884 lpServiceStatus
->dwWin32ExitCode
= service
->service_entry
->status
.dwWin32ExitCode
;
885 lpServiceStatus
->dwServiceSpecificExitCode
= service
->service_entry
->status
.dwServiceSpecificExitCode
;
886 lpServiceStatus
->dwCheckPoint
= service
->service_entry
->status
.dwCheckPoint
;
887 lpServiceStatus
->dwWaitHint
= service
->service_entry
->status
.dwWaitHint
;
890 if (!service_accepts_control(service
->service_entry
, dwControl
))
892 service_unlock(service
->service_entry
);
893 return ERROR_INVALID_SERVICE_CONTROL
;
896 switch (service
->service_entry
->status
.dwCurrentState
)
898 case SERVICE_STOPPED
:
899 service_unlock(service
->service_entry
);
900 return ERROR_SERVICE_NOT_ACTIVE
;
901 case SERVICE_START_PENDING
:
902 if (dwControl
==SERVICE_CONTROL_STOP
)
905 case SERVICE_STOP_PENDING
:
906 service_unlock(service
->service_entry
);
907 return ERROR_SERVICE_CANNOT_ACCEPT_CTRL
;
910 /* prevent races by caching these variables and clearing them on
911 * stop here instead of outside the services lock */
912 control_mutex
= service
->service_entry
->control_mutex
;
913 control_pipe
= service
->service_entry
->control_pipe
;
914 if (dwControl
== SERVICE_CONTROL_STOP
)
916 service
->service_entry
->control_mutex
= NULL
;
917 service
->service_entry
->control_pipe
= INVALID_HANDLE_VALUE
;
920 service_unlock(service
->service_entry
);
922 ret
= WaitForSingleObject(control_mutex
, 30000);
923 if (ret
== WAIT_OBJECT_0
)
925 DWORD result
= ERROR_SUCCESS
;
927 ret
= service_send_control(service
->service_entry
, control_pipe
, dwControl
, &result
);
929 if (dwControl
== SERVICE_CONTROL_STOP
)
931 CloseHandle(control_mutex
);
932 CloseHandle(control_pipe
);
935 ReleaseMutex(control_mutex
);
941 if (dwControl
== SERVICE_CONTROL_STOP
)
943 CloseHandle(control_mutex
);
944 CloseHandle(control_pipe
);
946 return ERROR_SERVICE_REQUEST_TIMEOUT
;
950 DWORD
svcctl_CloseServiceHandle(
951 SC_RPC_HANDLE
*handle
)
953 WINE_TRACE("(&%p)\n", *handle
);
955 SC_RPC_HANDLE_destroy(*handle
);
958 return ERROR_SUCCESS
;
961 static void SC_RPC_LOCK_destroy(SC_RPC_LOCK hLock
)
963 struct sc_lock
*lock
= hLock
;
964 scmdatabase_unlock_startup(lock
->db
);
965 HeapFree(GetProcessHeap(), 0, lock
);
968 void __RPC_USER
SC_RPC_LOCK_rundown(SC_RPC_LOCK hLock
)
970 SC_RPC_LOCK_destroy(hLock
);
973 DWORD
svcctl_LockServiceDatabase(
974 SC_RPC_HANDLE hSCManager
,
977 struct sc_manager_handle
*manager
;
978 struct sc_lock
*lock
;
981 WINE_TRACE("(%p, %p)\n", hSCManager
, phLock
);
983 if ((err
= validate_scm_handle(hSCManager
, SC_MANAGER_LOCK
, &manager
)) != ERROR_SUCCESS
)
986 err
= scmdatabase_lock_startup(manager
->db
);
987 if (err
!= ERROR_SUCCESS
)
990 lock
= HeapAlloc(GetProcessHeap(), 0, sizeof(struct sc_lock
));
993 scmdatabase_unlock_startup(manager
->db
);
994 return ERROR_NOT_ENOUGH_SERVER_MEMORY
;
997 lock
->db
= manager
->db
;
1000 return ERROR_SUCCESS
;
1003 DWORD
svcctl_UnlockServiceDatabase(
1004 SC_RPC_LOCK
*phLock
)
1006 WINE_TRACE("(&%p)\n", *phLock
);
1008 SC_RPC_LOCK_destroy(*phLock
);
1011 return ERROR_SUCCESS
;
1014 DWORD
svcctl_QueryServiceObjectSecurity(
1018 return ERROR_CALL_NOT_IMPLEMENTED
;
1021 DWORD
svcctl_SetServiceObjectSecurity(
1025 return ERROR_CALL_NOT_IMPLEMENTED
;
1028 DWORD
svcctl_QueryServiceStatus(
1032 return ERROR_CALL_NOT_IMPLEMENTED
;
1036 DWORD
svcctl_NotifyBootConfigStatus(
1040 return ERROR_CALL_NOT_IMPLEMENTED
;
1043 DWORD
svcctl_SCSetServiceBitsW(
1047 return ERROR_CALL_NOT_IMPLEMENTED
;
1051 DWORD
svcctl_EnumDependentServicesW(
1055 return ERROR_CALL_NOT_IMPLEMENTED
;
1058 DWORD
svcctl_EnumServicesStatusW(
1062 return ERROR_CALL_NOT_IMPLEMENTED
;
1066 DWORD
svcctl_QueryServiceLockStatusW(
1070 return ERROR_CALL_NOT_IMPLEMENTED
;
1073 DWORD
svcctl_SCSetServiceBitsA(
1077 return ERROR_CALL_NOT_IMPLEMENTED
;
1080 DWORD
svcctl_ChangeServiceConfigA(
1084 return ERROR_CALL_NOT_IMPLEMENTED
;
1087 DWORD
svcctl_CreateServiceA(
1091 return ERROR_CALL_NOT_IMPLEMENTED
;
1094 DWORD
svcctl_EnumDependentServicesA(
1098 return ERROR_CALL_NOT_IMPLEMENTED
;
1101 DWORD
svcctl_EnumServicesStatusA(
1105 return ERROR_CALL_NOT_IMPLEMENTED
;
1108 DWORD
svcctl_OpenSCManagerA(
1112 return ERROR_CALL_NOT_IMPLEMENTED
;
1115 DWORD
svcctl_OpenServiceA(
1119 return ERROR_CALL_NOT_IMPLEMENTED
;
1122 DWORD
svcctl_QueryServiceConfigA(
1126 return ERROR_CALL_NOT_IMPLEMENTED
;
1129 DWORD
svcctl_QueryServiceLockStatusA(
1133 return ERROR_CALL_NOT_IMPLEMENTED
;
1136 DWORD
svcctl_StartServiceA(
1140 return ERROR_CALL_NOT_IMPLEMENTED
;
1143 DWORD
svcctl_GetServiceDisplayNameA(
1147 return ERROR_CALL_NOT_IMPLEMENTED
;
1150 DWORD
svcctl_GetServiceKeyNameA(
1154 return ERROR_CALL_NOT_IMPLEMENTED
;
1157 DWORD
svcctl_GetCurrentGroupStateW(
1161 return ERROR_CALL_NOT_IMPLEMENTED
;
1164 DWORD
svcctl_EnumServiceGroupW(
1168 return ERROR_CALL_NOT_IMPLEMENTED
;
1171 DWORD
svcctl_ChangeServiceConfig2A(
1175 return ERROR_CALL_NOT_IMPLEMENTED
;
1178 DWORD
svcctl_QueryServiceConfig2A(
1182 return ERROR_CALL_NOT_IMPLEMENTED
;
1186 DWORD
RPC_Init(void)
1188 WCHAR transport
[] = SVCCTL_TRANSPORT
;
1189 WCHAR endpoint
[] = SVCCTL_ENDPOINT
;
1192 if ((err
= RpcServerUseProtseqEpW(transport
, 0, endpoint
, NULL
)) != ERROR_SUCCESS
)
1194 WINE_ERR("RpcServerUseProtseq failed with error %u\n", err
);
1198 if ((err
= RpcServerRegisterIf(svcctl_v2_0_s_ifspec
, 0, 0)) != ERROR_SUCCESS
)
1200 WINE_ERR("RpcServerRegisterIf failed with error %u\n", err
);
1204 if ((err
= RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT
, TRUE
)) != ERROR_SUCCESS
)
1206 WINE_ERR("RpcServerListen failed with error %u\n", err
);
1209 return ERROR_SUCCESS
;
1212 DWORD
RPC_MainLoop(void)
1215 HANDLE hExitEvent
= __wine_make_process_system();
1217 SetEvent(g_hStartedEvent
);
1219 WINE_TRACE("Entered main loop\n");
1223 err
= WaitForSingleObjectEx(hExitEvent
, INFINITE
, TRUE
);
1224 WINE_TRACE("Wait returned %d\n", err
);
1225 } while (err
!= WAIT_OBJECT_0
);
1227 WINE_TRACE("Object signaled - wine shutdown\n");
1228 CloseHandle(hExitEvent
);
1229 return ERROR_SUCCESS
;
1232 void __RPC_USER
SC_RPC_HANDLE_rundown(SC_RPC_HANDLE handle
)
1234 SC_RPC_HANDLE_destroy(handle
);
1237 void __RPC_FAR
* __RPC_USER
MIDL_user_allocate(SIZE_T len
)
1239 return HeapAlloc(GetProcessHeap(), 0, len
);
1242 void __RPC_USER
MIDL_user_free(void __RPC_FAR
* ptr
)
1244 HeapFree(GetProcessHeap(), 0, ptr
);