ReactOS  0.4.15-dev-2964-ge2a8585
scm.c File Reference
#include <advapi32.h>
Include dependency graph for scm.c:

Go to the source code of this file.

Functions

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

Function Documentation

◆ ChangeServiceConfig2A()

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

Definition at line 247 of file scm.c.

250 {
252  DWORD dwError;
253 
254  TRACE("ChangeServiceConfig2A(%p %lu %p)\n",
255  hService, dwInfoLevel, lpInfo);
256 
257  if (lpInfo == NULL) return TRUE;
258 
259  /* Fill relevant field of the Info structure */
260  Info.dwInfoLevel = dwInfoLevel;
261  switch (dwInfoLevel)
262  {
264  Info.psd = lpInfo;
265  break;
266 
268  Info.psfa = lpInfo;
269  break;
270 
271  default:
272  WARN("Unknown info level 0x%lx\n", dwInfoLevel);
274  return FALSE;
275  }
276 
278  {
279  dwError = RChangeServiceConfig2A((SC_RPC_HANDLE)hService,
280  Info);
281  }
283  {
285  }
286  RpcEndExcept;
287 
288  if (dwError != ERROR_SUCCESS)
289  {
290  TRACE("RChangeServiceConfig2A() failed (Error %lu)\n", dwError);
291  SetLastError(dwError);
292  return FALSE;
293  }
294 
295  return TRUE;
296 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
#define WARN(fmt,...)
Definition: debug.h:112
#define SERVICE_CONFIG_DESCRIPTION
Definition: winsvc.h:65
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:683
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
#define SERVICE_CONFIG_FAILURE_ACTIONS
Definition: winsvc.h:66
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
_In_ DWORD dwInfoLevel
Definition: winsvc.h:422
#define NULL
Definition: types.h:112
DWORD WINAPI RChangeServiceConfig2A(SC_RPC_HANDLE hService, SC_RPC_CONFIG_INFOA Info)
Definition: rpcserver.c:5019
#define RpcExcept(expr)
Definition: rpc.h:127

◆ ChangeServiceConfig2W()

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

Definition at line 305 of file scm.c.

308 {
310  DWORD dwError;
311 
312  TRACE("ChangeServiceConfig2W(%p %lu %p)\n",
313  hService, dwInfoLevel, lpInfo);
314 
315  if (lpInfo == NULL) return TRUE;
316 
317  /* Fill relevant field of the Info structure */
318  Info.dwInfoLevel = dwInfoLevel;
319  switch (dwInfoLevel)
320  {
322  Info.psd = lpInfo;
323  break;
324 
326  Info.psfa = lpInfo;
327  break;
328 
329  default:
330  WARN("Unknown info level 0x%lx\n", dwInfoLevel);
332  return FALSE;
333  }
334 
336  {
337  dwError = RChangeServiceConfig2W((SC_RPC_HANDLE)hService,
338  Info);
339  }
341  {
343  }
344  RpcEndExcept;
345 
346  if (dwError != ERROR_SUCCESS)
347  {
348  TRACE("RChangeServiceConfig2W() failed (Error %lu)\n", dwError);
349  SetLastError(dwError);
350  return FALSE;
351  }
352 
353  return TRUE;
354 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
#define WARN(fmt,...)
Definition: debug.h:112
#define SERVICE_CONFIG_DESCRIPTION
Definition: winsvc.h:65
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:683
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
#define SERVICE_CONFIG_FAILURE_ACTIONS
Definition: winsvc.h:66
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
_In_ DWORD dwInfoLevel
Definition: winsvc.h:422
DWORD WINAPI RChangeServiceConfig2W(SC_RPC_HANDLE hService, SC_RPC_CONFIG_INFOW Info)
Definition: rpcserver.c:5420
#define NULL
Definition: types.h:112
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by ITERATE_InstallService(), and SetServiceDescription().

◆ ChangeServiceConfigA()

BOOL WINAPI ChangeServiceConfigA ( SC_HANDLE  hService,
DWORD  dwServiceType,
DWORD  dwStartType,
DWORD  dwErrorControl,
LPCSTR  lpBinaryPathName,
LPCSTR  lpLoadOrderGroup,
LPDWORD  lpdwTagId,
LPCSTR  lpDependencies,
LPCSTR  lpServiceStartName,
LPCSTR  lpPassword,
LPCSTR  lpDisplayName 
)

Definition at line 363 of file scm.c.

374 {
375  DWORD dwError;
376  DWORD dwDependenciesLength = 0;
377  SIZE_T cchLength;
378  LPCSTR lpStr;
379  DWORD dwPasswordSize = 0;
380  LPWSTR lpPasswordW = NULL;
381  LPBYTE lpEncryptedPassword = NULL;
382 
383  TRACE("ChangeServiceConfigA(%p %lu %lu %lu %s %s %p %s %s %s %s)\n",
384  hService, dwServiceType, dwStartType, dwErrorControl, debugstr_a(lpBinaryPathName),
385  debugstr_a(lpLoadOrderGroup), lpdwTagId, debugstr_a(lpDependencies),
386  debugstr_a(lpServiceStartName), debugstr_a(lpPassword), debugstr_a(lpDisplayName));
387 
388  /* Calculate the Dependencies length*/
389  if (lpDependencies != NULL)
390  {
391  lpStr = lpDependencies;
392  while (*lpStr)
393  {
394  cchLength = strlen(lpStr) + 1;
395  dwDependenciesLength += (DWORD)cchLength;
396  lpStr = lpStr + cchLength;
397  }
398  dwDependenciesLength++;
399  }
400 
401  if (lpPassword != NULL)
402  {
403  /* Convert the password to unicode */
404  lpPasswordW = HeapAlloc(GetProcessHeap(),
406  (strlen(lpPassword) + 1) * sizeof(WCHAR));
407  if (lpPasswordW == NULL)
408  {
410  return FALSE;
411  }
412 
414  0,
415  lpPassword,
416  -1,
417  lpPasswordW,
418  (int)(strlen(lpPassword) + 1));
419 
420  /* Encrypt the unicode password */
421  dwError = ScmEncryptPassword(hService,
422  lpPasswordW,
423  &lpEncryptedPassword,
424  &dwPasswordSize);
425  if (dwError != ERROR_SUCCESS)
426  goto done;
427  }
428 
430  {
431  dwError = RChangeServiceConfigA((SC_RPC_HANDLE)hService,
432  dwServiceType,
433  dwStartType,
434  dwErrorControl,
435  (LPSTR)lpBinaryPathName,
436  (LPSTR)lpLoadOrderGroup,
437  lpdwTagId,
438  (LPBYTE)lpDependencies,
439  dwDependenciesLength,
440  (LPSTR)lpServiceStartName,
441  lpEncryptedPassword,
442  dwPasswordSize,
444  }
446  {
448  }
449  RpcEndExcept;
450 
451 done:
452  if (lpPasswordW != NULL)
453  {
454  /* Wipe and release the password buffers */
455  SecureZeroMemory(lpPasswordW, (wcslen(lpPasswordW) + 1) * sizeof(WCHAR));
456  HeapFree(GetProcessHeap(), 0, lpPasswordW);
457 
458  if (lpEncryptedPassword != NULL)
459  {
460  SecureZeroMemory(lpEncryptedPassword, dwPasswordSize);
461  HeapFree(GetProcessHeap(), 0, lpEncryptedPassword);
462  }
463  }
464 
465  if (dwError != ERROR_SUCCESS)
466  {
467  TRACE("RChangeServiceConfigA() failed (Error %lu)\n", dwError);
468  SetLastError(dwError);
469  return FALSE;
470  }
471 
472  return TRUE;
473 }
DWORD WINAPI RChangeServiceConfigA(SC_RPC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPSTR lpBinaryPathName, LPSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPBYTE lpDependencies, DWORD dwDependSize, LPSTR lpServiceStartName, LPBYTE lpPassword, DWORD dwPwSize, LPSTR lpDisplayName)
Definition: rpcserver.c:3461
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define TRUE
Definition: types.h:120
#define SecureZeroMemory
Definition: winbase.h:1665
#define CP_ACP
Definition: compat.h:109
static DWORD ScmEncryptPassword(_In_ PVOID ContextHandle, _In_ PCWSTR pClearTextPassword, _Out_ PBYTE *pEncryptedPassword, _Out_ PDWORD pEncryptedPasswordSize)
Definition: scm.c:173
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
char * LPSTR
Definition: xmlstorage.h:182
#define DWORD
Definition: nt_native.h:44
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
const char * LPCSTR
Definition: xmlstorage.h:183
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:595
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define debugstr_a
Definition: kernel32.h:31
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
ULONG_PTR SIZE_T
Definition: typedefs.h:80
#define NULL
Definition: types.h:112
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define MultiByteToWideChar
Definition: compat.h:110
WCHAR * LPWSTR
Definition: xmlstorage.h:184
_In_ LPCSTR _Out_writes_to_opt_ cchDisplayName LPSTR lpDisplayName
Definition: winbase.h:2769
#define HeapFree(x, y, z)
Definition: compat.h:594
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by test_sequence(), and test_start_stop().

◆ ChangeServiceConfigW()

BOOL WINAPI ChangeServiceConfigW ( SC_HANDLE  hService,
DWORD  dwServiceType,
DWORD  dwStartType,
DWORD  dwErrorControl,
LPCWSTR  lpBinaryPathName,
LPCWSTR  lpLoadOrderGroup,
LPDWORD  lpdwTagId,
LPCWSTR  lpDependencies,
LPCWSTR  lpServiceStartName,
LPCWSTR  lpPassword,
LPCWSTR  lpDisplayName 
)

Definition at line 482 of file scm.c.

493 {
494  DWORD dwError;
495  DWORD dwDependenciesLength = 0;
496  SIZE_T cchLength;
497  LPCWSTR lpStr;
498  DWORD dwPasswordSize = 0;
499  LPBYTE lpEncryptedPassword = NULL;
500 
501  TRACE("ChangeServiceConfigW(%p %lu %lu %lu %s %s %p %s %s %s %s)\n",
502  hService, dwServiceType, dwStartType, dwErrorControl, debugstr_w(lpBinaryPathName),
503  debugstr_w(lpLoadOrderGroup), lpdwTagId, debugstr_w(lpDependencies),
504  debugstr_w(lpServiceStartName), debugstr_w(lpPassword), debugstr_w(lpDisplayName));
505 
506  /* Calculate the Dependencies length*/
507  if (lpDependencies != NULL)
508  {
509  lpStr = lpDependencies;
510  while (*lpStr)
511  {
512  cchLength = wcslen(lpStr) + 1;
513  dwDependenciesLength += (DWORD)cchLength;
514  lpStr = lpStr + cchLength;
515  }
516  dwDependenciesLength++;
517  dwDependenciesLength *= sizeof(WCHAR);
518  }
519 
520  if (lpPassword != NULL)
521  {
522  dwError = ScmEncryptPassword(hService,
523  lpPassword,
524  &lpEncryptedPassword,
525  &dwPasswordSize);
526  if (dwError != ERROR_SUCCESS)
527  {
528  ERR("ScmEncryptPassword failed (Error %lu)\n", dwError);
529  goto done;
530  }
531  }
532 
534  {
535  dwError = RChangeServiceConfigW((SC_RPC_HANDLE)hService,
536  dwServiceType,
537  dwStartType,
538  dwErrorControl,
539  (LPWSTR)lpBinaryPathName,
540  (LPWSTR)lpLoadOrderGroup,
541  lpdwTagId,
542  (LPBYTE)lpDependencies,
543  dwDependenciesLength,
544  (LPWSTR)lpServiceStartName,
545  lpEncryptedPassword,
546  dwPasswordSize,
548  }
550  {
552  }
553  RpcEndExcept;
554 
555 done:
556  if (lpEncryptedPassword != NULL)
557  {
558  /* Wipe and release the password buffer */
559  SecureZeroMemory(lpEncryptedPassword, dwPasswordSize);
560  HeapFree(GetProcessHeap(), 0, lpEncryptedPassword);
561  }
562 
563  if (dwError != ERROR_SUCCESS)
564  {
565  TRACE("RChangeServiceConfigW() failed (Error %lu)\n", dwError);
566  SetLastError(dwError);
567  return FALSE;
568  }
569 
570  return TRUE;
571 }
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
#define TRUE
Definition: types.h:120
#define SecureZeroMemory
Definition: winbase.h:1665
static DWORD ScmEncryptPassword(_In_ PVOID ContextHandle, _In_ PCWSTR pClearTextPassword, _Out_ PBYTE *pEncryptedPassword, _Out_ PDWORD pEncryptedPasswordSize)
Definition: scm.c:173
#define DWORD
Definition: nt_native.h:44
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
#define debugstr_w
Definition: kernel32.h:32
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:595
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
#define ERR(fmt,...)
Definition: debug.h:110
ULONG_PTR SIZE_T
Definition: typedefs.h:80
#define NULL
Definition: types.h:112
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
WCHAR * LPWSTR
Definition: xmlstorage.h:184
_In_ LPCSTR _Out_writes_to_opt_ cchDisplayName LPSTR lpDisplayName
Definition: winbase.h:2769
#define HeapFree(x, y, z)
Definition: compat.h:594
DWORD WINAPI RChangeServiceConfigW(SC_RPC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPWSTR lpBinaryPathName, LPWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPBYTE lpDependencies, DWORD dwDependSize, LPWSTR lpServiceStartName, LPBYTE lpPassword, DWORD dwPwSize, LPWSTR lpDisplayName)
Definition: rpcserver.c:1920
#define RpcExcept(expr)
Definition: rpc.h:127

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

◆ CloseServiceHandle()

BOOL WINAPI CloseServiceHandle ( SC_HANDLE  hSCObject)

Definition at line 580 of file scm.c.

581 {
582  DWORD dwError;
583 
584  TRACE("CloseServiceHandle(%p)\n",
585  hSCObject);
586 
587  if (!hSCObject)
588  {
590  return FALSE;
591  }
592 
594  {
595  dwError = RCloseServiceHandle((LPSC_RPC_HANDLE)&hSCObject);
596  }
598  {
600  }
601  RpcEndExcept;
602 
603  if (dwError)
604  {
605  TRACE("RCloseServiceHandle() failed (Error %lu)\n", dwError);
606  SetLastError(dwError);
607  return FALSE;
608  }
609 
610  TRACE("CloseServiceHandle() done\n");
611 
612  return TRUE;
613 }
#define RpcEndExcept
Definition: rpc.h:128
#define TRUE
Definition: types.h:120
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
DWORD WINAPI RCloseServiceHandle(LPSC_RPC_HANDLE hSCObject)
Definition: rpcserver.c:936
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by _RunRemoteTest(), AccpCloseObjectHandle(), AccpOpenNamedObject(), AddService(), check_service_is_installed(), 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(), InstallOneService(), installService(), CShellDispatch::IsServiceRunning(), ITERATE_DeleteService(), ITERATE_InstallService(), ITERATE_StartService(), ITERATE_StopService(), KmtCloseService(), KmtDeleteService(), KmtServiceCleanup(), main(), MMSYS_InstallDevice(), my_test_server(), PlayLogonSoundThread(), query_service_config(), QueryConfig(), QueryDescription(), QueryDriverInfo(), QueryFailure(), QueryService(), RegisterDriver(), RpcSsConfigureAsNetworkService(), RunTest(), SchedEventLogoff(), SchedStartShell(), SdSet(), SdShow(), ServiceInfo(), ServicesPageWndProc(), ServiceStart(), SetConfig(), SetDescription(), SetFailure(), SetServiceAccount(), SetServiceConfig(), SetServiceDescription(), SetupStartService(), Start(), start_local_service(), start_rpcss(), start_service(), START_TEST(), StartAudioService(), StartDriver(), StartOneService(), StartSystemAudioServices(), stop_service(), stop_service_dependents(), StopDriver(), test_close(), test_create_delete_svc(), Test_CreateService(), test_delete_services(), test_driver_install(), test_enum_svc(), test_get_displayname(), test_get_servicekeyname(), test_install_services(), test_install_svc_from(), Test_LockUnlockServiceDatabase(), Test_LockUnlockServiceDatabaseWithServiceStart(), test_no_stop(), test_open_scm(), test_open_svc(), test_query_svc(), test_queryconfig2(), Test_QueryLockStatusA(), Test_QueryLockStatusW(), Test_QueryServiceConfig2A(), Test_QueryServiceConfig2W(), test_refcount(), test_regconnectregistry(), test_runner(), test_sequence(), test_service(), test_servicenotify(), test_SetupDiInstallClassExA(), test_SetupInstallServicesFromInfSectionExA(), test_SetupInstallServicesFromInfSectionExW(), test_start_stop(), test_start_stop_services(), ThemeWaitForServiceReady(), TV1_AddDependantsToTree(), TV2_GetDependants(), TV2_HasDependantServices(), uninstallService(), UnregisterDriver(), UpdateServiceStatus(), VfdConfigDriver(), VfdGetDriverConfig(), VfdGetDriverState(), VfdInstallDriver(), VfdRemoveDriver(), VfdStartDriver(), VfdStopDriver(), and WahDisableNonIFSHandleSupport().

◆ ControlService()

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

Definition at line 622 of file scm.c.

625 {
626  DWORD dwError;
627 
628  TRACE("ControlService(%p %lu %p)\n",
629  hService, dwControl, lpServiceStatus);
630 
632  {
633  dwError = RControlService((SC_RPC_HANDLE)hService,
634  dwControl,
635  lpServiceStatus);
636  }
638  {
640  }
641  RpcEndExcept;
642 
643  if (dwError != ERROR_SUCCESS)
644  {
645  TRACE("RControlService() failed (Error %lu)\n", dwError);
646  SetLastError(dwError);
647  return FALSE;
648  }
649 
650  TRACE("ControlService() done\n");
651 
652  return TRUE;
653 }
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
DWORD WINAPI RControlService(SC_RPC_HANDLE hService, DWORD dwControl, LPSERVICE_STATUS lpServiceStatus)
Definition: rpcserver.c:1069
#define RpcExcept(expr)
Definition: rpc.h:127

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

◆ ControlServiceEx()

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

Definition at line 662 of file scm.c.

666 {
667  FIXME("ControlServiceEx(%p %lu %lu %p)\n",
668  hService, dwControl, dwInfoLevel, pControlParams);
670  return FALSE;
671 }
#define FALSE
Definition: types.h:117
#define FIXME(fmt,...)
Definition: debug.h:111
#define SetLastError(x)
Definition: compat.h:611
_In_ DWORD dwInfoLevel
Definition: winsvc.h:422
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102

◆ CreateServiceA()

SC_HANDLE WINAPI CreateServiceA ( SC_HANDLE  hSCManager,
LPCSTR  lpServiceName,
LPCSTR  lpDisplayName,
DWORD  dwDesiredAccess,
DWORD  dwServiceType,
DWORD  dwStartType,
DWORD  dwErrorControl,
LPCSTR  lpBinaryPathName,
LPCSTR  lpLoadOrderGroup,
LPDWORD  lpdwTagId,
LPCSTR  lpDependencies,
LPCSTR  lpServiceStartName,
LPCSTR  lpPassword 
)

Definition at line 680 of file scm.c.

693 {
694  SC_HANDLE hService = NULL;
695  DWORD dwDependenciesLength = 0;
696  DWORD dwError;
697  SIZE_T cchLength;
698  LPCSTR lpStr;
699  DWORD dwPasswordSize = 0;
700  LPWSTR lpPasswordW = NULL;
701  LPBYTE lpEncryptedPassword = NULL;
702 
703  TRACE("CreateServiceA(%p %s %s %lx %lu %lu %lu %s %s %p %s %s %s)\n",
704  hSCManager, debugstr_a(lpServiceName), debugstr_a(lpDisplayName),
705  dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
706  debugstr_a(lpBinaryPathName), debugstr_a(lpLoadOrderGroup), lpdwTagId,
707  debugstr_a(lpDependencies), debugstr_a(lpServiceStartName), debugstr_a(lpPassword));
708 
709  if (!hSCManager)
710  {
712  return NULL;
713  }
714 
715  /* Calculate the Dependencies length */
716  if (lpDependencies != NULL)
717  {
718  lpStr = lpDependencies;
719  while (*lpStr)
720  {
721  cchLength = strlen(lpStr) + 1;
722  dwDependenciesLength += (DWORD)cchLength;
723  lpStr = lpStr + cchLength;
724  }
725  dwDependenciesLength++;
726  }
727 
728  if (lpPassword != NULL)
729  {
730  /* Convert the password to unicode */
731  lpPasswordW = HeapAlloc(GetProcessHeap(),
733  (strlen(lpPassword) + 1) * sizeof(WCHAR));
734  if (lpPasswordW == NULL)
735  {
737  return FALSE;
738  }
739 
741  0,
742  lpPassword,
743  -1,
744  lpPasswordW,
745  (int)(strlen(lpPassword) + 1));
746 
747  /* Encrypt the password */
748  dwError = ScmEncryptPassword(hSCManager,
749  lpPasswordW,
750  &lpEncryptedPassword,
751  &dwPasswordSize);
752  if (dwError != ERROR_SUCCESS)
753  goto done;
754  }
755 
757  {
759  (LPSTR)lpServiceName,
761  dwDesiredAccess,
762  dwServiceType,
763  dwStartType,
764  dwErrorControl,
765  (LPSTR)lpBinaryPathName,
766  (LPSTR)lpLoadOrderGroup,
767  lpdwTagId,
768  (LPBYTE)lpDependencies,
769  dwDependenciesLength,
770  (LPSTR)lpServiceStartName,
771  lpEncryptedPassword,
772  dwPasswordSize,
773  (SC_RPC_HANDLE *)&hService);
774  }
776  {
778  }
779  RpcEndExcept;
780 
781 done:
782  if (lpPasswordW != NULL)
783  {
784  /* Wipe and release the password buffers */
785  SecureZeroMemory(lpPasswordW, (wcslen(lpPasswordW) + 1) * sizeof(WCHAR));
786  HeapFree(GetProcessHeap(), 0, lpPasswordW);
787 
788  if (lpEncryptedPassword != NULL)
789  {
790  SecureZeroMemory(lpEncryptedPassword, dwPasswordSize);
791  HeapFree(GetProcessHeap(), 0, lpEncryptedPassword);
792  }
793  }
794 
795  SetLastError(dwError);
796  if (dwError != ERROR_SUCCESS)
797  {
798  TRACE("RCreateServiceA() failed (Error %lu)\n", dwError);
799  return NULL;
800  }
801 
802  return hService;
803 }
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define SecureZeroMemory
Definition: winbase.h:1665
#define CP_ACP
Definition: compat.h:109
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
static DWORD ScmEncryptPassword(_In_ PVOID ContextHandle, _In_ PCWSTR pClearTextPassword, _Out_ PBYTE *pEncryptedPassword, _Out_ PDWORD pEncryptedPasswordSize)
Definition: scm.c:173
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
char * LPSTR
Definition: xmlstorage.h:182
#define DWORD
Definition: nt_native.h:44
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
const char * LPCSTR
Definition: xmlstorage.h:183
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:595
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define debugstr_a
Definition: kernel32.h:31
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
DWORD WINAPI RCreateServiceA(SC_RPC_HANDLE hSCManager, LPSTR lpServiceName, LPSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPSTR lpBinaryPathName, LPSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPBYTE lpDependencies, DWORD dwDependSize, LPSTR lpServiceStartName, LPBYTE lpPassword, DWORD dwPwSize, LPSC_RPC_HANDLE lpServiceHandle)
Definition: rpcserver.c:3592
SC_HANDLE hSCManager
Definition: sc.c:12
ULONG_PTR SIZE_T
Definition: typedefs.h:80
#define NULL
Definition: types.h:112
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define MultiByteToWideChar
Definition: compat.h:110
WCHAR * LPWSTR
Definition: xmlstorage.h:184
_In_ LPCSTR _Out_writes_to_opt_ cchDisplayName LPSTR lpDisplayName
Definition: winbase.h:2769
#define HeapFree(x, y, z)
Definition: compat.h:594
#define RpcExcept(expr)
Definition: rpc.h:127

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

◆ CreateServiceW()

SC_HANDLE WINAPI CreateServiceW ( SC_HANDLE  hSCManager,
LPCWSTR  lpServiceName,
LPCWSTR  lpDisplayName,
DWORD  dwDesiredAccess,
DWORD  dwServiceType,
DWORD  dwStartType,
DWORD  dwErrorControl,
LPCWSTR  lpBinaryPathName,
LPCWSTR  lpLoadOrderGroup,
LPDWORD  lpdwTagId,
LPCWSTR  lpDependencies,
LPCWSTR  lpServiceStartName,
LPCWSTR  lpPassword 
)

Definition at line 812 of file scm.c.

825 {
826  SC_HANDLE hService = NULL;
827  DWORD dwDependenciesLength = 0;
828  DWORD dwError;
829  SIZE_T cchLength;
830  LPCWSTR lpStr;
831  DWORD dwPasswordSize = 0;
832  LPBYTE lpEncryptedPassword = NULL;
833 
834  TRACE("CreateServiceW(%p %s %s %lx %lu %lu %lu %s %s %p %s %s %s)\n",
835  hSCManager, debugstr_w(lpServiceName), debugstr_w(lpDisplayName),
836  dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
837  debugstr_w(lpBinaryPathName), debugstr_w(lpLoadOrderGroup), lpdwTagId,
838  debugstr_w(lpDependencies), debugstr_w(lpServiceStartName), debugstr_w(lpPassword));
839 
840  if (!hSCManager)
841  {
843  return NULL;
844  }
845 
846  /* Calculate the Dependencies length */
847  if (lpDependencies != NULL)
848  {
849  lpStr = lpDependencies;
850  while (*lpStr)
851  {
852  cchLength = wcslen(lpStr) + 1;
853  dwDependenciesLength += (DWORD)cchLength;
854  lpStr = lpStr + cchLength;
855  }
856  dwDependenciesLength++;
857  dwDependenciesLength *= sizeof(WCHAR);
858  }
859 
860  if (lpPassword != NULL)
861  {
862  /* Encrypt the password */
863  dwError = ScmEncryptPassword(hSCManager,
864  lpPassword,
865  &lpEncryptedPassword,
866  &dwPasswordSize);
867  if (dwError != ERROR_SUCCESS)
868  goto done;
869  }
870 
872  {
874  lpServiceName,
876  dwDesiredAccess,
877  dwServiceType,
878  dwStartType,
879  dwErrorControl,
880  lpBinaryPathName,
881  lpLoadOrderGroup,
882  lpdwTagId,
883  (LPBYTE)lpDependencies,
884  dwDependenciesLength,
885  lpServiceStartName,
886  lpEncryptedPassword,
887  dwPasswordSize,
888  (SC_RPC_HANDLE *)&hService);
889  }
891  {
893  }
894  RpcEndExcept;
895 
896 done:
897  if (lpEncryptedPassword != NULL)
898  {
899  /* Wipe and release the password buffers */
900  SecureZeroMemory(lpEncryptedPassword, dwPasswordSize);
901  HeapFree(GetProcessHeap(), 0, lpEncryptedPassword);
902  }
903 
904  SetLastError(dwError);
905  if (dwError != ERROR_SUCCESS)
906  {
907  TRACE("RCreateServiceW() failed (Error %lu)\n", dwError);
908  return NULL;
909  }
910 
911  return hService;
912 }
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
DWORD WINAPI RCreateServiceW(SC_RPC_HANDLE hSCManager, LPCWSTR lpServiceName, LPCWSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName, LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPBYTE lpDependencies, DWORD dwDependSize, LPCWSTR lpServiceStartName, LPBYTE lpPassword, DWORD dwPwSize, LPSC_RPC_HANDLE lpServiceHandle)
Definition: rpcserver.c:2272
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
#define SecureZeroMemory
Definition: winbase.h:1665
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
static DWORD ScmEncryptPassword(_In_ PVOID ContextHandle, _In_ PCWSTR pClearTextPassword, _Out_ PBYTE *pEncryptedPassword, _Out_ PDWORD pEncryptedPasswordSize)
Definition: scm.c:173
#define DWORD
Definition: nt_native.h:44
unsigned char * LPBYTE
Definition: typedefs.h:53
#define debugstr_w
Definition: kernel32.h:32
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:595
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
SC_HANDLE hSCManager
Definition: sc.c:12
ULONG_PTR SIZE_T
Definition: typedefs.h:80
#define NULL
Definition: types.h:112
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
_In_ LPCSTR _Out_writes_to_opt_ cchDisplayName LPSTR lpDisplayName
Definition: winbase.h:2769
#define HeapFree(x, y, z)
Definition: compat.h:594
#define RpcExcept(expr)
Definition: rpc.h:127

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

