Go to the source code of this file.

Classes
struct	_SERVICE_STATUS

struct	_SERVICE_STATUS_PROCESS

struct	_SERVICE_NOTIFY_2A

struct	_SERVICE_NOTIFY_2W

struct	_SERVICE_TABLE_ENTRYA

struct	_SERVICE_TABLE_ENTRYW

struct	_ENUM_SERVICE_STATUSA

struct	_ENUM_SERVICE_STATUSW

struct	_ENUM_SERVICE_STATUS_PROCESSA

struct	_ENUM_SERVICE_STATUS_PROCESSW

struct	_QUERY_SERVICE_CONFIGA

struct	_QUERY_SERVICE_CONFIGW

struct	_SERVICE_DESCRIPTIONA

struct	_SERVICE_DESCRIPTIONW

struct	_SC_ACTION

struct	_SERVICE_FAILURE_ACTIONSA

struct	_SERVICE_FAILURE_ACTIONSW

struct	_SERVICE_DELAYED_AUTO_START_INFO

struct	_SERVICE_FAILURE_ACTIONS_FLAG

struct	_SERVICE_SID_INFO

struct	_SERVICE_REQUIRED_PRIVILEGES_INFOA

struct	_SERVICE_REQUIRED_PRIVILEGES_INFOW

struct	_SERVICE_PRESHUTDOWN_INFO

struct	_QUERY_SERVICE_LOCK_STATUSA

struct	_QUERY_SERVICE_LOCK_STATUSW

Macros
#define	WINADVAPI DECLSPEC_IMPORT

#define	SERVICES_ACTIVE_DATABASEA "ServicesActive"

#define	SERVICES_FAILED_DATABASEA "ServicesFailed"

#define	SERVICES_ACTIVE_DATABASE WINELIB_NAME_AW( SERVICES_ACTIVE_DATABASE )

#define	SERVICES_FAILED_DATABASE WINELIB_NAME_AW( SERVICES_FAILED_DATABASE )

#define	SERVICE_ACTIVE 0x00000001

#define	SERVICE_INACTIVE 0x00000002

#define	SERVICE_STATE_ALL (SERVICE_ACTIVE \| SERVICE_INACTIVE)

#define	SERVICE_CONTROL_STOP 0x00000001

#define	SERVICE_CONTROL_PAUSE 0x00000002

#define	SERVICE_CONTROL_CONTINUE 0x00000003

#define	SERVICE_CONTROL_INTERROGATE 0x00000004

#define	SERVICE_CONTROL_SHUTDOWN 0x00000005

#define	SERVICE_CONTROL_PARAMCHANGE 0x00000006

#define	SERVICE_CONTROL_NETBINDADD 0x00000007

#define	SERVICE_CONTROL_NETBINDREMOVE 0x00000008

#define	SERVICE_CONTROL_NETBINDENABLE 0x00000009

#define	SERVICE_CONTROL_NETBINDDISABLE 0x0000000A

#define	SERVICE_CONTROL_DEVICEEVENT 0x0000000B

#define	SERVICE_CONTROL_HARDWAREPROFILECHANGE 0x0000000C

#define	SERVICE_CONTROL_POWEREVENT 0x0000000D

#define	SERVICE_CONTROL_SESSIONCHANGE 0x0000000E

#define	SERVICE_CONTROL_PRESHUTDOWN 0x0000000F

#define	SERVICE_STOPPED 0x00000001

#define	SERVICE_START_PENDING 0x00000002

#define	SERVICE_STOP_PENDING 0x00000003

#define	SERVICE_RUNNING 0x00000004

#define	SERVICE_CONTINUE_PENDING 0x00000005

#define	SERVICE_PAUSE_PENDING 0x00000006

#define	SERVICE_PAUSED 0x00000007

#define	SERVICE_ACCEPT_STOP 0x00000001

#define	SERVICE_ACCEPT_PAUSE_CONTINUE 0x00000002

#define	SERVICE_ACCEPT_SHUTDOWN 0x00000004

#define	SERVICE_ACCEPT_PARAMCHANGE 0x00000008

#define	SERVICE_ACCEPT_NETBINDCHANGE 0x00000010

#define	SERVICE_ACCEPT_HARDWAREPROFILECHANGE 0x00000020

#define	SERVICE_ACCEPT_POWEREVENT 0x00000040

#define	SERVICE_ACCEPT_SESSIONCHANGE 0x00000080

#define	SERVICE_ACCEPT_PRESHUTDOWN 0x00000100

#define	SERVICE_ACCEPT_TIMECHANGE 0x00000200

#define	SERVICE_ACCEPT_TRIGGEREVENT 0x00000400

#define	SC_MANAGER_CONNECT 0x0001

#define	SC_MANAGER_CREATE_SERVICE 0x0002

#define	SC_MANAGER_ENUMERATE_SERVICE 0x0004

#define	SC_MANAGER_LOCK 0x0008

#define	SC_MANAGER_QUERY_LOCK_STATUS 0x0010

#define	SC_MANAGER_MODIFY_BOOT_CONFIG 0x0020

#define	SC_MANAGER_ALL_ACCESS

#define	SERVICE_QUERY_CONFIG 0x0001

#define	SERVICE_CHANGE_CONFIG 0x0002

#define	SERVICE_QUERY_STATUS 0x0004

#define	SERVICE_ENUMERATE_DEPENDENTS 0x0008

#define	SERVICE_START 0x0010

#define	SERVICE_STOP 0x0020

#define	SERVICE_PAUSE_CONTINUE 0x0040

#define	SERVICE_INTERROGATE 0x0080

#define	SERVICE_USER_DEFINED_CONTROL 0x0100

#define	SERVICE_ALL_ACCESS

#define	SERVICE_NO_CHANGE 0xffffffff

#define	SERVICE_RUNS_IN_SYSTEM_PROCESS 0x00000001

#define	SERVICE_NOTIFY_STATUS_CHANGE 2

#define	SERVICE_NOTIFY_STOPPED 0x1

#define	SERVICE_NOTIFY_START_PENDING 0x2

#define	SERVICE_NOTIFY_STOP_PENDING 0x4

#define	SERVICE_NOTIFY_RUNNING 0x8

#define	SERVICE_NOTIFY_CONTINUE_PENDING 0x10

#define	SERVICE_NOTIFY_PAUSE_PENDING 0x20

#define	SERVICE_NOTIFY_PAUSED 0x40

#define	SERVICE_NOTIFY_CREATED 0x80

#define	SERVICE_NOTIFY_DELETED 0x100

#define	SERVICE_NOTIFY_DELETE_PENDING 0x200

#define	SERVICE_CONFIG_DESCRIPTION 1

#define	SERVICE_CONFIG_FAILURE_ACTIONS 2

#define	SERVICE_CONFIG_DELAYED_AUTO_START_INFO 3

#define	SERVICE_CONFIG_FAILURE_ACTIONS_FLAG 4

#define	SERVICE_CONFIG_SERVICE_SID_INFO 5

#define	SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO 6

#define	SERVICE_CONFIG_PRESHUTDOWN_INFO 7

#define	ChangeServiceConfig WINELIB_NAME_AW(ChangeServiceConfig)

#define	ChangeServiceConfig2 WINELIB_NAME_AW(ChangeServiceConfig2)

#define	CreateService WINELIB_NAME_AW(CreateService)

#define	EnumDependentServices WINELIB_NAME_AW(EnumDependentServices)

#define	EnumServicesStatus WINELIB_NAME_AW(EnumServicesStatus)

#define	EnumServicesStatus WINELIB_NAME_AW(EnumServicesStatus)

#define	GetServiceDisplayName WINELIB_NAME_AW(GetServiceDisplayName)

#define	GetServiceKeyName WINELIB_NAME_AW(GetServiceKeyName)

#define	OpenSCManager WINELIB_NAME_AW(OpenSCManager)

#define	OpenService WINELIB_NAME_AW(OpenService)

#define	QueryServiceConfig WINELIB_NAME_AW(QueryServiceConfig)

#define	QueryServiceConfig2 WINELIB_NAME_AW(QueryServiceConfig2)

#define	QueryServiceLockStatus WINELIB_NAME_AW(QueryServiceLockStatus)

#define	RegisterServiceCtrlHandler WINELIB_NAME_AW(RegisterServiceCtrlHandler)

#define	RegisterServiceCtrlHandlerEx WINELIB_NAME_AW(RegisterServiceCtrlHandlerEx)

#define	StartService WINELIB_NAME_AW(StartService)

#define	StartServiceCtrlDispatcher WINELIB_NAME_AW(StartServiceCtrlDispatcher)

Typedefs
typedef SC_HANDLE *	LPSC_HANDLE

