/* FUNCTIONS *****************************************************************/
-handle_t BindingHandle = NULL;
+handle_t __RPC_USER
+SVCCTL_HANDLEA_bind(SVCCTL_HANDLEA szMachineName)
+{
+ handle_t hBinding = NULL;
+ UCHAR *pszStringBinding;
+ RPC_STATUS status;
+
+ TRACE("SVCCTL_HANDLEA_bind() called\n");
+
+ status = RpcStringBindingComposeA(NULL,
+ (UCHAR *)"ncacn_np",
+ (UCHAR *)szMachineName,
+ (UCHAR *)"\\pipe\\ntsvcs",
+ NULL,
+ (UCHAR **)&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 = RpcBindingFromStringBindingA(pszStringBinding,
+ &hBinding);
+ if (status != RPC_S_OK)
+ {
+ ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
+ }
+
+ status = RpcStringFreeA(&pszStringBinding);
+ if (status != RPC_S_OK)
+ {
+ ERR("RpcStringFree returned 0x%x\n", status);
+ }
-VOID
-HandleBind(VOID)
+ return hBinding;
+}
+
+
+void __RPC_USER
+SVCCTL_HANDLEA_unbind(SVCCTL_HANDLEA szMachineName,
+ handle_t hBinding)
{
+ RPC_STATUS status;
+
+ TRACE("SVCCTL_HANDLEA_unbind() called\n");
+
+ status = RpcBindingFree(&hBinding);
+ if (status != RPC_S_OK)
+ {
+ ERR("RpcBindingFree returned 0x%x\n", status);
+ }
+}
+
+
+handle_t __RPC_USER
+SVCCTL_HANDLEW_bind(SVCCTL_HANDLEW szMachineName)
+{
+ handle_t hBinding = NULL;
LPWSTR pszStringBinding;
RPC_STATUS status;
- if (BindingHandle != NULL)
- return;
+ TRACE("SVCCTL_HANDLEW_bind() called\n");
status = RpcStringBindingComposeW(NULL,
L"ncacn_np",
- NULL,
+ szMachineName,
L"\\pipe\\ntsvcs",
NULL,
&pszStringBinding);
- if (status)
+ if (status != RPC_S_OK)
{
- TRACE("RpcStringBindingCompose returned 0x%x\n", status);
- return;
+ 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,
- &BindingHandle);
- if (status)
+ &hBinding);
+ if (status != RPC_S_OK)
{
- TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
+ ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
}
status = RpcStringFreeW(&pszStringBinding);
- if (status)
+ if (status != RPC_S_OK)
{
- TRACE("RpcStringFree returned 0x%x\n", status);
+ ERR("RpcStringFree returned 0x%x\n", status);
}
+
+ return hBinding;
}
-#if 0
-static VOID
-HandleUnbind(VOID)
+void __RPC_USER
+SVCCTL_HANDLEW_unbind(SVCCTL_HANDLEW szMachineName,
+ handle_t hBinding)
{
RPC_STATUS status;
- if (BindingHandle == NULL)
- return;
+ TRACE("SVCCTL_HANDLEW_unbind() called\n");
- status = RpcBindingFree(&BindingHandle);
- if (status)
+ status = RpcBindingFree(&hBinding);
+ if (status != RPC_S_OK)
{
- TRACE("RpcBindingFree returned 0x%x\n", status);
+ ERR("RpcBindingFree returned 0x%x\n", status);
+ }
+}
+
+
+DWORD
+ScmRpcStatusToWinError(RPC_STATUS Status)
+{
+ switch (Status)
+ {
+ case RPC_S_INVALID_BINDING:
+ case RPC_X_SS_IN_NULL_CONTEXT:
+ return ERROR_INVALID_HANDLE;
+
+ case RPC_X_ENUM_VALUE_OUT_OF_RANGE:
+ case RPC_X_BYTE_COUNT_TOO_SMALL:
+ return ERROR_INVALID_PARAMETER;
+
+ case RPC_X_NULL_REF_POINTER:
+ return ERROR_INVALID_ADDRESS;
+
+ default:
+ return (DWORD)Status;
}
}
-#endif
/**********************************************************************
{
case SERVICE_CONFIG_DESCRIPTION:
Info.psd = (LPSERVICE_DESCRIPTIONA)&lpInfo;
+ Info.lpDescription = ((LPSERVICE_DESCRIPTIONA)lpInfo)->lpDescription; //HACK
break;
case SERVICE_CONFIG_FAILURE_ACTIONS:
- Info.psfa = (LPSERVICE_FAILURE_ACTIONSA)&lpInfo;
+ Info.psfa = (LPSERVICE_FAILURE_ACTIONSA)lpInfo;
break;
default:
if (lpInfo == NULL)
return TRUE;
- HandleBind();
+ RpcTryExcept
+ {
+ dwError = RChangeServiceConfig2A((SC_RPC_HANDLE)hService,
+ Info);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- dwError = RChangeServiceConfig2A(BindingHandle,
- (SC_RPC_HANDLE)hService,
- Info);
if (dwError != ERROR_SUCCESS)
{
- ERR("RChangeServiceConfig2A() failed (Error %lu)\n", dwError);
+ TRACE("RChangeServiceConfig2A() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
switch (dwInfoLevel)
{
case SERVICE_CONFIG_DESCRIPTION:
- {
Info.psd = (LPSERVICE_DESCRIPTIONW)&lpInfo;
break;
- }
case SERVICE_CONFIG_FAILURE_ACTIONS:
Info.psfa = (LPSERVICE_FAILURE_ACTIONSW)&lpInfo;
if (lpInfo == NULL)
return TRUE;
- HandleBind();
+ RpcTryExcept
+ {
+ dwError = RChangeServiceConfig2W((SC_RPC_HANDLE)hService,
+ Info);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- dwError = RChangeServiceConfig2W(BindingHandle,
- (SC_RPC_HANDLE)hService,
- Info);
if (dwError != ERROR_SUCCESS)
{
- ERR("RChangeServiceConfig2W() failed (Error %lu)\n", dwError);
+ TRACE("RChangeServiceConfig2W() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
ChangeServiceConfigA(SC_HANDLE hService,
DWORD dwServiceType,
DWORD dwStartType,
/* FIXME: Encrypt the password */
- HandleBind();
-
- /* Call to services.exe using RPC */
- dwError = RChangeServiceConfigA(BindingHandle,
- (SC_RPC_HANDLE)hService,
- dwServiceType,
- dwStartType,
- dwErrorControl,
- (LPSTR)lpBinaryPathName,
- (LPSTR)lpLoadOrderGroup,
- lpdwTagId,
- (LPSTR)lpDependencies,
- dwDependenciesLength,
- (LPSTR)lpServiceStartName,
- NULL, /* FIXME: lpPassword */
- 0, /* FIXME: dwPasswordLength */
- (LPSTR)lpDisplayName);
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RChangeServiceConfigA((SC_RPC_HANDLE)hService,
+ dwServiceType,
+ dwStartType,
+ dwErrorControl,
+ (LPSTR)lpBinaryPathName,
+ (LPSTR)lpLoadOrderGroup,
+ lpdwTagId,
+ (LPSTR)lpDependencies,
+ dwDependenciesLength,
+ (LPSTR)lpServiceStartName,
+ NULL, /* FIXME: lpPassword */
+ 0, /* FIXME: dwPasswordLength */
+ (LPSTR)lpDisplayName);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
if (dwError != ERROR_SUCCESS)
{
- ERR("RChangeServiceConfigA() failed (Error %lu)\n", dwError);
+ TRACE("RChangeServiceConfigA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
ChangeServiceConfigW(SC_HANDLE hService,
DWORD dwServiceType,
DWORD dwStartType,
/* FIXME: Encrypt the password */
- HandleBind();
-
- /* Call to services.exe using RPC */
- dwError = RChangeServiceConfigW(BindingHandle,
- (SC_RPC_HANDLE)hService,
- dwServiceType,
- dwStartType,
- dwErrorControl,
- (LPWSTR)lpBinaryPathName,
- (LPWSTR)lpLoadOrderGroup,
- lpdwTagId,
- (LPBYTE)lpDependencies,
- dwDependenciesLength,
- (LPWSTR)lpServiceStartName,
- NULL, /* FIXME: lpPassword */
- 0, /* FIXME: dwPasswordLength */
- (LPWSTR)lpDisplayName);
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RChangeServiceConfigW((SC_RPC_HANDLE)hService,
+ dwServiceType,
+ dwStartType,
+ dwErrorControl,
+ (LPWSTR)lpBinaryPathName,
+ (LPWSTR)lpLoadOrderGroup,
+ lpdwTagId,
+ (LPBYTE)lpDependencies,
+ dwDependenciesLength,
+ (LPWSTR)lpServiceStartName,
+ NULL, /* FIXME: lpPassword */
+ 0, /* FIXME: dwPasswordLength */
+ (LPWSTR)lpDisplayName);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
if (dwError != ERROR_SUCCESS)
{
- ERR("RChangeServiceConfigW() failed (Error %lu)\n", dwError);
+ TRACE("RChangeServiceConfigW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
CloseServiceHandle(SC_HANDLE hSCObject)
{
DWORD dwError;
TRACE("CloseServiceHandle() called\n");
- HandleBind();
+ if (!hSCObject)
+ {
+ SetLastError(ERROR_INVALID_HANDLE);
+ return FALSE;
+ }
+
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RCloseServiceHandle((LPSC_RPC_HANDLE)&hSCObject);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = RCloseServiceHandle(BindingHandle,
- (LPSC_RPC_HANDLE)&hSCObject);
if (dwError)
{
- ERR("RCloseServiceHandle() failed (Error %lu)\n", dwError);
+ TRACE("RCloseServiceHandle() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
ControlService(SC_HANDLE hService,
DWORD dwControl,
LPSERVICE_STATUS lpServiceStatus)
TRACE("ControlService(%x, %x, %p)\n",
hService, dwControl, lpServiceStatus);
- HandleBind();
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RControlService((SC_RPC_HANDLE)hService,
+ dwControl,
+ lpServiceStatus);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = RControlService(BindingHandle,
- (SC_RPC_HANDLE)hService,
- dwControl,
- lpServiceStatus);
if (dwError != ERROR_SUCCESS)
{
- ERR("RControlService() failed (Error %lu)\n", dwError);
+ TRACE("RControlService() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @unimplemented
*/
-BOOL STDCALL
+BOOL WINAPI
ControlServiceEx(IN SC_HANDLE hService,
IN DWORD dwControl,
IN DWORD dwInfoLevel,
}
-
/**********************************************************************
* CreateServiceA
*
* @implemented
*/
-SC_HANDLE STDCALL
+SC_HANDLE WINAPI
CreateServiceA(SC_HANDLE hSCManager,
LPCSTR lpServiceName,
LPCSTR lpDisplayName,
LPCSTR lpServiceStartName,
LPCSTR lpPassword)
{
- SC_HANDLE RetVal = NULL;
- LPWSTR lpServiceNameW = NULL;
- LPWSTR lpDisplayNameW = NULL;
- LPWSTR lpBinaryPathNameW = NULL;
- LPWSTR lpLoadOrderGroupW = NULL;
- LPWSTR lpDependenciesW = NULL;
- LPWSTR lpServiceStartNameW = NULL;
- LPWSTR lpPasswordW = NULL;
+ SC_HANDLE hService = NULL;
DWORD dwDependenciesLength = 0;
+ DWORD dwError;
DWORD dwLength;
- int len;
LPSTR lpStr;
- if (lpServiceName)
- {
- len = MultiByteToWideChar(CP_ACP, 0, lpServiceName, -1, NULL, 0);
- lpServiceNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
- if (!lpServiceNameW)
- {
- SetLastError(ERROR_NOT_ENOUGH_MEMORY);
- goto cleanup;
- }
- MultiByteToWideChar(CP_ACP, 0, lpServiceName, -1, lpServiceNameW, len);
- }
+ TRACE("CreateServiceA() called\n");
+ TRACE("%p %s %s\n", hSCManager,
+ lpServiceName, lpDisplayName);
- if (lpDisplayName)
+ if (!hSCManager)
{
- len = MultiByteToWideChar(CP_ACP, 0, lpDisplayName, -1, NULL, 0);
- lpDisplayNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
- if (!lpDisplayNameW)
- {
- SetLastError(ERROR_NOT_ENOUGH_MEMORY);
- goto cleanup;
- }
- MultiByteToWideChar(CP_ACP, 0, lpDisplayName, -1, lpDisplayNameW, len);
- }
-
- if (lpBinaryPathName)
- {
- len = MultiByteToWideChar(CP_ACP, 0, lpBinaryPathName, -1, NULL, 0);
- lpBinaryPathNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
- if (!lpBinaryPathNameW)
- {
- SetLastError(ERROR_NOT_ENOUGH_MEMORY);
- goto cleanup;
- }
- MultiByteToWideChar(CP_ACP, 0, lpBinaryPathName, -1, lpBinaryPathNameW, len);
- }
-
- if (lpLoadOrderGroup)
- {
- len = MultiByteToWideChar(CP_ACP, 0, lpLoadOrderGroup, -1, NULL, 0);
- lpLoadOrderGroupW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
- if (!lpLoadOrderGroupW)
- {
- SetLastError(ERROR_NOT_ENOUGH_MEMORY);
- goto cleanup;
- }
- MultiByteToWideChar(CP_ACP, 0, lpLoadOrderGroup, -1, lpLoadOrderGroupW, len);
+ SetLastError(ERROR_INVALID_HANDLE);
+ return NULL;
}
- if (lpDependencies)
+ /* Calculate the Dependencies length*/
+ if (lpDependencies != NULL)
{
lpStr = (LPSTR)lpDependencies;
while (*lpStr)
lpStr = lpStr + dwLength;
}
dwDependenciesLength++;
-
- lpDependenciesW = HeapAlloc(GetProcessHeap(), 0, dwDependenciesLength * sizeof(WCHAR));
- if (!lpDependenciesW)
- {
- SetLastError(ERROR_NOT_ENOUGH_MEMORY);
- goto cleanup;
- }
- MultiByteToWideChar(CP_ACP, 0, lpDependencies, -1, lpDependenciesW, dwDependenciesLength);
}
- if (lpServiceStartName)
+ /* FIXME: Encrypt the password */
+
+ RpcTryExcept
{
- len = MultiByteToWideChar(CP_ACP, 0, lpServiceStartName, -1, NULL, 0);
- lpServiceStartName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
- if (!lpServiceStartNameW)
- {
- SetLastError(ERROR_NOT_ENOUGH_MEMORY);
- goto cleanup;
- }
- MultiByteToWideChar(CP_ACP, 0, lpServiceStartName, -1, lpServiceStartNameW, len);
- }
+ /* Call to services.exe using RPC */
+ dwError = RCreateServiceA((SC_RPC_HANDLE)hSCManager,
+ (LPSTR)lpServiceName,
+ (LPSTR)lpDisplayName,
+ dwDesiredAccess,
+ dwServiceType,
+ dwStartType,
+ dwErrorControl,
+ (LPSTR)lpBinaryPathName,
+ (LPSTR)lpLoadOrderGroup,
+ lpdwTagId,
+ (LPBYTE)lpDependencies,
+ dwDependenciesLength,
+ (LPSTR)lpServiceStartName,
+ NULL, /* FIXME: lpPassword */
+ 0, /* FIXME: dwPasswordLength */
+ (SC_RPC_HANDLE *)&hService);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- if (lpPassword)
+ if (dwError != ERROR_SUCCESS)
{
- len = MultiByteToWideChar(CP_ACP, 0, lpPassword, -1, NULL, 0);
- lpPasswordW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
- if (!lpPasswordW)
- {
- SetLastError(ERROR_NOT_ENOUGH_MEMORY);
- goto cleanup;
- }
- MultiByteToWideChar(CP_ACP, 0, lpPassword, -1, lpPasswordW, len);
+ TRACE("RCreateServiceA() failed (Error %lu)\n", dwError);
+ SetLastError(dwError);
+ return NULL;
}
- RetVal = CreateServiceW(hSCManager,
- lpServiceNameW,
- lpDisplayNameW,
- dwDesiredAccess,
- dwServiceType,
- dwStartType,
- dwErrorControl,
- lpBinaryPathNameW,
- lpLoadOrderGroupW,
- lpdwTagId,
- lpDependenciesW,
- lpServiceStartNameW,
- lpPasswordW);
-
-cleanup:
- if (lpServiceNameW !=NULL)
- HeapFree(GetProcessHeap(), 0, lpServiceNameW);
-
- if (lpDisplayNameW != NULL)
- HeapFree(GetProcessHeap(), 0, lpDisplayNameW);
-
- if (lpBinaryPathNameW != NULL)
- HeapFree(GetProcessHeap(), 0, lpBinaryPathNameW);
-
- if (lpLoadOrderGroupW != NULL)
- HeapFree(GetProcessHeap(), 0, lpLoadOrderGroupW);
-
- if (lpDependenciesW != NULL)
- HeapFree(GetProcessHeap(), 0, lpDependenciesW);
-
- if (lpServiceStartNameW != NULL)
- HeapFree(GetProcessHeap(), 0, lpServiceStartNameW);
-
- if (lpPasswordW != NULL)
- HeapFree(GetProcessHeap(), 0, lpPasswordW);
-
- return RetVal;
+ return hService;
}
*
* @implemented
*/
-SC_HANDLE STDCALL
+SC_HANDLE WINAPI
CreateServiceW(SC_HANDLE hSCManager,
LPCWSTR lpServiceName,
LPCWSTR lpDisplayName,
LPWSTR lpStr;
TRACE("CreateServiceW() called\n");
+ TRACE("%p %S %S\n", hSCManager,
+ lpServiceName, lpDisplayName);
+
+ if (!hSCManager)
+ {
+ SetLastError(ERROR_INVALID_HANDLE);
+ return NULL;
+ }
/* Calculate the Dependencies length*/
if (lpDependencies != NULL)
lpStr = lpStr + dwLength;
}
dwDependenciesLength++;
+
+ dwDependenciesLength *= sizeof(WCHAR);
}
/* FIXME: Encrypt the password */
- HandleBind();
-
- /* Call to services.exe using RPC */
- dwError = RCreateServiceW(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- (LPWSTR)lpServiceName,
- (LPWSTR)lpDisplayName,
- dwDesiredAccess,
- dwServiceType,
- dwStartType,
- dwErrorControl,
- (LPWSTR)lpBinaryPathName,
- (LPWSTR)lpLoadOrderGroup,
- lpdwTagId,
- (LPBYTE)lpDependencies,
- dwDependenciesLength,
- (LPWSTR)lpServiceStartName,
- NULL, /* FIXME: lpPassword */
- 0, /* FIXME: dwPasswordLength */
- (SC_RPC_HANDLE *)&hService);
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RCreateServiceW((SC_RPC_HANDLE)hSCManager,
+ lpServiceName,
+ lpDisplayName,
+ dwDesiredAccess,
+ dwServiceType,
+ dwStartType,
+ dwErrorControl,
+ lpBinaryPathName,
+ lpLoadOrderGroup,
+ lpdwTagId,
+ (LPBYTE)lpDependencies,
+ dwDependenciesLength,
+ lpServiceStartName,
+ NULL, /* FIXME: lpPassword */
+ 0, /* FIXME: dwPasswordLength */
+ (SC_RPC_HANDLE *)&hService);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
if (dwError != ERROR_SUCCESS)
{
- ERR("RCreateServiceW() failed (Error %lu)\n", dwError);
+ TRACE("RCreateServiceW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return NULL;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
DeleteService(SC_HANDLE hService)
{
DWORD dwError;
TRACE("DeleteService(%x)\n", hService);
- HandleBind();
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RDeleteService((SC_RPC_HANDLE)hService);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = RDeleteService(BindingHandle,
- (SC_RPC_HANDLE)hService);
if (dwError != ERROR_SUCCESS)
{
- ERR("RDeleteService() failed (Error %lu)\n", dwError);
+ TRACE("RDeleteService() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
EnumDependentServicesA(SC_HANDLE hService,
DWORD dwServiceState,
LPENUM_SERVICE_STATUSA lpServices,
LPDWORD lpServicesReturned)
{
LPENUM_SERVICE_STATUSA lpStatusPtr;
- DWORD dwError = ERROR_SUCCESS;
+ DWORD dwError;
DWORD dwCount;
TRACE("EnumServicesStatusA() called\n");
- HandleBind();
-
- dwError = REnumDependentServicesA(BindingHandle,
- (SC_RPC_HANDLE)hService,
- dwServiceState,
- (LPBYTE)lpServices,
- cbBufSize,
- pcbBytesNeeded,
- lpServicesReturned);
+ RpcTryExcept
+ {
+ dwError = REnumDependentServicesA((SC_RPC_HANDLE)hService,
+ dwServiceState,
+ (LPBYTE)lpServices,
+ cbBufSize,
+ pcbBytesNeeded,
+ lpServicesReturned);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- lpStatusPtr = (LPENUM_SERVICE_STATUSA)lpServices;
- for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
{
- if (lpStatusPtr->lpServiceName)
- lpStatusPtr->lpServiceName =
- (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
+ lpStatusPtr = (LPENUM_SERVICE_STATUSA)lpServices;
+ 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;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
EnumDependentServicesW(SC_HANDLE hService,
DWORD dwServiceState,
LPENUM_SERVICE_STATUSW lpServices,
LPDWORD lpServicesReturned)
{
LPENUM_SERVICE_STATUSW lpStatusPtr;
- DWORD dwError = ERROR_SUCCESS;
+ DWORD dwError;
DWORD dwCount;
TRACE("EnumServicesStatusW() called\n");
- HandleBind();
-
- dwError = REnumDependentServicesW(BindingHandle,
- (SC_RPC_HANDLE)hService,
- dwServiceState,
- (LPBYTE)lpServices,
- cbBufSize,
- pcbBytesNeeded,
- lpServicesReturned);
+ RpcTryExcept
+ {
+ dwError = REnumDependentServicesW((SC_RPC_HANDLE)hService,
+ dwServiceState,
+ (LPBYTE)lpServices,
+ cbBufSize,
+ pcbBytesNeeded,
+ lpServicesReturned);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- lpStatusPtr = (LPENUM_SERVICE_STATUSW)lpServices;
- for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
{
- if (lpStatusPtr->lpServiceName)
- lpStatusPtr->lpServiceName =
- (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
+ 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);
+ 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;
}
* @unimplemented
*/
BOOL
-STDCALL
+WINAPI
EnumServiceGroupW(
SC_HANDLE hSCManager,
DWORD dwServiceType,
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
EnumServicesStatusA(SC_HANDLE hSCManager,
DWORD dwServiceType,
DWORD dwServiceState,
LPDWORD lpResumeHandle)
{
LPENUM_SERVICE_STATUSA lpStatusPtr;
- DWORD dwError = ERROR_SUCCESS;
+ DWORD dwError;
DWORD dwCount;
TRACE("EnumServicesStatusA() called\n");
- HandleBind();
+ if (!hSCManager)
+ {
+ SetLastError(ERROR_INVALID_HANDLE);
+ return FALSE;
+ }
+
+ if (dwServiceType != SERVICE_DRIVER && dwServiceType != SERVICE_WIN32)
+ {
+ if (pcbBytesNeeded && lpServicesReturned)
+ {
+ *pcbBytesNeeded = 0;
+ *lpServicesReturned = 0;
+ }
- dwError = REnumServicesStatusA(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- dwServiceType,
- dwServiceState,
- (LPBYTE)lpServices,
- cbBufSize,
- pcbBytesNeeded,
- lpServicesReturned,
- lpResumeHandle);
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
- lpStatusPtr = (LPENUM_SERVICE_STATUSA)lpServices;
- for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ if (dwServiceState != SERVICE_ACTIVE && dwServiceState != SERVICE_INACTIVE && dwServiceState != SERVICE_STATE_ALL)
{
- if (lpStatusPtr->lpServiceName)
- lpStatusPtr->lpServiceName =
- (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
+ if (pcbBytesNeeded)
+ *pcbBytesNeeded = 0;
+
+ if (lpServicesReturned)
+ *lpServicesReturned = 0;
+
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
+
+ if (!pcbBytesNeeded || !lpServicesReturned)
+ {
+ SetLastError(ERROR_INVALID_ADDRESS);
+ return FALSE;
+ }
- if (lpStatusPtr->lpDisplayName)
- lpStatusPtr->lpDisplayName =
- (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
+ if (!lpServices && cbBufSize != 0)
+ {
+ SetLastError(ERROR_INVALID_ADDRESS);
+ return FALSE;
+ }
- lpStatusPtr++;
+ RpcTryExcept
+ {
+ dwError = REnumServicesStatusA((SC_RPC_HANDLE)hSCManager,
+ dwServiceType,
+ dwServiceState,
+ (LPBYTE)lpServices,
+ cbBufSize,
+ pcbBytesNeeded,
+ lpServicesReturned,
+ lpResumeHandle);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
+ {
+ lpStatusPtr = (LPENUM_SERVICE_STATUSA)lpServices;
+ for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ {
+ if (lpStatusPtr->lpServiceName)
+ lpStatusPtr->lpServiceName =
+ (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
+
+ if (lpStatusPtr->lpDisplayName)
+ lpStatusPtr->lpDisplayName =
+ (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
+
+ lpStatusPtr++;
+ }
}
if (dwError != ERROR_SUCCESS)
{
- ERR("REnumServicesStatusA() failed (Error %lu)\n", dwError);
+ TRACE("REnumServicesStatusA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
EnumServicesStatusW(SC_HANDLE hSCManager,
DWORD dwServiceType,
DWORD dwServiceState,
LPDWORD lpResumeHandle)
{
LPENUM_SERVICE_STATUSW lpStatusPtr;
- DWORD dwError = ERROR_SUCCESS;
+ DWORD dwError;
DWORD dwCount;
TRACE("EnumServicesStatusW() called\n");
- HandleBind();
+ if (!hSCManager)
+ {
+ SetLastError(ERROR_INVALID_HANDLE);
+ return FALSE;
+ }
- dwError = REnumServicesStatusW(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- dwServiceType,
- dwServiceState,
- (LPBYTE)lpServices,
- cbBufSize,
- pcbBytesNeeded,
- lpServicesReturned,
- lpResumeHandle);
+ RpcTryExcept
+ {
+ dwError = REnumServicesStatusW((SC_RPC_HANDLE)hSCManager,
+ dwServiceType,
+ dwServiceState,
+ (LPBYTE)lpServices,
+ cbBufSize,
+ pcbBytesNeeded,
+ lpServicesReturned,
+ lpResumeHandle);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- lpStatusPtr = (LPENUM_SERVICE_STATUSW)lpServices;
- for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
+ if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
{
- if (lpStatusPtr->lpServiceName)
- lpStatusPtr->lpServiceName =
- (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
+ 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);
+ 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;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
EnumServicesStatusExA(SC_HANDLE hSCManager,
SC_ENUM_TYPE InfoLevel,
DWORD dwServiceType,
LPCSTR pszGroupName)
{
LPENUM_SERVICE_STATUS_PROCESSA lpStatusPtr;
- DWORD dwError = ERROR_SUCCESS;
+ DWORD dwError;
DWORD dwCount;
TRACE("EnumServicesStatusExA() called\n");
- HandleBind();
-
- dwError = REnumServicesStatusExA(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- InfoLevel,
- dwServiceType,
- dwServiceState,
- (LPBYTE)lpServices,
- cbBufSize,
- pcbBytesNeeded,
- lpServicesReturned,
- lpResumeHandle,
- (LPSTR)pszGroupName);
+ if (InfoLevel != SC_ENUM_PROCESS_INFO)
+ {
+ SetLastError(ERROR_INVALID_LEVEL);
+ return FALSE;
+ }
- if (dwError == ERROR_MORE_DATA)
+ if (!hSCManager)
{
- WARN("Required buffer size %ul\n", *pcbBytesNeeded);
- SetLastError(dwError);
+ SetLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
- else if (dwError == ERROR_SUCCESS)
+
+ RpcTryExcept
+ {
+ dwError = REnumServicesStatusExA((SC_RPC_HANDLE)hSCManager,
+ InfoLevel,
+ dwServiceType,
+ dwServiceState,
+ (LPBYTE)lpServices,
+ cbBufSize,
+ pcbBytesNeeded,
+ lpServicesReturned,
+ lpResumeHandle,
+ (LPSTR)pszGroupName);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
{
lpStatusPtr = (LPENUM_SERVICE_STATUS_PROCESSA)lpServices;
for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
lpStatusPtr++;
}
}
- else
+
+ if (dwError != ERROR_SUCCESS)
{
- ERR("REnumServicesStatusExA() failed (Error %lu)\n", dwError);
+ TRACE("REnumServicesStatusExA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
EnumServicesStatusExW(SC_HANDLE hSCManager,
SC_ENUM_TYPE InfoLevel,
DWORD dwServiceType,
LPCWSTR pszGroupName)
{
LPENUM_SERVICE_STATUS_PROCESSW lpStatusPtr;
- DWORD dwError = ERROR_SUCCESS;
+ DWORD dwError;
DWORD dwCount;
TRACE("EnumServicesStatusExW() called\n");
- HandleBind();
-
- dwError = REnumServicesStatusExW(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- InfoLevel,
- dwServiceType,
- dwServiceState,
- (LPBYTE)lpServices,
- cbBufSize,
- pcbBytesNeeded,
- lpServicesReturned,
- lpResumeHandle,
- (LPWSTR)pszGroupName);
-
- if (dwError == ERROR_MORE_DATA)
+ RpcTryExcept
{
- WARN("Required buffer size %ul\n", *pcbBytesNeeded);
- SetLastError(dwError);
- return FALSE;
+ dwError = REnumServicesStatusExW((SC_RPC_HANDLE)hSCManager,
+ InfoLevel,
+ dwServiceType,
+ dwServiceState,
+ (LPBYTE)lpServices,
+ cbBufSize,
+ pcbBytesNeeded,
+ lpServicesReturned,
+ lpResumeHandle,
+ (LPWSTR)pszGroupName);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
}
- else if (dwError == ERROR_SUCCESS)
+ RpcEndExcept;
+
+ if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
{
lpStatusPtr = (LPENUM_SERVICE_STATUS_PROCESSW)lpServices;
for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
lpStatusPtr++;
}
}
- else
+
+ if (dwError != ERROR_SUCCESS)
{
- ERR("REnumServicesStatusExW() failed (Error %lu)\n", dwError);
+ TRACE("REnumServicesStatusExW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
GetServiceDisplayNameA(SC_HANDLE hSCManager,
LPCSTR lpServiceName,
LPSTR lpDisplayName,
LPDWORD lpcchBuffer)
{
DWORD dwError;
+ LPSTR lpNameBuffer;
+ CHAR szEmptyName[] = "";
TRACE("GetServiceDisplayNameA() called\n");
+ TRACE("%p %s %p %p\n", hSCManager,
+ debugstr_a(lpServiceName), lpDisplayName, lpcchBuffer);
+
+ if (!hSCManager)
+ {
+ SetLastError(ERROR_INVALID_HANDLE);
+ return FALSE;
+ }
- HandleBind();
+ if (!lpDisplayName || *lpcchBuffer < sizeof(CHAR))
+ {
+ lpNameBuffer = szEmptyName;
+ *lpcchBuffer = sizeof(CHAR);
+ }
+ else
+ {
+ lpNameBuffer = lpDisplayName;
+ }
+
+ RpcTryExcept
+ {
+ dwError = RGetServiceDisplayNameA((SC_RPC_HANDLE)hSCManager,
+ lpServiceName,
+ lpNameBuffer,
+ lpcchBuffer);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ /* HACK: because of a problem with rpcrt4, rpcserver is hacked to return 6 for ERROR_SERVICE_DOES_NOT_EXIST */
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- dwError = RGetServiceDisplayNameA(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- (LPSTR)lpServiceName,
- lpDisplayName,
- lpcchBuffer);
if (dwError != ERROR_SUCCESS)
{
- ERR("RGetServiceDisplayNameA() failed (Error %lu)\n", dwError);
+ TRACE("RGetServiceDisplayNameA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
- (*lpcchBuffer)--;
-
return TRUE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
GetServiceDisplayNameW(SC_HANDLE hSCManager,
LPCWSTR lpServiceName,
LPWSTR lpDisplayName,
LPDWORD lpcchBuffer)
{
DWORD dwError;
+ LPWSTR lpNameBuffer;
+ WCHAR szEmptyName[] = L"";
TRACE("GetServiceDisplayNameW() called\n");
- HandleBind();
+ if (!hSCManager)
+ {
+ SetLastError(ERROR_INVALID_HANDLE);
+ return FALSE;
+ }
+
+ if (!lpDisplayName || *lpcchBuffer < sizeof(WCHAR))
+ {
+ lpNameBuffer = szEmptyName;
+ *lpcchBuffer = sizeof(WCHAR);
+ }
+ else
+ {
+ lpNameBuffer = lpDisplayName;
+ }
+
+ RpcTryExcept
+ {
+ dwError = RGetServiceDisplayNameW((SC_RPC_HANDLE)hSCManager,
+ lpServiceName,
+ lpNameBuffer,
+ lpcchBuffer);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- dwError = RGetServiceDisplayNameW(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- (LPWSTR)lpServiceName,
- lpDisplayName,
- lpcchBuffer);
if (dwError != ERROR_SUCCESS)
{
- ERR("RGetServiceDisplayNameW() failed (Error %lu)\n", dwError);
+ TRACE("RGetServiceDisplayNameW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
- (*lpcchBuffer)--;
-
return TRUE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
GetServiceKeyNameA(SC_HANDLE hSCManager,
LPCSTR lpDisplayName,
LPSTR lpServiceName,
LPDWORD lpcchBuffer)
{
DWORD dwError;
+ LPSTR lpNameBuffer;
+ CHAR szEmptyName[] = "";
TRACE("GetServiceKeyNameA() called\n");
- HandleBind();
+ if (!hSCManager)
+ {
+ SetLastError(ERROR_INVALID_HANDLE);
+ return FALSE;
+ }
+
+ if (!lpServiceName || *lpcchBuffer < sizeof(CHAR))
+ {
+ lpNameBuffer = szEmptyName;
+ *lpcchBuffer = sizeof(CHAR);
+ }
+ else
+ {
+ lpNameBuffer = lpServiceName;
+ }
+
+ RpcTryExcept
+ {
+ dwError = RGetServiceKeyNameA((SC_RPC_HANDLE)hSCManager,
+ lpDisplayName,
+ lpNameBuffer,
+ lpcchBuffer);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- dwError = RGetServiceKeyNameA(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- (LPSTR)lpDisplayName,
- lpServiceName,
- lpcchBuffer);
if (dwError != ERROR_SUCCESS)
{
- ERR("RGetServiceKeyNameA() failed (Error %lu)\n", dwError);
+ TRACE("RGetServiceKeyNameA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
- (*lpcchBuffer)--;
-
return TRUE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
GetServiceKeyNameW(SC_HANDLE hSCManager,
LPCWSTR lpDisplayName,
LPWSTR lpServiceName,
LPDWORD lpcchBuffer)
{
DWORD dwError;
+ LPWSTR lpNameBuffer;
+ WCHAR szEmptyName[] = L"";
TRACE("GetServiceKeyNameW() called\n");
- HandleBind();
+ if (!hSCManager)
+ {
+ SetLastError(ERROR_INVALID_HANDLE);
+ return FALSE;
+ }
+
+ if (!lpServiceName || *lpcchBuffer < sizeof(WCHAR))
+ {
+ lpNameBuffer = szEmptyName;
+ *lpcchBuffer = sizeof(WCHAR);
+ }
+ else
+ {
+ lpNameBuffer = lpServiceName;
+ }
+
+ RpcTryExcept
+ {
+ dwError = RGetServiceKeyNameW((SC_RPC_HANDLE)hSCManager,
+ lpDisplayName,
+ lpNameBuffer,
+ lpcchBuffer);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- dwError = RGetServiceKeyNameW(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- (LPWSTR)lpDisplayName,
- lpServiceName,
- lpcchBuffer);
if (dwError != ERROR_SUCCESS)
{
- ERR("RGetServiceKeyNameW() failed (Error %lu)\n", dwError);
+ TRACE("RGetServiceKeyNameW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
- (*lpcchBuffer)--;
-
return TRUE;
}
*
* @implemented
*/
-SC_LOCK STDCALL
+SC_LOCK WINAPI
LockServiceDatabase(SC_HANDLE hSCManager)
{
SC_LOCK hLock;
TRACE("LockServiceDatabase(%x)\n", hSCManager);
- HandleBind();
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RLockServiceDatabase((SC_RPC_HANDLE)hSCManager,
+ (SC_RPC_LOCK *)&hLock);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = RLockServiceDatabase(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- (SC_RPC_LOCK *)&hLock);
if (dwError != ERROR_SUCCESS)
{
- ERR("RLockServiceDatabase() failed (Error %lu)\n", dwError);
+ TRACE("RLockServiceDatabase() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return NULL;
}
*
* @implemented
*/
-SC_HANDLE STDCALL
+SC_HANDLE WINAPI
OpenSCManagerA(LPCSTR lpMachineName,
LPCSTR lpDatabaseName,
DWORD dwDesiredAccess)
WaitForSCManager();
- HandleBind();
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = ROpenSCManagerA((LPSTR)lpMachineName,
+ (LPSTR)lpDatabaseName,
+ dwDesiredAccess,
+ (SC_RPC_HANDLE *)&hScm);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = ROpenSCManagerA(BindingHandle,
- (LPSTR)lpMachineName,
- (LPSTR)lpDatabaseName,
- dwDesiredAccess,
- (SC_RPC_HANDLE *)&hScm);
if (dwError != ERROR_SUCCESS)
{
- ERR("ROpenSCManagerA() failed (Error %lu)\n", dwError);
+ TRACE("ROpenSCManagerA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return NULL;
}
*
* @implemented
*/
-SC_HANDLE STDCALL
+SC_HANDLE WINAPI
OpenSCManagerW(LPCWSTR lpMachineName,
LPCWSTR lpDatabaseName,
DWORD dwDesiredAccess)
WaitForSCManager();
- HandleBind();
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = ROpenSCManagerW((LPWSTR)lpMachineName,
+ (LPWSTR)lpDatabaseName,
+ dwDesiredAccess,
+ (SC_RPC_HANDLE *)&hScm);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = ROpenSCManagerW(BindingHandle,
- (LPWSTR)lpMachineName,
- (LPWSTR)lpDatabaseName,
- dwDesiredAccess,
- (SC_RPC_HANDLE *)&hScm);
if (dwError != ERROR_SUCCESS)
{
- ERR("ROpenSCManagerW() failed (Error %lu)\n", dwError);
+ TRACE("ROpenSCManagerW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return NULL;
}
*
* @implemented
*/
-SC_HANDLE STDCALL
+SC_HANDLE WINAPI
OpenServiceA(SC_HANDLE hSCManager,
LPCSTR lpServiceName,
DWORD dwDesiredAccess)
TRACE("OpenServiceA(%p, %s, %lx)\n",
hSCManager, lpServiceName, dwDesiredAccess);
- HandleBind();
+ if (!hSCManager)
+ {
+ SetLastError(ERROR_INVALID_HANDLE);
+ return NULL;
+ }
+
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = ROpenServiceA((SC_RPC_HANDLE)hSCManager,
+ (LPSTR)lpServiceName,
+ dwDesiredAccess,
+ (SC_RPC_HANDLE *)&hService);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = ROpenServiceA(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- (LPSTR)lpServiceName,
- dwDesiredAccess,
- (SC_RPC_HANDLE *)&hService);
if (dwError != ERROR_SUCCESS)
{
- ERR("ROpenServiceA() failed (Error %lu)\n", dwError);
+ TRACE("ROpenServiceA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return NULL;
}
*
* @implemented
*/
-SC_HANDLE STDCALL
+SC_HANDLE WINAPI
OpenServiceW(SC_HANDLE hSCManager,
LPCWSTR lpServiceName,
DWORD dwDesiredAccess)
TRACE("OpenServiceW(%p, %S, %lx)\n",
hSCManager, lpServiceName, dwDesiredAccess);
- HandleBind();
+ if (!hSCManager)
+ {
+ SetLastError(ERROR_INVALID_HANDLE);
+ return NULL;
+ }
+
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = ROpenServiceW((SC_RPC_HANDLE)hSCManager,
+ (LPWSTR)lpServiceName,
+ dwDesiredAccess,
+ (SC_RPC_HANDLE *)&hService);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = ROpenServiceW(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- (LPWSTR)lpServiceName,
- dwDesiredAccess,
- (SC_RPC_HANDLE *)&hService);
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;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
QueryServiceConfigA(SC_HANDLE hService,
LPQUERY_SERVICE_CONFIGA lpServiceConfig,
DWORD cbBufSize,
TRACE("QueryServiceConfigA(%p, %p, %lu, %p)\n",
hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
- HandleBind();
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceConfigA((SC_RPC_HANDLE)hService,
+ (LPBYTE)lpServiceConfig,
+ cbBufSize,
+ pcbBytesNeeded);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = RQueryServiceConfigA(BindingHandle,
- (SC_RPC_HANDLE)hService,
- lpServiceConfig,
- cbBufSize,
- pcbBytesNeeded);
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceConfigA() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceConfigA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
QueryServiceConfigW(SC_HANDLE hService,
LPQUERY_SERVICE_CONFIGW lpServiceConfig,
DWORD cbBufSize,
TRACE("QueryServiceConfigW(%p, %p, %lu, %p)\n",
hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
- HandleBind();
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceConfigW((SC_RPC_HANDLE)hService,
+ (LPBYTE)lpServiceConfig,
+ cbBufSize,
+ pcbBytesNeeded);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = RQueryServiceConfigW(BindingHandle,
- (SC_RPC_HANDLE)hService,
- (LPBYTE)lpServiceConfig,
- cbBufSize,
- pcbBytesNeeded);
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;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
QueryServiceConfig2A(SC_HANDLE hService,
DWORD dwInfoLevel,
LPBYTE lpBuffer,
{
DWORD dwError;
- TRACE("QueryServiceConfig2A(%p, %lu, %p, %lu, %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);
- HandleBind();
+ if (dwInfoLevel != SERVICE_CONFIG_DESCRIPTION &&
+ dwInfoLevel != SERVICE_CONFIG_FAILURE_ACTIONS)
+ {
+ SetLastError(ERROR_INVALID_LEVEL);
+ return FALSE;
+ }
+
+ if ((lpBuffer == NULL && cbBufSize != 0) ||
+ pcbBytesNeeded == NULL)
+ {
+ SetLastError(ERROR_INVALID_ADDRESS);
+ return FALSE;
+ }
+
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceConfig2A((SC_RPC_HANDLE)hService,
+ dwInfoLevel,
+ lpBuffer,
+ cbBufSize,
+ pcbBytesNeeded);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = RQueryServiceConfig2A(BindingHandle,
- (SC_RPC_HANDLE)hService,
- dwInfoLevel,
- lpBuffer,
- cbBufSize,
- pcbBytesNeeded);
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceConfig2A() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceConfig2A() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
QueryServiceConfig2W(SC_HANDLE hService,
DWORD dwInfoLevel,
LPBYTE lpBuffer,
TRACE("QueryServiceConfig2W(%p, %lu, %p, %lu, %p)\n",
hService, dwInfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
- HandleBind();
+ if (dwInfoLevel != SERVICE_CONFIG_DESCRIPTION &&
+ dwInfoLevel != SERVICE_CONFIG_FAILURE_ACTIONS)
+ {
+ SetLastError(ERROR_INVALID_LEVEL);
+ return FALSE;
+ }
+
+ if ((lpBuffer == NULL && cbBufSize != 0) ||
+ pcbBytesNeeded == NULL)
+ {
+ SetLastError(ERROR_INVALID_ADDRESS);
+ return FALSE;
+ }
+
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceConfig2W((SC_RPC_HANDLE)hService,
+ dwInfoLevel,
+ lpBuffer,
+ cbBufSize,
+ pcbBytesNeeded);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = RQueryServiceConfig2W(BindingHandle,
- (SC_RPC_HANDLE)hService,
- dwInfoLevel,
- lpBuffer,
- cbBufSize,
- pcbBytesNeeded);
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceConfig2W() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceConfig2W() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
QueryServiceLockStatusA(SC_HANDLE hSCManager,
LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus,
DWORD cbBufSize,
TRACE("QueryServiceLockStatusA() called\n");
- HandleBind();
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceLockStatusA((SC_RPC_HANDLE)hSCManager,
+ lpLockStatus,
+ cbBufSize,
+ pcbBytesNeeded);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = RQueryServiceLockStatusA(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- lpLockStatus,
- cbBufSize,
- pcbBytesNeeded);
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceLockStatusA() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceLockStatusA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
QueryServiceLockStatusW(SC_HANDLE hSCManager,
LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus,
DWORD cbBufSize,
TRACE("QueryServiceLockStatusW() called\n");
- HandleBind();
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceLockStatusW((SC_RPC_HANDLE)hSCManager,
+ lpLockStatus,
+ cbBufSize,
+ pcbBytesNeeded);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = RQueryServiceLockStatusW(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- lpLockStatus,
- cbBufSize,
- pcbBytesNeeded);
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceLockStatusW() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceLockStatusW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
QueryServiceObjectSecurity(SC_HANDLE hService,
SECURITY_INFORMATION dwSecurityInformation,
PSECURITY_DESCRIPTOR lpSecurityDescriptor,
TRACE("QueryServiceObjectSecurity(%p, %lu, %p)\n",
hService, dwSecurityInformation, lpSecurityDescriptor);
- HandleBind();
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceObjectSecurity((SC_RPC_HANDLE)hService,
+ dwSecurityInformation,
+ (LPBYTE)lpSecurityDescriptor,
+ cbBufSize,
+ pcbBytesNeeded);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = RQueryServiceObjectSecurity(BindingHandle,
- (SC_RPC_HANDLE)hService,
- dwSecurityInformation,
- (LPBYTE)lpSecurityDescriptor,
- cbBufSize,
- pcbBytesNeeded);
if (dwError != ERROR_SUCCESS)
{
- ERR("QueryServiceObjectSecurity() failed (Error %lu)\n", dwError);
+ TRACE("QueryServiceObjectSecurity() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
SetServiceObjectSecurity(SC_HANDLE hService,
SECURITY_INFORMATION dwSecurityInformation,
PSECURITY_DESCRIPTOR lpSecurityDescriptor)
return FALSE;
}
- HandleBind();
-
- /* Call to services.exe using RPC */
- dwError = RSetServiceObjectSecurity(BindingHandle,
- (SC_RPC_HANDLE)hService,
- dwSecurityInformation,
- (LPBYTE)SelfRelativeSD,
- Length);
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RSetServiceObjectSecurity((SC_RPC_HANDLE)hService,
+ dwSecurityInformation,
+ (LPBYTE)SelfRelativeSD,
+ Length);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
HeapFree(GetProcessHeap(), 0, SelfRelativeSD);
if (dwError != ERROR_SUCCESS)
{
- ERR("RServiceObjectSecurity() failed (Error %lu)\n", dwError);
+ TRACE("RServiceObjectSecurity() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
QueryServiceStatus(SC_HANDLE hService,
LPSERVICE_STATUS lpServiceStatus)
{
TRACE("QueryServiceStatus(%p, %p)\n",
hService, lpServiceStatus);
- HandleBind();
+ if (!hService)
+ {
+ SetLastError(ERROR_INVALID_HANDLE);
+ return FALSE;
+ }
+
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceStatus((SC_RPC_HANDLE)hService,
+ lpServiceStatus);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = RQueryServiceStatus(BindingHandle,
- (SC_RPC_HANDLE)hService,
- lpServiceStatus);
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceStatus() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceStatus() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
QueryServiceStatusEx(SC_HANDLE hService,
SC_STATUS_TYPE InfoLevel,
LPBYTE lpBuffer,
TRACE("QueryServiceStatusEx() called\n");
- HandleBind();
+ if (InfoLevel != SC_STATUS_PROCESS_INFO)
+ {
+ SetLastError(ERROR_INVALID_LEVEL);
+ return FALSE;
+ }
+
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceStatusEx((SC_RPC_HANDLE)hService,
+ InfoLevel,
+ lpBuffer,
+ cbBufSize,
+ pcbBytesNeeded);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = RQueryServiceStatusEx(BindingHandle,
- (SC_RPC_HANDLE)hService,
- InfoLevel,
- lpBuffer,
- cbBufSize,
- pcbBytesNeeded);
if (dwError != ERROR_SUCCESS)
{
- ERR("RQueryServiceStatusEx() failed (Error %lu)\n", dwError);
+ TRACE("RQueryServiceStatusEx() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
StartServiceA(SC_HANDLE hService,
DWORD dwNumServiceArgs,
LPCSTR *lpServiceArgVectors)
{
DWORD dwError;
- dwError = RStartServiceA(BindingHandle,
- (SC_RPC_HANDLE)hService,
- dwNumServiceArgs,
- (LPSTRING_PTRSA)lpServiceArgVectors);
-
+ RpcTryExcept
+ {
+ dwError = RStartServiceA((SC_RPC_HANDLE)hService,
+ dwNumServiceArgs,
+ (LPSTRING_PTRSA)lpServiceArgVectors);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
if (dwError != ERROR_SUCCESS)
{
- ERR("RStartServiceA() failed (Error %lu)\n", dwError);
+ TRACE("RStartServiceA() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
StartServiceW(SC_HANDLE hService,
DWORD dwNumServiceArgs,
LPCWSTR *lpServiceArgVectors)
{
DWORD dwError;
- dwError = RStartServiceW(BindingHandle,
- (SC_RPC_HANDLE)hService,
- dwNumServiceArgs,
- (LPSTRING_PTRSW)lpServiceArgVectors);
+ RpcTryExcept
+ {
+ dwError = RStartServiceW((SC_RPC_HANDLE)hService,
+ dwNumServiceArgs,
+ (LPSTRING_PTRSW)lpServiceArgVectors);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
if (dwError != ERROR_SUCCESS)
{
- ERR("RStartServiceW() failed (Error %lu)\n", dwError);
+ TRACE("RStartServiceW() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
UnlockServiceDatabase(SC_LOCK ScLock)
{
DWORD dwError;
TRACE("UnlockServiceDatabase(%x)\n", ScLock);
- HandleBind();
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RUnlockServiceDatabase((LPSC_RPC_LOCK)&ScLock);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = RUnlockServiceDatabase(BindingHandle,
- (SC_RPC_LOCK)ScLock);
if (dwError != ERROR_SUCCESS)
{
- ERR("RUnlockServiceDatabase() failed (Error %lu)\n", dwError);
+ TRACE("RUnlockServiceDatabase() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
NotifyBootConfigStatus(BOOL BootAcceptable)
{
DWORD dwError;
TRACE("NotifyBootConfigStatus()\n");
- HandleBind();
+ RpcTryExcept
+ {
+ /* Call to services.exe using RPC */
+ dwError = RNotifyBootConfigStatus(NULL,
+ BootAcceptable);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ RpcEndExcept;
- /* Call to services.exe using RPC */
- dwError = RNotifyBootConfigStatus(BindingHandle,
- NULL,
- BootAcceptable);
if (dwError != ERROR_SUCCESS)
{
- ERR("NotifyBootConfigStatus() failed (Error %lu)\n", dwError);
+ TRACE("NotifyBootConfigStatus() failed (Error %lu)\n", dwError);
SetLastError(dwError);
return FALSE;
}
projects / reactos.git / blobdiff