◆ DeleteService()

BOOL WINAPI DeleteService ( SC_HANDLE  hService)

Definition at line 921 of file scm.c.

922 {
923  DWORD dwError;
924 
925  TRACE("DeleteService(%p)\n",
926  hService);
927 
929  {
930  dwError = RDeleteService((SC_RPC_HANDLE)hService);
931  }
933  {
935  }
936  RpcEndExcept;
937 
938  if (dwError != ERROR_SUCCESS)
939  {
940  TRACE("RDeleteService() failed (Error %lu)\n", dwError);
941  SetLastError(dwError);
942  return FALSE;
943  }
944 
945  return TRUE;
946 }
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
DWORD WINAPI RDeleteService(SC_RPC_HANDLE hService)
Definition: rpcserver.c:1304
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
#define RpcExcept(expr)
Definition: rpc.h:127

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

◆ EnumDependentServicesA()

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

Definition at line 955 of file scm.c.

961 {
963  LPENUM_SERVICE_STATUSA lpStatusPtr;
964  DWORD dwBufferSize;
965  DWORD dwError;
966  DWORD dwCount;
967 
968  TRACE("EnumDependentServicesA(%p %lu %p %lu %p %p)\n",
969  hService, dwServiceState, lpServices, cbBufSize,
970  pcbBytesNeeded, lpServicesReturned);
971 
972  if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSA))
973  {
974  lpStatusPtr = &ServiceStatus;
975  dwBufferSize = sizeof(ENUM_SERVICE_STATUSA);
976  }
977  else
978  {
979  lpStatusPtr = lpServices;
980  dwBufferSize = cbBufSize;
981  }
982 
984  {
985  dwError = REnumDependentServicesA((SC_RPC_HANDLE)hService,
986  dwServiceState,
987  (LPBYTE)lpStatusPtr,
988  dwBufferSize,
990  lpServicesReturned);
991  }
993  {
995  }
996  RpcEndExcept;
997 
998  if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
999  {
1000  for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1001  {
1002  if (lpStatusPtr->lpServiceName)
1003  lpStatusPtr->lpServiceName =
1004  (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1005 
1006  if (lpStatusPtr->lpDisplayName)
1007  lpStatusPtr->lpDisplayName =
1008  (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1009 
1010  lpStatusPtr++;
1011  }
1012  }
1013 
1014  if (dwError != ERROR_SUCCESS)
1015  {
1016  TRACE("REnumDependentServicesA() failed (Error %lu)\n", dwError);
1017  SetLastError(dwError);
1018  return FALSE;
1019  }
1020 
1021  TRACE("EnumDependentServicesA() done\n");
1022 
1023  return TRUE;
1024 }
#define RpcEndExcept
Definition: rpc.h:128
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
Definition: winsvc.h:424
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
char * LPSTR
Definition: xmlstorage.h:182
uint32_t ULONG_PTR
Definition: typedefs.h:65
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
static SERVICE_STATUS ServiceStatus
Definition: browser.c:22
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ DWORD _In_ DWORD cbBufSize
Definition: winsvc.h:424
#define SetLastError(x)
Definition: compat.h:611
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define NULL
Definition: types.h:112
#define ULONG_PTR
Definition: config.h:101
DWORD WINAPI REnumDependentServicesA(SC_RPC_HANDLE hService, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned)
Definition: rpcserver.c:3745
struct _ENUM_SERVICE_STATUSA ENUM_SERVICE_STATUSA
#define RpcExcept(expr)
Definition: rpc.h:127

◆ EnumDependentServicesW()

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

Definition at line 1033 of file scm.c.

1039 {
1041  LPENUM_SERVICE_STATUSW lpStatusPtr;
1042  DWORD dwBufferSize;
1043  DWORD dwError;
1044  DWORD dwCount;
1045 
1046  TRACE("EnumDependentServicesW(%p %lu %p %lu %p %p)\n",
1047  hService, dwServiceState, lpServices, cbBufSize,
1048  pcbBytesNeeded, lpServicesReturned);
1049 
1050  if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSW))
1051  {
1052  lpStatusPtr = &ServiceStatus;
1053  dwBufferSize = sizeof(ENUM_SERVICE_STATUSW);
1054  }
1055  else
1056  {
1057  lpStatusPtr = lpServices;
1058  dwBufferSize = cbBufSize;
1059  }
1060 
1061  RpcTryExcept
1062  {
1063  dwError = REnumDependentServicesW((SC_RPC_HANDLE)hService,
1064  dwServiceState,
1065  (LPBYTE)lpStatusPtr,
1066  dwBufferSize,
1068  lpServicesReturned);
1069  }
1071  {
1073  }
1074  RpcEndExcept;
1075 
1076  if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1077  {
1078  for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1079  {
1080  if (lpStatusPtr->lpServiceName)
1081  lpStatusPtr->lpServiceName =
1082  (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1083 
1084  if (lpStatusPtr->lpDisplayName)
1085  lpStatusPtr->lpDisplayName =
1086  (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1087 
1088  lpStatusPtr++;
1089  }
1090  }
1091 
1092  if (dwError != ERROR_SUCCESS)
1093  {
1094  TRACE("REnumDependentServicesW() failed (Error %lu)\n", dwError);
1095  SetLastError(dwError);
1096  return FALSE;
1097  }
1098 
1099  TRACE("EnumDependentServicesW() done\n");
1100 
1101  return TRUE;
1102 }
#define RpcEndExcept
Definition: rpc.h:128
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
Definition: winsvc.h:424
#define ERROR_SUCCESS
Definition: deptool.c:10
DWORD WINAPI REnumDependentServicesW(SC_RPC_HANDLE hService, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned)
Definition: rpcserver.c:2707
#define TRUE
Definition: types.h:120
uint32_t ULONG_PTR
Definition: typedefs.h:65
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
static SERVICE_STATUS ServiceStatus
Definition: browser.c:22
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ DWORD _In_ DWORD cbBufSize
Definition: winsvc.h:424
#define SetLastError(x)
Definition: compat.h:611
struct _ENUM_SERVICE_STATUSW ENUM_SERVICE_STATUSW
#define ERROR_MORE_DATA
Definition: dderror.h:13
LPWSTR lpServiceName
Definition: winsvc.h:130
LPWSTR lpDisplayName
Definition: winsvc.h:131
#define NULL
Definition: types.h:112
#define ULONG_PTR
Definition: config.h:101
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by stop_service_dependents(), and TV2_GetDependants().

◆ EnumServiceGroupW()

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

Definition at line 1111 of file scm.c.

1120 {
1122  LPENUM_SERVICE_STATUSW lpStatusPtr;
1123  DWORD dwBufferSize;
1124  DWORD dwError;
1125  DWORD dwCount;
1126 
1127  TRACE("EnumServiceGroupW(%p %lu %lu %p %lu %p %p %p %s)\n",
1128  hSCManager, dwServiceType, dwServiceState, lpServices,
1129  cbBufSize, pcbBytesNeeded, lpServicesReturned,
1130  lpResumeHandle, debugstr_w(lpGroup));
1131 
1132  if (!hSCManager)
1133  {
1135  return FALSE;
1136  }
1137 
1138  if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
1139  {
1141  return FALSE;
1142  }
1143 
1144  if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSW))
1145  {
1146  lpStatusPtr = &ServiceStatus;
1147  dwBufferSize = sizeof(ENUM_SERVICE_STATUSW);
1148  }
1149  else
1150  {
1151  lpStatusPtr = lpServices;
1152  dwBufferSize = cbBufSize;
1153  }
1154 
1155  RpcTryExcept
1156  {
1157  if (lpGroup == NULL)
1158  {
1160  dwServiceType,
1161  dwServiceState,
1162  (LPBYTE)lpStatusPtr,
1163  dwBufferSize,
1165  lpServicesReturned,
1166  lpResumeHandle);
1167  }
1168  else
1169  {
1171  dwServiceType,
1172  dwServiceState,
1173  (LPBYTE)lpStatusPtr,
1174  dwBufferSize,
1176  lpServicesReturned,
1177  lpResumeHandle,
1178  lpGroup);
1179  }
1180  }
1182  {
1184  }
1185  RpcEndExcept;
1186 
1187  if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1188  {
1189  for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1190  {
1191  if (lpStatusPtr->lpServiceName)
1192  lpStatusPtr->lpServiceName =
1193  (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1194 
1195  if (lpStatusPtr->lpDisplayName)
1196  lpStatusPtr->lpDisplayName =
1197  (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1198 
1199  lpStatusPtr++;
1200  }
1201  }
1202 
1203  if (dwError != ERROR_SUCCESS)
1204  {
1205  TRACE("REnumServiceGroupW() failed (Error %lu)\n", dwError);
1206  SetLastError(dwError);
1207  return FALSE;
1208  }
1209 
1210  TRACE("EnumServiceGroupW() done\n");
1211 
1212  return TRUE;
1213 }
#define RpcEndExcept
Definition: rpc.h:128
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
Definition: winsvc.h:424
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
uint32_t ULONG_PTR
Definition: typedefs.h:65
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
#define debugstr_w
Definition: kernel32.h:32
#define RpcTryExcept
Definition: rpc.h:126
DWORD WINAPI REnumServiceGroupW(SC_RPC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeIndex, LPCWSTR pszGroupName)
Definition: rpcserver.c:4753
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
static SERVICE_STATUS ServiceStatus
Definition: browser.c:22
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ DWORD _In_ DWORD cbBufSize
Definition: winsvc.h:424
#define SetLastError(x)
Definition: compat.h:611
struct _ENUM_SERVICE_STATUSW ENUM_SERVICE_STATUSW
#define ERROR_INVALID_ADDRESS
Definition: compat.h:106
SC_HANDLE hSCManager
Definition: sc.c:12
#define ERROR_MORE_DATA
Definition: dderror.h:13
DWORD WINAPI REnumServicesStatusW(SC_RPC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD dwBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeHandle)
Definition: rpcserver.c:2842
LPWSTR lpServiceName
Definition: winsvc.h:130
LPWSTR lpDisplayName
Definition: winsvc.h:131
#define NULL
Definition: types.h:112
#define ULONG_PTR
Definition: config.h:101
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define RpcExcept(expr)
Definition: rpc.h:127

◆ EnumServicesStatusA()

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

Definition at line 1222 of file scm.c.

1230 {
1232  LPENUM_SERVICE_STATUSA lpStatusPtr;
1233  DWORD dwBufferSize;
1234  DWORD dwError;
1235  DWORD dwCount;
1236 
1237  TRACE("EnumServicesStatusA(%p %lu %lu %p %lu %p %p %p)\n",
1238  hSCManager, dwServiceType, dwServiceState, lpServices,
1239  cbBufSize, pcbBytesNeeded, lpServicesReturned, lpResumeHandle);
1240 
1241  if (!hSCManager)
1242  {
1244  return FALSE;
1245  }
1246 
1247  if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
1248  {
1250  return FALSE;
1251  }
1252 
1253  if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSA))
1254  {
1255  lpStatusPtr = &ServiceStatus;
1256  dwBufferSize = sizeof(ENUM_SERVICE_STATUSA);
1257  }
1258  else
1259  {
1260  lpStatusPtr = lpServices;
1261  dwBufferSize = cbBufSize;
1262  }
1263 
1264  RpcTryExcept
1265  {
1267  dwServiceType,
1268  dwServiceState,
1269  (LPBYTE)lpStatusPtr,
1270  dwBufferSize,
1272  lpServicesReturned,
1273  lpResumeHandle);
1274  }
1276  {
1278  }
1279  RpcEndExcept;
1280 
1281  if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1282  {
1283  for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1284  {
1285  if (lpStatusPtr->lpServiceName)
1286  lpStatusPtr->lpServiceName =
1287  (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1288 
1289  if (lpStatusPtr->lpDisplayName)
1290  lpStatusPtr->lpDisplayName =
1291  (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1292 
1293  lpStatusPtr++;
1294  }
1295  }
1296 
1297  if (dwError != ERROR_SUCCESS)
1298  {
1299  TRACE("REnumServicesStatusA() failed (Error %lu)\n", dwError);
1300  SetLastError(dwError);
1301  return FALSE;
1302  }
1303 
1304  TRACE("EnumServicesStatusA() done\n");
1305 
1306  return TRUE;
1307 }
DWORD WINAPI REnumServicesStatusA(SC_RPC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD dwBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeHandle)
Definition: rpcserver.c:3899
#define RpcEndExcept
Definition: rpc.h:128
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
Definition: winsvc.h:424
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
char * LPSTR
Definition: xmlstorage.h:182
uint32_t ULONG_PTR
Definition: typedefs.h:65
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
static SERVICE_STATUS ServiceStatus
Definition: browser.c:22
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ DWORD _In_ DWORD cbBufSize
Definition: winsvc.h:424
#define SetLastError(x)
Definition: compat.h:611
#define ERROR_INVALID_ADDRESS
Definition: compat.h:106
SC_HANDLE hSCManager
Definition: sc.c:12
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define NULL
Definition: types.h:112
#define ULONG_PTR
Definition: config.h:101
struct _ENUM_SERVICE_STATUSA ENUM_SERVICE_STATUSA
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by test_enum_svc().

◆ EnumServicesStatusExA()

BOOL WINAPI EnumServicesStatusExA ( SC_HANDLE  hSCManager,
SC_ENUM_TYPE  InfoLevel,
DWORD  dwServiceType,
DWORD  dwServiceState,
LPBYTE  lpServices,
DWORD  cbBufSize,
LPDWORD  pcbBytesNeeded,
LPDWORD  lpServicesReturned,
LPDWORD  lpResumeHandle,
LPCSTR  pszGroupName 
)

Definition at line 1410 of file scm.c.

1420 {
1422  LPENUM_SERVICE_STATUS_PROCESSA lpStatusPtr;
1423  DWORD dwBufferSize;
1424  DWORD dwError;
1425  DWORD dwCount;
1426 
1427  TRACE("EnumServicesStatusExA(%p %lu %lu %p %lu %p %p %p %s)\n",
1428  hSCManager, dwServiceType, dwServiceState, lpServices,
1429  cbBufSize, pcbBytesNeeded, lpServicesReturned, lpResumeHandle,
1430  debugstr_a(pszGroupName));
1431 
1432  if (InfoLevel != SC_ENUM_PROCESS_INFO)
1433  {
1435  return FALSE;
1436  }
1437 
1438  if (!hSCManager)
1439  {
1441  return FALSE;
1442  }
1443 
1444  if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
1445  {
1447  return FALSE;
1448  }
1449 
1450  if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUS_PROCESSA))
1451  {
1452  lpStatusPtr = &ServiceStatus;
1453  dwBufferSize = sizeof(ENUM_SERVICE_STATUS_PROCESSA);
1454  }
1455  else
1456  {
1457  lpStatusPtr = (LPENUM_SERVICE_STATUS_PROCESSA)lpServices;
1458  dwBufferSize = cbBufSize;
1459  }
1460 
1461  RpcTryExcept
1462  {
1464  InfoLevel,
1465  dwServiceType,
1466  dwServiceState,
1467  (LPBYTE)lpStatusPtr,
1468  dwBufferSize,
1470  lpServicesReturned,
1471  lpResumeHandle,
1472  (LPSTR)pszGroupName);
1473  }
1475  {
1477  }
1478  RpcEndExcept;
1479 
1480  if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1481  {
1482  if (InfoLevel == SC_ENUM_PROCESS_INFO)
1483  {
1484  for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1485  {
1486  if (lpStatusPtr->lpServiceName)
1487  lpStatusPtr->lpServiceName =
1488  (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1489 
1490  if (lpStatusPtr->lpDisplayName)
1491  lpStatusPtr->lpDisplayName =
1492  (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1493 
1494  lpStatusPtr++;
1495  }
1496  }
1497  }
1498 
1499  if (dwError != ERROR_SUCCESS)
1500  {
1501  TRACE("REnumServicesStatusExA() failed (Error %lu)\n", dwError);
1502  SetLastError(dwError);
1503  return FALSE;
1504  }
1505 
1506  TRACE("EnumServicesStatusExA() done\n");
1507 
1508  return TRUE;
1509 }
DWORD WINAPI REnumServicesStatusExA(SC_RPC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeIndex, LPCSTR pszGroupName)
Definition: rpcserver.c:6096
#define RpcEndExcept
Definition: rpc.h:128
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
Definition: winsvc.h:424
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
char * LPSTR
Definition: xmlstorage.h:182
uint32_t ULONG_PTR
Definition: typedefs.h:65
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
struct _ENUM_SERVICE_STATUS_PROCESSA ENUM_SERVICE_STATUS_PROCESSA
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
struct _ENUM_SERVICE_STATUS_PROCESSA * LPENUM_SERVICE_STATUS_PROCESSA
#define debugstr_a
Definition: kernel32.h:31
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
static SERVICE_STATUS ServiceStatus
Definition: browser.c:22
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ DWORD _In_ DWORD cbBufSize
Definition: winsvc.h:424
#define SetLastError(x)
Definition: compat.h:611
#define ERROR_INVALID_ADDRESS
Definition: compat.h:106
SC_HANDLE hSCManager
Definition: sc.c:12
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define NULL
Definition: types.h:112
#define ULONG_PTR
Definition: config.h:101
#define ERROR_INVALID_LEVEL
Definition: winerror.h:196
#define RpcExcept(expr)
Definition: rpc.h:127

◆ EnumServicesStatusExW()

BOOL WINAPI EnumServicesStatusExW ( SC_HANDLE  hSCManager,
SC_ENUM_TYPE  InfoLevel,
DWORD  dwServiceType,
DWORD  dwServiceState,
LPBYTE  lpServices,
DWORD  cbBufSize,
LPDWORD  pcbBytesNeeded,
LPDWORD  lpServicesReturned,
LPDWORD  lpResumeHandle,
LPCWSTR  pszGroupName 
)

Definition at line 1518 of file scm.c.

1528 {
1530  LPENUM_SERVICE_STATUS_PROCESSW lpStatusPtr;
1531  DWORD dwBufferSize;
1532  DWORD dwError;
1533  DWORD dwCount;
1534 
1535  TRACE("EnumServicesStatusExW(%p %lu %lu %p %lu %p %p %p %s)\n",
1536  hSCManager, dwServiceType, dwServiceState, lpServices,
1537  cbBufSize, pcbBytesNeeded, lpServicesReturned, lpResumeHandle,
1538  debugstr_w(pszGroupName));
1539 
1540  if (InfoLevel != SC_ENUM_PROCESS_INFO)
1541  {
1543  return FALSE;
1544  }
1545 
1546  if (!hSCManager)
1547  {
1549  return FALSE;
1550  }
1551 
1552  if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
1553  {
1555  return FALSE;
1556  }
1557 
1558  if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUS_PROCESSW))
1559  {
1560  lpStatusPtr = &ServiceStatus;
1561  dwBufferSize = sizeof(ENUM_SERVICE_STATUS_PROCESSW);
1562  }
1563  else
1564  {
1565  lpStatusPtr = (LPENUM_SERVICE_STATUS_PROCESSW)lpServices;
1566  dwBufferSize = cbBufSize;
1567  }
1568 
1569  RpcTryExcept
1570  {
1572  InfoLevel,
1573  dwServiceType,
1574  dwServiceState,
1575  (LPBYTE)lpStatusPtr,
1576  dwBufferSize,
1578  lpServicesReturned,
1579  lpResumeHandle,
1580  (LPWSTR)pszGroupName);
1581  }
1583  {
1585  }
1586  RpcEndExcept;
1587 
1588  if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1589  {
1590  if (InfoLevel == SC_ENUM_PROCESS_INFO)
1591  {
1592  for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1593  {
1594  if (lpStatusPtr->lpServiceName)
1595  lpStatusPtr->lpServiceName =
1596  (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1597 
1598  if (lpStatusPtr->lpDisplayName)
1599  lpStatusPtr->lpDisplayName =
1600  (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1601 
1602  lpStatusPtr++;
1603  }
1604  }
1605  }
1606 
1607  if (dwError != ERROR_SUCCESS)
1608  {
1609  TRACE("REnumServicesStatusExW() failed (Error %lu)\n", dwError);
1610  SetLastError(dwError);
1611  return FALSE;
1612  }
1613 
1614  TRACE("EnumServicesStatusExW() done\n");
1615 
1616  return TRUE;
1617 }
#define RpcEndExcept
Definition: rpc.h:128
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
Definition: winsvc.h:424
#define ERROR_SUCCESS
Definition: deptool.c:10
DWORD WINAPI REnumServicesStatusExW(SC_RPC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeIndex, LPCWSTR pszGroupName)
Definition: rpcserver.c:6235
#define TRUE
Definition: types.h:120
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
uint32_t ULONG_PTR
Definition: typedefs.h:65
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
#define debugstr_w
Definition: kernel32.h:32
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
static SERVICE_STATUS ServiceStatus
Definition: browser.c:22
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ DWORD _In_ DWORD cbBufSize
Definition: winsvc.h:424
#define SetLastError(x)
Definition: compat.h:611
#define ERROR_INVALID_ADDRESS
Definition: compat.h:106
struct _ENUM_SERVICE_STATUS_PROCESSW * LPENUM_SERVICE_STATUS_PROCESSW
SC_HANDLE hSCManager
Definition: sc.c:12
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define NULL
Definition: types.h:112
struct _ENUM_SERVICE_STATUS_PROCESSW ENUM_SERVICE_STATUS_PROCESSW
#define ULONG_PTR
Definition: config.h:101
#define ERROR_INVALID_LEVEL
Definition: winerror.h:196
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by fill_service(), and GetServices().

◆ EnumServicesStatusW()

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

Definition at line 1316 of file scm.c.

1324 {
1326  LPENUM_SERVICE_STATUSW lpStatusPtr;
1327  DWORD dwBufferSize;
1328  DWORD dwError;
1329  DWORD dwCount;
1330 
1331  TRACE("EnumServicesStatusW(%p %lu %lu %p %lu %p %p %p)\n",
1332  hSCManager, dwServiceType, dwServiceState, lpServices,
1333  cbBufSize, pcbBytesNeeded, lpServicesReturned, lpResumeHandle);
1334 
1335  if (!hSCManager)
1336  {
1338  return FALSE;
1339  }
1340 
1341  if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
1342  {
1344  return FALSE;
1345  }
1346 
1347  if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSW))
1348  {
1349  lpStatusPtr = &ServiceStatus;
1350  dwBufferSize = sizeof(ENUM_SERVICE_STATUSW);
1351  }
1352  else
1353  {
1354  lpStatusPtr = lpServices;
1355  dwBufferSize = cbBufSize;
1356  }
1357 
1358  RpcTryExcept
1359  {
1361  dwServiceType,
1362  dwServiceState,
1363  (LPBYTE)lpStatusPtr,
1364  dwBufferSize,
1366  lpServicesReturned,
1367  lpResumeHandle);
1368  }
1370  {
1372  }
1373  RpcEndExcept;
1374 
1375  if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1376  {
1377  for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1378  {
1379  if (lpStatusPtr->lpServiceName)
1380  lpStatusPtr->lpServiceName =
1381  (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1382 
1383  if (lpStatusPtr->lpDisplayName)
1384  lpStatusPtr->lpDisplayName =
1385  (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1386 
1387  lpStatusPtr++;
1388  }
1389  }
1390 
1391  if (dwError != ERROR_SUCCESS)
1392  {
1393  TRACE("REnumServicesStatusW() failed (Error %lu)\n", dwError);
1394  SetLastError(dwError);
1395  return FALSE;
1396  }
1397 
1398  TRACE("EnumServicesStatusW() done\n");
1399 
1400  return TRUE;
1401 }
#define RpcEndExcept
Definition: rpc.h:128
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
Definition: winsvc.h:424
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
uint32_t ULONG_PTR
Definition: typedefs.h:65
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
static SERVICE_STATUS ServiceStatus
Definition: browser.c:22
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ DWORD _In_ DWORD cbBufSize
Definition: winsvc.h:424
#define SetLastError(x)
Definition: compat.h:611
struct _ENUM_SERVICE_STATUSW ENUM_SERVICE_STATUSW
#define ERROR_INVALID_ADDRESS
Definition: compat.h:106
SC_HANDLE hSCManager
Definition: sc.c:12
#define ERROR_MORE_DATA
Definition: dderror.h:13
DWORD WINAPI REnumServicesStatusW(SC_RPC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD dwBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeHandle)
Definition: rpcserver.c:2842
LPWSTR lpServiceName
Definition: winsvc.h:130
LPWSTR lpDisplayName
Definition: winsvc.h:131
#define NULL
Definition: types.h:112
#define ULONG_PTR
Definition: config.h:101
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by EnumerateRunningServices(), and test_enum_svc().

◆ GetServiceDisplayNameA()

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

Definition at line 1626 of file scm.c.

1630 {
1631  DWORD dwError;
1633  CHAR szEmptyName[] = "";
1634 
1635  TRACE("GetServiceDisplayNameA(%p %s %p %p)\n",
1636  hSCManager, debugstr_a(lpServiceName), lpDisplayName, lpcchBuffer);
1637 
1638  if (!hSCManager)
1639  {
1641  return FALSE;
1642  }
1643 
1644  if (!lpDisplayName || *lpcchBuffer < sizeof(CHAR))
1645  {
1646  lpNameBuffer = szEmptyName;
1647  *lpcchBuffer = sizeof(CHAR);
1648  }
1649  else
1650  {
1652  }
1653 
1654  RpcTryExcept
1655  {
1657  lpServiceName,
1658  lpNameBuffer,
1659  lpcchBuffer);
1660  }
1662  {
1664  }
1665  RpcEndExcept;
1666 
1667  if (dwError != ERROR_SUCCESS)
1668  {
1669  TRACE("RGetServiceDisplayNameA() failed (Error %lu)\n", dwError);
1670  SetLastError(dwError);
1671  return FALSE;
1672  }
1673 
1674  return TRUE;
1675 }
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
char CHAR
Definition: xmlstorage.h:175
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
char * LPSTR
Definition: xmlstorage.h:182
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
static LPSTR lpNameBuffer
Definition: secur32.c:50
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define debugstr_a
Definition: kernel32.h:31
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
DWORD WINAPI RGetServiceDisplayNameA(SC_RPC_HANDLE hSCManager, LPCSTR lpServiceName, LPSTR lpDisplayName, LPBOUNDED_DWORD_4K lpcchBuffer)
Definition: rpcserver.c:4460
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
SC_HANDLE hSCManager
Definition: sc.c:12
#define CHAR(Char)
_In_ LPCSTR _Out_writes_to_opt_ cchDisplayName LPSTR lpDisplayName
Definition: winbase.h:2769
#define RpcExcept(expr)
Definition: rpc.h:127

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

