librpc: use WERROR in the clusapi interface.

Guenther

Signed-off-by: Günther Deschner <gd@samba.org>
Reviewed-by: Stefan Metzmacher <metze@samba.org>

diff --git a/librpc/idl/clusapi.idl b/librpc/idl/clusapi.idl
index 50fe9d449955f55291a2a156e1be44e2cb9d64d6..9c54a451b6f21aa1f8484920e096bca06168a860 100644 (file)
--- a/librpc/idl/clusapi.idl
+++ b/librpc/idl/clusapi.idl
@@ -73,12 +73,12 @@ import "security.idl";
 #if 0
        HCLUSTER_RPC
        clusapi_OpenCluster(
-               [ out ] error_status_t *Status
+               [ out ] WERROR *Status
        );
 #else
        void
        clusapi_OpenCluster(
-               [ out ] error_status_t *Status,
+               [ out ] WERROR *Status,
                [ out ] HCLUSTER_RPC *Cluster
        );
 #endif
@@ -86,7 +86,7 @@ import "security.idl";
        /*****************/
        /* Function 0x01 */
 
-       error_status_t
+       WERROR
        clusapi_CloseCluster(
                [ in, out ] HCLUSTER_RPC *Cluster
        );
@@ -94,16 +94,16 @@ import "security.idl";
        /*****************/
        /* Function 0x02 */
 
