scm.c File Reference

#include <advapi32.h>

Include dependency graph for scm.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (advapi)
NTSTATUS WINAPI	SystemFunction004 (const struct ustring *in, const struct ustring *key, struct ustring *out)
NTSTATUS WINAPI	SystemFunction028 (IN PVOID ContextHandle, OUT LPBYTE SessionKey)
handle_t __RPC_USER	SVCCTL_HANDLEA_bind (SVCCTL_HANDLEA szMachineName)
void __RPC_USER	SVCCTL_HANDLEA_unbind (SVCCTL_HANDLEA szMachineName, handle_t hBinding)
handle_t __RPC_USER	SVCCTL_HANDLEW_bind (SVCCTL_HANDLEW szMachineName)
void __RPC_USER	SVCCTL_HANDLEW_unbind (SVCCTL_HANDLEW szMachineName, handle_t hBinding)
DWORD	ScmRpcStatusToWinError (RPC_STATUS Status)
static DWORD	ScmEncryptPassword (_In_ PVOID ContextHandle, _In_ PCWSTR pClearTextPassword, _Out_ PBYTE *pEncryptedPassword, _Out_ PDWORD pEncryptedPasswordSize)
BOOL WINAPI	ChangeServiceConfig2A (SC_HANDLE hService, DWORD dwInfoLevel, LPVOID lpInfo)
BOOL WINAPI	ChangeServiceConfig2W (SC_HANDLE hService, DWORD dwInfoLevel, LPVOID lpInfo)
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)
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)
BOOL WINAPI	CloseServiceHandle (SC_HANDLE hSCObject)
BOOL WINAPI	ControlService (SC_HANDLE hService, DWORD dwControl, LPSERVICE_STATUS lpServiceStatus)
BOOL WINAPI	ControlServiceEx (IN SC_HANDLE hService, IN DWORD dwControl, IN DWORD dwInfoLevel, IN OUT PVOID pControlParams)
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)
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)
BOOL WINAPI	DeleteService (SC_HANDLE hService)
BOOL WINAPI	EnumDependentServicesA (SC_HANDLE hService, DWORD dwServiceState, LPENUM_SERVICE_STATUSA lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned)
BOOL WINAPI	EnumDependentServicesW (SC_HANDLE hService, DWORD dwServiceState, LPENUM_SERVICE_STATUSW lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned)
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	EnumServicesStatusA (SC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPENUM_SERVICE_STATUSA lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle)
BOOL WINAPI	EnumServicesStatusW (SC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPENUM_SERVICE_STATUSW lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle)
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	EnumServicesStatusExW (SC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle, LPCWSTR pszGroupName)
BOOL WINAPI	GetServiceDisplayNameA (SC_HANDLE hSCManager, LPCSTR lpServiceName, LPSTR lpDisplayName, LPDWORD lpcchBuffer)
BOOL WINAPI	GetServiceDisplayNameW (SC_HANDLE hSCManager, LPCWSTR lpServiceName, LPWSTR lpDisplayName, LPDWORD lpcchBuffer)
BOOL WINAPI	GetServiceKeyNameA (SC_HANDLE hSCManager, LPCSTR lpDisplayName, LPSTR lpServiceName, LPDWORD lpcchBuffer)
BOOL WINAPI	GetServiceKeyNameW (SC_HANDLE hSCManager, LPCWSTR lpDisplayName, LPWSTR lpServiceName, LPDWORD lpcchBuffer)
DWORD WINAPI	I_ScGetCurrentGroupStateW (SC_HANDLE hSCManager, LPWSTR pszGroupName, LPDWORD pdwGroupState)
DWORD WINAPI	I_ScValidatePnpService (_In_ LPCWSTR pszMachineName, _In_ LPCWSTR pszServiceName, _Out_ SERVICE_STATUS_HANDLE *phServiceStatus)
SC_LOCK WINAPI	LockServiceDatabase (SC_HANDLE hSCManager)
static VOID	WaitForSCManager (VOID)
SC_HANDLE WINAPI	OpenSCManagerA (LPCSTR lpMachineName, LPCSTR lpDatabaseName, DWORD dwDesiredAccess)
SC_HANDLE WINAPI	OpenSCManagerW (LPCWSTR lpMachineName, LPCWSTR lpDatabaseName, DWORD dwDesiredAccess)
SC_HANDLE WINAPI	OpenServiceA (SC_HANDLE hSCManager, LPCSTR lpServiceName, DWORD dwDesiredAccess)
SC_HANDLE WINAPI	OpenServiceW (SC_HANDLE hSCManager, LPCWSTR lpServiceName, DWORD dwDesiredAccess)
BOOL WINAPI	QueryServiceConfigA (SC_HANDLE hService, LPQUERY_SERVICE_CONFIGA lpServiceConfig, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
BOOL WINAPI	QueryServiceConfigW (SC_HANDLE hService, LPQUERY_SERVICE_CONFIGW lpServiceConfig, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
BOOL WINAPI	QueryServiceConfig2A (SC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
BOOL WINAPI	QueryServiceConfig2W (SC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
BOOL WINAPI	QueryServiceLockStatusA (SC_HANDLE hSCManager, LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
BOOL WINAPI	QueryServiceLockStatusW (SC_HANDLE hSCManager, LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
BOOL WINAPI	QueryServiceObjectSecurity (SC_HANDLE hService, SECURITY_INFORMATION dwSecurityInformation, PSECURITY_DESCRIPTOR lpSecurityDescriptor, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
BOOL WINAPI	SetServiceObjectSecurity (SC_HANDLE hService, SECURITY_INFORMATION dwSecurityInformation, PSECURITY_DESCRIPTOR lpSecurityDescriptor)
BOOL WINAPI	QueryServiceStatus (SC_HANDLE hService, LPSERVICE_STATUS lpServiceStatus)
BOOL WINAPI	QueryServiceStatusEx (SC_HANDLE hService, SC_STATUS_TYPE InfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
BOOL WINAPI	StartServiceA (SC_HANDLE hService, DWORD dwNumServiceArgs, LPCSTR *lpServiceArgVectors)
BOOL WINAPI	StartServiceW (SC_HANDLE hService, DWORD dwNumServiceArgs, LPCWSTR *lpServiceArgVectors)
BOOL WINAPI	UnlockServiceDatabase (SC_LOCK ScLock)
BOOL WINAPI	NotifyBootConfigStatus (BOOL BootAcceptable)
DWORD	I_ScQueryServiceTagInfo (PVOID Unused, TAG_INFO_LEVEL dwInfoLevel, PTAG_INFO_NAME_FROM_TAG InOutParams)
DWORD WINAPI	I_QueryTagInformation (PVOID Unused, TAG_INFO_LEVEL dwInfoLevel, PTAG_INFO_NAME_FROM_TAG InOutParams)

Function Documentation

ChangeServiceConfig2A()

BOOL WINAPI ChangeServiceConfig2A	(	SC_HANDLE	hService,
		DWORD	dwInfoLevel,
		LPVOID	lpInfo
	)

Definition at line 247 of file scm.c.

{
    SC_RPC_CONFIG_INFOA Info;
    DWORD dwError;
 
    TRACE("ChangeServiceConfig2A(%p %lu %p)\n",
          hService, dwInfoLevel, lpInfo);
 
    if (lpInfo == NULL) return TRUE;
 
    /* Fill relevant field of the Info structure */
    Info.dwInfoLevel = dwInfoLevel;
    switch (dwInfoLevel)
    {
        case SERVICE_CONFIG_DESCRIPTION:
            Info.psd = lpInfo;
            break;
 
        case SERVICE_CONFIG_FAILURE_ACTIONS:
            Info.psfa = lpInfo;
            break;
 
        default:
            WARN("Unknown info level 0x%lx\n", dwInfoLevel);
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
    }
 
    RpcTryExcept
    {
        dwError = RChangeServiceConfig2A((SC_RPC_HANDLE)hService,
                                         Info);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RChangeServiceConfig2A() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    return TRUE;
}

ChangeServiceConfig2W()

BOOL WINAPI ChangeServiceConfig2W	(	SC_HANDLE	hService,
		DWORD	dwInfoLevel,
		LPVOID	lpInfo
	)

Definition at line 305 of file scm.c.

{
    SC_RPC_CONFIG_INFOW Info;
    DWORD dwError;
 
    TRACE("ChangeServiceConfig2W(%p %lu %p)\n",
          hService, dwInfoLevel, lpInfo);
 
    if (lpInfo == NULL) return TRUE;
 
    /* Fill relevant field of the Info structure */
    Info.dwInfoLevel = dwInfoLevel;
    switch (dwInfoLevel)
    {
        case SERVICE_CONFIG_DESCRIPTION:
            Info.psd = lpInfo;
            break;
 
        case SERVICE_CONFIG_FAILURE_ACTIONS:
            Info.psfa = lpInfo;
            break;
 
        default:
            WARN("Unknown info level 0x%lx\n", dwInfoLevel);
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
    }
 
    RpcTryExcept
    {
        dwError = RChangeServiceConfig2W((SC_RPC_HANDLE)hService,
                                         Info);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RChangeServiceConfig2W() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by ITERATE_InstallService(), RegisterService(), and SetServiceDescription().

ChangeServiceConfigA()

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
	)

Definition at line 363 of file scm.c.

{
    DWORD dwError;
    DWORD dwDependenciesLength = 0;
    SIZE_T cchLength;
    LPCSTR lpStr;
    DWORD dwPasswordSize = 0;
    LPWSTR lpPasswordW = NULL;
    LPBYTE lpEncryptedPassword = NULL;
 
    TRACE("ChangeServiceConfigA(%p %lu %lu %lu %s %s %p %s %s %s %s)\n",
          hService, dwServiceType, dwStartType, dwErrorControl, debugstr_a(lpBinaryPathName),
          debugstr_a(lpLoadOrderGroup), lpdwTagId, debugstr_a(lpDependencies),
          debugstr_a(lpServiceStartName), debugstr_a(lpPassword), debugstr_a(lpDisplayName));
 
    /* Calculate the Dependencies length*/
    if (lpDependencies != NULL)
    {
        lpStr = lpDependencies;
        while (*lpStr)
        {
            cchLength = strlen(lpStr) + 1;
            dwDependenciesLength += (DWORD)cchLength;
            lpStr = lpStr + cchLength;
        }
        dwDependenciesLength++;
    }
 
    if (lpPassword != NULL)
    {
        /* Convert the password to unicode */
        lpPasswordW = HeapAlloc(GetProcessHeap(),
                                HEAP_ZERO_MEMORY,
                                (strlen(lpPassword) + 1) * sizeof(WCHAR));
        if (lpPasswordW == NULL)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return FALSE;
        }
 
        MultiByteToWideChar(CP_ACP,
                            0,
                            lpPassword,
                            -1,
                            lpPasswordW,
                            (int)(strlen(lpPassword) + 1));
 
        /* Encrypt the unicode password */
        dwError = ScmEncryptPassword(hService,
                                     lpPasswordW,
                                     &lpEncryptedPassword,
                                     &dwPasswordSize);
        if (dwError != ERROR_SUCCESS)
            goto done;
    }
 
    RpcTryExcept
    {
        dwError = RChangeServiceConfigA((SC_RPC_HANDLE)hService,
                                        dwServiceType,
                                        dwStartType,
                                        dwErrorControl,
                                        (LPSTR)lpBinaryPathName,
                                        (LPSTR)lpLoadOrderGroup,
                                        lpdwTagId,
                                        (LPBYTE)lpDependencies,
                                        dwDependenciesLength,
                                        (LPSTR)lpServiceStartName,
                                        lpEncryptedPassword,
                                        dwPasswordSize,
                                        (LPSTR)lpDisplayName);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
done:
    if (lpPasswordW != NULL)
    {
        /* Wipe and release the password buffers */
        SecureZeroMemory(lpPasswordW, (wcslen(lpPasswordW) + 1) * sizeof(WCHAR));
        HeapFree(GetProcessHeap(), 0, lpPasswordW);
 
        if (lpEncryptedPassword != NULL)
        {
            SecureZeroMemory(lpEncryptedPassword, dwPasswordSize);
            HeapFree(GetProcessHeap(), 0, lpEncryptedPassword);
        }
    }
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RChangeServiceConfigA() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by test_sequence(), and test_start_stop().

ChangeServiceConfigW()

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
	)

Definition at line 482 of file scm.c.

{
    DWORD dwError;
    DWORD dwDependenciesLength = 0;
    SIZE_T cchLength;
    LPCWSTR lpStr;
    DWORD dwPasswordSize = 0;
    LPBYTE lpEncryptedPassword = NULL;
 
    TRACE("ChangeServiceConfigW(%p %lu %lu %lu %s %s %p %s %s %s %s)\n",
          hService, dwServiceType, dwStartType, dwErrorControl, debugstr_w(lpBinaryPathName),
          debugstr_w(lpLoadOrderGroup), lpdwTagId, debugstr_w(lpDependencies),
          debugstr_w(lpServiceStartName), debugstr_w(lpPassword), debugstr_w(lpDisplayName));
 
    /* Calculate the Dependencies length*/
    if (lpDependencies != NULL)
    {
        lpStr = lpDependencies;
        while (*lpStr)
        {
            cchLength = wcslen(lpStr) + 1;
            dwDependenciesLength += (DWORD)cchLength;
            lpStr = lpStr + cchLength;
        }
        dwDependenciesLength++;
        dwDependenciesLength *= sizeof(WCHAR);
    }
 
    if (lpPassword != NULL)
    {
        dwError = ScmEncryptPassword(hService,
                                     lpPassword,
                                     &lpEncryptedPassword,
                                     &dwPasswordSize);
        if (dwError != ERROR_SUCCESS)
        {
            ERR("ScmEncryptPassword failed (Error %lu)\n", dwError);
            goto done;
        }
    }
 
    RpcTryExcept
    {
        dwError = RChangeServiceConfigW((SC_RPC_HANDLE)hService,
                                        dwServiceType,
                                        dwStartType,
                                        dwErrorControl,
                                        (LPWSTR)lpBinaryPathName,
                                        (LPWSTR)lpLoadOrderGroup,
                                        lpdwTagId,
                                        (LPBYTE)lpDependencies,
                                        dwDependenciesLength,
                                        (LPWSTR)lpServiceStartName,
                                        lpEncryptedPassword,
                                        dwPasswordSize,
                                        (LPWSTR)lpDisplayName);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
done:
    if (lpEncryptedPassword != NULL)
    {
        /* Wipe and release the password buffer */
        SecureZeroMemory(lpEncryptedPassword, dwPasswordSize);
        HeapFree(GetProcessHeap(), 0, lpEncryptedPassword);
    }
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RChangeServiceConfigW() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by EnableUserModePnpManager(), InstallOneService(), MMSYS_InstallDevice(), my_test_server(), RpcSsConfigureAsNetworkService(), ServicesPageWndProc(), SetServiceAccount(), SetServiceConfig(), SHELL32_ControlService(), and Test_LockUnlockServiceDatabaseWithServiceStart().

CloseServiceHandle()

BOOL WINAPI CloseServiceHandle

(

SC_HANDLE

hSCObject

)

Definition at line 580 of file scm.c.

{
    DWORD dwError;
 
    TRACE("CloseServiceHandle(%p)\n",
          hSCObject);
 
    if (!hSCObject)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    RpcTryExcept
    {
        dwError = RCloseServiceHandle((LPSC_RPC_HANDLE)&hSCObject);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError)
    {
        TRACE("RCloseServiceHandle() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    TRACE("CloseServiceHandle() done\n");
 
    return TRUE;
}

Referenced by _RunRemoteTest(), AccpCloseObjectHandle(), AccpOpenNamedObject(), AddService(), CShellDispatch::CanStartStopService(), cmdContinue(), CmdInstallService(), cmdPause(), CmdRemoveService(), cmdStop(), Control(), control_service(), Create(), Delete(), delete_test_service(), DestroyService(), DoControlService(), DoCreate(), DoDeleteService(), DoRegServer(), DoStartService(), DoStopService(), DoUnregServer(), EnableUserModePnpManager(), EnumDepend(), EnumerateRunningServices(), EnumServices(), fill_service(), GetDisplayName(), GetKeyName(), GetServiceConfig(), GetServiceDescription(), GetServiceFailure(), GetServiceList(), GetServices(), GetThemeServiceProcessHandle(), I_ScQueryServiceTagInfo(), I_ScValidatePnpService(), InstallOneService(), installService(), CShellDispatch::IsServiceRunning(), ITERATE_DeleteService(), ITERATE_InstallService(), ITERATE_StartService(), ITERATE_StopService(), KmtCloseService(), KmtDeleteService(), KmtServiceCleanup(), main(), MMSYS_InstallDevice(), my_test_server(), OpenServiceHelper(), PlayLogonSoundThread(), query_service_config(), QueryConfig(), QueryDescription(), QueryDriverInfo(), QueryFailure(), QueryService(), RegisterDriver(), RegisterService(), RpcSsConfigureAsNetworkService(), RunTest(), SchedEventLogoff(), SchedStartShell(), sds_absent(), sds_present(), SdSet(), SdShow(), ServiceInfo(), ServicesPageWndProc(), ServiceStart(), SetConfig(), SetDescription(), SetFailure(), SetServiceAccount(), SetServiceConfig(), SetServiceDescription(), SetupStartService(), SHELL32_ControlService(), sis_absent(), sis_present(), sss_started(), sss_stopped(), Start(), start_local_service(), start_rpcss(), start_service(), START_TEST(), StartAudioService(), StartDriver(), StartOneService(), StartSystemAudioServices(), stop_service(), stop_service_dependents(), StopDriver(), test_close(), test_create_delete_svc(), Test_CreateService(), test_delete_services(), test_driver_install(), test_enum_svc(), test_get_displayname(), test_get_servicekeyname(), test_install_services(), test_install_svc_from(), Test_LockUnlockServiceDatabase(), Test_LockUnlockServiceDatabaseWithServiceStart(), test_no_stop(), test_open_scm(), test_open_svc(), test_query_svc(), test_queryconfig2(), Test_QueryLockStatusA(), Test_QueryLockStatusW(), Test_QueryServiceConfig2A(), Test_QueryServiceConfig2W(), test_refcount(), test_regconnectregistry(), test_runner(), test_sequence(), test_service(), test_servicenotify(), test_SetupDiInstallClassExA(), test_SetupInstallServicesFromInfSectionExA(), test_SetupInstallServicesFromInfSectionExW(), test_start_stop(), test_start_stop_services(), ThemeWaitForServiceReady(), TV1_AddDependantsToTree(), TV2_GetDependants(), TV2_HasDependantServices(), uninstallService(), UnregisterDriver(), UpdateServiceStatus(), VfdConfigDriver(), VfdGetDriverConfig(), VfdGetDriverState(), VfdInstallDriver(), VfdRemoveDriver(), VfdStartDriver(), VfdStopDriver(), and WahDisableNonIFSHandleSupport().

ControlService()

BOOL WINAPI ControlService	(	SC_HANDLE	hService,
		DWORD	dwControl,
		LPSERVICE_STATUS	lpServiceStatus
	)

Definition at line 622 of file scm.c.

{
    DWORD dwError;
 
    TRACE("ControlService(%p %lu %p)\n",
          hService, dwControl, lpServiceStatus);
 
    RpcTryExcept
    {
        dwError = RControlService((SC_RPC_HANDLE)hService,
                                  dwControl,
                                  lpServiceStatus);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RControlService() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    TRACE("ControlService() done\n");
 
    return TRUE;
}

Referenced by cmdContinue(), cmdPause(), CmdRemoveService(), cmdStop(), Control(), control_service(), DoControlService(), DoStopService(), KmtStopService(), my_test_server(), RequestAddition(), RunTest(), SchedEventLogoff(), SchedStartShell(), SetupInstallServicesFromInfSectionExW(), SHELL32_ControlService(), stop_service(), stop_service_dependents(), StopDriver(), stopService(), Test_LockUnlockServiceDatabaseWithServiceStart(), test_no_stop(), test_service(), test_servicenotify(), test_start_stop_services(), try_start_stop(), and VfdStopDriver().

ControlServiceEx()

BOOL WINAPI ControlServiceEx	(	IN SC_HANDLE	hService,
		IN DWORD	dwControl,
		IN DWORD	dwInfoLevel,
		IN OUT PVOID	pControlParams
	)

Definition at line 662 of file scm.c.

{
    FIXME("ControlServiceEx(%p %lu %lu %p)\n",
          hService, dwControl, dwInfoLevel, pControlParams);
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return FALSE;
}

CreateServiceA()

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
	)

Definition at line 680 of file scm.c.

{
    SC_HANDLE hService = NULL;
    DWORD dwDependenciesLength = 0;
    DWORD dwError;
    SIZE_T cchLength;
    LPCSTR lpStr;
    DWORD dwPasswordSize = 0;
    LPWSTR lpPasswordW = NULL;
    LPBYTE lpEncryptedPassword = NULL;
 
    TRACE("CreateServiceA(%p %s %s %lx %lu %lu %lu %s %s %p %s %s %s)\n",
          hSCManager, debugstr_a(lpServiceName), debugstr_a(lpDisplayName),
          dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
          debugstr_a(lpBinaryPathName), debugstr_a(lpLoadOrderGroup), lpdwTagId,
          debugstr_a(lpDependencies), debugstr_a(lpServiceStartName), debugstr_a(lpPassword));
 
    if (!hSCManager)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return NULL;
    }
 
    /* Calculate the Dependencies length */
    if (lpDependencies != NULL)
    {
        lpStr = lpDependencies;
        while (*lpStr)
        {
            cchLength = strlen(lpStr) + 1;
            dwDependenciesLength += (DWORD)cchLength;
            lpStr = lpStr + cchLength;
        }
        dwDependenciesLength++;
    }
 
    if (lpPassword != NULL)
    {
        /* Convert the password to unicode */
        lpPasswordW = HeapAlloc(GetProcessHeap(),
                                HEAP_ZERO_MEMORY,
                                (strlen(lpPassword) + 1) * sizeof(WCHAR));
        if (lpPasswordW == NULL)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return FALSE;
        }
 
        MultiByteToWideChar(CP_ACP,
                            0,
                            lpPassword,
                            -1,
                            lpPasswordW,
                            (int)(strlen(lpPassword) + 1));
 
        /* Encrypt the password */
        dwError = ScmEncryptPassword(hSCManager,
                                     lpPasswordW,
                                     &lpEncryptedPassword,
                                     &dwPasswordSize);
        if (dwError != ERROR_SUCCESS)
            goto done;
    }
 
    RpcTryExcept
    {
        dwError = RCreateServiceA((SC_RPC_HANDLE)hSCManager,
                                  (LPSTR)lpServiceName,
                                  (LPSTR)lpDisplayName,
                                  dwDesiredAccess,
                                  dwServiceType,
                                  dwStartType,
                                  dwErrorControl,
                                  (LPSTR)lpBinaryPathName,
                                  (LPSTR)lpLoadOrderGroup,
                                  lpdwTagId,
                                  (LPBYTE)lpDependencies,
                                  dwDependenciesLength,
                                  (LPSTR)lpServiceStartName,
                                  lpEncryptedPassword,
                                  dwPasswordSize,
                                  (SC_RPC_HANDLE *)&hService);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
done:
    if (lpPasswordW != NULL)
    {
        /* Wipe and release the password buffers */
        SecureZeroMemory(lpPasswordW, (wcslen(lpPasswordW) + 1) * sizeof(WCHAR));
        HeapFree(GetProcessHeap(), 0, lpPasswordW);
 
        if (lpEncryptedPassword != NULL)
        {
            SecureZeroMemory(lpEncryptedPassword, dwPasswordSize);
            HeapFree(GetProcessHeap(), 0, lpEncryptedPassword);
        }
    }
 
    SetLastError(dwError);
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RCreateServiceA() failed (Error %lu)\n", dwError);
        return NULL;
    }
 
    return hService;
}

Referenced by InstallService(), register_service(), register_service_exA(), test_create_delete_svc(), test_delete_services(), test_get_displayname(), test_queryconfig2(), test_refcount(), test_sequence(), and test_start_stop().

CreateServiceW()

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
	)

Definition at line 812 of file scm.c.

{
    SC_HANDLE hService = NULL;
    DWORD dwDependenciesLength = 0;
    DWORD dwError;
    SIZE_T cchLength;
    LPCWSTR lpStr;
    DWORD dwPasswordSize = 0;
    LPBYTE lpEncryptedPassword = NULL;
 
    TRACE("CreateServiceW(%p %s %s %lx %lu %lu %lu %s %s %p %s %s %s)\n",
          hSCManager, debugstr_w(lpServiceName), debugstr_w(lpDisplayName),
          dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
          debugstr_w(lpBinaryPathName), debugstr_w(lpLoadOrderGroup), lpdwTagId,
          debugstr_w(lpDependencies), debugstr_w(lpServiceStartName), debugstr_w(lpPassword));
 
    if (!hSCManager)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return NULL;
    }
 
    /* Calculate the Dependencies length */
    if (lpDependencies != NULL)
    {
        lpStr = lpDependencies;
        while (*lpStr)
        {
            cchLength = wcslen(lpStr) + 1;
            dwDependenciesLength += (DWORD)cchLength;
            lpStr = lpStr + cchLength;
        }
        dwDependenciesLength++;
        dwDependenciesLength *= sizeof(WCHAR);
    }
 
    if (lpPassword != NULL)
    {
        /* Encrypt the password */
        dwError = ScmEncryptPassword(hSCManager,
                                     lpPassword,
                                     &lpEncryptedPassword,
                                     &dwPasswordSize);
        if (dwError != ERROR_SUCCESS)
            goto done;
    }
 
    RpcTryExcept
    {
        dwError = RCreateServiceW((SC_RPC_HANDLE)hSCManager,
                                  lpServiceName,
                                  lpDisplayName,
                                  dwDesiredAccess,
                                  dwServiceType,
                                  dwStartType,
                                  dwErrorControl,
                                  lpBinaryPathName,
                                  lpLoadOrderGroup,
                                  lpdwTagId,
                                  (LPBYTE)lpDependencies,
                                  dwDependenciesLength,
                                  lpServiceStartName,
                                  lpEncryptedPassword,
                                  dwPasswordSize,
                                  (SC_RPC_HANDLE *)&hService);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
done:
    if (lpEncryptedPassword != NULL)
    {
        /* Wipe and release the password buffers */
        SecureZeroMemory(lpEncryptedPassword, dwPasswordSize);
        HeapFree(GetProcessHeap(), 0, lpEncryptedPassword);
    }
 
    SetLastError(dwError);
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RCreateServiceW() failed (Error %lu)\n", dwError);
        return NULL;
    }
 
    return hService;
}

Referenced by _RunRemoteTest(), DoCreate(), DoRegServer(), InstallOneService(), ITERATE_InstallService(), MakeService(), register_service(), register_service_exW(), RegisterDriver(), RegisterService(), and Test_CreateService().

DeleteService()

BOOL WINAPI DeleteService

(

SC_HANDLE

hService

)

Definition at line 921 of file scm.c.

{
    DWORD dwError;
 
    TRACE("DeleteService(%p)\n",
          hService);
 
    RpcTryExcept
    {
        dwError = RDeleteService((SC_RPC_HANDLE)hService);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RDeleteService() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by CmdRemoveService(), Delete(), delete_test_service(), DestroyService(), DoDeleteService(), DoUnregServer(), InstallOneService(), ITERATE_DeleteService(), KmtDeleteService(), my_test_server(), RunTest(), test_create_delete_svc(), test_driver_install(), test_get_displayname(), test_install_svc_from(), test_no_stop(), test_queryconfig2(), test_refcount(), test_runner(), test_sequence(), test_service(), test_SetupDiInstallClassExA(), test_SetupInstallServicesFromInfSectionExA(), test_SetupInstallServicesFromInfSectionExW(), test_start_stop(), uninstallService(), UnregisterDriver(), and VfdRemoveDriver().

EnumDependentServicesA()

BOOL WINAPI EnumDependentServicesA	(	SC_HANDLE	hService,
		DWORD	dwServiceState,
		LPENUM_SERVICE_STATUSA	lpServices,
		DWORD	cbBufSize,
		LPDWORD	pcbBytesNeeded,
		LPDWORD	lpServicesReturned
	)

Definition at line 955 of file scm.c.

{
    ENUM_SERVICE_STATUSA ServiceStatus;
    LPENUM_SERVICE_STATUSA lpStatusPtr;
    DWORD dwBufferSize;
    DWORD dwError;
    DWORD dwCount;
 
    TRACE("EnumDependentServicesA(%p %lu %p %lu %p %p)\n",
          hService, dwServiceState, lpServices, cbBufSize,
          pcbBytesNeeded, lpServicesReturned);
 
    if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSA))
    {
        lpStatusPtr = &ServiceStatus;
        dwBufferSize = sizeof(ENUM_SERVICE_STATUSA);
    }
    else
    {
        lpStatusPtr = lpServices;
        dwBufferSize = cbBufSize;
    }
 
    RpcTryExcept
    {
        dwError = REnumDependentServicesA((SC_RPC_HANDLE)hService,
                                          dwServiceState,
                                          (LPBYTE)lpStatusPtr,
                                          dwBufferSize,
                                          pcbBytesNeeded,
                                          lpServicesReturned);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
    {
        for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
        {
            if (lpStatusPtr->lpServiceName)
                lpStatusPtr->lpServiceName =
                    (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
 
            if (lpStatusPtr->lpDisplayName)
                lpStatusPtr->lpDisplayName =
                    (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
 
            lpStatusPtr++;
        }
    }
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("REnumDependentServicesA() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    TRACE("EnumDependentServicesA() done\n");
 
    return TRUE;
}

EnumDependentServicesW()

BOOL WINAPI EnumDependentServicesW	(	SC_HANDLE	hService,
		DWORD	dwServiceState,
		LPENUM_SERVICE_STATUSW	lpServices,
		DWORD	cbBufSize,
		LPDWORD	pcbBytesNeeded,
		LPDWORD	lpServicesReturned
	)

Definition at line 1033 of file scm.c.

{
    ENUM_SERVICE_STATUSW ServiceStatus;
    LPENUM_SERVICE_STATUSW lpStatusPtr;
    DWORD dwBufferSize;
    DWORD dwError;
    DWORD dwCount;
 
    TRACE("EnumDependentServicesW(%p %lu %p %lu %p %p)\n",
          hService, dwServiceState, lpServices, cbBufSize,
          pcbBytesNeeded, lpServicesReturned);
 
    if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSW))
    {
        lpStatusPtr = &ServiceStatus;
        dwBufferSize = sizeof(ENUM_SERVICE_STATUSW);
    }
    else
    {
        lpStatusPtr = lpServices;
        dwBufferSize = cbBufSize;
    }
 
    RpcTryExcept
    {
        dwError = REnumDependentServicesW((SC_RPC_HANDLE)hService,
                                          dwServiceState,
                                          (LPBYTE)lpStatusPtr,
                                          dwBufferSize,
                                          pcbBytesNeeded,
                                          lpServicesReturned);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
    {
        for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
        {
            if (lpStatusPtr->lpServiceName)
                lpStatusPtr->lpServiceName =
                    (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
 
            if (lpStatusPtr->lpDisplayName)
                lpStatusPtr->lpDisplayName =
                    (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
 
            lpStatusPtr++;
        }
    }
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("REnumDependentServicesW() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    TRACE("EnumDependentServicesW() done\n");
 
    return TRUE;
}

Referenced by stop_service_dependents(), and TV2_GetDependants().

EnumServiceGroupW()

BOOL WINAPI EnumServiceGroupW	(	SC_HANDLE	hSCManager,
		DWORD	dwServiceType,
		DWORD	dwServiceState,
		LPENUM_SERVICE_STATUSW	lpServices,
		DWORD	cbBufSize,
		LPDWORD	pcbBytesNeeded,
		LPDWORD	lpServicesReturned,
		LPDWORD	lpResumeHandle,
		LPCWSTR	lpGroup
	)

Definition at line 1111 of file scm.c.

{
    ENUM_SERVICE_STATUSW ServiceStatus;
    LPENUM_SERVICE_STATUSW lpStatusPtr;
    DWORD dwBufferSize;
    DWORD dwError;
    DWORD dwCount;
 
    TRACE("EnumServiceGroupW(%p %lu %lu %p %lu %p %p %p %s)\n",
          hSCManager, dwServiceType, dwServiceState, lpServices,
          cbBufSize, pcbBytesNeeded, lpServicesReturned,
          lpResumeHandle, debugstr_w(lpGroup));
 
    if (!hSCManager)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
    {
        SetLastError(ERROR_INVALID_ADDRESS);
        return FALSE;
    }
 
    if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSW))
    {
        lpStatusPtr = &ServiceStatus;
        dwBufferSize = sizeof(ENUM_SERVICE_STATUSW);
    }
    else
    {
        lpStatusPtr = lpServices;
        dwBufferSize = cbBufSize;
    }
 
    RpcTryExcept
    {
        if (lpGroup == NULL)
        {
            dwError = REnumServicesStatusW((SC_RPC_HANDLE)hSCManager,
                                           dwServiceType,
                                           dwServiceState,
                                           (LPBYTE)lpStatusPtr,
                                           dwBufferSize,
                                           pcbBytesNeeded,
                                           lpServicesReturned,
                                           lpResumeHandle);
        }
        else
        {
            dwError = REnumServiceGroupW((SC_RPC_HANDLE)hSCManager,
                                         dwServiceType,
                                         dwServiceState,
                                         (LPBYTE)lpStatusPtr,
                                         dwBufferSize,
                                         pcbBytesNeeded,
                                         lpServicesReturned,
                                         lpResumeHandle,
                                         lpGroup);
        }
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
    {
        for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
        {
            if (lpStatusPtr->lpServiceName)
                lpStatusPtr->lpServiceName =
                    (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
 
            if (lpStatusPtr->lpDisplayName)
                lpStatusPtr->lpDisplayName =
                    (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
 
            lpStatusPtr++;
        }
    }
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("REnumServiceGroupW() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    TRACE("EnumServiceGroupW() done\n");
 
    return TRUE;
}

EnumServicesStatusA()

BOOL WINAPI EnumServicesStatusA	(	SC_HANDLE	hSCManager,
		DWORD	dwServiceType,
		DWORD	dwServiceState,
		LPENUM_SERVICE_STATUSA	lpServices,
		DWORD	cbBufSize,
		LPDWORD	pcbBytesNeeded,
		LPDWORD	lpServicesReturned,
		LPDWORD	lpResumeHandle
	)

Definition at line 1222 of file scm.c.

{
    ENUM_SERVICE_STATUSA ServiceStatus;
    LPENUM_SERVICE_STATUSA lpStatusPtr;
    DWORD dwBufferSize;
    DWORD dwError;
    DWORD dwCount;
 
    TRACE("EnumServicesStatusA(%p %lu %lu %p %lu %p %p %p)\n",
          hSCManager, dwServiceType, dwServiceState, lpServices,
          cbBufSize, pcbBytesNeeded, lpServicesReturned, lpResumeHandle);
 
    if (!hSCManager)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
    {
        SetLastError(ERROR_INVALID_ADDRESS);
        return FALSE;
    }
 
    if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSA))
    {
        lpStatusPtr = &ServiceStatus;
        dwBufferSize = sizeof(ENUM_SERVICE_STATUSA);
    }
    else
    {
        lpStatusPtr = lpServices;
        dwBufferSize = cbBufSize;
    }
 
    RpcTryExcept
    {
        dwError = REnumServicesStatusA((SC_RPC_HANDLE)hSCManager,
                                       dwServiceType,
                                       dwServiceState,
                                       (LPBYTE)lpStatusPtr,
                                       dwBufferSize,
                                       pcbBytesNeeded,
                                       lpServicesReturned,
                                       lpResumeHandle);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
    {
        for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
        {
            if (lpStatusPtr->lpServiceName)
                lpStatusPtr->lpServiceName =
                    (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
 
            if (lpStatusPtr->lpDisplayName)
                lpStatusPtr->lpDisplayName =
                    (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
 
            lpStatusPtr++;
        }
    }
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("REnumServicesStatusA() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    TRACE("EnumServicesStatusA() done\n");
 
    return TRUE;
}

Referenced by test_enum_svc().

EnumServicesStatusExA()

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
	)

Definition at line 1410 of file scm.c.

{
    ENUM_SERVICE_STATUS_PROCESSA ServiceStatus;
    LPENUM_SERVICE_STATUS_PROCESSA lpStatusPtr;
    DWORD dwBufferSize;
    DWORD dwError;
    DWORD dwCount;
 
    TRACE("EnumServicesStatusExA(%p %lu %lu %p %lu %p %p %p %s)\n",
          hSCManager, dwServiceType, dwServiceState, lpServices,
          cbBufSize, pcbBytesNeeded, lpServicesReturned, lpResumeHandle,
          debugstr_a(pszGroupName));
 
    if (InfoLevel != SC_ENUM_PROCESS_INFO)
    {
        SetLastError(ERROR_INVALID_LEVEL);
        return FALSE;
    }
 
    if (!hSCManager)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
    {
        SetLastError(ERROR_INVALID_ADDRESS);
        return FALSE;
    }
 
    if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUS_PROCESSA))
    {
        lpStatusPtr = &ServiceStatus;
        dwBufferSize = sizeof(ENUM_SERVICE_STATUS_PROCESSA);
    }
    else
    {
        lpStatusPtr = (LPENUM_SERVICE_STATUS_PROCESSA)lpServices;
        dwBufferSize = cbBufSize;
    }
 
    RpcTryExcept
    {
        dwError = REnumServicesStatusExA((SC_RPC_HANDLE)hSCManager,
                                         InfoLevel,
                                         dwServiceType,
                                         dwServiceState,
                                         (LPBYTE)lpStatusPtr,
                                         dwBufferSize,
                                         pcbBytesNeeded,
                                         lpServicesReturned,
                                         lpResumeHandle,
                                         (LPSTR)pszGroupName);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
    {
        if (InfoLevel == SC_ENUM_PROCESS_INFO)
        {
            for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
            {
                if (lpStatusPtr->lpServiceName)
                    lpStatusPtr->lpServiceName =
                        (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
 
                if (lpStatusPtr->lpDisplayName)
                    lpStatusPtr->lpDisplayName =
                        (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
 
                lpStatusPtr++;
            }
        }
    }
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("REnumServicesStatusExA() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    TRACE("EnumServicesStatusExA() done\n");
 
    return TRUE;
}

EnumServicesStatusExW()

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
	)

Definition at line 1518 of file scm.c.

{
    ENUM_SERVICE_STATUS_PROCESSW ServiceStatus;
    LPENUM_SERVICE_STATUS_PROCESSW lpStatusPtr;
    DWORD dwBufferSize;
    DWORD dwError;
    DWORD dwCount;
 
    TRACE("EnumServicesStatusExW(%p %lu %lu %p %lu %p %p %p %s)\n",
          hSCManager, dwServiceType, dwServiceState, lpServices,
          cbBufSize, pcbBytesNeeded, lpServicesReturned, lpResumeHandle,
          debugstr_w(pszGroupName));
 
    if (InfoLevel != SC_ENUM_PROCESS_INFO)
    {
        SetLastError(ERROR_INVALID_LEVEL);
        return FALSE;
    }
 
    if (!hSCManager)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
    {
        SetLastError(ERROR_INVALID_ADDRESS);
        return FALSE;
    }
 
    if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUS_PROCESSW))
    {
        lpStatusPtr = &ServiceStatus;
        dwBufferSize = sizeof(ENUM_SERVICE_STATUS_PROCESSW);
    }
    else
    {
        lpStatusPtr = (LPENUM_SERVICE_STATUS_PROCESSW)lpServices;
        dwBufferSize = cbBufSize;
    }
 
    RpcTryExcept
    {
        dwError = REnumServicesStatusExW((SC_RPC_HANDLE)hSCManager,
                                         InfoLevel,
                                         dwServiceType,
                                         dwServiceState,
                                         (LPBYTE)lpStatusPtr,
                                         dwBufferSize,
                                         pcbBytesNeeded,
                                         lpServicesReturned,
                                         lpResumeHandle,
                                         (LPWSTR)pszGroupName);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
    {
        if (InfoLevel == SC_ENUM_PROCESS_INFO)
        {
            for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
            {
                if (lpStatusPtr->lpServiceName)
                    lpStatusPtr->lpServiceName =
                        (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
 
                if (lpStatusPtr->lpDisplayName)
                    lpStatusPtr->lpDisplayName =
                        (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
 
                lpStatusPtr++;
            }
        }
    }
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("REnumServicesStatusExW() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    TRACE("EnumServicesStatusExW() done\n");
 
    return TRUE;
}

Referenced by fill_service(), and GetServices().

EnumServicesStatusW()

BOOL WINAPI EnumServicesStatusW	(	SC_HANDLE	hSCManager,
		DWORD	dwServiceType,
		DWORD	dwServiceState,
		LPENUM_SERVICE_STATUSW	lpServices,
		DWORD	cbBufSize,
		LPDWORD	pcbBytesNeeded,
		LPDWORD	lpServicesReturned,
		LPDWORD	lpResumeHandle
	)

Definition at line 1316 of file scm.c.

{
    ENUM_SERVICE_STATUSW ServiceStatus;
    LPENUM_SERVICE_STATUSW lpStatusPtr;
    DWORD dwBufferSize;
    DWORD dwError;
    DWORD dwCount;
 
    TRACE("EnumServicesStatusW(%p %lu %lu %p %lu %p %p %p)\n",
          hSCManager, dwServiceType, dwServiceState, lpServices,
          cbBufSize, pcbBytesNeeded, lpServicesReturned, lpResumeHandle);
 
    if (!hSCManager)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
    {
        SetLastError(ERROR_INVALID_ADDRESS);
        return FALSE;
    }
 
    if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSW))
    {
        lpStatusPtr = &ServiceStatus;
        dwBufferSize = sizeof(ENUM_SERVICE_STATUSW);
    }
    else
    {
        lpStatusPtr = lpServices;
        dwBufferSize = cbBufSize;
    }
 
    RpcTryExcept
    {
        dwError = REnumServicesStatusW((SC_RPC_HANDLE)hSCManager,
                                       dwServiceType,
                                       dwServiceState,
                                       (LPBYTE)lpStatusPtr,
                                       dwBufferSize,
                                       pcbBytesNeeded,
                                       lpServicesReturned,
                                       lpResumeHandle);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
    {
        for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
        {
            if (lpStatusPtr->lpServiceName)
                lpStatusPtr->lpServiceName =
                    (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
 
            if (lpStatusPtr->lpDisplayName)
                lpStatusPtr->lpDisplayName =
                    (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
 
            lpStatusPtr++;
        }
    }
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("REnumServicesStatusW() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    TRACE("EnumServicesStatusW() done\n");
 
    return TRUE;
}

Referenced by EnumerateRunningServices(), and test_enum_svc().

GetServiceDisplayNameA()

BOOL WINAPI GetServiceDisplayNameA	(	SC_HANDLE	hSCManager,
		LPCSTR	lpServiceName,
		LPSTR	lpDisplayName,
		LPDWORD	lpcchBuffer
	)

Definition at line 1626 of file scm.c.

{
    DWORD dwError;
    LPSTR lpNameBuffer;
    CHAR szEmptyName[] = "";
 
    TRACE("GetServiceDisplayNameA(%p %s %p %p)\n",
          hSCManager, debugstr_a(lpServiceName), lpDisplayName, lpcchBuffer);
 
    if (!hSCManager)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (!lpDisplayName || *lpcchBuffer < sizeof(CHAR))
    {
        lpNameBuffer = szEmptyName;
        *lpcchBuffer = sizeof(CHAR);
    }
    else
    {
        lpNameBuffer = lpDisplayName;
    }
 
    RpcTryExcept
    {
        dwError = RGetServiceDisplayNameA((SC_RPC_HANDLE)hSCManager,
                                          lpServiceName,
                                          lpNameBuffer,
                                          lpcchBuffer);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RGetServiceDisplayNameA() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by test_create_delete_svc(), test_get_displayname(), test_get_servicekeyname(), and test_open_svc().

GetServiceDisplayNameW()

BOOL WINAPI GetServiceDisplayNameW	(	SC_HANDLE	hSCManager,
		LPCWSTR	lpServiceName,
		LPWSTR	lpDisplayName,
		LPDWORD	lpcchBuffer
	)

Definition at line 1684 of file scm.c.

{
    DWORD dwError;
    LPWSTR lpNameBuffer;
    WCHAR szEmptyName[] = L"";
 
    TRACE("GetServiceDisplayNameW(%p %s %p %p)\n",
          hSCManager, debugstr_w(lpServiceName), lpDisplayName, lpcchBuffer);
 
    if (!hSCManager)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    /*
     * NOTE: A size of 1 character would be enough, but tests show that
     * Windows returns 2 characters instead, certainly due to a WCHAR/bytes
     * mismatch in their code.
     */
    if (!lpDisplayName || *lpcchBuffer < sizeof(WCHAR))
    {
        lpNameBuffer = szEmptyName;
        *lpcchBuffer = sizeof(WCHAR);
    }
    else
    {
        lpNameBuffer = lpDisplayName;
    }
 
    RpcTryExcept
    {
        dwError = RGetServiceDisplayNameW((SC_RPC_HANDLE)hSCManager,
                                          lpServiceName,
                                          lpNameBuffer,
                                          lpcchBuffer);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RGetServiceDisplayNameW() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by ITERATE_DeleteService(), ITERATE_StartService(), ITERATE_StopService(), and test_get_displayname().

GetServiceKeyNameA()

BOOL WINAPI GetServiceKeyNameA	(	SC_HANDLE	hSCManager,
		LPCSTR	lpDisplayName,
		LPSTR	lpServiceName,
		LPDWORD	lpcchBuffer
	)

Definition at line 1747 of file scm.c.

{
    DWORD dwError;
    LPSTR lpNameBuffer;
    CHAR szEmptyName[] = "";
 
    TRACE("GetServiceKeyNameA(%p %s %p %p)\n",
          hSCManager, debugstr_a(lpDisplayName), lpServiceName, lpcchBuffer);
 
    if (!hSCManager)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (!lpServiceName || *lpcchBuffer < sizeof(CHAR))
    {
        lpNameBuffer = szEmptyName;
        *lpcchBuffer = sizeof(CHAR);
    }
    else
    {
        lpNameBuffer = lpServiceName;
    }
 
    RpcTryExcept
    {
        dwError = RGetServiceKeyNameA((SC_RPC_HANDLE)hSCManager,
                                      lpDisplayName,
                                      lpNameBuffer,
                                      lpcchBuffer);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        /* HACK: because of a problem with rpcrt4, rpcserver is hacked to return 6 for ERROR_SERVICE_DOES_NOT_EXIST */
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RGetServiceKeyNameA() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by test_get_servicekeyname().

GetServiceKeyNameW()

BOOL WINAPI GetServiceKeyNameW	(	SC_HANDLE	hSCManager,
		LPCWSTR	lpDisplayName,
		LPWSTR	lpServiceName,
		LPDWORD	lpcchBuffer
	)

Definition at line 1806 of file scm.c.

{
    DWORD dwError;
    LPWSTR lpNameBuffer;
    WCHAR szEmptyName[] = L"";
 
    TRACE("GetServiceKeyNameW(%p %s %p %p)\n",
          hSCManager, debugstr_w(lpDisplayName), lpServiceName, lpcchBuffer);
 
    if (!hSCManager)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    /*
     * NOTE: A size of 1 character would be enough, but tests show that
     * Windows returns 2 characters instead, certainly due to a WCHAR/bytes
     * mismatch in their code.
     */
    if (!lpServiceName || *lpcchBuffer < sizeof(WCHAR))
    {
        lpNameBuffer = szEmptyName;
        *lpcchBuffer = sizeof(WCHAR);
    }
    else
    {
        lpNameBuffer = lpServiceName;
    }
 
    RpcTryExcept
    {
        dwError = RGetServiceKeyNameW((SC_RPC_HANDLE)hSCManager,
                                      lpDisplayName,
                                      lpNameBuffer,
                                      lpcchBuffer);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RGetServiceKeyNameW() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by test_get_servicekeyname().

I_QueryTagInformation()

DWORD WINAPI I_QueryTagInformation	(	PVOID	Unused,
		TAG_INFO_LEVEL	dwInfoLevel,
		PTAG_INFO_NAME_FROM_TAG	InOutParams
	)

Definition at line 3184 of file scm.c.

{
    /*
     * We only support one information class and it
     * needs parameters
     */
    if (dwInfoLevel != TagInfoLevelNameFromTag ||
        InOutParams == NULL)
    {
        return ERROR_INVALID_PARAMETER;
    }
 
    /* Validate input structure */
    if (InOutParams->InParams.dwPid == 0 || InOutParams->InParams.dwTag == 0)
    {
        return ERROR_INVALID_PARAMETER;
    }
 
    /* Validate output structure */
    if (InOutParams->OutParams.pszName != NULL)
    {
        return ERROR_INVALID_PARAMETER;
    }
 
    /* Call internal function for the RPC call */
    return I_ScQueryServiceTagInfo(Unused, TagInfoLevelNameFromTag, InOutParams);
}

I_ScGetCurrentGroupStateW()

DWORD WINAPI I_ScGetCurrentGroupStateW	(	SC_HANDLE	hSCManager,
		LPWSTR	pszGroupName,
		LPDWORD	pdwGroupState
	)

Definition at line 1869 of file scm.c.

{
    DWORD dwError;
 
    TRACE("I_ScGetCurrentGroupStateW(%p %s %p)\n",
          hSCManager, debugstr_w(pszGroupName), pdwGroupState);
 
    RpcTryExcept
    {
        dwError = RI_ScGetCurrentGroupStateW((SC_RPC_HANDLE)hSCManager,
                                             pszGroupName,
                                             pdwGroupState);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RI_ScGetCurrentGroupStateW() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
    }
 
    return dwError;
}

I_ScQueryServiceTagInfo()

DWORD I_ScQueryServiceTagInfo	(	PVOID	Unused,
		TAG_INFO_LEVEL	dwInfoLevel,
		PTAG_INFO_NAME_FROM_TAG	InOutParams
	)

Definition at line 3084 of file scm.c.

{
    SC_HANDLE hScm;
    DWORD dwError;
    PTAG_INFO_NAME_FROM_TAG_IN_PARAMS InParams;
    PTAG_INFO_NAME_FROM_TAG_OUT_PARAMS OutParams;
    LPWSTR lpszName;
 
    /* We only support one class */
    if (dwInfoLevel != TagInfoLevelNameFromTag)
    {
        return ERROR_RETRY;
    }
 
    /* Validate input structure */
    if (InOutParams->InParams.dwPid == 0 || InOutParams->InParams.dwTag == 0)
    {
        return ERROR_INVALID_PARAMETER;
    }
 
    /* Validate output structure */
    if (InOutParams->OutParams.pszName != NULL)
    {
        return ERROR_INVALID_PARAMETER;
    }
 
    /* Open service manager */
    hScm = OpenSCManagerW(NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE);
    if (hScm == NULL)
    {
        return GetLastError();
    }
 
    /* Setup call parameters */
    InParams = &InOutParams->InParams;
    OutParams = NULL;
 
    /* Call SCM to query tag information */
    RpcTryExcept
    {
        dwError = RI_ScQueryServiceTagInfo(hScm, TagInfoLevelNameFromTag, &InParams, &OutParams);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    /* Quit if not a success */
    if (dwError != ERROR_SUCCESS)
    {
        goto Cleanup;
    }
 
    /* OutParams must be set now and we must have a name */
    if (OutParams == NULL ||
        OutParams->pszName == NULL)
    {
        dwError = ERROR_INVALID_DATA;
        goto Cleanup;
    }
 
    /* Copy back what SCM returned */
    lpszName = LocalAlloc(LPTR,
                          sizeof(WCHAR) * wcslen(OutParams->pszName) + sizeof(UNICODE_NULL));
    if (lpszName == NULL)
    {
        dwError = GetLastError();
        goto Cleanup;
    }
 
    wcscpy(lpszName, OutParams->pszName);
    InOutParams->OutParams.pszName = lpszName;
    InOutParams->OutParams.TagType = OutParams->TagType;
 
Cleanup:
    CloseServiceHandle(hScm);
 
    /* Free memory allocated by SCM */
    if (OutParams != NULL)
    {
        if (OutParams->pszName != NULL)
        {
            midl_user_free(OutParams->pszName);
        }
 
        midl_user_free(OutParams);
    }
 
    return dwError;
}

Referenced by I_QueryTagInformation().

I_ScValidatePnpService()

DWORD WINAPI I_ScValidatePnpService	(	_In_ LPCWSTR	pszMachineName,
		_In_ LPCWSTR	pszServiceName,
		_Out_ SERVICE_STATUS_HANDLE *	phServiceStatus
	)

Definition at line 1909 of file scm.c.

{
    SC_RPC_HANDLE hSCManager = NULL;
    SERVICE_STATUS_HANDLE hServiceStatus = NULL;
    DWORD dwError;
 
    TRACE("I_ScValidatePnpService(%S %S %p)\n",
         pszMachineName, pszServiceName, phServiceStatus);
 
    hSCManager = OpenSCManagerW(pszMachineName,
                                SERVICES_ACTIVE_DATABASEW,
                                SC_MANAGER_CONNECT);
    if (hSCManager == NULL)
    {
        dwError = GetLastError();
        goto done;
    }
 
    RpcTryExcept
    {
        dwError = RI_ScValidatePnPService(hSCManager,
                                          (LPWSTR)pszServiceName,
                                          (RPC_SERVICE_STATUS_HANDLE *)&hServiceStatus);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept
 
    *phServiceStatus = hServiceStatus;
 
done:
    if (hSCManager != NULL)
        CloseServiceHandle(hSCManager);
 
    return dwError;
}

LockServiceDatabase()

SC_LOCK WINAPI LockServiceDatabase

(

SC_HANDLE

hSCManager

)

Definition at line 1958 of file scm.c.

{
    SC_LOCK hLock;
    DWORD dwError;
 
    TRACE("LockServiceDatabase(%p)\n",
          hSCManager);
 
    RpcTryExcept
    {
        dwError = RLockServiceDatabase((SC_RPC_HANDLE)hSCManager,
                                       (SC_RPC_LOCK *)&hLock);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RLockServiceDatabase() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return NULL;
    }
 
    TRACE("hLock = %p\n", hLock);
 
    return hLock;
}

Referenced by SetServiceAccount(), SetServiceConfig(), SetServiceDescription(), Test_LockUnlockServiceDatabase(), Test_LockUnlockServiceDatabaseWithServiceStart(), Test_QueryLockStatusA(), and Test_QueryLockStatusW().

NotifyBootConfigStatus()

BOOL WINAPI NotifyBootConfigStatus

(

BOOL

BootAcceptable

)

Definition at line 3055 of file scm.c.

{
    DWORD dwError;
 
    TRACE("NotifyBootConfigStatus(%u)\n",
          BootAcceptable);
 
    RpcTryExcept
    {
        dwError = RNotifyBootConfigStatus(NULL,
                                          BootAcceptable);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("NotifyBootConfigStatus() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by _tmain().

OpenSCManagerA()

SC_HANDLE WINAPI OpenSCManagerA	(	LPCSTR	lpMachineName,
		LPCSTR	lpDatabaseName,
		DWORD	dwDesiredAccess
	)

Definition at line 2024 of file scm.c.

{
    SC_HANDLE hScm = NULL;
    DWORD dwError;
 
    TRACE("OpenSCManagerA(%s %s %lx)\n",
          debugstr_a(lpMachineName), debugstr_a(lpDatabaseName), dwDesiredAccess);
 
    WaitForSCManager();
 
    RpcTryExcept
    {
        dwError = ROpenSCManagerA((LPSTR)lpMachineName,
                                  (LPSTR)lpDatabaseName,
                                  dwDesiredAccess,
                                  (SC_RPC_HANDLE *)&hScm);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    SetLastError(dwError);
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("ROpenSCManagerA() failed (Error %lu)\n", dwError);
        return NULL;
    }
 
    TRACE("hScm = %p\n", hScm);
 
    return hScm;
}

Referenced by delete_test_service(), RunTest(), sds_absent(), sds_present(), sis_absent(), sis_present(), sss_started(), sss_stopped(), START_TEST(), test_close(), test_create_delete_svc(), test_delete_services(), test_driver_install(), test_enum_svc(), test_get_displayname(), test_get_servicekeyname(), test_install_services(), test_install_svc_from(), test_open_scm(), test_open_svc(), test_query_svc(), test_queryconfig2(), Test_QueryLockStatusA(), Test_QueryServiceConfig2A(), test_refcount(), test_regconnectregistry(), test_sequence(), test_SetupDiInstallClassExA(), test_SetupInstallServicesFromInfSectionExA(), test_start_stop(), and test_start_stop_services().

OpenSCManagerW()

SC_HANDLE WINAPI OpenSCManagerW	(	LPCWSTR	lpMachineName,
		LPCWSTR	lpDatabaseName,
		DWORD	dwDesiredAccess
	)

Definition at line 2068 of file scm.c.

{
    SC_HANDLE hScm = NULL;
    DWORD dwError;
 
    TRACE("OpenSCManagerW(%s %s %lx)\n",
          debugstr_w(lpMachineName), debugstr_w(lpDatabaseName), dwDesiredAccess);
 
    WaitForSCManager();
 
    RpcTryExcept
    {
        dwError = ROpenSCManagerW((LPWSTR)lpMachineName,
                                  (LPWSTR)lpDatabaseName,
                                  dwDesiredAccess,
                                  (SC_RPC_HANDLE *)&hScm);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    SetLastError(dwError);
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("ROpenSCManagerW() failed (Error %lu)\n", dwError);
        return NULL;
    }
 
    TRACE("hScm = %p\n", hScm);
 
    return hScm;
}

Referenced by _RunRemoteTest(), cmdStop(), control_service(), DoControlService(), DoCreate(), DoDeleteService(), DoRegServer(), DoStartService(), DoStopService(), DoUnregServer(), EnableUserModePnpManager(), EnumerateRunningServices(), fill_service(), GetServiceConfig(), GetServiceDescription(), GetServiceList(), GetServices(), GetThemeServiceProcessHandle(), I_ScQueryServiceTagInfo(), I_ScValidatePnpService(), InstallOneService(), CShellDispatch::IsServiceRunning(), ITERATE_DeleteService(), ITERATE_InstallService(), ITERATE_StartService(), ITERATE_StopService(), MMSYS_InstallDevice(), my_test_server(), OpenServiceHelper(), RegisterDriver(), RegisterService(), RpcSsConfigureAsNetworkService(), SchedEventLogoff(), SchedStartShell(), ServicesPageWndProc(), SetServiceAccount(), SetServiceConfig(), SetServiceDescription(), SetupStartService(), start_local_service(), start_rpcss(), start_service(), START_TEST(), StartDriver(), StartOneService(), stop_service(), StopDriver(), Test_CreateService(), Test_LockUnlockServiceDatabase(), Test_LockUnlockServiceDatabaseWithServiceStart(), Test_QueryLockStatusW(), Test_QueryServiceConfig2W(), test_service(), test_SetupInstallServicesFromInfSectionExW(), ThemeWaitForServiceReady(), TV1_AddDependantsToTree(), TV2_GetDependants(), TV2_HasDependantServices(), UnregisterDriver(), and UpdateServiceStatus().

OpenServiceA()

SC_HANDLE WINAPI OpenServiceA	(	SC_HANDLE	hSCManager,
		LPCSTR	lpServiceName,
		DWORD	dwDesiredAccess
	)

Definition at line 2112 of file scm.c.

{
    SC_HANDLE hService = NULL;
    DWORD dwError;
 
    TRACE("OpenServiceA(%p %s %lx)\n",
           hSCManager, debugstr_a(lpServiceName), dwDesiredAccess);
 
    if (!hSCManager)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return NULL;
    }
 
    RpcTryExcept
    {
        dwError = ROpenServiceA((SC_RPC_HANDLE)hSCManager,
                                (LPSTR)lpServiceName,
                                dwDesiredAccess,
                                (SC_RPC_HANDLE *)&hService);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    SetLastError(dwError);
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("ROpenServiceA() failed (Error %lu)\n", dwError);
        return NULL;
    }
 
    TRACE("hService = %p\n", hService);
 
    return hService;
}

Referenced by delete_test_service(), sds_absent(), sds_present(), sis_absent(), sis_present(), sss_started(), sss_stopped(), test_create_delete_svc(), test_delete_services(), test_driver_install(), test_get_displayname(), test_get_servicekeyname(), test_install_services(), test_install_svc_from(), test_open_svc(), test_query_svc(), test_queryconfig2(), Test_QueryServiceConfig2A(), test_refcount(), test_sequence(), test_servicenotify(), test_SetupDiInstallClassExA(), test_SetupInstallServicesFromInfSectionExA(), test_start_stop(), and test_start_stop_services().

OpenServiceW()

SC_HANDLE WINAPI OpenServiceW	(	SC_HANDLE	hSCManager,
		LPCWSTR	lpServiceName,
		DWORD	dwDesiredAccess
	)

Definition at line 2160 of file scm.c.

{
    SC_HANDLE hService = NULL;
    DWORD dwError;
 
    TRACE("OpenServiceW(%p %s %lx)\n",
           hSCManager, debugstr_w(lpServiceName), dwDesiredAccess);
 
    if (!hSCManager)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return NULL;
    }
 
    RpcTryExcept
    {
        dwError = ROpenServiceW((SC_RPC_HANDLE)hSCManager,
                                (LPWSTR)lpServiceName,
                                dwDesiredAccess,
                                (SC_RPC_HANDLE *)&hService);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    SetLastError(dwError);
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("ROpenServiceW() failed (Error %lu)\n", dwError);
        return NULL;
    }
 
    TRACE("hService = %p\n", hService);
 
    return hService;
}

Referenced by _RunRemoteTest(), AddService(), cmdStop(), control_service(), DoControlService(), DoDeleteService(), DoStartService(), DoStopService(), DoUnregServer(), EnableUserModePnpManager(), GetServiceConfig(), GetServiceDescription(), GetThemeServiceProcessHandle(), InstallOneService(), CShellDispatch::IsServiceRunning(), ITERATE_DeleteService(), ITERATE_StartService(), MMSYS_InstallDevice(), OpenServiceHelper(), PlayLogonSoundThread(), query_service_config(), RpcSsConfigureAsNetworkService(), SchedEventLogoff(), SchedStartShell(), ServicesPageWndProc(), SetServiceAccount(), SetServiceConfig(), SetServiceDescription(), SetupStartService(), start_local_service(), start_rpcss(), start_service(), StartDriver(), StartOneService(), stop_service(), stop_service_dependents(), StopDriver(), Test_LockUnlockServiceDatabaseWithServiceStart(), Test_QueryServiceConfig2W(), test_service(), test_SetupInstallServicesFromInfSectionExW(), ThemeWaitForServiceReady(), TV1_AddDependantsToTree(), TV2_GetDependants(), TV2_HasDependantServices(), UnregisterDriver(), and UpdateServiceStatus().

QueryServiceConfig2A()

BOOL WINAPI QueryServiceConfig2A	(	SC_HANDLE	hService,
		DWORD	dwInfoLevel,
		LPBYTE	lpBuffer,
		DWORD	cbBufSize,
		LPDWORD	pcbBytesNeeded
	)

Definition at line 2374 of file scm.c.

{
    SERVICE_DESCRIPTIONA ServiceDescription;
    SERVICE_FAILURE_ACTIONSA ServiceFailureActions;
    LPBYTE lpTempBuffer;
    BOOL bUseTempBuffer = FALSE;
    DWORD dwBufferSize;
    DWORD dwError;
 
    TRACE("QueryServiceConfig2A(%p %lu %p %lu %p)\n",
          hService, dwInfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
 
    lpTempBuffer = lpBuffer;
    dwBufferSize = cbBufSize;
 
    switch (dwInfoLevel)
    {
        case SERVICE_CONFIG_DESCRIPTION:
            if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_DESCRIPTIONA)))
            {
                lpTempBuffer = (LPBYTE)&ServiceDescription;
                dwBufferSize = sizeof(SERVICE_DESCRIPTIONA);
                bUseTempBuffer = TRUE;
            }
            break;
 
        case SERVICE_CONFIG_FAILURE_ACTIONS:
            if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_FAILURE_ACTIONSA)))
            {
                lpTempBuffer = (LPBYTE)&ServiceFailureActions;
                dwBufferSize = sizeof(SERVICE_FAILURE_ACTIONSA);
                bUseTempBuffer = TRUE;
            }
            break;
 
        default:
            WARN("Unknown info level 0x%lx\n", dwInfoLevel);
            SetLastError(ERROR_INVALID_LEVEL);
            return FALSE;
    }
 
    RpcTryExcept
    {
        dwError = RQueryServiceConfig2A((SC_RPC_HANDLE)hService,
                                        dwInfoLevel,
                                        lpTempBuffer,
                                        dwBufferSize,
                                        pcbBytesNeeded);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RQueryServiceConfig2A() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    if (bUseTempBuffer != FALSE)
    {
        TRACE("RQueryServiceConfig2A() returns ERROR_INSUFFICIENT_BUFFER\n");
        *pcbBytesNeeded = dwBufferSize;
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }
 
    switch (dwInfoLevel)
    {
        case SERVICE_CONFIG_DESCRIPTION:
            {
                LPSERVICE_DESCRIPTIONA lpPtr = (LPSERVICE_DESCRIPTIONA)lpTempBuffer;
 
                if (lpPtr->lpDescription != NULL)
                    lpPtr->lpDescription =
                        (LPSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpDescription);
            }
            break;
 
        case SERVICE_CONFIG_FAILURE_ACTIONS:
            {
                LPSERVICE_FAILURE_ACTIONSA lpPtr = (LPSERVICE_FAILURE_ACTIONSA)lpTempBuffer;
 
                if (lpPtr->lpRebootMsg != NULL)
                    lpPtr->lpRebootMsg =
                        (LPSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpRebootMsg);
 
                if (lpPtr->lpCommand != NULL)
                    lpPtr->lpCommand =
                        (LPSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpCommand);
 
                if (lpPtr->lpsaActions != NULL)
                    lpPtr->lpsaActions =
                        (LPSC_ACTION)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpsaActions);
            }
            break;
    }
 
    TRACE("QueryServiceConfig2A() done\n");
 
    return TRUE;
}

Referenced by QueryConfig2A().

QueryServiceConfig2W()

BOOL WINAPI QueryServiceConfig2W	(	SC_HANDLE	hService,
		DWORD	dwInfoLevel,
		LPBYTE	lpBuffer,
		DWORD	cbBufSize,
		LPDWORD	pcbBytesNeeded
	)

Definition at line 2491 of file scm.c.

{
    SERVICE_DESCRIPTIONW ServiceDescription;
    SERVICE_FAILURE_ACTIONSW ServiceFailureActions;
    LPBYTE lpTempBuffer;
    BOOL bUseTempBuffer = FALSE;
    DWORD dwBufferSize;
    DWORD dwError;
 
    TRACE("QueryServiceConfig2W(%p %lu %p %lu %p)\n",
          hService, dwInfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
 
    lpTempBuffer = lpBuffer;
    dwBufferSize = cbBufSize;
 
    switch (dwInfoLevel)
    {
        case SERVICE_CONFIG_DESCRIPTION:
            if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_DESCRIPTIONW)))
            {
                lpTempBuffer = (LPBYTE)&ServiceDescription;
                dwBufferSize = sizeof(SERVICE_DESCRIPTIONW);
                bUseTempBuffer = TRUE;
            }
            break;
 
        case SERVICE_CONFIG_FAILURE_ACTIONS:
            if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_FAILURE_ACTIONSW)))
            {
                lpTempBuffer = (LPBYTE)&ServiceFailureActions;
                dwBufferSize = sizeof(SERVICE_FAILURE_ACTIONSW);
                bUseTempBuffer = TRUE;
            }
            break;
 
        default:
            WARN("Unknown info level 0x%lx\n", dwInfoLevel);
            SetLastError(ERROR_INVALID_LEVEL);
            return FALSE;
    }
 
    RpcTryExcept
    {
        dwError = RQueryServiceConfig2W((SC_RPC_HANDLE)hService,
                                        dwInfoLevel,
                                        lpTempBuffer,
                                        dwBufferSize,
                                        pcbBytesNeeded);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RQueryServiceConfig2W() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    if (bUseTempBuffer != FALSE)
    {
        TRACE("RQueryServiceConfig2W() returns ERROR_INSUFFICIENT_BUFFER\n");
        *pcbBytesNeeded = dwBufferSize;
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }
 
    switch (dwInfoLevel)
    {
        case SERVICE_CONFIG_DESCRIPTION:
            {
                LPSERVICE_DESCRIPTIONW lpPtr = (LPSERVICE_DESCRIPTIONW)lpTempBuffer;
 
                if (lpPtr->lpDescription != NULL)
                    lpPtr->lpDescription =
                        (LPWSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpDescription);
            }
            break;
 
        case SERVICE_CONFIG_FAILURE_ACTIONS:
            {
                LPSERVICE_FAILURE_ACTIONSW lpPtr = (LPSERVICE_FAILURE_ACTIONSW)lpTempBuffer;
 
                if (lpPtr->lpRebootMsg != NULL)
                    lpPtr->lpRebootMsg =
                        (LPWSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpRebootMsg);
 
                if (lpPtr->lpCommand != NULL)
                    lpPtr->lpCommand =
                        (LPWSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpCommand);
 
                if (lpPtr->lpsaActions != NULL)
                    lpPtr->lpsaActions =
                        (LPSC_ACTION)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpsaActions);
            }
            break;
    }
 
    TRACE("QueryServiceConfig2W() done\n");
 
    return TRUE;
}

Referenced by GetServiceDescription(), and QueryConfig2W().

QueryServiceConfigA()

BOOL WINAPI QueryServiceConfigA	(	SC_HANDLE	hService,
		LPQUERY_SERVICE_CONFIGA	lpServiceConfig,
		DWORD	cbBufSize,
		LPDWORD	pcbBytesNeeded
	)

Definition at line 2208 of file scm.c.

{
    QUERY_SERVICE_CONFIGA ServiceConfig;
    LPQUERY_SERVICE_CONFIGA lpConfigPtr;
    DWORD dwBufferSize;
    DWORD dwError;
 
    TRACE("QueryServiceConfigA(%p %p %lu %p)\n",
           hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
 
    if (lpServiceConfig == NULL ||
        cbBufSize < sizeof(QUERY_SERVICE_CONFIGA))
    {
        lpConfigPtr = &ServiceConfig;
        dwBufferSize = sizeof(QUERY_SERVICE_CONFIGA);
    }
    else
    {
        lpConfigPtr = lpServiceConfig;
        dwBufferSize = cbBufSize;
    }
 
    RpcTryExcept
    {
        dwError = RQueryServiceConfigA((SC_RPC_HANDLE)hService,
                                       (LPBYTE)lpConfigPtr,
                                       dwBufferSize,
                                       pcbBytesNeeded);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RQueryServiceConfigA() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    /* Adjust the pointers */
    if (lpConfigPtr->lpBinaryPathName)
        lpConfigPtr->lpBinaryPathName =
            (LPSTR)((ULONG_PTR)lpConfigPtr +
                    (ULONG_PTR)lpConfigPtr->lpBinaryPathName);
 
    if (lpConfigPtr->lpLoadOrderGroup)
        lpConfigPtr->lpLoadOrderGroup =
            (LPSTR)((ULONG_PTR)lpConfigPtr +
                    (ULONG_PTR)lpConfigPtr->lpLoadOrderGroup);
 
    if (lpConfigPtr->lpDependencies)
        lpConfigPtr->lpDependencies =
            (LPSTR)((ULONG_PTR)lpConfigPtr +
                    (ULONG_PTR)lpConfigPtr->lpDependencies);
 
    if (lpConfigPtr->lpServiceStartName)
        lpConfigPtr->lpServiceStartName =
            (LPSTR)((ULONG_PTR)lpConfigPtr +
                    (ULONG_PTR)lpConfigPtr->lpServiceStartName);
 
    if (lpConfigPtr->lpDisplayName)
        lpConfigPtr->lpDisplayName =
           (LPSTR)((ULONG_PTR)lpConfigPtr +
                   (ULONG_PTR)lpConfigPtr->lpDisplayName);
 
    TRACE("QueryServiceConfigA() done\n");
 
    return TRUE;
}

Referenced by test_sequence().

QueryServiceConfigW()

BOOL WINAPI QueryServiceConfigW	(	SC_HANDLE	hService,
		LPQUERY_SERVICE_CONFIGW	lpServiceConfig,
		DWORD	cbBufSize,
		LPDWORD	pcbBytesNeeded
	)

Definition at line 2291 of file scm.c.

{
    QUERY_SERVICE_CONFIGW ServiceConfig;
    LPQUERY_SERVICE_CONFIGW lpConfigPtr;
    DWORD dwBufferSize;
    DWORD dwError;
 
    TRACE("QueryServiceConfigW(%p %p %lu %p)\n",
           hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
 
    if (lpServiceConfig == NULL ||
        cbBufSize < sizeof(QUERY_SERVICE_CONFIGW))
    {
        lpConfigPtr = &ServiceConfig;
        dwBufferSize = sizeof(QUERY_SERVICE_CONFIGW);
    }
    else
    {
        lpConfigPtr = lpServiceConfig;
        dwBufferSize = cbBufSize;
    }
 
    RpcTryExcept
    {
        dwError = RQueryServiceConfigW((SC_RPC_HANDLE)hService,
                                       (LPBYTE)lpConfigPtr,
                                       dwBufferSize,
                                       pcbBytesNeeded);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RQueryServiceConfigW() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    /* Adjust the pointers */
    if (lpConfigPtr->lpBinaryPathName)
        lpConfigPtr->lpBinaryPathName =
            (LPWSTR)((ULONG_PTR)lpConfigPtr +
                     (ULONG_PTR)lpConfigPtr->lpBinaryPathName);
 
    if (lpConfigPtr->lpLoadOrderGroup)
        lpConfigPtr->lpLoadOrderGroup =
            (LPWSTR)((ULONG_PTR)lpConfigPtr +
                     (ULONG_PTR)lpConfigPtr->lpLoadOrderGroup);
 
    if (lpConfigPtr->lpDependencies)
        lpConfigPtr->lpDependencies =
            (LPWSTR)((ULONG_PTR)lpConfigPtr +
                     (ULONG_PTR)lpConfigPtr->lpDependencies);
 
    if (lpConfigPtr->lpServiceStartName)
        lpConfigPtr->lpServiceStartName =
            (LPWSTR)((ULONG_PTR)lpConfigPtr +
                     (ULONG_PTR)lpConfigPtr->lpServiceStartName);
 
    if (lpConfigPtr->lpDisplayName)
        lpConfigPtr->lpDisplayName =
           (LPWSTR)((ULONG_PTR)lpConfigPtr +
                    (ULONG_PTR)lpConfigPtr->lpDisplayName);
 
    TRACE("QueryServiceConfigW() done\n");
 
    return TRUE;
}

Referenced by AddService(), GetServiceConfig(), InstallOneService(), query_service_config(), ServicesPageWndProc(), Test_LockUnlockServiceDatabaseWithServiceStart(), and TV1_GetDependants().

QueryServiceLockStatusA()

BOOL WINAPI QueryServiceLockStatusA	(	SC_HANDLE	hSCManager,
		LPQUERY_SERVICE_LOCK_STATUSA	lpLockStatus,
		DWORD	cbBufSize,
		LPDWORD	pcbBytesNeeded
	)

Definition at line 2608 of file scm.c.

{
    QUERY_SERVICE_LOCK_STATUSA LockStatus;
    LPQUERY_SERVICE_LOCK_STATUSA lpStatusPtr;
    DWORD dwBufferSize;
    DWORD dwError;
 
    TRACE("QueryServiceLockStatusA(%p %p %lu %p)\n",
          hSCManager, lpLockStatus, cbBufSize, pcbBytesNeeded);
 
    if (lpLockStatus == NULL || cbBufSize < sizeof(QUERY_SERVICE_LOCK_STATUSA))
    {
        lpStatusPtr = &LockStatus;
        dwBufferSize = sizeof(QUERY_SERVICE_LOCK_STATUSA);
    }
    else
    {
        lpStatusPtr = lpLockStatus;
        dwBufferSize = cbBufSize;
    }
 
    RpcTryExcept
    {
        dwError = RQueryServiceLockStatusA((SC_RPC_HANDLE)hSCManager,
                                           (LPBYTE)lpStatusPtr,
                                           dwBufferSize,
                                           pcbBytesNeeded);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RQueryServiceLockStatusA() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    if (lpStatusPtr->lpLockOwner != NULL)
    {
        lpStatusPtr->lpLockOwner =
            (LPSTR)((ULONG_PTR)lpStatusPtr + (ULONG_PTR)lpStatusPtr->lpLockOwner);
    }
 
    TRACE("QueryServiceLockStatusA() done\n");
 
    return TRUE;
}

Referenced by Test_QueryLockStatusA().

QueryServiceLockStatusW()

BOOL WINAPI QueryServiceLockStatusW	(	SC_HANDLE	hSCManager,
		LPQUERY_SERVICE_LOCK_STATUSW	lpLockStatus,
		DWORD	cbBufSize,
		LPDWORD	pcbBytesNeeded
	)

Definition at line 2670 of file scm.c.

{
    QUERY_SERVICE_LOCK_STATUSW LockStatus;
    LPQUERY_SERVICE_LOCK_STATUSW lpStatusPtr;
    DWORD dwBufferSize;
    DWORD dwError;
 
    TRACE("QueryServiceLockStatusW(%p %p %lu %p)\n",
          hSCManager, lpLockStatus, cbBufSize, pcbBytesNeeded);
 
    if (lpLockStatus == NULL || cbBufSize < sizeof(QUERY_SERVICE_LOCK_STATUSW))
    {
        lpStatusPtr = &LockStatus;
        dwBufferSize = sizeof(QUERY_SERVICE_LOCK_STATUSW);
    }
    else
    {
        lpStatusPtr = lpLockStatus;
        dwBufferSize = cbBufSize;
    }
 
    RpcTryExcept
    {
        dwError = RQueryServiceLockStatusW((SC_RPC_HANDLE)hSCManager,
                                           (LPBYTE)lpStatusPtr,
                                           dwBufferSize,
                                           pcbBytesNeeded);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RQueryServiceLockStatusW() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    if (lpStatusPtr->lpLockOwner != NULL)
    {
        lpStatusPtr->lpLockOwner =
            (LPWSTR)((ULONG_PTR)lpStatusPtr + (ULONG_PTR)lpStatusPtr->lpLockOwner);
    }
 
    TRACE("QueryServiceLockStatusW() done\n");
 
    return TRUE;
}

Referenced by Test_QueryLockStatusW().

QueryServiceObjectSecurity()

BOOL WINAPI QueryServiceObjectSecurity	(	SC_HANDLE	hService,
		SECURITY_INFORMATION	dwSecurityInformation,
		PSECURITY_DESCRIPTOR	lpSecurityDescriptor,
		DWORD	cbBufSize,
		LPDWORD	pcbBytesNeeded
	)

Definition at line 2732 of file scm.c.

{
    DWORD dwError;
 
    TRACE("QueryServiceObjectSecurity(%p %lu %p)\n",
           hService, dwSecurityInformation, lpSecurityDescriptor);
 
    RpcTryExcept
    {
        dwError = RQueryServiceObjectSecurity((SC_RPC_HANDLE)hService,
                                              dwSecurityInformation,
                                              (LPBYTE)lpSecurityDescriptor,
                                              cbBufSize,
                                              pcbBytesNeeded);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("QueryServiceObjectSecurity() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by AccRewriteGetHandleRights(), and SdShow().

QueryServiceStatus()

BOOL WINAPI QueryServiceStatus	(	SC_HANDLE	hService,
		LPSERVICE_STATUS	lpServiceStatus
	)

Definition at line 2845 of file scm.c.

{
    DWORD dwError;
 
    TRACE("QueryServiceStatus(%p %p)\n",
          hService, lpServiceStatus);
 
    if (!hService)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    RpcTryExcept
    {
        dwError = RQueryServiceStatus((SC_RPC_HANDLE)hService,
                                      lpServiceStatus);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RQueryServiceStatus() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by _RunRemoteTest(), CmdRemoveService(), KmtEnsureServiceState(), my_test_server(), QueryDriverInfo(), ServiceInfo(), ServiceStart(), sss_started(), sss_stopped(), stopService(), Test_LockUnlockServiceDatabaseWithServiceStart(), test_no_stop(), test_query_svc(), test_service(), test_startA(), test_startW(), VfdGetDriverState(), VfdStartDriver(), and VfdStopDriver().

QueryServiceStatusEx()

BOOL WINAPI QueryServiceStatusEx	(	SC_HANDLE	hService,
		SC_STATUS_TYPE	InfoLevel,
		LPBYTE	lpBuffer,
		DWORD	cbBufSize,
		LPDWORD	pcbBytesNeeded
	)

Definition at line 2887 of file scm.c.

{
    DWORD dwError;
 
    TRACE("QueryServiceStatusEx(%p %lu %p %lu %p)\n",
          hService, InfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
 
    if (InfoLevel != SC_STATUS_PROCESS_INFO)
    {
        SetLastError(ERROR_INVALID_LEVEL);
        return FALSE;
    }
 
    if (cbBufSize < sizeof(SERVICE_STATUS_PROCESS))
    {
        *pcbBytesNeeded = sizeof(SERVICE_STATUS_PROCESS);
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }
 
    RpcTryExcept
    {
        dwError = RQueryServiceStatusEx((SC_RPC_HANDLE)hService,
                                        InfoLevel,
                                        lpBuffer,
                                        cbBufSize,
                                        pcbBytesNeeded);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RQueryServiceStatusEx() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by DoControlService(), DoStartService(), DoStopService(), EnableUserModePnpManager(), GetThemeServiceProcessHandle(), CShellDispatch::IsServiceRunning(), ITERATE_StartService(), PlayLogonSoundThread(), QueryService(), start_rpcss(), stop_service(), test_no_stop(), test_service(), ThemeWaitForServiceReady(), UpdateServiceStatus(), WaitForService(), and WaitService().

ScmEncryptPassword()

static DWORD ScmEncryptPassword ( _In_ PVOID  ContextHandle, _In_ PCWSTR  pClearTextPassword, _Out_ PBYTE *  pEncryptedPassword, _Out_ PDWORD  pEncryptedPasswordSize  )

static

Definition at line 173 of file scm.c.

{
    struct ustring inData, keyData, outData;
    BYTE SessionKey[16];
    PBYTE pBuffer;
    NTSTATUS Status;
 
    /* Get the session key */
    Status = SystemFunction028(ContextHandle,
                               SessionKey);
    if (!NT_SUCCESS(Status))
    {
        ERR("SystemFunction028 failed (Status 0x%08lx)\n", Status);
        return RtlNtStatusToDosError(Status);
    }
 
    inData.Length = (wcslen(pClearTextPassword) + 1) * sizeof(WCHAR);
    inData.MaximumLength = inData.Length;
    inData.Buffer = (unsigned char *)pClearTextPassword;
 
    keyData.Length = sizeof(SessionKey);
    keyData.MaximumLength = keyData.Length;
    keyData.Buffer = SessionKey;
 
    outData.Length = 0;
    outData.MaximumLength = 0;
    outData.Buffer = NULL;
 
    /* Get the required buffer size */
    Status = SystemFunction004(&inData,
                               &keyData,
                               &outData);
    if (Status != STATUS_BUFFER_TOO_SMALL)
    {
        ERR("SystemFunction004 failed (Status 0x%08lx)\n", Status);
        return RtlNtStatusToDosError(Status);
    }
 
    /* Allocate a buffer for the encrypted password */
    pBuffer = HeapAlloc(GetProcessHeap(), 0, outData.Length);
    if (pBuffer == NULL)
        return ERROR_OUTOFMEMORY;
 
    outData.MaximumLength = outData.Length;
    outData.Buffer = pBuffer;
 
    /* Encrypt the password */
    Status = SystemFunction004(&inData,
                               &keyData,
                               &outData);
    if (!NT_SUCCESS(Status))
    {
        ERR("SystemFunction004 failed (Status 0x%08lx)\n", Status);
        HeapFree(GetProcessHeap(), 0, pBuffer);
        return RtlNtStatusToDosError(Status);
    }
 
    *pEncryptedPassword = outData.Buffer;
    *pEncryptedPasswordSize = outData.Length;
 
    return ERROR_SUCCESS;
}

Referenced by ChangeServiceConfigA(), ChangeServiceConfigW(), CreateServiceA(), and CreateServiceW().

ScmRpcStatusToWinError()

DWORD ScmRpcStatusToWinError

(

RPC_STATUS

Status

)

Definition at line 146 of file scm.c.

{
    TRACE("ScmRpcStatusToWinError(%lx)\n",
          Status);
 
    switch (Status)
    {
        case STATUS_ACCESS_VIOLATION:
        case RPC_S_INVALID_BINDING:
        case RPC_X_SS_IN_NULL_CONTEXT:
            return ERROR_INVALID_HANDLE;
 
        case RPC_X_ENUM_VALUE_OUT_OF_RANGE:
        case RPC_X_BYTE_COUNT_TOO_SMALL:
            return ERROR_INVALID_PARAMETER;
 
        case RPC_X_NULL_REF_POINTER:
            return ERROR_INVALID_ADDRESS;
 
        default:
            return (DWORD)Status;
    }
}

Referenced by ChangeServiceConfig2A(), ChangeServiceConfig2W(), ChangeServiceConfigA(), ChangeServiceConfigW(), CloseServiceHandle(), ControlService(), CreateServiceA(), CreateServiceW(), DeleteService(), EnumDependentServicesA(), EnumDependentServicesW(), EnumServiceGroupW(), EnumServicesStatusA(), EnumServicesStatusExA(), EnumServicesStatusExW(), EnumServicesStatusW(), GetServiceDisplayNameA(), GetServiceDisplayNameW(), GetServiceKeyNameA(), GetServiceKeyNameW(), I_ScGetCurrentGroupStateW(), I_ScQueryServiceTagInfo(), I_ScSetServiceBitsA(), I_ScSetServiceBitsW(), I_ScValidatePnpService(), LockServiceDatabase(), NotifyBootConfigStatus(), OpenSCManagerA(), OpenSCManagerW(), OpenServiceA(), OpenServiceW(), QueryServiceConfig2A(), QueryServiceConfig2W(), QueryServiceConfigA(), QueryServiceConfigW(), QueryServiceLockStatusA(), QueryServiceLockStatusW(), QueryServiceObjectSecurity(), QueryServiceStatus(), QueryServiceStatusEx(), SetServiceObjectSecurity(), SetServiceStatus(), StartServiceA(), StartServiceW(), and UnlockServiceDatabase().

SetServiceObjectSecurity()

BOOL WINAPI SetServiceObjectSecurity	(	SC_HANDLE	hService,
		SECURITY_INFORMATION	dwSecurityInformation,
		PSECURITY_DESCRIPTOR	lpSecurityDescriptor
	)

Definition at line 2774 of file scm.c.

{
    PSECURITY_DESCRIPTOR SelfRelativeSD = NULL;
    ULONG Length;
    NTSTATUS Status;
    DWORD dwError;
 
    TRACE("SetServiceObjectSecurity(%p %lu %p)\n",
          hService, dwSecurityInformation, lpSecurityDescriptor);
 
    Length = 0;
    Status = RtlMakeSelfRelativeSD(lpSecurityDescriptor,
                                   SelfRelativeSD,
                                   &Length);
    if (Status != STATUS_BUFFER_TOO_SMALL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    SelfRelativeSD = HeapAlloc(GetProcessHeap(), 0, Length);
    if (SelfRelativeSD == NULL)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    Status = RtlMakeSelfRelativeSD(lpSecurityDescriptor,
                                   SelfRelativeSD,
                                   &Length);
    if (!NT_SUCCESS(Status))
    {
        HeapFree(GetProcessHeap(), 0, SelfRelativeSD);
        SetLastError(RtlNtStatusToDosError(Status));
        return FALSE;
    }
 
    RpcTryExcept
    {
        dwError = RSetServiceObjectSecurity((SC_RPC_HANDLE)hService,
                                            dwSecurityInformation,
                                            (LPBYTE)SelfRelativeSD,
                                            Length);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    HeapFree(GetProcessHeap(), 0, SelfRelativeSD);
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RServiceObjectSecurity() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by AccRewriteSetHandleRights(), InstallOneService(), and SdSet().

StartServiceA()

BOOL WINAPI StartServiceA	(	SC_HANDLE	hService,
		DWORD	dwNumServiceArgs,
		LPCSTR *	lpServiceArgVectors
	)

Definition at line 2942 of file scm.c.

{
    DWORD dwError;
 
    TRACE("StartServiceA(%p %lu %p)\n",
          hService, dwNumServiceArgs, lpServiceArgVectors);
 
    RpcTryExcept
    {
        dwError = RStartServiceA((SC_RPC_HANDLE)hService,
                                 dwNumServiceArgs,
                                 (LPSTRING_PTRSA)lpServiceArgVectors);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        ERR("RStartServiceA() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by RunTest(), test_no_stop(), test_service(), test_servicenotify(), test_start_stop_services(), test_startA(), and try_start_stop().

StartServiceW()

BOOL WINAPI StartServiceW	(	SC_HANDLE	hService,
		DWORD	dwNumServiceArgs,
		LPCWSTR *	lpServiceArgVectors
	)

Definition at line 2980 of file scm.c.

{
    DWORD dwError;
 
    TRACE("StartServiceW(%p %lu %p)\n",
          hService, dwNumServiceArgs, lpServiceArgVectors);
 
    RpcTryExcept
    {
        dwError = RStartServiceW((SC_RPC_HANDLE)hService,
                                 dwNumServiceArgs,
                                 (LPSTRING_PTRSW)lpServiceArgVectors);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        ERR("RStartServiceW() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by _RunRemoteTest(), DoStartService(), EnableUserModePnpManager(), ITERATE_StartService(), MMSYS_InstallDevice(), my_test_server(), start_local_service(), start_rpcss(), start_service(), StartDriver(), StartOneService(), Test_LockUnlockServiceDatabaseWithServiceStart(), and test_startW().

SVCCTL_HANDLEA_bind()

handle_t __RPC_USER SVCCTL_HANDLEA_bind

(

SVCCTL_HANDLEA

szMachineName

)

Definition at line 32 of file scm.c.

{
    handle_t hBinding = NULL;
    RPC_CSTR pszStringBinding;
    RPC_STATUS status;
 
    TRACE("SVCCTL_HANDLEA_bind(%s)\n",
          debugstr_a(szMachineName));
 
    status = RpcStringBindingComposeA(NULL,
                                      (RPC_CSTR)"ncacn_np",
                                      (RPC_CSTR)szMachineName,
                                      (RPC_CSTR)"\\pipe\\ntsvcs",
                                      NULL,
                                      &pszStringBinding);
    if (status != RPC_S_OK)
    {
        ERR("RpcStringBindingCompose returned 0x%x\n", status);
        return NULL;
    }
 
    /* Set the binding handle that will be used to bind to the server. */
    status = RpcBindingFromStringBindingA(pszStringBinding,
                                          &hBinding);
    if (status != RPC_S_OK)
    {
        ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
    }
 
    status = RpcStringFreeA(&pszStringBinding);
    if (status != RPC_S_OK)
    {
        ERR("RpcStringFree returned 0x%x\n", status);
    }
 
    return hBinding;
}

SVCCTL_HANDLEA_unbind()

void __RPC_USER SVCCTL_HANDLEA_unbind	(	SVCCTL_HANDLEA	szMachineName,
		handle_t	hBinding
	)

Definition at line 72 of file scm.c.

{
    RPC_STATUS status;
 
    TRACE("SVCCTL_HANDLEA_unbind(%s %p)\n",
          debugstr_a(szMachineName), hBinding);
 
    status = RpcBindingFree(&hBinding);
    if (status != RPC_S_OK)
    {
        ERR("RpcBindingFree returned 0x%x\n", status);
    }
}

SVCCTL_HANDLEW_bind()

handle_t __RPC_USER SVCCTL_HANDLEW_bind

(

SVCCTL_HANDLEW

szMachineName

)

Definition at line 89 of file scm.c.

{
    handle_t hBinding = NULL;
    RPC_WSTR pszStringBinding;
    RPC_STATUS status;
 
    TRACE("SVCCTL_HANDLEW_bind(%s)\n",
          debugstr_w(szMachineName));
 
    status = RpcStringBindingComposeW(NULL,
                                      L"ncacn_np",
                                      szMachineName,
                                      L"\\pipe\\ntsvcs",
                                      NULL,
                                      &pszStringBinding);
    if (status != RPC_S_OK)
    {
        ERR("RpcStringBindingCompose returned 0x%x\n", status);
        return NULL;
    }
 
    /* Set the binding handle that will be used to bind to the server. */
    status = RpcBindingFromStringBindingW(pszStringBinding,
                                          &hBinding);
    if (status != RPC_S_OK)
    {
        ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
    }
 
    status = RpcStringFreeW(&pszStringBinding);
    if (status != RPC_S_OK)
    {
        ERR("RpcStringFree returned 0x%x\n", status);
    }
 
    return hBinding;
}

SVCCTL_HANDLEW_unbind()

void __RPC_USER SVCCTL_HANDLEW_unbind	(	SVCCTL_HANDLEW	szMachineName,
		handle_t	hBinding
	)

Definition at line 129 of file scm.c.

{
    RPC_STATUS status;
 
    TRACE("SVCCTL_HANDLEW_unbind(%s %p)\n",
          debugstr_w(szMachineName), hBinding);
 
    status = RpcBindingFree(&hBinding);
    if (status != RPC_S_OK)
    {
        ERR("RpcBindingFree returned 0x%x\n", status);
    }
}

SystemFunction004()

NTSTATUS WINAPI SystemFunction004	(	const struct ustring *	in,
		const struct ustring *	key,
		struct ustring *	out
	)

Definition at line 119 of file sysfunc.c.

{
    union {
        unsigned char uc[8];
          unsigned int  ui[2];
    } data;
    unsigned char deskey[7];
    unsigned int crypt_len, ofs;
 
    if (key->Length<=0)
        return STATUS_INVALID_PARAMETER_2;
 
    crypt_len = ((in->Length+7)&~7);
    if (out->MaximumLength < (crypt_len+8))
    {
        out->Length = crypt_len + 8;
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    data.ui[0] = in->Length;
    data.ui[1] = 1;
 
    if (key->Length<sizeof deskey)
    {
        memset(deskey, 0, sizeof deskey);
        memcpy(deskey, key->Buffer, key->Length);
    }
    else
        memcpy(deskey, key->Buffer, sizeof deskey);
 
    CRYPT_DEShash(out->Buffer, deskey, data.uc);
 
    for(ofs=0; ofs<(crypt_len-8); ofs+=8)
        CRYPT_DEShash(out->Buffer+8+ofs, deskey, in->Buffer+ofs);
 
    memset(data.uc, 0, sizeof data.uc);
    memcpy(data.uc, in->Buffer+ofs, in->Length +8-crypt_len);
    CRYPT_DEShash(out->Buffer+8+ofs, deskey, data.uc);
 
    out->Length = crypt_len+8;
 
    return STATUS_SUCCESS;
}

Referenced by ScmEncryptPassword().

SystemFunction028()

NTSTATUS WINAPI SystemFunction028	(	IN PVOID	ContextHandle,
		OUT LPBYTE	SessionKey
	)

Referenced by ScmEncryptPassword().

UnlockServiceDatabase()

BOOL WINAPI UnlockServiceDatabase

(

SC_LOCK

ScLock

)

Definition at line 3018 of file scm.c.

{
    DWORD dwError;
 
    TRACE("UnlockServiceDatabase(%x)\n",
          ScLock);
 
    RpcTryExcept
    {
        dwError = RUnlockServiceDatabase((LPSC_RPC_LOCK)&ScLock);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError == ERROR_INVALID_HANDLE)
        dwError = ERROR_INVALID_SERVICE_LOCK;
 
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RUnlockServiceDatabase() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by SetServiceAccount(), SetServiceConfig(), SetServiceDescription(), Test_LockUnlockServiceDatabase(), Test_LockUnlockServiceDatabaseWithServiceStart(), Test_QueryLockStatusA(), and Test_QueryLockStatusW().

WaitForSCManager()

static VOID WaitForSCManager ( VOID  )

static

Definition at line 1991 of file scm.c.

{
    HANDLE hEvent;
 
    TRACE("WaitForSCManager()\n");
 
    /* Try to open the existing event */
    hEvent = OpenEventW(SYNCHRONIZE, FALSE, SCM_START_EVENT);
    if (hEvent == NULL)
    {
        if (GetLastError() != ERROR_FILE_NOT_FOUND)
            return;
 
        /* Try to create a new event */
        hEvent = CreateEventW(NULL, TRUE, FALSE, SCM_START_EVENT);
        if (hEvent == NULL)
            return;
    }
 
    /* Wait for 3 minutes */
    WaitForSingleObject(hEvent, 180000);
    CloseHandle(hEvent);
 
    TRACE("ScmWaitForSCManager() done\n");
}

Referenced by OpenSCManagerA(), and OpenSCManagerW().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

advapi

)