◆ GetServiceDisplayNameW()

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

Definition at line 1684 of file scm.c.

1688 {
1689  DWORD dwError;
1691  WCHAR szEmptyName[] = L"";
1692 
1693  TRACE("GetServiceDisplayNameW(%p %s %p %p)\n",
1694  hSCManager, debugstr_w(lpServiceName), lpDisplayName, lpcchBuffer);
1695 
1696  if (!hSCManager)
1697  {
1699  return FALSE;
1700  }
1701 
1702  /*
1703  * NOTE: A size of 1 character would be enough, but tests show that
1704  * Windows returns 2 characters instead, certainly due to a WCHAR/bytes
1705  * mismatch in their code.
1706  */
1707  if (!lpDisplayName || *lpcchBuffer < sizeof(WCHAR))
1708  {
1709  lpNameBuffer = szEmptyName;
1710  *lpcchBuffer = sizeof(WCHAR);
1711  }
1712  else
1713  {
1715  }
1716 
1717  RpcTryExcept
1718  {
1720  lpServiceName,
1721  lpNameBuffer,
1722  lpcchBuffer);
1723  }
1725  {
1727  }
1728  RpcEndExcept;
1729 
1730  if (dwError != ERROR_SUCCESS)
1731  {
1732  TRACE("RGetServiceDisplayNameW() failed (Error %lu)\n", dwError);
1733  SetLastError(dwError);
1734  return FALSE;
1735  }
1736 
1737  return TRUE;
1738 }
#define RpcEndExcept
Definition: rpc.h:128
DWORD WINAPI RGetServiceDisplayNameW(SC_RPC_HANDLE hSCManager, LPCWSTR lpServiceName, LPWSTR lpDisplayName, DWORD *lpcchBuffer)
Definition: rpcserver.c:3317
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
#define FALSE
Definition: types.h:117
#define debugstr_w
Definition: kernel32.h:32
#define RpcTryExcept
Definition: rpc.h:126
static LPSTR lpNameBuffer
Definition: secur32.c:50
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
static const WCHAR L[]
Definition: oid.c:1250
SC_HANDLE hSCManager
Definition: sc.c:12
WCHAR * LPWSTR
Definition: xmlstorage.h:184
_In_ LPCSTR _Out_writes_to_opt_ cchDisplayName LPSTR lpDisplayName
Definition: winbase.h:2769
#define RpcExcept(expr)
Definition: rpc.h:127

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

