/* 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((UCHAR *)szMachineName,
+ (UCHAR *)"ncacn_np",
+ NULL,
+ (UCHAR *)"\\pipe\\ntsvcs",
+ NULL,
+ (UCHAR **)&pszStringBinding);
+ if (status)
+ {
+ 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)
+ {
+ ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
+ }
+
+ status = RpcStringFreeA(&pszStringBinding);
+ if (status)
+ {
+ ERR("RpcStringFree returned 0x%x\n", status);
+ }
+
+ return hBinding;
+}
+
-VOID
-HandleBind(VOID)
+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)
+ {
+ 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(szMachineName,
+ L"ncacn_np",
+ NULL,
+ L"\\pipe\\ntsvcs",
+ NULL,
+ &pszStringBinding);
+ if (status)
+ {
+ 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)
+ {
+ ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
+ }
+
+ status = RpcStringFreeW(&pszStringBinding);
+ if (status)
+ {
+ ERR("RpcStringFree returned 0x%x\n", status);
+ }
+
+ return hBinding;
+}
+
+
+void __RPC_USER
+SVCCTL_HANDLEW_unbind(SVCCTL_HANDLEW szMachineName,
+ handle_t hBinding)
+{
+ RPC_STATUS status;
+
+ TRACE("SVCCTL_HANDLEW_unbind() called\n");
+
+ status = RpcBindingFree(&hBinding);
+ if (status)
+ {
+ ERR("RpcBindingFree returned 0x%x\n", status);
+ }
+}
+
+
+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",
&pszStringBinding);
if (status)
{
- 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);
+ &hBinding);
if (status)
{
- TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
+ ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
}
status = RpcStringFreeW(&pszStringBinding);
if (status)
{
- 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
+RPC_SERVICE_STATUS_HANDLE_unbind(RPC_SERVICE_STATUS_HANDLE hServiceStatus,
+ handle_t hBinding)
{
RPC_STATUS status;
- if (BindingHandle == NULL)
- return;
+ TRACE("RPC_SERVICE_STATUS_HANDLE_unbind() called\n");
- status = RpcBindingFree(&BindingHandle);
+ status = RpcBindingFree(&hBinding);
if (status)
{
- TRACE("RpcBindingFree returned 0x%x\n", status);
+ ERR("RpcBindingFree returned 0x%x\n", status);
+ }
+}
+
+
+DWORD
+ScmRpcStatusToWinError(RPC_STATUS Status)
+{
+ switch (Status)
+ {
+ case RPC_X_SS_IN_NULL_CONTEXT:
+ return ERROR_INVALID_HANDLE;
+
+ case RPC_X_NULL_REF_POINTER:
+ return ERROR_INVALID_PARAMETER;
+
+ case STATUS_ACCESS_VIOLATION:
+ return ERROR_INVALID_ADDRESS;
+
+ default:
+ return (DWORD)Status;
}
}
-#endif
/**********************************************************************
if (lpInfo == NULL)
return TRUE;
- HandleBind();
+ _SEH_TRY
+ {
+ dwError = RChangeServiceConfig2A((SC_RPC_HANDLE)hService,
+ Info);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- dwError = RChangeServiceConfig2A(BindingHandle,
- (SC_RPC_HANDLE)hService,
- Info);
if (dwError != ERROR_SUCCESS)
{
ERR("RChangeServiceConfig2A() failed (Error %lu)\n", dwError);
if (lpInfo == NULL)
return TRUE;
- HandleBind();
+ _SEH_TRY
+ {
+ dwError = RChangeServiceConfig2W((SC_RPC_HANDLE)hService,
+ Info);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- dwError = RChangeServiceConfig2W(BindingHandle,
- (SC_RPC_HANDLE)hService,
- Info);
if (dwError != ERROR_SUCCESS)
{
ERR("RChangeServiceConfig2W() failed (Error %lu)\n", dwError);
/* 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);
+ _SEH_TRY
+ {
+ /* 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);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
+
if (dwError != ERROR_SUCCESS)
{
ERR("RChangeServiceConfigA() failed (Error %lu)\n", dwError);
/* 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);
+ _SEH_TRY
+ {
+ /* 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);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
+
if (dwError != ERROR_SUCCESS)
{
ERR("RChangeServiceConfigW() failed (Error %lu)\n", dwError);
TRACE("CloseServiceHandle() called\n");
- HandleBind();
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = RCloseServiceHandle((LPSC_RPC_HANDLE)&hSCObject);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* Call to services.exe using RPC */
- dwError = RCloseServiceHandle(BindingHandle,
- (LPSC_RPC_HANDLE)&hSCObject);
if (dwError)
{
ERR("RCloseServiceHandle() failed (Error %lu)\n", dwError);
TRACE("ControlService(%x, %x, %p)\n",
hService, dwControl, lpServiceStatus);
- HandleBind();
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = RControlService((SC_RPC_HANDLE)hService,
+ dwControl,
+ lpServiceStatus);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* 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);
}
-
/**********************************************************************
* CreateServiceA
*
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto cleanup;
}
- MultiByteToWideChar(CP_ACP, 0, lpDependencies, -1, lpDependenciesW, dwDependenciesLength);
+ MultiByteToWideChar(CP_ACP, 0, lpDependencies, dwDependenciesLength, lpDependenciesW, dwDependenciesLength);
}
if (lpServiceStartName)
/* 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);
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = RCreateServiceW((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);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
+
if (dwError != ERROR_SUCCESS)
{
ERR("RCreateServiceW() failed (Error %lu)\n", dwError);
TRACE("DeleteService(%x)\n", hService);
- HandleBind();
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = RDeleteService((SC_RPC_HANDLE)hService);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* Call to services.exe using RPC */
- dwError = RDeleteService(BindingHandle,
- (SC_RPC_HANDLE)hService);
if (dwError != ERROR_SUCCESS)
{
ERR("RDeleteService() failed (Error %lu)\n", dwError);
LPDWORD lpServicesReturned)
{
LPENUM_SERVICE_STATUSA lpStatusPtr;
- DWORD dwError = ERROR_SUCCESS;
+ DWORD dwError;
DWORD dwCount;
TRACE("EnumServicesStatusA() called\n");
- HandleBind();
+ _SEH_TRY
+ {
+ dwError = REnumDependentServicesA((SC_RPC_HANDLE)hService,
+ dwServiceState,
+ (LPBYTE)lpServices,
+ cbBufSize,
+ pcbBytesNeeded,
+ lpServicesReturned);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- dwError = REnumDependentServicesA(BindingHandle,
- (SC_RPC_HANDLE)hService,
- dwServiceState,
- (LPBYTE)lpServices,
- cbBufSize,
- pcbBytesNeeded,
- lpServicesReturned);
+ if (dwError != ERROR_SUCCESS)
+ {
+ ERR("REnumDependentServicesA() failed (Error %lu)\n", dwError);
+ SetLastError(dwError);
+ return FALSE;
+ }
lpStatusPtr = (LPENUM_SERVICE_STATUSA)lpServices;
for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
lpStatusPtr++;
}
- if (dwError != ERROR_SUCCESS)
- {
- ERR("REnumDependentServicesA() failed (Error %lu)\n", dwError);
- SetLastError(dwError);
- return FALSE;
- }
-
TRACE("EnumDependentServicesA() done\n");
return TRUE;
LPDWORD lpServicesReturned)
{
LPENUM_SERVICE_STATUSW lpStatusPtr;
- DWORD dwError = ERROR_SUCCESS;
+ DWORD dwError;
DWORD dwCount;
TRACE("EnumServicesStatusW() called\n");
- HandleBind();
+ _SEH_TRY
+ {
+ dwError = REnumDependentServicesW((SC_RPC_HANDLE)hService,
+ dwServiceState,
+ (LPBYTE)lpServices,
+ cbBufSize,
+ pcbBytesNeeded,
+ lpServicesReturned);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- dwError = REnumDependentServicesW(BindingHandle,
- (SC_RPC_HANDLE)hService,
- dwServiceState,
- (LPBYTE)lpServices,
- cbBufSize,
- pcbBytesNeeded,
- lpServicesReturned);
+ if (dwError != ERROR_SUCCESS)
+ {
+ ERR("REnumDependentServicesW() failed (Error %lu)\n", dwError);
+ SetLastError(dwError);
+ return FALSE;
+ }
lpStatusPtr = (LPENUM_SERVICE_STATUSW)lpServices;
for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
lpStatusPtr++;
}
- if (dwError != ERROR_SUCCESS)
- {
- ERR("REnumDependentServicesW() failed (Error %lu)\n", dwError);
- SetLastError(dwError);
- return FALSE;
- }
-
TRACE("EnumDependentServicesW() done\n");
return TRUE;
LPDWORD lpResumeHandle)
{
LPENUM_SERVICE_STATUSA lpStatusPtr;
- DWORD dwError = ERROR_SUCCESS;
+ DWORD dwError;
DWORD dwCount;
TRACE("EnumServicesStatusA() called\n");
- HandleBind();
+ _SEH_TRY
+ {
+ dwError = REnumServicesStatusA((SC_RPC_HANDLE)hSCManager,
+ dwServiceType,
+ dwServiceState,
+ (LPBYTE)lpServices,
+ cbBufSize,
+ pcbBytesNeeded,
+ lpServicesReturned,
+ lpResumeHandle);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- dwError = REnumServicesStatusA(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- dwServiceType,
- dwServiceState,
- (LPBYTE)lpServices,
- cbBufSize,
- pcbBytesNeeded,
- lpServicesReturned,
- lpResumeHandle);
+ if (dwError != ERROR_SUCCESS)
+ {
+ ERR("REnumServicesStatusA() failed (Error %lu)\n", dwError);
+ SetLastError(dwError);
+ return FALSE;
+ }
lpStatusPtr = (LPENUM_SERVICE_STATUSA)lpServices;
for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
lpStatusPtr++;
}
- if (dwError != ERROR_SUCCESS)
- {
- ERR("REnumServicesStatusA() failed (Error %lu)\n", dwError);
- SetLastError(dwError);
- return FALSE;
- }
-
TRACE("EnumServicesStatusA() done\n");
return TRUE;
LPDWORD lpResumeHandle)
{
LPENUM_SERVICE_STATUSW lpStatusPtr;
- DWORD dwError = ERROR_SUCCESS;
+ DWORD dwError;
DWORD dwCount;
TRACE("EnumServicesStatusW() called\n");
- HandleBind();
+ _SEH_TRY
+ {
+ dwError = REnumServicesStatusW((SC_RPC_HANDLE)hSCManager,
+ dwServiceType,
+ dwServiceState,
+ (LPBYTE)lpServices,
+ cbBufSize,
+ pcbBytesNeeded,
+ lpServicesReturned,
+ lpResumeHandle);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- dwError = REnumServicesStatusW(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- dwServiceType,
- dwServiceState,
- (LPBYTE)lpServices,
- cbBufSize,
- pcbBytesNeeded,
- lpServicesReturned,
- lpResumeHandle);
+ if (dwError != ERROR_SUCCESS)
+ {
+ ERR("REnumServicesStatusW() failed (Error %lu)\n", dwError);
+ SetLastError(dwError);
+ return FALSE;
+ }
lpStatusPtr = (LPENUM_SERVICE_STATUSW)lpServices;
for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
lpStatusPtr++;
}
- if (dwError != ERROR_SUCCESS)
- {
- ERR("REnumServicesStatusW() failed (Error %lu)\n", dwError);
- SetLastError(dwError);
- return FALSE;
- }
-
TRACE("EnumServicesStatusW() done\n");
return TRUE;
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);
+ _SEH_TRY
+ {
+ dwError = REnumServicesStatusExA((SC_RPC_HANDLE)hSCManager,
+ InfoLevel,
+ dwServiceType,
+ dwServiceState,
+ (LPBYTE)lpServices,
+ cbBufSize,
+ pcbBytesNeeded,
+ lpServicesReturned,
+ lpResumeHandle,
+ (LPSTR)pszGroupName);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
if (dwError == ERROR_MORE_DATA)
{
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);
+ _SEH_TRY
+ {
+ dwError = REnumServicesStatusExW((SC_RPC_HANDLE)hSCManager,
+ InfoLevel,
+ dwServiceType,
+ dwServiceState,
+ (LPBYTE)lpServices,
+ cbBufSize,
+ pcbBytesNeeded,
+ lpServicesReturned,
+ lpResumeHandle,
+ (LPWSTR)pszGroupName);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
if (dwError == ERROR_MORE_DATA)
{
TRACE("GetServiceDisplayNameA() called\n");
- HandleBind();
+ if (!lpDisplayName)
+ *lpcchBuffer = 0;
+
+ _SEH_TRY
+ {
+ dwError = RGetServiceDisplayNameA((SC_RPC_HANDLE)hSCManager,
+ (LPSTR)lpServiceName,
+ lpDisplayName,
+ lpcchBuffer);
+ }
+ _SEH_HANDLE
+ {
+ /* HACK: because of a problem with rpcrt4, rpcserver is hacked to return 6 for ERROR_SERVICE_DOES_NOT_EXIST */
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+
+
+ _SEH_END;
- dwError = RGetServiceDisplayNameA(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- (LPSTR)lpServiceName,
- lpDisplayName,
- lpcchBuffer);
if (dwError != ERROR_SUCCESS)
{
ERR("RGetServiceDisplayNameA() failed (Error %lu)\n", dwError);
return FALSE;
}
- (*lpcchBuffer)--;
-
return TRUE;
}
TRACE("GetServiceDisplayNameW() called\n");
- HandleBind();
+ if (!lpDisplayName)
+ *lpcchBuffer = 0;
+
+ _SEH_TRY
+ {
+ dwError = RGetServiceDisplayNameW((SC_RPC_HANDLE)hSCManager,
+ (LPWSTR)lpServiceName,
+ lpDisplayName,
+ lpcchBuffer);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- dwError = RGetServiceDisplayNameW(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- (LPWSTR)lpServiceName,
- lpDisplayName,
- lpcchBuffer);
if (dwError != ERROR_SUCCESS)
{
ERR("RGetServiceDisplayNameW() failed (Error %lu)\n", dwError);
return FALSE;
}
- (*lpcchBuffer)--;
-
return TRUE;
}
TRACE("GetServiceKeyNameA() called\n");
- HandleBind();
+ if (!lpServiceName)
+ *lpcchBuffer = 0;
+
+ _SEH_TRY
+ {
+ dwError = RGetServiceKeyNameA((SC_RPC_HANDLE)hSCManager,
+ (LPSTR)lpDisplayName,
+ lpServiceName,
+ lpcchBuffer);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- dwError = RGetServiceKeyNameA(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- (LPSTR)lpDisplayName,
- lpServiceName,
- lpcchBuffer);
if (dwError != ERROR_SUCCESS)
{
ERR("RGetServiceKeyNameA() failed (Error %lu)\n", dwError);
return FALSE;
}
- (*lpcchBuffer)--;
-
return TRUE;
}
TRACE("GetServiceKeyNameW() called\n");
- HandleBind();
+ if (!lpDisplayName)
+ *lpcchBuffer = 0;
+
+ _SEH_TRY
+ {
+ dwError = RGetServiceKeyNameW((SC_RPC_HANDLE)hSCManager,
+ (LPWSTR)lpDisplayName,
+ lpServiceName,
+ lpcchBuffer);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- dwError = RGetServiceKeyNameW(BindingHandle,
- (SC_RPC_HANDLE)hSCManager,
- (LPWSTR)lpDisplayName,
- lpServiceName,
- lpcchBuffer);
if (dwError != ERROR_SUCCESS)
{
ERR("RGetServiceKeyNameW() failed (Error %lu)\n", dwError);
return FALSE;
}
- (*lpcchBuffer)--;
-
return TRUE;
}
TRACE("LockServiceDatabase(%x)\n", hSCManager);
- HandleBind();
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = RLockServiceDatabase((SC_RPC_HANDLE)hSCManager,
+ (SC_RPC_LOCK *)&hLock);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* 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);
WaitForSCManager();
- HandleBind();
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = ROpenSCManagerA((LPSTR)lpMachineName,
+ (LPSTR)lpDatabaseName,
+ dwDesiredAccess,
+ (SC_RPC_HANDLE *)&hScm);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* 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);
WaitForSCManager();
- HandleBind();
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = ROpenSCManagerW((LPWSTR)lpMachineName,
+ (LPWSTR)lpDatabaseName,
+ dwDesiredAccess,
+ (SC_RPC_HANDLE *)&hScm);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* 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("OpenServiceA(%p, %s, %lx)\n",
hSCManager, lpServiceName, dwDesiredAccess);
- HandleBind();
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = ROpenServiceA((SC_RPC_HANDLE)hSCManager,
+ (LPSTR)lpServiceName,
+ dwDesiredAccess,
+ (SC_RPC_HANDLE *)&hService);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* 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("OpenServiceW(%p, %S, %lx)\n",
hSCManager, lpServiceName, dwDesiredAccess);
- HandleBind();
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = ROpenServiceW((SC_RPC_HANDLE)hSCManager,
+ (LPWSTR)lpServiceName,
+ dwDesiredAccess,
+ (SC_RPC_HANDLE *)&hService);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* 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)
TRACE("QueryServiceConfigA(%p, %p, %lu, %p)\n",
hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
- HandleBind();
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceConfigA((SC_RPC_HANDLE)hService,
+ (LPBYTE)lpServiceConfig,
+ cbBufSize,
+ pcbBytesNeeded);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* 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("QueryServiceConfigW(%p, %p, %lu, %p)\n",
hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
- HandleBind();
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceConfigW((SC_RPC_HANDLE)hService,
+ (LPBYTE)lpServiceConfig,
+ cbBufSize,
+ pcbBytesNeeded);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* 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)
TRACE("QueryServiceConfig2A(%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;
+ }
+
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceConfig2A((SC_RPC_HANDLE)hService,
+ dwInfoLevel,
+ lpBuffer,
+ cbBufSize,
+ pcbBytesNeeded);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* 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("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;
+ }
+
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceConfig2W((SC_RPC_HANDLE)hService,
+ dwInfoLevel,
+ lpBuffer,
+ cbBufSize,
+ pcbBytesNeeded);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* 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("QueryServiceLockStatusA() called\n");
- HandleBind();
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceLockStatusA((SC_RPC_HANDLE)hSCManager,
+ lpLockStatus,
+ cbBufSize,
+ pcbBytesNeeded);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* 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("QueryServiceLockStatusW() called\n");
- HandleBind();
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceLockStatusW((SC_RPC_HANDLE)hSCManager,
+ lpLockStatus,
+ cbBufSize,
+ pcbBytesNeeded);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* 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("QueryServiceObjectSecurity(%p, %lu, %p)\n",
hService, dwSecurityInformation, lpSecurityDescriptor);
- HandleBind();
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceObjectSecurity((SC_RPC_HANDLE)hService,
+ dwSecurityInformation,
+ (LPBYTE)lpSecurityDescriptor,
+ cbBufSize,
+ pcbBytesNeeded);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* 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);
return FALSE;
}
- HandleBind();
-
- /* Call to services.exe using RPC */
- dwError = RSetServiceObjectSecurity(BindingHandle,
- (SC_RPC_HANDLE)hService,
- dwSecurityInformation,
- (LPBYTE)SelfRelativeSD,
- Length);
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = RSetServiceObjectSecurity((SC_RPC_HANDLE)hService,
+ dwSecurityInformation,
+ (LPBYTE)SelfRelativeSD,
+ Length);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
HeapFree(GetProcessHeap(), 0, SelfRelativeSD);
TRACE("QueryServiceStatus(%p, %p)\n",
hService, lpServiceStatus);
- HandleBind();
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceStatus((SC_RPC_HANDLE)hService,
+ lpServiceStatus);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* 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("QueryServiceStatusEx() called\n");
- HandleBind();
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = RQueryServiceStatusEx((SC_RPC_HANDLE)hService,
+ InfoLevel,
+ lpBuffer,
+ cbBufSize,
+ pcbBytesNeeded);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* 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);
{
DWORD dwError;
- dwError = RStartServiceA(BindingHandle,
- (SC_RPC_HANDLE)hService,
- dwNumServiceArgs,
- (LPSTRING_PTRSA)lpServiceArgVectors);
-
+ _SEH_TRY
+ {
+ dwError = RStartServiceA((SC_RPC_HANDLE)hService,
+ dwNumServiceArgs,
+ (LPSTRING_PTRSA)lpServiceArgVectors);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
if (dwError != ERROR_SUCCESS)
{
{
DWORD dwError;
- dwError = RStartServiceW(BindingHandle,
- (SC_RPC_HANDLE)hService,
- dwNumServiceArgs,
- (LPSTRING_PTRSW)lpServiceArgVectors);
+ _SEH_TRY
+ {
+ dwError = RStartServiceW((SC_RPC_HANDLE)hService,
+ dwNumServiceArgs,
+ (LPSTRING_PTRSW)lpServiceArgVectors);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
if (dwError != ERROR_SUCCESS)
{
TRACE("UnlockServiceDatabase(%x)\n", ScLock);
- HandleBind();
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = RUnlockServiceDatabase((LPSC_RPC_LOCK)&ScLock);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* 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("NotifyBootConfigStatus()\n");
- HandleBind();
+ _SEH_TRY
+ {
+ /* Call to services.exe using RPC */
+ dwError = RNotifyBootConfigStatus(NULL,
+ BootAcceptable);
+ }
+ _SEH_HANDLE
+ {
+ dwError = ScmRpcStatusToWinError(RpcExceptionCode());
+ }
+ _SEH_END;
- /* Call to services.exe using RPC */
- dwError = RNotifyBootConfigStatus(BindingHandle,
- NULL,
- BootAcceptable);
if (dwError != ERROR_SUCCESS)
{
ERR("NotifyBootConfigStatus() failed (Error %lu)\n", dwError);
projects / reactos.git / blobdiff