typedef LPVOID	SC_LOCK

typedef struct _SERVICE_STATUS	SERVICE_STATUS

typedef struct _SERVICE_STATUS *	LPSERVICE_STATUS

typedef struct _SERVICE_STATUS_PROCESS	SERVICE_STATUS_PROCESS

typedef struct _SERVICE_STATUS_PROCESS *	LPSERVICE_STATUS_PROCESS

typedef void(CALLBACK *	PFN_SC_NOTIFY_CALLBACK) (void *)

typedef struct _SERVICE_NOTIFY_2A	SERVICE_NOTIFY_2A

typedef struct _SERVICE_NOTIFY_2A	SERVICE_NOTIFYA

typedef struct _SERVICE_NOTIFY_2W	SERVICE_NOTIFY_2W

typedef struct _SERVICE_NOTIFY_2W	SERVICE_NOTIFYW

typedef enum _SC_STATUS_TYPE	SC_STATUS_TYPE

typedef VOID(CALLBACK *	LPSERVICE_MAIN_FUNCTIONA) (DWORD, LPSTR *)

typedef VOID(CALLBACK *	LPSERVICE_MAIN_FUNCTIONW) (DWORD, LPWSTR *)

typedef struct _SERVICE_TABLE_ENTRYA	SERVICE_TABLE_ENTRYA

typedef struct _SERVICE_TABLE_ENTRYA *	LPSERVICE_TABLE_ENTRYA

typedef struct _SERVICE_TABLE_ENTRYW	SERVICE_TABLE_ENTRYW

typedef struct _SERVICE_TABLE_ENTRYW *	LPSERVICE_TABLE_ENTRYW

typedef struct _ENUM_SERVICE_STATUSA	ENUM_SERVICE_STATUSA

typedef struct _ENUM_SERVICE_STATUSA *	LPENUM_SERVICE_STATUSA

typedef struct _ENUM_SERVICE_STATUSW	ENUM_SERVICE_STATUSW

typedef struct _ENUM_SERVICE_STATUSW *	LPENUM_SERVICE_STATUSW

typedef struct _ENUM_SERVICE_STATUS_PROCESSA	ENUM_SERVICE_STATUS_PROCESSA

typedef struct _ENUM_SERVICE_STATUS_PROCESSA *	LPENUM_SERVICE_STATUS_PROCESSA

typedef struct _ENUM_SERVICE_STATUS_PROCESSW	ENUM_SERVICE_STATUS_PROCESSW

typedef struct _ENUM_SERVICE_STATUS_PROCESSW *	LPENUM_SERVICE_STATUS_PROCESSW

typedef enum _SC_ENUM_TYPE	SC_ENUM_TYPE

typedef struct _QUERY_SERVICE_CONFIGA	QUERY_SERVICE_CONFIGA

typedef struct _QUERY_SERVICE_CONFIGA *	LPQUERY_SERVICE_CONFIGA

typedef struct _QUERY_SERVICE_CONFIGW	QUERY_SERVICE_CONFIGW

typedef struct _QUERY_SERVICE_CONFIGW *	LPQUERY_SERVICE_CONFIGW

typedef struct _SERVICE_DESCRIPTIONA	SERVICE_DESCRIPTIONA

typedef struct _SERVICE_DESCRIPTIONA *	LPSERVICE_DESCRIPTIONA

typedef struct _SERVICE_DESCRIPTIONW	SERVICE_DESCRIPTIONW

typedef struct _SERVICE_DESCRIPTIONW *	LPSERVICE_DESCRIPTIONW

typedef enum _SC_ACTION_TYPE	SC_ACTION_TYPE

typedef struct _SC_ACTION	SC_ACTION

typedef struct _SC_ACTION *	LPSC_ACTION

typedef struct _SERVICE_FAILURE_ACTIONSA	SERVICE_FAILURE_ACTIONSA

typedef struct _SERVICE_FAILURE_ACTIONSA *	LPSERVICE_FAILURE_ACTIONSA

typedef struct _SERVICE_FAILURE_ACTIONSW	SERVICE_FAILURE_ACTIONSW

typedef struct _SERVICE_FAILURE_ACTIONSW *	LPSERVICE_FAILURE_ACTIONSW

typedef struct _SERVICE_DELAYED_AUTO_START_INFO	SERVICE_DELAYED_AUTO_START_INFO

typedef struct _SERVICE_DELAYED_AUTO_START_INFO *	LPSERVICE_DELAYED_AUTO_START_INFO

typedef struct _SERVICE_FAILURE_ACTIONS_FLAG	SERVICE_FAILURE_ACTIONS_FLAG

typedef struct _SERVICE_FAILURE_ACTIONS_FLAG *	LPSERVICE_FAILURE_ACTIONS_FLAG

typedef struct _SERVICE_SID_INFO	SERVICE_SID_INFO

typedef struct _SERVICE_SID_INFO *	LPSERVICE_SID_INFO

typedef struct _SERVICE_REQUIRED_PRIVILEGES_INFOA	SERVICE_REQUIRED_PRIVILEGES_INFOA

typedef struct _SERVICE_REQUIRED_PRIVILEGES_INFOA *	LPSERVICE_REQUIRED_PRIVILEGES_INFOA

typedef struct _SERVICE_REQUIRED_PRIVILEGES_INFOW	SERVICE_REQUIRED_PRIVILEGES_INFOW

typedef struct _SERVICE_REQUIRED_PRIVILEGES_INFOW *	LPSERVICE_REQUIRED_PRIVILEGES_INFOW

typedef struct _SERVICE_PRESHUTDOWN_INFO	SERVICE_PRESHUTDOWN_INFO

typedef struct _SERVICE_PRESHUTDOWN_INFO *	LPSERVICE_PRESHUTDOWN_INFO

typedef struct _QUERY_SERVICE_LOCK_STATUSA	QUERY_SERVICE_LOCK_STATUSA

typedef struct _QUERY_SERVICE_LOCK_STATUSA *	LPQUERY_SERVICE_LOCK_STATUSA

typedef struct _QUERY_SERVICE_LOCK_STATUSW	QUERY_SERVICE_LOCK_STATUSW

typedef struct _QUERY_SERVICE_LOCK_STATUSW *	LPQUERY_SERVICE_LOCK_STATUSW

typedef VOID(WINAPI *	LPHANDLER_FUNCTION) (DWORD)

typedef DWORD(WINAPI *	LPHANDLER_FUNCTION_EX) (DWORD, DWORD, LPVOID, LPVOID)

Enumerations
enum	_SC_STATUS_TYPE { SC_STATUS_PROCESS_INFO = 0 , SC_STATUS_PROCESS_INFO = 0 , SC_STATUS_PROCESS_INFO = 0 }

enum	_SC_ENUM_TYPE { SC_ENUM_PROCESS_INFO = 0 , SC_ENUM_PROCESS_INFO = 0 , SC_ENUM_PROCESS_INFO = 0 }

enum	_SC_ACTION_TYPE { SC_ACTION_NONE = 0 , SC_ACTION_RESTART = 1 , SC_ACTION_REBOOT = 2 , SC_ACTION_RUN_COMMAND = 3 , SC_ACTION_NONE = 0 , SC_ACTION_RESTART = 1 , SC_ACTION_REBOOT = 2 , SC_ACTION_RUN_COMMAND = 3 , SC_ACTION_NONE = 0 , SC_ACTION_RESTART = 1 , SC_ACTION_REBOOT = 2 , SC_ACTION_RUN_COMMAND = 3 }

Functions
	DECLARE_HANDLE (SC_HANDLE)

	DECLARE_HANDLE (SERVICE_STATUS_HANDLE)

WINADVAPI BOOL WINAPI	ChangeServiceConfigA (SC_HANDLE, DWORD, DWORD, DWORD, LPCSTR, LPCSTR, LPDWORD, LPCSTR, LPCSTR, LPCSTR, LPCSTR)

WINADVAPI BOOL WINAPI	ChangeServiceConfigW (SC_HANDLE, DWORD, DWORD, DWORD, LPCWSTR, LPCWSTR, LPDWORD, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR)

WINADVAPI BOOL WINAPI	ChangeServiceConfig2A (SC_HANDLE, DWORD, LPVOID)

WINADVAPI BOOL WINAPI	ChangeServiceConfig2W (SC_HANDLE, DWORD, LPVOID)

WINADVAPI BOOL WINAPI	CloseServiceHandle (SC_HANDLE)

WINADVAPI BOOL WINAPI	ControlService (SC_HANDLE, DWORD, LPSERVICE_STATUS)