◆ GetServiceKeyNameA()

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

Definition at line 1747 of file scm.c.

1751 {
1752  DWORD dwError;
1754  CHAR szEmptyName[] = "";
1755 
1756  TRACE("GetServiceKeyNameA(%p %s %p %p)\n",
1757  hSCManager, debugstr_a(lpDisplayName), lpServiceName, lpcchBuffer);
1758 
1759  if (!hSCManager)
1760  {
1762  return FALSE;
1763  }
1764 
1765  if (!lpServiceName || *lpcchBuffer < sizeof(CHAR))
1766  {
1767  lpNameBuffer = szEmptyName;
1768  *lpcchBuffer = sizeof(CHAR);
1769  }
1770  else
1771  {
1772  lpNameBuffer = lpServiceName;
1773  }
1774 
1775  RpcTryExcept
1776  {
1778  lpDisplayName,
1779  lpNameBuffer,
1780  lpcchBuffer);
1781  }
1783  {
1784  /* HACK: because of a problem with rpcrt4, rpcserver is hacked to return 6 for ERROR_SERVICE_DOES_NOT_EXIST */
1786  }
1787  RpcEndExcept;
1788 
1789  if (dwError != ERROR_SUCCESS)
1790  {
1791  TRACE("RGetServiceKeyNameA() failed (Error %lu)\n", dwError);
1792  SetLastError(dwError);
1793  return FALSE;
1794  }
1795 
1796  return TRUE;
1797 }
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
char CHAR
Definition: xmlstorage.h:175
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
char * LPSTR
Definition: xmlstorage.h:182
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
static LPSTR lpNameBuffer
Definition: secur32.c:50
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define debugstr_a
Definition: kernel32.h:31
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
SC_HANDLE hSCManager
Definition: sc.c:12
DWORD WINAPI RGetServiceKeyNameA(SC_RPC_HANDLE hSCManager, LPCSTR lpDisplayName, LPSTR lpServiceName, LPBOUNDED_DWORD_4K lpcchBuffer)
Definition: rpcserver.c:4582
#define CHAR(Char)
_In_ LPCSTR _Out_writes_to_opt_ cchDisplayName LPSTR lpDisplayName
Definition: winbase.h:2769
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by test_get_servicekeyname().

