[ros-diffs] [hpoussin] 32908: Use R- prefix instead of Scmr- prefix for service RPC calls

Author: hpoussin
Date: Thu Apr 10 11:39:01 2008
New Revision: 32908

URL: http://svn.reactos.org/svn/reactos?rev=32908&view=rev
Log:
Use R- prefix instead of Scmr- prefix for service RPC calls

Modified:
    trunk/reactos/base/system/services/rpcserver.c
    trunk/reactos/dll/win32/advapi32/service/scm.c
    trunk/reactos/dll/win32/advapi32/service/sctrl.c
    trunk/reactos/include/reactos/idl/svcctl.idl

Modified: trunk/reactos/base/system/services/rpcserver.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/base/system/services/rpcse…
==============================================================================
--- trunk/reactos/base/system/services/rpcserver.c [iso-8859-1] (original)
+++ trunk/reactos/base/system/services/rpcserver.c [iso-8859-1] Thu Apr 10 11:39:01 2008
@@ -236,13 +236,13 @@
 
 
 /* Function 0 */
-DWORD ScmrCloseServiceHandle(
+DWORD RCloseServiceHandle(
     handle_t BindingHandle,
     LPSC_RPC_HANDLE hSCObject)
 {
     PMANAGER_HANDLE hManager;
 
-    DPRINT("ScmrCloseServiceHandle() called\n");
+    DPRINT("RCloseServiceHandle() called\n");
 
     DPRINT("hSCObject = %p\n", *hSCObject);
 
@@ -262,7 +262,7 @@
             HeapFree(GetProcessHeap(), 0, hManager);
         }
 
-        DPRINT("ScmrCloseServiceHandle() done\n");
+        DPRINT("RCloseServiceHandle() done\n");
         return ERROR_SUCCESS;
     }
     else if (hManager->Handle.Tag == SERVICE_TAG)
@@ -277,7 +277,7 @@
             HeapFree(GetProcessHeap(), 0, hManager);
         }
 
-        DPRINT("ScmrCloseServiceHandle() done\n");
+        DPRINT("RCloseServiceHandle() done\n");
         return ERROR_SUCCESS;
     }
 
@@ -288,7 +288,7 @@
 
 
 /* Function 1 */