WINADVAPI SC_HANDLE WINAPI	CreateServiceA (SC_HANDLE, LPCSTR, LPCSTR, DWORD, DWORD, DWORD, DWORD, LPCSTR, LPCSTR, LPDWORD, LPCSTR, LPCSTR, LPCSTR)

WINADVAPI SC_HANDLE WINAPI	CreateServiceW (SC_HANDLE, LPCWSTR, LPCWSTR, DWORD, DWORD, DWORD, DWORD, LPCWSTR, LPCWSTR, LPDWORD, LPCWSTR, LPCWSTR, LPCWSTR)

WINADVAPI BOOL WINAPI	DeleteService (SC_HANDLE)

WINADVAPI BOOL WINAPI	EnumDependentServicesA (SC_HANDLE, DWORD, LPENUM_SERVICE_STATUSA, DWORD, LPDWORD, LPDWORD)

WINADVAPI BOOL WINAPI	EnumDependentServicesW (SC_HANDLE, DWORD, LPENUM_SERVICE_STATUSW, DWORD, LPDWORD, LPDWORD)

WINADVAPI BOOL WINAPI	EnumServicesStatusA (SC_HANDLE, DWORD, DWORD, LPENUM_SERVICE_STATUSA, DWORD, LPDWORD, LPDWORD, LPDWORD)

WINADVAPI BOOL WINAPI	EnumServicesStatusW (SC_HANDLE, DWORD, DWORD, LPENUM_SERVICE_STATUSW, DWORD, LPDWORD, LPDWORD, LPDWORD)

WINADVAPI BOOL WINAPI	EnumServicesStatusExA (SC_HANDLE, SC_ENUM_TYPE, DWORD, DWORD, LPBYTE, DWORD, LPDWORD, LPDWORD, LPDWORD, LPCSTR)

WINADVAPI BOOL WINAPI	EnumServicesStatusExW (SC_HANDLE, SC_ENUM_TYPE, DWORD, DWORD, LPBYTE, DWORD, LPDWORD, LPDWORD, LPDWORD, LPCWSTR)

WINADVAPI BOOL WINAPI	GetServiceDisplayNameA (SC_HANDLE, LPCSTR, LPSTR, LPDWORD)

WINADVAPI BOOL WINAPI	GetServiceDisplayNameW (SC_HANDLE, LPCWSTR, LPWSTR, LPDWORD)

WINADVAPI BOOL WINAPI	GetServiceKeyNameA (SC_HANDLE, LPCSTR, LPSTR, LPDWORD)

WINADVAPI BOOL WINAPI	GetServiceKeyNameW (SC_HANDLE, LPCWSTR, LPWSTR, LPDWORD)

WINADVAPI SC_LOCK WINAPI	LockServiceDatabase (SC_HANDLE)

WINADVAPI BOOL WINAPI	NotifyBootConfigStatus (BOOL)

WINADVAPI DWORD WINAPI	NotifyServiceStatusChangeW (SC_HANDLE, DWORD, SERVICE_NOTIFYW *)

WINADVAPI SC_HANDLE WINAPI	OpenSCManagerA (LPCSTR, LPCSTR, DWORD)

WINADVAPI SC_HANDLE WINAPI	OpenSCManagerW (LPCWSTR, LPCWSTR, DWORD)

WINADVAPI SC_HANDLE WINAPI	OpenServiceA (SC_HANDLE, LPCSTR, DWORD)

WINADVAPI SC_HANDLE WINAPI	OpenServiceW (SC_HANDLE, LPCWSTR, DWORD)

WINADVAPI BOOL WINAPI	QueryServiceStatus (SC_HANDLE, LPSERVICE_STATUS)

WINADVAPI BOOL WINAPI	QueryServiceStatusEx (SC_HANDLE, SC_STATUS_TYPE, LPBYTE, DWORD, LPDWORD)

WINADVAPI BOOL WINAPI	QueryServiceConfigA (SC_HANDLE, LPQUERY_SERVICE_CONFIGA, DWORD, LPDWORD)

WINADVAPI BOOL WINAPI	QueryServiceConfigW (SC_HANDLE, LPQUERY_SERVICE_CONFIGW, DWORD, LPDWORD)

WINADVAPI BOOL WINAPI	QueryServiceConfig2A (SC_HANDLE, DWORD, LPBYTE, DWORD, LPDWORD)

WINADVAPI BOOL WINAPI	QueryServiceConfig2W (SC_HANDLE, DWORD, LPBYTE, DWORD, LPDWORD)

WINADVAPI BOOL WINAPI	QueryServiceLockStatusA (SC_HANDLE, LPQUERY_SERVICE_LOCK_STATUSA, DWORD, LPDWORD)

WINADVAPI BOOL WINAPI	QueryServiceLockStatusW (SC_HANDLE, LPQUERY_SERVICE_LOCK_STATUSW, DWORD, LPDWORD)

WINADVAPI BOOL WINAPI	QueryServiceObjectSecurity (SC_HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, LPDWORD)

WINADVAPI SERVICE_STATUS_HANDLE WINAPI	RegisterServiceCtrlHandlerA (LPCSTR, LPHANDLER_FUNCTION)

WINADVAPI SERVICE_STATUS_HANDLE WINAPI	RegisterServiceCtrlHandlerW (LPCWSTR, LPHANDLER_FUNCTION)

WINADVAPI SERVICE_STATUS_HANDLE WINAPI	RegisterServiceCtrlHandlerExA (LPCSTR, LPHANDLER_FUNCTION_EX, LPVOID)

WINADVAPI SERVICE_STATUS_HANDLE WINAPI	RegisterServiceCtrlHandlerExW (LPCWSTR, LPHANDLER_FUNCTION_EX, LPVOID)

WINADVAPI BOOL WINAPI	SetServiceObjectSecurity (SC_HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR)

WINADVAPI BOOL WINAPI	SetServiceStatus (SERVICE_STATUS_HANDLE, LPSERVICE_STATUS)

WINADVAPI BOOL WINAPI	StartServiceA (SC_HANDLE, DWORD, LPCSTR *)

WINADVAPI BOOL WINAPI	StartServiceW (SC_HANDLE, DWORD, LPCWSTR *)

WINADVAPI BOOL WINAPI	StartServiceCtrlDispatcherA (const SERVICE_TABLE_ENTRYA *)

WINADVAPI BOOL WINAPI	StartServiceCtrlDispatcherW (const SERVICE_TABLE_ENTRYW *)

WINADVAPI BOOL WINAPI	UnlockServiceDatabase (SC_LOCK)

Variables
static const WCHAR	SERVICES_ACTIVE_DATABASEW [] = { 'S','e','r','v','i','c','e','s','A','c','t','i','v','e',0 }

static const WCHAR	SERVICES_FAILED_DATABASEW [] = { 'S','e','r','v','i','c','e','s','F','a','i','l','e','d',0 }

Macro Definition Documentation

◆ ChangeServiceConfig

#define ChangeServiceConfig WINELIB_NAME_AW(ChangeServiceConfig)

Definition at line 391 of file winsvc.h.

◆ ChangeServiceConfig2

#define ChangeServiceConfig2 WINELIB_NAME_AW(ChangeServiceConfig2)

Definition at line 394 of file winsvc.h.

◆ CreateService

#define CreateService WINELIB_NAME_AW(CreateService)

Definition at line 399 of file winsvc.h.

◆ EnumDependentServices

#define EnumDependentServices WINELIB_NAME_AW(EnumDependentServices)

Definition at line 403 of file winsvc.h.

◆ EnumServicesStatus [1/2]

#define EnumServicesStatus WINELIB_NAME_AW(EnumServicesStatus)

Definition at line 409 of file winsvc.h.

◆ EnumServicesStatus [2/2]

#define EnumServicesStatus WINELIB_NAME_AW(EnumServicesStatus)

Definition at line 409 of file winsvc.h.

◆ GetServiceDisplayName

#define GetServiceDisplayName WINELIB_NAME_AW(GetServiceDisplayName)

Definition at line 412 of file winsvc.h.

◆ GetServiceKeyName

#define GetServiceKeyName WINELIB_NAME_AW(GetServiceKeyName)

Definition at line 415 of file winsvc.h.

◆ OpenSCManager

#define OpenSCManager WINELIB_NAME_AW(OpenSCManager)

Definition at line 421 of file winsvc.h.

◆ OpenService

#define OpenService WINELIB_NAME_AW(OpenService)

Definition at line 424 of file winsvc.h.

◆ QueryServiceConfig

#define QueryServiceConfig WINELIB_NAME_AW(QueryServiceConfig)

Definition at line 429 of file winsvc.h.

◆ QueryServiceConfig2

