38 TRACE(
"SVCCTL_HANDLEA_bind(%s)\n",
49 ERR(
"RpcStringBindingCompose returned 0x%x\n",
status);
58 ERR(
"RpcBindingFromStringBinding returned 0x%x\n",
status);
64 ERR(
"RpcStringFree returned 0x%x\n",
status);
77 TRACE(
"SVCCTL_HANDLEA_unbind(%s %p)\n",
83 ERR(
"RpcBindingFree returned 0x%x\n",
status);
95 TRACE(
"SVCCTL_HANDLEW_bind(%s)\n",
106 ERR(
"RpcStringBindingCompose returned 0x%x\n",
status);
115 ERR(
"RpcBindingFromStringBinding returned 0x%x\n",
status);
121 ERR(
"RpcStringFree returned 0x%x\n",
status);
134 TRACE(
"SVCCTL_HANDLEW_unbind(%s %p)\n",
140 ERR(
"RpcBindingFree returned 0x%x\n",
status);
148 TRACE(
"ScmRpcStatusToWinError(%lx)\n",
178 struct ustring inData, keyData, outData;
188 ERR(
"SystemFunction028 failed (Status 0x%08lx)\n",
Status);
194 inData.
Buffer = (
unsigned char *)pClearTextPassword;
196 keyData.
Length =
sizeof(SessionKey);
198 keyData.
Buffer = SessionKey;
210 ERR(
"SystemFunction004 failed (Status 0x%08lx)\n",
Status);
228 ERR(
"SystemFunction004 failed (Status 0x%08lx)\n",
Status);
233 *pEncryptedPassword = outData.
Buffer;
234 *pEncryptedPasswordSize = outData.
Length;
253 TRACE(
"ChangeServiceConfig2A(%p %lu %p)\n",
289 TRACE(
"RChangeServiceConfig2A() failed (Error %lu)\n", dwError);
311 TRACE(
"ChangeServiceConfig2W(%p %lu %p)\n",
347 TRACE(
"RChangeServiceConfig2W() failed (Error %lu)\n", dwError);
365 DWORD dwErrorControl,
370 LPCSTR lpServiceStartName,
375 DWORD dwDependenciesLength = 0;
378 DWORD dwPasswordSize = 0;
382 TRACE(
"ChangeServiceConfigA(%p %lu %lu %lu %s %s %p %s %s %s %s)\n",
383 hService, dwServiceType, dwStartType, dwErrorControl,
debugstr_a(lpBinaryPathName),
388 if (lpDependencies !=
NULL)
390 lpStr = lpDependencies;
393 cchLength =
strlen(lpStr) + 1;
394 dwDependenciesLength += (
DWORD)cchLength;
395 lpStr = lpStr + cchLength;
397 dwDependenciesLength++;
400 if (lpPassword !=
NULL)
406 if (lpPasswordW ==
NULL)
417 (
int)(
strlen(lpPassword) + 1));
421 &lpEncryptedPassword,
433 (
LPSTR)lpBinaryPathName,
434 (
LPSTR)lpLoadOrderGroup,
437 dwDependenciesLength,
438 (
LPSTR)lpServiceStartName,
450 if (lpPasswordW !=
NULL)
456 if (lpEncryptedPassword !=
NULL)
465 TRACE(
"RChangeServiceConfigA() failed (Error %lu)\n", dwError);
483 DWORD dwErrorControl,
493 DWORD dwDependenciesLength = 0;
496 DWORD dwPasswordSize = 0;
499 TRACE(
"ChangeServiceConfigW(%p %lu %lu %lu %s %s %p %s %s %s %s)\n",
500 hService, dwServiceType, dwStartType, dwErrorControl,
debugstr_w(lpBinaryPathName),
505 if (lpDependencies !=
NULL)
507 lpStr = lpDependencies;
510 cchLength =
wcslen(lpStr) + 1;
511 dwDependenciesLength += (
DWORD)cchLength;
512 lpStr = lpStr + cchLength;
514 dwDependenciesLength++;
515 dwDependenciesLength *=
sizeof(
WCHAR);
518 if (lpPassword !=
NULL)
521 &lpEncryptedPassword,
525 ERR(
"ScmEncryptPassword failed (Error %lu)\n", dwError);
540 dwDependenciesLength,
541 (
LPWSTR)lpServiceStartName,
553 if (lpEncryptedPassword !=
NULL)
562 TRACE(
"RChangeServiceConfigW() failed (Error %lu)\n", dwError);
581 TRACE(
"CloseServiceHandle(%p)\n",
602 TRACE(
"RCloseServiceHandle() failed (Error %lu)\n", dwError);
607 TRACE(
"CloseServiceHandle() done\n");
625 TRACE(
"ControlService(%p %lu %p)\n",
626 hService, dwControl, lpServiceStatus);
642 TRACE(
"RControlService() failed (Error %lu)\n", dwError);
647 TRACE(
"ControlService() done\n");
664 FIXME(
"ControlServiceEx(%p %lu %lu %p)\n",
680 DWORD dwDesiredAccess,
683 DWORD dwErrorControl,
688 LPCSTR lpServiceStartName,
691 SC_HANDLE hService =
NULL;
692 DWORD dwDependenciesLength = 0;
696 DWORD dwPasswordSize = 0;
700 TRACE(
"CreateServiceA(%p %s %s %lx %lu %lu %lu %s %s %p %s %s %s)\n",
702 dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
713 if (lpDependencies !=
NULL)
715 lpStr = lpDependencies;
718 cchLength =
strlen(lpStr) + 1;
719 dwDependenciesLength += (
DWORD)cchLength;
720 lpStr = lpStr + cchLength;
722 dwDependenciesLength++;
725 if (lpPassword !=
NULL)
731 if (lpPasswordW ==
NULL)
742 (
int)(
strlen(lpPassword) + 1));
746 &lpEncryptedPassword,
755 (
LPSTR)lpServiceName,
761 (
LPSTR)lpBinaryPathName,
762 (
LPSTR)lpLoadOrderGroup,
765 dwDependenciesLength,
766 (
LPSTR)lpServiceStartName,
778 if (lpPasswordW !=
NULL)
784 if (lpEncryptedPassword !=
NULL)
794 TRACE(
"RCreateServiceA() failed (Error %lu)\n", dwError);
811 DWORD dwDesiredAccess,
814 DWORD dwErrorControl,
822 SC_HANDLE hService =
NULL;
823 DWORD dwDependenciesLength = 0;
827 DWORD dwPasswordSize = 0;
830 TRACE(
"CreateServiceW(%p %s %s %lx %lu %lu %lu %s %s %p %s %s %s)\n",
832 dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
843 if (lpDependencies !=
NULL)
845 lpStr = lpDependencies;
848 cchLength =
wcslen(lpStr) + 1;
849 dwDependenciesLength += (
DWORD)cchLength;
850 lpStr = lpStr + cchLength;
852 dwDependenciesLength++;
853 dwDependenciesLength *=
sizeof(
WCHAR);
856 if (lpPassword !=
NULL)
860 &lpEncryptedPassword,
879 dwDependenciesLength,
892 if (lpEncryptedPassword !=
NULL)
902 TRACE(
"RCreateServiceW() failed (Error %lu)\n", dwError);
920 TRACE(
"DeleteService(%p)\n",
935 TRACE(
"RDeleteService() failed (Error %lu)\n", dwError);
951 DWORD dwServiceState,
963 TRACE(
"EnumDependentServicesA(%p %lu %p %lu %p %p)\n",
964 hService, dwServiceState, lpServices,
cbBufSize,
974 lpStatusPtr = lpServices;
995 for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1011 TRACE(
"REnumDependentServicesA() failed (Error %lu)\n", dwError);
1016 TRACE(
"EnumDependentServicesA() done\n");
1029 DWORD dwServiceState,
1041 TRACE(
"EnumDependentServicesW(%p %lu %p %lu %p %p)\n",
1042 hService, dwServiceState, lpServices,
cbBufSize,
1052 lpStatusPtr = lpServices;
1063 lpServicesReturned);
1073 for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1089 TRACE(
"REnumDependentServicesW() failed (Error %lu)\n", dwError);
1094 TRACE(
"EnumDependentServicesW() done\n");
1107 DWORD dwServiceType,
1108 DWORD dwServiceState,
1122 TRACE(
"EnumServiceGroupW(%p %lu %lu %p %lu %p %p %p %s)\n",
1123 hSCManager, dwServiceType, dwServiceState, lpServices,
1146 lpStatusPtr = lpServices;
1152 if (lpGroup ==
NULL)
1184 for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1200 TRACE(
"REnumServiceGroupW() failed (Error %lu)\n", dwError);
1205 TRACE(
"EnumServiceGroupW() done\n");
1218 DWORD dwServiceType,
1219 DWORD dwServiceState,
1232 TRACE(
"EnumServicesStatusA(%p %lu %lu %p %lu %p %p %p)\n",
1233 hSCManager, dwServiceType, dwServiceState, lpServices,
1255 lpStatusPtr = lpServices;
1278 for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1294 TRACE(
"REnumServicesStatusA() failed (Error %lu)\n", dwError);
1299 TRACE(
"EnumServicesStatusA() done\n");
1312 DWORD dwServiceType,
1313 DWORD dwServiceState,
1326 TRACE(
"EnumServicesStatusW(%p %lu %lu %p %lu %p %p %p)\n",
1327 hSCManager, dwServiceType, dwServiceState, lpServices,
1349 lpStatusPtr = lpServices;
1372 for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1388 TRACE(
"REnumServicesStatusW() failed (Error %lu)\n", dwError);
1393 TRACE(
"EnumServicesStatusW() done\n");
1407 DWORD dwServiceType,
1408 DWORD dwServiceState,
1422 TRACE(
"EnumServicesStatusExA(%p %lu %lu %p %lu %p %p %p %s)\n",
1423 hSCManager, dwServiceType, dwServiceState, lpServices,
1467 (
LPSTR)pszGroupName);
1479 for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1496 TRACE(
"REnumServicesStatusExA() failed (Error %lu)\n", dwError);
1501 TRACE(
"EnumServicesStatusExA() done\n");
1515 DWORD dwServiceType,
1516 DWORD dwServiceState,
1530 TRACE(
"EnumServicesStatusExW(%p %lu %lu %p %lu %p %p %p %s)\n",
1531 hSCManager, dwServiceType, dwServiceState, lpServices,
1587 for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1604 TRACE(
"REnumServicesStatusExW() failed (Error %lu)\n", dwError);
1609 TRACE(
"EnumServicesStatusExW() done\n");
1628 CHAR szEmptyName[] =
"";
1630 TRACE(
"GetServiceDisplayNameA(%p %s %p %p)\n",
1642 *lpcchBuffer =
sizeof(
CHAR);
1664 TRACE(
"RGetServiceDisplayNameA() failed (Error %lu)\n", dwError);
1686 WCHAR szEmptyName[] =
L"";
1688 TRACE(
"GetServiceDisplayNameW(%p %s %p %p)\n",
1705 *lpcchBuffer =
sizeof(
WCHAR);
1727 TRACE(
"RGetServiceDisplayNameW() failed (Error %lu)\n", dwError);
1744 LPSTR lpServiceName,
1749 CHAR szEmptyName[] =
"";
1751 TRACE(
"GetServiceKeyNameA(%p %s %p %p)\n",
1760 if (!lpServiceName || *lpcchBuffer <
sizeof(
CHAR))
1763 *lpcchBuffer =
sizeof(
CHAR);
1786 TRACE(
"RGetServiceKeyNameA() failed (Error %lu)\n", dwError);
1808 WCHAR szEmptyName[] =
L"";
1810 TRACE(
"GetServiceKeyNameW(%p %s %p %p)\n",
1824 if (!lpServiceName || *lpcchBuffer <
sizeof(
WCHAR))
1827 *lpcchBuffer =
sizeof(
WCHAR);
1849 TRACE(
"RGetServiceKeyNameW() failed (Error %lu)\n", dwError);
1870 TRACE(
"I_ScGetCurrentGroupStateW(%p %s %p)\n",
1887 TRACE(
"RI_ScGetCurrentGroupStateW() failed (Error %lu)\n", dwError);
1906 TRACE(
"LockServiceDatabase(%p)\n",
1922 TRACE(
"RLockServiceDatabase() failed (Error %lu)\n", dwError);
1927 TRACE(
"hLock = %p\n", hLock);
1938 TRACE(
"WaitForSCManager()\n");
1957 TRACE(
"ScmWaitForSCManager() done\n");
1969 DWORD dwDesiredAccess)
1971 SC_HANDLE hScm =
NULL;
1974 TRACE(
"OpenSCManagerA(%s %s %lx)\n",
1982 (
LPSTR)lpDatabaseName,
1995 TRACE(
"ROpenSCManagerA() failed (Error %lu)\n", dwError);
1999 TRACE(
"hScm = %p\n", hScm);
2013 DWORD dwDesiredAccess)
2015 SC_HANDLE hScm =
NULL;
2018 TRACE(
"OpenSCManagerW(%s %s %lx)\n",
2039 TRACE(
"ROpenSCManagerW() failed (Error %lu)\n", dwError);
2043 TRACE(
"hScm = %p\n", hScm);
2057 DWORD dwDesiredAccess)
2059 SC_HANDLE hService =
NULL;
2062 TRACE(
"OpenServiceA(%p %s %lx)\n",
2074 (
LPSTR)lpServiceName,
2087 TRACE(
"ROpenServiceA() failed (Error %lu)\n", dwError);
2091 TRACE(
"hService = %p\n", hService);
2105 DWORD dwDesiredAccess)
2107 SC_HANDLE hService =
NULL;
2110 TRACE(
"OpenServiceW(%p %s %lx)\n",
2135 TRACE(
"ROpenServiceW() failed (Error %lu)\n", dwError);
2139 TRACE(
"hService = %p\n", hService);
2161 TRACE(
"QueryServiceConfigA(%p %p %lu %p)\n",
2164 if (lpServiceConfig ==
NULL ||
2167 lpConfigPtr = &ServiceConfig;
2172 lpConfigPtr = lpServiceConfig;
2191 TRACE(
"RQueryServiceConfigA() failed (Error %lu)\n", dwError);
2222 TRACE(
"QueryServiceConfigA() done\n");
2244 TRACE(
"QueryServiceConfigW(%p %p %lu %p)\n",
2247 if (lpServiceConfig ==
NULL ||
2250 lpConfigPtr = &ServiceConfig;
2255 lpConfigPtr = lpServiceConfig;
2274 TRACE(
"RQueryServiceConfigW() failed (Error %lu)\n", dwError);
2305 TRACE(
"QueryServiceConfigW() done\n");
2330 TRACE(
"QueryServiceConfig2A(%p %lu %p %lu %p)\n",
2341 lpTempBuffer = (
LPBYTE)&ServiceDescription;
2343 bUseTempBuffer =
TRUE;
2350 lpTempBuffer = (
LPBYTE)&ServiceFailureActions;
2352 bUseTempBuffer =
TRUE;
2378 TRACE(
"RQueryServiceConfig2A() failed (Error %lu)\n", dwError);
2383 if (bUseTempBuffer !=
FALSE)
2385 TRACE(
"RQueryServiceConfig2A() returns ERROR_INSUFFICIENT_BUFFER\n");
2422 TRACE(
"QueryServiceConfig2A() done\n");
2447 TRACE(
"QueryServiceConfig2W(%p %lu %p %lu %p)\n",
2458 lpTempBuffer = (
LPBYTE)&ServiceDescription;
2460 bUseTempBuffer =
TRUE;
2467 lpTempBuffer = (
LPBYTE)&ServiceFailureActions;
2469 bUseTempBuffer =
TRUE;
2495 TRACE(
"RQueryServiceConfig2W() failed (Error %lu)\n", dwError);
2500 if (bUseTempBuffer !=
FALSE)
2502 TRACE(
"RQueryServiceConfig2W() returns ERROR_INSUFFICIENT_BUFFER\n");
2539 TRACE(
"QueryServiceConfig2W() done\n");
2561 TRACE(
"QueryServiceLockStatusA(%p %p %lu %p)\n",
2566 lpStatusPtr = &LockStatus;
2571 lpStatusPtr = lpLockStatus;
2590 TRACE(
"RQueryServiceLockStatusA() failed (Error %lu)\n", dwError);
2601 TRACE(
"QueryServiceLockStatusA() done\n");
2623 TRACE(
"QueryServiceLockStatusW(%p %p %lu %p)\n",
2628 lpStatusPtr = &LockStatus;
2633 lpStatusPtr = lpLockStatus;
2652 TRACE(
"RQueryServiceLockStatusW() failed (Error %lu)\n", dwError);
2663 TRACE(
"QueryServiceLockStatusW() done\n");
2683 TRACE(
"QueryServiceObjectSecurity(%p %lu %p)\n",
2684 hService, dwSecurityInformation, lpSecurityDescriptor);
2689 dwSecurityInformation,
2690 (
LPBYTE)lpSecurityDescriptor,
2702 TRACE(
"QueryServiceObjectSecurity() failed (Error %lu)\n", dwError);
2726 TRACE(
"SetServiceObjectSecurity(%p %lu %p)\n",
2727 hService, dwSecurityInformation, lpSecurityDescriptor);
2740 if (SelfRelativeSD ==
NULL)
2759 dwSecurityInformation,
2773 TRACE(
"RServiceObjectSecurity() failed (Error %lu)\n", dwError);
2793 TRACE(
"QueryServiceStatus(%p %p)\n",
2794 hService, lpServiceStatus);
2815 TRACE(
"RQueryServiceStatus() failed (Error %lu)\n", dwError);
2838 TRACE(
"QueryServiceStatusEx(%p %lu %p %lu %p)\n",
2870 TRACE(
"RQueryServiceStatusEx() failed (Error %lu)\n", dwError);
2886 DWORD dwNumServiceArgs,
2887 LPCSTR *lpServiceArgVectors)
2891 TRACE(
"StartServiceA(%p %lu %p)\n",
2892 hService, dwNumServiceArgs, lpServiceArgVectors);
2908 ERR(
"RStartServiceA() failed (Error %lu)\n", dwError);
2924 DWORD dwNumServiceArgs,
2929 TRACE(
"StartServiceW(%p %lu %p)\n",
2930 hService, dwNumServiceArgs, lpServiceArgVectors);
2946 ERR(
"RStartServiceW() failed (Error %lu)\n", dwError);
2965 TRACE(
"UnlockServiceDatabase(%x)\n",
2983 TRACE(
"RUnlockServiceDatabase() failed (Error %lu)\n", dwError);
3002 TRACE(
"NotifyBootConfigStatus(%u)\n",
3018 TRACE(
"NotifyBootConfigStatus() failed (Error %lu)\n", dwError);
3084 if (OutParams ==
NULL ||
3094 if (lpszName ==
NULL)
3108 if (OutParams !=
NULL)
3136 InOutParams ==
NULL)
#define ERROR_INVALID_PARAMETER
DWORD WINAPI REnumServicesStatusExA(SC_RPC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeIndex, LPCSTR pszGroupName)
RPC_STATUS WINAPI RpcBindingFromStringBindingW(RPC_WSTR StringBinding, RPC_BINDING_HANDLE *Binding)
DWORD WINAPI RChangeServiceConfigA(SC_RPC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPSTR lpBinaryPathName, LPSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPBYTE lpDependencies, DWORD dwDependSize, LPSTR lpServiceStartName, LPBYTE lpPassword, DWORD dwPwSize, LPSTR lpDisplayName)
#define RPC_X_SS_IN_NULL_CONTEXT
DWORD I_ScQueryServiceTagInfo(PVOID Unused, TAG_INFO_LEVEL dwInfoLevel, PTAG_INFO_NAME_FROM_TAG InOutParams)
static VOID WaitForSCManager(VOID)
DWORD WINAPI RQueryServiceConfigW(SC_RPC_HANDLE hService, LPBYTE lpBuf, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
_Must_inspect_result_ typedef _In_ PVOID Unused
DWORD WINAPI REnumServicesStatusA(SC_RPC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD dwBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeHandle)
#define SC_MANAGER_ENUMERATE_SERVICE
RPC_STATUS WINAPI RpcBindingFree(RPC_BINDING_HANDLE *Binding)
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
struct _QUERY_SERVICE_CONFIGW QUERY_SERVICE_CONFIGW
_In_ ULONG _In_ ULONG _In_ ULONG Length
struct _SERVICE_DESCRIPTIONA * LPSERVICE_DESCRIPTIONA
DWORD WINAPI RGetServiceDisplayNameW(SC_RPC_HANDLE hSCManager, LPCWSTR lpServiceName, LPWSTR lpDisplayName, DWORD *lpcchBuffer)
#define RPC_X_NULL_REF_POINTER
TAG_INFO_NAME_FROM_TAG_OUT_PARAMS OutParams
BOOL WINAPI QueryServiceConfigA(SC_HANDLE hService, LPQUERY_SERVICE_CONFIGA lpServiceConfig, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
TAG_INFO_NAME_FROM_TAG_IN_PARAMS InParams
DWORD WINAPI RCreateServiceW(SC_RPC_HANDLE hSCManager, LPCWSTR lpServiceName, LPCWSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName, LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPBYTE lpDependencies, DWORD dwDependSize, LPCWSTR lpServiceStartName, LPBYTE lpPassword, DWORD dwPwSize, LPSC_RPC_HANDLE lpServiceHandle)
RPC_STATUS WINAPI RpcStringFreeW(RPC_WSTR *String)
DWORD WINAPI REnumServicesStatusExW(SC_RPC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeIndex, LPCWSTR pszGroupName)
ACPI_SIZE strlen(const char *String)
DWORD WINAPI REnumDependentServicesW(SC_RPC_HANDLE hService, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned)
SC_HANDLE WINAPI CreateServiceW(SC_HANDLE hSCManager, LPCWSTR lpServiceName, LPCWSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName, LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCWSTR lpDependencies, LPCWSTR lpServiceStartName, LPCWSTR lpPassword)
DWORD WINAPI RDeleteService(SC_RPC_HANDLE hService)
struct _SERVICE_STATUS_PROCESS SERVICE_STATUS_PROCESS
BOOL WINAPI QueryServiceConfigW(SC_HANDLE hService, LPQUERY_SERVICE_CONFIGW lpServiceConfig, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
RPC_STATUS WINAPI RpcStringBindingComposeA(RPC_CSTR ObjUuid, RPC_CSTR Protseq, RPC_CSTR NetworkAddr, RPC_CSTR Endpoint, RPC_CSTR Options, RPC_CSTR *StringBinding)
BOOL WINAPI NotifyBootConfigStatus(BOOL BootAcceptable)
struct _QUERY_SERVICE_CONFIGA QUERY_SERVICE_CONFIGA
enum _SC_STATUS_TYPE SC_STATUS_TYPE
struct _SERVICE_FAILURE_ACTIONSA SERVICE_FAILURE_ACTIONSA
struct _SERVICE_DESCRIPTIONW SERVICE_DESCRIPTIONW
#define ERROR_INVALID_HANDLE
#define RPC_X_BYTE_COUNT_TOO_SMALL
#define ERROR_NOT_ENOUGH_MEMORY
DWORD WINAPI GetLastError(VOID)
BOOL WINAPI EnumServicesStatusA(SC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPENUM_SERVICE_STATUSA lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle)
BOOL WINAPI UnlockServiceDatabase(SC_LOCK ScLock)
#define SERVICE_CONFIG_DESCRIPTION
BOOL WINAPI EnumServiceGroupW(SC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPENUM_SERVICE_STATUSW lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle, LPCWSTR lpGroup)
BOOL WINAPI QueryServiceStatusEx(SC_HANDLE hService, SC_STATUS_TYPE InfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
unsigned short * RPC_WSTR
BOOL WINAPI DeleteService(SC_HANDLE hService)
DWORD WINAPI RQueryServiceObjectSecurity(SC_RPC_HANDLE hService, SECURITY_INFORMATION dwSecurityInformation, LPBYTE lpSecurityDescriptor, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded)
RPC_STATUS WINAPI RpcStringFreeA(RPC_CSTR *String)
SC_HANDLE WINAPI CreateServiceA(SC_HANDLE hSCManager, LPCSTR lpServiceName, LPCSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpBinaryPathName, LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCSTR lpDependencies, LPCSTR lpServiceStartName, LPCSTR lpPassword)
DWORD WINAPI ROpenSCManagerW(LPWSTR lpMachineName, LPWSTR lpDatabaseName, DWORD dwDesiredAccess, LPSC_RPC_HANDLE lpScHandle)
BOOL WINAPI GetServiceDisplayNameA(SC_HANDLE hSCManager, LPCSTR lpServiceName, LPSTR lpDisplayName, LPDWORD lpcchBuffer)
DWORD WINAPI I_ScGetCurrentGroupStateW(SC_HANDLE hSCManager, LPWSTR pszGroupName, LPDWORD pdwGroupState)
RPC_STATUS WINAPI RpcStringBindingComposeW(RPC_WSTR ObjUuid, RPC_WSTR Protseq, RPC_WSTR NetworkAddr, RPC_WSTR Endpoint, RPC_WSTR Options, RPC_WSTR *StringBinding)
DWORD WINAPI RStartServiceA(SC_RPC_HANDLE hService, DWORD argc, LPSTRING_PTRSA argv)
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
BOOL WINAPI ChangeServiceConfig2A(SC_HANDLE hService, DWORD dwInfoLevel, LPVOID lpInfo)
#define STATUS_BUFFER_TOO_SMALL
HANDLE WINAPI DECLSPEC_HOTPATCH OpenEventW(IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN LPCWSTR lpName)
BOOL WINAPI GetServiceKeyNameW(SC_HANDLE hSCManager, LPCWSTR lpDisplayName, LPWSTR lpServiceName, LPDWORD lpcchBuffer)
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
void __RPC_USER SVCCTL_HANDLEW_unbind(SVCCTL_HANDLEW szMachineName, handle_t hBinding)
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
BOOL WINAPI EnumServicesStatusW(SC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPENUM_SERVICE_STATUSW lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle)
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
handle_t __RPC_USER SVCCTL_HANDLEA_bind(SVCCTL_HANDLEA szMachineName)
SC_HANDLE WINAPI OpenSCManagerA(LPCSTR lpMachineName, LPCSTR lpDatabaseName, DWORD dwDesiredAccess)
DWORD WINAPI RGetServiceKeyNameW(SC_RPC_HANDLE hSCManager, LPCWSTR lpDisplayName, LPWSTR lpServiceName, DWORD *lpcchBuffer)
DWORD SECURITY_INFORMATION
DWORD WINAPI RQueryServiceConfig2W(SC_RPC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
BOOL WINAPI ChangeServiceConfigW(SC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName, LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCWSTR lpDependencies, LPCWSTR lpServiceStartName, LPCWSTR lpPassword, LPCWSTR lpDisplayName)
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
WINE_DEFAULT_DEBUG_CHANNEL(advapi)
SC_HANDLE WINAPI OpenServiceW(SC_HANDLE hSCManager, LPCWSTR lpServiceName, DWORD dwDesiredAccess)
DWORD WINAPI REnumServiceGroupW(SC_RPC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeIndex, LPCWSTR pszGroupName)
#define EXCEPTION_EXECUTE_HANDLER
BOOL WINAPI CloseServiceHandle(SC_HANDLE hSCObject)
#define RPC_S_INVALID_BINDING
void __RPC_USER SVCCTL_HANDLEA_unbind(SVCCTL_HANDLEA szMachineName, handle_t hBinding)
BOOL WINAPI QueryServiceConfig2A(SC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
DWORD WINAPI RStartServiceW(SC_RPC_HANDLE hService, DWORD argc, LPSTRING_PTRSW argv)
struct _ENUM_SERVICE_STATUS_PROCESSA ENUM_SERVICE_STATUS_PROCESSA
DWORD WINAPI RNotifyBootConfigStatus(SVCCTL_HANDLEW lpMachineName, DWORD BootAcceptable)
#define ERROR_FILE_NOT_FOUND
DWORD WINAPI RQueryServiceConfig2A(SC_RPC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
DWORD WINAPI RQueryServiceStatus(SC_RPC_HANDLE hService, LPSERVICE_STATUS lpServiceStatus)
BOOL WINAPI StartServiceA(SC_HANDLE hService, DWORD dwNumServiceArgs, LPCSTR *lpServiceArgVectors)
static LPSTR lpNameBuffer
NTSTATUS WINAPI SystemFunction028(IN PVOID ContextHandle, OUT LPBYTE SessionKey)
BOOL WINAPI EnumDependentServicesW(SC_HANDLE hService, DWORD dwServiceState, LPENUM_SERVICE_STATUSW lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned)
#define RpcExceptionCode()
BOOL WINAPI StartServiceW(SC_HANDLE hService, DWORD dwNumServiceArgs, LPCWSTR *lpServiceArgVectors)
struct _QUERY_SERVICE_LOCK_STATUSW QUERY_SERVICE_LOCK_STATUSW
BOOL WINAPI QueryServiceLockStatusW(SC_HANDLE hSCManager, LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
enum _SC_ENUM_TYPE SC_ENUM_TYPE
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
struct _SERVICE_DESCRIPTIONW * LPSERVICE_DESCRIPTIONW
RPC_STATUS WINAPI RpcBindingFromStringBindingA(RPC_CSTR StringBinding, RPC_BINDING_HANDLE *Binding)
struct _ENUM_SERVICE_STATUS_PROCESSA * LPENUM_SERVICE_STATUS_PROCESSA
#define NT_SUCCESS(StatCode)
BOOL WINAPI EnumServicesStatusExA(SC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle, LPCSTR pszGroupName)
BOOL WINAPI ChangeServiceConfigA(SC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpBinaryPathName, LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCSTR lpDependencies, LPCSTR lpServiceStartName, LPCSTR lpPassword, LPCSTR lpDisplayName)
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
static SERVICE_STATUS ServiceStatus
DWORD WINAPI RGetServiceDisplayNameA(SC_RPC_HANDLE hSCManager, LPCSTR lpServiceName, LPSTR lpDisplayName, LPBOUNDED_DWORD_4K lpcchBuffer)
struct _SERVICE_FAILURE_ACTIONSW SERVICE_FAILURE_ACTIONSW
#define SERVICE_CONFIG_FAILURE_ACTIONS
DWORD WINAPI ROpenServiceW(SC_RPC_HANDLE hSCManager, LPWSTR lpServiceName, DWORD dwDesiredAccess, LPSC_RPC_HANDLE lpServiceHandle)
_In_ DWORD _In_ DWORD cbBufSize
BOOL WINAPI QueryServiceStatus(SC_HANDLE hService, LPSERVICE_STATUS lpServiceStatus)
static DWORD ScmEncryptPassword(_In_ PCWSTR pClearTextPassword, _Out_ PBYTE *pEncryptedPassword, _Out_ PDWORD pEncryptedPasswordSize)
NTSTATUS WINAPI SystemFunction004(const struct ustring *in, const struct ustring *key, struct ustring *out)
DWORD WINAPI RCreateServiceA(SC_RPC_HANDLE hSCManager, LPSTR lpServiceName, LPSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPSTR lpBinaryPathName, LPSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPBYTE lpDependencies, DWORD dwDependSize, LPSTR lpServiceStartName, LPBYTE lpPassword, DWORD dwPwSize, LPSC_RPC_HANDLE lpServiceHandle)
struct _ENUM_SERVICE_STATUSW ENUM_SERVICE_STATUSW
#define ERROR_INVALID_ADDRESS
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
struct _ENUM_SERVICE_STATUS_PROCESSW * LPENUM_SERVICE_STATUS_PROCESSW
#define RPC_X_ENUM_VALUE_OUT_OF_RANGE
DWORD WINAPI RI_ScQueryServiceTagInfo(SC_RPC_HANDLE hSCManager, TAG_INFO_LEVEL dwInfoLevel, PTAG_INFO_NAME_FROM_TAG_IN_PARAMS *lpInParams, PTAG_INFO_NAME_FROM_TAG_OUT_PARAMS *lpOutParams)
SC_HANDLE WINAPI OpenSCManagerW(LPCWSTR lpMachineName, LPCWSTR lpDatabaseName, DWORD dwDesiredAccess)
BOOL WINAPI QueryServiceConfig2W(SC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
BOOL WINAPI EnumDependentServicesA(SC_HANDLE hService, DWORD dwServiceState, LPENUM_SERVICE_STATUSA lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned)
static const WCHAR Cleanup[]
DWORD WINAPI RCloseServiceHandle(LPSC_RPC_HANDLE hSCObject)
struct _QUERY_SERVICE_LOCK_STATUSA QUERY_SERVICE_LOCK_STATUSA
DWORD WINAPI RSetServiceObjectSecurity(SC_RPC_HANDLE hService, DWORD dwSecurityInformation, LPBYTE lpSecurityDescriptor, DWORD dwSecurityDescriptorSize)
struct _SERVICE_DESCRIPTIONA SERVICE_DESCRIPTIONA
#define ERROR_INVALID_DATA
DWORD WINAPI RChangeServiceConfig2W(SC_RPC_HANDLE hService, SC_RPC_CONFIG_INFOW Info)
DWORD WINAPI REnumServicesStatusW(SC_RPC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD dwBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeHandle)
BOOL WINAPI GetServiceDisplayNameW(SC_HANDLE hSCManager, LPCWSTR lpServiceName, LPWSTR lpDisplayName, LPDWORD lpcchBuffer)
DWORD WINAPI ROpenSCManagerA(LPSTR lpMachineName, LPSTR lpDatabaseName, DWORD dwDesiredAccess, LPSC_RPC_HANDLE lpScHandle)
DWORD WINAPI RQueryServiceLockStatusA(SC_RPC_HANDLE hSCManager, LPBYTE lpBuf, DWORD cbBufSize, LPBOUNDED_DWORD_4K pcbBytesNeeded)
#define ERROR_INVALID_SERVICE_LOCK
#define STATUS_ACCESS_VIOLATION
BOOL WINAPI ControlService(SC_HANDLE hService, DWORD dwControl, LPSERVICE_STATUS lpServiceStatus)
struct _SERVICE_FAILURE_ACTIONSW * LPSERVICE_FAILURE_ACTIONSW
SC_LOCK WINAPI LockServiceDatabase(SC_HANDLE hSCManager)
BOOL WINAPI SetServiceObjectSecurity(SC_HANDLE hService, SECURITY_INFORMATION dwSecurityInformation, PSECURITY_DESCRIPTOR lpSecurityDescriptor)
DWORD WINAPI RLockServiceDatabase(SC_RPC_HANDLE hSCManager, LPSC_RPC_LOCK lpLock)
BOOL WINAPI ControlServiceEx(IN SC_HANDLE hService, IN DWORD dwControl, IN DWORD dwInfoLevel, IN OUT PVOID pControlParams)
LPWSTR lpServiceStartName
#define MultiByteToWideChar
SC_HANDLE WINAPI OpenServiceA(SC_HANDLE hSCManager, LPCSTR lpServiceName, DWORD dwDesiredAccess)
struct _ENUM_SERVICE_STATUS_PROCESSW ENUM_SERVICE_STATUS_PROCESSW
BOOL WINAPI GetServiceKeyNameA(SC_HANDLE hSCManager, LPCSTR lpDisplayName, LPSTR lpServiceName, LPDWORD lpcchBuffer)
DWORD WINAPI I_QueryTagInformation(PVOID Unused, TAG_INFO_LEVEL dwInfoLevel, PTAG_INFO_NAME_FROM_TAG InOutParams)
handle_t __RPC_USER SVCCTL_HANDLEW_bind(SVCCTL_HANDLEW szMachineName)
BOOL WINAPI QueryServiceLockStatusA(SC_HANDLE hSCManager, LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
#define ERROR_CALL_NOT_IMPLEMENTED
DWORD WINAPI REnumDependentServicesA(SC_RPC_HANDLE hService, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned)
DWORD WINAPI ROpenServiceA(SC_RPC_HANDLE hSCManager, LPSTR lpServiceName, DWORD dwDesiredAccess, LPSC_RPC_HANDLE lpServiceHandle)
DWORD WINAPI RControlService(SC_RPC_HANDLE hService, DWORD dwControl, LPSERVICE_STATUS lpServiceStatus)
DWORD WINAPI RQueryServiceLockStatusW(SC_RPC_HANDLE hSCManager, LPBYTE lpBuf, DWORD cbBufSize, LPBOUNDED_DWORD_4K pcbBytesNeeded)
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
DWORD WINAPI RQueryServiceStatusEx(SC_RPC_HANDLE hService, SC_STATUS_TYPE InfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
DWORD WINAPI RUnlockServiceDatabase(LPSC_RPC_LOCK Lock)
#define ERROR_INVALID_LEVEL
DWORD WINAPI RQueryServiceConfigA(SC_RPC_HANDLE hService, LPBYTE lpBuf, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
BOOL WINAPI ChangeServiceConfig2W(SC_HANDLE hService, DWORD dwInfoLevel, LPVOID lpInfo)
struct _ENUM_SERVICE_STATUSA ENUM_SERVICE_STATUSA
DWORD WINAPI RGetServiceKeyNameA(SC_RPC_HANDLE hSCManager, LPCSTR lpDisplayName, LPSTR lpServiceName, LPBOUNDED_DWORD_4K lpcchBuffer)
NTSYSAPI NTSTATUS NTAPI RtlMakeSelfRelativeSD(_In_ PSECURITY_DESCRIPTOR AbsoluteSD, _Out_ PSECURITY_DESCRIPTOR SelfRelativeSD, _Inout_ PULONG BufferLength)
DWORD WINAPI RI_ScGetCurrentGroupStateW(SC_RPC_HANDLE hSCManager, LPWSTR lpLoadOrderGroup, LPDWORD lpState)
static SERVICE_STATUS status
BOOL WINAPI EnumServicesStatusExW(SC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle, LPCWSTR pszGroupName)
_In_ LPCSTR _Out_writes_to_opt_ cchDisplayName LPSTR lpDisplayName
DWORD WINAPI RChangeServiceConfig2A(SC_RPC_HANDLE hService, SC_RPC_CONFIG_INFOA Info)
struct _SC_ACTION * LPSC_ACTION
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define HeapFree(x, y, z)
struct _SERVICE_FAILURE_ACTIONSA * LPSERVICE_FAILURE_ACTIONSA
enum _TAG_INFO_LEVEL TAG_INFO_LEVEL
DWORD WINAPI RChangeServiceConfigW(SC_RPC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPWSTR lpBinaryPathName, LPWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPBYTE lpDependencies, DWORD dwDependSize, LPWSTR lpServiceStartName, LPBYTE lpPassword, DWORD dwPwSize, LPWSTR lpDisplayName)
BOOL WINAPI QueryServiceObjectSecurity(SC_HANDLE hService, SECURITY_INFORMATION dwSecurityInformation, PSECURITY_DESCRIPTOR lpSecurityDescriptor, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
#define ERROR_INSUFFICIENT_BUFFER