}
-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;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("REnumDependentServicesA() failed (Error %lu)\n", dwError);
+ TRACE("REnumDependentServicesA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
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;
+ LPENUM_SERVICE_STATUSW lpStatusPtr;
+ DWORD dwError;
+ DWORD dwCount;
+
+ TRACE("EnumServiceGroupW() called\n");
+
+ if (!hSCManager)
+ {
+ SetLastError(ERROR_INVALID_HANDLE);
+ return FALSE;
+ }
+
+ RpcTryExcept
+ {
+ if (lpGroup == NULL)
+ {
+ dwError = REnumServicesStatusW((SC_RPC_HANDLE)hSCManager,
+ dwServiceType,
+ dwServiceState,
+ (LPBYTE)lpServices,
+ cbBufSize,
+ pcbBytesNeeded,
+ lpServicesReturned,
+ lpResumeHandle);
+ }
+ else
+ {
+ dwError = REnumServiceGroupW((SC_RPC_HANDLE)hSCManager,
+ dwServiceType,
+ dwServiceState,
+ (LPBYTE)lpServices,
+ cbBufSize,
+ pcbBytesNeeded,
+ lpServicesReturned,
+ lpResumeHandle,
+ lpGroup);
+ }
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
+ {
+ lpStatusPtr = (LPENUM_SERVICE_STATUSW)lpServices;
+ 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;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("REnumServicesStatusA() failed (Error %lu)\n", dwError);
+ TRACE("REnumServicesStatusA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
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 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)
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceConfig2A() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceConfig2A() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceConfig2W() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceConfig2W() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceLockStatusA() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceLockStatusA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceLockStatusW() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceLockStatusW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
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;
}
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;
}