◆ GetServiceKeyNameW()

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

Definition at line 1806 of file scm.c.

1810 {
1811  DWORD dwError;
1813  WCHAR szEmptyName[] = L"";
1814 
1815  TRACE("GetServiceKeyNameW(%p %s %p %p)\n",
1816  hSCManager, debugstr_w(lpDisplayName), lpServiceName, lpcchBuffer);
1817 
1818  if (!hSCManager)
1819  {
1821  return FALSE;
1822  }
1823 
1824  /*
1825  * NOTE: A size of 1 character would be enough, but tests show that
1826  * Windows returns 2 characters instead, certainly due to a WCHAR/bytes
1827  * mismatch in their code.
1828  */
1829  if (!lpServiceName || *lpcchBuffer < sizeof(WCHAR))
1830  {
1831  lpNameBuffer = szEmptyName;
1832  *lpcchBuffer = sizeof(WCHAR);
1833  }
1834  else
1835  {
1836  lpNameBuffer = lpServiceName;
1837  }
1838 
1839  RpcTryExcept
1840  {
1842  lpDisplayName,
1843  lpNameBuffer,
1844  lpcchBuffer);
1845  }
1847  {
1849  }
1850  RpcEndExcept;
1851 
1852  if (dwError != ERROR_SUCCESS)
1853  {
1854  TRACE("RGetServiceKeyNameW() failed (Error %lu)\n", dwError);
1855  SetLastError(dwError);
1856  return FALSE;
1857  }
1858 
1859  return TRUE;
1860 }
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
#define FALSE
Definition: types.h:117
DWORD WINAPI RGetServiceKeyNameW(SC_RPC_HANDLE hSCManager, LPCWSTR lpDisplayName, LPWSTR lpServiceName, DWORD *lpcchBuffer)
Definition: rpcserver.c:3380
#define debugstr_w
Definition: kernel32.h:32
#define RpcTryExcept
Definition: rpc.h:126
static LPSTR lpNameBuffer
Definition: secur32.c:50
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
static const WCHAR L[]
Definition: oid.c:1250
SC_HANDLE hSCManager
Definition: sc.c:12
WCHAR * LPWSTR
Definition: xmlstorage.h:184
_In_ LPCSTR _Out_writes_to_opt_ cchDisplayName LPSTR lpDisplayName
Definition: winbase.h:2769
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by test_get_servicekeyname().

◆ I_QueryTagInformation()

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

Definition at line 3132 of file scm.c.

3135 {
3136  /*
3137  * We only support one information class and it
3138  * needs parameters
3139  */
3141  InOutParams == NULL)
3142  {
3143  return ERROR_INVALID_PARAMETER;
3144  }
3145 
3146  /* Validate input structure */
3147  if (InOutParams->InParams.dwPid == 0 || InOutParams->InParams.dwTag == 0)
3148  {
3149  return ERROR_INVALID_PARAMETER;
3150  }
3151 
3152  /* Validate output structure */
3153  if (InOutParams->OutParams.pszName != NULL)
3154  {
3155  return ERROR_INVALID_PARAMETER;
3156  }
3157 
3158  /* Call internal function for the RPC call */
3160 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
DWORD I_ScQueryServiceTagInfo(PVOID Unused, TAG_INFO_LEVEL dwInfoLevel, PTAG_INFO_NAME_FROM_TAG InOutParams)
Definition: scm.c:3032
_Must_inspect_result_ typedef _In_ PVOID Unused
Definition: iotypes.h:1166
TAG_INFO_NAME_FROM_TAG_OUT_PARAMS OutParams
Definition: svcctl.idl:320
TAG_INFO_NAME_FROM_TAG_IN_PARAMS InParams
Definition: svcctl.idl:319
_In_ DWORD dwInfoLevel
Definition: winsvc.h:422
#define NULL
Definition: types.h:112

◆ I_ScGetCurrentGroupStateW()

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

Definition at line 1869 of file scm.c.

1872 {
1873  DWORD dwError;
1874 
1875  TRACE("I_ScGetCurrentGroupStateW(%p %s %p)\n",
1876  hSCManager, debugstr_w(pszGroupName), pdwGroupState);
1877 
1878  RpcTryExcept
1879  {
1881  pszGroupName,
1882  pdwGroupState);
1883  }
1885  {
1887  }
1888  RpcEndExcept
1889 
1890  if (dwError != ERROR_SUCCESS)
1891  {
1892  TRACE("RI_ScGetCurrentGroupStateW() failed (Error %lu)\n", dwError);
1893  SetLastError(dwError);
1894  }
1895 
1896  return dwError;
1897 }
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
#define debugstr_w
Definition: kernel32.h:32
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
SC_HANDLE hSCManager
Definition: sc.c:12
DWORD WINAPI RI_ScGetCurrentGroupStateW(SC_RPC_HANDLE hSCManager, LPWSTR lpLoadOrderGroup, LPDWORD lpState)
Definition: rpcserver.c:4696
#define RpcExcept(expr)
Definition: rpc.h:127

◆ I_ScQueryServiceTagInfo()

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

Definition at line 3032 of file scm.c.

3035 {
3036  SC_HANDLE hScm;
3037  DWORD dwError;
3040  LPWSTR lpszName;
3041 
3042  /* We only support one class */
3044  {
3045  return ERROR_RETRY;
3046  }
3047 
3048  /* Validate input structure */
3049  if (InOutParams->InParams.dwPid == 0 || InOutParams->InParams.dwTag == 0)
3050  {
3051  return ERROR_INVALID_PARAMETER;
3052  }
3053 
3054  /* Validate output structure */
3055  if (InOutParams->OutParams.pszName != NULL)
3056  {
3057  return ERROR_INVALID_PARAMETER;
3058  }
3059 
3060  /* Open service manager */
3062  if (hScm == NULL)
3063  {
3064  return GetLastError();
3065  }
3066 
3067  /* Setup call parameters */
3068  InParams = &InOutParams->InParams;
3069  OutParams = NULL;
3070 
3071  /* Call SCM to query tag information */
3072  RpcTryExcept
3073  {
3074  dwError = RI_ScQueryServiceTagInfo(hScm, TagInfoLevelNameFromTag, &InParams, &OutParams);
3075  }
3077  {
3079  }
3080  RpcEndExcept;
3081 
3082  /* Quit if not a success */
3083  if (dwError != ERROR_SUCCESS)
3084  {
3085  goto Cleanup;
3086  }
3087 
3088  /* OutParams must be set now and we must have a name */
3089  if (OutParams == NULL ||
3090  OutParams->pszName == NULL)
3091  {
3092  dwError = ERROR_INVALID_DATA;
3093  goto Cleanup;
3094  }
3095 
3096  /* Copy back what SCM returned */
3097  lpszName = LocalAlloc(LPTR,
3098  sizeof(WCHAR) * wcslen(OutParams->pszName) + sizeof(UNICODE_NULL));
3099  if (lpszName == NULL)
3100  {
3101  dwError = GetLastError();
3102  goto Cleanup;
3103  }
3104 
3105  wcscpy(lpszName, OutParams->pszName);
3106  InOutParams->OutParams.pszName = lpszName;
3107  InOutParams->OutParams.TagType = OutParams->TagType;
3108 
3109 Cleanup:
3110  CloseServiceHandle(hScm);
3111 
3112  /* Free memory allocated by SCM */
3113  if (OutParams != NULL)
3114  {
3115  if (OutParams->pszName != NULL)
3116  {
3117  midl_user_free(OutParams->pszName);
3118  }
3119 
3120  midl_user_free(OutParams);
3121  }
3122 
3123  return dwError;
3124 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define SC_MANAGER_ENUMERATE_SERVICE
Definition: winsvc.h:16
#define midl_user_free
Definition: rpc.h:45
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
TAG_INFO_NAME_FROM_TAG_OUT_PARAMS OutParams
Definition: svcctl.idl:320
TAG_INFO_NAME_FROM_TAG_IN_PARAMS InParams
Definition: svcctl.idl:319
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1040
#define UNICODE_NULL
#define RpcTryExcept
Definition: rpc.h:126
BOOL WINAPI CloseServiceHandle(SC_HANDLE hSCObject)
Definition: scm.c:580
#define RpcExceptionCode()
Definition: rpc.h:132
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
DWORD WINAPI RI_ScQueryServiceTagInfo(SC_RPC_HANDLE hSCManager, TAG_INFO_LEVEL dwInfoLevel, PTAG_INFO_NAME_FROM_TAG_IN_PARAMS *lpInParams, PTAG_INFO_NAME_FROM_TAG_OUT_PARAMS *lpOutParams)
Definition: rpcserver.c:6593
SC_HANDLE WINAPI OpenSCManagerW(LPCWSTR lpMachineName, LPCWSTR lpDatabaseName, DWORD dwDesiredAccess)
Definition: scm.c:2016
static const WCHAR Cleanup[]
Definition: register.c:80
_In_ DWORD dwInfoLevel
Definition: winsvc.h:422
#define ERROR_INVALID_DATA
Definition: winerror.h:116
#define ERROR_RETRY
Definition: winerror.h:740
#define NULL
Definition: types.h:112
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define LPTR
Definition: winbase.h:378
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1373
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by I_QueryTagInformation().

◆ LockServiceDatabase()

SC_LOCK WINAPI LockServiceDatabase ( SC_HANDLE  hSCManager)

Definition at line 1906 of file scm.c.

1907 {
1908  SC_LOCK hLock;
1909  DWORD dwError;
1910 
1911  TRACE("LockServiceDatabase(%p)\n",
1912  hSCManager);
1913 
1914  RpcTryExcept
1915  {
1917  (SC_RPC_LOCK *)&hLock);
1918  }
1920  {
1922  }
1923  RpcEndExcept;
1924 
1925  if (dwError != ERROR_SUCCESS)
1926  {
1927  TRACE("RLockServiceDatabase() failed (Error %lu)\n", dwError);
1928  SetLastError(dwError);
1929  return NULL;
1930  }
1931 
1932  TRACE("hLock = %p\n", hLock);
1933 
1934  return hLock;
1935 }
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
SC_HANDLE hSCManager
Definition: sc.c:12
#define NULL
Definition: types.h:112
DWORD WINAPI RLockServiceDatabase(SC_RPC_HANDLE hSCManager, LPSC_RPC_LOCK lpLock)
Definition: rpcserver.c:1362
#define RpcExcept(expr)
Definition: rpc.h:127

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