-DWORD ScmrControlService(
+DWORD RControlService(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     DWORD dwControl,
@@ -299,7 +299,7 @@
     ACCESS_MASK DesiredAccess;
     DWORD dwError = ERROR_SUCCESS;
 
-    DPRINT("ScmrControlService() called\n");
+    DPRINT("RControlService() called\n");
 
     if (ScmShutdown)
         return ERROR_SHUTDOWN_IN_PROGRESS;
@@ -377,7 +377,7 @@
 
 
 /* Function 2 */
-DWORD ScmrDeleteService(
+DWORD RDeleteService(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService)
 {
@@ -385,7 +385,7 @@
     PSERVICE lpService;
     DWORD dwError;
 
-    DPRINT("ScmrDeleteService() called\n");
+    DPRINT("RDeleteService() called\n");
 
     if (ScmShutdown)
         return ERROR_SHUTDOWN_IN_PROGRESS;
@@ -420,21 +420,21 @@
 
     /* FIXME: Release service database lock */
 
-    DPRINT("ScmrDeleteService() done\n");
+    DPRINT("RDeleteService() done\n");
 
     return dwError;
 }
 
 
 /* Function 3 */
-DWORD ScmrLockServiceDatabase(
+DWORD RLockServiceDatabase(
     handle_t BindingHandle,
     SC_RPC_HANDLE hSCManager,
     LPSC_RPC_LOCK lpLock)
 {
     PMANAGER_HANDLE hMgr;
 
-    DPRINT("ScmrLockServiceDatabase() called\n");
+    DPRINT("RLockServiceDatabase() called\n");
 
     *lpLock = 0;
 
@@ -456,7 +456,7 @@
 
 
 /* Function 4 */
-DWORD ScmrQueryServiceObjectSecurity(
+DWORD RQueryServiceObjectSecurity(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     SECURITY_INFORMATION dwSecurityInformation,
@@ -472,7 +472,7 @@
     DWORD dwBytesNeeded;
     DWORD dwError;
 
-    DPRINT("ScmrQueryServiceObjectSecurity() called\n");
+    DPRINT("RQueryServiceObjectSecurity() called\n");
 
     hSvc = (PSERVICE_HANDLE)hService;
     if (!hSvc || hSvc->Handle.Tag != SERVICE_TAG)
@@ -540,7 +540,7 @@
 
 
 /* Function 5 */
-DWORD ScmrSetServiceObjectSecurity(
+DWORD RSetServiceObjectSecurity(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     DWORD dwSecurityInformation,
@@ -555,7 +555,7 @@
     NTSTATUS Status;
     DWORD dwError;
 
-    DPRINT1("ScmrSetServiceObjectSecurity() called\n");
+    DPRINT1("RSetServiceObjectSecurity() called\n");
 
     hSvc = (PSERVICE_HANDLE)hService;
     if (!hSvc || hSvc->Handle.Tag != SERVICE_TAG)
@@ -653,14 +653,14 @@
 
     /* FIXME: Unlock service database */
 
-    DPRINT("ScmrSetServiceObjectSecurity() done (Error %lu)\n", dwError);
+    DPRINT("RSetServiceObjectSecurity() done (Error %lu)\n", dwError);
 
     return dwError;
 }
 
 
 /* Function 6 */
-DWORD ScmrQueryServiceStatus(
+DWORD RQueryServiceStatus(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     LPSERVICE_STATUS lpServiceStatus)
@@ -668,7 +668,7 @@
     PSERVICE_HANDLE hSvc;
     PSERVICE lpService;
 
-    DPRINT("ScmrQueryServiceStatus() called\n");
+    DPRINT("RQueryServiceStatus() called\n");
 
     if (ScmShutdown)
         return ERROR_SHUTDOWN_IN_PROGRESS;
@@ -704,14 +704,14 @@
 
 
 /* Function 7 */
-DWORD ScmrSetServiceStatus(
+DWORD RSetServiceStatus(
     handle_t BindingHandle,
     SC_RPC_HANDLE hServiceStatus,
     LPSERVICE_STATUS lpServiceStatus)
 {
     PSERVICE lpService;
 
-    DPRINT("ScmrSetServiceStatus() called\n");
+    DPRINT("RSetServiceStatus() called\n");
 
     if (ScmShutdown)
         return ERROR_SHUTDOWN_IN_PROGRESS;
@@ -728,14 +728,14 @@
                   sizeof(SERVICE_STATUS));
 
     DPRINT("Set %S to %lu\n", lpService->lpDisplayName,
lpService->Status.dwCurrentState);
-    DPRINT("ScmrSetServiceStatus() done\n");
+    DPRINT("RSetServiceStatus() done\n");
 
     return ERROR_SUCCESS;
 }
 
 
 /* Function 8 */
-DWORD ScmrUnlockServiceDatabase(
+DWORD RUnlockServiceDatabase(
     handle_t BindingHandle,
     LPSC_RPC_LOCK Lock)
 {
@@ -745,7 +745,7 @@
 
 
 /* Function 9 */
-DWORD ScmrNotifyBootConfigStatus(
+DWORD RNotifyBootConfigStatus(
     handle_t BindingHandle,
     SVCCTL_HANDLEW lpMachineName,
     DWORD BootAcceptable)
@@ -756,7 +756,7 @@
 
 
 /* Function 10 */
-DWORD ScmrSetServiceBitsW(
+DWORD RSetServiceBitsW(
     handle_t BindingHandle,
     SC_RPC_HANDLE hServiceStatus,
     DWORD dwServiceBits,
@@ -770,7 +770,7 @@
 
 
 /* Function 11 */
-DWORD ScmrChangeServiceConfigW(
+DWORD RChangeServiceConfigW(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     DWORD dwServiceType,
@@ -791,7 +791,7 @@
     PSERVICE lpService = NULL;
     HKEY hServiceKey = NULL;
 
-    DPRINT("ScmrChangeServiceConfigW() called\n");
+    DPRINT("RChangeServiceConfigW() called\n");
     DPRINT("dwServiceType = %lu\n", dwServiceType);
     DPRINT("dwStartType = %lu\n", dwStartType);
     DPRINT("dwErrorControl = %lu\n", dwErrorControl);
@@ -984,7 +984,7 @@
     if (hServiceKey != NULL)
         RegCloseKey(hServiceKey);
 
-    DPRINT("ScmrChangeServiceConfigW() done (Error %lu)\n", dwError);
+    DPRINT("RChangeServiceConfigW() done (Error %lu)\n", dwError);
 
     return dwError;
 }
@@ -1365,7 +1365,7 @@
 
 
 /* Function 12 */
-DWORD ScmrCreateServiceW(
+DWORD RCreateServiceW(
     handle_t BindingHandle,
     SC_RPC_HANDLE hSCManager,
     LPWSTR lpServiceName,
@@ -1391,7 +1391,7 @@
     LPWSTR lpImagePath = NULL;
     HKEY hServiceKey = NULL;
 
-    DPRINT("ScmrCreateServiceW() called\n");
+    DPRINT("RCreateServiceW() called\n");
     DPRINT("lpServiceName = %S\n", lpServiceName);
     DPRINT("lpDisplayName = %S\n", lpDisplayName);
     DPRINT("dwDesiredAccess = %lx\n", dwDesiredAccess);
@@ -1633,14 +1633,14 @@
     if (lpImagePath != NULL)
         HeapFree(GetProcessHeap(), 0, lpImagePath);
 
-    DPRINT("ScmrCreateServiceW() done (Error %lu)\n", dwError);
+    DPRINT("RCreateServiceW() done (Error %lu)\n", dwError);
 
     return dwError;
 }
 
 
 /* Function 13 */
-DWORD ScmrEnumDependentServicesW(
+DWORD REnumDependentServicesW(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     DWORD dwServiceState,
@@ -1655,14 +1655,14 @@
     *pcbBytesNeeded = 0;
     *lpServicesReturned = 0;
 
-    DPRINT1("ScmrEnumDependentServicesW() done (Error %lu)\n", dwError);
+    DPRINT1("REnumDependentServicesW() done (Error %lu)\n", dwError);
 
     return dwError;
 }
 
 
 /* Function 14 */
-DWORD ScmrEnumServicesStatusW(
+DWORD REnumServicesStatusW(
     handle_t BindingHandle,
     SC_RPC_HANDLE hSCManager,
     DWORD dwServiceType,
@@ -1686,7 +1686,7 @@
     LPENUM_SERVICE_STATUSW lpStatusPtr;
     LPWSTR lpStringPtr;
 
-    DPRINT("ScmrEnumServicesStatusW() called\n");
+    DPRINT("REnumServicesStatusW() called\n");
 
     if (ScmShutdown)
         return ERROR_SHUTDOWN_IN_PROGRESS;
@@ -1854,14 +1854,14 @@
 Done:;
     /* FIXME: Unlock the service list */
 
-    DPRINT("ScmrEnumServicesStatusW() done (Error %lu)\n", dwError);
+    DPRINT("REnumServicesStatusW() done (Error %lu)\n", dwError);
 
     return dwError;
 }
 
 
 /* Function 15 */
-DWORD ScmrOpenSCManagerW(
+DWORD ROpenSCManagerW(
     handle_t BindingHandle,
     LPWSTR lpMachineName,
     LPWSTR lpDatabaseName,
@@ -1871,7 +1871,7 @@
     DWORD dwError;
     SC_HANDLE hHandle;
 
-    DPRINT("ScmrOpenSCManagerW() called\n");
+    DPRINT("ROpenSCManagerW() called\n");
     DPRINT("lpMachineName = %p\n", lpMachineName);
     DPRINT("lpMachineName: %S\n", lpMachineName);
     DPRINT("lpDataBaseName = %p\n", lpDatabaseName);
@@ -1905,14 +1905,14 @@
     *lpScHandle = (unsigned long)hHandle; /* FIXME: 64 bit portability */
     DPRINT("*hScm = %p\n", *lpScHandle);
 
-    DPRINT("ScmrOpenSCManagerW() done\n");
+    DPRINT("ROpenSCManagerW() done\n");
 
     return ERROR_SUCCESS;
 }
 
 
 /* Function 16 */
-DWORD ScmrOpenServiceW(
+DWORD ROpenServiceW(
     handle_t BindingHandle,
     SC_RPC_HANDLE hSCManager,
     LPWSTR lpServiceName,
@@ -1924,7 +1924,7 @@
     SC_HANDLE hHandle;
     DWORD dwError;
 
-    DPRINT("ScmrOpenServiceW() called\n");
+    DPRINT("ROpenServiceW() called\n");
     DPRINT("hSCManager = %p\n", hSCManager);
     DPRINT("lpServiceName = %p\n", lpServiceName);
     DPRINT("lpServiceName: %S\n", lpServiceName);
@@ -1975,14 +1975,14 @@
     *lpServiceHandle = (unsigned long)hHandle; /* FIXME: 64 bit portability */
     DPRINT("*hService = %p\n", *lpServiceHandle);
 
-    DPRINT("ScmrOpenServiceW() done\n");
+    DPRINT("ROpenServiceW() done\n");
 
     return ERROR_SUCCESS;
 }
 
 
 /* Function 17 */
-DWORD ScmrQueryServiceConfigW(
+DWORD RQueryServiceConfigW(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     LPBYTE lpBuf, //LPQUERY_SERVICE_CONFIGW lpServiceConfig,
@@ -2000,7 +2000,7 @@
     LPQUERY_SERVICE_CONFIGW lpConfig;
     LPWSTR lpStr;
 
-    DPRINT("ScmrQueryServiceConfigW() called\n");
+    DPRINT("RQueryServiceConfigW() called\n");
 
     if (ScmShutdown)
         return ERROR_SHUTDOWN_IN_PROGRESS;
@@ -2136,14 +2136,14 @@
 
     /* FIXME: Unlock the service database */
 
-    DPRINT("ScmrQueryServiceConfigW() done\n");
+    DPRINT("RQueryServiceConfigW() done\n");
 
     return dwError;
 }
 
 
 /* Function 18 */
-DWORD ScmrQueryServiceLockStatusW(
+DWORD RQueryServiceLockStatusW(
     handle_t BindingHandle,
     SC_RPC_HANDLE hSCManager,
     LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus,
@@ -2156,7 +2156,7 @@
 
 
 /* Function 19 */
-DWORD ScmrStartServiceW(
+DWORD RStartServiceW(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     DWORD argc,
@@ -2166,7 +2166,7 @@
     PSERVICE_HANDLE hSvc;
     PSERVICE lpService = NULL;
 
-    DPRINT("ScmrStartServiceW() called\n");
+    DPRINT("RStartServiceW() called\n");
 
     if (ScmShutdown)
         return ERROR_SHUTDOWN_IN_PROGRESS;
@@ -2211,7 +2211,7 @@
 
 
 /* Function 20 */
-DWORD ScmrGetServiceDisplayNameW(
+DWORD RGetServiceDisplayNameW(
     handle_t BindingHandle,
     SC_RPC_HANDLE hSCManager,
     LPWSTR lpServiceName,
@@ -2223,7 +2223,7 @@
     DWORD dwLength;
     DWORD dwError;
 
-    DPRINT("ScmrGetServiceDisplayNameW() called\n");
+    DPRINT("RGetServiceDisplayNameW() called\n");
     DPRINT("hSCManager = %p\n", hSCManager);
     DPRINT("lpServiceName: %S\n", lpServiceName);
     DPRINT("lpDisplayName: %p\n", lpDisplayName);
@@ -2261,7 +2261,7 @@
 
 
 /* Function 21 */
-DWORD ScmrGetServiceKeyNameW(
+DWORD RGetServiceKeyNameW(
     handle_t BindingHandle,
     SC_RPC_HANDLE hSCManager,
     LPWSTR lpDisplayName,
@@ -2273,7 +2273,7 @@
     DWORD dwLength;
     DWORD dwError;
 
-    DPRINT("ScmrGetServiceKeyNameW() called\n");
+    DPRINT("RGetServiceKeyNameW() called\n");
     DPRINT("hSCManager = %p\n", hSCManager);
     DPRINT("lpDisplayName: %S\n", lpDisplayName);
     DPRINT("lpServiceName: %p\n", lpServiceName);
@@ -2311,7 +2311,7 @@
 
 
 /* Function 22 */
-DWORD ScmrSetServiceBitsA(
+DWORD RSetServiceBitsA(
     handle_t BindingHandle,
     SC_RPC_HANDLE hServiceStatus,
     DWORD dwServiceBits,
@@ -2325,7 +2325,7 @@
 
 
 /* Function 23 */
-DWORD ScmrChangeServiceConfigA(
+DWORD RChangeServiceConfigA(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     DWORD dwServiceType,
@@ -2347,7 +2347,7 @@
 
 
 /* Function 24 */
-DWORD ScmrCreateServiceA(
+DWORD RCreateServiceA(
     handle_t BindingHandle,
     SC_RPC_HANDLE hSCManager,
     LPSTR lpServiceName,
@@ -2372,7 +2372,7 @@
 
 
 /* Function 25 */
-DWORD ScmrEnumDependentServicesA(
+DWORD REnumDependentServicesA(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     DWORD dwServiceState,
@@ -2389,7 +2389,7 @@
 
 
 /* Function 26 */
-DWORD ScmrEnumServicesStatusA(
+DWORD REnumServicesStatusA(
     handle_t BindingHandle,
     SC_RPC_HANDLE hSCManager,
     DWORD dwServiceType,
@@ -2406,7 +2406,7 @@
 
 
 /* Function 27 */
-DWORD ScmrOpenSCManagerA(
+DWORD ROpenSCManagerA(
     handle_t BindingHandle,
     LPSTR lpMachineName,
     LPSTR lpDatabaseName,
@@ -2417,7 +2417,7 @@
     UNICODE_STRING DatabaseName;
     DWORD dwError;
 
-    DPRINT("ScmrOpenSCManagerA() called\n");
+    DPRINT("ROpenSCManagerA() called\n");
 
     if (lpMachineName)
         RtlCreateUnicodeStringFromAsciiz(&MachineName,
@@ -2427,7 +2427,7 @@
         RtlCreateUnicodeStringFromAsciiz(&DatabaseName,
                                          lpDatabaseName);
 
-    dwError = ScmrOpenSCManagerW(BindingHandle,
+    dwError = ROpenSCManagerW(BindingHandle,
                                  lpMachineName ? MachineName.Buffer : NULL,
                                  lpDatabaseName ? DatabaseName.Buffer : NULL,
                                  dwDesiredAccess,
@@ -2444,7 +2444,7 @@
 
 
 /* Function 28 */
-DWORD ScmrOpenServiceA(
+DWORD ROpenServiceA(
     handle_t BindingHandle,
     SC_RPC_HANDLE hSCManager,
     LPSTR lpServiceName,
@@ -2454,12 +2454,12 @@
     UNICODE_STRING ServiceName;
     DWORD dwError;
 
-    DPRINT("ScmrOpenServiceA() called\n");
+    DPRINT("ROpenServiceA() called\n");
 
     RtlCreateUnicodeStringFromAsciiz(&ServiceName,
                                      lpServiceName);
 
-    dwError = ScmrOpenServiceW(BindingHandle,
+    dwError = ROpenServiceW(BindingHandle,
                                hSCManager,
                                ServiceName.Buffer,
                                dwDesiredAccess,
@@ -2472,7 +2472,7 @@
 
 
 /* Function 29 */
-DWORD ScmrQueryServiceConfigA(
+DWORD RQueryServiceConfigA(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     LPQUERY_SERVICE_CONFIGA lpServiceConfig,
@@ -2485,7 +2485,7 @@
 
 
 /* Function 30 */
-DWORD ScmrQueryServiceLockStatusA(
+DWORD RQueryServiceLockStatusA(
     handle_t BindingHandle,
     SC_RPC_HANDLE hSCManager,
     LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus,
@@ -2498,7 +2498,7 @@
 
 
 /* Function 31 */
-DWORD ScmrStartServiceA(
+DWORD RStartServiceA(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     DWORD argc,
@@ -2508,7 +2508,7 @@
     PSERVICE_HANDLE hSvc;
     PSERVICE lpService = NULL;
 
-    DPRINT1("ScmrStartServiceA() called\n");
+    DPRINT1("RStartServiceA() called\n");
 
     if (ScmShutdown)
         return ERROR_SHUTDOWN_IN_PROGRESS;
@@ -2552,7 +2552,7 @@
 
 
 /* Function 32 */
-DWORD ScmrGetServiceDisplayNameA(
+DWORD RGetServiceDisplayNameA(
     handle_t BindingHandle,
     SC_RPC_HANDLE hSCManager,
     LPSTR lpServiceName,
@@ -2565,7 +2565,7 @@
 
 
 /* Function 33 */
-DWORD ScmrGetServiceKeyNameA(
+DWORD RGetServiceKeyNameA(
     handle_t BindingHandle,
     SC_RPC_HANDLE hSCManager,
     LPSTR lpDisplayName,
@@ -2578,7 +2578,7 @@
 
 
 /* Function 34 */
-DWORD ScmrGetCurrentGroupStateW(
+DWORD RGetCurrentGroupStateW(
     handle_t BindingHandle)
 {
     UNIMPLEMENTED;
@@ -2587,7 +2587,7 @@
 
 
 /* Function 35 */
-DWORD ScmrEnumServiceGroupW(
+DWORD REnumServiceGroupW(
     handle_t BindingHandle,
     SC_RPC_HANDLE hSCManager,
     DWORD dwServiceType,
@@ -2605,7 +2605,7 @@
 
 
 /* Function 36 */
-DWORD ScmrChangeServiceConfig2A(
+DWORD RChangeServiceConfig2A(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     SC_RPC_CONFIG_INFOA Info)
@@ -2616,7 +2616,7 @@
 
 
 /* Function 37 */
-DWORD ScmrChangeServiceConfig2W(
+DWORD RChangeServiceConfig2W(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     SC_RPC_CONFIG_INFOW Info)
@@ -2626,7 +2626,7 @@
     PSERVICE lpService = NULL;
     HKEY hServiceKey = NULL;
 
-    DPRINT("ScmrChangeServiceConfig2W() called\n");
+    DPRINT("RChangeServiceConfig2W() called\n");
     DPRINT("dwInfoLevel = %lu\n", Info.dwInfoLevel);
 
     if (ScmShutdown)
@@ -2702,14 +2702,14 @@
     if (hServiceKey != NULL)
         RegCloseKey(hServiceKey);
 
-    DPRINT("ScmrChangeServiceConfig2W() done (Error %lu)\n", dwError);
+    DPRINT("RChangeServiceConfig2W() done (Error %lu)\n", dwError);
 
     return dwError;
 }
 
 
 /* Function 38 */
-DWORD ScmrQueryServiceConfig2A(
+DWORD RQueryServiceConfig2A(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     DWORD dwInfoLevel,
@@ -2723,7 +2723,7 @@
 
 
 /* Function 39 */
-DWORD ScmrQueryServiceConfig2W(
+DWORD RQueryServiceConfig2W(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     DWORD dwInfoLevel,
@@ -2738,7 +2738,7 @@
     DWORD dwRequiredSize;
     LPWSTR lpDescription = NULL;
 
-    DPRINT("ScmrQueryServiceConfig2W() called\n");
+    DPRINT("RQueryServiceConfig2W() called\n");
 
     if (ScmShutdown)
         return ERROR_SHUTDOWN_IN_PROGRESS;
@@ -2814,14 +2814,14 @@
 
     /* FIXME: Unlock database */
 
-    DPRINT("ScmrQueryServiceConfig2W() done (Error %lu)\n", dwError);
+    DPRINT("RQueryServiceConfig2W() done (Error %lu)\n", dwError);
 
     return dwError;
 }
 
 
 /* Function 40 */
-DWORD ScmrQueryServiceStatusEx(
+DWORD RQueryServiceStatusEx(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     SC_STATUS_TYPE InfoLevel,
@@ -2833,7 +2833,7 @@
     PSERVICE_HANDLE hSvc;
     PSERVICE lpService;
 
-    DPRINT("ScmrQueryServiceStatusEx() called\n");
+    DPRINT("RQueryServiceStatusEx() called\n");
 
     if (ScmShutdown)
         return ERROR_SHUTDOWN_IN_PROGRESS;
@@ -2882,7 +2882,7 @@
 
 
 /* Function 41 */
-DWORD ScmrEnumServicesStatusExA(
+DWORD REnumServicesStatusExA(
     handle_t BindingHandle,
     SC_RPC_HANDLE hSCManager,
     SC_ENUM_TYPE InfoLevel,
@@ -2903,7 +2903,7 @@
 
 
 /* Function 42 */
-DWORD ScmrEnumServicesStatusExW(
+DWORD REnumServicesStatusExW(
     handle_t BindingHandle,
     SC_RPC_HANDLE hSCManager,
     SC_ENUM_TYPE InfoLevel,
@@ -2929,7 +2929,7 @@
     LPENUM_SERVICE_STATUS_PROCESSW lpStatusPtr;
     LPWSTR lpStringPtr;
 
-    DPRINT("ScmrEnumServicesStatusExW() called\n");
+    DPRINT("REnumServicesStatusExW() called\n");
 
     if (ScmShutdown)
         return ERROR_SHUTDOWN_IN_PROGRESS;
@@ -3147,14 +3147,14 @@
 Done:;
     /* Unlock the service list */
 
-    DPRINT("ScmrEnumServicesStatusExW() done (Error %lu)\n", dwError);
+    DPRINT("REnumServicesStatusExW() done (Error %lu)\n", dwError);
 
     return dwError;
 }
 
 
 /* Function 43 */
-DWORD ScmrSendTSMessage(
+DWORD RSendTSMessage(
     handle_t BindingHandle)
 {
     UNIMPLEMENTED;
@@ -3163,7 +3163,7 @@
 
 
 /* Function 44 */
-DWORD ScmrCreateServiceWOW64A(
+DWORD RCreateServiceWOW64A(
     handle_t BindingHandle,
     LPSTR lpServiceName,
     LPSTR lpDisplayName,
@@ -3187,7 +3187,7 @@
 
 
 /* Function 45 */
-DWORD ScmrCreateServiceWOW64W(
+DWORD RCreateServiceWOW64W(
     handle_t BindingHandle,
     LPWSTR lpServiceName,
     LPWSTR lpDisplayName,
@@ -3211,7 +3211,7 @@
 
 
 /* Function 46 */
-DWORD ScmrFunction46(
+DWORD RQueryServiceTagInfo(
     handle_t BindingHandle)
 {
     UNIMPLEMENTED;
@@ -3220,7 +3220,7 @@
 
 
 /* Function 47 */
-DWORD ScmrNotifyServiceStatusChange(
+DWORD RNotifyServiceStatusChange(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     SC_RPC_NOTIFY_PARAMS NotifyParams,
@@ -3235,7 +3235,7 @@
 
 
 /* Function 48 */
-DWORD ScmrGetNotifyResults(
+DWORD RGetNotifyResults(
     handle_t BindingHandle,
     SC_NOTIFY_RPC_HANDLE hNotify,
     PSC_RPC_NOTIFY_PARAMS_LIST *ppNotifyParams)
@@ -3246,7 +3246,7 @@
 
 
 /* Function 49 */
-DWORD ScmrCloseNotifyHandle(
+DWORD RCloseNotifyHandle(
     handle_t BindingHandle,
     LPSC_NOTIFY_RPC_HANDLE phNotify,
     PBOOL pfApcFired)
@@ -3257,7 +3257,7 @@
 
 
 /* Function 50 */
-DWORD ScmrControlServiceExA(
+DWORD RControlServiceExA(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     DWORD dwControl,
@@ -3269,7 +3269,7 @@
 
 
 /* Function 51 */
-DWORD ScmrControlServiceExW(
+DWORD RControlServiceExW(
     handle_t BindingHandle,
     SC_RPC_HANDLE hService,
     DWORD dwControl,
@@ -3281,7 +3281,7 @@
 
 
 /* Function 52 */
-DWORD ScmrFunction52(
+DWORD RSendPnPMessage(
     handle_t BindingHandle)
 {
     UNIMPLEMENTED;
@@ -3290,7 +3290,7 @@
 
 
 /* Function 53 */
-DWORD ScmrFunction53(
+DWORD RValidatePnPService(
     handle_t BindingHandle)
 {
     UNIMPLEMENTED;
@@ -3299,7 +3299,7 @@
 
 
 /* Function 54 */
-DWORD ScmrFunction54(
+DWORD ROpenServiceStatusHandle(
     handle_t BindingHandle)
 {
     UNIMPLEMENTED;
@@ -3308,7 +3308,7 @@
 
 
 /* Function 55 */
-DWORD ScmrFunction55(
+DWORD RFunction55(
     handle_t BindingHandle)
 {
     UNIMPLEMENTED;

Modified: trunk/reactos/dll/win32/advapi32/service/scm.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/advapi32/service…
==============================================================================
--- trunk/reactos/dll/win32/advapi32/service/scm.c [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/advapi32/service/scm.c [iso-8859-1] Thu Apr 10 11:39:01 2008
@@ -116,12 +116,12 @@
 
     HandleBind();
 
-    dwError = ScmrChangeServiceConfig2A(BindingHandle,
-                                        (SC_RPC_HANDLE)hService,
-                                        Info);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrChangeServiceConfig2A() failed (Error %lu)\n", dwError);
+    dwError = RChangeServiceConfig2A(BindingHandle,
+                                     (SC_RPC_HANDLE)hService,
+                                     Info);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RChangeServiceConfig2A() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -170,12 +170,12 @@
 
     HandleBind();
 
-    dwError = ScmrChangeServiceConfig2W(BindingHandle,
-                                        (SC_RPC_HANDLE)hService,
-                                        Info);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrChangeServiceConfig2W() failed (Error %lu)\n", dwError);
+    dwError = RChangeServiceConfig2W(BindingHandle,
+                                     (SC_RPC_HANDLE)hService,
+                                     Info);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RChangeServiceConfig2W() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -227,23 +227,23 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrChangeServiceConfigA(BindingHandle,
-                                       (unsigned int)hService,
-                                       dwServiceType,
-                                       dwStartType,
-                                       dwErrorControl,
-                                       (LPSTR)lpBinaryPathName,
-                                       (LPSTR)lpLoadOrderGroup,
-                                       lpdwTagId,
-                                       (LPSTR)lpDependencies,
-                                       dwDependenciesLength,
-                                       (LPSTR)lpServiceStartName,
-                                       NULL,              /* FIXME: lpPassword */
-                                       0,                 /* FIXME: dwPasswordLength */
-                                       (LPSTR)lpDisplayName);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrChangeServiceConfigA() failed (Error %lu)\n", dwError);
+    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);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RChangeServiceConfigA() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -295,23 +295,23 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrChangeServiceConfigW(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);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrChangeServiceConfigW() failed (Error %lu)\n", dwError);
+    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);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RChangeServiceConfigW() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -335,11 +335,11 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrCloseServiceHandle(BindingHandle,
-                                     (LPSC_RPC_HANDLE)&hSCObject);
+    dwError = RCloseServiceHandle(BindingHandle,
+                                  (LPSC_RPC_HANDLE)&hSCObject);
     if (dwError)
     {
-        ERR("ScmrCloseServiceHandle() failed (Error %lu)\n", dwError);
+        ERR("RCloseServiceHandle() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -368,13 +368,13 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrControlService(BindingHandle,
-                                 (unsigned int)hService,
-                                 dwControl,
-                                 lpServiceStatus);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrControlService() failed (Error %lu)\n", dwError);
+    dwError = RControlService(BindingHandle,
+                              (SC_RPC_HANDLE)hService,
+                              dwControl,
+                              lpServiceStatus);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RControlService() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -615,26 +615,26 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrCreateServiceW(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);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrCreateServiceW() failed (Error %lu)\n", dwError);
+    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);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RCreateServiceW() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return NULL;
     }
@@ -658,11 +658,11 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrDeleteService(BindingHandle,
-                                (unsigned int)hService);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrDeleteService() failed (Error %lu)\n", dwError);
+    dwError = RDeleteService(BindingHandle,
+                             (SC_RPC_HANDLE)hService);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RDeleteService() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -692,13 +692,13 @@
 
     HandleBind();
 
-    dwError = ScmrEnumDependentServicesA(BindingHandle,
-                                         (unsigned int)hService,
-                                         dwServiceState,
-                                         (unsigned char *)lpServices,
-                                         cbBufSize,
-                                         pcbBytesNeeded,
-                                         lpServicesReturned);
+    dwError = REnumDependentServicesA(BindingHandle,
+                                      (SC_RPC_HANDLE)hService,
+                                      dwServiceState,
+                                      (LPBYTE)lpServices,
+                                      cbBufSize,
+                                      pcbBytesNeeded,
+                                      lpServicesReturned);
 
     lpStatusPtr = (LPENUM_SERVICE_STATUSA)lpServices;
     for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
@@ -716,7 +716,7 @@
 
     if (dwError != ERROR_SUCCESS)
     {
-        ERR("ScmrEnumDependentServicesA() failed (Error %lu)\n", dwError);
+        ERR("REnumDependentServicesA() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -748,13 +748,13 @@
 
     HandleBind();
 
-    dwError = ScmrEnumDependentServicesW(BindingHandle,
-                                         (unsigned int)hService,
-                                         dwServiceState,
-                                         (unsigned char *)lpServices,
-                                         cbBufSize,
-                                         pcbBytesNeeded,
-                                         lpServicesReturned);
+    dwError = REnumDependentServicesW(BindingHandle,
+                                      (SC_RPC_HANDLE)hService,
+                                      dwServiceState,
+                                      (LPBYTE)lpServices,
+                                      cbBufSize,
+                                      pcbBytesNeeded,
+                                      lpServicesReturned);
 
     lpStatusPtr = (LPENUM_SERVICE_STATUSW)lpServices;
     for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
@@ -772,7 +772,7 @@
 
     if (dwError != ERROR_SUCCESS)
     {
-        ERR("ScmrEnumDependentServicesW() failed (Error %lu)\n", dwError);
+        ERR("REnumDependentServicesW() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -830,15 +830,15 @@
 
     HandleBind();
 
-    dwError = ScmrEnumServicesStatusA(BindingHandle,
-                                      (unsigned int)hSCManager,
-                                      dwServiceType,
-                                      dwServiceState,
-                                      (unsigned char *)lpServices,
-                                      cbBufSize,
-                                      pcbBytesNeeded,
-                                      lpServicesReturned,
-                                      lpResumeHandle);
+    dwError = REnumServicesStatusA(BindingHandle,
+                                   (SC_RPC_HANDLE)hSCManager,
+                                   dwServiceType,
+                                   dwServiceState,
+                                   (LPBYTE)lpServices,
+                                   cbBufSize,
+                                   pcbBytesNeeded,
+                                   lpServicesReturned,
+                                   lpResumeHandle);
 
     lpStatusPtr = (LPENUM_SERVICE_STATUSA)lpServices;
     for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
@@ -856,7 +856,7 @@
 
     if (dwError != ERROR_SUCCESS)
     {
-        ERR("ScmrEnumServicesStatusA() failed (Error %lu)\n", dwError);
+        ERR("REnumServicesStatusA() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -890,15 +890,15 @@
 
     HandleBind();
 
-    dwError = ScmrEnumServicesStatusW(BindingHandle,
-                                      (unsigned int)hSCManager,
-                                      dwServiceType,
-                                      dwServiceState,
-                                      (unsigned char *)lpServices,
-                                      cbBufSize,
-                                      pcbBytesNeeded,
-                                      lpServicesReturned,
-                                      lpResumeHandle);
+    dwError = REnumServicesStatusW(BindingHandle,
+                                   (SC_RPC_HANDLE)hSCManager,
+                                   dwServiceType,
+                                   dwServiceState,
+                                   (LPBYTE)lpServices,
+                                   cbBufSize,
+                                   pcbBytesNeeded,
+                                   lpServicesReturned,
+                                   lpResumeHandle);
 
     lpStatusPtr = (LPENUM_SERVICE_STATUSW)lpServices;
     for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
@@ -916,7 +916,7 @@
 
     if (dwError != ERROR_SUCCESS)
     {
-        ERR("ScmrEnumServicesStatusW() failed (Error %lu)\n", dwError);
+        ERR("REnumServicesStatusW() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -952,17 +952,17 @@
 
     HandleBind();
 
-    dwError = ScmrEnumServicesStatusExA(BindingHandle,
-                                        (unsigned int)hSCManager,
-                                        (unsigned long)InfoLevel,
-                                        dwServiceType,
-                                        dwServiceState,
-                                        (unsigned char *)lpServices,
-                                        cbBufSize,
-                                        pcbBytesNeeded,
-                                        lpServicesReturned,
-                                        lpResumeHandle,
-                                        (char *)pszGroupName);
+    dwError = REnumServicesStatusExA(BindingHandle,
+                                     (SC_RPC_HANDLE)hSCManager,
+                                     InfoLevel,
+                                     dwServiceType,
+                                     dwServiceState,
+                                     (LPBYTE)lpServices,
+                                     cbBufSize,
+                                     pcbBytesNeeded,
+                                     lpServicesReturned,
+                                     lpResumeHandle,
+                                     (LPSTR)pszGroupName);
 
     if (dwError == ERROR_MORE_DATA)
     {
@@ -988,7 +988,7 @@
     }
     else
     {
-        ERR("ScmrEnumServicesStatusExA() failed (Error %lu)\n", dwError);
+        ERR("REnumServicesStatusExA() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -1024,17 +1024,17 @@
 
     HandleBind();
 
-    dwError = ScmrEnumServicesStatusExW(BindingHandle,
-                                        (unsigned int)hSCManager,
-                                        (unsigned long)InfoLevel,
-                                        dwServiceType,
-                                        dwServiceState,
-                                        (unsigned char *)lpServices,
-                                        cbBufSize,
-                                        pcbBytesNeeded,
-                                        lpServicesReturned,
-                                        lpResumeHandle,
-                                        (wchar_t *)pszGroupName);
+    dwError = REnumServicesStatusExW(BindingHandle,
+                                     (SC_RPC_HANDLE)hSCManager,
+                                     InfoLevel,
+                                     dwServiceType,
+                                     dwServiceState,
+                                     (LPBYTE)lpServices,
+                                     cbBufSize,
+                                     pcbBytesNeeded,
+                                     lpServicesReturned,
+                                     lpResumeHandle,
+                                     (LPWSTR)pszGroupName);
 
     if (dwError == ERROR_MORE_DATA)
     {
@@ -1060,7 +1060,7 @@
     }
     else
     {
-        ERR("ScmrEnumServicesStatusExW() failed (Error %lu)\n", dwError);
+        ERR("REnumServicesStatusExW() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -1088,14 +1088,14 @@
 
     HandleBind();
 
-    dwError = ScmrGetServiceDisplayNameA(BindingHandle,
-                                         (unsigned int)hSCManager,
-                                         (LPSTR)lpServiceName,
-                                         lpDisplayName,
-                                         lpcchBuffer);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrGetServiceDisplayNameA() failed (Error %lu)\n", dwError);
+    dwError = RGetServiceDisplayNameA(BindingHandle,
+                                      (SC_RPC_HANDLE)hSCManager,
+                                      (LPSTR)lpServiceName,
+                                      lpDisplayName,
+                                      lpcchBuffer);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RGetServiceDisplayNameA() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -1123,14 +1123,14 @@
 
     HandleBind();
 
-    dwError = ScmrGetServiceDisplayNameW(BindingHandle,
-                                         (unsigned int)hSCManager,
-                                         (LPWSTR)lpServiceName,
-                                         lpDisplayName,
-                                         lpcchBuffer);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrGetServiceDisplayNameW() failed (Error %lu)\n", dwError);
+    dwError = RGetServiceDisplayNameW(BindingHandle,
+                                      (SC_RPC_HANDLE)hSCManager,
+                                      (LPWSTR)lpServiceName,
+                                      lpDisplayName,
+                                      lpcchBuffer);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RGetServiceDisplayNameW() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -1158,14 +1158,14 @@
 
     HandleBind();
 
-    dwError = ScmrGetServiceKeyNameA(BindingHandle,
-                                     (unsigned int)hSCManager,
-                                     (LPSTR)lpDisplayName,
-                                     lpServiceName,
-                                     lpcchBuffer);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrGetServiceKeyNameA() failed (Error %lu)\n", dwError);
+    dwError = RGetServiceKeyNameA(BindingHandle,
+                                  (SC_RPC_HANDLE)hSCManager,
+                                  (LPSTR)lpDisplayName,
+                                  lpServiceName,
+                                  lpcchBuffer);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RGetServiceKeyNameA() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -1193,14 +1193,14 @@
 
     HandleBind();
 
-    dwError = ScmrGetServiceKeyNameW(BindingHandle,
-                                     (unsigned int)hSCManager,
-                                     (LPWSTR)lpDisplayName,
-                                     lpServiceName,
-                                     lpcchBuffer);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrGetServiceKeyNameW() failed (Error %lu)\n", dwError);
+    dwError = RGetServiceKeyNameW(BindingHandle,
+                                  (SC_RPC_HANDLE)hSCManager,
+                                  (LPWSTR)lpDisplayName,
+                                  lpServiceName,
+                                  lpcchBuffer);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RGetServiceKeyNameW() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -1227,12 +1227,12 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrLockServiceDatabase(BindingHandle,
-                                      (SC_RPC_HANDLE)hSCManager,
-                                      (SC_RPC_LOCK *)&hLock);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrLockServiceDatabase() failed (Error %lu)\n", dwError);
+    dwError = RLockServiceDatabase(BindingHandle,
+                                   (SC_RPC_HANDLE)hSCManager,
+                                   (SC_RPC_LOCK *)&hLock);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RLockServiceDatabase() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return NULL;
     }
@@ -1304,14 +1304,14 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrOpenSCManagerA(BindingHandle,
-                                 (LPSTR)lpMachineName,
-                                 (LPSTR)lpDatabaseName,
-                                 dwDesiredAccess,
-                                 (unsigned long*)&hScm);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrOpenSCManagerA() failed (Error %lu)\n", dwError);
+    dwError = ROpenSCManagerA(BindingHandle,
+                              (LPSTR)lpMachineName,
+                              (LPSTR)lpDatabaseName,
+                              dwDesiredAccess,
+                              (SC_RPC_HANDLE *)&hScm);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("ROpenSCManagerA() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return NULL;
     }
@@ -1343,14 +1343,14 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrOpenSCManagerW(BindingHandle,
-                                 (LPWSTR)lpMachineName,
-                                 (LPWSTR)lpDatabaseName,
-                                 dwDesiredAccess,
-                                 (unsigned long*)&hScm);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrOpenSCManagerW() failed (Error %lu)\n", dwError);
+    dwError = ROpenSCManagerW(BindingHandle,
+                              (LPWSTR)lpMachineName,
+                              (LPWSTR)lpDatabaseName,
+                              dwDesiredAccess,
+                              (SC_RPC_HANDLE *)&hScm);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("ROpenSCManagerW() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return NULL;
     }
@@ -1380,14 +1380,14 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrOpenServiceA(BindingHandle,
-                               (unsigned int)hSCManager,
-                               (LPSTR)lpServiceName,
-                               dwDesiredAccess,
-                               (unsigned long*)&hService);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrOpenServiceA() failed (Error %lu)\n", dwError);
+    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);
         SetLastError(dwError);
         return NULL;
     }
@@ -1417,14 +1417,14 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrOpenServiceW(BindingHandle,
-                               (unsigned int)hSCManager,
-                               (LPWSTR)lpServiceName,
-                               dwDesiredAccess,
-                               (unsigned long*)&hService);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrOpenServiceW() failed (Error %lu)\n", dwError);
+    dwError = ROpenServiceW(BindingHandle,
+                            (SC_RPC_HANDLE)hSCManager,
+                            (LPWSTR)lpServiceName,
+                            dwDesiredAccess,
+                            (SC_RPC_HANDLE *)&hService);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("ROpenServiceW() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return NULL;
     }
@@ -1454,14 +1454,14 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrQueryServiceConfigA(BindingHandle,
-                                      (SC_RPC_HANDLE)hService,
-                                      lpServiceConfig,
-                                      cbBufSize,
-                                      pcbBytesNeeded);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrQueryServiceConfigA() failed (Error %lu)\n", dwError);
+    dwError = RQueryServiceConfigA(BindingHandle,
+                                   (SC_RPC_HANDLE)hService,
+                                   lpServiceConfig,
+                                   cbBufSize,
+                                   pcbBytesNeeded);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RQueryServiceConfigA() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -1517,14 +1517,14 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrQueryServiceConfigW(BindingHandle,
-                                      (SC_RPC_HANDLE)hService,
-                                      (LPBYTE)lpServiceConfig,
-                                      cbBufSize,
-                                      pcbBytesNeeded);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrQueryServiceConfigW() failed (Error %lu)\n", dwError);
+    dwError = RQueryServiceConfigW(BindingHandle,
+                                   (SC_RPC_HANDLE)hService,
+                                   (LPBYTE)lpServiceConfig,
+                                   cbBufSize,
+                                   pcbBytesNeeded);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RQueryServiceConfigW() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -1581,15 +1581,15 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrQueryServiceConfig2A(BindingHandle,
-                                       (unsigned int)hService,
-                                       dwInfoLevel,
-                                       (unsigned char *)lpBuffer,
-                                       cbBufSize,
-                                       pcbBytesNeeded);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrQueryServiceConfig2A() failed (Error %lu)\n", dwError);
+    dwError = RQueryServiceConfig2A(BindingHandle,
+                                    (SC_RPC_HANDLE)hService,
+                                    dwInfoLevel,
+                                    lpBuffer,
+                                    cbBufSize,
+                                    pcbBytesNeeded);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RQueryServiceConfig2A() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -1656,15 +1656,15 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrQueryServiceConfig2W(BindingHandle,
-                                       (unsigned int)hService,
-                                       dwInfoLevel,
-                                       (unsigned char *)lpBuffer,
-                                       cbBufSize,
-                                       pcbBytesNeeded);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrQueryServiceConfig2W() failed (Error %lu)\n", dwError);
+    dwError = RQueryServiceConfig2W(BindingHandle,
+                                    (SC_RPC_HANDLE)hService,
+                                    dwInfoLevel,
+                                    lpBuffer,
+                                    cbBufSize,
+                                    pcbBytesNeeded);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RQueryServiceConfig2W() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -1729,14 +1729,14 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrQueryServiceLockStatusA(BindingHandle,
-                                          (SC_RPC_HANDLE)hSCManager,
-                                          lpLockStatus,
-                                          cbBufSize,
-                                          pcbBytesNeeded);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrQueryServiceLockStatusA() failed (Error %lu)\n", dwError);
+    dwError = RQueryServiceLockStatusA(BindingHandle,
+                                       (SC_RPC_HANDLE)hSCManager,
+                                       lpLockStatus,
+                                       cbBufSize,
+                                       pcbBytesNeeded);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RQueryServiceLockStatusA() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -1771,14 +1771,14 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrQueryServiceLockStatusW(BindingHandle,
-                                          (SC_RPC_HANDLE)hSCManager,
-                                          lpLockStatus,
-                                          cbBufSize,
-                                          pcbBytesNeeded);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrQueryServiceLockStatusW() failed (Error %lu)\n", dwError);
+    dwError = RQueryServiceLockStatusW(BindingHandle,
+                                       (SC_RPC_HANDLE)hSCManager,
+                                       lpLockStatus,
+                                       cbBufSize,
+                                       pcbBytesNeeded);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RQueryServiceLockStatusW() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -1815,12 +1815,12 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrQueryServiceObjectSecurity(BindingHandle,
-                                             (unsigned int)hService,
-                                             dwSecurityInformation,
-                                             (unsigned char *)lpSecurityDescriptor,
-                                             cbBufSize,
-                                             pcbBytesNeeded);
+    dwError = RQueryServiceObjectSecurity(BindingHandle,
+                                          (SC_RPC_HANDLE)hService,
+                                          dwSecurityInformation,
+                                          (LPBYTE)lpSecurityDescriptor,
+                                          cbBufSize,
+                                          pcbBytesNeeded);
     if (dwError != ERROR_SUCCESS)
     {
         ERR("QueryServiceObjectSecurity() failed (Error %lu)\n", dwError);
@@ -1876,17 +1876,17 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrSetServiceObjectSecurity(BindingHandle,
-                                           (unsigned int)hService,
-                                           dwSecurityInformation,
-                                           (unsigned char *)SelfRelativeSD,
-                                           Length);
+    dwError = RSetServiceObjectSecurity(BindingHandle,
+                                        (SC_RPC_HANDLE)hService,
+                                        dwSecurityInformation,
+                                        (LPBYTE)SelfRelativeSD,
+                                        Length);
 
     HeapFree(GetProcessHeap(), 0, SelfRelativeSD);
 
     if (dwError != ERROR_SUCCESS)
     {
-        ERR("ScmrServiceObjectSecurity() failed (Error %lu)\n", dwError);
+        ERR("RServiceObjectSecurity() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -1912,12 +1912,12 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrQueryServiceStatus(BindingHandle,
-                                     (unsigned int)hService,
-                                     lpServiceStatus);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrQueryServiceStatus() failed (Error %lu)\n", dwError);
+    dwError = RQueryServiceStatus(BindingHandle,
+                                  (SC_RPC_HANDLE)hService,
+                                  lpServiceStatus);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RQueryServiceStatus() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -1945,15 +1945,15 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrQueryServiceStatusEx(BindingHandle,
-                                       (unsigned int)hService,
-                                       InfoLevel,
-                                       lpBuffer,
-                                       cbBufSize,
-                                       pcbBytesNeeded);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrQueryServiceStatusEx() failed (Error %lu)\n", dwError);
+    dwError = RQueryServiceStatusEx(BindingHandle,
+                                    (SC_RPC_HANDLE)hService,
+                                    InfoLevel,
+                                    lpBuffer,
+                                    cbBufSize,
+                                    pcbBytesNeeded);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RQueryServiceStatusEx() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -1974,15 +1974,15 @@
 {
     DWORD dwError;
 
-    dwError = ScmrStartServiceA(BindingHandle,
-                                (SC_RPC_HANDLE)hService,
-                                dwNumServiceArgs,
-                                (LPSTRING_PTRSA)lpServiceArgVectors);
-
-
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrStartServiceA() failed (Error %lu)\n", dwError);
+    dwError = RStartServiceA(BindingHandle,
+                             (SC_RPC_HANDLE)hService,
+                             dwNumServiceArgs,
+                             (LPSTRING_PTRSA)lpServiceArgVectors);
+
+
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RStartServiceA() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -2003,14 +2003,14 @@
 {
     DWORD dwError;
 
-    dwError = ScmrStartServiceW(BindingHandle,
-                                (SC_RPC_HANDLE)hService,
-                                dwNumServiceArgs,
-                                (LPSTRING_PTRSW)lpServiceArgVectors);
-
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrStartServiceW() failed (Error %lu)\n", dwError);
+    dwError = RStartServiceW(BindingHandle,
+                             (SC_RPC_HANDLE)hService,
+                             dwNumServiceArgs,
+                             (LPSTRING_PTRSW)lpServiceArgVectors);
+
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RStartServiceW() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -2034,11 +2034,11 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrUnlockServiceDatabase(BindingHandle,
-                                        (SC_RPC_LOCK)ScLock);
-    if (dwError != ERROR_SUCCESS)
-    {
-        ERR("ScmrUnlockServiceDatabase() failed (Error %lu)\n", dwError);
+    dwError = RUnlockServiceDatabase(BindingHandle,
+                                     (SC_RPC_LOCK)ScLock);
+    if (dwError != ERROR_SUCCESS)
+    {
+        ERR("RUnlockServiceDatabase() failed (Error %lu)\n", dwError);
         SetLastError(dwError);
         return FALSE;
     }
@@ -2062,9 +2062,9 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrNotifyBootConfigStatus(BindingHandle,
-                                         NULL,
-                                         BootAcceptable);
+    dwError = RNotifyBootConfigStatus(BindingHandle,
+                                      NULL,
+                                      BootAcceptable);
     if (dwError != ERROR_SUCCESS)
     {
         ERR("NotifyBootConfigStatus() failed (Error %lu)\n", dwError);

Modified: trunk/reactos/dll/win32/advapi32/service/sctrl.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/advapi32/service…
==============================================================================
--- trunk/reactos/dll/win32/advapi32/service/sctrl.c [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/advapi32/service/sctrl.c [iso-8859-1] Thu Apr 10 11:39:01
2008
@@ -561,9 +561,9 @@
     HandleBind();
 
     /* Call to services.exe using RPC */
-    dwError = ScmrSetServiceStatus(BindingHandle,
-                                   (unsigned long)hServiceStatus,
-                                   lpServiceStatus);
+    dwError = RSetServiceStatus(BindingHandle,
+                                (SC_RPC_HANDLE)hServiceStatus,
+                                lpServiceStatus);
     if (dwError != ERROR_SUCCESS)
     {
         ERR("ScmrSetServiceStatus() failed (Error %lu)\n", dwError);

Modified: trunk/reactos/include/reactos/idl/svcctl.idl
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/include/reactos/idl/svcctl…
==============================================================================
--- trunk/reactos/include/reactos/idl/svcctl.idl [iso-8859-1] (original)
+++ trunk/reactos/include/reactos/idl/svcctl.idl [iso-8859-1] Thu Apr 10 11:39:01 2008
@@ -14,8 +14,6 @@
 const unsigned short SC_MAX_COMMENT_LENGTH = 128;
 const unsigned short SC_MAX_ARGUMENT_LENGTH = 1024;
 const unsigned short SC_MAX_ARGUMENTS = 1024;
-
-#define R(fn) Scmr ## fn
 
 typedef unsigned long SECURITY_INFORMATION;
 typedef [handle] LPSTR SVCCTL_HANDLEA;
@@ -304,30 +302,30 @@
 interface svcctl
 {
     /* Function 0 */
-    DWORD R(CloseServiceHandle) (
+    DWORD RCloseServiceHandle(
         [in] handle_t BindingHandle,
         [in, out] LPSC_RPC_HANDLE hSCObject);
 
     /* Function 1 */
-    DWORD R(ControlService) (
+    DWORD RControlService(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [in] DWORD dwControl,
         [out] LPSERVICE_STATUS lpServiceStatus);
 
     /* Function 2 */
-    DWORD R(DeleteService) (
+    DWORD RDeleteService(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService);
 
     /* Function 3 */
-    DWORD R(LockServiceDatabase) (
+    DWORD RLockServiceDatabase(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hSCManager,
         [out] LPSC_RPC_LOCK lpLock);
 
     /* Function 4 */
-    DWORD R(QueryServiceObjectSecurity) (
+    DWORD RQueryServiceObjectSecurity(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [in] SECURITY_INFORMATION dwSecurityInformation,
@@ -336,7 +334,7 @@
         [out] LPBOUNDED_DWORD_256K pcbBytesNeeded);
 
     /* Function 5 */
-    DWORD R(SetServiceObjectSecurity) (
+    DWORD RSetServiceObjectSecurity(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [in] DWORD dwSecurityInformation,
@@ -344,30 +342,30 @@
         [in] DWORD dwSecuityDescriptorSize);
 
     /* Function 6 */
-    DWORD R(QueryServiceStatus) (
+    DWORD RQueryServiceStatus(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [out] LPSERVICE_STATUS lpServiceStatus);
 
     /* Function 7 */
-    DWORD R(SetServiceStatus) (
+    DWORD RSetServiceStatus(
       [in] handle_t BindingHandle,
       [in] SC_RPC_HANDLE hServiceStatus,
       [in] LPSERVICE_STATUS lpServiceStatus);
 
     /* Function 8 */
-    DWORD R(UnlockServiceDatabase) (
+    DWORD RUnlockServiceDatabase(
         [in] handle_t BindingHandle,
         [in, out] LPSC_RPC_LOCK Lock);
 
     /* Function 9 */
-    DWORD R(NotifyBootConfigStatus) (
+    DWORD RNotifyBootConfigStatus(
         [in] handle_t BindingHandle,
         [in, string, unique, range(0, SC_MAX_COMPUTER_NAME_LENGTH)] SVCCTL_HANDLEW
lpMachineName,
         [in] DWORD BootAcceptable);
 
     /* Function 10 */
-    DWORD R(SetServiceBitsW) (
+    DWORD RSetServiceBitsW(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hServiceStatus,
         [in] DWORD dwServiceBits,
@@ -376,7 +374,7 @@
         [in, string, unique] LPWSTR lpString);
 
     /* Function 11 */
-    DWORD R(ChangeServiceConfigW) (
+    DWORD RChangeServiceConfigW(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [in] DWORD dwServiceType,
@@ -393,7 +391,7 @@
         [in, string, unique, range(0, SC_MAX_NAME_LENGTH)] LPWSTR lpDisplayName);
 
     /* Function 12 */
-    DWORD R(CreateServiceW) (
+    DWORD RCreateServiceW(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hSCManager,
         [in, string, range(0, SC_MAX_NAME_LENGTH)] LPWSTR lpServiceName,
@@ -413,7 +411,7 @@
         [out] LPSC_RPC_HANDLE lpServiceHandle);
 
     /* Function 13 */
-    DWORD R(EnumDependentServicesW) (
+    DWORD REnumDependentServicesW(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [in] DWORD dwServiceState,
@@ -423,7 +421,7 @@
         [out] LPBOUNDED_DWORD_256K lpServicesReturned);
 
     /* Function 14 */
-    DWORD R(EnumServicesStatusW) (
+    DWORD REnumServicesStatusW(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hSCManager,
         [in] DWORD dwServiceType,
@@ -435,7 +433,7 @@
         [in, out, unique] LPBOUNDED_DWORD_256K lpResumeHandle);
 
     /* Function 15 */
-    DWORD R(OpenSCManagerW) (
+    DWORD ROpenSCManagerW(
         [in] handle_t BindingHandle,
         [in, string, unique, range(0, SC_MAX_COMPUTER_NAME_LENGTH)] LPWSTR
lpMachineName,
         [in, string, unique, range(0, SC_MAX_NAME_LENGTH)] LPWSTR lpDatabaseName,
@@ -443,7 +441,7 @@
         [out] LPSC_RPC_HANDLE lpScHandle);
 
     /* Function 16 */
-    DWORD R(OpenServiceW) (
+    DWORD ROpenServiceW(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hSCManager,
         [in, string, range(0, SC_MAX_NAME_LENGTH)] LPWSTR lpServiceName,
@@ -451,7 +449,7 @@
         [out] LPSC_RPC_HANDLE lpServiceHandle);
 
     /* Function 17 */
-    DWORD R(QueryServiceConfigW) (
+    DWORD RQueryServiceConfigW(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [out, unique, size_is(cbBufSize)] LPBYTE lpServiceConfig,
@@ -460,7 +458,7 @@
         [out] LPBOUNDED_DWORD_8K pcbBytesNeeded);
 
     /* Function 18 */
-    DWORD R(QueryServiceLockStatusW) (
+    DWORD RQueryServiceLockStatusW(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hSCManager,
         [out] LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus,
@@ -468,14 +466,14 @@
         [out] LPBOUNDED_DWORD_4K pcbBytesNeeded);
 
     /* Function 19 */
-    DWORD R(StartServiceW) (
+    DWORD RStartServiceW(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [in, range(0, SC_MAX_ARGUMENTS)] DWORD argc,
         [in, unique, size_is(argc)] LPSTRING_PTRSW argv);
 
     /* Function 20 */
-    DWORD R(GetServiceDisplayNameW) (
+    DWORD RGetServiceDisplayNameW(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hSCManager,
         [in, string, range(0, SC_MAX_NAME_LENGTH)] LPWSTR lpServiceName,
@@ -483,7 +481,7 @@
         [in, out] DWORD* lpcchBuffer);
 
     /* Function 21 */
-    DWORD R(GetServiceKeyNameW) (
+    DWORD RGetServiceKeyNameW(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hSCManager,
         [in, string, range(0, SC_MAX_NAME_LENGTH)] LPWSTR lpDisplayName,
@@ -491,7 +489,7 @@
         [in, out] DWORD* lpcchBuffer);
 
     /* Function 22 */
-    DWORD R(SetServiceBitsA) (
+    DWORD RSetServiceBitsA(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hServiceStatus,
         [in] DWORD dwServiceBits,
@@ -500,7 +498,7 @@
         [in, string, unique] LPSTR lpString);
 
     /* Function 23 */
-    DWORD R(ChangeServiceConfigA) (
+    DWORD RChangeServiceConfigA(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [in] DWORD dwServiceType,
@@ -517,7 +515,7 @@
         [in, string, unique, range(0, SC_MAX_NAME_LENGTH)] LPSTR lpDisplayName);
 
     /* Function 24 */
-    DWORD R(CreateServiceA) (
+    DWORD RCreateServiceA(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hSCManager,
         [in, string, range(0, SC_MAX_NAME_LENGTH)] LPSTR lpServiceName,
@@ -537,7 +535,7 @@
         [out] LPSC_RPC_HANDLE lpServiceHandle);
 
     /* Function 25 */
-    DWORD R(EnumDependentServicesA) (
+    DWORD REnumDependentServicesA(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [in] DWORD dwServiceState,
@@ -547,7 +545,7 @@
         [out] LPBOUNDED_DWORD_256K lpServicesReturned);
 
     /* Function 26 */
-    DWORD R(EnumServicesStatusA) (
+    DWORD REnumServicesStatusA(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hSCManager,
         [in] DWORD dwServiceType,
@@ -559,7 +557,7 @@
         [in, out, unique] LPBOUNDED_DWORD_256K lpResumeHandle);
 
     /* Function 27 */
-    DWORD R(OpenSCManagerA) (
+    DWORD ROpenSCManagerA(
         [in] handle_t BindingHandle,
         [in, string, unique, range(0, SC_MAX_COMPUTER_NAME_LENGTH)] LPSTR lpMachineName,
         [in, string, unique, range(0, SC_MAX_NAME_LENGTH)] LPSTR lpDatabaseName,
@@ -567,7 +565,7 @@
         [out] LPSC_RPC_HANDLE lpScHandle);
 
     /* Function 28 */
-    DWORD R(OpenServiceA) (
+    DWORD ROpenServiceA(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hSCManager,
         [in, string, range(0, SC_MAX_NAME_LENGTH)] LPSTR lpServiceName,
@@ -575,7 +573,7 @@
         [out] LPSC_RPC_HANDLE lpServiceHandle);
 
     /* Function 29 */
-    DWORD R(QueryServiceConfigA) (
+    DWORD RQueryServiceConfigA(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [out] LPQUERY_SERVICE_CONFIGA lpServiceConfig,
@@ -583,7 +581,7 @@
         [out] LPBOUNDED_DWORD_8K pcbBytesNeeded);
 
     /* Function 30 */
-    DWORD R(QueryServiceLockStatusA) (
+    DWORD RQueryServiceLockStatusA(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hSCManager,
         [out] LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus,
@@ -591,14 +589,14 @@
         [out] LPBOUNDED_DWORD_4K pcbBytesNeeded);
 
     /* Function 31 */
-    DWORD R(StartServiceA) (
+    DWORD RStartServiceA(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [in, range(0, SC_MAX_ARGUMENTS)] DWORD argc,
         [in, unique, size_is(argc)] LPSTRING_PTRSA argv);
 
     /* Function 32 */
-    DWORD R(GetServiceDisplayNameA) (
+    DWORD RGetServiceDisplayNameA(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hSCManager,
         [in, string, range(0, SC_MAX_NAME_LENGTH)] LPSTR lpServiceName,
@@ -606,7 +604,7 @@
         [in, out] LPBOUNDED_DWORD_4K lpcchBuffer);
 
     /* Function 33 */
-    DWORD R(GetServiceKeyNameA) (
+    DWORD RGetServiceKeyNameA(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hSCManager,
         [in, string, range(0, SC_MAX_NAME_LENGTH)] LPSTR lpDisplayName,
@@ -614,11 +612,11 @@
         [in, out] LPBOUNDED_DWORD_4K lpcchBuffer);
 
     /* Function 34 */
-    DWORD R(GetCurrentGroupStateW) (
+    DWORD RGetCurrentGroupStateW(
         [in] handle_t BindingHandle); /* FIXME */
 
     /* Function 35 */
-    DWORD R(EnumServiceGroupW) (
+    DWORD REnumServiceGroupW(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hSCManager,
         [in] DWORD dwServiceType,
@@ -631,19 +629,19 @@
         [in, string, unique, range(0, SC_MAX_NAME_LENGTH)] LPCWSTR pszGroupName);
 
     /* Function 36 */
-    DWORD R(ChangeServiceConfig2A) (
+    DWORD RChangeServiceConfig2A(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [in] SC_RPC_CONFIG_INFOA Info);
 
     /* Function 37 */
-    DWORD R(ChangeServiceConfig2W) (
+    DWORD RChangeServiceConfig2W(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [in] SC_RPC_CONFIG_INFOW Info);
 
     /* Function 38 */
-    DWORD R(QueryServiceConfig2A) (
+    DWORD RQueryServiceConfig2A(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [in] DWORD dwInfoLevel,
@@ -652,7 +650,7 @@
         [out] LPBOUNDED_DWORD_8K pcbBytesNeeded);
 
     /* Function 39 */
-    DWORD R(QueryServiceConfig2W) (
+    DWORD RQueryServiceConfig2W(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [in] DWORD dwInfoLevel,
@@ -661,7 +659,7 @@
         [out] LPBOUNDED_DWORD_8K pcbBytesNeeded);
 
     /* Function 40 */
-    DWORD R(QueryServiceStatusEx) (
+    DWORD RQueryServiceStatusEx(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [in] SC_STATUS_TYPE InfoLevel,
@@ -670,7 +668,7 @@
         [out] LPBOUNDED_DWORD_8K pcbBytesNeeded);
 
     /* Function 41 */
-    DWORD R(EnumServicesStatusExA) (
+    DWORD REnumServicesStatusExA(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hSCManager,
         [in] SC_ENUM_TYPE InfoLevel,
@@ -684,7 +682,7 @@
         [in, string, unique, range(0, SC_MAX_NAME_LENGTH)] LPCSTR pszGroupName);
 
     /* Function 42 */
-    DWORD R(EnumServicesStatusExW) (
+    DWORD REnumServicesStatusExW(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hSCManager,
         [in] SC_ENUM_TYPE InfoLevel,
@@ -698,11 +696,11 @@
         [in, string, unique, range(0, SC_MAX_NAME_LENGTH)] LPCWSTR pszGroupName);
 
     /* Function 43 */
-    DWORD R(SendTSMessage) (
+    DWORD RSendTSMessage(
         [in] handle_t BindingHandle); /* FIXME */
 
     /* Function 44 */
-    DWORD R(CreateServiceWOW64A) (
+    DWORD RCreateServiceWOW64A(
         [in] handle_t BindingHandle,
         [in, string, range(0, SC_MAX_NAME_LENGTH)] LPSTR lpServiceName,
         [in, string, unique, range(0, SC_MAX_NAME_LENGTH)] LPSTR lpDisplayName,
@@ -721,7 +719,7 @@
         [out] LPSC_RPC_HANDLE lpServiceHandle);
 
     /* Function 45 */
-    DWORD R(CreateServiceWOW64W) (
+    DWORD RCreateServiceWOW64W(
         [in] handle_t BindingHandle,
         [in, string, range(0, SC_MAX_NAME_LENGTH)] LPWSTR lpServiceName,
         [in, string, unique, range(0, SC_MAX_NAME_LENGTH)] LPWSTR lpDisplayName,
@@ -740,11 +738,11 @@
         [out] LPSC_RPC_HANDLE lpServiceHandle);
 
     /* Function 46 */
-    DWORD R(Function46) (
+    DWORD RQueryServiceTagInfo(
         [in] handle_t BindingHandle); /* FIXME */
 
     /* Function 47 */
-    DWORD R(NotifyServiceStatusChange) (
+    DWORD RNotifyServiceStatusChange(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [in] SC_RPC_NOTIFY_PARAMS NotifyParams,
@@ -754,19 +752,19 @@
         [out] LPSC_NOTIFY_RPC_HANDLE phNotify);
 
     /* Function 48 */
-    DWORD R(GetNotifyResults) (
+    DWORD RGetNotifyResults(
         [in] handle_t BindingHandle,
         [in] SC_NOTIFY_RPC_HANDLE hNotify,
         [out] PSC_RPC_NOTIFY_PARAMS_LIST *ppNotifyParams);
 
     /* Function 49 */
-    DWORD R(CloseNotifyHandle) (
+    DWORD RCloseNotifyHandle(
         [in] handle_t BindingHandle,
         [in, out] LPSC_NOTIFY_RPC_HANDLE phNotify,
         [out] PBOOL pfApcFired);
 
     /* Function 50 */
-    DWORD R(ControlServiceExA) (
+    DWORD RControlServiceExA(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [in] DWORD dwControl,
@@ -775,7 +773,7 @@
         [out, switch_is(dwInfoLevel)] PSC_RPC_SERVICE_CONTROL_IN_PARAMSA
pControlOutParams*/);
 
     /* Function 51 */
-    DWORD R(ControlServiceExW) (
+    DWORD RControlServiceExW(
         [in] handle_t BindingHandle,
         [in] SC_RPC_HANDLE hService,
         [in] DWORD dwControl,
@@ -784,18 +782,18 @@
         [out, switch_is(dwInfoLevel)] PSC_RPC_SERVICE_CONTROL_IN_PARAMSW
pControlOutParams*/);
 
     /* Function 52 */
-    DWORD R(Function52) (
+    DWORD RSendPnPMessage(
         [in] handle_t BindingHandle); /* FIXME */
 
     /* Function 53 */
-    DWORD R(Function53) (
+    DWORD RValidatePnPService(
         [in] handle_t BindingHandle); /* FIXME */
 
     /* Function 54 */
-    DWORD R(Function54) (
+    DWORD ROpenServiceStatusHandle(
         [in] handle_t BindingHandle); /* FIXME */
 
     /* Function 55 */
-    DWORD R(Function55) (
+    DWORD RFunction55(
         [in] handle_t BindingHandle); /* FIXME */
 }