2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS system libraries
4 * FILE: lib/advapi32/service/scm.c
5 * PURPOSE: Service control manager functions
6 * PROGRAMMER: Emanuele Aliberti
13 /* INCLUDES ******************************************************************/
17 #include "wine/debug.h"
19 WINE_DEFAULT_DEBUG_CHANNEL(advapi
);
22 /* FUNCTIONS *****************************************************************/
25 SVCCTL_HANDLEA_bind(SVCCTL_HANDLEA szMachineName
)
27 handle_t hBinding
= NULL
;
28 UCHAR
*pszStringBinding
;
31 TRACE("SVCCTL_HANDLEA_bind() called\n");
33 status
= RpcStringBindingComposeA((UCHAR
*)szMachineName
,
36 (UCHAR
*)"\\pipe\\ntsvcs",
38 (UCHAR
**)&pszStringBinding
);
41 ERR("RpcStringBindingCompose returned 0x%x\n", status
);
45 /* Set the binding handle that will be used to bind to the server. */
46 status
= RpcBindingFromStringBindingA(pszStringBinding
,
50 ERR("RpcBindingFromStringBinding returned 0x%x\n", status
);
53 status
= RpcStringFreeA(&pszStringBinding
);
56 ERR("RpcStringFree returned 0x%x\n", status
);
64 SVCCTL_HANDLEA_unbind(SVCCTL_HANDLEA szMachineName
,
69 TRACE("SVCCTL_HANDLEA_unbind() called\n");
71 status
= RpcBindingFree(&hBinding
);
74 ERR("RpcBindingFree returned 0x%x\n", status
);
80 SVCCTL_HANDLEW_bind(SVCCTL_HANDLEW szMachineName
)
82 handle_t hBinding
= NULL
;
83 LPWSTR pszStringBinding
;
86 TRACE("SVCCTL_HANDLEW_bind() called\n");
88 status
= RpcStringBindingComposeW(szMachineName
,
96 ERR("RpcStringBindingCompose returned 0x%x\n", status
);
100 /* Set the binding handle that will be used to bind to the server. */
101 status
= RpcBindingFromStringBindingW(pszStringBinding
,
105 ERR("RpcBindingFromStringBinding returned 0x%x\n", status
);
108 status
= RpcStringFreeW(&pszStringBinding
);
111 ERR("RpcStringFree returned 0x%x\n", status
);
119 SVCCTL_HANDLEW_unbind(SVCCTL_HANDLEW szMachineName
,
124 TRACE("SVCCTL_HANDLEW_unbind() called\n");
126 status
= RpcBindingFree(&hBinding
);
129 ERR("RpcBindingFree returned 0x%x\n", status
);
135 RPC_SERVICE_STATUS_HANDLE_bind(RPC_SERVICE_STATUS_HANDLE hServiceStatus
)
137 handle_t hBinding
= NULL
;
138 LPWSTR pszStringBinding
;
141 TRACE("RPC_SERVICE_STATUS_HANDLE_bind() called\n");
143 status
= RpcStringBindingComposeW(NULL
,
151 ERR("RpcStringBindingCompose returned 0x%x\n", status
);
155 /* Set the binding handle that will be used to bind to the server. */
156 status
= RpcBindingFromStringBindingW(pszStringBinding
,
160 ERR("RpcBindingFromStringBinding returned 0x%x\n", status
);
163 status
= RpcStringFreeW(&pszStringBinding
);
166 ERR("RpcStringFree returned 0x%x\n", status
);
174 RPC_SERVICE_STATUS_HANDLE_unbind(RPC_SERVICE_STATUS_HANDLE hServiceStatus
,
179 TRACE("RPC_SERVICE_STATUS_HANDLE_unbind() called\n");
181 status
= RpcBindingFree(&hBinding
);
184 ERR("RpcBindingFree returned 0x%x\n", status
);
190 ScmRpcStatusToWinError(RPC_STATUS Status
)
194 case RPC_X_SS_IN_NULL_CONTEXT
:
195 return ERROR_INVALID_HANDLE
;
197 case RPC_X_NULL_REF_POINTER
:
198 return ERROR_INVALID_PARAMETER
;
200 case STATUS_ACCESS_VIOLATION
:
201 return ERROR_INVALID_ADDRESS
;
204 return (DWORD
)Status
;
209 /**********************************************************************
210 * ChangeServiceConfig2A
215 ChangeServiceConfig2A(SC_HANDLE hService
,
219 SC_RPC_CONFIG_INFOA Info
;
222 TRACE("ChangeServiceConfig2A() called\n");
224 /* Fill relevent field of the Info structure */
225 Info
.dwInfoLevel
= dwInfoLevel
;
228 case SERVICE_CONFIG_DESCRIPTION
:
229 Info
.psd
= (LPSERVICE_DESCRIPTIONA
)&lpInfo
;
232 case SERVICE_CONFIG_FAILURE_ACTIONS
:
233 Info
.psfa
= (LPSERVICE_FAILURE_ACTIONSA
)&lpInfo
;
237 WARN("Unknown info level 0x%lx\n", dwInfoLevel
);
238 SetLastError(ERROR_INVALID_PARAMETER
);
247 dwError
= RChangeServiceConfig2A((SC_RPC_HANDLE
)hService
,
252 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
256 if (dwError
!= ERROR_SUCCESS
)
258 ERR("RChangeServiceConfig2A() failed (Error %lu)\n", dwError
);
259 SetLastError(dwError
);
267 /**********************************************************************
268 * ChangeServiceConfig2W
273 ChangeServiceConfig2W(SC_HANDLE hService
,
277 SC_RPC_CONFIG_INFOW Info
;
280 TRACE("ChangeServiceConfig2W() called\n");
282 /* Fill relevent field of the Info structure */
283 Info
.dwInfoLevel
= dwInfoLevel
;
286 case SERVICE_CONFIG_DESCRIPTION
:
288 Info
.psd
= (LPSERVICE_DESCRIPTIONW
)&lpInfo
;
292 case SERVICE_CONFIG_FAILURE_ACTIONS
:
293 Info
.psfa
= (LPSERVICE_FAILURE_ACTIONSW
)&lpInfo
;
297 WARN("Unknown info level 0x%lx\n", dwInfoLevel
);
298 SetLastError(ERROR_INVALID_PARAMETER
);
307 dwError
= RChangeServiceConfig2W((SC_RPC_HANDLE
)hService
,
312 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
316 if (dwError
!= ERROR_SUCCESS
)
318 ERR("RChangeServiceConfig2W() failed (Error %lu)\n", dwError
);
319 SetLastError(dwError
);
327 /**********************************************************************
328 * ChangeServiceConfigA
333 ChangeServiceConfigA(SC_HANDLE hService
,
336 DWORD dwErrorControl
,
337 LPCSTR lpBinaryPathName
,
338 LPCSTR lpLoadOrderGroup
,
340 LPCSTR lpDependencies
,
341 LPCSTR lpServiceStartName
,
343 LPCSTR lpDisplayName
)
346 DWORD dwDependenciesLength
= 0;
350 TRACE("ChangeServiceConfigA() called\n");
352 /* Calculate the Dependencies length*/
353 if (lpDependencies
!= NULL
)
355 lpStr
= (LPSTR
)lpDependencies
;
358 dwLength
= strlen(lpStr
) + 1;
359 dwDependenciesLength
+= dwLength
;
360 lpStr
= lpStr
+ dwLength
;
362 dwDependenciesLength
++;
365 /* FIXME: Encrypt the password */
369 /* Call to services.exe using RPC */
370 dwError
= RChangeServiceConfigA((SC_RPC_HANDLE
)hService
,
374 (LPSTR
)lpBinaryPathName
,
375 (LPSTR
)lpLoadOrderGroup
,
377 (LPSTR
)lpDependencies
,
378 dwDependenciesLength
,
379 (LPSTR
)lpServiceStartName
,
380 NULL
, /* FIXME: lpPassword */
381 0, /* FIXME: dwPasswordLength */
382 (LPSTR
)lpDisplayName
);
386 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
390 if (dwError
!= ERROR_SUCCESS
)
392 ERR("RChangeServiceConfigA() failed (Error %lu)\n", dwError
);
393 SetLastError(dwError
);
401 /**********************************************************************
402 * ChangeServiceConfigW
407 ChangeServiceConfigW(SC_HANDLE hService
,
410 DWORD dwErrorControl
,
411 LPCWSTR lpBinaryPathName
,
412 LPCWSTR lpLoadOrderGroup
,
414 LPCWSTR lpDependencies
,
415 LPCWSTR lpServiceStartName
,
417 LPCWSTR lpDisplayName
)
420 DWORD dwDependenciesLength
= 0;
424 TRACE("ChangeServiceConfigW() called\n");
426 /* Calculate the Dependencies length*/
427 if (lpDependencies
!= NULL
)
429 lpStr
= (LPWSTR
)lpDependencies
;
432 dwLength
= wcslen(lpStr
) + 1;
433 dwDependenciesLength
+= dwLength
;
434 lpStr
= lpStr
+ dwLength
;
436 dwDependenciesLength
++;
439 /* FIXME: Encrypt the password */
443 /* Call to services.exe using RPC */
444 dwError
= RChangeServiceConfigW((SC_RPC_HANDLE
)hService
,
448 (LPWSTR
)lpBinaryPathName
,
449 (LPWSTR
)lpLoadOrderGroup
,
451 (LPBYTE
)lpDependencies
,
452 dwDependenciesLength
,
453 (LPWSTR
)lpServiceStartName
,
454 NULL
, /* FIXME: lpPassword */
455 0, /* FIXME: dwPasswordLength */
456 (LPWSTR
)lpDisplayName
);
460 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
464 if (dwError
!= ERROR_SUCCESS
)
466 ERR("RChangeServiceConfigW() failed (Error %lu)\n", dwError
);
467 SetLastError(dwError
);
475 /**********************************************************************
481 CloseServiceHandle(SC_HANDLE hSCObject
)
485 TRACE("CloseServiceHandle() called\n");
489 /* Call to services.exe using RPC */
490 dwError
= RCloseServiceHandle((LPSC_RPC_HANDLE
)&hSCObject
);
494 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
500 ERR("RCloseServiceHandle() failed (Error %lu)\n", dwError
);
501 SetLastError(dwError
);
505 TRACE("CloseServiceHandle() done\n");
511 /**********************************************************************
517 ControlService(SC_HANDLE hService
,
519 LPSERVICE_STATUS lpServiceStatus
)
523 TRACE("ControlService(%x, %x, %p)\n",
524 hService
, dwControl
, lpServiceStatus
);
528 /* Call to services.exe using RPC */
529 dwError
= RControlService((SC_RPC_HANDLE
)hService
,
535 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
539 if (dwError
!= ERROR_SUCCESS
)
541 ERR("RControlService() failed (Error %lu)\n", dwError
);
542 SetLastError(dwError
);
546 TRACE("ControlService() done\n");
552 /**********************************************************************
558 ControlServiceEx(IN SC_HANDLE hService
,
560 IN DWORD dwInfoLevel
,
561 IN OUT PVOID pControlParams
)
563 FIXME("ControlServiceEx(0x%p, 0x%x, 0x%x, 0x%p) UNIMPLEMENTED!\n",
564 hService
, dwControl
, dwInfoLevel
, pControlParams
);
565 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
570 /**********************************************************************
576 CreateServiceA(SC_HANDLE hSCManager
,
577 LPCSTR lpServiceName
,
578 LPCSTR lpDisplayName
,
579 DWORD dwDesiredAccess
,
582 DWORD dwErrorControl
,
583 LPCSTR lpBinaryPathName
,
584 LPCSTR lpLoadOrderGroup
,
586 LPCSTR lpDependencies
,
587 LPCSTR lpServiceStartName
,
590 SC_HANDLE RetVal
= NULL
;
591 LPWSTR lpServiceNameW
= NULL
;
592 LPWSTR lpDisplayNameW
= NULL
;
593 LPWSTR lpBinaryPathNameW
= NULL
;
594 LPWSTR lpLoadOrderGroupW
= NULL
;
595 LPWSTR lpDependenciesW
= NULL
;
596 LPWSTR lpServiceStartNameW
= NULL
;
597 LPWSTR lpPasswordW
= NULL
;
598 DWORD dwDependenciesLength
= 0;
605 len
= MultiByteToWideChar(CP_ACP
, 0, lpServiceName
, -1, NULL
, 0);
606 lpServiceNameW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
609 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
612 MultiByteToWideChar(CP_ACP
, 0, lpServiceName
, -1, lpServiceNameW
, len
);
617 len
= MultiByteToWideChar(CP_ACP
, 0, lpDisplayName
, -1, NULL
, 0);
618 lpDisplayNameW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
621 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
624 MultiByteToWideChar(CP_ACP
, 0, lpDisplayName
, -1, lpDisplayNameW
, len
);
627 if (lpBinaryPathName
)
629 len
= MultiByteToWideChar(CP_ACP
, 0, lpBinaryPathName
, -1, NULL
, 0);
630 lpBinaryPathNameW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
631 if (!lpBinaryPathNameW
)
633 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
636 MultiByteToWideChar(CP_ACP
, 0, lpBinaryPathName
, -1, lpBinaryPathNameW
, len
);
639 if (lpLoadOrderGroup
)
641 len
= MultiByteToWideChar(CP_ACP
, 0, lpLoadOrderGroup
, -1, NULL
, 0);
642 lpLoadOrderGroupW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
643 if (!lpLoadOrderGroupW
)
645 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
648 MultiByteToWideChar(CP_ACP
, 0, lpLoadOrderGroup
, -1, lpLoadOrderGroupW
, len
);
653 lpStr
= (LPSTR
)lpDependencies
;
656 dwLength
= strlen(lpStr
) + 1;
657 dwDependenciesLength
+= dwLength
;
658 lpStr
= lpStr
+ dwLength
;
660 dwDependenciesLength
++;
662 lpDependenciesW
= HeapAlloc(GetProcessHeap(), 0, dwDependenciesLength
* sizeof(WCHAR
));
663 if (!lpDependenciesW
)
665 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
668 MultiByteToWideChar(CP_ACP
, 0, lpDependencies
, dwDependenciesLength
, lpDependenciesW
, dwDependenciesLength
);
671 if (lpServiceStartName
)
673 len
= MultiByteToWideChar(CP_ACP
, 0, lpServiceStartName
, -1, NULL
, 0);
674 lpServiceStartNameW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
675 if (!lpServiceStartNameW
)
677 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
680 MultiByteToWideChar(CP_ACP
, 0, lpServiceStartName
, -1, lpServiceStartNameW
, len
);
685 len
= MultiByteToWideChar(CP_ACP
, 0, lpPassword
, -1, NULL
, 0);
686 lpPasswordW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
689 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
692 MultiByteToWideChar(CP_ACP
, 0, lpPassword
, -1, lpPasswordW
, len
);
695 RetVal
= CreateServiceW(hSCManager
,
710 if (lpServiceNameW
!=NULL
)
711 HeapFree(GetProcessHeap(), 0, lpServiceNameW
);
713 if (lpDisplayNameW
!= NULL
)
714 HeapFree(GetProcessHeap(), 0, lpDisplayNameW
);
716 if (lpBinaryPathNameW
!= NULL
)
717 HeapFree(GetProcessHeap(), 0, lpBinaryPathNameW
);
719 if (lpLoadOrderGroupW
!= NULL
)
720 HeapFree(GetProcessHeap(), 0, lpLoadOrderGroupW
);
722 if (lpDependenciesW
!= NULL
)
723 HeapFree(GetProcessHeap(), 0, lpDependenciesW
);
725 if (lpServiceStartNameW
!= NULL
)
726 HeapFree(GetProcessHeap(), 0, lpServiceStartNameW
);
728 if (lpPasswordW
!= NULL
)
729 HeapFree(GetProcessHeap(), 0, lpPasswordW
);
735 /**********************************************************************
741 CreateServiceW(SC_HANDLE hSCManager
,
742 LPCWSTR lpServiceName
,
743 LPCWSTR lpDisplayName
,
744 DWORD dwDesiredAccess
,
747 DWORD dwErrorControl
,
748 LPCWSTR lpBinaryPathName
,
749 LPCWSTR lpLoadOrderGroup
,
751 LPCWSTR lpDependencies
,
752 LPCWSTR lpServiceStartName
,
755 SC_HANDLE hService
= NULL
;
756 DWORD dwDependenciesLength
= 0;
761 TRACE("CreateServiceW() called\n");
763 /* Calculate the Dependencies length*/
764 if (lpDependencies
!= NULL
)
766 lpStr
= (LPWSTR
)lpDependencies
;
769 dwLength
= wcslen(lpStr
) + 1;
770 dwDependenciesLength
+= dwLength
;
771 lpStr
= lpStr
+ dwLength
;
773 dwDependenciesLength
++;
775 dwDependenciesLength
*= sizeof(WCHAR
);
778 /* FIXME: Encrypt the password */
782 /* Call to services.exe using RPC */
783 dwError
= RCreateServiceW((SC_RPC_HANDLE
)hSCManager
,
784 (LPWSTR
)lpServiceName
,
785 (LPWSTR
)lpDisplayName
,
790 (LPWSTR
)lpBinaryPathName
,
791 (LPWSTR
)lpLoadOrderGroup
,
793 (LPBYTE
)lpDependencies
,
794 dwDependenciesLength
,
795 (LPWSTR
)lpServiceStartName
,
796 NULL
, /* FIXME: lpPassword */
797 0, /* FIXME: dwPasswordLength */
798 (SC_RPC_HANDLE
*)&hService
);
802 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
806 if (dwError
!= ERROR_SUCCESS
)
808 ERR("RCreateServiceW() failed (Error %lu)\n", dwError
);
809 SetLastError(dwError
);
817 /**********************************************************************
823 DeleteService(SC_HANDLE hService
)
827 TRACE("DeleteService(%x)\n", hService
);
831 /* Call to services.exe using RPC */
832 dwError
= RDeleteService((SC_RPC_HANDLE
)hService
);
836 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
840 if (dwError
!= ERROR_SUCCESS
)
842 ERR("RDeleteService() failed (Error %lu)\n", dwError
);
843 SetLastError(dwError
);
851 /**********************************************************************
852 * EnumDependentServicesA
857 EnumDependentServicesA(SC_HANDLE hService
,
858 DWORD dwServiceState
,
859 LPENUM_SERVICE_STATUSA lpServices
,
861 LPDWORD pcbBytesNeeded
,
862 LPDWORD lpServicesReturned
)
864 LPENUM_SERVICE_STATUSA lpStatusPtr
;
868 TRACE("EnumServicesStatusA() called\n");
872 dwError
= REnumDependentServicesA((SC_RPC_HANDLE
)hService
,
881 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
885 if (dwError
!= ERROR_SUCCESS
)
887 ERR("REnumDependentServicesA() failed (Error %lu)\n", dwError
);
888 SetLastError(dwError
);
892 lpStatusPtr
= (LPENUM_SERVICE_STATUSA
)lpServices
;
893 for (dwCount
= 0; dwCount
< *lpServicesReturned
; dwCount
++)
895 if (lpStatusPtr
->lpServiceName
)
896 lpStatusPtr
->lpServiceName
=
897 (LPSTR
)((ULONG_PTR
)lpServices
+ (ULONG_PTR
)lpStatusPtr
->lpServiceName
);
899 if (lpStatusPtr
->lpDisplayName
)
900 lpStatusPtr
->lpDisplayName
=
901 (LPSTR
)((ULONG_PTR
)lpServices
+ (ULONG_PTR
)lpStatusPtr
->lpDisplayName
);
906 TRACE("EnumDependentServicesA() done\n");
912 /**********************************************************************
913 * EnumDependentServicesW
918 EnumDependentServicesW(SC_HANDLE hService
,
919 DWORD dwServiceState
,
920 LPENUM_SERVICE_STATUSW lpServices
,
922 LPDWORD pcbBytesNeeded
,
923 LPDWORD lpServicesReturned
)
925 LPENUM_SERVICE_STATUSW lpStatusPtr
;
929 TRACE("EnumServicesStatusW() called\n");
933 dwError
= REnumDependentServicesW((SC_RPC_HANDLE
)hService
,
942 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
946 if (dwError
!= ERROR_SUCCESS
)
948 ERR("REnumDependentServicesW() failed (Error %lu)\n", dwError
);
949 SetLastError(dwError
);
953 lpStatusPtr
= (LPENUM_SERVICE_STATUSW
)lpServices
;
954 for (dwCount
= 0; dwCount
< *lpServicesReturned
; dwCount
++)
956 if (lpStatusPtr
->lpServiceName
)
957 lpStatusPtr
->lpServiceName
=
958 (LPWSTR
)((ULONG_PTR
)lpServices
+ (ULONG_PTR
)lpStatusPtr
->lpServiceName
);
960 if (lpStatusPtr
->lpDisplayName
)
961 lpStatusPtr
->lpDisplayName
=
962 (LPWSTR
)((ULONG_PTR
)lpServices
+ (ULONG_PTR
)lpStatusPtr
->lpDisplayName
);
967 TRACE("EnumDependentServicesW() done\n");
973 /**********************************************************************
981 SC_HANDLE hSCManager
,
983 DWORD dwServiceState
,
984 LPENUM_SERVICE_STATUSW lpServices
,
986 LPDWORD pcbBytesNeeded
,
987 LPDWORD lpServicesReturned
,
988 LPDWORD lpResumeHandle
,
991 FIXME("EnumServiceGroupW is unimplemented\n");
992 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
997 /**********************************************************************
998 * EnumServicesStatusA
1003 EnumServicesStatusA(SC_HANDLE hSCManager
,
1004 DWORD dwServiceType
,
1005 DWORD dwServiceState
,
1006 LPENUM_SERVICE_STATUSA lpServices
,
1008 LPDWORD pcbBytesNeeded
,
1009 LPDWORD lpServicesReturned
,
1010 LPDWORD lpResumeHandle
)
1012 LPENUM_SERVICE_STATUSA lpStatusPtr
;
1016 TRACE("EnumServicesStatusA() called\n");
1020 dwError
= REnumServicesStatusA((SC_RPC_HANDLE
)hSCManager
,
1031 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
1035 if (dwError
!= ERROR_SUCCESS
)
1037 ERR("REnumServicesStatusA() failed (Error %lu)\n", dwError
);
1038 SetLastError(dwError
);
1042 lpStatusPtr
= (LPENUM_SERVICE_STATUSA
)lpServices
;
1043 for (dwCount
= 0; dwCount
< *lpServicesReturned
; dwCount
++)
1045 if (lpStatusPtr
->lpServiceName
)
1046 lpStatusPtr
->lpServiceName
=
1047 (LPSTR
)((ULONG_PTR
)lpServices
+ (ULONG_PTR
)lpStatusPtr
->lpServiceName
);
1049 if (lpStatusPtr
->lpDisplayName
)
1050 lpStatusPtr
->lpDisplayName
=
1051 (LPSTR
)((ULONG_PTR
)lpServices
+ (ULONG_PTR
)lpStatusPtr
->lpDisplayName
);
1056 TRACE("EnumServicesStatusA() done\n");
1062 /**********************************************************************
1063 * EnumServicesStatusW
1068 EnumServicesStatusW(SC_HANDLE hSCManager
,
1069 DWORD dwServiceType
,
1070 DWORD dwServiceState
,
1071 LPENUM_SERVICE_STATUSW lpServices
,
1073 LPDWORD pcbBytesNeeded
,
1074 LPDWORD lpServicesReturned
,
1075 LPDWORD lpResumeHandle
)
1077 LPENUM_SERVICE_STATUSW lpStatusPtr
;
1081 TRACE("EnumServicesStatusW() called\n");
1085 dwError
= REnumServicesStatusW((SC_RPC_HANDLE
)hSCManager
,
1096 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
1100 if (dwError
!= ERROR_SUCCESS
)
1102 ERR("REnumServicesStatusW() failed (Error %lu)\n", dwError
);
1103 SetLastError(dwError
);
1107 lpStatusPtr
= (LPENUM_SERVICE_STATUSW
)lpServices
;
1108 for (dwCount
= 0; dwCount
< *lpServicesReturned
; dwCount
++)
1110 if (lpStatusPtr
->lpServiceName
)
1111 lpStatusPtr
->lpServiceName
=
1112 (LPWSTR
)((ULONG_PTR
)lpServices
+ (ULONG_PTR
)lpStatusPtr
->lpServiceName
);
1114 if (lpStatusPtr
->lpDisplayName
)
1115 lpStatusPtr
->lpDisplayName
=
1116 (LPWSTR
)((ULONG_PTR
)lpServices
+ (ULONG_PTR
)lpStatusPtr
->lpDisplayName
);
1121 TRACE("EnumServicesStatusW() done\n");
1127 /**********************************************************************
1128 * EnumServicesStatusExA
1133 EnumServicesStatusExA(SC_HANDLE hSCManager
,
1134 SC_ENUM_TYPE InfoLevel
,
1135 DWORD dwServiceType
,
1136 DWORD dwServiceState
,
1139 LPDWORD pcbBytesNeeded
,
1140 LPDWORD lpServicesReturned
,
1141 LPDWORD lpResumeHandle
,
1142 LPCSTR pszGroupName
)
1144 LPENUM_SERVICE_STATUS_PROCESSA lpStatusPtr
;
1148 TRACE("EnumServicesStatusExA() called\n");
1152 dwError
= REnumServicesStatusExA((SC_RPC_HANDLE
)hSCManager
,
1161 (LPSTR
)pszGroupName
);
1165 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
1169 if (dwError
== ERROR_MORE_DATA
)
1171 WARN("Required buffer size %ul\n", *pcbBytesNeeded
);
1172 SetLastError(dwError
);
1175 else if (dwError
== ERROR_SUCCESS
)
1177 lpStatusPtr
= (LPENUM_SERVICE_STATUS_PROCESSA
)lpServices
;
1178 for (dwCount
= 0; dwCount
< *lpServicesReturned
; dwCount
++)
1180 if (lpStatusPtr
->lpServiceName
)
1181 lpStatusPtr
->lpServiceName
=
1182 (LPSTR
)((ULONG_PTR
)lpServices
+ (ULONG_PTR
)lpStatusPtr
->lpServiceName
);
1184 if (lpStatusPtr
->lpDisplayName
)
1185 lpStatusPtr
->lpDisplayName
=
1186 (LPSTR
)((ULONG_PTR
)lpServices
+ (ULONG_PTR
)lpStatusPtr
->lpDisplayName
);
1193 ERR("REnumServicesStatusExA() failed (Error %lu)\n", dwError
);
1194 SetLastError(dwError
);
1198 TRACE("EnumServicesStatusExA() done\n");
1204 /**********************************************************************
1205 * EnumServicesStatusExW
1210 EnumServicesStatusExW(SC_HANDLE hSCManager
,
1211 SC_ENUM_TYPE InfoLevel
,
1212 DWORD dwServiceType
,
1213 DWORD dwServiceState
,
1216 LPDWORD pcbBytesNeeded
,
1217 LPDWORD lpServicesReturned
,
1218 LPDWORD lpResumeHandle
,
1219 LPCWSTR pszGroupName
)
1221 LPENUM_SERVICE_STATUS_PROCESSW lpStatusPtr
;
1225 TRACE("EnumServicesStatusExW() called\n");
1229 dwError
= REnumServicesStatusExW((SC_RPC_HANDLE
)hSCManager
,
1238 (LPWSTR
)pszGroupName
);
1242 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
1246 if (dwError
== ERROR_MORE_DATA
)
1248 WARN("Required buffer size %ul\n", *pcbBytesNeeded
);
1249 SetLastError(dwError
);
1252 else if (dwError
== ERROR_SUCCESS
)
1254 lpStatusPtr
= (LPENUM_SERVICE_STATUS_PROCESSW
)lpServices
;
1255 for (dwCount
= 0; dwCount
< *lpServicesReturned
; dwCount
++)
1257 if (lpStatusPtr
->lpServiceName
)
1258 lpStatusPtr
->lpServiceName
=
1259 (LPWSTR
)((ULONG_PTR
)lpServices
+ (ULONG_PTR
)lpStatusPtr
->lpServiceName
);
1261 if (lpStatusPtr
->lpDisplayName
)
1262 lpStatusPtr
->lpDisplayName
=
1263 (LPWSTR
)((ULONG_PTR
)lpServices
+ (ULONG_PTR
)lpStatusPtr
->lpDisplayName
);
1270 ERR("REnumServicesStatusExW() failed (Error %lu)\n", dwError
);
1271 SetLastError(dwError
);
1275 TRACE("EnumServicesStatusExW() done\n");
1281 /**********************************************************************
1282 * GetServiceDisplayNameA
1287 GetServiceDisplayNameA(SC_HANDLE hSCManager
,
1288 LPCSTR lpServiceName
,
1289 LPSTR lpDisplayName
,
1290 LPDWORD lpcchBuffer
)
1294 TRACE("GetServiceDisplayNameA() called\n");
1301 dwError
= RGetServiceDisplayNameA((SC_RPC_HANDLE
)hSCManager
,
1302 (LPSTR
)lpServiceName
,
1308 /* HACK: because of a problem with rpcrt4, rpcserver is hacked to return 6 for ERROR_SERVICE_DOES_NOT_EXIST */
1309 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
1315 if (dwError
!= ERROR_SUCCESS
)
1317 ERR("RGetServiceDisplayNameA() failed (Error %lu)\n", dwError
);
1318 SetLastError(dwError
);
1326 /**********************************************************************
1327 * GetServiceDisplayNameW
1332 GetServiceDisplayNameW(SC_HANDLE hSCManager
,
1333 LPCWSTR lpServiceName
,
1334 LPWSTR lpDisplayName
,
1335 LPDWORD lpcchBuffer
)
1339 TRACE("GetServiceDisplayNameW() called\n");
1346 dwError
= RGetServiceDisplayNameW((SC_RPC_HANDLE
)hSCManager
,
1347 (LPWSTR
)lpServiceName
,
1353 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
1357 if (dwError
!= ERROR_SUCCESS
)
1359 ERR("RGetServiceDisplayNameW() failed (Error %lu)\n", dwError
);
1360 SetLastError(dwError
);
1368 /**********************************************************************
1369 * GetServiceKeyNameA
1374 GetServiceKeyNameA(SC_HANDLE hSCManager
,
1375 LPCSTR lpDisplayName
,
1376 LPSTR lpServiceName
,
1377 LPDWORD lpcchBuffer
)
1381 TRACE("GetServiceKeyNameA() called\n");
1388 dwError
= RGetServiceKeyNameA((SC_RPC_HANDLE
)hSCManager
,
1389 (LPSTR
)lpDisplayName
,
1395 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
1399 if (dwError
!= ERROR_SUCCESS
)
1401 ERR("RGetServiceKeyNameA() failed (Error %lu)\n", dwError
);
1402 SetLastError(dwError
);
1410 /**********************************************************************
1411 * GetServiceKeyNameW
1416 GetServiceKeyNameW(SC_HANDLE hSCManager
,
1417 LPCWSTR lpDisplayName
,
1418 LPWSTR lpServiceName
,
1419 LPDWORD lpcchBuffer
)
1423 TRACE("GetServiceKeyNameW() called\n");
1430 dwError
= RGetServiceKeyNameW((SC_RPC_HANDLE
)hSCManager
,
1431 (LPWSTR
)lpDisplayName
,
1437 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
1441 if (dwError
!= ERROR_SUCCESS
)
1443 ERR("RGetServiceKeyNameW() failed (Error %lu)\n", dwError
);
1444 SetLastError(dwError
);
1452 /**********************************************************************
1453 * LockServiceDatabase
1458 LockServiceDatabase(SC_HANDLE hSCManager
)
1463 TRACE("LockServiceDatabase(%x)\n", hSCManager
);
1467 /* Call to services.exe using RPC */
1468 dwError
= RLockServiceDatabase((SC_RPC_HANDLE
)hSCManager
,
1469 (SC_RPC_LOCK
*)&hLock
);
1473 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
1477 if (dwError
!= ERROR_SUCCESS
)
1479 ERR("RLockServiceDatabase() failed (Error %lu)\n", dwError
);
1480 SetLastError(dwError
);
1484 TRACE("hLock = %p\n", hLock
);
1491 WaitForSCManager(VOID
)
1495 TRACE("WaitForSCManager() called\n");
1497 /* Try to open the existing event */
1498 hEvent
= OpenEventW(SYNCHRONIZE
,
1500 L
"SvcctrlStartEvent_A3752DX");
1503 if (GetLastError() != ERROR_FILE_NOT_FOUND
)
1506 /* Try to create a new event */
1507 hEvent
= CreateEventW(NULL
,
1510 L
"SvcctrlStartEvent_A3752DX");
1513 /* Try to open the existing event again */
1514 hEvent
= OpenEventW(SYNCHRONIZE
,
1516 L
"SvcctrlStartEvent_A3752DX");
1522 /* Wait for 3 minutes */
1523 WaitForSingleObject(hEvent
, 180000);
1524 CloseHandle(hEvent
);
1526 TRACE("ScmWaitForSCManager() done\n");
1530 /**********************************************************************
1536 OpenSCManagerA(LPCSTR lpMachineName
,
1537 LPCSTR lpDatabaseName
,
1538 DWORD dwDesiredAccess
)
1540 SC_HANDLE hScm
= NULL
;
1543 TRACE("OpenSCManagerA(%s, %s, %lx)\n",
1544 lpMachineName
, lpDatabaseName
, dwDesiredAccess
);
1550 /* Call to services.exe using RPC */
1551 dwError
= ROpenSCManagerA((LPSTR
)lpMachineName
,
1552 (LPSTR
)lpDatabaseName
,
1554 (SC_RPC_HANDLE
*)&hScm
);
1558 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
1562 if (dwError
!= ERROR_SUCCESS
)
1564 ERR("ROpenSCManagerA() failed (Error %lu)\n", dwError
);
1565 SetLastError(dwError
);
1569 TRACE("hScm = %p\n", hScm
);
1575 /**********************************************************************
1581 OpenSCManagerW(LPCWSTR lpMachineName
,
1582 LPCWSTR lpDatabaseName
,
1583 DWORD dwDesiredAccess
)
1585 SC_HANDLE hScm
= NULL
;
1588 TRACE("OpenSCManagerW(%S, %S, %lx)\n",
1589 lpMachineName
, lpDatabaseName
, dwDesiredAccess
);
1595 /* Call to services.exe using RPC */
1596 dwError
= ROpenSCManagerW((LPWSTR
)lpMachineName
,
1597 (LPWSTR
)lpDatabaseName
,
1599 (SC_RPC_HANDLE
*)&hScm
);
1603 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
1607 if (dwError
!= ERROR_SUCCESS
)
1609 ERR("ROpenSCManagerW() failed (Error %lu)\n", dwError
);
1610 SetLastError(dwError
);
1614 TRACE("hScm = %p\n", hScm
);
1620 /**********************************************************************
1626 OpenServiceA(SC_HANDLE hSCManager
,
1627 LPCSTR lpServiceName
,
1628 DWORD dwDesiredAccess
)
1630 SC_HANDLE hService
= NULL
;
1633 TRACE("OpenServiceA(%p, %s, %lx)\n",
1634 hSCManager
, lpServiceName
, dwDesiredAccess
);
1638 /* Call to services.exe using RPC */
1639 dwError
= ROpenServiceA((SC_RPC_HANDLE
)hSCManager
,
1640 (LPSTR
)lpServiceName
,
1642 (SC_RPC_HANDLE
*)&hService
);
1646 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
1650 if (dwError
!= ERROR_SUCCESS
)
1652 ERR("ROpenServiceA() failed (Error %lu)\n", dwError
);
1653 SetLastError(dwError
);
1657 TRACE("hService = %p\n", hService
);
1663 /**********************************************************************
1669 OpenServiceW(SC_HANDLE hSCManager
,
1670 LPCWSTR lpServiceName
,
1671 DWORD dwDesiredAccess
)
1673 SC_HANDLE hService
= NULL
;
1676 TRACE("OpenServiceW(%p, %S, %lx)\n",
1677 hSCManager
, lpServiceName
, dwDesiredAccess
);
1681 /* Call to services.exe using RPC */
1682 dwError
= ROpenServiceW((SC_RPC_HANDLE
)hSCManager
,
1683 (LPWSTR
)lpServiceName
,
1685 (SC_RPC_HANDLE
*)&hService
);
1689 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
1693 if (dwError
!= ERROR_SUCCESS
)
1695 if (dwError
== ERROR_SERVICE_DOES_NOT_EXIST
)
1696 WARN("ROpenServiceW() failed (Error %lu)\n", dwError
);
1698 ERR("ROpenServiceW() failed (Error %lu)\n", dwError
);
1699 SetLastError(dwError
);
1703 TRACE("hService = %p\n", hService
);
1709 /**********************************************************************
1710 * QueryServiceConfigA
1715 QueryServiceConfigA(SC_HANDLE hService
,
1716 LPQUERY_SERVICE_CONFIGA lpServiceConfig
,
1718 LPDWORD pcbBytesNeeded
)
1722 TRACE("QueryServiceConfigA(%p, %p, %lu, %p)\n",
1723 hService
, lpServiceConfig
, cbBufSize
, pcbBytesNeeded
);
1727 /* Call to services.exe using RPC */
1728 dwError
= RQueryServiceConfigA((SC_RPC_HANDLE
)hService
,
1729 (LPBYTE
)lpServiceConfig
,
1735 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
1739 if (dwError
!= ERROR_SUCCESS
)
1741 ERR("RQueryServiceConfigA() failed (Error %lu)\n", dwError
);
1742 SetLastError(dwError
);
1746 /* Adjust the pointers */
1747 if (lpServiceConfig
->lpBinaryPathName
)
1748 lpServiceConfig
->lpBinaryPathName
=
1749 (LPSTR
)((ULONG_PTR
)lpServiceConfig
+
1750 (ULONG_PTR
)lpServiceConfig
->lpBinaryPathName
);
1752 if (lpServiceConfig
->lpLoadOrderGroup
)
1753 lpServiceConfig
->lpLoadOrderGroup
=
1754 (LPSTR
)((ULONG_PTR
)lpServiceConfig
+
1755 (ULONG_PTR
)lpServiceConfig
->lpLoadOrderGroup
);
1757 if (lpServiceConfig
->lpDependencies
)
1758 lpServiceConfig
->lpDependencies
=
1759 (LPSTR
)((ULONG_PTR
)lpServiceConfig
+
1760 (ULONG_PTR
)lpServiceConfig
->lpDependencies
);
1762 if (lpServiceConfig
->lpServiceStartName
)
1763 lpServiceConfig
->lpServiceStartName
=
1764 (LPSTR
)((ULONG_PTR
)lpServiceConfig
+
1765 (ULONG_PTR
)lpServiceConfig
->lpServiceStartName
);
1767 if (lpServiceConfig
->lpDisplayName
)
1768 lpServiceConfig
->lpDisplayName
=
1769 (LPSTR
)((ULONG_PTR
)lpServiceConfig
+
1770 (ULONG_PTR
)lpServiceConfig
->lpDisplayName
);
1772 TRACE("QueryServiceConfigA() done\n");
1778 /**********************************************************************
1779 * QueryServiceConfigW
1784 QueryServiceConfigW(SC_HANDLE hService
,
1785 LPQUERY_SERVICE_CONFIGW lpServiceConfig
,
1787 LPDWORD pcbBytesNeeded
)
1791 TRACE("QueryServiceConfigW(%p, %p, %lu, %p)\n",
1792 hService
, lpServiceConfig
, cbBufSize
, pcbBytesNeeded
);
1796 /* Call to services.exe using RPC */
1797 dwError
= RQueryServiceConfigW((SC_RPC_HANDLE
)hService
,
1798 (LPBYTE
)lpServiceConfig
,
1804 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
1808 if (dwError
!= ERROR_SUCCESS
)
1810 if (dwError
== ERROR_INSUFFICIENT_BUFFER
)
1811 WARN("RQueryServiceConfigW() failed (Error %lu)\n", dwError
);
1813 ERR("RQueryServiceConfigW() failed (Error %lu)\n", dwError
);
1814 SetLastError(dwError
);
1818 /* Adjust the pointers */
1819 if (lpServiceConfig
->lpBinaryPathName
)
1820 lpServiceConfig
->lpBinaryPathName
=
1821 (LPWSTR
)((ULONG_PTR
)lpServiceConfig
+
1822 (ULONG_PTR
)lpServiceConfig
->lpBinaryPathName
);
1824 if (lpServiceConfig
->lpLoadOrderGroup
)
1825 lpServiceConfig
->lpLoadOrderGroup
=
1826 (LPWSTR
)((ULONG_PTR
)lpServiceConfig
+
1827 (ULONG_PTR
)lpServiceConfig
->lpLoadOrderGroup
);
1829 if (lpServiceConfig
->lpDependencies
)
1830 lpServiceConfig
->lpDependencies
=
1831 (LPWSTR
)((ULONG_PTR
)lpServiceConfig
+
1832 (ULONG_PTR
)lpServiceConfig
->lpDependencies
);
1834 if (lpServiceConfig
->lpServiceStartName
)
1835 lpServiceConfig
->lpServiceStartName
=
1836 (LPWSTR
)((ULONG_PTR
)lpServiceConfig
+
1837 (ULONG_PTR
)lpServiceConfig
->lpServiceStartName
);
1839 if (lpServiceConfig
->lpDisplayName
)
1840 lpServiceConfig
->lpDisplayName
=
1841 (LPWSTR
)((ULONG_PTR
)lpServiceConfig
+
1842 (ULONG_PTR
)lpServiceConfig
->lpDisplayName
);
1844 TRACE("QueryServiceConfigW() done\n");
1850 /**********************************************************************
1851 * QueryServiceConfig2A
1856 QueryServiceConfig2A(SC_HANDLE hService
,
1860 LPDWORD pcbBytesNeeded
)
1864 TRACE("QueryServiceConfig2A(%p, %lu, %p, %lu, %p)\n",
1865 hService
, dwInfoLevel
, lpBuffer
, cbBufSize
, pcbBytesNeeded
);
1867 if (dwInfoLevel
!= SERVICE_CONFIG_DESCRIPTION
&&
1868 dwInfoLevel
!= SERVICE_CONFIG_FAILURE_ACTIONS
)
1870 SetLastError(ERROR_INVALID_LEVEL
);
1874 if ((lpBuffer
== NULL
&& cbBufSize
!= 0) ||
1875 pcbBytesNeeded
== NULL
)
1877 SetLastError(ERROR_INVALID_ADDRESS
);
1883 /* Call to services.exe using RPC */
1884 dwError
= RQueryServiceConfig2A((SC_RPC_HANDLE
)hService
,
1892 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
1896 if (dwError
!= ERROR_SUCCESS
)
1898 ERR("RQueryServiceConfig2A() failed (Error %lu)\n", dwError
);
1899 SetLastError(dwError
);
1903 switch (dwInfoLevel
)
1905 case SERVICE_CONFIG_DESCRIPTION
:
1907 LPSERVICE_DESCRIPTIONA lpPtr
= (LPSERVICE_DESCRIPTIONA
)lpBuffer
;
1909 if (lpPtr
->lpDescription
!= NULL
)
1910 lpPtr
->lpDescription
=
1911 (LPSTR
)((UINT_PTR
)lpPtr
+ (UINT_PTR
)lpPtr
->lpDescription
);
1915 case SERVICE_CONFIG_FAILURE_ACTIONS
:
1917 LPSERVICE_FAILURE_ACTIONSA lpPtr
= (LPSERVICE_FAILURE_ACTIONSA
)lpBuffer
;
1919 if (lpPtr
->lpRebootMsg
!= NULL
)
1920 lpPtr
->lpRebootMsg
=
1921 (LPSTR
)((UINT_PTR
)lpPtr
+ (UINT_PTR
)lpPtr
->lpRebootMsg
);
1923 if (lpPtr
->lpCommand
!= NULL
)
1925 (LPSTR
)((UINT_PTR
)lpPtr
+ (UINT_PTR
)lpPtr
->lpCommand
);
1927 if (lpPtr
->lpsaActions
!= NULL
)
1928 lpPtr
->lpsaActions
=
1929 (SC_ACTION
*)((UINT_PTR
)lpPtr
+ (UINT_PTR
)lpPtr
->lpsaActions
);
1934 ERR("Unknown info level 0x%lx\n", dwInfoLevel
);
1935 SetLastError(ERROR_INVALID_PARAMETER
);
1939 TRACE("QueryServiceConfig2A() done\n");
1945 /**********************************************************************
1946 * QueryServiceConfig2W
1951 QueryServiceConfig2W(SC_HANDLE hService
,
1955 LPDWORD pcbBytesNeeded
)
1959 TRACE("QueryServiceConfig2W(%p, %lu, %p, %lu, %p)\n",
1960 hService
, dwInfoLevel
, lpBuffer
, cbBufSize
, pcbBytesNeeded
);
1962 if (dwInfoLevel
!= SERVICE_CONFIG_DESCRIPTION
&&
1963 dwInfoLevel
!= SERVICE_CONFIG_FAILURE_ACTIONS
)
1965 SetLastError(ERROR_INVALID_LEVEL
);
1969 if ((lpBuffer
== NULL
&& cbBufSize
!= 0) ||
1970 pcbBytesNeeded
== NULL
)
1972 SetLastError(ERROR_INVALID_ADDRESS
);
1978 /* Call to services.exe using RPC */
1979 dwError
= RQueryServiceConfig2W((SC_RPC_HANDLE
)hService
,
1987 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
1991 if (dwError
!= ERROR_SUCCESS
)
1993 ERR("RQueryServiceConfig2W() failed (Error %lu)\n", dwError
);
1994 SetLastError(dwError
);
1998 switch (dwInfoLevel
)
2000 case SERVICE_CONFIG_DESCRIPTION
:
2002 LPSERVICE_DESCRIPTIONW lpPtr
= (LPSERVICE_DESCRIPTIONW
)lpBuffer
;
2004 if (lpPtr
->lpDescription
!= NULL
)
2005 lpPtr
->lpDescription
=
2006 (LPWSTR
)((UINT_PTR
)lpPtr
+ (UINT_PTR
)lpPtr
->lpDescription
);
2010 case SERVICE_CONFIG_FAILURE_ACTIONS
:
2012 LPSERVICE_FAILURE_ACTIONSW lpPtr
= (LPSERVICE_FAILURE_ACTIONSW
)lpBuffer
;
2014 if (lpPtr
->lpRebootMsg
!= NULL
)
2015 lpPtr
->lpRebootMsg
=
2016 (LPWSTR
)((UINT_PTR
)lpPtr
+ (UINT_PTR
)lpPtr
->lpRebootMsg
);
2018 if (lpPtr
->lpCommand
!= NULL
)
2020 (LPWSTR
)((UINT_PTR
)lpPtr
+ (UINT_PTR
)lpPtr
->lpCommand
);
2022 if (lpPtr
->lpsaActions
!= NULL
)
2023 lpPtr
->lpsaActions
=
2024 (SC_ACTION
*)((UINT_PTR
)lpPtr
+ (UINT_PTR
)lpPtr
->lpsaActions
);
2029 WARN("Unknown info level 0x%lx\n", dwInfoLevel
);
2030 SetLastError(ERROR_INVALID_PARAMETER
);
2034 TRACE("QueryServiceConfig2W() done\n");
2040 /**********************************************************************
2041 * QueryServiceLockStatusA
2046 QueryServiceLockStatusA(SC_HANDLE hSCManager
,
2047 LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus
,
2049 LPDWORD pcbBytesNeeded
)
2053 TRACE("QueryServiceLockStatusA() called\n");
2057 /* Call to services.exe using RPC */
2058 dwError
= RQueryServiceLockStatusA((SC_RPC_HANDLE
)hSCManager
,
2065 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
2069 if (dwError
!= ERROR_SUCCESS
)
2071 ERR("RQueryServiceLockStatusA() failed (Error %lu)\n", dwError
);
2072 SetLastError(dwError
);
2076 if (lpLockStatus
->lpLockOwner
!= NULL
)
2078 lpLockStatus
->lpLockOwner
=
2079 (LPSTR
)((UINT_PTR
)lpLockStatus
+ (UINT_PTR
)lpLockStatus
->lpLockOwner
);
2082 TRACE("QueryServiceLockStatusA() done\n");
2088 /**********************************************************************
2089 * QueryServiceLockStatusW
2094 QueryServiceLockStatusW(SC_HANDLE hSCManager
,
2095 LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus
,
2097 LPDWORD pcbBytesNeeded
)
2101 TRACE("QueryServiceLockStatusW() called\n");
2105 /* Call to services.exe using RPC */
2106 dwError
= RQueryServiceLockStatusW((SC_RPC_HANDLE
)hSCManager
,
2113 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
2117 if (dwError
!= ERROR_SUCCESS
)
2119 ERR("RQueryServiceLockStatusW() failed (Error %lu)\n", dwError
);
2120 SetLastError(dwError
);
2124 if (lpLockStatus
->lpLockOwner
!= NULL
)
2126 lpLockStatus
->lpLockOwner
=
2127 (LPWSTR
)((UINT_PTR
)lpLockStatus
+ (UINT_PTR
)lpLockStatus
->lpLockOwner
);
2130 TRACE("QueryServiceLockStatusW() done\n");
2136 /**********************************************************************
2137 * QueryServiceObjectSecurity
2142 QueryServiceObjectSecurity(SC_HANDLE hService
,
2143 SECURITY_INFORMATION dwSecurityInformation
,
2144 PSECURITY_DESCRIPTOR lpSecurityDescriptor
,
2146 LPDWORD pcbBytesNeeded
)
2150 TRACE("QueryServiceObjectSecurity(%p, %lu, %p)\n",
2151 hService
, dwSecurityInformation
, lpSecurityDescriptor
);
2155 /* Call to services.exe using RPC */
2156 dwError
= RQueryServiceObjectSecurity((SC_RPC_HANDLE
)hService
,
2157 dwSecurityInformation
,
2158 (LPBYTE
)lpSecurityDescriptor
,
2164 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
2168 if (dwError
!= ERROR_SUCCESS
)
2170 ERR("QueryServiceObjectSecurity() failed (Error %lu)\n", dwError
);
2171 SetLastError(dwError
);
2178 /**********************************************************************
2179 * SetServiceObjectSecurity
2184 SetServiceObjectSecurity(SC_HANDLE hService
,
2185 SECURITY_INFORMATION dwSecurityInformation
,
2186 PSECURITY_DESCRIPTOR lpSecurityDescriptor
)
2188 PSECURITY_DESCRIPTOR SelfRelativeSD
= NULL
;
2194 Status
= RtlMakeSelfRelativeSD(lpSecurityDescriptor
,
2197 if (Status
!= STATUS_BUFFER_TOO_SMALL
)
2199 SetLastError(ERROR_INVALID_PARAMETER
);
2203 SelfRelativeSD
= HeapAlloc(GetProcessHeap(), 0, Length
);
2204 if (SelfRelativeSD
== NULL
)
2206 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2210 Status
= RtlMakeSelfRelativeSD(lpSecurityDescriptor
,
2213 if (!NT_SUCCESS(Status
))
2215 HeapFree(GetProcessHeap(), 0, SelfRelativeSD
);
2216 SetLastError(RtlNtStatusToDosError(Status
));
2222 /* Call to services.exe using RPC */
2223 dwError
= RSetServiceObjectSecurity((SC_RPC_HANDLE
)hService
,
2224 dwSecurityInformation
,
2225 (LPBYTE
)SelfRelativeSD
,
2230 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
2234 HeapFree(GetProcessHeap(), 0, SelfRelativeSD
);
2236 if (dwError
!= ERROR_SUCCESS
)
2238 ERR("RServiceObjectSecurity() failed (Error %lu)\n", dwError
);
2239 SetLastError(dwError
);
2247 /**********************************************************************
2248 * QueryServiceStatus
2253 QueryServiceStatus(SC_HANDLE hService
,
2254 LPSERVICE_STATUS lpServiceStatus
)
2258 TRACE("QueryServiceStatus(%p, %p)\n",
2259 hService
, lpServiceStatus
);
2263 /* Call to services.exe using RPC */
2264 dwError
= RQueryServiceStatus((SC_RPC_HANDLE
)hService
,
2269 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
2273 if (dwError
!= ERROR_SUCCESS
)
2275 ERR("RQueryServiceStatus() failed (Error %lu)\n", dwError
);
2276 SetLastError(dwError
);
2284 /**********************************************************************
2285 * QueryServiceStatusEx
2290 QueryServiceStatusEx(SC_HANDLE hService
,
2291 SC_STATUS_TYPE InfoLevel
,
2294 LPDWORD pcbBytesNeeded
)
2298 TRACE("QueryServiceStatusEx() called\n");
2302 /* Call to services.exe using RPC */
2303 dwError
= RQueryServiceStatusEx((SC_RPC_HANDLE
)hService
,
2311 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
2315 if (dwError
!= ERROR_SUCCESS
)
2317 ERR("RQueryServiceStatusEx() failed (Error %lu)\n", dwError
);
2318 SetLastError(dwError
);
2326 /**********************************************************************
2332 StartServiceA(SC_HANDLE hService
,
2333 DWORD dwNumServiceArgs
,
2334 LPCSTR
*lpServiceArgVectors
)
2340 dwError
= RStartServiceA((SC_RPC_HANDLE
)hService
,
2342 (LPSTRING_PTRSA
)lpServiceArgVectors
);
2346 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
2350 if (dwError
!= ERROR_SUCCESS
)
2352 ERR("RStartServiceA() failed (Error %lu)\n", dwError
);
2353 SetLastError(dwError
);
2361 /**********************************************************************
2367 StartServiceW(SC_HANDLE hService
,
2368 DWORD dwNumServiceArgs
,
2369 LPCWSTR
*lpServiceArgVectors
)
2375 dwError
= RStartServiceW((SC_RPC_HANDLE
)hService
,
2377 (LPSTRING_PTRSW
)lpServiceArgVectors
);
2381 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
2385 if (dwError
!= ERROR_SUCCESS
)
2387 ERR("RStartServiceW() failed (Error %lu)\n", dwError
);
2388 SetLastError(dwError
);
2396 /**********************************************************************
2397 * UnlockServiceDatabase
2402 UnlockServiceDatabase(SC_LOCK ScLock
)
2406 TRACE("UnlockServiceDatabase(%x)\n", ScLock
);
2410 /* Call to services.exe using RPC */
2411 dwError
= RUnlockServiceDatabase((LPSC_RPC_LOCK
)&ScLock
);
2415 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
2419 if (dwError
!= ERROR_SUCCESS
)
2421 ERR("RUnlockServiceDatabase() failed (Error %lu)\n", dwError
);
2422 SetLastError(dwError
);
2430 /**********************************************************************
2431 * NotifyBootConfigStatus
2436 NotifyBootConfigStatus(BOOL BootAcceptable
)
2440 TRACE("NotifyBootConfigStatus()\n");
2444 /* Call to services.exe using RPC */
2445 dwError
= RNotifyBootConfigStatus(NULL
,
2450 dwError
= ScmRpcStatusToWinError(RpcExceptionCode());
2454 if (dwError
!= ERROR_SUCCESS
)
2456 ERR("NotifyBootConfigStatus() failed (Error %lu)\n", dwError
);
2457 SetLastError(dwError
);