◆ NotifyBootConfigStatus()

BOOL WINAPI NotifyBootConfigStatus ( BOOL  BootAcceptable)

Definition at line 3003 of file scm.c.

3004 {
3005  DWORD dwError;
3006 
3007  TRACE("NotifyBootConfigStatus(%u)\n",
3008  BootAcceptable);
3009 
3010  RpcTryExcept
3011  {
3012  dwError = RNotifyBootConfigStatus(NULL,
3013  BootAcceptable);
3014  }
3016  {
3018  }
3019  RpcEndExcept;
3020 
3021  if (dwError != ERROR_SUCCESS)
3022  {
3023  TRACE("NotifyBootConfigStatus() failed (Error %lu)\n", dwError);
3024  SetLastError(dwError);
3025  return FALSE;
3026  }
3027 
3028  return TRUE;
3029 }
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
DWORD WINAPI RNotifyBootConfigStatus(SVCCTL_HANDLEW lpMachineName, DWORD BootAcceptable)
Definition: rpcserver.c:1849
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
#define NULL
Definition: types.h:112
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by _tmain().

◆ OpenSCManagerA()

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

Definition at line 1972 of file scm.c.

1975 {
1976  SC_HANDLE hScm = NULL;
1977  DWORD dwError;
1978 
1979  TRACE("OpenSCManagerA(%s %s %lx)\n",
1980  debugstr_a(lpMachineName), debugstr_a(lpDatabaseName), dwDesiredAccess);
1981 
1982  WaitForSCManager();
1983 
1984  RpcTryExcept
1985  {
1986  dwError = ROpenSCManagerA((LPSTR)lpMachineName,
1987  (LPSTR)lpDatabaseName,
1988  dwDesiredAccess,
1989  (SC_RPC_HANDLE *)&hScm);
1990  }
1992  {
1994  }
1995  RpcEndExcept;
1996 
1997  SetLastError(dwError);
1998  if (dwError != ERROR_SUCCESS)
1999  {
2000  TRACE("ROpenSCManagerA() failed (Error %lu)\n", dwError);
2001  return NULL;
2002  }
2003 
2004  TRACE("hScm = %p\n", hScm);
2005 
2006  return hScm;
2007 }
static VOID WaitForSCManager(VOID)
Definition: scm.c:1939
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
char * LPSTR
Definition: xmlstorage.h:182
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define debugstr_a
Definition: kernel32.h:31
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
DWORD WINAPI ROpenSCManagerA(LPSTR lpMachineName, LPSTR lpDatabaseName, DWORD dwDesiredAccess, LPSC_RPC_HANDLE lpScHandle)
Definition: rpcserver.c:4006
#define NULL
Definition: types.h:112
#define RpcExcept(expr)
Definition: rpc.h:127

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

◆ OpenSCManagerW()

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

Definition at line 2016 of file scm.c.

2019 {
2020  SC_HANDLE hScm = NULL;
2021  DWORD dwError;
2022 
2023  TRACE("OpenSCManagerW(%s %s %lx)\n",
2024  debugstr_w(lpMachineName), debugstr_w(lpDatabaseName), dwDesiredAccess);
2025 
2026  WaitForSCManager();
2027 
2028  RpcTryExcept
2029  {
2030  dwError = ROpenSCManagerW((LPWSTR)lpMachineName,
2031  (LPWSTR)lpDatabaseName,
2032  dwDesiredAccess,
2033  (SC_RPC_HANDLE *)&hScm);
2034  }
2036  {
2038  }
2039  RpcEndExcept;
2040 
2041  SetLastError(dwError);
2042  if (dwError != ERROR_SUCCESS)
2043  {
2044  TRACE("ROpenSCManagerW() failed (Error %lu)\n", dwError);
2045  return NULL;
2046  }
2047 
2048  TRACE("hScm = %p\n", hScm);
2049 
2050  return hScm;
2051 }
static VOID WaitForSCManager(VOID)
Definition: scm.c:1939
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
DWORD WINAPI ROpenSCManagerW(LPWSTR lpMachineName, LPWSTR lpDatabaseName, DWORD dwDesiredAccess, LPSC_RPC_HANDLE lpScHandle)
Definition: rpcserver.c:2868
#define debugstr_w
Definition: kernel32.h:32
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
#define NULL
Definition: types.h:112
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define RpcExcept(expr)
Definition: rpc.h:127

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

◆ OpenServiceA()

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

Definition at line 2060 of file scm.c.

2063 {
2064  SC_HANDLE hService = NULL;
2065  DWORD dwError;
2066 
2067  TRACE("OpenServiceA(%p %s %lx)\n",
2068  hSCManager, debugstr_a(lpServiceName), dwDesiredAccess);
2069 
2070  if (!hSCManager)
2071  {
2073  return NULL;
2074  }
2075 
2076  RpcTryExcept
2077  {
2079  (LPSTR)lpServiceName,
2080  dwDesiredAccess,
2081  (SC_RPC_HANDLE *)&hService);
2082  }
2084  {
2086  }
2087  RpcEndExcept;
2088 
2089  SetLastError(dwError);
2090  if (dwError != ERROR_SUCCESS)
2091  {
2092  TRACE("ROpenServiceA() failed (Error %lu)\n", dwError);
2093  return NULL;
2094  }
2095 
2096  TRACE("hService = %p\n", hService);
2097 
2098  return hService;
2099 }
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
char * LPSTR
Definition: xmlstorage.h:182
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define debugstr_a
Definition: kernel32.h:31
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
SC_HANDLE hSCManager
Definition: sc.c:12
#define NULL
Definition: types.h:112
DWORD WINAPI ROpenServiceA(SC_RPC_HANDLE hSCManager, LPSTR lpServiceName, DWORD dwDesiredAccess, LPSC_RPC_HANDLE lpServiceHandle)
Definition: rpcserver.c:4044
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by check_service_is_installed(), delete_test_service(), test_create_delete_svc(), test_delete_services(), test_driver_install(), test_get_displayname(), test_get_servicekeyname(), test_install_services(), test_install_svc_from(), test_open_svc(), test_query_svc(), test_queryconfig2(), Test_QueryServiceConfig2A(), test_refcount(), test_sequence(), test_servicenotify(), test_SetupDiInstallClassExA(), test_SetupInstallServicesFromInfSectionExA(), test_start_stop(), and test_start_stop_services().

◆ OpenServiceW()

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

Definition at line 2108 of file scm.c.

2111 {
2112  SC_HANDLE hService = NULL;
2113  DWORD dwError;
2114 
2115  TRACE("OpenServiceW(%p %s %lx)\n",
2116  hSCManager, debugstr_w(lpServiceName), dwDesiredAccess);
2117 
2118  if (!hSCManager)
2119  {
2121  return NULL;
2122  }
2123 
2124  RpcTryExcept
2125  {
2127  (LPWSTR)lpServiceName,
2128  dwDesiredAccess,
2129  (SC_RPC_HANDLE *)&hService);
2130  }
2132  {
2134  }
2135  RpcEndExcept;
2136 
2137  SetLastError(dwError);
2138  if (dwError != ERROR_SUCCESS)
2139  {
2140  TRACE("ROpenServiceW() failed (Error %lu)\n", dwError);
2141  return NULL;
2142  }
2143 
2144  TRACE("hService = %p\n", hService);
2145 
2146  return hService;
2147 }
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
#define debugstr_w
Definition: kernel32.h:32
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
DWORD WINAPI ROpenServiceW(SC_RPC_HANDLE hSCManager, LPWSTR lpServiceName, DWORD dwDesiredAccess, LPSC_RPC_HANDLE lpServiceHandle)
Definition: rpcserver.c:2920
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
SC_HANDLE hSCManager
Definition: sc.c:12
#define NULL
Definition: types.h:112
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define RpcExcept(expr)
Definition: rpc.h:127

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

◆ QueryServiceConfig2A()

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

Definition at line 2322 of file scm.c.

