/* INCLUDES ******************************************************************/
#include <advapi32.h>
-
-#include "wine/debug.h"
-
WINE_DEFAULT_DEBUG_CHANNEL(advapi);
}
-handle_t __RPC_USER
-RPC_SERVICE_STATUS_HANDLE_bind(RPC_SERVICE_STATUS_HANDLE hServiceStatus)
-{
- handle_t hBinding = NULL;
- LPWSTR pszStringBinding;
- RPC_STATUS status;
-
- TRACE("RPC_SERVICE_STATUS_HANDLE_bind() called\n");
-
- status = RpcStringBindingComposeW(NULL,
- L"ncacn_np",
- NULL,
- L"\\pipe\\ntsvcs",
- NULL,
- &pszStringBinding);
- if (status != RPC_S_OK)
- {
- ERR("RpcStringBindingCompose returned 0x%x\n", status);
- return NULL;
- }
-
- /* Set the binding handle that will be used to bind to the server. */
- status = RpcBindingFromStringBindingW(pszStringBinding,
- &hBinding);
- if (status != RPC_S_OK)
- {
- ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
- }
-
- status = RpcStringFreeW(&pszStringBinding);
- if (status != RPC_S_OK)
- {
- ERR("RpcStringFree returned 0x%x\n", status);
- }
-
- return hBinding;
-}
-
-
-void __RPC_USER
-RPC_SERVICE_STATUS_HANDLE_unbind(RPC_SERVICE_STATUS_HANDLE hServiceStatus,
- handle_t hBinding)
-{
- RPC_STATUS status;
-
- TRACE("RPC_SERVICE_STATUS_HANDLE_unbind() called\n");
-
- status = RpcBindingFree(&hBinding);
- if (status != RPC_S_OK)
- {
- ERR("RpcBindingFree returned 0x%x\n", status);
- }
-}
-
-
DWORD
ScmRpcStatusToWinError(RPC_STATUS Status)
{
if (dwError != ERROR_SUCCESS)
{
- ERR("RChangeServiceConfig2A() failed (Error %lu)\n", dwError);
+ TRACE("RChangeServiceConfig2A() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RChangeServiceConfig2W() failed (Error %lu)\n", dwError);
+ TRACE("RChangeServiceConfig2W() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RChangeServiceConfigA() failed (Error %lu)\n", dwError);
+ TRACE("RChangeServiceConfigA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RChangeServiceConfigW() failed (Error %lu)\n", dwError);
+ TRACE("RChangeServiceConfigW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError)
{
- ERR("RCloseServiceHandle() failed (Error %lu)\n", dwError);
+ TRACE("RCloseServiceHandle() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RControlService() failed (Error %lu)\n", dwError);
+ TRACE("RControlService() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RCreateServiceA() failed (Error %lu)\n", dwError);
+ TRACE("RCreateServiceA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return NULL;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RCreateServiceW() failed (Error %lu)\n", dwError);
+ TRACE("RCreateServiceW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return NULL;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RDeleteService() failed (Error %lu)\n", dwError);
+ TRACE("RDeleteService() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
LPDWORD pcbBytesNeeded,
LPDWORD lpServicesReturned)
{
+ ENUM_SERVICE_STATUSA ServiceStatus;
LPENUM_SERVICE_STATUSA lpStatusPtr;
+ DWORD dwBufferSize;
DWORD dwError;
DWORD dwCount;
- TRACE("EnumServicesStatusA() called\n");
+ TRACE("EnumDependentServicesA() called\n");
+
+ if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSA))
+ {
+ lpStatusPtr = &ServiceStatus;
+ dwBufferSize = sizeof(ENUM_SERVICE_STATUSA);
+ }
+ else
+ {
+ lpStatusPtr = lpServices;
+ dwBufferSize = cbBufSize;
+ }
RpcTryExcept
{
dwError = REnumDependentServicesA((SC_RPC_HANDLE)hService,
dwServiceState,
- (LPBYTE)lpServices,
- cbBufSize,
+ (LPBYTE)lpStatusPtr,
+ dwBufferSize,
pcbBytesNeeded,
lpServicesReturned);
}
if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
{
- lpStatusPtr = (LPENUM_SERVICE_STATUSA)lpServices;
- for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ if (*lpServicesReturned > 0)
{
- if (lpStatusPtr->lpServiceName)
- lpStatusPtr->lpServiceName =
- (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
+ for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ {
+ if (lpStatusPtr->lpServiceName)
+ lpStatusPtr->lpServiceName =
+ (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
- if (lpStatusPtr->lpDisplayName)
- lpStatusPtr->lpDisplayName =
- (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
+ if (lpStatusPtr->lpDisplayName)
+ lpStatusPtr->lpDisplayName =
+ (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
- lpStatusPtr++;
+ lpStatusPtr++;
+ }
}
}
if (dwError != ERROR_SUCCESS)
{
- ERR("REnumDependentServicesA() failed (Error %lu)\n", dwError);
+ TRACE("REnumDependentServicesA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
LPDWORD pcbBytesNeeded,
LPDWORD lpServicesReturned)
{
+ ENUM_SERVICE_STATUSW ServiceStatus;
LPENUM_SERVICE_STATUSW lpStatusPtr;
+ DWORD dwBufferSize;
DWORD dwError;
DWORD dwCount;
- TRACE("EnumServicesStatusW() called\n");
+ TRACE("EnumDependentServicesW() called\n");
+
+ if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSW))
+ {
+ lpStatusPtr = &ServiceStatus;
+ dwBufferSize = sizeof(ENUM_SERVICE_STATUSW);
+ }
+ else
+ {
+ lpStatusPtr = lpServices;
+ dwBufferSize = cbBufSize;
+ }
RpcTryExcept
{
dwError = REnumDependentServicesW((SC_RPC_HANDLE)hService,
dwServiceState,
- (LPBYTE)lpServices,
- cbBufSize,
+ (LPBYTE)lpStatusPtr,
+ dwBufferSize,
pcbBytesNeeded,
lpServicesReturned);
}
if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
{
- lpStatusPtr = (LPENUM_SERVICE_STATUSW)lpServices;
- for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ if (*lpServicesReturned > 0)
{
- if (lpStatusPtr->lpServiceName)
- lpStatusPtr->lpServiceName =
- (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
+ for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ {
+ if (lpStatusPtr->lpServiceName)
+ lpStatusPtr->lpServiceName =
+ (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
- if (lpStatusPtr->lpDisplayName)
- lpStatusPtr->lpDisplayName =
- (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
+ if (lpStatusPtr->lpDisplayName)
+ lpStatusPtr->lpDisplayName =
+ (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
- lpStatusPtr++;
+ lpStatusPtr++;
+ }
}
}
if (dwError != ERROR_SUCCESS)
{
- ERR("REnumDependentServicesW() failed (Error %lu)\n", dwError);
+ TRACE("REnumDependentServicesW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
/**********************************************************************
* EnumServiceGroupW
*
- * @unimplemented
+ * @implemented
*/
-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
+EnumServiceGroupW(SC_HANDLE hSCManager,
+ DWORD dwServiceType,
+ DWORD dwServiceState,
+ LPENUM_SERVICE_STATUSW lpServices,
+ DWORD cbBufSize,
+ LPDWORD pcbBytesNeeded,
+ LPDWORD lpServicesReturned,
+ LPDWORD lpResumeHandle,
+ LPCWSTR lpGroup)
{
- FIXME("EnumServiceGroupW is unimplemented\n");
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FALSE;
+ ENUM_SERVICE_STATUSW ServiceStatus;
+ LPENUM_SERVICE_STATUSW lpStatusPtr;
+ DWORD dwBufferSize;
+ DWORD dwError;
+ DWORD dwCount;
+
+ TRACE("EnumServiceGroupW() called\n");
+
+ if (!hSCManager)
+ {
+ SetLastError(ERROR_INVALID_HANDLE);
+ return FALSE;
+ }
+
+ if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSW))
+ {
+ lpStatusPtr = &ServiceStatus;
+ dwBufferSize = sizeof(ENUM_SERVICE_STATUSW);
+ }
+ else
+ {
+ lpStatusPtr = lpServices;
+ dwBufferSize = cbBufSize;
+ }
+
+ RpcTryExcept
+ {
+ if (lpGroup == NULL)
+ {
+ dwError = REnumServicesStatusW((SC_RPC_HANDLE)hSCManager,
+ dwServiceType,
+ dwServiceState,
+ (LPBYTE)lpStatusPtr,
+ dwBufferSize,
+ pcbBytesNeeded,
+ lpServicesReturned,
+ lpResumeHandle);
+ }
+ else
+ {
+ dwError = REnumServiceGroupW((SC_RPC_HANDLE)hSCManager,
+ dwServiceType,
+ dwServiceState,
+ (LPBYTE)lpStatusPtr,
+ dwBufferSize,
+ pcbBytesNeeded,
+ lpServicesReturned,
+ lpResumeHandle,
+ lpGroup);
+ }
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
+ {
+ if (*lpServicesReturned > 0)
+ {
+ for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ {
+ if (lpStatusPtr->lpServiceName)
+ lpStatusPtr->lpServiceName =
+ (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
+
+ if (lpStatusPtr->lpDisplayName)
+ lpStatusPtr->lpDisplayName =
+ (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
+
+ lpStatusPtr++;
+ }
+ }
+ }
+
+ if (dwError != ERROR_SUCCESS)
+ {
+ TRACE("REnumServiceGroupW() failed (Error %lu)\n", dwError);
+ SetLastError(dwError);
+ return FALSE;
+ }
+
+ TRACE("EnumServiceGroupW() done\n");
+
+ return TRUE;
}
LPDWORD lpServicesReturned,
LPDWORD lpResumeHandle)
{
+ ENUM_SERVICE_STATUSA ServiceStatus;
LPENUM_SERVICE_STATUSA lpStatusPtr;
+ DWORD dwBufferSize;
DWORD dwError;
DWORD dwCount;
return FALSE;
}
+ if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSW))
+ {
+ lpStatusPtr = &ServiceStatus;
+ dwBufferSize = sizeof(ENUM_SERVICE_STATUSW);
+ }
+ else
+ {
+ lpStatusPtr = lpServices;
+ dwBufferSize = cbBufSize;
+ }
+
RpcTryExcept
{
dwError = REnumServicesStatusA((SC_RPC_HANDLE)hSCManager,
dwServiceType,
dwServiceState,
- (LPBYTE)lpServices,
- cbBufSize,
+ (LPBYTE)lpStatusPtr,
+ dwBufferSize,
pcbBytesNeeded,
lpServicesReturned,
lpResumeHandle);
if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
{
- lpStatusPtr = (LPENUM_SERVICE_STATUSA)lpServices;
- for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ if (*lpServicesReturned > 0)
{
- if (lpStatusPtr->lpServiceName)
- lpStatusPtr->lpServiceName =
- (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
+ for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ {
+ if (lpStatusPtr->lpServiceName)
+ lpStatusPtr->lpServiceName =
+ (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
- if (lpStatusPtr->lpDisplayName)
- lpStatusPtr->lpDisplayName =
- (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
+ if (lpStatusPtr->lpDisplayName)
+ lpStatusPtr->lpDisplayName =
+ (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
- lpStatusPtr++;
+ lpStatusPtr++;
+ }
}
}
if (dwError != ERROR_SUCCESS)
{
- ERR("REnumServicesStatusA() failed (Error %lu)\n", dwError);
+ TRACE("REnumServicesStatusA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
LPDWORD lpServicesReturned,
LPDWORD lpResumeHandle)
{
+ ENUM_SERVICE_STATUSW ServiceStatus;
LPENUM_SERVICE_STATUSW lpStatusPtr;
+ DWORD dwBufferSize;
DWORD dwError;
DWORD dwCount;
return FALSE;
}
+ if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSW))
+ {
+ lpStatusPtr = &ServiceStatus;
+ dwBufferSize = sizeof(ENUM_SERVICE_STATUSW);
+ }
+ else
+ {
+ lpStatusPtr = lpServices;
+ dwBufferSize = cbBufSize;
+ }
+
RpcTryExcept
{
dwError = REnumServicesStatusW((SC_RPC_HANDLE)hSCManager,
dwServiceType,
dwServiceState,
- (LPBYTE)lpServices,
- cbBufSize,
+ (LPBYTE)lpStatusPtr,
+ dwBufferSize,
pcbBytesNeeded,
lpServicesReturned,
lpResumeHandle);
if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
{
- lpStatusPtr = (LPENUM_SERVICE_STATUSW)lpServices;
- for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ if (*lpServicesReturned > 0)
{
- if (lpStatusPtr->lpServiceName)
- lpStatusPtr->lpServiceName =
- (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
+ for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ {
+ if (lpStatusPtr->lpServiceName)
+ lpStatusPtr->lpServiceName =
+ (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
- if (lpStatusPtr->lpDisplayName)
- lpStatusPtr->lpDisplayName =
- (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
+ if (lpStatusPtr->lpDisplayName)
+ lpStatusPtr->lpDisplayName =
+ (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
- lpStatusPtr++;
+ lpStatusPtr++;
+ }
}
}
if (dwError != ERROR_SUCCESS)
{
- ERR("REnumServicesStatusW() failed (Error %lu)\n", dwError);
+ TRACE("REnumServicesStatusW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
LPDWORD lpResumeHandle,
LPCSTR pszGroupName)
{
+ ENUM_SERVICE_STATUS_PROCESSA ServiceStatus;
LPENUM_SERVICE_STATUS_PROCESSA lpStatusPtr;
+ DWORD dwBufferSize;
DWORD dwError;
DWORD dwCount;
return FALSE;
}
+ if (lpServices == NULL ||
+ cbBufSize < sizeof(ENUM_SERVICE_STATUS_PROCESSA))
+ {
+ lpStatusPtr = &ServiceStatus;
+ dwBufferSize = sizeof(ENUM_SERVICE_STATUS_PROCESSA);
+ }
+ else
+ {
+ lpStatusPtr = (LPENUM_SERVICE_STATUS_PROCESSA)lpServices;
+ dwBufferSize = cbBufSize;
+ }
+
RpcTryExcept
{
dwError = REnumServicesStatusExA((SC_RPC_HANDLE)hSCManager,
InfoLevel,
dwServiceType,
dwServiceState,
- (LPBYTE)lpServices,
- cbBufSize,
+ (LPBYTE)lpStatusPtr,
+ dwBufferSize,
pcbBytesNeeded,
lpServicesReturned,
lpResumeHandle,
if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
{
- lpStatusPtr = (LPENUM_SERVICE_STATUS_PROCESSA)lpServices;
- for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ if (InfoLevel == SC_ENUM_PROCESS_INFO)
{
- if (lpStatusPtr->lpServiceName)
- lpStatusPtr->lpServiceName =
- (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
+ for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ {
+ if (lpStatusPtr->lpServiceName)
+ lpStatusPtr->lpServiceName =
+ (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
- if (lpStatusPtr->lpDisplayName)
- lpStatusPtr->lpDisplayName =
- (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
+ if (lpStatusPtr->lpDisplayName)
+ lpStatusPtr->lpDisplayName =
+ (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
- lpStatusPtr++;
+ lpStatusPtr++;
+ }
}
}
if (dwError != ERROR_SUCCESS)
{
- ERR("REnumServicesStatusExA() failed (Error %lu)\n", dwError);
+ TRACE("REnumServicesStatusExA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
LPDWORD lpResumeHandle,
LPCWSTR pszGroupName)
{
+ ENUM_SERVICE_STATUS_PROCESSW ServiceStatus;
LPENUM_SERVICE_STATUS_PROCESSW lpStatusPtr;
+ DWORD dwBufferSize;
DWORD dwError;
DWORD dwCount;
TRACE("EnumServicesStatusExW() called\n");
+ if (InfoLevel != SC_ENUM_PROCESS_INFO)
+ {
+ SetLastError(ERROR_INVALID_LEVEL);
+ return FALSE;
+ }
+
+ if (lpServices == NULL ||
+ cbBufSize < sizeof(ENUM_SERVICE_STATUS_PROCESSW))
+ {
+ lpStatusPtr = &ServiceStatus;
+ dwBufferSize = sizeof(ENUM_SERVICE_STATUS_PROCESSW);
+ }
+ else
+ {
+ lpStatusPtr = (LPENUM_SERVICE_STATUS_PROCESSW)lpServices;
+ dwBufferSize = cbBufSize;
+ }
+
RpcTryExcept
{
dwError = REnumServicesStatusExW((SC_RPC_HANDLE)hSCManager,
InfoLevel,
dwServiceType,
dwServiceState,
- (LPBYTE)lpServices,
- cbBufSize,
+ (LPBYTE)lpStatusPtr,
+ dwBufferSize,
pcbBytesNeeded,
lpServicesReturned,
lpResumeHandle,
if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
{
- lpStatusPtr = (LPENUM_SERVICE_STATUS_PROCESSW)lpServices;
- for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ if (InfoLevel == SC_ENUM_PROCESS_INFO)
{
- if (lpStatusPtr->lpServiceName)
- lpStatusPtr->lpServiceName =
- (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
+ for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ {
+ if (lpStatusPtr->lpServiceName)
+ lpStatusPtr->lpServiceName =
+ (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
- if (lpStatusPtr->lpDisplayName)
- lpStatusPtr->lpDisplayName =
- (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
+ if (lpStatusPtr->lpDisplayName)
+ lpStatusPtr->lpDisplayName =
+ (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
- lpStatusPtr++;
+ lpStatusPtr++;
+ }
}
}
if (dwError != ERROR_SUCCESS)
{
- ERR("REnumServicesStatusExW() failed (Error %lu)\n", dwError);
+ TRACE("REnumServicesStatusExW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RGetServiceDisplayNameA() failed (Error %lu)\n", dwError);
+ TRACE("RGetServiceDisplayNameA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RGetServiceDisplayNameW() failed (Error %lu)\n", dwError);
+ TRACE("RGetServiceDisplayNameW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RGetServiceKeyNameA() failed (Error %lu)\n", dwError);
+ TRACE("RGetServiceKeyNameA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RGetServiceKeyNameW() failed (Error %lu)\n", dwError);
+ TRACE("RGetServiceKeyNameW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RLockServiceDatabase() failed (Error %lu)\n", dwError);
+ TRACE("RLockServiceDatabase() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return NULL;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("ROpenSCManagerA() failed (Error %lu)\n", dwError);
+ TRACE("ROpenSCManagerA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return NULL;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("ROpenSCManagerW() failed (Error %lu)\n", dwError);
+ TRACE("ROpenSCManagerW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return NULL;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("ROpenServiceA() failed (Error %lu)\n", dwError);
+ TRACE("ROpenServiceA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return NULL;
}
if (dwError != ERROR_SUCCESS)
{
- if (dwError == ERROR_SERVICE_DOES_NOT_EXIST)
- WARN("ROpenServiceW() failed (Error %lu)\n", dwError);
- else
- ERR("ROpenServiceW() failed (Error %lu)\n", dwError);
+ TRACE("ROpenServiceW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return NULL;
}
DWORD cbBufSize,
LPDWORD pcbBytesNeeded)
{
+ QUERY_SERVICE_CONFIGA ServiceConfig;
+ LPQUERY_SERVICE_CONFIGA lpConfigPtr;
+ DWORD dwBufferSize;
DWORD dwError;
TRACE("QueryServiceConfigA(%p, %p, %lu, %p)\n",
hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
+ if (lpServiceConfig == NULL ||
+ cbBufSize < sizeof(QUERY_SERVICE_CONFIGA))
+ {
+ lpConfigPtr = &ServiceConfig;
+ dwBufferSize = sizeof(QUERY_SERVICE_CONFIGA);
+ }
+ else
+ {
+ lpConfigPtr = lpServiceConfig;
+ dwBufferSize = cbBufSize;
+ }
+
RpcTryExcept
{
/* Call to services.exe using RPC */
dwError = RQueryServiceConfigA((SC_RPC_HANDLE)hService,
- (LPBYTE)lpServiceConfig,
- cbBufSize,
+ (LPBYTE)lpConfigPtr,
+ dwBufferSize,
pcbBytesNeeded);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceConfigA() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceConfigA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
/* Adjust the pointers */
- if (lpServiceConfig->lpBinaryPathName)
- lpServiceConfig->lpBinaryPathName =
- (LPSTR)((ULONG_PTR)lpServiceConfig +
- (ULONG_PTR)lpServiceConfig->lpBinaryPathName);
-
- if (lpServiceConfig->lpLoadOrderGroup)
- lpServiceConfig->lpLoadOrderGroup =
- (LPSTR)((ULONG_PTR)lpServiceConfig +
- (ULONG_PTR)lpServiceConfig->lpLoadOrderGroup);
-
- if (lpServiceConfig->lpDependencies)
- lpServiceConfig->lpDependencies =
- (LPSTR)((ULONG_PTR)lpServiceConfig +
- (ULONG_PTR)lpServiceConfig->lpDependencies);
-
- if (lpServiceConfig->lpServiceStartName)
- lpServiceConfig->lpServiceStartName =
- (LPSTR)((ULONG_PTR)lpServiceConfig +
- (ULONG_PTR)lpServiceConfig->lpServiceStartName);
-
- if (lpServiceConfig->lpDisplayName)
- lpServiceConfig->lpDisplayName =
- (LPSTR)((ULONG_PTR)lpServiceConfig +
- (ULONG_PTR)lpServiceConfig->lpDisplayName);
+ if (lpConfigPtr->lpBinaryPathName)
+ lpConfigPtr->lpBinaryPathName =
+ (LPSTR)((ULONG_PTR)lpConfigPtr +
+ (ULONG_PTR)lpConfigPtr->lpBinaryPathName);
+
+ if (lpConfigPtr->lpLoadOrderGroup)
+ lpConfigPtr->lpLoadOrderGroup =
+ (LPSTR)((ULONG_PTR)lpConfigPtr +
+ (ULONG_PTR)lpConfigPtr->lpLoadOrderGroup);
+
+ if (lpConfigPtr->lpDependencies)
+ lpConfigPtr->lpDependencies =
+ (LPSTR)((ULONG_PTR)lpConfigPtr +
+ (ULONG_PTR)lpConfigPtr->lpDependencies);
+
+ if (lpConfigPtr->lpServiceStartName)
+ lpConfigPtr->lpServiceStartName =
+ (LPSTR)((ULONG_PTR)lpConfigPtr +
+ (ULONG_PTR)lpConfigPtr->lpServiceStartName);
+
+ if (lpConfigPtr->lpDisplayName)
+ lpConfigPtr->lpDisplayName =
+ (LPSTR)((ULONG_PTR)lpConfigPtr +
+ (ULONG_PTR)lpConfigPtr->lpDisplayName);
TRACE("QueryServiceConfigA() done\n");
DWORD cbBufSize,
LPDWORD pcbBytesNeeded)
{
+ QUERY_SERVICE_CONFIGW ServiceConfig;
+ LPQUERY_SERVICE_CONFIGW lpConfigPtr;
+ DWORD dwBufferSize;
DWORD dwError;
TRACE("QueryServiceConfigW(%p, %p, %lu, %p)\n",
hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
+ if (lpServiceConfig == NULL ||
+ cbBufSize < sizeof(QUERY_SERVICE_CONFIGW))
+ {
+ lpConfigPtr = &ServiceConfig;
+ dwBufferSize = sizeof(QUERY_SERVICE_CONFIGW);
+ }
+ else
+ {
+ lpConfigPtr = lpServiceConfig;
+ dwBufferSize = cbBufSize;
+ }
+
RpcTryExcept
{
/* Call to services.exe using RPC */
dwError = RQueryServiceConfigW((SC_RPC_HANDLE)hService,
- (LPBYTE)lpServiceConfig,
- cbBufSize,
+ (LPBYTE)lpConfigPtr,
+ dwBufferSize,
pcbBytesNeeded);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
if (dwError != ERROR_SUCCESS)
{
- if (dwError == ERROR_INSUFFICIENT_BUFFER)
- WARN("RQueryServiceConfigW() failed (Error %lu)\n", dwError);
- else
- ERR("RQueryServiceConfigW() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceConfigW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
/* Adjust the pointers */
- if (lpServiceConfig->lpBinaryPathName)
- lpServiceConfig->lpBinaryPathName =
- (LPWSTR)((ULONG_PTR)lpServiceConfig +
- (ULONG_PTR)lpServiceConfig->lpBinaryPathName);
-
- if (lpServiceConfig->lpLoadOrderGroup)
- lpServiceConfig->lpLoadOrderGroup =
- (LPWSTR)((ULONG_PTR)lpServiceConfig +
- (ULONG_PTR)lpServiceConfig->lpLoadOrderGroup);
-
- if (lpServiceConfig->lpDependencies)
- lpServiceConfig->lpDependencies =
- (LPWSTR)((ULONG_PTR)lpServiceConfig +
- (ULONG_PTR)lpServiceConfig->lpDependencies);
-
- if (lpServiceConfig->lpServiceStartName)
- lpServiceConfig->lpServiceStartName =
- (LPWSTR)((ULONG_PTR)lpServiceConfig +
- (ULONG_PTR)lpServiceConfig->lpServiceStartName);
-
- if (lpServiceConfig->lpDisplayName)
- lpServiceConfig->lpDisplayName =
- (LPWSTR)((ULONG_PTR)lpServiceConfig +
- (ULONG_PTR)lpServiceConfig->lpDisplayName);
+ if (lpConfigPtr->lpBinaryPathName)
+ lpConfigPtr->lpBinaryPathName =
+ (LPWSTR)((ULONG_PTR)lpConfigPtr +
+ (ULONG_PTR)lpConfigPtr->lpBinaryPathName);
+
+ if (lpConfigPtr->lpLoadOrderGroup)
+ lpConfigPtr->lpLoadOrderGroup =
+ (LPWSTR)((ULONG_PTR)lpConfigPtr +
+ (ULONG_PTR)lpConfigPtr->lpLoadOrderGroup);
+
+ if (lpConfigPtr->lpDependencies)
+ lpConfigPtr->lpDependencies =
+ (LPWSTR)((ULONG_PTR)lpConfigPtr +
+ (ULONG_PTR)lpConfigPtr->lpDependencies);
+
+ if (lpConfigPtr->lpServiceStartName)
+ lpConfigPtr->lpServiceStartName =
+ (LPWSTR)((ULONG_PTR)lpConfigPtr +
+ (ULONG_PTR)lpConfigPtr->lpServiceStartName);
+
+ if (lpConfigPtr->lpDisplayName)
+ lpConfigPtr->lpDisplayName =
+ (LPWSTR)((ULONG_PTR)lpConfigPtr +
+ (ULONG_PTR)lpConfigPtr->lpDisplayName);
TRACE("QueryServiceConfigW() done\n");
DWORD cbBufSize,
LPDWORD pcbBytesNeeded)
{
+ SERVICE_DESCRIPTIONA ServiceDescription;
+ SERVICE_FAILURE_ACTIONSA ServiceFailureActions;
+ LPBYTE lpTempBuffer;
+ BOOL bUseTempBuffer = FALSE;
+ DWORD dwBufferSize;
DWORD dwError;
- DbgPrint("QueryServiceConfig2A(hService %p, dwInfoLevel %lu, lpBuffer %p, cbBufSize %lu, pcbBytesNeeded %p)\n",
- hService, dwInfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
+ TRACE("QueryServiceConfig2A(hService %p, dwInfoLevel %lu, lpBuffer %p, cbBufSize %lu, pcbBytesNeeded %p)\n",
+ hService, dwInfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
- if (dwInfoLevel != SERVICE_CONFIG_DESCRIPTION &&
- dwInfoLevel != SERVICE_CONFIG_FAILURE_ACTIONS)
- {
- SetLastError(ERROR_INVALID_LEVEL);
- return FALSE;
- }
+ lpTempBuffer = lpBuffer;
+ dwBufferSize = cbBufSize;
- if ((lpBuffer == NULL && cbBufSize != 0) ||
- pcbBytesNeeded == NULL)
+ switch (dwInfoLevel)
{
- SetLastError(ERROR_INVALID_ADDRESS);
- return FALSE;
+ case SERVICE_CONFIG_DESCRIPTION:
+ if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_DESCRIPTIONA)))
+ {
+ lpTempBuffer = (LPBYTE)&ServiceDescription;
+ dwBufferSize = sizeof(SERVICE_DESCRIPTIONA);
+ bUseTempBuffer = TRUE;
+ }
+ break;
+
+ case SERVICE_CONFIG_FAILURE_ACTIONS:
+ if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_FAILURE_ACTIONSA)))
+ {
+ lpTempBuffer = (LPBYTE)&ServiceFailureActions;
+ dwBufferSize = sizeof(SERVICE_FAILURE_ACTIONSA);
+ bUseTempBuffer = TRUE;
+ }
+ break;
+
+ default:
+ WARN("Unknown info level 0x%lx\n", dwInfoLevel);
+ SetLastError(ERROR_INVALID_LEVEL);
+ return FALSE;
}
RpcTryExcept
/* Call to services.exe using RPC */
dwError = RQueryServiceConfig2A((SC_RPC_HANDLE)hService,
dwInfoLevel,
- lpBuffer,
- cbBufSize,
+ lpTempBuffer,
+ dwBufferSize,
pcbBytesNeeded);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceConfig2A() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceConfig2A() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
+ if (bUseTempBuffer == TRUE)
+ {
+ TRACE("RQueryServiceConfig2A() returns ERROR_INSUFFICIENT_BUFFER\n");
+ SetLastError(ERROR_INSUFFICIENT_BUFFER);
+ return FALSE;
+ }
+
switch (dwInfoLevel)
{
case SERVICE_CONFIG_DESCRIPTION:
{
- LPSERVICE_DESCRIPTIONA lpPtr = (LPSERVICE_DESCRIPTIONA)lpBuffer;
+ LPSERVICE_DESCRIPTIONA lpPtr = (LPSERVICE_DESCRIPTIONA)lpTempBuffer;
if (lpPtr->lpDescription != NULL)
lpPtr->lpDescription =
case SERVICE_CONFIG_FAILURE_ACTIONS:
{
- LPSERVICE_FAILURE_ACTIONSA lpPtr = (LPSERVICE_FAILURE_ACTIONSA)lpBuffer;
+ LPSERVICE_FAILURE_ACTIONSA lpPtr = (LPSERVICE_FAILURE_ACTIONSA)lpTempBuffer;
if (lpPtr->lpRebootMsg != NULL)
lpPtr->lpRebootMsg =
(SC_ACTION*)((UINT_PTR)lpPtr + (UINT_PTR)lpPtr->lpsaActions);
}
break;
-
- default:
- ERR("Unknown info level 0x%lx\n", dwInfoLevel);
- SetLastError(ERROR_INVALID_PARAMETER);
- return FALSE;
}
TRACE("QueryServiceConfig2A() done\n");
DWORD cbBufSize,
LPDWORD pcbBytesNeeded)
{
+ SERVICE_DESCRIPTIONW ServiceDescription;
+ SERVICE_FAILURE_ACTIONSW ServiceFailureActions;
+ LPBYTE lpTempBuffer;
+ BOOL bUseTempBuffer = FALSE;
+ DWORD dwBufferSize;
DWORD dwError;
TRACE("QueryServiceConfig2W(%p, %lu, %p, %lu, %p)\n",
hService, dwInfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
- if (dwInfoLevel != SERVICE_CONFIG_DESCRIPTION &&
- dwInfoLevel != SERVICE_CONFIG_FAILURE_ACTIONS)
- {
- SetLastError(ERROR_INVALID_LEVEL);
- return FALSE;
- }
+ lpTempBuffer = lpBuffer;
+ dwBufferSize = cbBufSize;
- if ((lpBuffer == NULL && cbBufSize != 0) ||
- pcbBytesNeeded == NULL)
+ switch (dwInfoLevel)
{
- SetLastError(ERROR_INVALID_ADDRESS);
- return FALSE;
+ case SERVICE_CONFIG_DESCRIPTION:
+ if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_DESCRIPTIONW)))
+ {
+ lpTempBuffer = (LPBYTE)&ServiceDescription;
+ dwBufferSize = sizeof(SERVICE_DESCRIPTIONW);
+ bUseTempBuffer = TRUE;
+ }
+ break;
+
+ case SERVICE_CONFIG_FAILURE_ACTIONS:
+ if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_FAILURE_ACTIONSW)))
+ {
+ lpTempBuffer = (LPBYTE)&ServiceFailureActions;
+ dwBufferSize = sizeof(SERVICE_FAILURE_ACTIONSW);
+ bUseTempBuffer = TRUE;
+ }
+ break;
+
+ default:
+ WARN("Unknown info level 0x%lx\n", dwInfoLevel);
+ SetLastError(ERROR_INVALID_LEVEL);
+ return FALSE;
}
RpcTryExcept
/* Call to services.exe using RPC */
dwError = RQueryServiceConfig2W((SC_RPC_HANDLE)hService,
dwInfoLevel,
- lpBuffer,
- cbBufSize,
+ lpTempBuffer,
+ dwBufferSize,
pcbBytesNeeded);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceConfig2W() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceConfig2W() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
+ if (bUseTempBuffer == TRUE)
+ {
+ TRACE("RQueryServiceConfig2W() returns ERROR_INSUFFICIENT_BUFFER\n");
+ SetLastError(ERROR_INSUFFICIENT_BUFFER);
+ return FALSE;
+ }
+
switch (dwInfoLevel)
{
case SERVICE_CONFIG_DESCRIPTION:
{
- LPSERVICE_DESCRIPTIONW lpPtr = (LPSERVICE_DESCRIPTIONW)lpBuffer;
+ LPSERVICE_DESCRIPTIONW lpPtr = (LPSERVICE_DESCRIPTIONW)lpTempBuffer;
if (lpPtr->lpDescription != NULL)
lpPtr->lpDescription =
case SERVICE_CONFIG_FAILURE_ACTIONS:
{
- LPSERVICE_FAILURE_ACTIONSW lpPtr = (LPSERVICE_FAILURE_ACTIONSW)lpBuffer;
+ LPSERVICE_FAILURE_ACTIONSW lpPtr = (LPSERVICE_FAILURE_ACTIONSW)lpTempBuffer;
if (lpPtr->lpRebootMsg != NULL)
lpPtr->lpRebootMsg =
(SC_ACTION*)((UINT_PTR)lpPtr + (UINT_PTR)lpPtr->lpsaActions);
}
break;
-
- default:
- WARN("Unknown info level 0x%lx\n", dwInfoLevel);
- SetLastError(ERROR_INVALID_PARAMETER);
- return FALSE;
}
TRACE("QueryServiceConfig2W() done\n");
DWORD cbBufSize,
LPDWORD pcbBytesNeeded)
{
+ QUERY_SERVICE_LOCK_STATUSA LockStatus;
+ LPQUERY_SERVICE_LOCK_STATUSA lpStatusPtr;
+ DWORD dwBufferSize;
DWORD dwError;
TRACE("QueryServiceLockStatusA() called\n");
+ if (lpLockStatus == NULL || cbBufSize < sizeof(QUERY_SERVICE_LOCK_STATUSA))
+ {
+ lpStatusPtr = &LockStatus;
+ dwBufferSize = sizeof(QUERY_SERVICE_LOCK_STATUSA);
+ }
+ else
+ {
+ lpStatusPtr = lpLockStatus;
+ dwBufferSize = cbBufSize;
+ }
+
RpcTryExcept
{
/* Call to services.exe using RPC */
dwError = RQueryServiceLockStatusA((SC_RPC_HANDLE)hSCManager,
- lpLockStatus,
- cbBufSize,
+ lpStatusPtr,
+ dwBufferSize,
pcbBytesNeeded);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceLockStatusA() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceLockStatusA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
- if (lpLockStatus->lpLockOwner != NULL)
+ if (lpStatusPtr->lpLockOwner != NULL)
{
- lpLockStatus->lpLockOwner =
- (LPSTR)((UINT_PTR)lpLockStatus + (UINT_PTR)lpLockStatus->lpLockOwner);
+ lpStatusPtr->lpLockOwner =
+ (LPSTR)((UINT_PTR)lpStatusPtr + (UINT_PTR)lpStatusPtr->lpLockOwner);
}
TRACE("QueryServiceLockStatusA() done\n");
DWORD cbBufSize,
LPDWORD pcbBytesNeeded)
{
+ QUERY_SERVICE_LOCK_STATUSW LockStatus;
+ LPQUERY_SERVICE_LOCK_STATUSW lpStatusPtr;
+ DWORD dwBufferSize;
DWORD dwError;
TRACE("QueryServiceLockStatusW() called\n");
+ if (lpLockStatus == NULL || cbBufSize < sizeof(QUERY_SERVICE_LOCK_STATUSW))
+ {
+ lpStatusPtr = &LockStatus;
+ dwBufferSize = sizeof(QUERY_SERVICE_LOCK_STATUSW);
+ }
+ else
+ {
+ lpStatusPtr = lpLockStatus;
+ dwBufferSize = cbBufSize;
+ }
+
RpcTryExcept
{
/* Call to services.exe using RPC */
dwError = RQueryServiceLockStatusW((SC_RPC_HANDLE)hSCManager,
- lpLockStatus,
- cbBufSize,
+ lpStatusPtr,
+ dwBufferSize,
pcbBytesNeeded);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceLockStatusW() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceLockStatusW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
- if (lpLockStatus->lpLockOwner != NULL)
+ if (lpStatusPtr->lpLockOwner != NULL)
{
- lpLockStatus->lpLockOwner =
- (LPWSTR)((UINT_PTR)lpLockStatus + (UINT_PTR)lpLockStatus->lpLockOwner);
+ lpStatusPtr->lpLockOwner =
+ (LPWSTR)((UINT_PTR)lpStatusPtr + (UINT_PTR)lpStatusPtr->lpLockOwner);
}
TRACE("QueryServiceLockStatusW() done\n");
if (dwError != ERROR_SUCCESS)
{
- ERR("QueryServiceObjectSecurity() failed (Error %lu)\n", dwError);
+ TRACE("QueryServiceObjectSecurity() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RServiceObjectSecurity() failed (Error %lu)\n", dwError);
+ TRACE("RServiceObjectSecurity() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceStatus() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceStatus() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
return FALSE;
}
+ if (cbBufSize < sizeof(SERVICE_STATUS_PROCESS))
+ {
+ *pcbBytesNeeded = sizeof(SERVICE_STATUS_PROCESS);
+ SetLastError(ERROR_INSUFFICIENT_BUFFER);
+ return FALSE;
+ }
+
RpcTryExcept
{
/* Call to services.exe using RPC */
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceStatusEx() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceStatusEx() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RUnlockServiceDatabase() failed (Error %lu)\n", dwError);
+ TRACE("RUnlockServiceDatabase() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("NotifyBootConfigStatus() failed (Error %lu)\n", dwError);
+ TRACE("NotifyBootConfigStatus() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}