#define QueryServiceConfig2 WINELIB_NAME_AW(QueryServiceConfig2)

Definition at line 432 of file winsvc.h.

◆ QueryServiceLockStatus

#define QueryServiceLockStatus WINELIB_NAME_AW(QueryServiceLockStatus)

Definition at line 435 of file winsvc.h.

◆ RegisterServiceCtrlHandler

#define RegisterServiceCtrlHandler WINELIB_NAME_AW(RegisterServiceCtrlHandler)

Definition at line 439 of file winsvc.h.

◆ RegisterServiceCtrlHandlerEx

#define RegisterServiceCtrlHandlerEx WINELIB_NAME_AW(RegisterServiceCtrlHandlerEx)

Definition at line 442 of file winsvc.h.

◆ SC_MANAGER_ALL_ACCESS

#define SC_MANAGER_ALL_ACCESS

Value:

                                        ( STANDARD_RIGHTS_REQUIRED      | \
                                        SC_MANAGER_CONNECT            | \
                                        SC_MANAGER_CREATE_SERVICE     | \
                                        SC_MANAGER_ENUMERATE_SERVICE  | \
                                        SC_MANAGER_LOCK               | \
                                        SC_MANAGER_QUERY_LOCK_STATUS  | \
                                        SC_MANAGER_MODIFY_BOOT_CONFIG )

Definition at line 100 of file winsvc.h.

◆ SC_MANAGER_CONNECT

#define SC_MANAGER_CONNECT 0x0001

Definition at line 94 of file winsvc.h.

◆ SC_MANAGER_CREATE_SERVICE

#define SC_MANAGER_CREATE_SERVICE 0x0002

Definition at line 95 of file winsvc.h.

◆ SC_MANAGER_ENUMERATE_SERVICE

#define SC_MANAGER_ENUMERATE_SERVICE 0x0004

Definition at line 96 of file winsvc.h.

◆ SC_MANAGER_LOCK

#define SC_MANAGER_LOCK 0x0008

Definition at line 97 of file winsvc.h.

◆ SC_MANAGER_MODIFY_BOOT_CONFIG

#define SC_MANAGER_MODIFY_BOOT_CONFIG 0x0020

Definition at line 99 of file winsvc.h.

◆ SC_MANAGER_QUERY_LOCK_STATUS

#define SC_MANAGER_QUERY_LOCK_STATUS 0x0010

Definition at line 98 of file winsvc.h.

◆ SERVICE_ACCEPT_HARDWAREPROFILECHANGE

#define SERVICE_ACCEPT_HARDWAREPROFILECHANGE 0x00000020

Definition at line 86 of file winsvc.h.

◆ SERVICE_ACCEPT_NETBINDCHANGE

#define SERVICE_ACCEPT_NETBINDCHANGE 0x00000010

Definition at line 85 of file winsvc.h.

◆ SERVICE_ACCEPT_PARAMCHANGE

#define SERVICE_ACCEPT_PARAMCHANGE 0x00000008

Definition at line 84 of file winsvc.h.

◆ SERVICE_ACCEPT_PAUSE_CONTINUE

#define SERVICE_ACCEPT_PAUSE_CONTINUE 0x00000002

Definition at line 82 of file winsvc.h.

◆ SERVICE_ACCEPT_POWEREVENT

#define SERVICE_ACCEPT_POWEREVENT 0x00000040

Definition at line 87 of file winsvc.h.

◆ SERVICE_ACCEPT_PRESHUTDOWN

#define SERVICE_ACCEPT_PRESHUTDOWN 0x00000100

Definition at line 89 of file winsvc.h.

◆ SERVICE_ACCEPT_SESSIONCHANGE

#define SERVICE_ACCEPT_SESSIONCHANGE 0x00000080

Definition at line 88 of file winsvc.h.

◆ SERVICE_ACCEPT_SHUTDOWN

#define SERVICE_ACCEPT_SHUTDOWN 0x00000004

Definition at line 83 of file winsvc.h.

◆ SERVICE_ACCEPT_STOP

#define SERVICE_ACCEPT_STOP 0x00000001

Definition at line 81 of file winsvc.h.

◆ SERVICE_ACCEPT_TIMECHANGE

#define SERVICE_ACCEPT_TIMECHANGE 0x00000200

Definition at line 90 of file winsvc.h.

◆ SERVICE_ACCEPT_TRIGGEREVENT

#define SERVICE_ACCEPT_TRIGGEREVENT 0x00000400

Definition at line 91 of file winsvc.h.

◆ SERVICE_ACTIVE

#define SERVICE_ACTIVE 0x00000001

Definition at line 50 of file winsvc.h.

◆ SERVICE_ALL_ACCESS

#define SERVICE_ALL_ACCESS

Value:

                                       ( STANDARD_RIGHTS_REQUIRED     | \
                                       SERVICE_QUERY_CONFIG         | \
                                       SERVICE_CHANGE_CONFIG        | \
                                       SERVICE_QUERY_STATUS         | \
                                       SERVICE_ENUMERATE_DEPENDENTS | \
                                       SERVICE_START                | \
                                       SERVICE_STOP                 | \
                                       SERVICE_PAUSE_CONTINUE       | \
                                       SERVICE_INTERROGATE          | \
                                       SERVICE_USER_DEFINED_CONTROL )

Definition at line 118 of file winsvc.h.

◆ SERVICE_CHANGE_CONFIG

#define SERVICE_CHANGE_CONFIG 0x0002

Definition at line 109 of file winsvc.h.

◆ SERVICE_CONFIG_DELAYED_AUTO_START_INFO

#define SERVICE_CONFIG_DELAYED_AUTO_START_INFO 3

Definition at line 290 of file winsvc.h.

◆ SERVICE_CONFIG_DESCRIPTION

#define SERVICE_CONFIG_DESCRIPTION 1

Definition at line 288 of file winsvc.h.

◆ SERVICE_CONFIG_FAILURE_ACTIONS

#define SERVICE_CONFIG_FAILURE_ACTIONS 2

Definition at line 289 of file winsvc.h.

◆ SERVICE_CONFIG_FAILURE_ACTIONS_FLAG

#define SERVICE_CONFIG_FAILURE_ACTIONS_FLAG 4

Definition at line 291 of file winsvc.h.

◆ SERVICE_CONFIG_PRESHUTDOWN_INFO

#define SERVICE_CONFIG_PRESHUTDOWN_INFO 7

Definition at line 294 of file winsvc.h.

◆ SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO

#define SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO 6

Definition at line 293 of file winsvc.h.

◆ SERVICE_CONFIG_SERVICE_SID_INFO

#define SERVICE_CONFIG_SERVICE_SID_INFO 5

Definition at line 292 of file winsvc.h.

◆ SERVICE_CONTINUE_PENDING

#define SERVICE_CONTINUE_PENDING 0x00000005

Definition at line 76 of file winsvc.h.

◆ SERVICE_CONTROL_CONTINUE

#define SERVICE_CONTROL_CONTINUE 0x00000003

Definition at line 57 of file winsvc.h.

◆ SERVICE_CONTROL_DEVICEEVENT

#define SERVICE_CONTROL_DEVICEEVENT 0x0000000B

Definition at line 65 of file winsvc.h.

◆ SERVICE_CONTROL_HARDWAREPROFILECHANGE

#define SERVICE_CONTROL_HARDWAREPROFILECHANGE 0x0000000C

Definition at line 66 of file winsvc.h.

◆ SERVICE_CONTROL_INTERROGATE

#define SERVICE_CONTROL_INTERROGATE 0x00000004

Definition at line 58 of file winsvc.h.

◆ SERVICE_CONTROL_NETBINDADD

#define SERVICE_CONTROL_NETBINDADD 0x00000007

Definition at line 61 of file winsvc.h.

◆ SERVICE_CONTROL_NETBINDDISABLE

#define SERVICE_CONTROL_NETBINDDISABLE 0x0000000A

Definition at line 64 of file winsvc.h.

◆ SERVICE_CONTROL_NETBINDENABLE

#define SERVICE_CONTROL_NETBINDENABLE 0x00000009

Definition at line 63 of file winsvc.h.

◆ SERVICE_CONTROL_NETBINDREMOVE

#define SERVICE_CONTROL_NETBINDREMOVE 0x00000008

Definition at line 62 of file winsvc.h.

◆ SERVICE_CONTROL_PARAMCHANGE

#define SERVICE_CONTROL_PARAMCHANGE 0x00000006

Definition at line 60 of file winsvc.h.

◆ SERVICE_CONTROL_PAUSE

#define SERVICE_CONTROL_PAUSE 0x00000002

Definition at line 56 of file winsvc.h.

◆ SERVICE_CONTROL_POWEREVENT