2327 {
2328  SERVICE_DESCRIPTIONA ServiceDescription;
2329  SERVICE_FAILURE_ACTIONSA ServiceFailureActions;
2330  LPBYTE lpTempBuffer;
2331  BOOL bUseTempBuffer = FALSE;
2332  DWORD dwBufferSize;
2333  DWORD dwError;
2334 
2335  TRACE("QueryServiceConfig2A(%p %lu %p %lu %p)\n",
2337 
2338  lpTempBuffer = lpBuffer;
2339  dwBufferSize = cbBufSize;
2340 
2341  switch (dwInfoLevel)
2342  {
2344  if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_DESCRIPTIONA)))
2345  {
2346  lpTempBuffer = (LPBYTE)&ServiceDescription;
2347  dwBufferSize = sizeof(SERVICE_DESCRIPTIONA);
2348  bUseTempBuffer = TRUE;
2349  }
2350  break;
2351 
2353  if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_FAILURE_ACTIONSA)))
2354  {
2355  lpTempBuffer = (LPBYTE)&ServiceFailureActions;
2356  dwBufferSize = sizeof(SERVICE_FAILURE_ACTIONSA);
2357  bUseTempBuffer = TRUE;
2358  }
2359  break;
2360 
2361  default:
2362  WARN("Unknown info level 0x%lx\n", dwInfoLevel);
2364  return FALSE;
2365  }
2366 
2367  RpcTryExcept
2368  {
2369  dwError = RQueryServiceConfig2A((SC_RPC_HANDLE)hService,
2370  dwInfoLevel,
2371  lpTempBuffer,
2372  dwBufferSize,
2373  pcbBytesNeeded);
2374  }
2376  {
2378  }
2379  RpcEndExcept;
2380 
2381  if (dwError != ERROR_SUCCESS)
2382  {
2383  TRACE("RQueryServiceConfig2A() failed (Error %lu)\n", dwError);
2384  SetLastError(dwError);
2385  return FALSE;
2386  }
2387 
2388  if (bUseTempBuffer != FALSE)
2389  {
2390  TRACE("RQueryServiceConfig2A() returns ERROR_INSUFFICIENT_BUFFER\n");
2391  *pcbBytesNeeded = dwBufferSize;
2393  return FALSE;
2394  }
2395 
2396  switch (dwInfoLevel)
2397  {
2399  {
2400  LPSERVICE_DESCRIPTIONA lpPtr = (LPSERVICE_DESCRIPTIONA)lpTempBuffer;
2401 
2402  if (lpPtr->lpDescription != NULL)
2403  lpPtr->lpDescription =
2404  (LPSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpDescription);
2405  }
2406  break;
2407 
2409  {
2411 
2412  if (lpPtr->lpRebootMsg != NULL)
2413  lpPtr->lpRebootMsg =
2414  (LPSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpRebootMsg);
2415 
2416  if (lpPtr->lpCommand != NULL)
2417  lpPtr->lpCommand =
2418  (LPSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpCommand);
2419 
2420  if (lpPtr->lpsaActions != NULL)
2421  lpPtr->lpsaActions =
2422  (LPSC_ACTION)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpsaActions);
2423  }
2424  break;
2425  }
2426 
2427  TRACE("QueryServiceConfig2A() done\n");
2428 
2429  return TRUE;
2430 }
#define RpcEndExcept
Definition: rpc.h:128
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
Definition: winsvc.h:424
struct _SERVICE_DESCRIPTIONA * LPSERVICE_DESCRIPTIONA
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
struct _SERVICE_FAILURE_ACTIONSA SERVICE_FAILURE_ACTIONSA
#define WARN(fmt,...)
Definition: debug.h:112
#define SERVICE_CONFIG_DESCRIPTION
Definition: winsvc.h:65
char * LPSTR
Definition: xmlstorage.h:182
uint32_t ULONG_PTR
Definition: typedefs.h:65
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
#define RpcTryExcept
Definition: rpc.h:126
DWORD WINAPI RQueryServiceConfig2A(SC_RPC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
Definition: rpcserver.c:5552
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
#define SERVICE_CONFIG_FAILURE_ACTIONS
Definition: winsvc.h:66
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ DWORD _In_ DWORD cbBufSize
Definition: winsvc.h:424
#define SetLastError(x)
Definition: compat.h:611
_In_ DWORD dwInfoLevel
Definition: winsvc.h:422
struct _SERVICE_DESCRIPTIONA SERVICE_DESCRIPTIONA
SC_ACTION * lpsaActions
Definition: winsvc.h:213
#define NULL
Definition: types.h:112
#define ULONG_PTR
Definition: config.h:101
#define ERROR_INVALID_LEVEL
Definition: winerror.h:196
struct _SC_ACTION * LPSC_ACTION
struct _SERVICE_FAILURE_ACTIONSA * LPSERVICE_FAILURE_ACTIONSA
#define RpcExcept(expr)
Definition: rpc.h:127
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

Referenced by QueryConfig2A().

◆ QueryServiceConfig2W()

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

Definition at line 2439 of file scm.c.

2444 {
2445  SERVICE_DESCRIPTIONW ServiceDescription;
2446  SERVICE_FAILURE_ACTIONSW ServiceFailureActions;
2447  LPBYTE lpTempBuffer;
2448  BOOL bUseTempBuffer = FALSE;
2449  DWORD dwBufferSize;
2450  DWORD dwError;
2451 
2452  TRACE("QueryServiceConfig2W(%p %lu %p %lu %p)\n",
2454 
2455  lpTempBuffer = lpBuffer;
2456  dwBufferSize = cbBufSize;
2457 
2458  switch (dwInfoLevel)
2459  {
2461  if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_DESCRIPTIONW)))
2462  {
2463  lpTempBuffer = (LPBYTE)&ServiceDescription;
2464  dwBufferSize = sizeof(SERVICE_DESCRIPTIONW);
2465  bUseTempBuffer = TRUE;
2466  }
2467  break;
2468 
2470  if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_FAILURE_ACTIONSW)))
2471  {
2472  lpTempBuffer = (LPBYTE)&ServiceFailureActions;
2473  dwBufferSize = sizeof(SERVICE_FAILURE_ACTIONSW);
2474  bUseTempBuffer = TRUE;
2475  }
2476  break;
2477 
2478  default:
2479  WARN("Unknown info level 0x%lx\n", dwInfoLevel);
2481  return FALSE;
2482  }
2483 
2484  RpcTryExcept
2485  {
2486  dwError = RQueryServiceConfig2W((SC_RPC_HANDLE)hService,
2487  dwInfoLevel,
2488  lpTempBuffer,
2489  dwBufferSize,
2490  pcbBytesNeeded);
2491  }
2493  {
2495  }
2496  RpcEndExcept;
2497 
2498  if (dwError != ERROR_SUCCESS)
2499  {
2500  TRACE("RQueryServiceConfig2W() failed (Error %lu)\n", dwError);
2501  SetLastError(dwError);
2502  return FALSE;
2503  }
2504 
2505  if (bUseTempBuffer != FALSE)
2506  {
2507  TRACE("RQueryServiceConfig2W() returns ERROR_INSUFFICIENT_BUFFER\n");
2508  *pcbBytesNeeded = dwBufferSize;
2510  return FALSE;
2511  }
2512 
2513  switch (dwInfoLevel)
2514  {
2516  {
2517  LPSERVICE_DESCRIPTIONW lpPtr = (LPSERVICE_DESCRIPTIONW)lpTempBuffer;
2518 
2519  if (lpPtr->lpDescription != NULL)
2520  lpPtr->lpDescription =
2521  (LPWSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpDescription);
2522  }
2523  break;
2524 
2526  {
2528 
2529  if (lpPtr->lpRebootMsg != NULL)
2530  lpPtr->lpRebootMsg =
2531  (LPWSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpRebootMsg);
2532 
2533  if (lpPtr->lpCommand != NULL)
2534  lpPtr->lpCommand =
2535  (LPWSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpCommand);
2536 
2537  if (lpPtr->lpsaActions != NULL)
2538  lpPtr->lpsaActions =
2539  (LPSC_ACTION)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpsaActions);
2540  }
2541  break;
2542  }
2543 
2544  TRACE("QueryServiceConfig2W() done\n");
2545 
2546  return TRUE;
2547 }
#define RpcEndExcept
Definition: rpc.h:128
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
Definition: winsvc.h:424
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
SC_ACTION * lpsaActions
Definition: winsvc.h:220
#define WARN(fmt,...)
Definition: debug.h:112
struct _SERVICE_DESCRIPTIONW SERVICE_DESCRIPTIONW
#define SERVICE_CONFIG_DESCRIPTION
Definition: winsvc.h:65
uint32_t ULONG_PTR
Definition: typedefs.h:65
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD WINAPI RQueryServiceConfig2W(SC_RPC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
Definition: rpcserver.c:5799
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
struct _SERVICE_DESCRIPTIONW * LPSERVICE_DESCRIPTIONW
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
struct _SERVICE_FAILURE_ACTIONSW SERVICE_FAILURE_ACTIONSW
#define SERVICE_CONFIG_FAILURE_ACTIONS
Definition: winsvc.h:66
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ DWORD _In_ DWORD cbBufSize
Definition: winsvc.h:424
#define SetLastError(x)
Definition: compat.h:611
LPWSTR lpDescription
Definition: winsvc.h:196
_In_ DWORD dwInfoLevel
Definition: winsvc.h:422
struct _SERVICE_FAILURE_ACTIONSW * LPSERVICE_FAILURE_ACTIONSW
#define NULL
Definition: types.h:112
#define ULONG_PTR
Definition: config.h:101
#define ERROR_INVALID_LEVEL
Definition: winerror.h:196
WCHAR * LPWSTR
Definition: xmlstorage.h:184
struct _SC_ACTION * LPSC_ACTION
#define RpcExcept(expr)
Definition: rpc.h:127
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

Referenced by GetServiceDescription(), and QueryConfig2W().

◆ QueryServiceConfigA()

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

Definition at line 2156 of file scm.c.

2160 {
2161  QUERY_SERVICE_CONFIGA ServiceConfig;
2162  LPQUERY_SERVICE_CONFIGA lpConfigPtr;
2163  DWORD dwBufferSize;
2164  DWORD dwError;
2165 
2166  TRACE("QueryServiceConfigA(%p %p %lu %p)\n",
2167  hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
2168 
2169  if (lpServiceConfig == NULL ||
2170  cbBufSize < sizeof(QUERY_SERVICE_CONFIGA))
2171  {
2172  lpConfigPtr = &ServiceConfig;
2173  dwBufferSize = sizeof(QUERY_SERVICE_CONFIGA);
2174  }
2175  else
2176  {
2177  lpConfigPtr = lpServiceConfig;
2178  dwBufferSize = cbBufSize;
2179  }
2180 
2181  RpcTryExcept
2182  {
2183  dwError = RQueryServiceConfigA((SC_RPC_HANDLE)hService,
2184  (LPBYTE)lpConfigPtr,
2185  dwBufferSize,
2186  pcbBytesNeeded);
2187  }
2189  {
2191  }
2192  RpcEndExcept;
2193 
2194  if (dwError != ERROR_SUCCESS)
2195  {
2196  TRACE("RQueryServiceConfigA() failed (Error %lu)\n", dwError);
2197  SetLastError(dwError);
2198  return FALSE;
2199  }
2200 
2201  /* Adjust the pointers */
2202  if (lpConfigPtr->lpBinaryPathName)
2203  lpConfigPtr->lpBinaryPathName =
2204  (LPSTR)((ULONG_PTR)lpConfigPtr +
2205  (ULONG_PTR)lpConfigPtr->lpBinaryPathName);
2206 
2207  if (lpConfigPtr->lpLoadOrderGroup)
2208  lpConfigPtr->lpLoadOrderGroup =
2209  (LPSTR)((ULONG_PTR)lpConfigPtr +
2210  (ULONG_PTR)lpConfigPtr->lpLoadOrderGroup);
2211 
2212  if (lpConfigPtr->lpDependencies)
2213  lpConfigPtr->lpDependencies =
2214  (LPSTR)((ULONG_PTR)lpConfigPtr +
2215  (ULONG_PTR)lpConfigPtr->lpDependencies);
2216 
2217  if (lpConfigPtr->lpServiceStartName)
2218  lpConfigPtr->lpServiceStartName =
2219  (LPSTR)((ULONG_PTR)lpConfigPtr +
2220  (ULONG_PTR)lpConfigPtr->lpServiceStartName);
2221 
2222  if (lpConfigPtr->lpDisplayName)
2223  lpConfigPtr->lpDisplayName =
2224  (LPSTR)((ULONG_PTR)lpConfigPtr +
2225  (ULONG_PTR)lpConfigPtr->lpDisplayName);
2226 
2227  TRACE("QueryServiceConfigA() done\n");
2228 
2229  return TRUE;
2230 }
#define RpcEndExcept
Definition: rpc.h:128
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
Definition: winsvc.h:424
#define ERROR_SUCCESS
Definition: deptool.c:10
LPSTR lpServiceStartName
Definition: winsvc.h:152
#define TRUE
Definition: types.h:120
struct _QUERY_SERVICE_CONFIGA QUERY_SERVICE_CONFIGA
char * LPSTR
Definition: xmlstorage.h:182
uint32_t ULONG_PTR
Definition: typedefs.h:65
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ DWORD _In_ DWORD cbBufSize
Definition: winsvc.h:424
#define SetLastError(x)
Definition: compat.h:611
#define NULL
Definition: types.h:112
#define ULONG_PTR
Definition: config.h:101
DWORD WINAPI RQueryServiceConfigA(SC_RPC_HANDLE hService, LPBYTE lpBuf, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
Definition: rpcserver.c:4074
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by test_sequence().

◆ QueryServiceConfigW()

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

Definition at line 2239 of file scm.c.

2243 {
2244  QUERY_SERVICE_CONFIGW ServiceConfig;
2245  LPQUERY_SERVICE_CONFIGW lpConfigPtr;
2246  DWORD dwBufferSize;
2247  DWORD dwError;
2248 
2249  TRACE("QueryServiceConfigW(%p %p %lu %p)\n",
2250  hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
2251 
2252  if (lpServiceConfig == NULL ||
2253  cbBufSize < sizeof(QUERY_SERVICE_CONFIGW))
2254  {
2255  lpConfigPtr = &ServiceConfig;
2256  dwBufferSize = sizeof(QUERY_SERVICE_CONFIGW);
2257  }
2258  else
2259  {
2260  lpConfigPtr = lpServiceConfig;
2261  dwBufferSize = cbBufSize;
2262  }
2263 
2264  RpcTryExcept
2265  {
2266  dwError = RQueryServiceConfigW((SC_RPC_HANDLE)hService,
2267  (LPBYTE)lpConfigPtr,
2268  dwBufferSize,
2269  pcbBytesNeeded);
2270  }
2272  {
2274  }
2275  RpcEndExcept;
2276 
2277  if (dwError != ERROR_SUCCESS)
2278  {
2279  TRACE("RQueryServiceConfigW() failed (Error %lu)\n", dwError);
2280  SetLastError(dwError);
2281  return FALSE;
2282  }
2283 
2284  /* Adjust the pointers */
2285  if (lpConfigPtr->lpBinaryPathName)
2286  lpConfigPtr->lpBinaryPathName =
2287  (LPWSTR)((ULONG_PTR)lpConfigPtr +
2288  (ULONG_PTR)lpConfigPtr->lpBinaryPathName);
2289 
2290  if (lpConfigPtr->lpLoadOrderGroup)
2291  lpConfigPtr->lpLoadOrderGroup =
2292  (LPWSTR)((ULONG_PTR)lpConfigPtr +
2293  (ULONG_PTR)lpConfigPtr->lpLoadOrderGroup);
2294 
2295  if (lpConfigPtr->lpDependencies)
2296  lpConfigPtr->lpDependencies =
2297  (LPWSTR)((ULONG_PTR)lpConfigPtr +
2298  (ULONG_PTR)lpConfigPtr->lpDependencies);
2299 
2300  if (lpConfigPtr->lpServiceStartName)
2301  lpConfigPtr->lpServiceStartName =
2302  (LPWSTR)((ULONG_PTR)lpConfigPtr +
2303  (ULONG_PTR)lpConfigPtr->lpServiceStartName);
2304 
2305  if (lpConfigPtr->lpDisplayName)
2306  lpConfigPtr->lpDisplayName =
2307  (LPWSTR)((ULONG_PTR)lpConfigPtr +
2308  (ULONG_PTR)lpConfigPtr->lpDisplayName);
2309 
2310  TRACE("QueryServiceConfigW() done\n");
2311 
2312  return TRUE;
2313 }
DWORD WINAPI RQueryServiceConfigW(SC_RPC_HANDLE hService, LPBYTE lpBuf, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
Definition: rpcserver.c:3003
#define RpcEndExcept
Definition: rpc.h:128
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
Definition: winsvc.h:424
struct _QUERY_SERVICE_CONFIGW QUERY_SERVICE_CONFIGW
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
LPWSTR lpLoadOrderGroup
Definition: winsvc.h:160
uint32_t ULONG_PTR
Definition: typedefs.h:65
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ DWORD _In_ DWORD cbBufSize
Definition: winsvc.h:424
#define SetLastError(x)
Definition: compat.h:611
#define NULL
Definition: types.h:112
LPWSTR lpServiceStartName
Definition: winsvc.h:163
#define ULONG_PTR
Definition: config.h:101
LPWSTR lpBinaryPathName
Definition: winsvc.h:159
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define RpcExcept(expr)
Definition: rpc.h:127

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

◆ QueryServiceLockStatusA()

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

Definition at line 2556 of file scm.c.

2560 {
2561  QUERY_SERVICE_LOCK_STATUSA LockStatus;
2562  LPQUERY_SERVICE_LOCK_STATUSA lpStatusPtr;
2563  DWORD dwBufferSize;
2564  DWORD dwError;
2565 
2566  TRACE("QueryServiceLockStatusA(%p %p %lu %p)\n",
2567  hSCManager, lpLockStatus, cbBufSize, pcbBytesNeeded);
2568 
2569  if (lpLockStatus == NULL || cbBufSize < sizeof(QUERY_SERVICE_LOCK_STATUSA))
2570  {
2571  lpStatusPtr = &LockStatus;
2572  dwBufferSize = sizeof(QUERY_SERVICE_LOCK_STATUSA);
2573  }
2574  else
2575  {
2576  lpStatusPtr = lpLockStatus;
2577  dwBufferSize = cbBufSize;
2578  }
2579 
2580  RpcTryExcept
2581  {
2583  (LPBYTE)lpStatusPtr,
2584  dwBufferSize,
2585  pcbBytesNeeded);
2586  }
2588  {
2590  }
2591  RpcEndExcept;
2592 
2593  if (dwError != ERROR_SUCCESS)
2594  {
2595  TRACE("RQueryServiceLockStatusA() failed (Error %lu)\n", dwError);
2596  SetLastError(dwError);
2597  return FALSE;
2598  }
2599 
2600  if (lpStatusPtr->lpLockOwner != NULL)
2601  {
2602  lpStatusPtr->lpLockOwner =
2603  (LPSTR)((ULONG_PTR)lpStatusPtr + (ULONG_PTR)lpStatusPtr->lpLockOwner);
2604  }
2605 
2606  TRACE("QueryServiceLockStatusA() done\n");
2607 
2608  return TRUE;
2609 }
#define RpcEndExcept
Definition: rpc.h:128
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
Definition: winsvc.h:424
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
char * LPSTR
Definition: xmlstorage.h:182
uint32_t ULONG_PTR
Definition: typedefs.h:65
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ DWORD _In_ DWORD cbBufSize
Definition: winsvc.h:424
#define SetLastError(x)
Definition: compat.h:611
SC_HANDLE hSCManager
Definition: sc.c:12
struct _QUERY_SERVICE_LOCK_STATUSA QUERY_SERVICE_LOCK_STATUSA
DWORD WINAPI RQueryServiceLockStatusA(SC_RPC_HANDLE hSCManager, LPBYTE lpBuf, DWORD cbBufSize, LPBOUNDED_DWORD_4K pcbBytesNeeded)
Definition: rpcserver.c:4315
#define NULL
Definition: types.h:112
#define ULONG_PTR
Definition: config.h:101
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by Test_QueryLockStatusA().

◆ QueryServiceLockStatusW()

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

Definition at line 2618 of file scm.c.

2622 {
2623  QUERY_SERVICE_LOCK_STATUSW LockStatus;
2624  LPQUERY_SERVICE_LOCK_STATUSW lpStatusPtr;
2625  DWORD dwBufferSize;
2626  DWORD dwError;
2627 
2628  TRACE("QueryServiceLockStatusW(%p %p %lu %p)\n",
2629  hSCManager, lpLockStatus, cbBufSize, pcbBytesNeeded);
2630 
2631  if (lpLockStatus == NULL || cbBufSize < sizeof(QUERY_SERVICE_LOCK_STATUSW))
2632  {
2633  lpStatusPtr = &LockStatus;
2634  dwBufferSize = sizeof(QUERY_SERVICE_LOCK_STATUSW);
2635  }
2636  else
2637  {
2638  lpStatusPtr = lpLockStatus;
2639  dwBufferSize = cbBufSize;
2640  }
2641 
2642  RpcTryExcept
2643  {
2645  (LPBYTE)lpStatusPtr,
2646  dwBufferSize,
2647  pcbBytesNeeded);
2648  }
2650  {
2652  }
2653  RpcEndExcept;
2654 
2655  if (dwError != ERROR_SUCCESS)
2656  {
2657  TRACE("RQueryServiceLockStatusW() failed (Error %lu)\n", dwError);
2658  SetLastError(dwError);
2659  return FALSE;
2660  }
2661 
2662  if (lpStatusPtr->lpLockOwner != NULL)
2663  {
2664  lpStatusPtr->lpLockOwner =
2665  (LPWSTR)((ULONG_PTR)lpStatusPtr + (ULONG_PTR)lpStatusPtr->lpLockOwner);
2666  }
2667 
2668  TRACE("QueryServiceLockStatusW() done\n");
2669 
2670  return TRUE;
2671 }
#define RpcEndExcept
Definition: rpc.h:128
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
Definition: winsvc.h:424
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
uint32_t ULONG_PTR
Definition: typedefs.h:65
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
struct _QUERY_SERVICE_LOCK_STATUSW QUERY_SERVICE_LOCK_STATUSW
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ DWORD _In_ DWORD cbBufSize
Definition: winsvc.h:424
#define SetLastError(x)
Definition: compat.h:611
SC_HANDLE hSCManager
Definition: sc.c:12
#define NULL
Definition: types.h:112
#define ULONG_PTR
Definition: config.h:101
DWORD WINAPI RQueryServiceLockStatusW(SC_RPC_HANDLE hSCManager, LPBYTE lpBuf, DWORD cbBufSize, LPBOUNDED_DWORD_4K pcbBytesNeeded)
Definition: rpcserver.c:3211
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by Test_QueryLockStatusW().

◆ QueryServiceObjectSecurity()

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

Definition at line 2680 of file scm.c.

2685 {
2686  DWORD dwError;
2687 
2688  TRACE("QueryServiceObjectSecurity(%p %lu %p)\n",
2689  hService, dwSecurityInformation, lpSecurityDescriptor);
2690 
2691  RpcTryExcept
2692  {
2693  dwError = RQueryServiceObjectSecurity((SC_RPC_HANDLE)hService,
2694  dwSecurityInformation,
2695  (LPBYTE)lpSecurityDescriptor,
2696  cbBufSize,
2697  pcbBytesNeeded);
2698  }
2700  {
2702  }
2703  RpcEndExcept;
2704 
2705  if (dwError != ERROR_SUCCESS)
2706  {
2707  TRACE("QueryServiceObjectSecurity() failed (Error %lu)\n", dwError);
2708  SetLastError(dwError);
2709  return FALSE;
2710  }
2711 
2712  return TRUE;
2713 }
#define RpcEndExcept
Definition: rpc.h:128
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
Definition: winsvc.h:424
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
DWORD WINAPI RQueryServiceObjectSecurity(SC_RPC_HANDLE hService, SECURITY_INFORMATION dwSecurityInformation, LPBYTE lpSecurityDescriptor, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded)
Definition: rpcserver.c:1390
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ DWORD _In_ DWORD cbBufSize
Definition: winsvc.h:424
#define SetLastError(x)
Definition: compat.h:611
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by AccRewriteGetHandleRights(), and SdShow().

◆ QueryServiceStatus()

BOOL WINAPI QueryServiceStatus ( SC_HANDLE  hService,
LPSERVICE_STATUS  lpServiceStatus 
)

Definition at line 2793 of file scm.c.

2795 {
2796  DWORD dwError;
2797 
2798  TRACE("QueryServiceStatus(%p %p)\n",
2799  hService, lpServiceStatus);
2800 
2801  if (!hService)
2802  {
2804  return FALSE;
2805  }
2806 
2807  RpcTryExcept
2808  {
2809  dwError = RQueryServiceStatus((SC_RPC_HANDLE)hService,
2810  lpServiceStatus);
2811  }
2813  {
2815  }
2816  RpcEndExcept;
2817 
2818  if (dwError != ERROR_SUCCESS)
2819  {
2820  TRACE("RQueryServiceStatus() failed (Error %lu)\n", dwError);
2821  SetLastError(dwError);
2822  return FALSE;
2823  }
2824 
2825  return TRUE;
2826 }
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
DWORD WINAPI RQueryServiceStatus(SC_RPC_HANDLE hService, LPSERVICE_STATUS lpServiceStatus)
Definition: rpcserver.c:1608
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:611
#define RpcExcept(expr)
Definition: rpc.h:127

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

◆ QueryServiceStatusEx()

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

Definition at line 2835 of file scm.c.

2840 {
2841  DWORD dwError;
2842 
2843  TRACE("QueryServiceStatusEx(%p %lu %p %lu %p)\n",
2844  hService, InfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
2845 
2846  if (InfoLevel != SC_STATUS_PROCESS_INFO)
2847  {
2849  return FALSE;
2850  }
2851 
2852  if (cbBufSize < sizeof(SERVICE_STATUS_PROCESS))
2853  {
2856  return FALSE;
2857  }
2858 
2859  RpcTryExcept
2860  {
2861  dwError = RQueryServiceStatusEx((SC_RPC_HANDLE)hService,
2862  InfoLevel,
2863  lpBuffer,
2864  cbBufSize,
2865  pcbBytesNeeded);
2866  }
2868  {
2870  }
2871  RpcEndExcept;
2872 
2873  if (dwError != ERROR_SUCCESS)
2874  {
2875  TRACE("RQueryServiceStatusEx() failed (Error %lu)\n", dwError);
2876  SetLastError(dwError);
2877  return FALSE;
2878  }
2879 
2880  return TRUE;
2881 }
#define RpcEndExcept
Definition: rpc.h:128
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
Definition: winsvc.h:424
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
struct _SERVICE_STATUS_PROCESS SERVICE_STATUS_PROCESS
#define FALSE
Definition: types.h:117
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ DWORD _In_ DWORD cbBufSize
Definition: winsvc.h:424
#define SetLastError(x)
Definition: compat.h:611
DWORD WINAPI RQueryServiceStatusEx(SC_RPC_HANDLE hService, SC_STATUS_TYPE InfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
Definition: rpcserver.c:6023
#define ERROR_INVALID_LEVEL
Definition: winerror.h:196
#define RpcExcept(expr)
Definition: rpc.h:127
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

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

◆ ScmEncryptPassword()

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

Definition at line 173 of file scm.c.

178 {
179  struct ustring inData, keyData, outData;
180  BYTE SessionKey[16];
181  PBYTE pBuffer;
183 
184  /* Get the session key */
185  Status = SystemFunction028(ContextHandle,
186  SessionKey);
187  if (!NT_SUCCESS(Status))
188  {
189  ERR("SystemFunction028 failed (Status 0x%08lx)\n", Status);
191  }
192 
193  inData.Length = (wcslen(pClearTextPassword) + 1) * sizeof(WCHAR);
194  inData.MaximumLength = inData.Length;
195  inData.Buffer = (unsigned char *)pClearTextPassword;
196 
197  keyData.Length = sizeof(SessionKey);
198  keyData.MaximumLength = keyData.Length;
199  keyData.Buffer = SessionKey;
200 
201  outData.Length = 0;
202  outData.MaximumLength = 0;
203  outData.Buffer = NULL;
204 
205  /* Get the required buffer size */
206  Status = SystemFunction004(&inData,
207  &keyData,
208  &outData);
210  {
211  ERR("SystemFunction004 failed (Status 0x%08lx)\n", Status);
213  }
214 
215  /* Allocate a buffer for the encrypted password */
216  pBuffer = HeapAlloc(GetProcessHeap(), 0, outData.Length);
217  if (pBuffer == NULL)
218  return ERROR_OUTOFMEMORY;
219 
220  outData.MaximumLength = outData.Length;
221  outData.Buffer = pBuffer;
222 
223  /* Encrypt the password */
224  Status = SystemFunction004(&inData,
225  &keyData,
226  &outData);
227  if (!NT_SUCCESS(Status))
228  {
229  ERR("SystemFunction004 failed (Status 0x%08lx)\n", Status);
232  }
233 
234  *pEncryptedPassword = outData.Buffer;
235  *pEncryptedPasswordSize = outData.Length;
236 
237  return ERROR_SUCCESS;
238 }
#define ERROR_SUCCESS
Definition: deptool.c:10
LONG NTSTATUS
Definition: precomp.h:26
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
PVOID pBuffer
NTSTATUS WINAPI SystemFunction028(IN PVOID ContextHandle, OUT LPBYTE SessionKey)
Status
Definition: gdiplustypes.h:24
#define GetProcessHeap()
Definition: compat.h:595
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
NTSTATUS WINAPI SystemFunction004(const struct ustring *in, const struct ustring *key, struct ustring *out)
Definition: sysfunc.c:119
unsigned char BYTE
Definition: xxhash.c:193
#define ERR(fmt,...)
Definition: debug.h:110
Definition: config.c:18
#define NULL
Definition: types.h:112
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
BYTE * PBYTE
Definition: pedump.c:66
#define HeapFree(x, y, z)
Definition: compat.h:594
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13

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

◆ ScmRpcStatusToWinError()

DWORD ScmRpcStatusToWinError ( RPC_STATUS  Status)

Definition at line 146 of file scm.c.

147 {
148  TRACE("ScmRpcStatusToWinError(%lx)\n",
149  Status);
150 
151  switch (Status)
152  {
156  return ERROR_INVALID_HANDLE;
157 
161 
163  return ERROR_INVALID_ADDRESS;
164 
165  default:
166  return (DWORD)Status;
167  }
168 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define RPC_X_SS_IN_NULL_CONTEXT
Definition: winerror.h:1083
#define RPC_X_NULL_REF_POINTER
Definition: winerror.h:1087
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
#define RPC_X_BYTE_COUNT_TOO_SMALL
Definition: winerror.h:1089
#define RPC_S_INVALID_BINDING
Definition: winerror.h:1013
Status
Definition: gdiplustypes.h:24
#define TRACE(s)
Definition: solgame.cpp:4
unsigned long DWORD
Definition: ntddk_ex.h:95
#define ERROR_INVALID_ADDRESS
Definition: compat.h:106
#define RPC_X_ENUM_VALUE_OUT_OF_RANGE
Definition: winerror.h:1088
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242

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

◆ SetServiceObjectSecurity()

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

Definition at line 2722 of file scm.c.

2725 {
2726  PSECURITY_DESCRIPTOR SelfRelativeSD = NULL;
2727  ULONG Length;
2728  NTSTATUS Status;
2729  DWORD dwError;
2730 
2731  TRACE("SetServiceObjectSecurity(%p %lu %p)\n",
2732  hService, dwSecurityInformation, lpSecurityDescriptor);
2733 
2734  Length = 0;
2735  Status = RtlMakeSelfRelativeSD(lpSecurityDescriptor,
2736  SelfRelativeSD,
2737  &Length);
2739  {
2741  return FALSE;
2742  }
2743 
2744  SelfRelativeSD = HeapAlloc(GetProcessHeap(), 0, Length);
2745  if (SelfRelativeSD == NULL)
2746  {
2748  return FALSE;
2749  }
2750 
2751  Status = RtlMakeSelfRelativeSD(lpSecurityDescriptor,
2752  SelfRelativeSD,
2753  &Length);
2754  if (!NT_SUCCESS(Status))
2755  {
2756  HeapFree(GetProcessHeap(), 0, SelfRelativeSD);
2758  return FALSE;
2759  }
2760 
2761  RpcTryExcept
2762  {
2763  dwError = RSetServiceObjectSecurity((SC_RPC_HANDLE)hService,
2764  dwSecurityInformation,
2765  (LPBYTE)SelfRelativeSD,
2766  Length);
2767  }
2769  {
2771  }
2772  RpcEndExcept;
2773 
2774  HeapFree(GetProcessHeap(), 0, SelfRelativeSD);
2775 
2776  if (dwError != ERROR_SUCCESS)
2777  {
2778  TRACE("RServiceObjectSecurity() failed (Error %lu)\n", dwError);
2779  SetLastError(dwError);
2780  return FALSE;
2781  }
2782 
2783  return TRUE;
2784 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define RpcEndExcept
Definition: rpc.h:128
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
LONG NTSTATUS
Definition: precomp.h:26
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
#define RpcTryExcept
Definition: rpc.h:126
Status
Definition: gdiplustypes.h:24
#define RpcExceptionCode()
Definition: rpc.h:132
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:595
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define EXCEPTION_EXECUTE_HANDLER
Definition: