- Implement RCreateServiceA.

[reactos.git] / reactos / dll / win32 / advapi32 / service / scm.c

diff --git a/reactos/dll/win32/advapi32/service/scm.c b/reactos/dll/win32/advapi32/service/scm.c
index beb5be0..9aa422c 100644 (file)
--- a/reactos/dll/win32/advapi32/service/scm.c
+++ b/reactos/dll/win32/advapi32/service/scm.c
@@ -30,13 +30,13 @@ SVCCTL_HANDLEA_bind(SVCCTL_HANDLEA szMachineName)
 
     TRACE("SVCCTL_HANDLEA_bind() called\n");
 
-    status = RpcStringBindingComposeA((UCHAR *)szMachineName,
+    status = RpcStringBindingComposeA(NULL,
                                       (UCHAR *)"ncacn_np",
-                                      NULL,
+                                      (UCHAR *)szMachineName,
                                       (UCHAR *)"\\pipe\\ntsvcs",
                                       NULL,
                                       (UCHAR **)&pszStringBinding);
-    if (status)
+    if (status != RPC_S_OK)
     {
         ERR("RpcStringBindingCompose returned 0x%x\n", status);
         return NULL;
@@ -45,13 +45,13 @@ SVCCTL_HANDLEA_bind(SVCCTL_HANDLEA szMachineName)
     /* Set the binding handle that will be used to bind to the server. */
     status = RpcBindingFromStringBindingA(pszStringBinding,
                                           &hBinding);
-    if (status)
+    if (status != RPC_S_OK)
     {
         ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
     }
 
     status = RpcStringFreeA(&pszStringBinding);
-    if (status)
+    if (status != RPC_S_OK)
     {
         ERR("RpcStringFree returned 0x%x\n", status);
     }
@@ -69,7 +69,7 @@ SVCCTL_HANDLEA_unbind(SVCCTL_HANDLEA szMachineName,
     TRACE("SVCCTL_HANDLEA_unbind() called\n");
 
     status = RpcBindingFree(&hBinding);
-    if (status)
+    if (status != RPC_S_OK)
     {
         ERR("RpcBindingFree returned 0x%x\n", status);
     }
@@ -85,13 +85,13 @@ SVCCTL_HANDLEW_bind(SVCCTL_HANDLEW szMachineName)
 
     TRACE("SVCCTL_HANDLEW_bind() called\n");
 
-    status = RpcStringBindingComposeW(szMachineName,
+    status = RpcStringBindingComposeW(NULL,
                                       L"ncacn_np",
-                                      NULL,
+                                      szMachineName,
                                       L"\\pipe\\ntsvcs",
                                       NULL,
                                       &pszStringBinding);
-    if (status)
+    if (status != RPC_S_OK)
     {
         ERR("RpcStringBindingCompose returned 0x%x\n", status);
         return NULL;
@@ -100,13 +100,13 @@ SVCCTL_HANDLEW_bind(SVCCTL_HANDLEW szMachineName)
     /* Set the binding handle that will be used to bind to the server. */
     status = RpcBindingFromStringBindingW(pszStringBinding,
                                           &hBinding);
-    if (status)
+    if (status != RPC_S_OK)
     {
         ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
     }
 
     status = RpcStringFreeW(&pszStringBinding);
-    if (status)
+    if (status != RPC_S_OK)
     {
         ERR("RpcStringFree returned 0x%x\n", status);
     }
@@ -124,7 +124,7 @@ SVCCTL_HANDLEW_unbind(SVCCTL_HANDLEW szMachineName,
     TRACE("SVCCTL_HANDLEW_unbind() called\n");
 
     status = RpcBindingFree(&hBinding);
-    if (status)
+    if (status != RPC_S_OK)
     {
         ERR("RpcBindingFree returned 0x%x\n", status);
     }
@@ -146,7 +146,7 @@ RPC_SERVICE_STATUS_HANDLE_bind(RPC_SERVICE_STATUS_HANDLE hServiceStatus)
                                       L"\\pipe\\ntsvcs",
                                       NULL,
                                       &pszStringBinding);
-    if (status)
+    if (status != RPC_S_OK)
     {
         ERR("RpcStringBindingCompose returned 0x%x\n", status);
         return NULL;
@@ -155,13 +155,13 @@ RPC_SERVICE_STATUS_HANDLE_bind(RPC_SERVICE_STATUS_HANDLE hServiceStatus)
     /* Set the binding handle that will be used to bind to the server. */
     status = RpcBindingFromStringBindingW(pszStringBinding,
                                           &hBinding);
-    if (status)
+    if (status != RPC_S_OK)
     {
         ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
     }
 
     status = RpcStringFreeW(&pszStringBinding);
-    if (status)
+    if (status != RPC_S_OK)
     {
         ERR("RpcStringFree returned 0x%x\n", status);
     }
@@ -179,7 +179,7 @@ RPC_SERVICE_STATUS_HANDLE_unbind(RPC_SERVICE_STATUS_HANDLE hServiceStatus,
     TRACE("RPC_SERVICE_STATUS_HANDLE_unbind() called\n");
 
     status = RpcBindingFree(&hBinding);
-    if (status)
+    if (status != RPC_S_OK)
     {
         ERR("RpcBindingFree returned 0x%x\n", status);
     }
@@ -191,13 +191,15 @@ 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_NULL_REF_POINTER:
+        case RPC_X_ENUM_VALUE_OUT_OF_RANGE:
+        case RPC_X_BYTE_COUNT_TOO_SMALL:
             return ERROR_INVALID_PARAMETER;
 
-        case STATUS_ACCESS_VIOLATION:
+        case RPC_X_NULL_REF_POINTER:
             return ERROR_INVALID_ADDRESS;
 
         default:
@@ -227,10 +229,11 @@ ChangeServiceConfig2A(SC_HANDLE hService,
     {
         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:
@@ -242,16 +245,16 @@ ChangeServiceConfig2A(SC_HANDLE hService,
     if (lpInfo == NULL)
         return TRUE;
 
-    _SEH_TRY
+    RpcTryExcept
     {
         dwError = RChangeServiceConfig2A((SC_RPC_HANDLE)hService,
                                          Info);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -284,10 +287,8 @@ ChangeServiceConfig2W(SC_HANDLE hService,
     switch (dwInfoLevel)
     {
         case SERVICE_CONFIG_DESCRIPTION:
-        {
             Info.psd = (LPSERVICE_DESCRIPTIONW)&lpInfo;
             break;
-        }
 
         case SERVICE_CONFIG_FAILURE_ACTIONS:
             Info.psfa = (LPSERVICE_FAILURE_ACTIONSW)&lpInfo;
@@ -302,16 +303,16 @@ ChangeServiceConfig2W(SC_HANDLE hService,
     if (lpInfo == NULL)
         return TRUE;
 
-    _SEH_TRY
+    RpcTryExcept
     {
         dwError = RChangeServiceConfig2W((SC_RPC_HANDLE)hService,
                                          Info);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -329,7 +330,7 @@ ChangeServiceConfig2W(SC_HANDLE hService,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 ChangeServiceConfigA(SC_HANDLE hService,
                      DWORD dwServiceType,
                      DWORD dwStartType,
@@ -364,7 +365,7 @@ ChangeServiceConfigA(SC_HANDLE hService,
 
     /* FIXME: Encrypt the password */
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RChangeServiceConfigA((SC_RPC_HANDLE)hService,
@@ -381,11 +382,11 @@ ChangeServiceConfigA(SC_HANDLE hService,
                                         0,                 /* FIXME: dwPasswordLength */
                                         (LPSTR)lpDisplayName);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -403,7 +404,7 @@ ChangeServiceConfigA(SC_HANDLE hService,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 ChangeServiceConfigW(SC_HANDLE hService,
                      DWORD dwServiceType,
                      DWORD dwStartType,
@@ -438,7 +439,7 @@ ChangeServiceConfigW(SC_HANDLE hService,
 
     /* FIXME: Encrypt the password */
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RChangeServiceConfigW((SC_RPC_HANDLE)hService,
@@ -455,11 +456,11 @@ ChangeServiceConfigW(SC_HANDLE hService,
                                         0,                 /* FIXME: dwPasswordLength */
                                         (LPWSTR)lpDisplayName);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -477,23 +478,29 @@ ChangeServiceConfigW(SC_HANDLE hService,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 CloseServiceHandle(SC_HANDLE hSCObject)
 {
     DWORD dwError;
 
     TRACE("CloseServiceHandle() called\n");
 
-    _SEH_TRY
+    if (!hSCObject)
+    {
+        SetLastError(ERROR_INVALID_HANDLE);
+        return FALSE;
+    }
+
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RCloseServiceHandle((LPSC_RPC_HANDLE)&hSCObject);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError)
     {
@@ -513,7 +520,7 @@ CloseServiceHandle(SC_HANDLE hSCObject)
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 ControlService(SC_HANDLE hService,
                DWORD dwControl,
                LPSERVICE_STATUS lpServiceStatus)
@@ -523,18 +530,18 @@ ControlService(SC_HANDLE hService,
     TRACE("ControlService(%x, %x, %p)\n",
            hService, dwControl, lpServiceStatus);
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RControlService((SC_RPC_HANDLE)hService,
                                   dwControl,
                                   lpServiceStatus);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -554,7 +561,7 @@ ControlService(SC_HANDLE hService,
  *
  * @unimplemented
  */
-BOOL STDCALL
+BOOL WINAPI
 ControlServiceEx(IN SC_HANDLE hService,
                  IN DWORD dwControl,
                  IN DWORD dwInfoLevel,
@@ -572,7 +579,7 @@ ControlServiceEx(IN SC_HANDLE hService,
  *
  * @implemented
  */
-SC_HANDLE STDCALL
+SC_HANDLE WINAPI
 CreateServiceA(SC_HANDLE hSCManager,
                LPCSTR lpServiceName,
                LPCSTR lpDisplayName,
@@ -587,68 +594,24 @@ CreateServiceA(SC_HANDLE hSCManager,
                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);
-    }
-
-    if (lpDisplayName)
-    {
-        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);
-    }
+    TRACE("CreateServiceA() called\n");
+    TRACE("%p %s %s\n", hSCManager, 
+          lpServiceName, lpDisplayName);
 
-    if (lpLoadOrderGroup)
+    if (!hSCManager)
     {
-        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)
@@ -658,77 +621,44 @@ CreateServiceA(SC_HANDLE hSCManager,
             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, dwDependenciesLength, lpDependenciesW, dwDependenciesLength);
     }
 
-    if (lpServiceStartName)
+    /* FIXME: Encrypt the password */
+
+    RpcTryExcept
     {
-        len = MultiByteToWideChar(CP_ACP, 0, lpServiceStartName, -1, NULL, 0);
-        lpServiceStartNameW = 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);
     }
-
-    if (lpPassword)
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
-        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);
+        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
+    RpcEndExcept;
 
-    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);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RCreateServiceA() failed (Error %lu)\n", dwError);
+        SetLastError(dwError);
+        return NULL;
+    }
 
-    return RetVal;
+    return hService;
 }
 
 
@@ -737,7 +667,7 @@ cleanup:
  *
  * @implemented
  */
-SC_HANDLE STDCALL
+SC_HANDLE WINAPI
 CreateServiceW(SC_HANDLE hSCManager,
                LPCWSTR lpServiceName,
                LPCWSTR lpDisplayName,
@@ -759,6 +689,14 @@ CreateServiceW(SC_HANDLE hSCManager,
     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)
@@ -777,31 +715,31 @@ CreateServiceW(SC_HANDLE hSCManager,
 
     /* FIXME: Encrypt the password */
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RCreateServiceW((SC_RPC_HANDLE)hSCManager,
-                                  (LPWSTR)lpServiceName,
-                                  (LPWSTR)lpDisplayName,
+                                  lpServiceName,
+                                  lpDisplayName,
                                   dwDesiredAccess,
                                   dwServiceType,
                                   dwStartType,
                                   dwErrorControl,
-                                  (LPWSTR)lpBinaryPathName,
-                                  (LPWSTR)lpLoadOrderGroup,
+                                  lpBinaryPathName,
+                                  lpLoadOrderGroup,
                                   lpdwTagId,
                                   (LPBYTE)lpDependencies,
                                   dwDependenciesLength,
-                                  (LPWSTR)lpServiceStartName,
+                                  lpServiceStartName,
                                   NULL,              /* FIXME: lpPassword */
                                   0,                 /* FIXME: dwPasswordLength */
                                   (SC_RPC_HANDLE *)&hService);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -819,23 +757,23 @@ CreateServiceW(SC_HANDLE hSCManager,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 DeleteService(SC_HANDLE hService)
 {
     DWORD dwError;
 
     TRACE("DeleteService(%x)\n", hService);
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RDeleteService((SC_RPC_HANDLE)hService);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -853,7 +791,7 @@ DeleteService(SC_HANDLE hService)
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 EnumDependentServicesA(SC_HANDLE hService,
                        DWORD dwServiceState,
                        LPENUM_SERVICE_STATUSA lpServices,
@@ -867,7 +805,7 @@ EnumDependentServicesA(SC_HANDLE hService,
 
     TRACE("EnumServicesStatusA() called\n");
 
-    _SEH_TRY
+    RpcTryExcept
     {
         dwError = REnumDependentServicesA((SC_RPC_HANDLE)hService,
                                           dwServiceState,
@@ -876,11 +814,11 @@ EnumDependentServicesA(SC_HANDLE hService,
                                           pcbBytesNeeded,
                                           lpServicesReturned);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -914,7 +852,7 @@ EnumDependentServicesA(SC_HANDLE hService,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 EnumDependentServicesW(SC_HANDLE hService,
                        DWORD dwServiceState,
                        LPENUM_SERVICE_STATUSW lpServices,
@@ -928,7 +866,7 @@ EnumDependentServicesW(SC_HANDLE hService,
 
     TRACE("EnumServicesStatusW() called\n");
 
-    _SEH_TRY
+    RpcTryExcept
     {
         dwError = REnumDependentServicesW((SC_RPC_HANDLE)hService,
                                           dwServiceState,
@@ -937,11 +875,11 @@ EnumDependentServicesW(SC_HANDLE hService,
                                           pcbBytesNeeded,
                                           lpServicesReturned);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -976,7 +914,7 @@ EnumDependentServicesW(SC_HANDLE hService,
  * @unimplemented
  */
 BOOL
-STDCALL
+WINAPI
 EnumServiceGroupW(
     SC_HANDLE               hSCManager,
     DWORD                   dwServiceType,
@@ -999,7 +937,7 @@ EnumServiceGroupW(
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 EnumServicesStatusA(SC_HANDLE hSCManager,
                     DWORD dwServiceType,
                     DWORD dwServiceState,
@@ -1015,7 +953,49 @@ EnumServicesStatusA(SC_HANDLE hSCManager,
 
     TRACE("EnumServicesStatusA() called\n");
 
-    _SEH_TRY
+    if (!hSCManager)
+    {
+        SetLastError(ERROR_INVALID_HANDLE);
+        return FALSE;
+    }
+
+    if (dwServiceType != SERVICE_DRIVER && dwServiceType != SERVICE_WIN32)
+    {
+        if (pcbBytesNeeded && lpServicesReturned)
+        {
+            *pcbBytesNeeded = 0;
+            *lpServicesReturned = 0;
+        }
+
+        SetLastError(ERROR_INVALID_PARAMETER);
+        return FALSE;
+    }
+
+    if (dwServiceState != SERVICE_ACTIVE && dwServiceState != SERVICE_INACTIVE && dwServiceState != SERVICE_STATE_ALL)
+    {
+            if (pcbBytesNeeded)
+                *pcbBytesNeeded = 0;
+
+            if (lpServicesReturned)
+                *lpServicesReturned = 0;
+
+        SetLastError(ERROR_INVALID_PARAMETER);
+        return FALSE;
+    }
+
+    if (!pcbBytesNeeded || !lpServicesReturned)
+    {
+        SetLastError(ERROR_INVALID_ADDRESS);
+        return FALSE;
+    }
+
+    if (!lpServices && cbBufSize != 0)
+    {
+        SetLastError(ERROR_INVALID_ADDRESS);
+        return FALSE;
+    }
+
+    RpcTryExcept
     {
         dwError = REnumServicesStatusA((SC_RPC_HANDLE)hSCManager,
                                        dwServiceType,
@@ -1026,11 +1006,11 @@ EnumServicesStatusA(SC_HANDLE hSCManager,
                                        lpServicesReturned,
                                        lpResumeHandle);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -1064,7 +1044,7 @@ EnumServicesStatusA(SC_HANDLE hSCManager,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 EnumServicesStatusW(SC_HANDLE hSCManager,
                     DWORD dwServiceType,
                     DWORD dwServiceState,
@@ -1080,7 +1060,13 @@ EnumServicesStatusW(SC_HANDLE hSCManager,
 
     TRACE("EnumServicesStatusW() called\n");
 
-    _SEH_TRY
+    if (!hSCManager)
+    {
+        SetLastError(ERROR_INVALID_HANDLE);
+        return FALSE;
+    }
+
+    RpcTryExcept
     {
         dwError = REnumServicesStatusW((SC_RPC_HANDLE)hSCManager,
                                        dwServiceType,
@@ -1091,11 +1077,11 @@ EnumServicesStatusW(SC_HANDLE hSCManager,
                                        lpServicesReturned,
                                        lpResumeHandle);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -1129,7 +1115,7 @@ EnumServicesStatusW(SC_HANDLE hSCManager,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 EnumServicesStatusExA(SC_HANDLE hSCManager,
                       SC_ENUM_TYPE InfoLevel,
                       DWORD dwServiceType,
@@ -1147,7 +1133,20 @@ EnumServicesStatusExA(SC_HANDLE hSCManager,
 
     TRACE("EnumServicesStatusExA() called\n");
 
-    _SEH_TRY
+    if (InfoLevel != SC_ENUM_PROCESS_INFO)
+    {
+        SetLastError(ERROR_INVALID_LEVEL);
+        return FALSE;
+    }
+
+    if (!hSCManager)
+    {
+        SetLastError(ERROR_INVALID_HANDLE);
+        return FALSE;
+    }
+
+
+    RpcTryExcept
     {
         dwError = REnumServicesStatusExA((SC_RPC_HANDLE)hSCManager,
                                          InfoLevel,
@@ -1160,11 +1159,11 @@ EnumServicesStatusExA(SC_HANDLE hSCManager,
                                          lpResumeHandle,
                                          (LPSTR)pszGroupName);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError == ERROR_MORE_DATA)
     {
@@ -1206,7 +1205,7 @@ EnumServicesStatusExA(SC_HANDLE hSCManager,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 EnumServicesStatusExW(SC_HANDLE hSCManager,
                       SC_ENUM_TYPE InfoLevel,
                       DWORD dwServiceType,
@@ -1224,7 +1223,7 @@ EnumServicesStatusExW(SC_HANDLE hSCManager,
 
     TRACE("EnumServicesStatusExW() called\n");
 
-    _SEH_TRY
+    RpcTryExcept
     {
         dwError = REnumServicesStatusExW((SC_RPC_HANDLE)hSCManager,
                                          InfoLevel,
@@ -1237,11 +1236,11 @@ EnumServicesStatusExW(SC_HANDLE hSCManager,
                                          lpResumeHandle,
                                          (LPWSTR)pszGroupName);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError == ERROR_MORE_DATA)
     {
@@ -1283,7 +1282,7 @@ EnumServicesStatusExW(SC_HANDLE hSCManager,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 GetServiceDisplayNameA(SC_HANDLE hSCManager,
                        LPCSTR lpServiceName,
                        LPSTR lpDisplayName,
@@ -1292,25 +1291,33 @@ GetServiceDisplayNameA(SC_HANDLE hSCManager,
     DWORD dwError;
 
     TRACE("GetServiceDisplayNameA() called\n");
+    TRACE("%p %s %p %p\n", hSCManager,
+          debugstr_a(lpServiceName), lpDisplayName, lpcchBuffer);
+
+    if (!hSCManager)
+    {
+        SetLastError(ERROR_INVALID_HANDLE);
+        return FALSE;
+    }
 
     if (!lpDisplayName)
         *lpcchBuffer = 0;
 
-    _SEH_TRY
+    RpcTryExcept
     {
         dwError = RGetServiceDisplayNameA((SC_RPC_HANDLE)hSCManager,
-                                          (LPSTR)lpServiceName,
+                                          lpServiceName,
                                           lpDisplayName,
                                           lpcchBuffer);
     }
-    _SEH_HANDLE
+    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());
     }
 
 
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -1328,7 +1335,7 @@ GetServiceDisplayNameA(SC_HANDLE hSCManager,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 GetServiceDisplayNameW(SC_HANDLE hSCManager,
                        LPCWSTR lpServiceName,
                        LPWSTR lpDisplayName,
@@ -1338,21 +1345,27 @@ GetServiceDisplayNameW(SC_HANDLE hSCManager,
 
     TRACE("GetServiceDisplayNameW() called\n");
 
+    if (!hSCManager)
+    {
+        SetLastError(ERROR_INVALID_HANDLE);
+        return FALSE;
+    }
+
     if (!lpDisplayName)
         *lpcchBuffer = 0;
 
-    _SEH_TRY
+    RpcTryExcept
     {
         dwError = RGetServiceDisplayNameW((SC_RPC_HANDLE)hSCManager,
-                                          (LPWSTR)lpServiceName,
+                                          lpServiceName,
                                           lpDisplayName,
                                           lpcchBuffer);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -1370,7 +1383,7 @@ GetServiceDisplayNameW(SC_HANDLE hSCManager,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 GetServiceKeyNameA(SC_HANDLE hSCManager,
                    LPCSTR lpDisplayName,
                    LPSTR lpServiceName,
@@ -1380,21 +1393,36 @@ GetServiceKeyNameA(SC_HANDLE hSCManager,
 
     TRACE("GetServiceKeyNameA() called\n");
 
+    if (!hSCManager)
+    {
+        SetLastError(ERROR_INVALID_HANDLE);
+        return FALSE;
+    }
+
+    if (!lpDisplayName)
+    {
+        SetLastError(ERROR_INVALID_ADDRESS);
+
+        if (!lpServiceName)
+            *lpcchBuffer = 1;
+        return FALSE;
+    }
+
     if (!lpServiceName)
         *lpcchBuffer = 0;
 
-    _SEH_TRY
+    RpcTryExcept
     {
         dwError = RGetServiceKeyNameA((SC_RPC_HANDLE)hSCManager,
-                                      (LPSTR)lpDisplayName,
+                                      lpDisplayName,
                                       lpServiceName,
                                       lpcchBuffer);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -1412,7 +1440,7 @@ GetServiceKeyNameA(SC_HANDLE hSCManager,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 GetServiceKeyNameW(SC_HANDLE hSCManager,
                    LPCWSTR lpDisplayName,
                    LPWSTR lpServiceName,
@@ -1422,21 +1450,36 @@ GetServiceKeyNameW(SC_HANDLE hSCManager,
 
     TRACE("GetServiceKeyNameW() called\n");
 
+    if (!hSCManager)
+    {
+        SetLastError(ERROR_INVALID_HANDLE);
+        return FALSE;
+    }
+
     if (!lpDisplayName)
+    {
+        SetLastError(ERROR_INVALID_ADDRESS);
+
+        if (!lpServiceName)
+            *lpcchBuffer = 1;
+        return FALSE;
+    }
+
+    if (!lpServiceName)
         *lpcchBuffer = 0;
 
-    _SEH_TRY
+    RpcTryExcept
     {
         dwError = RGetServiceKeyNameW((SC_RPC_HANDLE)hSCManager,
-                                      (LPWSTR)lpDisplayName,
+                                      lpDisplayName,
                                       lpServiceName,
                                       lpcchBuffer);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -1454,7 +1497,7 @@ GetServiceKeyNameW(SC_HANDLE hSCManager,
  *
  * @implemented
  */
-SC_LOCK STDCALL
+SC_LOCK WINAPI
 LockServiceDatabase(SC_HANDLE hSCManager)
 {
     SC_LOCK hLock;
@@ -1462,17 +1505,17 @@ LockServiceDatabase(SC_HANDLE hSCManager)
 
     TRACE("LockServiceDatabase(%x)\n", hSCManager);
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RLockServiceDatabase((SC_RPC_HANDLE)hSCManager,
                                        (SC_RPC_LOCK *)&hLock);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -1532,7 +1575,7 @@ WaitForSCManager(VOID)
  *
  * @implemented
  */
-SC_HANDLE STDCALL
+SC_HANDLE WINAPI
 OpenSCManagerA(LPCSTR lpMachineName,
                LPCSTR lpDatabaseName,
                DWORD dwDesiredAccess)
@@ -1545,7 +1588,7 @@ OpenSCManagerA(LPCSTR lpMachineName,
 
     WaitForSCManager();
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = ROpenSCManagerA((LPSTR)lpMachineName,
@@ -1553,11 +1596,11 @@ OpenSCManagerA(LPCSTR lpMachineName,
                                   dwDesiredAccess,
                                   (SC_RPC_HANDLE *)&hScm);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -1577,7 +1620,7 @@ OpenSCManagerA(LPCSTR lpMachineName,
  *
  * @implemented
  */
-SC_HANDLE STDCALL
+SC_HANDLE WINAPI
 OpenSCManagerW(LPCWSTR lpMachineName,
                LPCWSTR lpDatabaseName,
                DWORD dwDesiredAccess)
@@ -1590,7 +1633,7 @@ OpenSCManagerW(LPCWSTR lpMachineName,
 
     WaitForSCManager();
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = ROpenSCManagerW((LPWSTR)lpMachineName,
@@ -1598,11 +1641,11 @@ OpenSCManagerW(LPCWSTR lpMachineName,
                                   dwDesiredAccess,
                                   (SC_RPC_HANDLE *)&hScm);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -1622,7 +1665,7 @@ OpenSCManagerW(LPCWSTR lpMachineName,
  *
  * @implemented
  */
-SC_HANDLE STDCALL
+SC_HANDLE WINAPI
 OpenServiceA(SC_HANDLE hSCManager,
              LPCSTR lpServiceName,
              DWORD dwDesiredAccess)
@@ -1633,7 +1676,13 @@ OpenServiceA(SC_HANDLE hSCManager,
     TRACE("OpenServiceA(%p, %s, %lx)\n",
            hSCManager, lpServiceName, dwDesiredAccess);
 
-    _SEH_TRY
+    if (!hSCManager)
+    {
+        SetLastError(ERROR_INVALID_HANDLE);
+        return NULL;
+    }
+
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = ROpenServiceA((SC_RPC_HANDLE)hSCManager,
@@ -1641,11 +1690,11 @@ OpenServiceA(SC_HANDLE hSCManager,
                                 dwDesiredAccess,
                                 (SC_RPC_HANDLE *)&hService);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -1665,7 +1714,7 @@ OpenServiceA(SC_HANDLE hSCManager,
  *
  * @implemented
  */
-SC_HANDLE STDCALL
+SC_HANDLE WINAPI
 OpenServiceW(SC_HANDLE hSCManager,
              LPCWSTR lpServiceName,
              DWORD dwDesiredAccess)
@@ -1676,7 +1725,13 @@ OpenServiceW(SC_HANDLE hSCManager,
     TRACE("OpenServiceW(%p, %S, %lx)\n",
            hSCManager, lpServiceName, dwDesiredAccess);
 
-    _SEH_TRY
+    if (!hSCManager)
+    {
+        SetLastError(ERROR_INVALID_HANDLE);
+        return NULL;
+    }
+
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = ROpenServiceW((SC_RPC_HANDLE)hSCManager,
@@ -1684,11 +1739,11 @@ OpenServiceW(SC_HANDLE hSCManager,
                                 dwDesiredAccess,
                                 (SC_RPC_HANDLE *)&hService);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -1711,7 +1766,7 @@ OpenServiceW(SC_HANDLE hSCManager,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 QueryServiceConfigA(SC_HANDLE hService,
                     LPQUERY_SERVICE_CONFIGA lpServiceConfig,
                     DWORD cbBufSize,
@@ -1722,7 +1777,7 @@ QueryServiceConfigA(SC_HANDLE hService,
     TRACE("QueryServiceConfigA(%p, %p, %lu, %p)\n",
            hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RQueryServiceConfigA((SC_RPC_HANDLE)hService,
@@ -1730,11 +1785,11 @@ QueryServiceConfigA(SC_HANDLE hService,
                                        cbBufSize,
                                        pcbBytesNeeded);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -1780,7 +1835,7 @@ QueryServiceConfigA(SC_HANDLE hService,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 QueryServiceConfigW(SC_HANDLE hService,
                     LPQUERY_SERVICE_CONFIGW lpServiceConfig,
                     DWORD cbBufSize,
@@ -1791,7 +1846,7 @@ QueryServiceConfigW(SC_HANDLE hService,
     TRACE("QueryServiceConfigW(%p, %p, %lu, %p)\n",
            hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RQueryServiceConfigW((SC_RPC_HANDLE)hService,
@@ -1799,11 +1854,11 @@ QueryServiceConfigW(SC_HANDLE hService,
                                        cbBufSize,
                                        pcbBytesNeeded);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -1852,7 +1907,7 @@ QueryServiceConfigW(SC_HANDLE hService,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 QueryServiceConfig2A(SC_HANDLE hService,
                      DWORD dwInfoLevel,
                      LPBYTE lpBuffer,
@@ -1861,7 +1916,7 @@ QueryServiceConfig2A(SC_HANDLE hService,
 {
     DWORD dwError;
 
-    TRACE("QueryServiceConfig2A(%p, %lu, %p, %lu, %p)\n",
+    DbgPrint("QueryServiceConfig2A(hService %p, dwInfoLevel %lu, lpBuffer %p, cbBufSize %lu, pcbBytesNeeded %p)\n",
            hService, dwInfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
 
     if (dwInfoLevel != SERVICE_CONFIG_DESCRIPTION &&
@@ -1878,7 +1933,7 @@ QueryServiceConfig2A(SC_HANDLE hService,
         return FALSE;
     }
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RQueryServiceConfig2A((SC_RPC_HANDLE)hService,
@@ -1887,11 +1942,11 @@ QueryServiceConfig2A(SC_HANDLE hService,
                                         cbBufSize,
                                         pcbBytesNeeded);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -1947,7 +2002,7 @@ QueryServiceConfig2A(SC_HANDLE hService,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 QueryServiceConfig2W(SC_HANDLE hService,
                      DWORD dwInfoLevel,
                      LPBYTE lpBuffer,
@@ -1973,7 +2028,7 @@ QueryServiceConfig2W(SC_HANDLE hService,
         return FALSE;
     }
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RQueryServiceConfig2W((SC_RPC_HANDLE)hService,
@@ -1982,11 +2037,11 @@ QueryServiceConfig2W(SC_HANDLE hService,
                                         cbBufSize,
                                         pcbBytesNeeded);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -2042,7 +2097,7 @@ QueryServiceConfig2W(SC_HANDLE hService,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 QueryServiceLockStatusA(SC_HANDLE hSCManager,
                         LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus,
                         DWORD cbBufSize,
@@ -2052,7 +2107,7 @@ QueryServiceLockStatusA(SC_HANDLE hSCManager,
 
     TRACE("QueryServiceLockStatusA() called\n");
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RQueryServiceLockStatusA((SC_RPC_HANDLE)hSCManager,
@@ -2060,11 +2115,11 @@ QueryServiceLockStatusA(SC_HANDLE hSCManager,
                                            cbBufSize,
                                            pcbBytesNeeded);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -2090,7 +2145,7 @@ QueryServiceLockStatusA(SC_HANDLE hSCManager,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 QueryServiceLockStatusW(SC_HANDLE hSCManager,
                         LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus,
                         DWORD cbBufSize,
@@ -2100,7 +2155,7 @@ QueryServiceLockStatusW(SC_HANDLE hSCManager,
 
     TRACE("QueryServiceLockStatusW() called\n");
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RQueryServiceLockStatusW((SC_RPC_HANDLE)hSCManager,
@@ -2108,11 +2163,11 @@ QueryServiceLockStatusW(SC_HANDLE hSCManager,
                                            cbBufSize,
                                            pcbBytesNeeded);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -2138,7 +2193,7 @@ QueryServiceLockStatusW(SC_HANDLE hSCManager,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 QueryServiceObjectSecurity(SC_HANDLE hService,
                            SECURITY_INFORMATION dwSecurityInformation,
                            PSECURITY_DESCRIPTOR lpSecurityDescriptor,
@@ -2150,7 +2205,7 @@ QueryServiceObjectSecurity(SC_HANDLE hService,
     TRACE("QueryServiceObjectSecurity(%p, %lu, %p)\n",
            hService, dwSecurityInformation, lpSecurityDescriptor);
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RQueryServiceObjectSecurity((SC_RPC_HANDLE)hService,
@@ -2159,11 +2214,11 @@ QueryServiceObjectSecurity(SC_HANDLE hService,
                                               cbBufSize,
                                               pcbBytesNeeded);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -2180,7 +2235,7 @@ QueryServiceObjectSecurity(SC_HANDLE hService,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 SetServiceObjectSecurity(SC_HANDLE hService,
                          SECURITY_INFORMATION dwSecurityInformation,
                          PSECURITY_DESCRIPTOR lpSecurityDescriptor)
@@ -2217,7 +2272,7 @@ SetServiceObjectSecurity(SC_HANDLE hService,
         return FALSE;
     }
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RSetServiceObjectSecurity((SC_RPC_HANDLE)hService,
@@ -2225,11 +2280,11 @@ SetServiceObjectSecurity(SC_HANDLE hService,
                                             (LPBYTE)SelfRelativeSD,
                                             Length);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     HeapFree(GetProcessHeap(), 0, SelfRelativeSD);
 
@@ -2249,7 +2304,7 @@ SetServiceObjectSecurity(SC_HANDLE hService,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 QueryServiceStatus(SC_HANDLE hService,
                    LPSERVICE_STATUS lpServiceStatus)
 {
@@ -2258,17 +2313,23 @@ QueryServiceStatus(SC_HANDLE hService,
     TRACE("QueryServiceStatus(%p, %p)\n",
            hService, lpServiceStatus);
 
-    _SEH_TRY
+    if (!hService)
+    {
+        SetLastError(ERROR_INVALID_HANDLE);
+        return FALSE;
+    }
+
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RQueryServiceStatus((SC_RPC_HANDLE)hService,
                                       lpServiceStatus);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -2286,7 +2347,7 @@ QueryServiceStatus(SC_HANDLE hService,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 QueryServiceStatusEx(SC_HANDLE hService,
                      SC_STATUS_TYPE InfoLevel,
                      LPBYTE lpBuffer,
@@ -2297,7 +2358,13 @@ QueryServiceStatusEx(SC_HANDLE hService,
 
     TRACE("QueryServiceStatusEx() called\n");
 
-    _SEH_TRY
+    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,
@@ -2306,11 +2373,11 @@ QueryServiceStatusEx(SC_HANDLE hService,
                                         cbBufSize,
                                         pcbBytesNeeded);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -2328,24 +2395,24 @@ QueryServiceStatusEx(SC_HANDLE hService,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 StartServiceA(SC_HANDLE hService,
               DWORD dwNumServiceArgs,
               LPCSTR *lpServiceArgVectors)
 {
     DWORD dwError;
 
-    _SEH_TRY
+    RpcTryExcept
     {
         dwError = RStartServiceA((SC_RPC_HANDLE)hService,
                                  dwNumServiceArgs,
                                  (LPSTRING_PTRSA)lpServiceArgVectors);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -2363,24 +2430,24 @@ StartServiceA(SC_HANDLE hService,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 StartServiceW(SC_HANDLE hService,
               DWORD dwNumServiceArgs,
               LPCWSTR *lpServiceArgVectors)
 {
     DWORD dwError;
 
-    _SEH_TRY
+    RpcTryExcept
     {
         dwError = RStartServiceW((SC_RPC_HANDLE)hService,
                                  dwNumServiceArgs,
                                  (LPSTRING_PTRSW)lpServiceArgVectors);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -2398,23 +2465,23 @@ StartServiceW(SC_HANDLE hService,
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 UnlockServiceDatabase(SC_LOCK ScLock)
 {
     DWORD dwError;
 
     TRACE("UnlockServiceDatabase(%x)\n", ScLock);
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RUnlockServiceDatabase((LPSC_RPC_LOCK)&ScLock);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {
@@ -2432,24 +2499,24 @@ UnlockServiceDatabase(SC_LOCK ScLock)
  *
  * @implemented
  */
-BOOL STDCALL
+BOOL WINAPI
 NotifyBootConfigStatus(BOOL BootAcceptable)
 {
     DWORD dwError;
 
     TRACE("NotifyBootConfigStatus()\n");
 
-    _SEH_TRY
+    RpcTryExcept
     {
         /* Call to services.exe using RPC */
         dwError = RNotifyBootConfigStatus(NULL,
                                           BootAcceptable);
     }
-    _SEH_HANDLE
+    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
     {
         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
     }
-    _SEH_END;
+    RpcEndExcept;
 
     if (dwError != ERROR_SUCCESS)
     {