/* INCLUDES ******************************************************************/
#include <advapi32.h>
-
-#include "wine/debug.h"
-
WINE_DEFAULT_DEBUG_CHANNEL(advapi);
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++;
+ }
}
}
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++;
+ }
}
}
LPDWORD lpResumeHandle,
LPCWSTR lpGroup)
{
+ 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
{
if (lpGroup == NULL)
dwError = REnumServicesStatusW((SC_RPC_HANDLE)hSCManager,
dwServiceType,
dwServiceState,
- (LPBYTE)lpServices,
- cbBufSize,
+ (LPBYTE)lpStatusPtr,
+ dwBufferSize,
pcbBytesNeeded,
lpServicesReturned,
lpResumeHandle);
dwError = REnumServiceGroupW((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++;
+ }
}
}
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++;
+ }
}
}
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++;
+ }
}
}
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++;
+ }
}
}
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++;
+ }
}
}
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)
}
/* 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)
}
/* 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;
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)
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)
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)
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)
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");
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 */