#define SERVICE_CONTROL_POWEREVENT 0x0000000D

Definition at line 67 of file winsvc.h.

◆ SERVICE_CONTROL_PRESHUTDOWN

#define SERVICE_CONTROL_PRESHUTDOWN 0x0000000F

Definition at line 69 of file winsvc.h.

◆ SERVICE_CONTROL_SESSIONCHANGE

#define SERVICE_CONTROL_SESSIONCHANGE 0x0000000E

Definition at line 68 of file winsvc.h.

◆ SERVICE_CONTROL_SHUTDOWN

#define SERVICE_CONTROL_SHUTDOWN 0x00000005

Definition at line 59 of file winsvc.h.

◆ SERVICE_CONTROL_STOP

#define SERVICE_CONTROL_STOP 0x00000001

Definition at line 55 of file winsvc.h.

◆ SERVICE_ENUMERATE_DEPENDENTS

#define SERVICE_ENUMERATE_DEPENDENTS 0x0008

Definition at line 111 of file winsvc.h.

◆ SERVICE_INACTIVE

#define SERVICE_INACTIVE 0x00000002

Definition at line 51 of file winsvc.h.

◆ SERVICE_INTERROGATE

#define SERVICE_INTERROGATE 0x0080

Definition at line 115 of file winsvc.h.

◆ SERVICE_NO_CHANGE

#define SERVICE_NO_CHANGE 0xffffffff

Definition at line 129 of file winsvc.h.

◆ SERVICE_NOTIFY_CONTINUE_PENDING

#define SERVICE_NOTIFY_CONTINUE_PENDING 0x10

Definition at line 173 of file winsvc.h.

◆ SERVICE_NOTIFY_CREATED

#define SERVICE_NOTIFY_CREATED 0x80

Definition at line 176 of file winsvc.h.

◆ SERVICE_NOTIFY_DELETE_PENDING

#define SERVICE_NOTIFY_DELETE_PENDING 0x200

Definition at line 178 of file winsvc.h.

◆ SERVICE_NOTIFY_DELETED

#define SERVICE_NOTIFY_DELETED 0x100

Definition at line 177 of file winsvc.h.

◆ SERVICE_NOTIFY_PAUSE_PENDING

#define SERVICE_NOTIFY_PAUSE_PENDING 0x20

Definition at line 174 of file winsvc.h.

◆ SERVICE_NOTIFY_PAUSED

#define SERVICE_NOTIFY_PAUSED 0x40

Definition at line 175 of file winsvc.h.

◆ SERVICE_NOTIFY_RUNNING

#define SERVICE_NOTIFY_RUNNING 0x8

Definition at line 172 of file winsvc.h.

◆ SERVICE_NOTIFY_START_PENDING

#define SERVICE_NOTIFY_START_PENDING 0x2

Definition at line 170 of file winsvc.h.

◆ SERVICE_NOTIFY_STATUS_CHANGE

#define SERVICE_NOTIFY_STATUS_CHANGE 2

Definition at line 167 of file winsvc.h.

◆ SERVICE_NOTIFY_STOP_PENDING

#define SERVICE_NOTIFY_STOP_PENDING 0x4

Definition at line 171 of file winsvc.h.

◆ SERVICE_NOTIFY_STOPPED

#define SERVICE_NOTIFY_STOPPED 0x1

Definition at line 169 of file winsvc.h.

◆ SERVICE_PAUSE_CONTINUE

#define SERVICE_PAUSE_CONTINUE 0x0040

Definition at line 114 of file winsvc.h.

◆ SERVICE_PAUSE_PENDING

#define SERVICE_PAUSE_PENDING 0x00000006

Definition at line 77 of file winsvc.h.

◆ SERVICE_PAUSED

#define SERVICE_PAUSED 0x00000007

Definition at line 78 of file winsvc.h.

◆ SERVICE_QUERY_CONFIG

#define SERVICE_QUERY_CONFIG 0x0001

Definition at line 108 of file winsvc.h.

◆ SERVICE_QUERY_STATUS

#define SERVICE_QUERY_STATUS 0x0004

Definition at line 110 of file winsvc.h.

◆ SERVICE_RUNNING

#define SERVICE_RUNNING 0x00000004

Definition at line 75 of file winsvc.h.

◆ SERVICE_RUNS_IN_SYSTEM_PROCESS

#define SERVICE_RUNS_IN_SYSTEM_PROCESS 0x00000001

Definition at line 131 of file winsvc.h.

◆ SERVICE_START

#define SERVICE_START 0x0010

Definition at line 112 of file winsvc.h.

◆ SERVICE_START_PENDING

#define SERVICE_START_PENDING 0x00000002

Definition at line 73 of file winsvc.h.

◆ SERVICE_STATE_ALL

#define SERVICE_STATE_ALL (SERVICE_ACTIVE | SERVICE_INACTIVE)

Definition at line 52 of file winsvc.h.

◆ SERVICE_STOP

#define SERVICE_STOP 0x0020

Definition at line 113 of file winsvc.h.

◆ SERVICE_STOP_PENDING

#define SERVICE_STOP_PENDING 0x00000003

Definition at line 74 of file winsvc.h.

◆ SERVICE_STOPPED

#define SERVICE_STOPPED 0x00000001

Definition at line 72 of file winsvc.h.

◆ SERVICE_USER_DEFINED_CONTROL

#define SERVICE_USER_DEFINED_CONTROL 0x0100

Definition at line 116 of file winsvc.h.

◆ SERVICES_ACTIVE_DATABASE

#define SERVICES_ACTIVE_DATABASE WINELIB_NAME_AW( SERVICES_ACTIVE_DATABASE )

Definition at line 46 of file winsvc.h.

◆ SERVICES_ACTIVE_DATABASEA

#define SERVICES_ACTIVE_DATABASEA "ServicesActive"

Definition at line 35 of file winsvc.h.

◆ SERVICES_FAILED_DATABASE

#define SERVICES_FAILED_DATABASE WINELIB_NAME_AW( SERVICES_FAILED_DATABASE )

Definition at line 47 of file winsvc.h.

◆ SERVICES_FAILED_DATABASEA

#define SERVICES_FAILED_DATABASEA "ServicesFailed"

Definition at line 36 of file winsvc.h.

◆ StartService

#define StartService WINELIB_NAME_AW(StartService)

Definition at line 447 of file winsvc.h.

◆ StartServiceCtrlDispatcher

#define StartServiceCtrlDispatcher WINELIB_NAME_AW(StartServiceCtrlDispatcher)

Definition at line 450 of file winsvc.h.

◆ WINADVAPI

#define WINADVAPI DECLSPEC_IMPORT

Definition at line 30 of file winsvc.h.

Typedef Documentation

◆ ENUM_SERVICE_STATUS_PROCESSA

typedef struct _ENUM_SERVICE_STATUS_PROCESSA ENUM_SERVICE_STATUS_PROCESSA

◆ ENUM_SERVICE_STATUS_PROCESSW

typedef struct _ENUM_SERVICE_STATUS_PROCESSW ENUM_SERVICE_STATUS_PROCESSW

◆ ENUM_SERVICE_STATUSA

typedef struct _ENUM_SERVICE_STATUSA ENUM_SERVICE_STATUSA

◆ ENUM_SERVICE_STATUSW

typedef struct _ENUM_SERVICE_STATUSW ENUM_SERVICE_STATUSW

◆ LPENUM_SERVICE_STATUS_PROCESSA

typedef struct _ENUM_SERVICE_STATUS_PROCESSA * LPENUM_SERVICE_STATUS_PROCESSA

◆ LPENUM_SERVICE_STATUS_PROCESSW

typedef struct _ENUM_SERVICE_STATUS_PROCESSW * LPENUM_SERVICE_STATUS_PROCESSW

◆ LPENUM_SERVICE_STATUSA

typedef struct _ENUM_SERVICE_STATUSA * LPENUM_SERVICE_STATUSA

◆ LPENUM_SERVICE_STATUSW

typedef struct _ENUM_SERVICE_STATUSW * LPENUM_SERVICE_STATUSW

◆ LPHANDLER_FUNCTION

typedef VOID(WINAPI * LPHANDLER_FUNCTION) (DWORD)

Definition at line 384 of file winsvc.h.

◆ LPHANDLER_FUNCTION_EX

typedef DWORD(WINAPI * LPHANDLER_FUNCTION_EX) (DWORD, DWORD, LPVOID, LPVOID)

Definition at line 385 of file winsvc.h.

◆ LPQUERY_SERVICE_CONFIGA

typedef struct _QUERY_SERVICE_CONFIGA * LPQUERY_SERVICE_CONFIGA

◆ LPQUERY_SERVICE_CONFIGW

typedef struct _QUERY_SERVICE_CONFIGW * LPQUERY_SERVICE_CONFIGW

◆ LPQUERY_SERVICE_LOCK_STATUSA

typedef struct _QUERY_SERVICE_LOCK_STATUSA * LPQUERY_SERVICE_LOCK_STATUSA

◆ LPQUERY_SERVICE_LOCK_STATUSW

typedef struct _QUERY_SERVICE_LOCK_STATUSW * LPQUERY_SERVICE_LOCK_STATUSW

◆ LPSC_ACTION

typedef struct _SC_ACTION* LPSC_ACTION

◆ LPSC_HANDLE

typedef SC_HANDLE* LPSC_HANDLE

Definition at line 136 of file winsvc.h.

◆ LPSERVICE_DELAYED_AUTO_START_INFO

typedef struct _SERVICE_DELAYED_AUTO_START_INFO* LPSERVICE_DELAYED_AUTO_START_INFO

◆ LPSERVICE_DESCRIPTIONA

typedef struct _SERVICE_DESCRIPTIONA* LPSERVICE_DESCRIPTIONA

◆ LPSERVICE_DESCRIPTIONW

typedef struct _SERVICE_DESCRIPTIONW* LPSERVICE_DESCRIPTIONW

◆ LPSERVICE_FAILURE_ACTIONS_FLAG

typedef struct _SERVICE_FAILURE_ACTIONS_FLAG* LPSERVICE_FAILURE_ACTIONS_FLAG

◆ LPSERVICE_FAILURE_ACTIONSA

typedef struct _SERVICE_FAILURE_ACTIONSA* LPSERVICE_FAILURE_ACTIONSA

◆ LPSERVICE_FAILURE_ACTIONSW

typedef struct _SERVICE_FAILURE_ACTIONSW* LPSERVICE_FAILURE_ACTIONSW

◆ LPSERVICE_MAIN_FUNCTIONA

typedef VOID(CALLBACK * LPSERVICE_MAIN_FUNCTIONA) (DWORD, LPSTR *)

Definition at line 208 of file winsvc.h.

◆ LPSERVICE_MAIN_FUNCTIONW

typedef VOID(CALLBACK * LPSERVICE_MAIN_FUNCTIONW) (DWORD, LPWSTR *)

Definition at line 209 of file winsvc.h.

◆ LPSERVICE_PRESHUTDOWN_INFO

typedef struct _SERVICE_PRESHUTDOWN_INFO* LPSERVICE_PRESHUTDOWN_INFO

◆ LPSERVICE_REQUIRED_PRIVILEGES_INFOA

typedef struct _SERVICE_REQUIRED_PRIVILEGES_INFOA* LPSERVICE_REQUIRED_PRIVILEGES_INFOA

◆ LPSERVICE_REQUIRED_PRIVILEGES_INFOW

typedef struct _SERVICE_REQUIRED_PRIVILEGES_INFOW* LPSERVICE_REQUIRED_PRIVILEGES_INFOW

◆ LPSERVICE_SID_INFO

typedef struct _SERVICE_SID_INFO* LPSERVICE_SID_INFO

◆ LPSERVICE_STATUS

typedef struct _SERVICE_STATUS * LPSERVICE_STATUS

◆ LPSERVICE_STATUS_PROCESS

typedef struct _SERVICE_STATUS_PROCESS * LPSERVICE_STATUS_PROCESS

◆ LPSERVICE_TABLE_ENTRYA

typedef struct _SERVICE_TABLE_ENTRYA * LPSERVICE_TABLE_ENTRYA

◆ LPSERVICE_TABLE_ENTRYW

typedef struct _SERVICE_TABLE_ENTRYW * LPSERVICE_TABLE_ENTRYW

◆ PFN_SC_NOTIFY_CALLBACK

typedef void(CALLBACK * PFN_SC_NOTIFY_CALLBACK) (void *)

Definition at line 180 of file winsvc.h.

◆ QUERY_SERVICE_CONFIGA

typedef struct _QUERY_SERVICE_CONFIGA QUERY_SERVICE_CONFIGA

◆ QUERY_SERVICE_CONFIGW

typedef struct _QUERY_SERVICE_CONFIGW QUERY_SERVICE_CONFIGW

◆ QUERY_SERVICE_LOCK_STATUSA

typedef struct _QUERY_SERVICE_LOCK_STATUSA QUERY_SERVICE_LOCK_STATUSA

◆ QUERY_SERVICE_LOCK_STATUSW

typedef struct _QUERY_SERVICE_LOCK_STATUSW QUERY_SERVICE_LOCK_STATUSW

◆ SC_ACTION

typedef struct _SC_ACTION SC_ACTION

◆ SC_ACTION_TYPE

typedef enum _SC_ACTION_TYPE SC_ACTION_TYPE

◆ SC_ENUM_TYPE

typedef enum _SC_ENUM_TYPE SC_ENUM_TYPE

◆ SC_LOCK

typedef LPVOID SC_LOCK

Definition at line 138 of file winsvc.h.

◆ SC_STATUS_TYPE

typedef enum _SC_STATUS_TYPE SC_STATUS_TYPE

◆ SERVICE_DELAYED_AUTO_START_INFO

typedef struct _SERVICE_DELAYED_AUTO_START_INFO SERVICE_DELAYED_AUTO_START_INFO

◆ SERVICE_DESCRIPTIONA

typedef struct _SERVICE_DESCRIPTIONA SERVICE_DESCRIPTIONA

◆ SERVICE_DESCRIPTIONW

typedef struct _SERVICE_DESCRIPTIONW SERVICE_DESCRIPTIONW

◆ SERVICE_FAILURE_ACTIONS_FLAG

typedef struct _SERVICE_FAILURE_ACTIONS_FLAG SERVICE_FAILURE_ACTIONS_FLAG

◆ SERVICE_FAILURE_ACTIONSA

typedef struct _SERVICE_FAILURE_ACTIONSA SERVICE_FAILURE_ACTIONSA

◆ SERVICE_FAILURE_ACTIONSW

typedef struct _SERVICE_FAILURE_ACTIONSW SERVICE_FAILURE_ACTIONSW

◆ SERVICE_NOTIFY_2A

typedef struct _SERVICE_NOTIFY_2A SERVICE_NOTIFY_2A

◆ SERVICE_NOTIFY_2W

typedef struct _SERVICE_NOTIFY_2W SERVICE_NOTIFY_2W

◆ SERVICE_NOTIFYA

typedef struct _SERVICE_NOTIFY_2A SERVICE_NOTIFYA

◆ SERVICE_NOTIFYW

typedef struct _SERVICE_NOTIFY_2W SERVICE_NOTIFYW

◆ SERVICE_PRESHUTDOWN_INFO

typedef struct _SERVICE_PRESHUTDOWN_INFO SERVICE_PRESHUTDOWN_INFO

◆ SERVICE_REQUIRED_PRIVILEGES_INFOA

typedef struct _SERVICE_REQUIRED_PRIVILEGES_INFOA SERVICE_REQUIRED_PRIVILEGES_INFOA

◆ SERVICE_REQUIRED_PRIVILEGES_INFOW

typedef struct _SERVICE_REQUIRED_PRIVILEGES_INFOW SERVICE_REQUIRED_PRIVILEGES_INFOW

◆ SERVICE_SID_INFO

typedef struct _SERVICE_SID_INFO SERVICE_SID_INFO

◆ SERVICE_STATUS

typedef struct _SERVICE_STATUS SERVICE_STATUS

◆ SERVICE_STATUS_PROCESS

typedef struct _SERVICE_STATUS_PROCESS SERVICE_STATUS_PROCESS

◆ SERVICE_TABLE_ENTRYA

typedef struct _SERVICE_TABLE_ENTRYA SERVICE_TABLE_ENTRYA

◆ SERVICE_TABLE_ENTRYW

typedef struct _SERVICE_TABLE_ENTRYW SERVICE_TABLE_ENTRYW

Enumeration Type Documentation

◆ _SC_ACTION_TYPE

enum _SC_ACTION_TYPE

Enumerator
SC_ACTION_NONE
SC_ACTION_RESTART
SC_ACTION_REBOOT
SC_ACTION_RUN_COMMAND
SC_ACTION_NONE
SC_ACTION_RESTART
SC_ACTION_REBOOT
SC_ACTION_RUN_COMMAND
SC_ACTION_NONE
SC_ACTION_RESTART
SC_ACTION_REBOOT
SC_ACTION_RUN_COMMAND

Definition at line 308 of file winsvc.h.

                             {
    SC_ACTION_NONE        = 0,
    SC_ACTION_RESTART     = 1,
    SC_ACTION_REBOOT      = 2,
    SC_ACTION_RUN_COMMAND = 3
} SC_ACTION_TYPE;

◆ _SC_ENUM_TYPE

enum _SC_ENUM_TYPE

Enumerator
SC_ENUM_PROCESS_INFO
SC_ENUM_PROCESS_INFO
SC_ENUM_PROCESS_INFO

Definition at line 259 of file winsvc.h.

                           {
    SC_ENUM_PROCESS_INFO      = 0
} SC_ENUM_TYPE;

◆ _SC_STATUS_TYPE

enum _SC_STATUS_TYPE

Enumerator
SC_STATUS_PROCESS_INFO
SC_STATUS_PROCESS_INFO
SC_STATUS_PROCESS_INFO

Definition at line 202 of file winsvc.h.

                             {
  SC_STATUS_PROCESS_INFO      = 0
} SC_STATUS_TYPE;

Function Documentation

◆ ChangeServiceConfig2A()

WINADVAPI 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()

WINADVAPI 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()

WINADVAPI 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()

WINADVAPI 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()

WINADVAPI 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(), StartNetworkServices(), 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_enum_svc_ex(), test_EventLog(), 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(), test_wow64(), ThemeWaitForServiceReady(), TV1_AddDependantsToTree(), TV2_GetDependants(), TV2_HasDependantServices(), uninstallService(), UnregisterDriver(), UpdateServiceStatus(), VfdConfigDriver(), VfdGetDriverConfig(), VfdGetDriverState(), VfdInstallDriver(), VfdRemoveDriver(), VfdStartDriver(), VfdStopDriver(), and WahDisableNonIFSHandleSupport().

◆ ControlService()

WINADVAPI 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().

◆ CreateServiceA()

WINADVAPI 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(), test_start_stop(), and test_wow64().

◆ CreateServiceW()

WINADVAPI 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().

◆ DECLARE_HANDLE() [1/2]

DECLARE_HANDLE ( SC_HANDLE )

◆ DECLARE_HANDLE() [2/2]

DECLARE_HANDLE ( SERVICE_STATUS_HANDLE )

◆ DeleteService()

WINADVAPI 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(), test_wow64(), uninstallService(), UnregisterDriver(), and VfdRemoveDriver().

◆ EnumDependentServicesA()

WINADVAPI 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()

WINADVAPI 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().

◆ EnumServicesStatusA()

WINADVAPI 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()

WINADVAPI 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()

WINADVAPI 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()

WINADVAPI 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(), test_enum_svc(), and test_enum_svc_ex().

◆ GetServiceDisplayNameA()

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

Definition at line 1665 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_get_displayname(), test_get_servicekeyname(), and test_open_svc().

◆ GetServiceDisplayNameW()

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

Definition at line 1723 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()

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

Definition at line 1786 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_create_delete_svc(), and test_get_servicekeyname().

◆ GetServiceKeyNameW()

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

Definition at line 1845 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().

◆ LockServiceDatabase()

WINADVAPI SC_LOCK WINAPI LockServiceDatabase ( SC_HANDLE hSCManager )

Definition at line 1997 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()

WINADVAPI BOOL WINAPI NotifyBootConfigStatus ( BOOL BootAcceptable )

Definition at line 3094 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().

◆ NotifyServiceStatusChangeW()

WINADVAPI DWORD WINAPI NotifyServiceStatusChangeW	(	SC_HANDLE	,
		DWORD	,
		SERVICE_NOTIFYW *
	)

◆ OpenSCManagerA()

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

Definition at line 2063 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_enum_svc_ex(), test_EventLog(), 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(), test_start_stop_services(), and test_wow64().

◆ OpenSCManagerW()

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

Definition at line 2107 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(), StartNetworkServices(), 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()

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

Definition at line 2151 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_EventLog(), 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()

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

Definition at line 2199 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(), StartNetworkServices(), 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()

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

Definition at line 2413 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()

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

Definition at line 2530 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()

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

Definition at line 2247 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_EventLog(), and test_sequence().

◆ QueryServiceConfigW()

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

Definition at line 2330 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()

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

Definition at line 2647 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()

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

Definition at line 2709 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()

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

Definition at line 2771 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()

WINADVAPI BOOL WINAPI QueryServiceStatus	(	SC_HANDLE	hService,
		LPSERVICE_STATUS	lpServiceStatus
	)

Definition at line 2884 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()

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

Definition at line 2926 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_EventLog(), test_no_stop(), test_service(), ThemeWaitForServiceReady(), UpdateServiceStatus(), WaitForService(), and WaitService().

◆ RegisterServiceCtrlHandlerA()

WINADVAPI SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerA	(	LPCSTR	lpServiceName,
		LPHANDLER_FUNCTION	lpHandlerProc
	)

Definition at line 729 of file sctrl.c.

{
    ANSI_STRING ServiceNameA;
    UNICODE_STRING ServiceNameU;
    SERVICE_STATUS_HANDLE hServiceStatus;
 
    TRACE("RegisterServiceCtrlHandlerA(%s %p)\n",
          debugstr_a(lpServiceName), lpHandlerProc);
 
    RtlInitAnsiString(&ServiceNameA, lpServiceName);
    if (!NT_SUCCESS(RtlAnsiStringToUnicodeString(&ServiceNameU, &ServiceNameA, TRUE)))
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return NULL;
    }
 
    hServiceStatus = RegisterServiceCtrlHandlerW(ServiceNameU.Buffer,
                                                 lpHandlerProc);
 
    RtlFreeUnicodeString(&ServiceNameU);
 
    return hServiceStatus;
}

Referenced by ServiceMain().

◆ RegisterServiceCtrlHandlerExA()

WINADVAPI SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerExA	(	LPCSTR	lpServiceName,
		LPHANDLER_FUNCTION_EX	lpHandlerProc,
		LPVOID	lpContext
	)

Definition at line 797 of file sctrl.c.

{
    ANSI_STRING ServiceNameA;
    UNICODE_STRING ServiceNameU;
    SERVICE_STATUS_HANDLE hServiceStatus;
 
    TRACE("RegisterServiceCtrlHandlerExA(%s %p %p)\n",
          debugstr_a(lpServiceName), lpHandlerProc, lpContext);
 
    RtlInitAnsiString(&ServiceNameA, lpServiceName);
    if (!NT_SUCCESS(RtlAnsiStringToUnicodeString(&ServiceNameU, &ServiceNameA, TRUE)))
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return NULL;
    }
 
    hServiceStatus = RegisterServiceCtrlHandlerExW(ServiceNameU.Buffer,
                                                   lpHandlerProc,
                                                   lpContext);
 
    RtlFreeUnicodeString(&ServiceNameU);
 
    return hServiceStatus;
}

Referenced by service_main().

◆ RegisterServiceCtrlHandlerExW()

WINADVAPI SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerExW	(	LPCWSTR	lpServiceName,
		LPHANDLER_FUNCTION_EX	lpHandlerProc,
		LPVOID	lpContext
	)

Definition at line 831 of file sctrl.c.

{
    PACTIVE_SERVICE Service;
 
    TRACE("RegisterServiceCtrlHandlerExW(%s %p %p)\n",
          debugstr_w(lpServiceName), lpHandlerProc, lpContext);
 
    Service = ScLookupServiceByServiceName(lpServiceName);
    if (Service == NULL)
    {
        SetLastError(ERROR_SERVICE_NOT_IN_EXE);
        return NULL;
    }
 
    if (!lpHandlerProc)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    Service->HandlerFunction = NULL;
    Service->HandlerFunctionEx = lpHandlerProc;
    Service->HandlerContext = lpContext;
 
    TRACE("RegisterServiceCtrlHandlerEx returning %p\n", Service->hServiceStatus);
 
    return Service->hServiceStatus;
}

Referenced by _ServiceMain(), NlNetlogonMain(), RegisterServiceCtrlHandlerExA(), SchedServiceMain(), serv_main(), ServiceMain(), SvcEntry_Seclogon(), and ThemeServiceMain().

◆ RegisterServiceCtrlHandlerW()

WINADVAPI SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerW	(	LPCWSTR	lpServiceName,
		LPHANDLER_FUNCTION	lpHandlerProc
	)

Definition at line 761 of file sctrl.c.

{
    PACTIVE_SERVICE Service;
 
    TRACE("RegisterServiceCtrlHandlerW(%s %p)\n",
          debugstr_w(lpServiceName), lpHandlerProc);
 
    Service = ScLookupServiceByServiceName(lpServiceName);
    if (Service == NULL)
    {
        SetLastError(ERROR_SERVICE_NOT_IN_EXE);
        return NULL;
    }
 
    if (!lpHandlerProc)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    Service->HandlerFunction = lpHandlerProc;
    Service->HandlerFunctionEx = NULL;
 
    TRACE("RegisterServiceCtrlHandler returning %p\n", Service->hServiceStatus);
 
    return Service->hServiceStatus;
}

Referenced by AbortSvchostService(), RegisterServiceCtrlHandlerA(), SamSsServiceMain(), service_main(), service_main_common(), and W32TmServiceMain().

◆ SetServiceObjectSecurity()

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

Definition at line 2813 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().

◆ SetServiceStatus()

WINADVAPI BOOL WINAPI SetServiceStatus	(	SERVICE_STATUS_HANDLE	hServiceStatus,
		LPSERVICE_STATUS	lpServiceStatus
	)

Definition at line 1016 of file sctrl.c.

{
    DWORD dwError;
 
    TRACE("SetServiceStatus(%lu %p)\n",
          hServiceStatus, lpServiceStatus);
 
    RpcTryExcept
    {
        dwError = RSetServiceStatus((RPC_SERVICE_STATUS_HANDLE)hServiceStatus,
                                    lpServiceStatus);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (dwError != ERROR_SUCCESS)
    {
        ERR("RSetServiceStatus() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }
 
    TRACE("SetServiceStatus() done\n");
 
    return TRUE;
}

Referenced by _ServiceMain(), _UpdateServiceStatus(), AbortSvchostService(), ControlHandler(), no_stop_handler(), no_stop_main(), report_service_status(), ReportStatusToSCMgr(), SamSsServiceMain(), serv_main(), ServerCtrlHandler(), service_handler(), service_main(), service_main_common(), ServiceControlHandler(), ServiceControlHandlerEx(), ServiceMain(), UpdateSCMStatus(), UpdateServiceStatus(), UpdateStatus(), and W32TmServiceMain().

◆ StartServiceA()

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

Definition at line 2981 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(), test_wow64(), and try_start_stop().

◆ StartServiceCtrlDispatcherA()

WINADVAPI BOOL WINAPI StartServiceCtrlDispatcherA ( const SERVICE_TABLE_ENTRYA * lpServiceStartTable )

Definition at line 1054 of file sctrl.c.

{
    ULONG i;
    HANDLE hPipe;
    DWORD dwError;
    PSCM_CONTROL_PACKET ControlPacket;
    DWORD dwBufSize;
    BOOL bRet = TRUE;
 
    TRACE("StartServiceCtrlDispatcherA(%p)\n",
          lpServiceStartTable);
 
    i = 0;
    while (lpServiceStartTable[i].lpServiceProc != NULL)
    {
        i++;
    }
 
    dwActiveServiceCount = i;
 
    /* Allocate the service table */
    lpActiveServices = RtlAllocateHeap(RtlGetProcessHeap(),
                                       HEAP_ZERO_MEMORY,
                                       dwActiveServiceCount * sizeof(ACTIVE_SERVICE));
    if (lpActiveServices == NULL)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    /* Copy service names and start procedure */
    for (i = 0; i < dwActiveServiceCount; i++)
    {
        RtlCreateUnicodeStringFromAsciiz(&lpActiveServices[i].ServiceName,
                                         lpServiceStartTable[i].lpServiceName);
        lpActiveServices[i].ServiceMain.A = lpServiceStartTable[i].lpServiceProc;
        lpActiveServices[i].hServiceStatus = NULL;
        lpActiveServices[i].bUnicode = FALSE;
        lpActiveServices[i].bOwnProcess = FALSE;
    }
 
    /* Connect to the SCM */
    dwError = ScConnectControlPipe(&hPipe);
    if (dwError != ERROR_SUCCESS)
    {
        bRet = FALSE;
        goto done;
    }
 
    dwBufSize = sizeof(SCM_CONTROL_PACKET) +
                (MAX_SERVICE_NAME_LENGTH + 1) * sizeof(WCHAR);
 
    ControlPacket = RtlAllocateHeap(RtlGetProcessHeap(),
                                    HEAP_ZERO_MEMORY,
                                    dwBufSize);
    if (ControlPacket == NULL)
    {
        dwError = ERROR_NOT_ENOUGH_MEMORY;
        bRet = FALSE;
        goto done;
    }
 
    ScCreateStatusBinding();
 
    /* Call the dispatcher loop */
    ScServiceDispatcher(hPipe, ControlPacket, dwBufSize);
 
 
    ScDestroyStatusBinding();
 
    /* Close the connection */
    CloseHandle(hPipe);
 
    /* Free the control packet */
    RtlFreeHeap(RtlGetProcessHeap(), 0, ControlPacket);
 
done:
    /* Free the service table */
    for (i = 0; i < dwActiveServiceCount; i++)
    {
        RtlFreeUnicodeString(&lpActiveServices[i].ServiceName);
    }
    RtlFreeHeap(RtlGetProcessHeap(), 0, lpActiveServices);
    lpActiveServices = NULL;
    dwActiveServiceCount = 0;
 
    if (!bRet)
        SetLastError(dwError);
 
    return bRet;
}

Referenced by DoService(), run_service(), service_process(), and START_TEST().

◆ StartServiceCtrlDispatcherW()

WINADVAPI BOOL WINAPI StartServiceCtrlDispatcherW ( const SERVICE_TABLE_ENTRYW * lpServiceStartTable )

Definition at line 1153 of file sctrl.c.

{
    ULONG i;
    HANDLE hPipe;
    DWORD dwError;
    PSCM_CONTROL_PACKET ControlPacket;
    DWORD dwBufSize;
    BOOL bRet = TRUE;
 
    TRACE("StartServiceCtrlDispatcherW(%p)\n",
          lpServiceStartTable);
 
    i = 0;
    while (lpServiceStartTable[i].lpServiceProc != NULL)
    {
        i++;
    }
 
    dwActiveServiceCount = i;
 
    /* Allocate the service table */
    lpActiveServices = RtlAllocateHeap(RtlGetProcessHeap(),
                                       HEAP_ZERO_MEMORY,
                                       dwActiveServiceCount * sizeof(ACTIVE_SERVICE));
    if (lpActiveServices == NULL)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    /* Copy service names and start procedure */
    for (i = 0; i < dwActiveServiceCount; i++)
    {
        RtlCreateUnicodeString(&lpActiveServices[i].ServiceName,
                               lpServiceStartTable[i].lpServiceName);
        lpActiveServices[i].ServiceMain.W = lpServiceStartTable[i].lpServiceProc;
        lpActiveServices[i].hServiceStatus = NULL;
        lpActiveServices[i].bUnicode = TRUE;
        lpActiveServices[i].bOwnProcess = FALSE;
    }
 
    /* Connect to the SCM */
    dwError = ScConnectControlPipe(&hPipe);
    if (dwError != ERROR_SUCCESS)
    {
        bRet = FALSE;
        goto done;
    }
 
    dwBufSize = sizeof(SCM_CONTROL_PACKET) +
                (MAX_SERVICE_NAME_LENGTH + 1) * sizeof(WCHAR);
 
    ControlPacket = RtlAllocateHeap(RtlGetProcessHeap(),
                                    HEAP_ZERO_MEMORY,
                                    dwBufSize);
    if (ControlPacket == NULL)
    {
        dwError = ERROR_NOT_ENOUGH_MEMORY;
        bRet = FALSE;
        goto done;
    }
 
    ScCreateStatusBinding();
 
    /* Call the dispatcher loop */
    ScServiceDispatcher(hPipe, ControlPacket, dwBufSize);
 
    ScDestroyStatusBinding();
 
    /* Close the connection */
    CloseHandle(hPipe);
 
    /* Free the control packet */
    RtlFreeHeap(RtlGetProcessHeap(), 0, ControlPacket);
 
done:
    /* Free the service table */
    for (i = 0; i < dwActiveServiceCount; i++)
    {
        RtlFreeUnicodeString(&lpActiveServices[i].ServiceName);
    }
    RtlFreeHeap(RtlGetProcessHeap(), 0, lpActiveServices);
    lpActiveServices = NULL;
    dwActiveServiceCount = 0;
 
    if (!bRet)
        SetLastError(dwError);
 
    return bRet;
}

Referenced by _tmain(), DispatcherThread(), main(), service_process(), start_service(), START_TEST(), wmain(), and wmainCRTStartup().

◆ StartServiceW()

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

Definition at line 3019 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().

◆ UnlockServiceDatabase()

WINADVAPI BOOL WINAPI UnlockServiceDatabase ( SC_LOCK ScLock )

Definition at line 3057 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;
}