-       error_status_t
+       WERROR
        clusapi_SetClusterName(
                [ in, string ] [charset(UTF16)] uint16 *NewClusterName,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x03 */
 
-       error_status_t
+       WERROR
        clusapi_GetClusterName(
                [ out, string ] [charset(UTF16)] uint16 **ClusterName,
                [ out, string ] [charset(UTF16)] uint16 **NodeName
@@ -112,7 +112,7 @@ import "security.idl";
        /*****************/
        /* Function 0x04 */
 
-       error_status_t
+       WERROR
        clusapi_GetClusterVersion(
                [ out ] uint16 *lpwMajorVersion,
                [ out ] uint16 *lpwMinorVersion,
@@ -124,23 +124,23 @@ import "security.idl";
        /*****************/
        /* Function 0x05 */
 
-       error_status_t
+       WERROR
        clusapi_GetQuorumResource(
                [ out, string ] [charset(UTF16)] uint16 **lpszResourceName,
                [ out, string ] [charset(UTF16)] uint16 **lpszDeviceName,
                [ out ] uint32 *pdwMaxQuorumLogSize,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x06 */
 
-       error_status_t
+       WERROR
        clusapi_SetQuorumResource(
                [ in ] HRES_RPC hResource,
                [ in, string ] [charset(UTF16)] uint16 *lpszDeviceName,
                [ in ] uint32    dwMaxQuorumLogSize,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        typedef [bitmap32bit] bitmap {
@@ -200,11 +200,11 @@ import "security.idl";
        /*****************/
        /* Function 0x07 */
 
-       error_status_t
+       WERROR
        clusapi_CreateEnum(
                [ in ] ClusterEnumType dwType,
                [ out ] ENUM_LIST **ReturnEnum,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
@@ -214,15 +214,15 @@ import "security.idl";
        HRES_RPC
        clusapi_OpenResource(
                [ in, string ] [charset(UTF16)] uint16 *lpszResourceName,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
        clusapi_OpenResource(
                [ in, string ] [charset(UTF16)] uint16 *lpszResourceName,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status,
                [ out ] HRES_RPC *hResource
        );
 #endif
@@ -236,8 +236,8 @@ import "security.idl";
                [ in, string ] [charset(UTF16)] uint16 *lpszResourceName,
                [ in, string ] [charset(UTF16)] uint16 *lpszResourceType,
                [ in ] uint32 dwFlags,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
@@ -246,24 +246,24 @@ import "security.idl";
                [ in, string ] [charset(UTF16)] uint16 *lpszResourceName,
                [ in, string ] [charset(UTF16)] uint16 *lpszResourceType,
                [ in ] uint32 dwFlags,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status,
                [ out ] HRES_RPC *hResource
        );
 #endif
        /*****************/
        /* Function 0x0A */
 
-       error_status_t
+       WERROR
        clusapi_DeleteResource(
                [ in ] HRES_RPC hResource,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x0B */
 
-       error_status_t
+       WERROR
        clusapi_CloseResource(
                [ in, out ] HRES_RPC *Resource
        );
@@ -271,163 +271,163 @@ import "security.idl";
        /*****************/
        /* Function 0x0C */
 
-       error_status_t
+       WERROR
        clusapi_GetResourceState(
                [ in ] HRES_RPC hResource,
                [ out ] uint32 *State,
                [ out, string ] [charset(UTF16)] uint16 **NodeName,
                [ out, string ] [charset(UTF16)] uint16 **GroupName,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x0D */
 
-       error_status_t
+       WERROR
        clusapi_SetResourceName(
                [ in ] HRES_RPC hResource,
                [ in, string ] [charset(UTF16)] uint16 *lpszResourceName,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x0E */
 
-       error_status_t
+       WERROR
        clusapi_GetResourceId(
                [ in ] HRES_RPC hResource,
                [ out, string ] [charset(UTF16)] uint16 **pGuid,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x0F */
 
-       error_status_t
+       WERROR
        clusapi_GetResourceType(
                [ in ] HRES_RPC hResource,
                [ out, string ] [charset(UTF16)] uint16 **lpszResourceType,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x10 */
 
-       error_status_t
+       WERROR
        clusapi_FailResource(
                [ in ] HRES_RPC hResource,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x11 */
 
-       error_status_t
+       WERROR
        clusapi_OnlineResource(
                [ in ] HRES_RPC hResource,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x12 */
 
-       error_status_t
+       WERROR
        clusapi_OfflineResource(
                [ in ] HRES_RPC hResource,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x13 */
 
-       error_status_t
+       WERROR
        clusapi_AddResourceDependency(
                [ in ] HRES_RPC hResource,
                [ in ] HRES_RPC hDependsOn,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x14 */
 
-       error_status_t
+       WERROR
        clusapi_RemoveResourceDependency(
                [ in ] HRES_RPC hResource,
                [ in ] HRES_RPC hDependsOn,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x15 */
 
-       error_status_t
+       WERROR
        clusapi_CanResourceBeDependent(
                [ in ] HRES_RPC hResource,
                [ in ] HRES_RPC hResourceDependent,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x16 */
 
-       error_status_t
+       WERROR
        clusapi_CreateResEnum(
                [ in ] HRES_RPC hResource,
                [ in ] uint32 dwType,
                [ out ] ENUM_LIST **ReturnEnum,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x17 */
 
-       error_status_t
+       WERROR
        clusapi_AddResourceNode(
                [ in ] HRES_RPC hResource,
                [ in ] HNODE_RPC hNode,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x18 */
 
-       error_status_t
+       WERROR
        clusapi_RemoveResourceNode(
                [ in ] HRES_RPC hResource,
                [ in ] HNODE_RPC hNode,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x19 */
 
-       error_status_t
+       WERROR
        clusapi_ChangeResourceGroup(
                [ in ] HRES_RPC hResource,
                [ in ] HGROUP_RPC hGroup,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x1A */
 
-       error_status_t
+       WERROR
        clusapi_CreateResourceType(
                [ in, string ] [charset(UTF16)] uint16 *lpszTypeName,
                [ in, string ] [charset(UTF16)] uint16 *lpszDisplayName,
                [ in, string ] [charset(UTF16)] uint16 *lpszDllName,
                [ in ] uint32 dwLooksAlive,
                [ in ] uint32 dwIsAlive,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x1B */
 
-       error_status_t
+       WERROR
        clusapi_DeleteResourceType(
                [ in, string ] [charset(UTF16)] uint16 *lpszTypeName,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
@@ -436,15 +436,15 @@ import "security.idl";
        HKEY_RPC
        clusapi_GetRootKey(
                [ in ] uint32 samDesired,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
        clusapi_GetRootKey(
                [ in ] uint32 samDesired,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status,
                [ out ] HKEY_RPC *phKey
        );
 #endif
@@ -459,8 +459,8 @@ import "security.idl";
                [ in ] uint32 samDesired,
                [ in, unique ] RPC_SECURITY_ATTRIBUTES *lpSecurityAttributes,
                [ out ] uint32 *lpdwDisposition,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
@@ -471,8 +471,8 @@ import "security.idl";
                [ in ] uint32 samDesired,
                [ in, unique ] RPC_SECURITY_ATTRIBUTES *lpSecurityAttributes,
                [ out ] uint32 *lpdwDisposition,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status,
                [ out ] HKEY_RPC *phKey
        );
 #endif
@@ -484,8 +484,8 @@ import "security.idl";
                [ in ] HKEY_RPC hKey,
                [ in, string ] [charset(UTF16)] uint16 *lpSubKey,
                [ in ] uint32 samDesired,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
@@ -493,50 +493,50 @@ import "security.idl";
                [ in ] HKEY_RPC hKey,
                [ in, string ] [charset(UTF16)] uint16 *lpSubKey,
                [ in ] uint32 samDesired,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status,
                [ out ] HKEY_RPC *phKey
        );
 #endif
        /*****************/
        /* Function 0x1F */
 
-       error_status_t
+       WERROR
        clusapi_EnumKey(
                [ in ] HKEY_RPC hKey,
                [ in ] uint32 dwIndex,
                [ out, string ] [charset(UTF16)] uint16 **KeyName,
                [ out ] NTTIME *lpftLastWriteTime,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x20 */
 
-       error_status_t
+       WERROR
        clusapi_SetValue(
                [ in ] HKEY_RPC hKey,
                [ in, string ] [charset(UTF16)] uint16 *lpValueName,
                [ in ] uint32 dwType,
                [ in, size_is(cbData) ] uint8 *lpData,
                [ in ] uint32 cbData,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x21 */
 
-       error_status_t
+       WERROR
        clusapi_DeleteValue(
                [ in ] HKEY_RPC hKey,
                [ in, string ] [charset(UTF16)] uint16 *lpValueName,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x22 */
 
-       error_status_t
+       WERROR
        clusapi_QueryValue(
                [ in ] HKEY_RPC hKey,
                [ in, string ] [charset(UTF16)] uint16 *lpValueName,
@@ -544,23 +544,23 @@ import "security.idl";
                [ out, size_is(cbData) ] uint8 *lpData,
                [ in ] uint32 cbData,
                [ out ] uint32 *lpcbRequired,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x23 */
 
-       error_status_t
+       WERROR
        clusapi_DeleteKey(
                [ in ] HKEY_RPC hKey,
                [ in, string ] [charset(UTF16)] uint16 *lpSubKey,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x24 */
 
-       error_status_t
+       WERROR
        clusapi_EnumValue(
                [ in ] HKEY_RPC hKey,
                [ in ] uint32 dwIndex,
@@ -569,13 +569,13 @@ import "security.idl";
                [ out, size_is(*lpcbData) ] uint8 *lpData,
                [ in, out ] uint32 *lpcbData,
                [ out ] uint32 *TotalSize,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x25 */
 
-       error_status_t
+       WERROR
        clusapi_CloseKey(
                [ in, out ] HKEY_RPC *pKey
        );
@@ -583,7 +583,7 @@ import "security.idl";
        /*****************/
        /* Function 0x26 */
 
-       error_status_t
+       WERROR
        clusapi_QueryInfoKey(
                [ in ] HKEY_RPC hKey,
                [ out ] uint32 *lpcSubKeys,
@@ -593,29 +593,29 @@ import "security.idl";
                [ out ] uint32 *lpcbMaxValueLen,
                [ out ] uint32 *lpcbSecurityDescriptor,
                [ out ] NTTIME *lpftLastWriteTime,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x27 */
 
-       error_status_t
+       WERROR
        clusapi_SetKeySecurity(
                [ in ] HKEY_RPC hKey,
                [ in ] uint32 SecurityInformation,
                [ in ] RPC_SECURITY_DESCRIPTOR *pRpcSecurityDescriptor,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x28 */
 
-       error_status_t
+       WERROR
        clusapi_GetKeySecurity(
                [ in ] HKEY_RPC hKey,
                [ in ] uint32 SecurityInformation,
                [ in, out ] RPC_SECURITY_DESCRIPTOR *pRpcSecurityDescriptor,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
@@ -624,15 +624,15 @@ import "security.idl";
        HGROUP_RPC
        clusapi_OpenGroup(
                [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
        clusapi_OpenGroup(
                [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status,
                [ out ] HGROUP_RPC *hGroup
        );
 #endif
@@ -642,32 +642,32 @@ import "security.idl";
        HGROUP_RPC
        clusapi_CreateGroup(
                [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
        clusapi_CreateGroup(
                [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status,
                [ out ] HGROUP_RPC *hGroup
        );
 #endif
        /*****************/
        /* Function 0x2B */
 
-       error_status_t
+       WERROR
        clusapi_DeleteGroup(
                [ in ] HGROUP_RPC Group,
                [ in ] boolean8 force,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x2C */
 
-       error_status_t
+       WERROR
        clusapi_CloseGroup(
                [ in, out ] HGROUP_RPC *Group
        );
@@ -675,101 +675,101 @@ import "security.idl";
        /*****************/
        /* Function 0x2D */
 
-       error_status_t
+       WERROR
        clusapi_GetGroupState(
                [ in ] HGROUP_RPC hGroup,
                [ out ] uint32 *State,
                [ out, string ] [charset(UTF16)] uint16 **NodeName,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x2E */
 
-       error_status_t
+       WERROR
        clusapi_SetGroupName(
                [ in ] HGROUP_RPC hGroup,
                [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x2F */
 
-       error_status_t
+       WERROR
        clusapi_GetGroupId(
                [ in ] HGROUP_RPC hGroup,
                [ out, string ] [charset(UTF16)] uint16 **pGuid,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x30 */
 
-       error_status_t
+       WERROR
        clusapi_GetNodeId(
                [ in ] HNODE_RPC hNode,
                [ out, string ] [charset(UTF16)] uint16 **pGuid,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x31 */
 
-       error_status_t
+       WERROR
        clusapi_OnlineGroup(
                [ in ] HGROUP_RPC hGroup,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x32 */
 
-       error_status_t
+       WERROR
        clusapi_OfflineGroup(
                [ in ] HGROUP_RPC hGroup,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x33 */
 
-       error_status_t
+       WERROR
        clusapi_MoveGroup(
                [ in ] HGROUP_RPC hGroup,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x34 */
 
-       error_status_t
+       WERROR
        clusapi_MoveGroupToNode(
                [ in ] HGROUP_RPC hGroup,
                [ in ] HNODE_RPC hNode,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x35 */
 
-       error_status_t
+       WERROR
        clusapi_CreateGroupResourceEnum(
                [ in ] HGROUP_RPC hGroup,
                [ in ] uint32 dwType,
                [ out ] ENUM_LIST **ReturnEnum,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x36 */
 
-       error_status_t
+       WERROR
        clusapi_SetGroupNodeList(
                [ in ] HGROUP_RPC hGroup,
                [ in, unique, size_is(cchListSize) ] uint16 *multiSzNodeList,
                [ in ] uint32 cchListSize,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
@@ -777,21 +777,21 @@ import "security.idl";
 #if 0
        HNOTIFY_RPC
        clusapi_CreateNotify(
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
        clusapi_CreateNotify(
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status,
                [ out ] HNOTIFY_RPC *hNotify
        );
 #endif
        /*****************/
        /* Function 0x38 */
 
-       error_status_t
+       WERROR
        clusapi_CloseNotify(
                [ in, out ] HNOTIFY_RPC *Notify
        );
@@ -799,117 +799,117 @@ import "security.idl";
        /*****************/
        /* Function 0x39 */
 
-       error_status_t
+       WERROR
        clusapi_AddNotifyCluster(
                [ in ] HNOTIFY_RPC hNotify,
                [ in ] HCLUSTER_RPC hCluster,
                [ in ] uint32 dwFilter,
                [ in ] uint32 dwNotifyKey,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x3A */
 
-       error_status_t
+       WERROR
        clusapi_AddNotifyNode(
                [ in ] HNOTIFY_RPC hNotify,
                [ in ] HNODE_RPC hNode,
                [ in ] uint32 dwFilter,
                [ in ] uint32 dwNotifyKey,
                [ out ] uint32 *dwStateSequence,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x3B */
 
-       error_status_t
+       WERROR
        clusapi_AddNotifyGroup(
                [ in ] HNOTIFY_RPC hNotify,
                [ in ] HGROUP_RPC hGroup,
                [ in ] uint32 dwFilter,
                [ in ] uint32 dwNotifyKey,
                [ out ] uint32 *dwStateSequence,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x3C */
 
-       error_status_t
+       WERROR
        clusapi_AddNotifyResource(
                [ in ] HNOTIFY_RPC hNotify,
                [ in ] HRES_RPC hResource,
                [ in ] uint32 dwFilter,
                [ in ] uint32 dwNotifyKey,
                [ out ] uint32 *dwStateSequence,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x3D */
 
-       error_status_t
+       WERROR
        clusapi_AddNotifyKey(
                [ in ] HNOTIFY_RPC hNotify,
                [ in ] HKEY_RPC hKey,
                [ in ] uint32 dwNotifyKey,
                [ in ] uint32 Filter,
                [ in ] boolean8 WatchSubTree,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x3E */
 
-       error_status_t
+       WERROR
        clusapi_ReAddNotifyNode(
                [ in ] HNOTIFY_RPC hNotify,
                [ in ] HNODE_RPC hNode,
                [ in ] uint32 dwFilter,
                [ in ] uint32 dwNotifyKey,
                [ in ] uint32 StateSequence,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x3F */
 
-       error_status_t
+       WERROR
        clusapi_ReAddNotifyGroup(
                [ in ] HNOTIFY_RPC hNotify,
                [ in ] HGROUP_RPC hGroup,
                [ in ] uint32 dwFilter,
                [ in ] uint32 dwNotifyKey,
                [ in ] uint32 StateSequence,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x40 */
 
-       error_status_t
+       WERROR
        clusapi_ReAddNotifyResource(
                [ in ] HNOTIFY_RPC hNotify,
                [ in ] HRES_RPC hResource,
                [ in ] uint32 dwFilter,
                [ in ] uint32 dwNotifyKey,
                [ in ] uint32 StateSequence,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x41 */
 
-       error_status_t
+       WERROR
        clusapi_GetNotify(
                [ in ] HNOTIFY_RPC hNotify,
                [ out ] uint32 *dwNotifyKey,
                [ out ] uint32 *dwFilter,
                [ out ] uint32 *dwStateSequence,
                [ out, string ] [charset(UTF16)] uint16 **Name,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
@@ -918,22 +918,22 @@ import "security.idl";
        HNODE_RPC
        clusapi_OpenNode(
                [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
        clusapi_OpenNode(
                [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status,
                [ out ] HNODE_RPC *hNode
        );
 #endif
        /*****************/
        /* Function 0x43 */
 
-       error_status_t
+       WERROR
        clusapi_CloseNode(
                [ in, out ] HNODE_RPC *Node
        );
@@ -941,44 +941,44 @@ import "security.idl";
        /*****************/
        /* Function 0x44 */
 
-       error_status_t
+       WERROR
        clusapi_GetNodeState(
                [ in ] HNODE_RPC hNode,
                [ out ] uint32 *State,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x45 */
 
-       error_status_t
+       WERROR
        clusapi_PauseNode(
                [ in ] HNODE_RPC hNode,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x46 */
 
-       error_status_t
+       WERROR
        clusapi_ResumeNode(
                [ in ] HNODE_RPC hNode,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x47 */
 
-       error_status_t
+       WERROR
        clusapi_EvictNode(
                [ in ] HNODE_RPC hNode,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x48 */
 
-       error_status_t
+       WERROR
        clusapi_NodeResourceControl(
                [ in ] HRES_RPC hResource,
                [ in ] HNODE_RPC hNode,
@@ -990,13 +990,13 @@ import "security.idl";
                [ in ] uint32 nOutBufferSize,
                [ out ] uint32 *lpBytesReturned,
                [ out ] uint32 *lpcbRequired,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x49 */
 
-       error_status_t
+       WERROR
        clusapi_ResourceControl(
                [ in ] HRES_RPC hResource,
                [ in ] uint32 dwControlCode,
@@ -1007,13 +1007,13 @@ import "security.idl";
                [ in ] uint32 nOutBufferSize,
                [ out ] uint32 *lpBytesReturned,
                [ out ] uint32 *lpcbRequired,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x4A */
 
-       error_status_t
+       WERROR
        clusapi_NodeResourceTypeControl(
                [ in ] HCLUSTER_RPC hCluster,
                [ in, string ] [charset(UTF16)] uint16 *lpszResourceTypeName,
@@ -1026,13 +1026,13 @@ import "security.idl";
                [ in ] uint32 nOutBufferSize,
                [ out ] uint32 *lpBytesReturned,
                [ out ] uint32 *lpcbRequired,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x4B */
 
-       error_status_t
+       WERROR
        clusapi_ResourceTypeControl(
                [ in ] HCLUSTER_RPC hCluster,
                [ in, string ] [charset(UTF16)] uint16 *lpszResourceTypeName,
@@ -1044,13 +1044,13 @@ import "security.idl";
                [ in ] uint32 nOutBufferSize,
                [ out ] uint32 *lpBytesReturned,
                [ out ] uint32 *lpcbRequired,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x4C */
 
-       error_status_t
+       WERROR
        clusapi_NodeGroupControl(
                [ in ] HGROUP_RPC hGroup,
                [ in ] HNODE_RPC hNode,
@@ -1062,13 +1062,13 @@ import "security.idl";
                [ in ] uint32 nOutBufferSize,
                [ out ] uint32 *lpBytesReturned,
                [ out ] uint32 *lpcbRequired,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x4D */
 
-       error_status_t
+       WERROR
        clusapi_GroupControl(
                [ in ] HGROUP_RPC hGroup,
                [ in ] uint32 dwControlCode,
@@ -1079,13 +1079,13 @@ import "security.idl";
                [ in ] uint32 nOutBufferSize,
                [ out ] uint32 *lpBytesReturned,
                [ out ] uint32 *lpcbRequired,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x4E */
 
-       error_status_t
+       WERROR
        clusapi_NodeNodeControl(
                [ in ] HNODE_RPC hNode,
                [ in ] HNODE_RPC hHostNode,
@@ -1097,13 +1097,13 @@ import "security.idl";
                [ in ] uint32 nOutBufferSize,
                [ out ] uint32 *lpBytesReturned,
                [ out ] uint32 *lpcbRequired,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x4F */
 
-       error_status_t
+       WERROR
        clusapi_NodeControl(
                [ in ] HNODE_RPC hNode,
                [ in ] uint32 dwControlCode,
@@ -1114,13 +1114,13 @@ import "security.idl";
                [ in ] uint32 nOutBufferSize,
                [ out ] uint32 *lpBytesReturned,
                [ out ] uint32 *lpcbRequired,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x50 */
 
-       error_status_t
+       WERROR
        Opnum80NotUsedOnWire(void);
 
        /*****************/
@@ -1129,22 +1129,22 @@ import "security.idl";
        HNETWORK_RPC
        clusapi_OpenNetwork(
                [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
        clusapi_OpenNetwork(
                [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status,
                [ out ] HNETWORK_RPC *hNetwork
        );
 #endif
        /*****************/
        /* Function 0x52 */
 
-       error_status_t
+       WERROR
        clusapi_CloseNetwork(
                [ in, out ] HNETWORK_RPC *Network
        );
@@ -1152,58 +1152,58 @@ import "security.idl";
        /*****************/
        /* Function 0x53 */
 
-       error_status_t
+       WERROR
        clusapi_GetNetworkState(
                [ in ] HNETWORK_RPC hNetwork,
                [ out ] uint32 *State,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x54 */
 
-       error_status_t
+       WERROR
        clusapi_SetNetworkName(
                [ in ] HNETWORK_RPC hNetwork,
                [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x55 */
 
-       error_status_t
+       WERROR
        clusapi_CreateNetworkEnum(
                [ in ] HNETWORK_RPC hNetwork,
                [ in ] uint32 dwType,
                [ out ] ENUM_LIST **ReturnEnum,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x56 */
 
-       error_status_t
+       WERROR
        clusapi_GetNetworkId(
                [ in ] HNETWORK_RPC hNetwork,
                [ out, string ] [charset(UTF16)] uint16 **pGuid,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x57 */
 
-       error_status_t
+       WERROR
        clusapi_SetNetworkPriorityOrder(
                [ in, range(0, 1000)] uint32 NetworkCount,
                [ in, string, size_is(NetworkCount) ] [charset(UTF16)] uint16 NetworkIdList[*],
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x58 */
 
-       error_status_t
+       WERROR
        clusapi_NodeNetworkControl(
                [ in ] HNETWORK_RPC hNetwork,
                [ in ] HNODE_RPC hNode,
@@ -1215,13 +1215,13 @@ import "security.idl";
                [ in ] uint32 nOutBufferSize,
                [ out ] uint32 *lpBytesReturned,
                [ out ] uint32 *lpcbRequired,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x59 */
 
-       error_status_t
+       WERROR
        clusapi_NetworkControl(
                [ in ] HNETWORK_RPC hNetwork,
                [ in ] uint32 dwControlCode,
@@ -1232,33 +1232,33 @@ import "security.idl";
                [ in ] uint32 nOutBufferSize,
                [ out ] uint32 *lpBytesReturned,
                [ out ] uint32 *lpcbRequired,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x5A */
 
-       error_status_t
+       WERROR
        clusapi_AddNotifyNetwork(
                [ in ] HNOTIFY_RPC hNotify,
                [ in ] HNETWORK_RPC hNetwork,
                [ in ] uint32 dwFilter,
                [ in ] uint32 dwNotifyKey,
                [ out ] uint32 *dwStateSequence,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x5B */
 
-       error_status_t
+       WERROR
        clusapi_ReAddNotifyNetwork(
                [ in ] HNOTIFY_RPC hNotify,
                [ in ] HNETWORK_RPC hNetwork,
                [ in ] uint32 dwFilter,
                [ in ] uint32 dwNotifyKey,
                [ in ] uint32 StateSequence,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
@@ -1267,22 +1267,22 @@ import "security.idl";
        HNETINTERFACE_RPC
        clusapi_OpenNetInterface(
                [ in, string ] [charset(UTF16)] uint16 *lpszNetInterfaceName,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
        clusapi_OpenNetInterface(
                [ in, string ] [charset(UTF16)] uint16 *lpszNetInterfaceName,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status,
                [ out ] HNETINTERFACE_RPC *hNetInterface
        );
 #endif
        /*****************/
        /* Function 0x5D */
 
-       error_status_t
+       WERROR
        clusapi_CloseNetInterface(
                [ in, out ] HNETINTERFACE_RPC *NetInterface
        );
@@ -1290,38 +1290,38 @@ import "security.idl";
        /*****************/
        /* Function 0x5E */
 
-       error_status_t
+       WERROR
        clusapi_GetNetInterfaceState(
                [ in ] HNETINTERFACE_RPC hNetInterface,
                [ out ] uint32 *State,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x5F */
 
-       error_status_t
+       WERROR
        clusapi_GetNetInterface(
                [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
                [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
                [ out, string ] [charset(UTF16)] uint16 **lppszInterfaceName,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x60 */
 
-       error_status_t
+       WERROR
        clusapi_GetNetInterfaceId(
                [ in ] HNETINTERFACE_RPC hNetInterface,
                [ out, string ] [charset(UTF16)] uint16 **pGuid,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x61 */
 
-       error_status_t
+       WERROR
        clusapi_NodeNetInterfaceControl(
                [ in ] HNETINTERFACE_RPC hNetInterface,
                [ in ] HNODE_RPC hNode,
@@ -1333,13 +1333,13 @@ import "security.idl";
                [ in ] uint32 nOutBufferSize,
                [ out ] uint32 *lpBytesReturned,
                [ out ] uint32 *lpcbRequired,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x62 */
 
-       error_status_t
+       WERROR
        clusapi_NetInterfaceControl(
                [ in ] HNETINTERFACE_RPC hNetInterface,
                [ in ] uint32 dwControlCode,
@@ -1350,50 +1350,50 @@ import "security.idl";
                [ in ] uint32 nOutBufferSize,
                [ out ] uint32 *lpBytesReturned,
                [ out ] uint32 *lpcbRequired,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x63 */
 
-       error_status_t
+       WERROR
        clusapi_AddNotifyNetInterface(
                [ in ] HNOTIFY_RPC hNotify,
                [ in ] HNETINTERFACE_RPC hNetInterface,
                [ in ] uint32 dwFilter,
                [ in ] uint32 dwNotifyKey,
                [ out ] uint32 *dwStateSequence,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x64 */
 
-       error_status_t
+       WERROR
        clusapi_ReAddNotifyNetInterface(
                [ in ] HNOTIFY_RPC hNotify,
                [ in ] HNETINTERFACE_RPC hNetInterface,
                [ in ] uint32 dwFilter,
                [ in ] uint32 dwNotifyKey,
                [ in ] uint32 StateSequence,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x65 */
 
-       error_status_t
+       WERROR
        clusapi_CreateNodeEnum(
                [ in ] HNODE_RPC hNode,
                [ in ] uint32 dwType,
                [ out ] ENUM_LIST **ReturnEnum,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x66 */
 
-       error_status_t
+       WERROR
        clusapi_GetClusterVersion2(
                [ out ] uint16 *lpwMajorVersion,
                [ out ] uint16 *lpwMinorVersion,
@@ -1401,33 +1401,33 @@ import "security.idl";
                [ out, string ] [charset(UTF16)] uint16 **lpszVendorId,
                [ out, string ] [charset(UTF16)] uint16 **lpszCSDVersion,
                [ out ] CLUSTER_OPERATIONAL_VERSION_INFO **ppClusterOpVerInfo,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x67 */
 
-       error_status_t
+       WERROR
        clusapi_CreateResTypeEnum(
                [ in, string ] [charset(UTF16)] uint16 *lpszTypeName,
                [ in ] uint32 dwType,
                [ out ] ENUM_LIST **ReturnEnum,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x68 */
 
-       error_status_t
+       WERROR
        clusapi_BackupClusterDatabase(
                [ in, string ] [charset(UTF16)] uint16 *lpszPathName,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x69 */
 
-       error_status_t
+       WERROR
        clusapi_NodeClusterControl(
                [ in ] HCLUSTER_RPC hCluster,
                [ in ] HNODE_RPC hHostNode,
@@ -1439,13 +1439,13 @@ import "security.idl";
                [ in ] uint32 nOutBufferSize,
                [ out ] uint32 *lpBytesReturned,
                [ out ] uint32 *lpcbRequired,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x6A */
 
-       error_status_t
+       WERROR
        clusapi_ClusterControl(
                [ in ] HCLUSTER_RPC hCluster,
                [ in ] uint32 dwControlCode,
@@ -1456,13 +1456,13 @@ import "security.idl";
                [ in ] uint32 nOutBufferSize,
                [ out ] uint32 *lpBytesReturned,
                [ out ] uint32 *lpcbRequired,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x6B */
 
-       error_status_t
+       WERROR
        clusapi_UnblockGetNotifyCall(
                [ in ] HNOTIFY_RPC hNotify
        );
@@ -1470,7 +1470,7 @@ import "security.idl";
        /*****************/
        /* Function 0x6C */
 
-       error_status_t
+       WERROR
        clusapi_SetServiceAccountPassword(
                [ in, string ] [charset(UTF16)] uint16 *lpszNewPassword,
                [ in ]  IDL_CLUSTER_SET_PASSWORD_FLAGS dwFlags,
@@ -1484,65 +1484,65 @@ import "security.idl";
        /*****************/
        /* Function 0x6D */
 
-       error_status_t
+       WERROR
        clusapi_SetResourceDependencyExpression(
                [ in ] HRES_RPC hResource,
                [ in, string, unique ] [charset(UTF16)] uint16 *lpszDependencyExpression,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x6E */
 
-       error_status_t
+       WERROR
        clusapi_GetResourceDependencyExpression(
                [ in ] HRES_RPC hResource,
                [ out, string ] [charset(UTF16)] uint16 **lpszDependencyExpression,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x6F */
 
-       error_status_t
+       WERROR
        Opnum111NotUsedOnWire(void);
 
        /*****************/
        /* Function 0x70 */
 
-       error_status_t
+       WERROR
        clusapi_GetResourceNetworkName(
                [ in ] HRES_RPC hResource,
                [ out, string ] [charset(UTF16)] uint16 **lpszName,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x71 */
 
-       error_status_t
+       WERROR
        clusapi_ExecuteBatch(
                [ in ] HKEY_RPC hKey,
                [ in ] uint32 cbData,
                [ in, size_is(cbData)] uint8 *lpData,
                [ out ] int *pdwFailedCommand,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x72 */
 
-       error_status_t
+       WERROR
        clusapi_CreateBatchPort(
                [ in ] HKEY_RPC hKey,
                [ out ] HBATCH_PORT_RPC *phBatchPort,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x73 */
 
-       error_status_t
+       WERROR
        clusapi_GetBatchNotification(
                 [ in ] HBATCH_PORT_RPC hBatchNotify,
                 [ out ] uint32 *cbData,
@@ -1552,7 +1552,7 @@ import "security.idl";
        /*****************/
        /* Function 0x74 */
 
-       error_status_t
+       WERROR
        clusapi_CloseBatchPort(
                 [ in, out ] HBATCH_PORT_RPC *phBatchPort
        );
@@ -1564,14 +1564,14 @@ import "security.idl";
        clusapi_OpenClusterEx(
                [ in ] uint32 dwDesiredAccess,
                [ out ] uint32 *lpdwGrantedAccess,
-               [ out ] error_status_t *Status
+               [ out ] WERROR *Status
        );
 #else
        void
        clusapi_OpenClusterEx(
                [ in ] uint32 dwDesiredAccess,
                [ out ] uint32 *lpdwGrantedAccess,
-               [ out ] error_status_t *Status,
+               [ out ] WERROR *Status,
                [ out ] HCLUSTER_RPC *hCluster
        );
 #endif
@@ -1584,8 +1584,8 @@ import "security.idl";
                [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
                [ in ] uint32 dwDesiredAccess,
                [ out ] uint32 *lpdwGrantedAccess,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
@@ -1593,8 +1593,8 @@ import "security.idl";
                [ in, string ] [charset(UTF16)] uint16 *lpszNodeName,
                [ in ] uint32 dwDesiredAccess,
                [ out ] uint32 *lpdwGrantedAccess,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status,
                [ out ] HNODE_RPC *hNode
        );
 #endif
@@ -1606,8 +1606,8 @@ import "security.idl";
                [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
                [ in ] uint32 dwDesiredAccess,
                [ out ] uint32 *lpdwGrantedAccess,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
@@ -1615,8 +1615,8 @@ import "security.idl";
                [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
                [ in ] uint32 dwDesiredAccess,
                [ out ] uint32 *lpdwGrantedAccess,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status,
                [ out ] HGROUP_RPC *hGroup
        );
 #endif
@@ -1628,8 +1628,8 @@ import "security.idl";
                [ in, string ] [charset(UTF16)] uint16 *lpszResourceName,
                [ in ] uint32 dwDesiredAccess,
                [ out ] uint32 *lpdwGrantedAccess,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
@@ -1637,8 +1637,8 @@ import "security.idl";
                [ in, string ] [charset(UTF16)] uint16 *lpszResourceName,
                [ in ] uint32 dwDesiredAccess,
                [ out ] uint32 *lpdwGrantedAccess,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status,
                [ out ] HRES_RPC *hResource
        );
 #endif
@@ -1650,8 +1650,8 @@ import "security.idl";
                [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
                [ in ] uint32 dwDesiredAccess,
                [ out ] uint32 *lpdwGrantedAccess,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
@@ -1659,8 +1659,8 @@ import "security.idl";
                [ in, string ] [charset(UTF16)] uint16 *lpszNetworkName,
                [ in ] uint32 dwDesiredAccess,
                [ out ] uint32 *lpdwGrantedAccess,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status,
                [ out ] HNETWORK_RPC *hNetwork
        );
 #endif
@@ -1672,8 +1672,8 @@ import "security.idl";
                [ in, string ] [charset(UTF16)] uint16 *lpszNetInterfaceName,
                [ in ] uint32 dwDesiredAccess,
                [ out ] uint32 *lpdwGrantedAccess,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
@@ -1681,78 +1681,78 @@ import "security.idl";
                [ in, string ] [charset(UTF16)] uint16 *lpszNetInterfaceName,
                [ in ] uint32 dwDesiredAccess,
                [ out ] uint32 *lpdwGrantedAccess,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status,
                [ out ] HNETINTERFACE_RPC *hNetInterface
        );
 #endif
        /*****************/
        /* Function 0x7B */
 
-       error_status_t
+       WERROR
        clusapi_ChangeCsvState(
                [ in ] HRES_RPC hResource,
                [ in ] uint32 dwState,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x7C */
 
-       error_status_t
+       WERROR
        clusapi_CreateNodeEnumEx(
                [in] HNODE_RPC hNode,
                [in] uint32 dwType,
                [in] uint32 dwOptions,
                [out] ENUM_LIST **ReturnIdEnum,
                [out] ENUM_LIST **ReturnNameEnum,
-               [out] error_status_t* rpc_status
+               [out] WERROR* rpc_status
        );
 
        /*****************/
        /* Function 0x7D */
 
-       error_status_t
+       WERROR
        clusapi_CreateEnumEx(
                [in] HCLUSTER_RPC hCluster,
                [in] uint32 dwType,
                [in] uint32 dwOptions,
                [out] ENUM_LIST **ReturnIdEnum,
                [out] ENUM_LIST **ReturnNameEnum,
-               [out] error_status_t* rpc_status
+               [out] WERROR* rpc_status
        );
 
        /*****************/
        /* Function 0x7E */
 
-       error_status_t
+       WERROR
        clusapi_PauseNodeEx(
                [ in ] HNODE_RPC hNode,
                [ in ] boolean8 bDrainNode,
                [ in ] uint32 dwPauseFlags,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x7F */
 
-       error_status_t
+       WERROR
        clusapi_PauseNodeWithDrainTarget(
                [ in ] HNODE_RPC hNode,
                [ in ] uint32 dwPauseFlags,
                [ in ] HNODE_RPC hNodeDrainTarget,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x80 */
 
-       error_status_t
+       WERROR
        clusapi_ResumeNodeEx(
                [ in ] HNODE_RPC hNode,
                [ in ] uint32 dwResumeFailbackType,
                [ in ] uint32 dwResumeFlagsReserved,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
@@ -1762,100 +1762,100 @@ import "security.idl";
        clusapi_CreateGroupEx(
                [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
                [ in, unique ] CLUSTER_CREATE_GROUP_INFO_RPC *pGroupInfo,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
        clusapi_CreateGroupEx(
                [ in, string ] [charset(UTF16)] uint16 *lpszGroupName,
                [ in, unique ] CLUSTER_CREATE_GROUP_INFO_RPC *pGroupInfo,
-               [ out ] error_status_t *Status,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *Status,
+               [ out ] WERROR *rpc_status,
                [ out ] HGROUP_RPC *hGroup
        );
 #endif
        /*****************/
        /* Function 0x82 */
 
-       error_status_t
+       WERROR
        clusapi_OnlineGroupEx(
                [ in ] HGROUP_RPC hGroup,
                [ in ] uint32     dwOnlineFlags,
                [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
                [ in ] uint32     cbInBufferSize,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x83 */
 
-       error_status_t
+       WERROR
        clusapi_OfflineGroupEx(
                [ in ] HGROUP_RPC hGroup,
                [ in ] uint32     dwOfflineFlags,
                [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
                [ in ] uint32     cbInBufferSize,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x84 */
 
-       error_status_t
+       WERROR
        clusapi_MoveGroupEx(
                [ in ] HGROUP_RPC hGroup,
                [ in ] uint32           dwMoveFlags,
                [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
                [ in ] uint32           cbInBufferSize,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x85 */
 
-       error_status_t
+       WERROR
        clusapi_MoveGroupToNodeEx(
                [ in ] HGROUP_RPC hGroup,
                [ in ] HNODE_RPC  hNode,
                [ in ] uint32           dwMoveFlags,
                [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
                [ in ] uint32           cbInBufferSize,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x86 */
 
-       error_status_t
+       WERROR
        clusapi_CancelClusterGroupOperation(
                [ in ] HGROUP_RPC       hGroup,
                [ in ] uint32            dwCancelFlags,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x87 */
 
-       error_status_t
+       WERROR
        clusapi_OnlineResourceEx(
                [ in ] HRES_RPC hResource,
                [ in ] uint32     dwOnlineFlags,
                [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
                [ in ] uint32     cbInBufferSize,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x88 */
 
-       error_status_t
+       WERROR
        clusapi_OfflineResourceEx(
                [ in ] HRES_RPC hResource,
                [ in ] uint32     dwOfflineFlags,
                [ in, size_is(cbInBufferSize) ] uint8* lpInBuffer,
                [ in ] uint32     cbInBufferSize,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
 #define HGENERIC_RPC policy_handle
@@ -1892,14 +1892,14 @@ import "security.idl";
 #if 0
        HNOTIFY_RPC
        clusapi_CreateNotifyV2(
-               [ out ] error_status_t *rpc_error,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_error,
+               [ out ] WERROR *rpc_status
        );
 #else
        void
        clusapi_CreateNotifyV2(
-               [ out ] error_status_t *rpc_error,
-               [ out ] error_status_t *rpc_status,
+               [ out ] WERROR *rpc_error,
+               [ out ] WERROR *rpc_status,
                [ out ] HNOTIFY_RPC *hNotify
        );
 
@@ -1907,7 +1907,7 @@ import "security.idl";
        /*****************/
        /* Function 0x8A */
 
-       error_status_t
+       WERROR
        clusapi_AddNotifyV2(
                [ in ] HNOTIFY_RPC hNotify,
                [ in ] HGENERIC_RPC hObject,
@@ -1915,13 +1915,13 @@ import "security.idl";
                [ in ] uint32 dwNotifyKey,
                [ in ] uint32 dwVersion,
                [ in ] boolean8 isTargetedAtObject,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x8B */
 
-       error_status_t
+       WERROR
        clusapi_GetNotifyV2(
                [ in ] HNOTIFY_RPC hNotify,
                [ out, size_is(,*dwNumNotifications) ] NOTIFICATION_RPC **Notifications,
@@ -1931,12 +1931,12 @@ import "security.idl";
        /*****************/
        /* Function 0x8C */
 
-       error_status_t
+       WERROR
        clusapi_QueryAllValues(
                [ in ] HKEY_RPC hKey,
                [ out ] uint32 *pcbData,
                [ out, size_is(1, *pcbData) ] uint8 ** ppData,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        typedef struct {
@@ -1947,7 +1947,7 @@ import "security.idl";
        /*****************/
        /* Function 0x8D */
 
-       error_status_t
+       WERROR
        clusapi_StmFindDisk(
                [ in ] HCLUSTER_RPC hCluster,
                [ in ] uint32 dwFlags,
@@ -1955,7 +1955,7 @@ import "security.idl";
                [ in, size_is(uniqueIdSize), unique ] uint8 *pUniqueId,
                [ in ] uint32 uniqueIdSize,
                [ out, ref, string ] [charset(UTF16)] uint16 **ppszDeviceName,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        typedef struct{
@@ -1973,7 +1973,7 @@ import "security.idl";
        /*****************/
        /* Function 0x8E */
 
-       error_status_t
+       WERROR
        clusapi_ClusterMrr(
                [ in ] HCLUSTER_RPC hCluster,
                [ in ] boolean8 fExcludeSelf,
@@ -1984,13 +1984,13 @@ import "security.idl";
                [ in ] uint32 inSize,
                [ in, unique, size_is(inSize) ] uint8 *pInData,
                [ out, ref, size_is(1, 1) ] CLUSTER_MRR_RESPONSE **ppInfo,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x8F */
 
-       error_status_t
+       WERROR
        clusapi_CreateGroupEnum(
                [ in ] HCLUSTER_RPC hCluster,
                [ in, unique, size_is(cbProperties)] uint8* pProperties,
@@ -1998,13 +1998,13 @@ import "security.idl";
                [ in, unique, size_is(cbRoProperties)] uint8* pRoProperties,
                [ in ] uint32 cbRoProperties,
                [ out ] GROUP_ENUM_LIST **ppResultList,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x90 */
 
-       error_status_t
+       WERROR
        clusapi_CreateResourceEnum(
                [ in ] HCLUSTER_RPC hCluster,
                [ in, unique, size_is(cbProperties)] uint8* pProperties,
@@ -2012,30 +2012,30 @@ import "security.idl";
                [ in, unique, size_is(cbRoProperties)] uint8* pRoProperties,
                [ in ] uint32 cbRoProperties,
                [ out ] RESOURCE_ENUM_LIST **ppResultList,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x91 */
 
-       error_status_t
+       WERROR
        clusapi_ExecuteReadBatch(
                [ in ] HKEY_RPC hKey,
                [ in ] uint32 cbInData,
                [ in, size_is(cbInData)] uint8 *lpInData,
                [ out ] uint32 *cbOutData,
                [ out, size_is(,*cbOutData) ] uint8 ** lpOutData,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        /*****************/
        /* Function 0x92 */
 
-       error_status_t
+       WERROR
        clusapi_RestartResource(
                [ in ] HRES_RPC hResource,
                [ in ] uint32 dwFlags,
-               [ out ] error_status_t *rpc_status
+               [ out ] WERROR *rpc_status
        );
 
        typedef struct {
@@ -2047,7 +2047,7 @@ import "security.idl";
        /*****************/
        /* Function 0x93 */
 
-       error_status_t
+       WERROR
        clusapi_GetNotifyAsync(
                [ in ] HNOTIFY_RPC hNotify,
                [ out, size_is(,*dwNumNotifications) ] NOTIFICATION_DATA_ASYNC_RPC **Notifications,

diff --git a/source3/rpcclient/cmd_clusapi.c b/source3/rpcclient/cmd_clusapi.c
index 0f6f469b3c4d262c8fa409b7795debc013290211..280b5a070d2d11c2bc4b6392ec45326546ed8405 100644 (file)
--- a/source3/rpcclient/cmd_clusapi.c
+++ b/source3/rpcclient/cmd_clusapi.c
@@ -29,7 +29,7 @@ static WERROR cmd_clusapi_open_cluster(struct rpc_pipe_client *cli,
 {
        struct dcerpc_binding_handle *b = cli->binding_handle;
        NTSTATUS status;
-       uint32_t error;
+       WERROR error;
        struct policy_handle Cluster;
 
        status = dcerpc_clusapi_OpenCluster(b, mem_ctx,
@@ -39,9 +39,9 @@ static WERROR cmd_clusapi_open_cluster(struct rpc_pipe_client *cli,
                return ntstatus_to_werror(status);
        }
 
-       if (error) {
-               printf("error: %d\n", error);
-               return W_ERROR(error);
+       if (!W_ERROR_IS_OK(error)) {
+               printf("error: %s\n", win_errstr(error));
+               return error;
        }
 
        printf("successfully opened cluster\n");
@@ -53,9 +53,9 @@ static WERROR cmd_clusapi_open_cluster(struct rpc_pipe_client *cli,
                return ntstatus_to_werror(status);
        }
 
-       if (error) {
-               printf("error: %d\n", error);
-               return W_ERROR(error);
+       if (!W_ERROR_IS_OK(error)) {
+               printf("error: %s\n", win_errstr(error));
+               return error;
        }
 
        printf("successfully closed cluster\n");
@@ -70,7 +70,7 @@ static WERROR cmd_clusapi_get_cluster_name(struct rpc_pipe_client *cli,
 {
        struct dcerpc_binding_handle *b = cli->binding_handle;
        NTSTATUS status;
-       uint32_t error;
+       WERROR error;
        const char *ClusterName;
        const char *NodeName;
 
@@ -82,9 +82,9 @@ static WERROR cmd_clusapi_get_cluster_name(struct rpc_pipe_client *cli,
                return ntstatus_to_werror(status);
        }
 
-       if (error) {
-               printf("error: %d\n", error);
-               return W_ERROR(error);
+       if (!W_ERROR_IS_OK(error)) {
+               printf("error: %s\n", win_errstr(error));
+               return error;
        }
 
        printf("ClusterName: %s\n", ClusterName);
@@ -100,7 +100,7 @@ static WERROR cmd_clusapi_get_cluster_version(struct rpc_pipe_client *cli,
 {
        struct dcerpc_binding_handle *b = cli->binding_handle;
        NTSTATUS status;
-       uint32_t error;
+       WERROR error;
        uint16_t lpwMajorVersion;
        uint16_t lpwMinorVersion;
        uint16_t lpwBuildNumber;
@@ -118,9 +118,9 @@ static WERROR cmd_clusapi_get_cluster_version(struct rpc_pipe_client *cli,
                return ntstatus_to_werror(status);
        }
 
-       if (error) {
-               printf("error: %d\n", error);
-               return W_ERROR(error);
+       if (!W_ERROR_IS_OK(error)) {
+               printf("error: %s\n", win_errstr(error));
+               return error;
        }
 
        printf("lpwMajorVersion: %d\n", lpwMajorVersion);
@@ -139,11 +139,11 @@ static WERROR cmd_clusapi_get_quorum_resource(struct rpc_pipe_client *cli,
 {
        struct dcerpc_binding_handle *b = cli->binding_handle;
        NTSTATUS status;
-       uint32_t error;
+       WERROR error;
        const char *lpszResourceName;
        const char *lpszDeviceName;
        uint32_t pdwMaxQuorumLogSize;
-       uint32_t rpc_status;
+       WERROR rpc_status;
 
        status = dcerpc_clusapi_GetQuorumResource(b, mem_ctx,
                                                  &lpszResourceName,
@@ -155,15 +155,15 @@ static WERROR cmd_clusapi_get_quorum_resource(struct rpc_pipe_client *cli,
                return ntstatus_to_werror(status);
        }
 
-       if (error) {
-               printf("error: %d\n", error);
-               return W_ERROR(error);
+       if (!W_ERROR_IS_OK(error)) {
+               printf("error: %s\n", win_errstr(error));
+               return error;
        }
 
        printf("lpszResourceName: %s\n", lpszResourceName);
        printf("lpszDeviceName: %s\n", lpszDeviceName);
        printf("pdwMaxQuorumLogSize: %d\n", pdwMaxQuorumLogSize);
-       printf("rpc_status: %d\n", rpc_status);
+       printf("rpc_status: %s\n", win_errstr(rpc_status));
 
        return WERR_OK;
 }
@@ -175,10 +175,10 @@ static WERROR cmd_clusapi_create_enum(struct rpc_pipe_client *cli,
 {
        struct dcerpc_binding_handle *b = cli->binding_handle;
        NTSTATUS status;
-       uint32_t error;
+       WERROR error;
        uint32_t dwType = 1;
        struct ENUM_LIST *ReturnEnum;
-       uint32_t rpc_status;
+       WERROR rpc_status;
 
        if (argc >= 2) {
                sscanf(argv[1],"%x",&dwType);
@@ -193,12 +193,12 @@ static WERROR cmd_clusapi_create_enum(struct rpc_pipe_client *cli,
                return ntstatus_to_werror(status);
        }
 
-       if (error) {
-               printf("error: %d\n", error);
-               return W_ERROR(error);
+       if (!W_ERROR_IS_OK(error)) {
+               printf("error: %s\n", win_errstr(error));
+               return error;
        }
 
-       printf("rpc_status: %d\n", rpc_status);
+       printf("rpc_status: %s\n", win_errstr(rpc_status));
 
        return WERR_OK;
 }
@@ -211,9 +211,9 @@ static WERROR cmd_clusapi_open_resource(struct rpc_pipe_client *cli,
        struct dcerpc_binding_handle *b = cli->binding_handle;
        NTSTATUS status;
        const char *lpszResourceName = "Cluster Name";
-       uint32_t Status;
+       WERROR Status;
        struct policy_handle hResource;
-       uint32_t rpc_status;
+       WERROR rpc_status;
 
        if (argc >= 2) {
                lpszResourceName = argv[1];
@@ -228,12 +228,12 @@ static WERROR cmd_clusapi_open_resource(struct rpc_pipe_client *cli,
                return ntstatus_to_werror(status);
        }
 
-       if (Status) {
-               printf("Status: %d\n", Status);
-               return W_ERROR(Status);
+       if (!W_ERROR_IS_OK(Status)) {
+               printf("Status: %s\n", win_errstr(Status));
+               return Status;
        }
 
-       printf("rpc_status: %d\n", rpc_status);
+       printf("rpc_status: %s\n", win_errstr(rpc_status));
 
        return WERR_OK;
 }

diff --git a/source4/torture/rpc/clusapi.c b/source4/torture/rpc/clusapi.c
index 7156ec2ceadac8181d3ce6ec5666596efa58a832..aae933b053d20e92a0a99b3baab40ba2c372d390 100644 (file)
--- a/source4/torture/rpc/clusapi.c
+++ b/source4/torture/rpc/clusapi.c
@@ -29,7 +29,7 @@ static bool test_OpenCluster_int(struct torture_context *tctx,
 {
        struct dcerpc_binding_handle *b = p->binding_handle;
        struct clusapi_OpenCluster r;
-       uint32_t Status;
+       WERROR Status;
 
        r.out.Status = &Status;
        r.out.Cluster = Cluster;
@@ -38,7 +38,7 @@ static bool test_OpenCluster_int(struct torture_context *tctx,
                dcerpc_clusapi_OpenCluster_r(b, tctx, &r),
                "OpenCluster failed");
        torture_assert_werr_ok(tctx,
-               W_ERROR(*r.out.Status),
+               *r.out.Status,
                "OpenCluster failed");
 
        return true;
@@ -58,7 +58,7 @@ static bool test_CloseCluster_int(struct torture_context *tctx,
                dcerpc_clusapi_CloseCluster_r(b, tctx, &r),
                "CloseCluster failed");
        torture_assert_werr_ok(tctx,
-               W_ERROR(r.out.result),
+               r.out.result,
                "CloseCluster failed");
 
        torture_assert(tctx,
@@ -99,7 +99,7 @@ static bool test_SetClusterName(struct torture_context *tctx,
 {
        struct dcerpc_binding_handle *b = p->binding_handle;
        struct clusapi_SetClusterName r;
-       uint32_t rpc_status;
+       WERROR rpc_status;
 
        r.in.NewClusterName = "wurst";
        r.out.rpc_status = &rpc_status;
@@ -108,7 +108,7 @@ static bool test_SetClusterName(struct torture_context *tctx,
                dcerpc_clusapi_SetClusterName_r(b, tctx, &r),
                "SetClusterName failed");
        torture_assert_werr_ok(tctx,
-               W_ERROR(r.out.result),
+               r.out.result,
                "SetClusterName failed");
 
        return true;
@@ -129,7 +129,7 @@ static bool test_GetClusterName(struct torture_context *tctx,
                dcerpc_clusapi_GetClusterName_r(b, tctx, &r),
                "GetClusterName failed");
        torture_assert_werr_ok(tctx,
-               W_ERROR(r.out.result),
+               r.out.result,
                "GetClusterName failed");
 
        return true;
@@ -156,7 +156,7 @@ static bool test_GetClusterVersion(struct torture_context *tctx,
                dcerpc_clusapi_GetClusterVersion_r(b, tctx, &r),
                "GetClusterVersion failed");
        torture_assert_werr_equal(tctx,
-               W_ERROR(r.out.result),
+               r.out.result,
                WERR_CALL_NOT_IMPLEMENTED,
                "GetClusterVersion failed");
 
@@ -170,7 +170,7 @@ static bool test_CreateEnum(struct torture_context *tctx,
        struct clusapi_CreateEnum r;
        uint32_t dwType = CLUSTER_ENUM_RESOURCE;
        struct ENUM_LIST *ReturnEnum;
-       uint32_t rpc_status;
+       WERROR rpc_status;
 
        r.in.dwType = dwType;
        r.out.ReturnEnum = &ReturnEnum;
@@ -180,7 +180,7 @@ static bool test_CreateEnum(struct torture_context *tctx,
                dcerpc_clusapi_CreateEnum_r(b, tctx, &r),
                "CreateEnum failed");
        torture_assert_werr_ok(tctx,
-               W_ERROR(r.out.result),
+               r.out.result,
                "CreateEnum failed");
 
        return true;
@@ -194,7 +194,7 @@ static bool test_GetQuorumResource(struct torture_context *tctx,
        const char *lpszResourceName;
        const char *lpszDeviceName;
        uint32_t pdwMaxQuorumLogSize;
-       uint32_t rpc_status;
+       WERROR rpc_status;
 
        r.out.lpszResourceName = &lpszResourceName;
        r.out.lpszDeviceName = &lpszDeviceName;
@@ -205,7 +205,7 @@ static bool test_GetQuorumResource(struct torture_context *tctx,
                dcerpc_clusapi_GetQuorumResource_r(b, tctx, &r),
                "GetQuorumResource failed");
        torture_assert_werr_ok(tctx,
-               W_ERROR(r.out.result),
+               r.out.result,
                "GetQuorumResource failed");
 
        return true;
@@ -218,7 +218,7 @@ static bool test_SetQuorumResource(struct torture_context *tctx,
        struct clusapi_SetQuorumResource r;
        const char *lpszDeviceName = "";
        uint32_t dwMaxQuorumLogSize = 0;
-       uint32_t rpc_status;
+       WERROR rpc_status;
        struct policy_handle hResource;
 
        /* we need to figure out how this call works and what we provide as
@@ -238,7 +238,7 @@ static bool test_SetQuorumResource(struct torture_context *tctx,
                dcerpc_clusapi_SetQuorumResource_r(b, tctx, &r),
                "SetQuorumResource failed");
        torture_assert_werr_ok(tctx,
-               W_ERROR(r.out.result),
+               r.out.result,
                "SetQuorumResource failed");
 
        return true;
@@ -251,8 +251,8 @@ static bool test_OpenResource_int(struct torture_context *tctx,
        struct dcerpc_binding_handle *b = p->binding_handle;
        struct clusapi_OpenResource r;
        const char *lpszResourceName = "Cluster Name";
-       uint32_t Status;
-       uint32_t rpc_status;
+       WERROR Status;
+       WERROR rpc_status;
 
        r.in.lpszResourceName = lpszResourceName;
        r.out.rpc_status = &rpc_status;
@@ -263,7 +263,7 @@ static bool test_OpenResource_int(struct torture_context *tctx,
                dcerpc_clusapi_OpenResource_r(b, tctx, &r),
                "OpenResource failed");
        torture_assert_werr_ok(tctx,
-               W_ERROR(*r.out.Status),
+               *r.out.Status,
                "OpenResource failed");
 
        return true;
@@ -283,7 +283,7 @@ static bool test_CloseResource_int(struct torture_context *tctx,
                dcerpc_clusapi_CloseResource_r(b, tctx, &r),
                "CloseResource failed");
        torture_assert_werr_ok(tctx,
-               W_ERROR(r.out.result),
+               r.out.result,
                "CloseResource failed");
        torture_assert(tctx,
                ndr_policy_handle_empty(hResource),
@@ -326,8 +326,8 @@ static bool test_CreateResource_int(struct torture_context *tctx,
        struct clusapi_CreateResource r;
        const char *lpszResourceName = "Cluster Name";
        const char *lpszResourceType = "wurst";
-       uint32_t Status;
-       uint32_t rpc_status;
+       WERROR Status;
+       WERROR rpc_status;
        struct policy_handle hGroup;
 
        ZERO_STRUCT(hGroup); /* FIXME !!!!!! */
@@ -344,7 +344,7 @@ static bool test_CreateResource_int(struct torture_context *tctx,
                dcerpc_clusapi_CreateResource_r(b, tctx, &r),
                "CreateResource failed");
        torture_assert_werr_ok(tctx,
-               W_ERROR(*r.out.Status),
+               *r.out.Status,
                "CreateResource failed");
 
        return true;
@@ -356,7 +356,7 @@ static bool test_DeleteResource_int(struct torture_context *tctx,
 {
        struct dcerpc_binding_handle *b = p->binding_handle;
        struct clusapi_DeleteResource r;
-       uint32_t rpc_status;
+       WERROR rpc_status;
 
        r.in.hResource = *hResource;
        r.out.rpc_status = &rpc_status;
@@ -365,7 +365,7 @@ static bool test_DeleteResource_int(struct torture_context *tctx,
                dcerpc_clusapi_DeleteResource_r(b, tctx, &r),
                "DeleteResource failed");
        torture_assert_werr_ok(tctx,
-               W_ERROR(r.out.result),
+               r.out.result,
                "DeleteResource failed");
 
        return true;
@@ -406,7 +406,7 @@ static bool test_GetResourceState_int(struct torture_context *tctx,
        uint32_t State;
        const char *NodeName;
        const char *GroupName;
-       uint32_t rpc_status;
+       WERROR rpc_status;
 
        r.in.hResource = *hResource;
        r.out.State = &State;
@@ -418,7 +418,7 @@ static bool test_GetResourceState_int(struct torture_context *tctx,
                dcerpc_clusapi_GetResourceState_r(b, tctx, &r),
                "GetResourceState failed");
        torture_assert_werr_ok(tctx,
-               W_ERROR(r.out.result),
+               r.out.result,
                "GetResourceState failed");
 
        return true;
@@ -448,7 +448,7 @@ static bool test_GetResourceId_int(struct torture_context *tctx,
        struct dcerpc_binding_handle *b = p->binding_handle;
        struct clusapi_GetResourceId r;
        const char *pGuid;
-       uint32_t rpc_status;
+       WERROR rpc_status;
 
        r.in.hResource = *hResource;
        r.out.pGuid = &pGuid;
@@ -458,7 +458,7 @@ static bool test_GetResourceId_int(struct torture_context *tctx,
                dcerpc_clusapi_GetResourceId_r(b, tctx, &r),
                "GetResourceId failed");
        torture_assert_werr_ok(tctx,
-               W_ERROR(r.out.result),
+               r.out.result,
                "GetResourceId failed");
 
        return true;
@@ -488,7 +488,7 @@ static bool test_GetResourceType_int(struct torture_context *tctx,
        struct dcerpc_binding_handle *b = p->binding_handle;
        struct clusapi_GetResourceType r;
        const char *lpszResourceType;
-       uint32_t rpc_status;
+       WERROR rpc_status;
 
        r.in.hResource = *hResource;
        r.out.lpszResourceType = &lpszResourceType;
@@ -498,7 +498,7 @@ static bool test_GetResourceType_int(struct torture_context *tctx,
                dcerpc_clusapi_GetResourceType_r(b, tctx, &r),
                "GetResourceType failed");
        torture_assert_werr_ok(tctx,
-               W_ERROR(r.out.result),
+               r.out.result,
                "GetResourceType failed");
 
        return true;
@@ -527,7 +527,7 @@ static bool test_FailResource_int(struct torture_context *tctx,
 {
        struct dcerpc_binding_handle *b = p->binding_handle;
        struct clusapi_FailResource r;
-       uint32_t rpc_status;
+       WERROR rpc_status;
 
        r.in.hResource = *hResource;
        r.out.rpc_status = &rpc_status;
@@ -536,7 +536,7 @@ static bool test_FailResource_int(struct torture_context *tctx,
                dcerpc_clusapi_FailResource_r(b, tctx, &r),
                "FailResource failed");
        torture_assert_werr_ok(tctx,
-               W_ERROR(r.out.result),
+               r.out.result,
                "FailResource failed");
 
        return true;
@@ -565,7 +565,7 @@ static bool test_OnlineResource_int(struct torture_context *tctx,
 {
        struct dcerpc_binding_handle *b = p->binding_handle;
        struct clusapi_OnlineResource r;
-       uint32_t rpc_status;
+       WERROR rpc_status;
 
        r.in.hResource = *hResource;
        r.out.rpc_status = &rpc_status;
@@ -574,7 +574,7 @@ static bool test_OnlineResource_int(struct torture_context *tctx,
                dcerpc_clusapi_OnlineResource_r(b, tctx, &r),
                "OnlineResource failed");
        torture_assert_werr_ok(tctx,
-               W_ERROR(r.out.result),
+               r.out.result,
                "OnlineResource failed");
 
        return true;
@@ -603,7 +603,7 @@ static bool test_OfflineResource_int(struct torture_context *tctx,
 {
        struct dcerpc_binding_handle *b = p->binding_handle;
        struct clusapi_OfflineResource r;
-       uint32_t rpc_status;
+       WERROR rpc_status;
 
        r.in.hResource = *hResource;
        r.out.rpc_status = &rpc_status;
@@ -612,7 +612,7 @@ static bool test_OfflineResource_int(struct torture_context *tctx,
                dcerpc_clusapi_OfflineResource_r(b, tctx, &r),
                "OfflineResource failed");
        torture_assert_werr_ok(tctx,
-               W_ERROR(r.out.result),
+               r.out.result,
                "OfflineResource failed");
 
        return true;