LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - ndr_clusapi.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 226 16923 1.3 %
Date: 2021-09-23 10:06:22 Functions: 12 677 1.8 %

          Line data    Source code
       1             : /* parser auto-generated by pidl */
       2             : 
       3             : #include "includes.h"
       4             : #include "bin/default/librpc/gen_ndr/ndr_clusapi.h"
       5             : 
       6             : #include "librpc/gen_ndr/ndr_winreg.h"
       7             : #include "librpc/gen_ndr/ndr_misc.h"
       8           0 : static enum ndr_err_code ndr_push_RPC_SECURITY_DESCRIPTOR(struct ndr_push *ndr, int ndr_flags, const struct RPC_SECURITY_DESCRIPTOR *r)
       9             : {
      10           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
      11           0 :         if (ndr_flags & NDR_SCALARS) {
      12           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
      13           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lpSecurityDescriptor));
      14           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbInSecurityDescriptor));
      15           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbOutSecurityDescriptor));
      16           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
      17             :         }
      18           0 :         if (ndr_flags & NDR_BUFFERS) {
      19           0 :                 if (r->lpSecurityDescriptor) {
      20           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cbInSecurityDescriptor));
      21           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
      22           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cbOutSecurityDescriptor));
      23           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->lpSecurityDescriptor, r->cbOutSecurityDescriptor));
      24             :                 }
      25             :         }
      26           0 :         return NDR_ERR_SUCCESS;
      27             : }
      28             : 
      29           0 : static enum ndr_err_code ndr_pull_RPC_SECURITY_DESCRIPTOR(struct ndr_pull *ndr, int ndr_flags, struct RPC_SECURITY_DESCRIPTOR *r)
      30             : {
      31             :         uint32_t _ptr_lpSecurityDescriptor;
      32           0 :         uint32_t size_lpSecurityDescriptor_1 = 0;
      33           0 :         uint32_t length_lpSecurityDescriptor_1 = 0;
      34           0 :         TALLOC_CTX *_mem_save_lpSecurityDescriptor_0 = NULL;
      35           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
      36           0 :         if (ndr_flags & NDR_SCALARS) {
      37           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
      38           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpSecurityDescriptor));
      39           0 :                 if (_ptr_lpSecurityDescriptor) {
      40           0 :                         NDR_PULL_ALLOC(ndr, r->lpSecurityDescriptor);
      41             :                 } else {
      42           0 :                         r->lpSecurityDescriptor = NULL;
      43             :                 }
      44           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbInSecurityDescriptor));
      45           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbOutSecurityDescriptor));
      46           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
      47             :         }
      48           0 :         if (ndr_flags & NDR_BUFFERS) {
      49           0 :                 if (r->lpSecurityDescriptor) {
      50           0 :                         _mem_save_lpSecurityDescriptor_0 = NDR_PULL_GET_MEM_CTX(ndr);
      51           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->lpSecurityDescriptor, 0);
      52           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lpSecurityDescriptor));
      53           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lpSecurityDescriptor));
      54           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->lpSecurityDescriptor, &size_lpSecurityDescriptor_1));
      55           0 :                         NDR_CHECK(ndr_get_array_length(ndr, (void*)&r->lpSecurityDescriptor, &length_lpSecurityDescriptor_1));
      56           0 :                         if (length_lpSecurityDescriptor_1 > size_lpSecurityDescriptor_1) {
      57           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpSecurityDescriptor_1, length_lpSecurityDescriptor_1);
      58             :                         }
      59           0 :                         NDR_PULL_ALLOC_N(ndr, r->lpSecurityDescriptor, size_lpSecurityDescriptor_1);
      60           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->lpSecurityDescriptor, length_lpSecurityDescriptor_1));
      61           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpSecurityDescriptor_0, 0);
      62             :                 }
      63           0 :                 if (r->lpSecurityDescriptor) {
      64           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->lpSecurityDescriptor, r->cbInSecurityDescriptor));
      65             :                 }
      66           0 :                 if (r->lpSecurityDescriptor) {
      67           0 :                         NDR_CHECK(ndr_check_steal_array_length(ndr, (void*)&r->lpSecurityDescriptor, r->cbOutSecurityDescriptor));
      68             :                 }
      69             :         }
      70           0 :         return NDR_ERR_SUCCESS;
      71             : }
      72             : 
      73           0 : _PUBLIC_ void ndr_print_RPC_SECURITY_DESCRIPTOR(struct ndr_print *ndr, const char *name, const struct RPC_SECURITY_DESCRIPTOR *r)
      74             : {
      75           0 :         ndr_print_struct(ndr, name, "RPC_SECURITY_DESCRIPTOR");
      76           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
      77           0 :         ndr->depth++;
      78           0 :         ndr_print_ptr(ndr, "lpSecurityDescriptor", r->lpSecurityDescriptor);
      79           0 :         ndr->depth++;
      80           0 :         if (r->lpSecurityDescriptor) {
      81           0 :                 ndr_print_array_uint8(ndr, "lpSecurityDescriptor", r->lpSecurityDescriptor, r->cbOutSecurityDescriptor);
      82             :         }
      83           0 :         ndr->depth--;
      84           0 :         ndr_print_uint32(ndr, "cbInSecurityDescriptor", r->cbInSecurityDescriptor);
      85           0 :         ndr_print_uint32(ndr, "cbOutSecurityDescriptor", r->cbOutSecurityDescriptor);
      86           0 :         ndr->depth--;
      87             : }
      88             : 
      89           0 : static enum ndr_err_code ndr_push_RPC_SECURITY_ATTRIBUTES(struct ndr_push *ndr, int ndr_flags, const struct RPC_SECURITY_ATTRIBUTES *r)
      90             : {
      91           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
      92           0 :         if (ndr_flags & NDR_SCALARS) {
      93           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
      94           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nLength));
      95           0 :                 NDR_CHECK(ndr_push_RPC_SECURITY_DESCRIPTOR(ndr, NDR_SCALARS, &r->RpcSecurityDescriptor));
      96           0 :                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->bInheritHandle));
      97           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
      98             :         }
      99           0 :         if (ndr_flags & NDR_BUFFERS) {
     100           0 :                 NDR_CHECK(ndr_push_RPC_SECURITY_DESCRIPTOR(ndr, NDR_BUFFERS, &r->RpcSecurityDescriptor));
     101             :         }
     102           0 :         return NDR_ERR_SUCCESS;
     103             : }
     104             : 
     105           0 : static enum ndr_err_code ndr_pull_RPC_SECURITY_ATTRIBUTES(struct ndr_pull *ndr, int ndr_flags, struct RPC_SECURITY_ATTRIBUTES *r)
     106             : {
     107           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     108           0 :         if (ndr_flags & NDR_SCALARS) {
     109           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     110           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nLength));
     111           0 :                 NDR_CHECK(ndr_pull_RPC_SECURITY_DESCRIPTOR(ndr, NDR_SCALARS, &r->RpcSecurityDescriptor));
     112           0 :                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->bInheritHandle));
     113           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     114             :         }
     115           0 :         if (ndr_flags & NDR_BUFFERS) {
     116           0 :                 NDR_CHECK(ndr_pull_RPC_SECURITY_DESCRIPTOR(ndr, NDR_BUFFERS, &r->RpcSecurityDescriptor));
     117             :         }
     118           0 :         return NDR_ERR_SUCCESS;
     119             : }
     120             : 
     121           0 : _PUBLIC_ void ndr_print_RPC_SECURITY_ATTRIBUTES(struct ndr_print *ndr, const char *name, const struct RPC_SECURITY_ATTRIBUTES *r)
     122             : {
     123           0 :         ndr_print_struct(ndr, name, "RPC_SECURITY_ATTRIBUTES");
     124           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     125           0 :         ndr->depth++;
     126           0 :         ndr_print_uint32(ndr, "nLength", r->nLength);
     127           0 :         ndr_print_RPC_SECURITY_DESCRIPTOR(ndr, "RpcSecurityDescriptor", &r->RpcSecurityDescriptor);
     128           0 :         ndr_print_int32(ndr, "bInheritHandle", r->bInheritHandle);
     129           0 :         ndr->depth--;
     130             : }
     131             : 
     132           0 : static enum ndr_err_code ndr_push_CLUSTER_OPERATIONAL_VERSION_INFO(struct ndr_push *ndr, int ndr_flags, const struct CLUSTER_OPERATIONAL_VERSION_INFO *r)
     133             : {
     134           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     135           0 :         if (ndr_flags & NDR_SCALARS) {
     136           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     137           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 20));
     138           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwClusterHighestVersion));
     139           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwClusterLowestVersion));
     140           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwFlags));
     141           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwReserved));
     142           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     143             :         }
     144           0 :         if (ndr_flags & NDR_BUFFERS) {
     145             :         }
     146           0 :         return NDR_ERR_SUCCESS;
     147             : }
     148             : 
     149           0 : static enum ndr_err_code ndr_pull_CLUSTER_OPERATIONAL_VERSION_INFO(struct ndr_pull *ndr, int ndr_flags, struct CLUSTER_OPERATIONAL_VERSION_INFO *r)
     150             : {
     151           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     152           0 :         if (ndr_flags & NDR_SCALARS) {
     153           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     154           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwSize));
     155           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwClusterHighestVersion));
     156           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwClusterLowestVersion));
     157           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwFlags));
     158           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwReserved));
     159           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     160             :         }
     161           0 :         if (ndr_flags & NDR_BUFFERS) {
     162             :         }
     163           0 :         return NDR_ERR_SUCCESS;
     164             : }
     165             : 
     166           0 : _PUBLIC_ void ndr_print_CLUSTER_OPERATIONAL_VERSION_INFO(struct ndr_print *ndr, const char *name, const struct CLUSTER_OPERATIONAL_VERSION_INFO *r)
     167             : {
     168           0 :         ndr_print_struct(ndr, name, "CLUSTER_OPERATIONAL_VERSION_INFO");
     169           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     170           0 :         ndr->depth++;
     171           0 :         ndr_print_uint32(ndr, "dwSize", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?20:r->dwSize);
     172           0 :         ndr_print_uint32(ndr, "dwClusterHighestVersion", r->dwClusterHighestVersion);
     173           0 :         ndr_print_uint32(ndr, "dwClusterLowestVersion", r->dwClusterLowestVersion);
     174           0 :         ndr_print_uint32(ndr, "dwFlags", r->dwFlags);
     175           0 :         ndr_print_uint32(ndr, "dwReserved", r->dwReserved);
     176           0 :         ndr->depth--;
     177             : }
     178             : 
     179           0 : static enum ndr_err_code ndr_push_IDL_CLUSTER_SET_PASSWORD_STATUS(struct ndr_push *ndr, int ndr_flags, const struct IDL_CLUSTER_SET_PASSWORD_STATUS *r)
     180             : {
     181           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     182           0 :         if (ndr_flags & NDR_SCALARS) {
     183           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     184           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->NodeId));
     185           0 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->SetAttempted));
     186           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ReturnStatus));
     187           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     188             :         }
     189           0 :         if (ndr_flags & NDR_BUFFERS) {
     190             :         }
     191           0 :         return NDR_ERR_SUCCESS;
     192             : }
     193             : 
     194           0 : static enum ndr_err_code ndr_pull_IDL_CLUSTER_SET_PASSWORD_STATUS(struct ndr_pull *ndr, int ndr_flags, struct IDL_CLUSTER_SET_PASSWORD_STATUS *r)
     195             : {
     196           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     197           0 :         if (ndr_flags & NDR_SCALARS) {
     198           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     199           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->NodeId));
     200           0 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->SetAttempted));
     201           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ReturnStatus));
     202           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     203             :         }
     204           0 :         if (ndr_flags & NDR_BUFFERS) {
     205             :         }
     206           0 :         return NDR_ERR_SUCCESS;
     207             : }
     208             : 
     209           0 : _PUBLIC_ void ndr_print_IDL_CLUSTER_SET_PASSWORD_STATUS(struct ndr_print *ndr, const char *name, const struct IDL_CLUSTER_SET_PASSWORD_STATUS *r)
     210             : {
     211           0 :         ndr_print_struct(ndr, name, "IDL_CLUSTER_SET_PASSWORD_STATUS");
     212           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     213           0 :         ndr->depth++;
     214           0 :         ndr_print_uint32(ndr, "NodeId", r->NodeId);
     215           0 :         ndr_print_uint8(ndr, "SetAttempted", r->SetAttempted);
     216           0 :         ndr_print_uint32(ndr, "ReturnStatus", r->ReturnStatus);
     217           0 :         ndr->depth--;
     218             : }
     219             : 
     220           0 : static enum ndr_err_code ndr_push_IDL_CLUSTER_SET_PASSWORD_FLAGS(struct ndr_push *ndr, int ndr_flags, enum IDL_CLUSTER_SET_PASSWORD_FLAGS r)
     221             : {
     222           0 :         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
     223           0 :         return NDR_ERR_SUCCESS;
     224             : }
     225             : 
     226           0 : static enum ndr_err_code ndr_pull_IDL_CLUSTER_SET_PASSWORD_FLAGS(struct ndr_pull *ndr, int ndr_flags, enum IDL_CLUSTER_SET_PASSWORD_FLAGS *r)
     227             : {
     228             :         uint16_t v;
     229           0 :         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
     230           0 :         *r = v;
     231           0 :         return NDR_ERR_SUCCESS;
     232             : }
     233             : 
     234           0 : _PUBLIC_ void ndr_print_IDL_CLUSTER_SET_PASSWORD_FLAGS(struct ndr_print *ndr, const char *name, enum IDL_CLUSTER_SET_PASSWORD_FLAGS r)
     235             : {
     236           0 :         const char *val = NULL;
     237             : 
     238           0 :         switch (r) {
     239           0 :                 case IDL_CLUSTER_SET_PASSWORD_IGNORE_DOWN_NODES: val = "IDL_CLUSTER_SET_PASSWORD_IGNORE_DOWN_NODES"; break;
     240             :         }
     241           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
     242           0 : }
     243             : 
     244           0 : static enum ndr_err_code ndr_push_CLUSTER_CREATE_GROUP_INFO_RPC(struct ndr_push *ndr, int ndr_flags, const struct CLUSTER_CREATE_GROUP_INFO_RPC *r)
     245             : {
     246           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     247           0 :         if (ndr_flags & NDR_SCALARS) {
     248           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
     249           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwVersion));
     250           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwGroupType));
     251           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
     252             :         }
     253           0 :         if (ndr_flags & NDR_BUFFERS) {
     254             :         }
     255           0 :         return NDR_ERR_SUCCESS;
     256             : }
     257             : 
     258           0 : static enum ndr_err_code ndr_pull_CLUSTER_CREATE_GROUP_INFO_RPC(struct ndr_pull *ndr, int ndr_flags, struct CLUSTER_CREATE_GROUP_INFO_RPC *r)
     259             : {
     260           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     261           0 :         if (ndr_flags & NDR_SCALARS) {
     262           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
     263           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwVersion));
     264           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwGroupType));
     265           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
     266             :         }
     267           0 :         if (ndr_flags & NDR_BUFFERS) {
     268             :         }
     269           0 :         return NDR_ERR_SUCCESS;
     270             : }
     271             : 
     272           0 : _PUBLIC_ void ndr_print_CLUSTER_CREATE_GROUP_INFO_RPC(struct ndr_print *ndr, const char *name, const struct CLUSTER_CREATE_GROUP_INFO_RPC *r)
     273             : {
     274           0 :         ndr_print_struct(ndr, name, "CLUSTER_CREATE_GROUP_INFO_RPC");
     275           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     276           0 :         ndr->depth++;
     277           0 :         ndr_print_uint32(ndr, "dwVersion", r->dwVersion);
     278           0 :         ndr_print_uint32(ndr, "dwGroupType", r->dwGroupType);
     279           0 :         ndr->depth--;
     280             : }
     281             : 
     282           0 : static enum ndr_err_code ndr_push_ClusterEnumType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
     283             : {
     284           0 :         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
     285           0 :         return NDR_ERR_SUCCESS;
     286             : }
     287             : 
     288           0 : static enum ndr_err_code ndr_pull_ClusterEnumType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
     289             : {
     290             :         uint32_t v;
     291           0 :         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
     292           0 :         *r = v;
     293           0 :         return NDR_ERR_SUCCESS;
     294             : }
     295             : 
     296           0 : _PUBLIC_ void ndr_print_ClusterEnumType(struct ndr_print *ndr, const char *name, uint32_t r)
     297             : {
     298           0 :         ndr_print_uint32(ndr, name, r);
     299           0 :         ndr->depth++;
     300           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSTER_ENUM_NODE", CLUSTER_ENUM_NODE, r);
     301           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSTER_ENUM_RESTYPE", CLUSTER_ENUM_RESTYPE, r);
     302           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSTER_ENUM_RESOURCE", CLUSTER_ENUM_RESOURCE, r);
     303           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSTER_ENUM_GROUP", CLUSTER_ENUM_GROUP, r);
     304           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSTER_ENUM_NETWORK", CLUSTER_ENUM_NETWORK, r);
     305           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSTER_ENUM_NETINTERFACE", CLUSTER_ENUM_NETINTERFACE, r);
     306           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSTER_ENUM_INTERNAL_NETWORK", CLUSTER_ENUM_INTERNAL_NETWORK, r);
     307           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSTER_ENUM_SHARED_VOLUME_RESOURCE", CLUSTER_ENUM_SHARED_VOLUME_RESOURCE, r);
     308           0 :         ndr->depth--;
     309           0 : }
     310             : 
     311           0 : static enum ndr_err_code ndr_push_ENUM_ENTRY(struct ndr_push *ndr, int ndr_flags, const struct ENUM_ENTRY *r)
     312             : {
     313           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     314           0 :         if (ndr_flags & NDR_SCALARS) {
     315           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     316           0 :                 NDR_CHECK(ndr_push_ClusterEnumType(ndr, NDR_SCALARS, r->Type));
     317           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->Name));
     318           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     319             :         }
     320           0 :         if (ndr_flags & NDR_BUFFERS) {
     321           0 :                 if (r->Name) {
     322           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Name, CH_UTF16)));
     323           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     324           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Name, CH_UTF16)));
     325           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->Name, ndr_charset_length(r->Name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     326             :                 }
     327             :         }
     328           0 :         return NDR_ERR_SUCCESS;
     329             : }
     330             : 
     331           0 : static enum ndr_err_code ndr_pull_ENUM_ENTRY(struct ndr_pull *ndr, int ndr_flags, struct ENUM_ENTRY *r)
     332             : {
     333             :         uint32_t _ptr_Name;
     334           0 :         uint32_t size_Name_1 = 0;
     335           0 :         uint32_t length_Name_1 = 0;
     336           0 :         TALLOC_CTX *_mem_save_Name_0 = NULL;
     337           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     338           0 :         if (ndr_flags & NDR_SCALARS) {
     339           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     340           0 :                 NDR_CHECK(ndr_pull_ClusterEnumType(ndr, NDR_SCALARS, &r->Type));
     341           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Name));
     342           0 :                 if (_ptr_Name) {
     343           0 :                         NDR_PULL_ALLOC(ndr, r->Name);
     344             :                 } else {
     345           0 :                         r->Name = NULL;
     346             :                 }
     347           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     348             :         }
     349           0 :         if (ndr_flags & NDR_BUFFERS) {
     350           0 :                 if (r->Name) {
     351           0 :                         _mem_save_Name_0 = NDR_PULL_GET_MEM_CTX(ndr);
     352           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->Name, 0);
     353           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->Name));
     354           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->Name));
     355           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->Name, &size_Name_1));
     356           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->Name, &length_Name_1));
     357           0 :                         if (length_Name_1 > size_Name_1) {
     358           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_Name_1, length_Name_1);
     359             :                         }
     360           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_Name_1, sizeof(uint16_t)));
     361           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Name, length_Name_1, sizeof(uint16_t), CH_UTF16));
     362           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Name_0, 0);
     363             :                 }
     364             :         }
     365           0 :         return NDR_ERR_SUCCESS;
     366             : }
     367             : 
     368           0 : _PUBLIC_ void ndr_print_ENUM_ENTRY(struct ndr_print *ndr, const char *name, const struct ENUM_ENTRY *r)
     369             : {
     370           0 :         ndr_print_struct(ndr, name, "ENUM_ENTRY");
     371           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     372           0 :         ndr->depth++;
     373           0 :         ndr_print_ClusterEnumType(ndr, "Type", r->Type);
     374           0 :         ndr_print_ptr(ndr, "Name", r->Name);
     375           0 :         ndr->depth++;
     376           0 :         if (r->Name) {
     377           0 :                 ndr_print_string(ndr, "Name", r->Name);
     378             :         }
     379           0 :         ndr->depth--;
     380           0 :         ndr->depth--;
     381             : }
     382             : 
     383           0 : static enum ndr_err_code ndr_push_ENUM_LIST(struct ndr_push *ndr, int ndr_flags, const struct ENUM_LIST *r)
     384             : {
     385             :         uint32_t cntr_Entry_0;
     386           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     387           0 :         if (ndr_flags & NDR_SCALARS) {
     388           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->EntryCount));
     389           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     390           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->EntryCount));
     391           0 :                 for (cntr_Entry_0 = 0; cntr_Entry_0 < (r->EntryCount); cntr_Entry_0++) {
     392           0 :                         NDR_CHECK(ndr_push_ENUM_ENTRY(ndr, NDR_SCALARS, &r->Entry[cntr_Entry_0]));
     393             :                 }
     394           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     395             :         }
     396           0 :         if (ndr_flags & NDR_BUFFERS) {
     397           0 :                 for (cntr_Entry_0 = 0; cntr_Entry_0 < (r->EntryCount); cntr_Entry_0++) {
     398           0 :                         NDR_CHECK(ndr_push_ENUM_ENTRY(ndr, NDR_BUFFERS, &r->Entry[cntr_Entry_0]));
     399             :                 }
     400             :         }
     401           0 :         return NDR_ERR_SUCCESS;
     402             : }
     403             : 
     404           0 : static enum ndr_err_code ndr_pull_ENUM_LIST(struct ndr_pull *ndr, int ndr_flags, struct ENUM_LIST *r)
     405             : {
     406           0 :         uint32_t size_Entry_0 = 0;
     407             :         uint32_t cntr_Entry_0;
     408           0 :         TALLOC_CTX *_mem_save_Entry_0 = NULL;
     409           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     410           0 :         if (ndr_flags & NDR_SCALARS) {
     411           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->Entry));
     412           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     413           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->EntryCount));
     414           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->Entry, &size_Entry_0));
     415           0 :                 NDR_PULL_ALLOC_N(ndr, r->Entry, size_Entry_0);
     416           0 :                 _mem_save_Entry_0 = NDR_PULL_GET_MEM_CTX(ndr);
     417           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->Entry, 0);
     418           0 :                 for (cntr_Entry_0 = 0; cntr_Entry_0 < (size_Entry_0); cntr_Entry_0++) {
     419           0 :                         NDR_CHECK(ndr_pull_ENUM_ENTRY(ndr, NDR_SCALARS, &r->Entry[cntr_Entry_0]));
     420             :                 }
     421           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Entry_0, 0);
     422           0 :                 if (r->Entry) {
     423           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->Entry, r->EntryCount));
     424             :                 }
     425           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     426             :         }
     427           0 :         if (ndr_flags & NDR_BUFFERS) {
     428           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->Entry, &size_Entry_0));
     429           0 :                 _mem_save_Entry_0 = NDR_PULL_GET_MEM_CTX(ndr);
     430           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->Entry, 0);
     431           0 :                 for (cntr_Entry_0 = 0; cntr_Entry_0 < (size_Entry_0); cntr_Entry_0++) {
     432           0 :                         NDR_CHECK(ndr_pull_ENUM_ENTRY(ndr, NDR_BUFFERS, &r->Entry[cntr_Entry_0]));
     433             :                 }
     434           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Entry_0, 0);
     435           0 :                 for (cntr_Entry_0 = 0; cntr_Entry_0 < (size_Entry_0); cntr_Entry_0++) {
     436             :                 }
     437             :         }
     438           0 :         return NDR_ERR_SUCCESS;
     439             : }
     440             : 
     441           0 : _PUBLIC_ void ndr_print_ENUM_LIST(struct ndr_print *ndr, const char *name, const struct ENUM_LIST *r)
     442             : {
     443             :         uint32_t cntr_Entry_0;
     444           0 :         ndr_print_struct(ndr, name, "ENUM_LIST");
     445           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     446           0 :         ndr->depth++;
     447           0 :         ndr_print_uint32(ndr, "EntryCount", r->EntryCount);
     448           0 :         ndr->print(ndr, "%s: ARRAY(%d)", "Entry", (int)r->EntryCount);
     449           0 :         ndr->depth++;
     450           0 :         for (cntr_Entry_0 = 0; cntr_Entry_0 < (r->EntryCount); cntr_Entry_0++) {
     451           0 :                 ndr_print_ENUM_ENTRY(ndr, "Entry", &r->Entry[cntr_Entry_0]);
     452             :         }
     453           0 :         ndr->depth--;
     454           0 :         ndr->depth--;
     455             : }
     456             : 
     457           0 : static enum ndr_err_code ndr_push_GROUP_ENUM_ENTRY(struct ndr_push *ndr, int ndr_flags, const struct GROUP_ENUM_ENTRY *r)
     458             : {
     459           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     460           0 :         if (ndr_flags & NDR_SCALARS) {
     461           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     462           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->Name));
     463           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->Id));
     464           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwState));
     465           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->Owner));
     466           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwFlags));
     467           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbProperties));
     468           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->Properties));
     469           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbRoProperties));
     470           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->RoProperties));
     471           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     472             :         }
     473           0 :         if (ndr_flags & NDR_BUFFERS) {
     474           0 :                 if (r->Name) {
     475           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Name, CH_UTF16)));
     476           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     477           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Name, CH_UTF16)));
     478           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->Name, ndr_charset_length(r->Name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     479             :                 }
     480           0 :                 if (r->Id) {
     481           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Id, CH_UTF16)));
     482           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     483           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Id, CH_UTF16)));
     484           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->Id, ndr_charset_length(r->Id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     485             :                 }
     486           0 :                 if (r->Owner) {
     487           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Owner, CH_UTF16)));
     488           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     489           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Owner, CH_UTF16)));
     490           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->Owner, ndr_charset_length(r->Owner, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     491             :                 }
     492           0 :                 if (r->Properties) {
     493           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cbProperties));
     494           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Properties, r->cbProperties));
     495             :                 }
     496           0 :                 if (r->RoProperties) {
     497           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cbRoProperties));
     498           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->RoProperties, r->cbRoProperties));
     499             :                 }
     500             :         }
     501           0 :         return NDR_ERR_SUCCESS;
     502             : }
     503             : 
     504           0 : static enum ndr_err_code ndr_pull_GROUP_ENUM_ENTRY(struct ndr_pull *ndr, int ndr_flags, struct GROUP_ENUM_ENTRY *r)
     505             : {
     506             :         uint32_t _ptr_Name;
     507           0 :         uint32_t size_Name_1 = 0;
     508           0 :         uint32_t length_Name_1 = 0;
     509           0 :         TALLOC_CTX *_mem_save_Name_0 = NULL;
     510             :         uint32_t _ptr_Id;
     511           0 :         uint32_t size_Id_1 = 0;
     512           0 :         uint32_t length_Id_1 = 0;
     513           0 :         TALLOC_CTX *_mem_save_Id_0 = NULL;
     514             :         uint32_t _ptr_Owner;
     515           0 :         uint32_t size_Owner_1 = 0;
     516           0 :         uint32_t length_Owner_1 = 0;
     517           0 :         TALLOC_CTX *_mem_save_Owner_0 = NULL;
     518             :         uint32_t _ptr_Properties;
     519           0 :         uint32_t size_Properties_1 = 0;
     520           0 :         TALLOC_CTX *_mem_save_Properties_0 = NULL;
     521             :         uint32_t _ptr_RoProperties;
     522           0 :         uint32_t size_RoProperties_1 = 0;
     523           0 :         TALLOC_CTX *_mem_save_RoProperties_0 = NULL;
     524           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     525           0 :         if (ndr_flags & NDR_SCALARS) {
     526           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     527           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Name));
     528           0 :                 if (_ptr_Name) {
     529           0 :                         NDR_PULL_ALLOC(ndr, r->Name);
     530             :                 } else {
     531           0 :                         r->Name = NULL;
     532             :                 }
     533           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Id));
     534           0 :                 if (_ptr_Id) {
     535           0 :                         NDR_PULL_ALLOC(ndr, r->Id);
     536             :                 } else {
     537           0 :                         r->Id = NULL;
     538             :                 }
     539           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwState));
     540           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Owner));
     541           0 :                 if (_ptr_Owner) {
     542           0 :                         NDR_PULL_ALLOC(ndr, r->Owner);
     543             :                 } else {
     544           0 :                         r->Owner = NULL;
     545             :                 }
     546           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwFlags));
     547           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbProperties));
     548           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Properties));
     549           0 :                 if (_ptr_Properties) {
     550           0 :                         NDR_PULL_ALLOC(ndr, r->Properties);
     551             :                 } else {
     552           0 :                         r->Properties = NULL;
     553             :                 }
     554           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbRoProperties));
     555           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_RoProperties));
     556           0 :                 if (_ptr_RoProperties) {
     557           0 :                         NDR_PULL_ALLOC(ndr, r->RoProperties);
     558             :                 } else {
     559           0 :                         r->RoProperties = NULL;
     560             :                 }
     561           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     562             :         }
     563           0 :         if (ndr_flags & NDR_BUFFERS) {
     564           0 :                 if (r->Name) {
     565           0 :                         _mem_save_Name_0 = NDR_PULL_GET_MEM_CTX(ndr);
     566           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->Name, 0);
     567           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->Name));
     568           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->Name));
     569           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->Name, &size_Name_1));
     570           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->Name, &length_Name_1));
     571           0 :                         if (length_Name_1 > size_Name_1) {
     572           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_Name_1, length_Name_1);
     573             :                         }
     574           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_Name_1, sizeof(uint16_t)));
     575           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Name, length_Name_1, sizeof(uint16_t), CH_UTF16));
     576           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Name_0, 0);
     577             :                 }
     578           0 :                 if (r->Id) {
     579           0 :                         _mem_save_Id_0 = NDR_PULL_GET_MEM_CTX(ndr);
     580           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->Id, 0);
     581           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->Id));
     582           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->Id));
     583           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->Id, &size_Id_1));
     584           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->Id, &length_Id_1));
     585           0 :                         if (length_Id_1 > size_Id_1) {
     586           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_Id_1, length_Id_1);
     587             :                         }
     588           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_Id_1, sizeof(uint16_t)));
     589           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Id, length_Id_1, sizeof(uint16_t), CH_UTF16));
     590           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Id_0, 0);
     591             :                 }
     592           0 :                 if (r->Owner) {
     593           0 :                         _mem_save_Owner_0 = NDR_PULL_GET_MEM_CTX(ndr);
     594           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->Owner, 0);
     595           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->Owner));
     596           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->Owner));
     597           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->Owner, &size_Owner_1));
     598           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->Owner, &length_Owner_1));
     599           0 :                         if (length_Owner_1 > size_Owner_1) {
     600           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_Owner_1, length_Owner_1);
     601             :                         }
     602           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_Owner_1, sizeof(uint16_t)));
     603           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Owner, length_Owner_1, sizeof(uint16_t), CH_UTF16));
     604           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Owner_0, 0);
     605             :                 }
     606           0 :                 if (r->Properties) {
     607           0 :                         _mem_save_Properties_0 = NDR_PULL_GET_MEM_CTX(ndr);
     608           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->Properties, 0);
     609           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->Properties));
     610           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->Properties, &size_Properties_1));
     611           0 :                         NDR_PULL_ALLOC_N(ndr, r->Properties, size_Properties_1);
     612           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Properties, size_Properties_1));
     613           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Properties_0, 0);
     614             :                 }
     615           0 :                 if (r->RoProperties) {
     616           0 :                         _mem_save_RoProperties_0 = NDR_PULL_GET_MEM_CTX(ndr);
     617           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->RoProperties, 0);
     618           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->RoProperties));
     619           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->RoProperties, &size_RoProperties_1));
     620           0 :                         NDR_PULL_ALLOC_N(ndr, r->RoProperties, size_RoProperties_1);
     621           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->RoProperties, size_RoProperties_1));
     622           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_RoProperties_0, 0);
     623             :                 }
     624           0 :                 if (r->Properties) {
     625           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->Properties, r->cbProperties));
     626             :                 }
     627           0 :                 if (r->RoProperties) {
     628           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->RoProperties, r->cbRoProperties));
     629             :                 }
     630             :         }
     631           0 :         return NDR_ERR_SUCCESS;
     632             : }
     633             : 
     634           0 : _PUBLIC_ void ndr_print_GROUP_ENUM_ENTRY(struct ndr_print *ndr, const char *name, const struct GROUP_ENUM_ENTRY *r)
     635             : {
     636           0 :         ndr_print_struct(ndr, name, "GROUP_ENUM_ENTRY");
     637           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     638           0 :         ndr->depth++;
     639           0 :         ndr_print_ptr(ndr, "Name", r->Name);
     640           0 :         ndr->depth++;
     641           0 :         if (r->Name) {
     642           0 :                 ndr_print_string(ndr, "Name", r->Name);
     643             :         }
     644           0 :         ndr->depth--;
     645           0 :         ndr_print_ptr(ndr, "Id", r->Id);
     646           0 :         ndr->depth++;
     647           0 :         if (r->Id) {
     648           0 :                 ndr_print_string(ndr, "Id", r->Id);
     649             :         }
     650           0 :         ndr->depth--;
     651           0 :         ndr_print_uint32(ndr, "dwState", r->dwState);
     652           0 :         ndr_print_ptr(ndr, "Owner", r->Owner);
     653           0 :         ndr->depth++;
     654           0 :         if (r->Owner) {
     655           0 :                 ndr_print_string(ndr, "Owner", r->Owner);
     656             :         }
     657           0 :         ndr->depth--;
     658           0 :         ndr_print_uint32(ndr, "dwFlags", r->dwFlags);
     659           0 :         ndr_print_uint32(ndr, "cbProperties", r->cbProperties);
     660           0 :         ndr_print_ptr(ndr, "Properties", r->Properties);
     661           0 :         ndr->depth++;
     662           0 :         if (r->Properties) {
     663           0 :                 ndr_print_array_uint8(ndr, "Properties", r->Properties, r->cbProperties);
     664             :         }
     665           0 :         ndr->depth--;
     666           0 :         ndr_print_uint32(ndr, "cbRoProperties", r->cbRoProperties);
     667           0 :         ndr_print_ptr(ndr, "RoProperties", r->RoProperties);
     668           0 :         ndr->depth++;
     669           0 :         if (r->RoProperties) {
     670           0 :                 ndr_print_array_uint8(ndr, "RoProperties", r->RoProperties, r->cbRoProperties);
     671             :         }
     672           0 :         ndr->depth--;
     673           0 :         ndr->depth--;
     674             : }
     675             : 
     676           0 : static enum ndr_err_code ndr_push_RESOURCE_ENUM_ENTRY(struct ndr_push *ndr, int ndr_flags, const struct RESOURCE_ENUM_ENTRY *r)
     677             : {
     678           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     679           0 :         if (ndr_flags & NDR_SCALARS) {
     680           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     681           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->Name));
     682           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->Id));
     683           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->OwnerName));
     684           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->OwnerId));
     685           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbProperties));
     686           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->Properties));
     687           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbRoProperties));
     688           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->RoProperties));
     689           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     690             :         }
     691           0 :         if (ndr_flags & NDR_BUFFERS) {
     692           0 :                 if (r->Name) {
     693           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Name, CH_UTF16)));
     694           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     695           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Name, CH_UTF16)));
     696           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->Name, ndr_charset_length(r->Name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     697             :                 }
     698           0 :                 if (r->Id) {
     699           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Id, CH_UTF16)));
     700           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     701           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Id, CH_UTF16)));
     702           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->Id, ndr_charset_length(r->Id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     703             :                 }
     704           0 :                 if (r->OwnerName) {
     705           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->OwnerName, CH_UTF16)));
     706           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     707           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->OwnerName, CH_UTF16)));
     708           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->OwnerName, ndr_charset_length(r->OwnerName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     709             :                 }
     710           0 :                 if (r->OwnerId) {
     711           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->OwnerId, CH_UTF16)));
     712           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
     713           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->OwnerId, CH_UTF16)));
     714           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->OwnerId, ndr_charset_length(r->OwnerId, CH_UTF16), sizeof(uint16_t), CH_UTF16));
     715             :                 }
     716           0 :                 if (r->Properties) {
     717           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cbProperties));
     718           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Properties, r->cbProperties));
     719             :                 }
     720           0 :                 if (r->RoProperties) {
     721           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->cbRoProperties));
     722           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->RoProperties, r->cbRoProperties));
     723             :                 }
     724             :         }
     725           0 :         return NDR_ERR_SUCCESS;
     726             : }
     727             : 
     728           0 : static enum ndr_err_code ndr_pull_RESOURCE_ENUM_ENTRY(struct ndr_pull *ndr, int ndr_flags, struct RESOURCE_ENUM_ENTRY *r)
     729             : {
     730             :         uint32_t _ptr_Name;
     731           0 :         uint32_t size_Name_1 = 0;
     732           0 :         uint32_t length_Name_1 = 0;
     733           0 :         TALLOC_CTX *_mem_save_Name_0 = NULL;
     734             :         uint32_t _ptr_Id;
     735           0 :         uint32_t size_Id_1 = 0;
     736           0 :         uint32_t length_Id_1 = 0;
     737           0 :         TALLOC_CTX *_mem_save_Id_0 = NULL;
     738             :         uint32_t _ptr_OwnerName;
     739           0 :         uint32_t size_OwnerName_1 = 0;
     740           0 :         uint32_t length_OwnerName_1 = 0;
     741           0 :         TALLOC_CTX *_mem_save_OwnerName_0 = NULL;
     742             :         uint32_t _ptr_OwnerId;
     743           0 :         uint32_t size_OwnerId_1 = 0;
     744           0 :         uint32_t length_OwnerId_1 = 0;
     745           0 :         TALLOC_CTX *_mem_save_OwnerId_0 = NULL;
     746             :         uint32_t _ptr_Properties;
     747           0 :         uint32_t size_Properties_1 = 0;
     748           0 :         TALLOC_CTX *_mem_save_Properties_0 = NULL;
     749             :         uint32_t _ptr_RoProperties;
     750           0 :         uint32_t size_RoProperties_1 = 0;
     751           0 :         TALLOC_CTX *_mem_save_RoProperties_0 = NULL;
     752           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     753           0 :         if (ndr_flags & NDR_SCALARS) {
     754           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     755           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Name));
     756           0 :                 if (_ptr_Name) {
     757           0 :                         NDR_PULL_ALLOC(ndr, r->Name);
     758             :                 } else {
     759           0 :                         r->Name = NULL;
     760             :                 }
     761           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Id));
     762           0 :                 if (_ptr_Id) {
     763           0 :                         NDR_PULL_ALLOC(ndr, r->Id);
     764             :                 } else {
     765           0 :                         r->Id = NULL;
     766             :                 }
     767           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_OwnerName));
     768           0 :                 if (_ptr_OwnerName) {
     769           0 :                         NDR_PULL_ALLOC(ndr, r->OwnerName);
     770             :                 } else {
     771           0 :                         r->OwnerName = NULL;
     772             :                 }
     773           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_OwnerId));
     774           0 :                 if (_ptr_OwnerId) {
     775           0 :                         NDR_PULL_ALLOC(ndr, r->OwnerId);
     776             :                 } else {
     777           0 :                         r->OwnerId = NULL;
     778             :                 }
     779           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbProperties));
     780           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Properties));
     781           0 :                 if (_ptr_Properties) {
     782           0 :                         NDR_PULL_ALLOC(ndr, r->Properties);
     783             :                 } else {
     784           0 :                         r->Properties = NULL;
     785             :                 }
     786           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbRoProperties));
     787           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_RoProperties));
     788           0 :                 if (_ptr_RoProperties) {
     789           0 :                         NDR_PULL_ALLOC(ndr, r->RoProperties);
     790             :                 } else {
     791           0 :                         r->RoProperties = NULL;
     792             :                 }
     793           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     794             :         }
     795           0 :         if (ndr_flags & NDR_BUFFERS) {
     796           0 :                 if (r->Name) {
     797           0 :                         _mem_save_Name_0 = NDR_PULL_GET_MEM_CTX(ndr);
     798           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->Name, 0);
     799           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->Name));
     800           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->Name));
     801           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->Name, &size_Name_1));
     802           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->Name, &length_Name_1));
     803           0 :                         if (length_Name_1 > size_Name_1) {
     804           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_Name_1, length_Name_1);
     805             :                         }
     806           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_Name_1, sizeof(uint16_t)));
     807           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Name, length_Name_1, sizeof(uint16_t), CH_UTF16));
     808           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Name_0, 0);
     809             :                 }
     810           0 :                 if (r->Id) {
     811           0 :                         _mem_save_Id_0 = NDR_PULL_GET_MEM_CTX(ndr);
     812           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->Id, 0);
     813           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->Id));
     814           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->Id));
     815           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->Id, &size_Id_1));
     816           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->Id, &length_Id_1));
     817           0 :                         if (length_Id_1 > size_Id_1) {
     818           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_Id_1, length_Id_1);
     819             :                         }
     820           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_Id_1, sizeof(uint16_t)));
     821           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Id, length_Id_1, sizeof(uint16_t), CH_UTF16));
     822           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Id_0, 0);
     823             :                 }
     824           0 :                 if (r->OwnerName) {
     825           0 :                         _mem_save_OwnerName_0 = NDR_PULL_GET_MEM_CTX(ndr);
     826           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->OwnerName, 0);
     827           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->OwnerName));
     828           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->OwnerName));
     829           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->OwnerName, &size_OwnerName_1));
     830           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->OwnerName, &length_OwnerName_1));
     831           0 :                         if (length_OwnerName_1 > size_OwnerName_1) {
     832           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_OwnerName_1, length_OwnerName_1);
     833             :                         }
     834           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_OwnerName_1, sizeof(uint16_t)));
     835           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->OwnerName, length_OwnerName_1, sizeof(uint16_t), CH_UTF16));
     836           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_OwnerName_0, 0);
     837             :                 }
     838           0 :                 if (r->OwnerId) {
     839           0 :                         _mem_save_OwnerId_0 = NDR_PULL_GET_MEM_CTX(ndr);
     840           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->OwnerId, 0);
     841           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->OwnerId));
     842           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->OwnerId));
     843           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->OwnerId, &size_OwnerId_1));
     844           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->OwnerId, &length_OwnerId_1));
     845           0 :                         if (length_OwnerId_1 > size_OwnerId_1) {
     846           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_OwnerId_1, length_OwnerId_1);
     847             :                         }
     848           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_OwnerId_1, sizeof(uint16_t)));
     849           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->OwnerId, length_OwnerId_1, sizeof(uint16_t), CH_UTF16));
     850           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_OwnerId_0, 0);
     851             :                 }
     852           0 :                 if (r->Properties) {
     853           0 :                         _mem_save_Properties_0 = NDR_PULL_GET_MEM_CTX(ndr);
     854           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->Properties, 0);
     855           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->Properties));
     856           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->Properties, &size_Properties_1));
     857           0 :                         NDR_PULL_ALLOC_N(ndr, r->Properties, size_Properties_1);
     858           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Properties, size_Properties_1));
     859           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Properties_0, 0);
     860             :                 }
     861           0 :                 if (r->RoProperties) {
     862           0 :                         _mem_save_RoProperties_0 = NDR_PULL_GET_MEM_CTX(ndr);
     863           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->RoProperties, 0);
     864           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->RoProperties));
     865           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->RoProperties, &size_RoProperties_1));
     866           0 :                         NDR_PULL_ALLOC_N(ndr, r->RoProperties, size_RoProperties_1);
     867           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->RoProperties, size_RoProperties_1));
     868           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_RoProperties_0, 0);
     869             :                 }
     870           0 :                 if (r->Properties) {
     871           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->Properties, r->cbProperties));
     872             :                 }
     873           0 :                 if (r->RoProperties) {
     874           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->RoProperties, r->cbRoProperties));
     875             :                 }
     876             :         }
     877           0 :         return NDR_ERR_SUCCESS;
     878             : }
     879             : 
     880           0 : _PUBLIC_ void ndr_print_RESOURCE_ENUM_ENTRY(struct ndr_print *ndr, const char *name, const struct RESOURCE_ENUM_ENTRY *r)
     881             : {
     882           0 :         ndr_print_struct(ndr, name, "RESOURCE_ENUM_ENTRY");
     883           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     884           0 :         ndr->depth++;
     885           0 :         ndr_print_ptr(ndr, "Name", r->Name);
     886           0 :         ndr->depth++;
     887           0 :         if (r->Name) {
     888           0 :                 ndr_print_string(ndr, "Name", r->Name);
     889             :         }
     890           0 :         ndr->depth--;
     891           0 :         ndr_print_ptr(ndr, "Id", r->Id);
     892           0 :         ndr->depth++;
     893           0 :         if (r->Id) {
     894           0 :                 ndr_print_string(ndr, "Id", r->Id);
     895             :         }
     896           0 :         ndr->depth--;
     897           0 :         ndr_print_ptr(ndr, "OwnerName", r->OwnerName);
     898           0 :         ndr->depth++;
     899           0 :         if (r->OwnerName) {
     900           0 :                 ndr_print_string(ndr, "OwnerName", r->OwnerName);
     901             :         }
     902           0 :         ndr->depth--;
     903           0 :         ndr_print_ptr(ndr, "OwnerId", r->OwnerId);
     904           0 :         ndr->depth++;
     905           0 :         if (r->OwnerId) {
     906           0 :                 ndr_print_string(ndr, "OwnerId", r->OwnerId);
     907             :         }
     908           0 :         ndr->depth--;
     909           0 :         ndr_print_uint32(ndr, "cbProperties", r->cbProperties);
     910           0 :         ndr_print_ptr(ndr, "Properties", r->Properties);
     911           0 :         ndr->depth++;
     912           0 :         if (r->Properties) {
     913           0 :                 ndr_print_array_uint8(ndr, "Properties", r->Properties, r->cbProperties);
     914             :         }
     915           0 :         ndr->depth--;
     916           0 :         ndr_print_uint32(ndr, "cbRoProperties", r->cbRoProperties);
     917           0 :         ndr_print_ptr(ndr, "RoProperties", r->RoProperties);
     918           0 :         ndr->depth++;
     919           0 :         if (r->RoProperties) {
     920           0 :                 ndr_print_array_uint8(ndr, "RoProperties", r->RoProperties, r->cbRoProperties);
     921             :         }
     922           0 :         ndr->depth--;
     923           0 :         ndr->depth--;
     924             : }
     925             : 
     926           0 : static enum ndr_err_code ndr_push_GROUP_ENUM_LIST(struct ndr_push *ndr, int ndr_flags, const struct GROUP_ENUM_LIST *r)
     927             : {
     928             :         uint32_t cntr_Entry_0;
     929           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
     930           0 :         if (ndr_flags & NDR_SCALARS) {
     931           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->EntryCount));
     932           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
     933           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->EntryCount));
     934           0 :                 for (cntr_Entry_0 = 0; cntr_Entry_0 < (r->EntryCount); cntr_Entry_0++) {
     935           0 :                         NDR_CHECK(ndr_push_GROUP_ENUM_ENTRY(ndr, NDR_SCALARS, &r->Entry[cntr_Entry_0]));
     936             :                 }
     937           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
     938             :         }
     939           0 :         if (ndr_flags & NDR_BUFFERS) {
     940           0 :                 for (cntr_Entry_0 = 0; cntr_Entry_0 < (r->EntryCount); cntr_Entry_0++) {
     941           0 :                         NDR_CHECK(ndr_push_GROUP_ENUM_ENTRY(ndr, NDR_BUFFERS, &r->Entry[cntr_Entry_0]));
     942             :                 }
     943             :         }
     944           0 :         return NDR_ERR_SUCCESS;
     945             : }
     946             : 
     947           0 : static enum ndr_err_code ndr_pull_GROUP_ENUM_LIST(struct ndr_pull *ndr, int ndr_flags, struct GROUP_ENUM_LIST *r)
     948             : {
     949           0 :         uint32_t size_Entry_0 = 0;
     950             :         uint32_t cntr_Entry_0;
     951           0 :         TALLOC_CTX *_mem_save_Entry_0 = NULL;
     952           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
     953           0 :         if (ndr_flags & NDR_SCALARS) {
     954           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->Entry));
     955           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
     956           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->EntryCount));
     957           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->Entry, &size_Entry_0));
     958           0 :                 NDR_PULL_ALLOC_N(ndr, r->Entry, size_Entry_0);
     959           0 :                 _mem_save_Entry_0 = NDR_PULL_GET_MEM_CTX(ndr);
     960           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->Entry, 0);
     961           0 :                 for (cntr_Entry_0 = 0; cntr_Entry_0 < (size_Entry_0); cntr_Entry_0++) {
     962           0 :                         NDR_CHECK(ndr_pull_GROUP_ENUM_ENTRY(ndr, NDR_SCALARS, &r->Entry[cntr_Entry_0]));
     963             :                 }
     964           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Entry_0, 0);
     965           0 :                 if (r->Entry) {
     966           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->Entry, r->EntryCount));
     967             :                 }
     968           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
     969             :         }
     970           0 :         if (ndr_flags & NDR_BUFFERS) {
     971           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->Entry, &size_Entry_0));
     972           0 :                 _mem_save_Entry_0 = NDR_PULL_GET_MEM_CTX(ndr);
     973           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->Entry, 0);
     974           0 :                 for (cntr_Entry_0 = 0; cntr_Entry_0 < (size_Entry_0); cntr_Entry_0++) {
     975           0 :                         NDR_CHECK(ndr_pull_GROUP_ENUM_ENTRY(ndr, NDR_BUFFERS, &r->Entry[cntr_Entry_0]));
     976             :                 }
     977           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Entry_0, 0);
     978           0 :                 for (cntr_Entry_0 = 0; cntr_Entry_0 < (size_Entry_0); cntr_Entry_0++) {
     979             :                 }
     980             :         }
     981           0 :         return NDR_ERR_SUCCESS;
     982             : }
     983             : 
     984           0 : _PUBLIC_ void ndr_print_GROUP_ENUM_LIST(struct ndr_print *ndr, const char *name, const struct GROUP_ENUM_LIST *r)
     985             : {
     986             :         uint32_t cntr_Entry_0;
     987           0 :         ndr_print_struct(ndr, name, "GROUP_ENUM_LIST");
     988           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     989           0 :         ndr->depth++;
     990           0 :         ndr_print_uint32(ndr, "EntryCount", r->EntryCount);
     991           0 :         ndr->print(ndr, "%s: ARRAY(%d)", "Entry", (int)r->EntryCount);
     992           0 :         ndr->depth++;
     993           0 :         for (cntr_Entry_0 = 0; cntr_Entry_0 < (r->EntryCount); cntr_Entry_0++) {
     994           0 :                 ndr_print_GROUP_ENUM_ENTRY(ndr, "Entry", &r->Entry[cntr_Entry_0]);
     995             :         }
     996           0 :         ndr->depth--;
     997           0 :         ndr->depth--;
     998             : }
     999             : 
    1000           0 : static enum ndr_err_code ndr_push_RESOURCE_ENUM_LIST(struct ndr_push *ndr, int ndr_flags, const struct RESOURCE_ENUM_LIST *r)
    1001             : {
    1002             :         uint32_t cntr_Entry_0;
    1003           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1004           0 :         if (ndr_flags & NDR_SCALARS) {
    1005           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->EntryCount));
    1006           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    1007           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->EntryCount));
    1008           0 :                 for (cntr_Entry_0 = 0; cntr_Entry_0 < (r->EntryCount); cntr_Entry_0++) {
    1009           0 :                         NDR_CHECK(ndr_push_RESOURCE_ENUM_ENTRY(ndr, NDR_SCALARS, &r->Entry[cntr_Entry_0]));
    1010             :                 }
    1011           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    1012             :         }
    1013           0 :         if (ndr_flags & NDR_BUFFERS) {
    1014           0 :                 for (cntr_Entry_0 = 0; cntr_Entry_0 < (r->EntryCount); cntr_Entry_0++) {
    1015           0 :                         NDR_CHECK(ndr_push_RESOURCE_ENUM_ENTRY(ndr, NDR_BUFFERS, &r->Entry[cntr_Entry_0]));
    1016             :                 }
    1017             :         }
    1018           0 :         return NDR_ERR_SUCCESS;
    1019             : }
    1020             : 
    1021           0 : static enum ndr_err_code ndr_pull_RESOURCE_ENUM_LIST(struct ndr_pull *ndr, int ndr_flags, struct RESOURCE_ENUM_LIST *r)
    1022             : {
    1023           0 :         uint32_t size_Entry_0 = 0;
    1024             :         uint32_t cntr_Entry_0;
    1025           0 :         TALLOC_CTX *_mem_save_Entry_0 = NULL;
    1026           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1027           0 :         if (ndr_flags & NDR_SCALARS) {
    1028           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->Entry));
    1029           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    1030           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->EntryCount));
    1031           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->Entry, &size_Entry_0));
    1032           0 :                 NDR_PULL_ALLOC_N(ndr, r->Entry, size_Entry_0);
    1033           0 :                 _mem_save_Entry_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1034           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->Entry, 0);
    1035           0 :                 for (cntr_Entry_0 = 0; cntr_Entry_0 < (size_Entry_0); cntr_Entry_0++) {
    1036           0 :                         NDR_CHECK(ndr_pull_RESOURCE_ENUM_ENTRY(ndr, NDR_SCALARS, &r->Entry[cntr_Entry_0]));
    1037             :                 }
    1038           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Entry_0, 0);
    1039           0 :                 if (r->Entry) {
    1040           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->Entry, r->EntryCount));
    1041             :                 }
    1042           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    1043             :         }
    1044           0 :         if (ndr_flags & NDR_BUFFERS) {
    1045           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->Entry, &size_Entry_0));
    1046           0 :                 _mem_save_Entry_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1047           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->Entry, 0);
    1048           0 :                 for (cntr_Entry_0 = 0; cntr_Entry_0 < (size_Entry_0); cntr_Entry_0++) {
    1049           0 :                         NDR_CHECK(ndr_pull_RESOURCE_ENUM_ENTRY(ndr, NDR_BUFFERS, &r->Entry[cntr_Entry_0]));
    1050             :                 }
    1051           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Entry_0, 0);
    1052           0 :                 for (cntr_Entry_0 = 0; cntr_Entry_0 < (size_Entry_0); cntr_Entry_0++) {
    1053             :                 }
    1054             :         }
    1055           0 :         return NDR_ERR_SUCCESS;
    1056             : }
    1057             : 
    1058           0 : _PUBLIC_ void ndr_print_RESOURCE_ENUM_LIST(struct ndr_print *ndr, const char *name, const struct RESOURCE_ENUM_LIST *r)
    1059             : {
    1060             :         uint32_t cntr_Entry_0;
    1061           0 :         ndr_print_struct(ndr, name, "RESOURCE_ENUM_LIST");
    1062           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1063           0 :         ndr->depth++;
    1064           0 :         ndr_print_uint32(ndr, "EntryCount", r->EntryCount);
    1065           0 :         ndr->print(ndr, "%s: ARRAY(%d)", "Entry", (int)r->EntryCount);
    1066           0 :         ndr->depth++;
    1067           0 :         for (cntr_Entry_0 = 0; cntr_Entry_0 < (r->EntryCount); cntr_Entry_0++) {
    1068           0 :                 ndr_print_RESOURCE_ENUM_ENTRY(ndr, "Entry", &r->Entry[cntr_Entry_0]);
    1069             :         }
    1070           0 :         ndr->depth--;
    1071           0 :         ndr->depth--;
    1072             : }
    1073             : 
    1074           0 : static enum ndr_err_code ndr_push_clusapi_CreateResourceFlags(struct ndr_push *ndr, int ndr_flags, enum clusapi_CreateResourceFlags r)
    1075             : {
    1076           0 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    1077           0 :         return NDR_ERR_SUCCESS;
    1078             : }
    1079             : 
    1080           0 : static enum ndr_err_code ndr_pull_clusapi_CreateResourceFlags(struct ndr_pull *ndr, int ndr_flags, enum clusapi_CreateResourceFlags *r)
    1081             : {
    1082             :         uint32_t v;
    1083           0 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    1084           0 :         *r = v;
    1085           0 :         return NDR_ERR_SUCCESS;
    1086             : }
    1087             : 
    1088           0 : _PUBLIC_ void ndr_print_clusapi_CreateResourceFlags(struct ndr_print *ndr, const char *name, enum clusapi_CreateResourceFlags r)
    1089             : {
    1090           0 :         const char *val = NULL;
    1091             : 
    1092           0 :         switch (r) {
    1093           0 :                 case CLUSTER_RESOURCE_DEFAULT_MONITOR: val = "CLUSTER_RESOURCE_DEFAULT_MONITOR"; break;
    1094           0 :                 case CLUSTER_RESOURCE_SEPARATE_MONITOR: val = "CLUSTER_RESOURCE_SEPARATE_MONITOR"; break;
    1095             :         }
    1096           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1097           0 : }
    1098             : 
    1099           0 : static enum ndr_err_code ndr_push_clusapi_ClusterResourceState(struct ndr_push *ndr, int ndr_flags, enum clusapi_ClusterResourceState r)
    1100             : {
    1101           0 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    1102           0 :         return NDR_ERR_SUCCESS;
    1103             : }
    1104             : 
    1105           0 : static enum ndr_err_code ndr_pull_clusapi_ClusterResourceState(struct ndr_pull *ndr, int ndr_flags, enum clusapi_ClusterResourceState *r)
    1106             : {
    1107             :         uint32_t v;
    1108           0 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    1109           0 :         *r = v;
    1110           0 :         return NDR_ERR_SUCCESS;
    1111             : }
    1112             : 
    1113           0 : _PUBLIC_ void ndr_print_clusapi_ClusterResourceState(struct ndr_print *ndr, const char *name, enum clusapi_ClusterResourceState r)
    1114             : {
    1115           0 :         const char *val = NULL;
    1116             : 
    1117           0 :         switch (r) {
    1118           0 :                 case ClusterResourceInitializing: val = "ClusterResourceInitializing"; break;
    1119           0 :                 case ClusterResourceOnline: val = "ClusterResourceOnline"; break;
    1120           0 :                 case ClusterResourceOffline: val = "ClusterResourceOffline"; break;
    1121           0 :                 case ClusterResourceFailed: val = "ClusterResourceFailed"; break;
    1122           0 :                 case ClusterResourceOnlinePending: val = "ClusterResourceOnlinePending"; break;
    1123           0 :                 case ClusterResourceOfflinePending: val = "ClusterResourceOfflinePending"; break;
    1124           0 :                 case ClusterResourceStateUnknown: val = "ClusterResourceStateUnknown"; break;
    1125             :         }
    1126           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1127           0 : }
    1128             : 
    1129           0 : static enum ndr_err_code ndr_push_clusapi_ClusterGroupState(struct ndr_push *ndr, int ndr_flags, enum clusapi_ClusterGroupState r)
    1130             : {
    1131           0 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    1132           0 :         return NDR_ERR_SUCCESS;
    1133             : }
    1134             : 
    1135           0 : static enum ndr_err_code ndr_pull_clusapi_ClusterGroupState(struct ndr_pull *ndr, int ndr_flags, enum clusapi_ClusterGroupState *r)
    1136             : {
    1137             :         uint32_t v;
    1138           0 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    1139           0 :         *r = v;
    1140           0 :         return NDR_ERR_SUCCESS;
    1141             : }
    1142             : 
    1143           0 : _PUBLIC_ void ndr_print_clusapi_ClusterGroupState(struct ndr_print *ndr, const char *name, enum clusapi_ClusterGroupState r)
    1144             : {
    1145           0 :         const char *val = NULL;
    1146             : 
    1147           0 :         switch (r) {
    1148           0 :                 case ClusterGroupOnline: val = "ClusterGroupOnline"; break;
    1149           0 :                 case ClusterGroupOffline: val = "ClusterGroupOffline"; break;
    1150           0 :                 case ClusterGroupFailed: val = "ClusterGroupFailed"; break;
    1151           0 :                 case ClusterGroupPartialOnline: val = "ClusterGroupPartialOnline"; break;
    1152           0 :                 case ClusterGroupPending: val = "ClusterGroupPending"; break;
    1153           0 :                 case ClusterGroupStateUnknown: val = "ClusterGroupStateUnknown"; break;
    1154             :         }
    1155           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1156           0 : }
    1157             : 
    1158           0 : static enum ndr_err_code ndr_push_ClusterGroupEnumType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
    1159             : {
    1160           0 :         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
    1161           0 :         return NDR_ERR_SUCCESS;
    1162             : }
    1163             : 
    1164           0 : static enum ndr_err_code ndr_pull_ClusterGroupEnumType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
    1165             : {
    1166             :         uint32_t v;
    1167           0 :         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
    1168           0 :         *r = v;
    1169           0 :         return NDR_ERR_SUCCESS;
    1170             : }
    1171             : 
    1172           0 : _PUBLIC_ void ndr_print_ClusterGroupEnumType(struct ndr_print *ndr, const char *name, uint32_t r)
    1173             : {
    1174           0 :         ndr_print_uint32(ndr, name, r);
    1175           0 :         ndr->depth++;
    1176           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSTER_GROUP_ENUM_CONTAINS", CLUSTER_GROUP_ENUM_CONTAINS, r);
    1177           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSTER_GROUP_ENUM_NODES", CLUSTER_GROUP_ENUM_NODES, r);
    1178           0 :         ndr->depth--;
    1179           0 : }
    1180             : 
    1181           0 : static enum ndr_err_code ndr_push_clusapi_ClusterNodeState(struct ndr_push *ndr, int ndr_flags, enum clusapi_ClusterNodeState r)
    1182             : {
    1183           0 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    1184           0 :         return NDR_ERR_SUCCESS;
    1185             : }
    1186             : 
    1187           0 : static enum ndr_err_code ndr_pull_clusapi_ClusterNodeState(struct ndr_pull *ndr, int ndr_flags, enum clusapi_ClusterNodeState *r)
    1188             : {
    1189             :         uint32_t v;
    1190           0 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    1191           0 :         *r = v;
    1192           0 :         return NDR_ERR_SUCCESS;
    1193             : }
    1194             : 
    1195           0 : _PUBLIC_ void ndr_print_clusapi_ClusterNodeState(struct ndr_print *ndr, const char *name, enum clusapi_ClusterNodeState r)
    1196             : {
    1197           0 :         const char *val = NULL;
    1198             : 
    1199           0 :         switch (r) {
    1200           0 :                 case ClusterNodeUp: val = "ClusterNodeUp"; break;
    1201           0 :                 case ClusterNodeDown: val = "ClusterNodeDown"; break;
    1202           0 :                 case ClusterNodePaused: val = "ClusterNodePaused"; break;
    1203           0 :                 case ClusterNodeJoining: val = "ClusterNodeJoining"; break;
    1204           0 :                 case ClusterNodeStateUnknown: val = "ClusterNodeStateUnknown"; break;
    1205             :         }
    1206           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1207           0 : }
    1208             : 
    1209           0 : static enum ndr_err_code ndr_push_clusapi_ResourceClass(struct ndr_push *ndr, int ndr_flags, enum clusapi_ResourceClass r)
    1210             : {
    1211           0 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    1212           0 :         return NDR_ERR_SUCCESS;
    1213             : }
    1214             : 
    1215           0 : static enum ndr_err_code ndr_pull_clusapi_ResourceClass(struct ndr_pull *ndr, int ndr_flags, enum clusapi_ResourceClass *r)
    1216             : {
    1217             :         uint32_t v;
    1218           0 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    1219           0 :         *r = v;
    1220           0 :         return NDR_ERR_SUCCESS;
    1221             : }
    1222             : 
    1223           0 : _PUBLIC_ void ndr_print_clusapi_ResourceClass(struct ndr_print *ndr, const char *name, enum clusapi_ResourceClass r)
    1224             : {
    1225           0 :         const char *val = NULL;
    1226             : 
    1227           0 :         switch (r) {
    1228           0 :                 case CLUS_RESCLASS_UNKNOWN: val = "CLUS_RESCLASS_UNKNOWN"; break;
    1229           0 :                 case CLUS_RESCLASS_STORAGE: val = "CLUS_RESCLASS_STORAGE"; break;
    1230           0 :                 case CLUS_RESCLASS_NETWORK: val = "CLUS_RESCLASS_NETWORK"; break;
    1231             :         }
    1232           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1233           0 : }
    1234             : 
    1235           0 : _PUBLIC_ enum ndr_err_code ndr_push_CLUS_RESOURCE_CLASS_INFO(struct ndr_push *ndr, int ndr_flags, const struct CLUS_RESOURCE_CLASS_INFO *r)
    1236             : {
    1237           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1238           0 :         if (ndr_flags & NDR_SCALARS) {
    1239           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1240           0 :                 NDR_CHECK(ndr_push_clusapi_ResourceClass(ndr, NDR_SCALARS, r->Class));
    1241           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->SubClass));
    1242           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1243             :         }
    1244           0 :         if (ndr_flags & NDR_BUFFERS) {
    1245             :         }
    1246           0 :         return NDR_ERR_SUCCESS;
    1247             : }
    1248             : 
    1249           0 : _PUBLIC_ enum ndr_err_code ndr_pull_CLUS_RESOURCE_CLASS_INFO(struct ndr_pull *ndr, int ndr_flags, struct CLUS_RESOURCE_CLASS_INFO *r)
    1250             : {
    1251           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1252           0 :         if (ndr_flags & NDR_SCALARS) {
    1253           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1254           0 :                 NDR_CHECK(ndr_pull_clusapi_ResourceClass(ndr, NDR_SCALARS, &r->Class));
    1255           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->SubClass));
    1256           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1257             :         }
    1258           0 :         if (ndr_flags & NDR_BUFFERS) {
    1259             :         }
    1260           0 :         return NDR_ERR_SUCCESS;
    1261             : }
    1262             : 
    1263           0 : static void ndr_print_flags_CLUS_RESOURCE_CLASS_INFO(struct ndr_print *ndr, const char *name, int unused, const struct CLUS_RESOURCE_CLASS_INFO *r)
    1264             : {
    1265           0 :         ndr_print_CLUS_RESOURCE_CLASS_INFO(ndr, name, r);
    1266           0 : }
    1267             : 
    1268           0 : _PUBLIC_ void ndr_print_CLUS_RESOURCE_CLASS_INFO(struct ndr_print *ndr, const char *name, const struct CLUS_RESOURCE_CLASS_INFO *r)
    1269             : {
    1270           0 :         ndr_print_struct(ndr, name, "CLUS_RESOURCE_CLASS_INFO");
    1271           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1272           0 :         ndr->depth++;
    1273           0 :         ndr_print_clusapi_ResourceClass(ndr, "Class", r->Class);
    1274           0 :         ndr_print_uint32(ndr, "SubClass", r->SubClass);
    1275           0 :         ndr->depth--;
    1276             : }
    1277             : 
    1278           0 : static enum ndr_err_code ndr_push_clusapi_ResourceControlCode(struct ndr_push *ndr, int ndr_flags, enum clusapi_ResourceControlCode r)
    1279             : {
    1280           0 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    1281           0 :         return NDR_ERR_SUCCESS;
    1282             : }
    1283             : 
    1284           0 : static enum ndr_err_code ndr_pull_clusapi_ResourceControlCode(struct ndr_pull *ndr, int ndr_flags, enum clusapi_ResourceControlCode *r)
    1285             : {
    1286             :         uint32_t v;
    1287           0 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    1288           0 :         *r = v;
    1289           0 :         return NDR_ERR_SUCCESS;
    1290             : }
    1291             : 
    1292           0 : _PUBLIC_ void ndr_print_clusapi_ResourceControlCode(struct ndr_print *ndr, const char *name, enum clusapi_ResourceControlCode r)
    1293             : {
    1294           0 :         const char *val = NULL;
    1295             : 
    1296           0 :         switch (r) {
    1297           0 :                 case CLUSCTL_RESOURCE_UNKNOWN: val = "CLUSCTL_RESOURCE_UNKNOWN"; break;
    1298           0 :                 case CLUSCTL_RESOURCE_GET_CHARACTERISTICS: val = "CLUSCTL_RESOURCE_GET_CHARACTERISTICS"; break;
    1299           0 :                 case CLUSCTL_RESOURCE_GET_FLAGS: val = "CLUSCTL_RESOURCE_GET_FLAGS"; break;
    1300           0 :                 case CLUSCTL_RESOURCE_GET_CLASS_INFO: val = "CLUSCTL_RESOURCE_GET_CLASS_INFO"; break;
    1301           0 :                 case CLUSCTL_RESOURCE_GET_REQUIRED_DEPENDENCIES: val = "CLUSCTL_RESOURCE_GET_REQUIRED_DEPENDENCIES"; break;
    1302           0 :                 case CLUSCTL_RESOURCE_GET_NAME: val = "CLUSCTL_RESOURCE_GET_NAME"; break;
    1303           0 :                 case CLUSCTL_RESOURCE_GET_RESOURCE_TYPE: val = "CLUSCTL_RESOURCE_GET_RESOURCE_TYPE"; break;
    1304           0 :                 case CLUSCTL_RESOURCE_GET_ID: val = "CLUSCTL_RESOURCE_GET_ID"; break;
    1305           0 :                 case CLUSCTL_RESOURCE_ENUM_COMMON_PROPERTIES: val = "CLUSCTL_RESOURCE_ENUM_COMMON_PROPERTIES"; break;
    1306           0 :                 case CLUSCTL_RESOURCE_GET_RO_COMMON_PROPERTIES: val = "CLUSCTL_RESOURCE_GET_RO_COMMON_PROPERTIES"; break;
    1307           0 :                 case CLUSCTL_RESOURCE_GET_COMMON_PROPERTIES: val = "CLUSCTL_RESOURCE_GET_COMMON_PROPERTIES"; break;
    1308           0 :                 case CLUSCTL_RESOURCE_SET_COMMON_PROPERTIES: val = "CLUSCTL_RESOURCE_SET_COMMON_PROPERTIES"; break;
    1309           0 :                 case CLUSCTL_RESOURCE_VALIDATE_COMMON_PROPERTIES: val = "CLUSCTL_RESOURCE_VALIDATE_COMMON_PROPERTIES"; break;
    1310           0 :                 case CLUSCTL_RESOURCE_GET_COMMON_PROPERTY_FMTS: val = "CLUSCTL_RESOURCE_GET_COMMON_PROPERTY_FMTS"; break;
    1311           0 :                 case CLUSCTL_RESOURCE_ENUM_PRIVATE_PROPERTIES: val = "CLUSCTL_RESOURCE_ENUM_PRIVATE_PROPERTIES"; break;
    1312           0 :                 case CLUSCTL_RESOURCE_GET_RO_PRIVATE_PROPERTIES: val = "CLUSCTL_RESOURCE_GET_RO_PRIVATE_PROPERTIES"; break;
    1313           0 :                 case CLUSCTL_RESOURCE_GET_PRIVATE_PROPERTIES: val = "CLUSCTL_RESOURCE_GET_PRIVATE_PROPERTIES"; break;
    1314           0 :                 case CLUSCTL_RESOURCE_SET_PRIVATE_PROPERTIES: val = "CLUSCTL_RESOURCE_SET_PRIVATE_PROPERTIES"; break;
    1315           0 :                 case CLUSCTL_RESOURCE_VALIDATE_PRIVATE_PROPERTIES: val = "CLUSCTL_RESOURCE_VALIDATE_PRIVATE_PROPERTIES"; break;
    1316           0 :                 case CLUSCTL_RESOURCE_GET_PRIVATE_PROPERTY_FMTS: val = "CLUSCTL_RESOURCE_GET_PRIVATE_PROPERTY_FMTS"; break;
    1317           0 :                 case CLUSCTL_RESOURCE_ADD_REGISTRY_CHECKPOINT: val = "CLUSCTL_RESOURCE_ADD_REGISTRY_CHECKPOINT"; break;
    1318           0 :                 case CLUSCTL_RESOURCE_DELETE_REGISTRY_CHECKPOINT: val = "CLUSCTL_RESOURCE_DELETE_REGISTRY_CHECKPOINT"; break;
    1319           0 :                 case CLUSCTL_RESOURCE_GET_REGISTRY_CHECKPOINTS: val = "CLUSCTL_RESOURCE_GET_REGISTRY_CHECKPOINTS"; break;
    1320           0 :                 case CLUSCTL_RESOURCE_ADD_CRYPTO_CHECKPOINT: val = "CLUSCTL_RESOURCE_ADD_CRYPTO_CHECKPOINT"; break;
    1321           0 :                 case CLUSCTL_RESOURCE_DELETE_CRYPTO_CHECKPOINT: val = "CLUSCTL_RESOURCE_DELETE_CRYPTO_CHECKPOINT"; break;
    1322           0 :                 case CLUSCTL_RESOURCE_GET_CRYPTO_CHECKPOINTS: val = "CLUSCTL_RESOURCE_GET_CRYPTO_CHECKPOINTS"; break;
    1323           0 :                 case CLUSCTL_RESOURCE_UPGRADE_DLL: val = "CLUSCTL_RESOURCE_UPGRADE_DLL"; break;
    1324           0 :                 case CLUSCTL_RESOURCE_ADD_REGISTRY_CHECKPOINT_64BIT: val = "CLUSCTL_RESOURCE_ADD_REGISTRY_CHECKPOINT_64BIT"; break;
    1325           0 :                 case CLUSCTL_RESOURCE_ADD_REGISTRY_CHECKPOINT_32BIT: val = "CLUSCTL_RESOURCE_ADD_REGISTRY_CHECKPOINT_32BIT"; break;
    1326           0 :                 case CLUSCTL_RESOURCE_GET_NETWORK_NAME: val = "CLUSCTL_RESOURCE_GET_NETWORK_NAME"; break;
    1327           0 :                 case CLUSCTL_RESOURCE_NETNAME_REGISTER_DNS_RECORDS: val = "CLUSCTL_RESOURCE_NETNAME_REGISTER_DNS_RECORDS"; break;
    1328           0 :                 case CLUSCTL_RESOURCE_GET_DNS_NAME: val = "CLUSCTL_RESOURCE_GET_DNS_NAME"; break;
    1329           0 :                 case CLUSCTL_RESOURCE_NETNAME_SET_PWD_INFO: val = "CLUSCTL_RESOURCE_NETNAME_SET_PWD_INFO"; break;
    1330           0 :                 case CLUSCTL_RESOURCE_NETNAME_DELETE_CO: val = "CLUSCTL_RESOURCE_NETNAME_DELETE_CO"; break;
    1331           0 :                 case CLUSCTL_RESOURCE_NETNAME_VALIDATE_VCO: val = "CLUSCTL_RESOURCE_NETNAME_VALIDATE_VCO"; break;
    1332           0 :                 case CLUSCTL_RESOURCE_NETNAME_RESET_VCO: val = "CLUSCTL_RESOURCE_NETNAME_RESET_VCO"; break;
    1333           0 :                 case CLUSCTL_RESOURCE_NETNAME_CREDS_UPDATED: val = "CLUSCTL_RESOURCE_NETNAME_CREDS_UPDATED"; break;
    1334           0 :                 case CLUSCTL_RESOURCE_STORAGE_GET_DISK_INFO: val = "CLUSCTL_RESOURCE_STORAGE_GET_DISK_INFO"; break;
    1335           0 :                 case CLUSCTL_RESOURCE_STORAGE_IS_PATH_VALID: val = "CLUSCTL_RESOURCE_STORAGE_IS_PATH_VALID"; break;
    1336           0 :                 case CLUSCTL_RESOURCE_IPADDRESS_RENEW_LEASE: val = "CLUSCTL_RESOURCE_IPADDRESS_RENEW_LEASE"; break;
    1337           0 :                 case CLUSCTL_RESOURCE_IPADDRESS_RELEASE_LEASE: val = "CLUSCTL_RESOURCE_IPADDRESS_RELEASE_LEASE"; break;
    1338           0 :                 case CLUSCTL_RESOURCE_QUERY_MAINTENANCE_MODE: val = "CLUSCTL_RESOURCE_QUERY_MAINTENANCE_MODE"; break;
    1339           0 :                 case CLUSCTL_RESOURCE_SET_MAINTENANCE_MODE: val = "CLUSCTL_RESOURCE_SET_MAINTENANCE_MODE"; break;
    1340           0 :                 case CLUSCTL_RESOURCE_STORAGE_SET_DRIVELETTER: val = "CLUSCTL_RESOURCE_STORAGE_SET_DRIVELETTER"; break;
    1341           0 :                 case CLUSCTL_RESOURCE_STORAGE_GET_DISK_INFO_EX: val = "CLUSCTL_RESOURCE_STORAGE_GET_DISK_INFO_EX"; break;
    1342           0 :                 case CLUSCTL_RESOURCE_STORAGE_GET_DIRTY: val = "CLUSCTL_RESOURCE_STORAGE_GET_DIRTY"; break;
    1343           0 :                 case CLUSCTL_RESOURCE_STORAGE_GET_MOUNTPOINTS: val = "CLUSCTL_RESOURCE_STORAGE_GET_MOUNTPOINTS"; break;
    1344           0 :                 case CLUSCTL_RESOURCE_STORAGE_GET_SHARED_VOLUME_INFO: val = "CLUSCTL_RESOURCE_STORAGE_GET_SHARED_VOLUME_INFO"; break;
    1345           0 :                 case CLUSCTL_RESOURCE_VM_START_MIGRATION: val = "CLUSCTL_RESOURCE_VM_START_MIGRATION"; break;
    1346           0 :                 case CLUSCTL_RESOURCE_VM_CANCEL_MIGRATION: val = "CLUSCTL_RESOURCE_VM_CANCEL_MIGRATION"; break;
    1347           0 :                 case CLUSCTL_RESOURCE_SET_CSV_MAINTENANCE_MODE: val = "CLUSCTL_RESOURCE_SET_CSV_MAINTENANCE_MODE"; break;
    1348           0 :                 case CLUSCTL_RESOURCE_ENABLE_SHARED_VOLUME_DIRECTIO: val = "CLUSCTL_RESOURCE_ENABLE_SHARED_VOLUME_DIRECTIO"; break;
    1349           0 :                 case CLUSCTL_RESOURCE_DISABLE_SHARED_VOLUME_DIRECTIO: val = "CLUSCTL_RESOURCE_DISABLE_SHARED_VOLUME_DIRECTIO"; break;
    1350           0 :                 case CLUSCTL_RESOURCE_SET_SHARED_VOLUME_BACKUP_MODE: val = "CLUSCTL_RESOURCE_SET_SHARED_VOLUME_BACKUP_MODE"; break;
    1351           0 :                 case CLUSCTL_RESOURCE_GET_RELATED_RESOURCE_NAMES: val = "CLUSCTL_RESOURCE_GET_RELATED_RESOURCE_NAMES"; break;
    1352           0 :                 case CLUSCTL_RESOURCE_POOL_GET_DRIVE_INFO: val = "CLUSCTL_RESOURCE_POOL_GET_DRIVE_INFO"; break;
    1353           0 :                 case CLUSCTL_RESOURCE_CLOUD_WITNESS_UPDATE_TOKEN: val = "CLUSCTL_RESOURCE_CLOUD_WITNESS_UPDATE_TOKEN"; break;
    1354           0 :                 case CLUSCTL_RESOURCE_NETNAME_CHECK_OU_PERMISSIONS: val = "CLUSCTL_RESOURCE_NETNAME_CHECK_OU_PERMISSIONS"; break;
    1355           0 :                 case CLUSCTL_RESOURCE_NETNAME_CHECK_AD_STATE: val = "CLUSCTL_RESOURCE_NETNAME_CHECK_AD_STATE"; break;
    1356             :         }
    1357           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1358           0 : }
    1359             : 
    1360           0 : static enum ndr_err_code ndr_push_clusapi_ResourceTypeControlCode(struct ndr_push *ndr, int ndr_flags, enum clusapi_ResourceTypeControlCode r)
    1361             : {
    1362           0 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    1363           0 :         return NDR_ERR_SUCCESS;
    1364             : }
    1365             : 
    1366           0 : static enum ndr_err_code ndr_pull_clusapi_ResourceTypeControlCode(struct ndr_pull *ndr, int ndr_flags, enum clusapi_ResourceTypeControlCode *r)
    1367             : {
    1368             :         uint32_t v;
    1369           0 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    1370           0 :         *r = v;
    1371           0 :         return NDR_ERR_SUCCESS;
    1372             : }
    1373             : 
    1374           0 : _PUBLIC_ void ndr_print_clusapi_ResourceTypeControlCode(struct ndr_print *ndr, const char *name, enum clusapi_ResourceTypeControlCode r)
    1375             : {
    1376           0 :         const char *val = NULL;
    1377             : 
    1378           0 :         switch (r) {
    1379           0 :                 case CLUSCTL_RESOURCE_TYPE_UNKNOWN: val = "CLUSCTL_RESOURCE_TYPE_UNKNOWN"; break;
    1380           0 :                 case CLUSCTL_RESOURCE_TYPE_GET_CHARACTERISTICS: val = "CLUSCTL_RESOURCE_TYPE_GET_CHARACTERISTICS"; break;
    1381           0 :                 case CLUSCTL_RESOURCE_TYPE_GET_FLAGS: val = "CLUSCTL_RESOURCE_TYPE_GET_FLAGS"; break;
    1382           0 :                 case CLUSCTL_RESOURCE_TYPE_GET_CLASS_INFO: val = "CLUSCTL_RESOURCE_TYPE_GET_CLASS_INFO"; break;
    1383           0 :                 case CLUSCTL_RESOURCE_TYPE_GET_REQUIRED_DEPENDENCIES: val = "CLUSCTL_RESOURCE_TYPE_GET_REQUIRED_DEPENDENCIES"; break;
    1384           0 :                 case CLUSCTL_RESOURCE_TYPE_GET_ARB_TIMEOUT: val = "CLUSCTL_RESOURCE_TYPE_GET_ARB_TIMEOUT"; break;
    1385           0 :                 case CLUSCTL_RESOURCE_TYPE_ENUM_COMMON_PROPERTIES: val = "CLUSCTL_RESOURCE_TYPE_ENUM_COMMON_PROPERTIES"; break;
    1386           0 :                 case CLUSCTL_RESOURCE_TYPE_GET_RO_COMMON_PROPERTIES: val = "CLUSCTL_RESOURCE_TYPE_GET_RO_COMMON_PROPERTIES"; break;
    1387           0 :                 case CLUSCTL_RESOURCE_TYPE_GET_COMMON_PROPERTIES: val = "CLUSCTL_RESOURCE_TYPE_GET_COMMON_PROPERTIES"; break;
    1388           0 :                 case CLUSCTL_RESOURCE_TYPE_SET_COMMON_PROPERTIES: val = "CLUSCTL_RESOURCE_TYPE_SET_COMMON_PROPERTIES"; break;
    1389           0 :                 case CLUSCTL_RESOURCE_TYPE_VALIDATE_COMMON_PROPERTIES: val = "CLUSCTL_RESOURCE_TYPE_VALIDATE_COMMON_PROPERTIES"; break;
    1390           0 :                 case CLUSCTL_RESOURCE_TYPE_GET_COMMON_PROPERTY_FMTS: val = "CLUSCTL_RESOURCE_TYPE_GET_COMMON_PROPERTY_FMTS"; break;
    1391           0 :                 case CLUSCTL_RESOURCE_TYPE_GET_COMMON_RESOURCE_PROPERTY_FMTS: val = "CLUSCTL_RESOURCE_TYPE_GET_COMMON_RESOURCE_PROPERTY_FMTS"; break;
    1392           0 :                 case CLUSCTL_RESOURCE_TYPE_ENUM_PRIVATE_PROPERTIES: val = "CLUSCTL_RESOURCE_TYPE_ENUM_PRIVATE_PROPERTIES"; break;
    1393           0 :                 case CLUSCTL_RESOURCE_TYPE_GET_RO_PRIVATE_PROPERTIES: val = "CLUSCTL_RESOURCE_TYPE_GET_RO_PRIVATE_PROPERTIES"; break;
    1394           0 :                 case CLUSCTL_RESOURCE_TYPE_GET_PRIVATE_PROPERTIES: val = "CLUSCTL_RESOURCE_TYPE_GET_PRIVATE_PROPERTIES"; break;
    1395           0 :                 case CLUSCTL_RESOURCE_TYPE_SET_PRIVATE_PROPERTIES: val = "CLUSCTL_RESOURCE_TYPE_SET_PRIVATE_PROPERTIES"; break;
    1396           0 :                 case CLUSCTL_RESOURCE_TYPE_VALIDATE_PRIVATE_PROPERTIES: val = "CLUSCTL_RESOURCE_TYPE_VALIDATE_PRIVATE_PROPERTIES"; break;
    1397           0 :                 case CLUSCTL_RESOURCE_TYPE_GET_PRIVATE_PROPERTY_FMTS: val = "CLUSCTL_RESOURCE_TYPE_GET_PRIVATE_PROPERTY_FMTS"; break;
    1398           0 :                 case CLUSCTL_RESOURCE_TYPE_GET_PRIVATE_RESOURCE_PROPERTY_FMTS: val = "CLUSCTL_RESOURCE_TYPE_GET_PRIVATE_RESOURCE_PROPERTY_FMTS"; break;
    1399           0 :                 case CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS: val = "CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS"; break;
    1400           0 :                 case CLUSCTL_RESOURCE_TYPE_NETNAME_VALIDATE_NETNAME: val = "CLUSCTL_RESOURCE_TYPE_NETNAME_VALIDATE_NETNAME"; break;
    1401           0 :                 case CLUSCTL_RESOURCE_TYPE_VALIDATE_PATH: val = "CLUSCTL_RESOURCE_TYPE_VALIDATE_PATH"; break;
    1402           0 :                 case CLUSCTL_RESOURCE_TYPE_GEN_APP_VALIDATE_DIRECTORY: val = "CLUSCTL_RESOURCE_TYPE_GEN_APP_VALIDATE_DIRECTORY"; break;
    1403           0 :                 case CLUSCTL_RESOURCE_TYPE_STORAGE_GET_DRIVELETTERS: val = "CLUSCTL_RESOURCE_TYPE_STORAGE_GET_DRIVELETTERS"; break;
    1404           0 :                 case CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS_EX: val = "CLUSCTL_RESOURCE_TYPE_STORAGE_GET_AVAILABLE_DISKS_EX"; break;
    1405           0 :                 case CLUSCTL_RESOURCE_TYPE_STORAGE_REMAP_DRIVELETTER: val = "CLUSCTL_RESOURCE_TYPE_STORAGE_REMAP_DRIVELETTER"; break;
    1406           0 :                 case CLUSCTL_RESOURCE_TYPE_STORAGE_GET_DISKID: val = "CLUSCTL_RESOURCE_TYPE_STORAGE_GET_DISKID"; break;
    1407           0 :                 case CLUSCTL_RESOURCE_TYPE_STORAGE_IS_CLUSTERABLE: val = "CLUSCTL_RESOURCE_TYPE_STORAGE_IS_CLUSTERABLE"; break;
    1408           0 :                 case CLUSCTL_RESOURCE_TYPE_STORAGE_RELEASE_OWNERSHIP: val = "CLUSCTL_RESOURCE_TYPE_STORAGE_RELEASE_OWNERSHIP"; break;
    1409           0 :                 case CLUSCTL_RESOURCE_TYPE_STORAGE_IS_CSV_FILE: val = "CLUSCTL_RESOURCE_TYPE_STORAGE_IS_CSV_FILE"; break;
    1410           0 :                 case CLUSCTL_RESOURCE_TYPE_CLOUD_WITNESS_VALIDATE_CREDENTIALS: val = "CLUSCTL_RESOURCE_TYPE_CLOUD_WITNESS_VALIDATE_CREDENTIALS"; break;
    1411           0 :                 case CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_ELIGIBLE_LOGDISKS: val = "CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_ELIGIBLE_LOGDISKS"; break;
    1412           0 :                 case CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_ELIGIBLE_TARGET_DATADISKS: val = "CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_ELIGIBLE_TARGET_DATADISKS"; break;
    1413           0 :                 case CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_ELIGIBLE_SOURCE_DATADISKS: val = "CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_ELIGIBLE_SOURCE_DATADISKS"; break;
    1414           0 :                 case CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_REPLICA_VOLUMES: val = "CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_REPLICA_VOLUMES"; break;
    1415           0 :                 case CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_LOG_VOLUME: val = "CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_LOG_VOLUME"; break;
    1416           0 :                 case CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_REPLICATED_DISKS: val = "CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_REPLICATED_DISKS"; break;
    1417           0 :                 case CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_RESOURCE_GROUP: val = "CLUSCTL_RESOURCE_TYPE_REPLICATION_GET_RESOURCE_GROUP"; break;
    1418             :         }
    1419           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1420           0 : }
    1421             : 
    1422           0 : static enum ndr_err_code ndr_push_clusapi_GroupControlCode(struct ndr_push *ndr, int ndr_flags, enum clusapi_GroupControlCode r)
    1423             : {
    1424           0 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    1425           0 :         return NDR_ERR_SUCCESS;
    1426             : }
    1427             : 
    1428           0 : static enum ndr_err_code ndr_pull_clusapi_GroupControlCode(struct ndr_pull *ndr, int ndr_flags, enum clusapi_GroupControlCode *r)
    1429             : {
    1430             :         uint32_t v;
    1431           0 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    1432           0 :         *r = v;
    1433           0 :         return NDR_ERR_SUCCESS;
    1434             : }
    1435             : 
    1436           0 : _PUBLIC_ void ndr_print_clusapi_GroupControlCode(struct ndr_print *ndr, const char *name, enum clusapi_GroupControlCode r)
    1437             : {
    1438           0 :         const char *val = NULL;
    1439             : 
    1440           0 :         switch (r) {
    1441           0 :                 case CLUSCTL_GROUP_UNKNOWN: val = "CLUSCTL_GROUP_UNKNOWN"; break;
    1442           0 :                 case CLUSCTL_GROUP_GET_CHARACTERISTICS: val = "CLUSCTL_GROUP_GET_CHARACTERISTICS"; break;
    1443           0 :                 case CLUSCTL_GROUP_GET_FLAGS: val = "CLUSCTL_GROUP_GET_FLAGS"; break;
    1444           0 :                 case CLUSCTL_GROUP_GET_NAME: val = "CLUSCTL_GROUP_GET_NAME"; break;
    1445           0 :                 case CLUSCTL_GROUP_GET_ID: val = "CLUSCTL_GROUP_GET_ID"; break;
    1446           0 :                 case CLUSCTL_GROUP_ENUM_COMMON_PROPERTIES: val = "CLUSCTL_GROUP_ENUM_COMMON_PROPERTIES"; break;
    1447           0 :                 case CLUSCTL_GROUP_GET_RO_COMMON_PROPERTIES: val = "CLUSCTL_GROUP_GET_RO_COMMON_PROPERTIES"; break;
    1448           0 :                 case CLUSCTL_GROUP_GET_COMMON_PROPERTIES: val = "CLUSCTL_GROUP_GET_COMMON_PROPERTIES"; break;
    1449           0 :                 case CLUSCTL_GROUP_SET_COMMON_PROPERTIES: val = "CLUSCTL_GROUP_SET_COMMON_PROPERTIES"; break;
    1450           0 :                 case CLUSCTL_GROUP_VALIDATE_COMMON_PROPERTIES: val = "CLUSCTL_GROUP_VALIDATE_COMMON_PROPERTIES"; break;
    1451           0 :                 case CLUSCTL_GROUP_GET_COMMON_PROPERTY_FMTS: val = "CLUSCTL_GROUP_GET_COMMON_PROPERTY_FMTS"; break;
    1452           0 :                 case CLUSCTL_GROUP_ENUM_PRIVATE_PROPERTIES: val = "CLUSCTL_GROUP_ENUM_PRIVATE_PROPERTIES"; break;
    1453           0 :                 case CLUSCTL_GROUP_GET_RO_PRIVATE_PROPERTIES: val = "CLUSCTL_GROUP_GET_RO_PRIVATE_PROPERTIES"; break;
    1454           0 :                 case CLUSCTL_GROUP_GET_PRIVATE_PROPERTIES: val = "CLUSCTL_GROUP_GET_PRIVATE_PROPERTIES"; break;
    1455           0 :                 case CLUSCTL_GROUP_SET_PRIVATE_PROPERTIES: val = "CLUSCTL_GROUP_SET_PRIVATE_PROPERTIES"; break;
    1456           0 :                 case CLUSCTL_GROUP_VALIDATE_PRIVATE_PROPERTIES: val = "CLUSCTL_GROUP_VALIDATE_PRIVATE_PROPERTIES"; break;
    1457             :         }
    1458           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1459           0 : }
    1460             : 
    1461           0 : static enum ndr_err_code ndr_push_clusapi_NodeControlCode(struct ndr_push *ndr, int ndr_flags, enum clusapi_NodeControlCode r)
    1462             : {
    1463           0 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    1464           0 :         return NDR_ERR_SUCCESS;
    1465             : }
    1466             : 
    1467           0 : static enum ndr_err_code ndr_pull_clusapi_NodeControlCode(struct ndr_pull *ndr, int ndr_flags, enum clusapi_NodeControlCode *r)
    1468             : {
    1469             :         uint32_t v;
    1470           0 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    1471           0 :         *r = v;
    1472           0 :         return NDR_ERR_SUCCESS;
    1473             : }
    1474             : 
    1475           0 : _PUBLIC_ void ndr_print_clusapi_NodeControlCode(struct ndr_print *ndr, const char *name, enum clusapi_NodeControlCode r)
    1476             : {
    1477           0 :         const char *val = NULL;
    1478             : 
    1479           0 :         switch (r) {
    1480           0 :                 case CLUSCTL_NODE_UNKNOWN: val = "CLUSCTL_NODE_UNKNOWN"; break;
    1481           0 :                 case CLUSCTL_NODE_GET_CHARACTERISTICS: val = "CLUSCTL_NODE_GET_CHARACTERISTICS"; break;
    1482           0 :                 case CLUSCTL_NODE_GET_FLAGS: val = "CLUSCTL_NODE_GET_FLAGS"; break;
    1483           0 :                 case CLUSCTL_NODE_GET_NAME: val = "CLUSCTL_NODE_GET_NAME"; break;
    1484           0 :                 case CLUSCTL_NODE_GET_ID: val = "CLUSCTL_NODE_GET_ID"; break;
    1485           0 :                 case CLUSCTL_NODE_GET_CLUSTER_SERVICE_ACCOUNT_NAME: val = "CLUSCTL_NODE_GET_CLUSTER_SERVICE_ACCOUNT_NAME"; break;
    1486           0 :                 case CLUSCTL_NODE_ENUM_COMMON_PROPERTIES: val = "CLUSCTL_NODE_ENUM_COMMON_PROPERTIES"; break;
    1487           0 :                 case CLUSCTL_NODE_GET_RO_COMMON_PROPERTIES: val = "CLUSCTL_NODE_GET_RO_COMMON_PROPERTIES"; break;
    1488           0 :                 case CLUSCTL_NODE_GET_COMMON_PROPERTIES: val = "CLUSCTL_NODE_GET_COMMON_PROPERTIES"; break;
    1489           0 :                 case CLUSCTL_NODE_SET_COMMON_PROPERTIES: val = "CLUSCTL_NODE_SET_COMMON_PROPERTIES"; break;
    1490           0 :                 case CLUSCTL_NODE_VALIDATE_COMMON_PROPERTIES: val = "CLUSCTL_NODE_VALIDATE_COMMON_PROPERTIES"; break;
    1491           0 :                 case CLUSCTL_NODE_ENUM_PRIVATE_PROPERTIES: val = "CLUSCTL_NODE_ENUM_PRIVATE_PROPERTIES"; break;
    1492           0 :                 case CLUSCTL_NODE_GET_RO_PRIVATE_PROPERTIES: val = "CLUSCTL_NODE_GET_RO_PRIVATE_PROPERTIES"; break;
    1493           0 :                 case CLUSCTL_NODE_GET_PRIVATE_PROPERTIES: val = "CLUSCTL_NODE_GET_PRIVATE_PROPERTIES"; break;
    1494           0 :                 case CLUSCTL_NODE_SET_PRIVATE_PROPERTIES: val = "CLUSCTL_NODE_SET_PRIVATE_PROPERTIES"; break;
    1495           0 :                 case CLUSCTL_NODE_VALIDATE_PRIVATE_PROPERTIES: val = "CLUSCTL_NODE_VALIDATE_PRIVATE_PROPERTIES"; break;
    1496             :         }
    1497           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1498           0 : }
    1499             : 
    1500           0 : static enum ndr_err_code ndr_push_clusapi_ClusterNetworkState(struct ndr_push *ndr, int ndr_flags, enum clusapi_ClusterNetworkState r)
    1501             : {
    1502           0 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    1503           0 :         return NDR_ERR_SUCCESS;
    1504             : }
    1505             : 
    1506           0 : static enum ndr_err_code ndr_pull_clusapi_ClusterNetworkState(struct ndr_pull *ndr, int ndr_flags, enum clusapi_ClusterNetworkState *r)
    1507             : {
    1508             :         uint32_t v;
    1509           0 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    1510           0 :         *r = v;
    1511           0 :         return NDR_ERR_SUCCESS;
    1512             : }
    1513             : 
    1514           0 : _PUBLIC_ void ndr_print_clusapi_ClusterNetworkState(struct ndr_print *ndr, const char *name, enum clusapi_ClusterNetworkState r)
    1515             : {
    1516           0 :         const char *val = NULL;
    1517             : 
    1518           0 :         switch (r) {
    1519           0 :                 case ClusterNetworkUnavailable: val = "ClusterNetworkUnavailable"; break;
    1520           0 :                 case ClusterNetworkDown: val = "ClusterNetworkDown"; break;
    1521           0 :                 case ClusterNetworkPartitioned: val = "ClusterNetworkPartitioned"; break;
    1522           0 :                 case ClusterNetworkUp: val = "ClusterNetworkUp"; break;
    1523           0 :                 case ClusterNetworkStateUnknown: val = "ClusterNetworkStateUnknown"; break;
    1524             :         }
    1525           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1526           0 : }
    1527             : 
    1528           0 : static enum ndr_err_code ndr_push_clusapi_ClusterNetInterfaceState(struct ndr_push *ndr, int ndr_flags, enum clusapi_ClusterNetInterfaceState r)
    1529             : {
    1530           0 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    1531           0 :         return NDR_ERR_SUCCESS;
    1532             : }
    1533             : 
    1534           0 : static enum ndr_err_code ndr_pull_clusapi_ClusterNetInterfaceState(struct ndr_pull *ndr, int ndr_flags, enum clusapi_ClusterNetInterfaceState *r)
    1535             : {
    1536             :         uint32_t v;
    1537           0 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    1538           0 :         *r = v;
    1539           0 :         return NDR_ERR_SUCCESS;
    1540             : }
    1541             : 
    1542           0 : _PUBLIC_ void ndr_print_clusapi_ClusterNetInterfaceState(struct ndr_print *ndr, const char *name, enum clusapi_ClusterNetInterfaceState r)
    1543             : {
    1544           0 :         const char *val = NULL;
    1545             : 
    1546           0 :         switch (r) {
    1547           0 :                 case ClusterNetInterfaceFailed: val = "ClusterNetInterfaceFailed"; break;
    1548           0 :                 case ClusterNetInterfaceUnreachable: val = "ClusterNetInterfaceUnreachable"; break;
    1549           0 :                 case ClusterNetInterfaceUnavailable: val = "ClusterNetInterfaceUnavailable"; break;
    1550           0 :                 case ClusterNetInterfaceUp: val = "ClusterNetInterfaceUp"; break;
    1551           0 :                 case ClusterNetInterfaceStateUnknown: val = "ClusterNetInterfaceStateUnknown"; break;
    1552             :         }
    1553           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1554           0 : }
    1555             : 
    1556           0 : static enum ndr_err_code ndr_push_ClusterResTypeEnumType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
    1557             : {
    1558           0 :         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
    1559           0 :         return NDR_ERR_SUCCESS;
    1560             : }
    1561             : 
    1562           0 : static enum ndr_err_code ndr_pull_ClusterResTypeEnumType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
    1563             : {
    1564             :         uint32_t v;
    1565           0 :         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
    1566           0 :         *r = v;
    1567           0 :         return NDR_ERR_SUCCESS;
    1568             : }
    1569             : 
    1570           0 : _PUBLIC_ void ndr_print_ClusterResTypeEnumType(struct ndr_print *ndr, const char *name, uint32_t r)
    1571             : {
    1572           0 :         ndr_print_uint32(ndr, name, r);
    1573           0 :         ndr->depth++;
    1574           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSTER_RESOURCE_TYPE_ENUM_NODES", CLUSTER_RESOURCE_TYPE_ENUM_NODES, r);
    1575           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSTER_RESOURCE_TYPE_ENUM_RESOURCES", CLUSTER_RESOURCE_TYPE_ENUM_RESOURCES, r);
    1576           0 :         ndr->depth--;
    1577           0 : }
    1578             : 
    1579           0 : static enum ndr_err_code ndr_push_clusapi_ClusterControlCode(struct ndr_push *ndr, int ndr_flags, enum clusapi_ClusterControlCode r)
    1580             : {
    1581           0 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    1582           0 :         return NDR_ERR_SUCCESS;
    1583             : }
    1584             : 
    1585           0 : static enum ndr_err_code ndr_pull_clusapi_ClusterControlCode(struct ndr_pull *ndr, int ndr_flags, enum clusapi_ClusterControlCode *r)
    1586             : {
    1587             :         uint32_t v;
    1588           0 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    1589           0 :         *r = v;
    1590           0 :         return NDR_ERR_SUCCESS;
    1591             : }
    1592             : 
    1593           0 : _PUBLIC_ void ndr_print_clusapi_ClusterControlCode(struct ndr_print *ndr, const char *name, enum clusapi_ClusterControlCode r)
    1594             : {
    1595           0 :         const char *val = NULL;
    1596             : 
    1597           0 :         switch (r) {
    1598           0 :                 case CLUSCTL_CLUSTER_UNKNOWN: val = "CLUSCTL_CLUSTER_UNKNOWN"; break;
    1599           0 :                 case CLUSCTL_CLUSTER_GET_FQDN: val = "CLUSCTL_CLUSTER_GET_FQDN"; break;
    1600           0 :                 case CLUSCTL_CLUSTER_CHECK_VOTER_EVICT: val = "CLUSCTL_CLUSTER_CHECK_VOTER_EVICT"; break;
    1601           0 :                 case CLUSCTL_CLUSTER_CHECK_VOTER_DOWN: val = "CLUSCTL_CLUSTER_CHECK_VOTER_DOWN"; break;
    1602           0 :                 case CLUSCTL_CLUSTER_SHUTDOWN: val = "CLUSCTL_CLUSTER_SHUTDOWN"; break;
    1603           0 :                 case CLUSCTL_CLUSTER_ENUM_COMMON_PROPERTIES: val = "CLUSCTL_CLUSTER_ENUM_COMMON_PROPERTIES"; break;
    1604           0 :                 case CLUSCTL_CLUSTER_GET_RO_COMMON_PROPERTIES: val = "CLUSCTL_CLUSTER_GET_RO_COMMON_PROPERTIES"; break;
    1605           0 :                 case CLUSCTL_CLUSTER_GET_COMMON_PROPERTIES: val = "CLUSCTL_CLUSTER_GET_COMMON_PROPERTIES"; break;
    1606           0 :                 case CLUSCTL_CLUSTER_SET_COMMON_PROPERTIES: val = "CLUSCTL_CLUSTER_SET_COMMON_PROPERTIES"; break;
    1607           0 :                 case CLUSCTL_CLUSTER_VALIDATE_COMMON_PROPERTIES: val = "CLUSCTL_CLUSTER_VALIDATE_COMMON_PROPERTIES"; break;
    1608           0 :                 case CLUSCTL_CLUSTER_GET_COMMON_PROPERTY_FMTS: val = "CLUSCTL_CLUSTER_GET_COMMON_PROPERTY_FMTS"; break;
    1609           0 :                 case CLUSCTL_CLUSTER_ENUM_PRIVATE_PROPERTIES: val = "CLUSCTL_CLUSTER_ENUM_PRIVATE_PROPERTIES"; break;
    1610           0 :                 case CLUSCTL_CLUSTER_GET_RO_PRIVATE_PROPERTIES: val = "CLUSCTL_CLUSTER_GET_RO_PRIVATE_PROPERTIES"; break;
    1611           0 :                 case CLUSCTL_CLUSTER_GET_PRIVATE_PROPERTIES: val = "CLUSCTL_CLUSTER_GET_PRIVATE_PROPERTIES"; break;
    1612           0 :                 case CLUSCTL_CLUSTER_SET_PRIVATE_PROPERTIES: val = "CLUSCTL_CLUSTER_SET_PRIVATE_PROPERTIES"; break;
    1613           0 :                 case CLUSCTL_CLUSTER_VALIDATE_PRIVATE_PROPERTIES: val = "CLUSCTL_CLUSTER_VALIDATE_PRIVATE_PROPERTIES"; break;
    1614           0 :                 case CLUSCTL_CLUSTER_GET_SHARED_VOLUME_ID: val = "CLUSCTL_CLUSTER_GET_SHARED_VOLUME_ID"; break;
    1615           0 :                 case CLUSCTL_CLUSTER_UPGRADE_CLUSTER_VERSION: val = "CLUSCTL_CLUSTER_UPGRADE_CLUSTER_VERSION"; break;
    1616           0 :                 case CLUSCTL_CLUSTER_CLEAR_UPGRADE_IN_PROGRESS: val = "CLUSCTL_CLUSTER_CLEAR_UPGRADE_IN_PROGRESS"; break;
    1617           0 :                 case CLUSCTL_CLUSTER_IS_READY_FOR_UPGRADE: val = "CLUSCTL_CLUSTER_IS_READY_FOR_UPGRADE"; break;
    1618             :         }
    1619           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1620           0 : }
    1621             : 
    1622           0 : static enum ndr_err_code ndr_push_CLUSTER_PROPERTY_SYNTAX(struct ndr_push *ndr, int ndr_flags, enum CLUSTER_PROPERTY_SYNTAX r)
    1623             : {
    1624         112 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    1625           0 :         return NDR_ERR_SUCCESS;
    1626             : }
    1627             : 
    1628           0 : static enum ndr_err_code ndr_pull_CLUSTER_PROPERTY_SYNTAX(struct ndr_pull *ndr, int ndr_flags, enum CLUSTER_PROPERTY_SYNTAX *r)
    1629             : {
    1630             :         uint32_t v;
    1631         112 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    1632         112 :         *r = v;
    1633           0 :         return NDR_ERR_SUCCESS;
    1634             : }
    1635             : 
    1636         112 : _PUBLIC_ void ndr_print_CLUSTER_PROPERTY_SYNTAX(struct ndr_print *ndr, const char *name, enum CLUSTER_PROPERTY_SYNTAX r)
    1637             : {
    1638         112 :         const char *val = NULL;
    1639             : 
    1640         112 :         switch (r) {
    1641          40 :                 case CLUSPROP_SYNTAX_ENDMARK: val = "CLUSPROP_SYNTAX_ENDMARK"; break;
    1642          36 :                 case CLUSPROP_SYNTAX_NAME: val = "CLUSPROP_SYNTAX_NAME"; break;
    1643           0 :                 case CLUSPROP_SYNTAX_RESCLASS: val = "CLUSPROP_SYNTAX_RESCLASS"; break;
    1644           8 :                 case CLUSPROP_SYNTAX_LIST_VALUE_SZ: val = "CLUSPROP_SYNTAX_LIST_VALUE_SZ"; break;
    1645           0 :                 case CLUSPROP_SYNTAX_LIST_VALUE_EXPAND_SZ: val = "CLUSPROP_SYNTAX_LIST_VALUE_EXPAND_SZ"; break;
    1646          28 :                 case CLUSPROP_SYNTAX_LIST_VALUE_DWORD: val = "CLUSPROP_SYNTAX_LIST_VALUE_DWORD"; break;
    1647           0 :                 case CLUSPROP_SYNTAX_LIST_VALUE_BINARY: val = "CLUSPROP_SYNTAX_LIST_VALUE_BINARY"; break;
    1648           0 :                 case CLUSPROP_SYNTAX_LIST_VALUE_MULTI_SZ: val = "CLUSPROP_SYNTAX_LIST_VALUE_MULTI_SZ"; break;
    1649           0 :                 case CLUSPROP_SYNTAX_LIST_VALUE_LONG: val = "CLUSPROP_SYNTAX_LIST_VALUE_LONG"; break;
    1650           0 :                 case CLUSPROP_SYNTAX_LIST_VALUE_EXPANDED_SZ: val = "CLUSPROP_SYNTAX_LIST_VALUE_EXPANDED_SZ"; break;
    1651           0 :                 case CLUSPROP_SYNTAX_LIST_VALUE_SECURITY_DESCRIPTOR: val = "CLUSPROP_SYNTAX_LIST_VALUE_SECURITY_DESCRIPTOR"; break;
    1652           0 :                 case CLUSPROP_SYNTAX_LIST_VALUE_LARGE_INTEGER: val = "CLUSPROP_SYNTAX_LIST_VALUE_LARGE_INTEGER"; break;
    1653           0 :                 case CLUSPROP_SYNTAX_LIST_VALUE_ULARGE_INTEGER: val = "CLUSPROP_SYNTAX_LIST_VALUE_ULARGE_INTEGER"; break;
    1654           0 :                 case CLUSPROP_SYNTAX_LIST_VALUE_WORD: val = "CLUSPROP_SYNTAX_LIST_VALUE_WORD"; break;
    1655           0 :                 case CLUSPROP_SYNTAX_LIST_VALUE_FILETIME: val = "CLUSPROP_SYNTAX_LIST_VALUE_FILETIME"; break;
    1656           0 :                 case CLUSPROP_SYNTAX_DISK_SIGNATURE: val = "CLUSPROP_SYNTAX_DISK_SIGNATURE"; break;
    1657           0 :                 case CLUSPROP_SYNTAX_SCSI_ADDRESS: val = "CLUSPROP_SYNTAX_SCSI_ADDRESS"; break;
    1658           0 :                 case CLUSPROP_SYNTAX_DISK_NUMBER: val = "CLUSPROP_SYNTAX_DISK_NUMBER"; break;
    1659           0 :                 case CLUSPROP_SYNTAX_PARTITION_INFO: val = "CLUSPROP_SYNTAX_PARTITION_INFO"; break;
    1660           0 :                 case CLUSPROP_SYNTAX_DISK_SERIALNUMBER: val = "CLUSPROP_SYNTAX_DISK_SERIALNUMBER"; break;
    1661           0 :                 case CLUSPROP_SYNTAX_DISK_GUID: val = "CLUSPROP_SYNTAX_DISK_GUID"; break;
    1662           0 :                 case CLUSPROP_SYNTAX_DISK_SIZE: val = "CLUSPROP_SYNTAX_DISK_SIZE"; break;
    1663           0 :                 case CLUSPROP_SYNTAX_PARTITION_INFO_EX: val = "CLUSPROP_SYNTAX_PARTITION_INFO_EX"; break;
    1664             :         }
    1665         112 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    1666         112 : }
    1667             : 
    1668          36 : static enum ndr_err_code ndr_push_clusapi_propertyValues(struct ndr_push *ndr, int ndr_flags, const struct clusapi_propertyValues *r)
    1669             : {
    1670          36 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1671          36 :         if (ndr_flags & NDR_SCALARS) {
    1672          36 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1673          72 :                 NDR_CHECK(ndr_push_CLUSTER_PROPERTY_SYNTAX(ndr, NDR_SCALARS, r->Syntax));
    1674          36 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Size));
    1675             :                 {
    1676          36 :                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1677          36 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1678             :                         {
    1679             :                                 struct ndr_push *_ndr_Buffer;
    1680          36 :                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_Buffer, 0, r->Size));
    1681          36 :                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_Buffer, NDR_SCALARS, r->Buffer));
    1682          36 :                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_Buffer, 0, r->Size));
    1683             :                         }
    1684          36 :                         ndr->flags = _flags_save_DATA_BLOB;
    1685             :                 }
    1686             :                 {
    1687          36 :                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1688          36 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
    1689          36 :                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->Padding));
    1690          36 :                         ndr->flags = _flags_save_DATA_BLOB;
    1691             :                 }
    1692          36 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1693             :         }
    1694           0 :         if (ndr_flags & NDR_BUFFERS) {
    1695             :         }
    1696          36 :         return NDR_ERR_SUCCESS;
    1697             : }
    1698             : 
    1699          36 : static enum ndr_err_code ndr_pull_clusapi_propertyValues(struct ndr_pull *ndr, int ndr_flags, struct clusapi_propertyValues *r)
    1700             : {
    1701          36 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1702          36 :         if (ndr_flags & NDR_SCALARS) {
    1703          36 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1704          72 :                 NDR_CHECK(ndr_pull_CLUSTER_PROPERTY_SYNTAX(ndr, NDR_SCALARS, &r->Syntax));
    1705          36 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Size));
    1706             :                 {
    1707          36 :                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1708          36 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1709             :                         {
    1710             :                                 struct ndr_pull *_ndr_Buffer;
    1711          36 :                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_Buffer, 0, r->Size));
    1712          36 :                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_Buffer, NDR_SCALARS, &r->Buffer));
    1713          36 :                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_Buffer, 0, r->Size));
    1714             :                         }
    1715          36 :                         ndr->flags = _flags_save_DATA_BLOB;
    1716             :                 }
    1717             :                 {
    1718          36 :                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1719          36 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
    1720          36 :                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->Padding));
    1721          36 :                         ndr->flags = _flags_save_DATA_BLOB;
    1722             :                 }
    1723          36 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1724             :         }
    1725           0 :         if (ndr_flags & NDR_BUFFERS) {
    1726             :         }
    1727          36 :         return NDR_ERR_SUCCESS;
    1728             : }
    1729             : 
    1730          36 : _PUBLIC_ void ndr_print_clusapi_propertyValues(struct ndr_print *ndr, const char *name, const struct clusapi_propertyValues *r)
    1731             : {
    1732          36 :         ndr_print_struct(ndr, name, "clusapi_propertyValues");
    1733          36 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1734          36 :         ndr->depth++;
    1735          36 :         ndr_print_CLUSTER_PROPERTY_SYNTAX(ndr, "Syntax", r->Syntax);
    1736          36 :         ndr_print_uint32(ndr, "Size", r->Size);
    1737             :         {
    1738          36 :                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1739          36 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
    1740          36 :                 ndr_print_DATA_BLOB(ndr, "Buffer", r->Buffer);
    1741          36 :                 ndr->flags = _flags_save_DATA_BLOB;
    1742             :         }
    1743             :         {
    1744          36 :                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1745          36 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
    1746          36 :                 ndr_print_DATA_BLOB(ndr, "Padding", r->Padding);
    1747          36 :                 ndr->flags = _flags_save_DATA_BLOB;
    1748             :         }
    1749          36 :         ndr->depth--;
    1750             : }
    1751             : 
    1752          36 : static enum ndr_err_code ndr_push_clusapi_propertyValue(struct ndr_push *ndr, int ndr_flags, const struct clusapi_propertyValue *r)
    1753             : {
    1754          36 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1755          36 :         if (ndr_flags & NDR_SCALARS) {
    1756          36 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1757          72 :                 NDR_CHECK(ndr_push_CLUSTER_PROPERTY_SYNTAX(ndr, NDR_SCALARS, CLUSPROP_SYNTAX_NAME));
    1758          36 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m_term(r->buffer) * 2));
    1759             :                 {
    1760          36 :                         uint32_t _flags_save_string = ndr->flags;
    1761          36 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
    1762          36 :                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->buffer));
    1763          36 :                         ndr->flags = _flags_save_string;
    1764             :                 }
    1765             :                 {
    1766          36 :                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1767          36 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN2);
    1768          36 :                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->padding));
    1769          36 :                         ndr->flags = _flags_save_DATA_BLOB;
    1770             :                 }
    1771          36 :                 NDR_CHECK(ndr_push_clusapi_propertyValues(ndr, NDR_SCALARS, &r->PropertyValues));
    1772          72 :                 NDR_CHECK(ndr_push_CLUSTER_PROPERTY_SYNTAX(ndr, NDR_SCALARS, CLUSPROP_SYNTAX_ENDMARK));
    1773          36 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1774             :         }
    1775           0 :         if (ndr_flags & NDR_BUFFERS) {
    1776             :         }
    1777          36 :         return NDR_ERR_SUCCESS;
    1778             : }
    1779             : 
    1780          36 : static enum ndr_err_code ndr_pull_clusapi_propertyValue(struct ndr_pull *ndr, int ndr_flags, struct clusapi_propertyValue *r)
    1781             : {
    1782          36 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1783          36 :         if (ndr_flags & NDR_SCALARS) {
    1784          36 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1785          72 :                 NDR_CHECK(ndr_pull_CLUSTER_PROPERTY_SYNTAX(ndr, NDR_SCALARS, &r->syntax_name));
    1786          36 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
    1787             :                 {
    1788          36 :                         uint32_t _flags_save_string = ndr->flags;
    1789          36 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
    1790          36 :                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->buffer));
    1791          36 :                         ndr->flags = _flags_save_string;
    1792             :                 }
    1793             :                 {
    1794          36 :                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1795          36 :                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN2);
    1796          36 :                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->padding));
    1797          36 :                         ndr->flags = _flags_save_DATA_BLOB;
    1798             :                 }
    1799          36 :                 NDR_CHECK(ndr_pull_clusapi_propertyValues(ndr, NDR_SCALARS, &r->PropertyValues));
    1800          72 :                 NDR_CHECK(ndr_pull_CLUSTER_PROPERTY_SYNTAX(ndr, NDR_SCALARS, &r->end_mark));
    1801          36 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1802             :         }
    1803           0 :         if (ndr_flags & NDR_BUFFERS) {
    1804             :         }
    1805          36 :         return NDR_ERR_SUCCESS;
    1806             : }
    1807             : 
    1808          36 : _PUBLIC_ void ndr_print_clusapi_propertyValue(struct ndr_print *ndr, const char *name, const struct clusapi_propertyValue *r)
    1809             : {
    1810          36 :         ndr_print_struct(ndr, name, "clusapi_propertyValue");
    1811          36 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1812          36 :         ndr->depth++;
    1813          36 :         ndr_print_CLUSTER_PROPERTY_SYNTAX(ndr, "syntax_name", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?CLUSPROP_SYNTAX_NAME:r->syntax_name);
    1814          36 :         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term(r->buffer) * 2:r->size);
    1815             :         {
    1816          36 :                 uint32_t _flags_save_string = ndr->flags;
    1817          36 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
    1818          36 :                 ndr_print_string(ndr, "buffer", r->buffer);
    1819          36 :                 ndr->flags = _flags_save_string;
    1820             :         }
    1821             :         {
    1822          36 :                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
    1823          36 :                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN2);
    1824          36 :                 ndr_print_DATA_BLOB(ndr, "padding", r->padding);
    1825          36 :                 ndr->flags = _flags_save_DATA_BLOB;
    1826             :         }
    1827          36 :         ndr_print_clusapi_propertyValues(ndr, "PropertyValues", &r->PropertyValues);
    1828          36 :         ndr_print_CLUSTER_PROPERTY_SYNTAX(ndr, "end_mark", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?CLUSPROP_SYNTAX_ENDMARK:r->end_mark);
    1829          36 :         ndr->depth--;
    1830             : }
    1831             : 
    1832           4 : _PUBLIC_ enum ndr_err_code ndr_push_clusapi_PROPERTY_LIST(struct ndr_push *ndr, int ndr_flags, const struct clusapi_PROPERTY_LIST *r)
    1833             : {
    1834             :         uint32_t cntr_propertyValues_0;
    1835           4 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1836           4 :         if (ndr_flags & NDR_SCALARS) {
    1837           4 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    1838           4 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->propertyCount));
    1839          36 :                 for (cntr_propertyValues_0 = 0; cntr_propertyValues_0 < (r->propertyCount); cntr_propertyValues_0++) {
    1840          36 :                         NDR_CHECK(ndr_push_clusapi_propertyValue(ndr, NDR_SCALARS, &r->propertyValues[cntr_propertyValues_0]));
    1841             :                 }
    1842           8 :                 NDR_CHECK(ndr_push_CLUSTER_PROPERTY_SYNTAX(ndr, NDR_SCALARS, CLUSPROP_SYNTAX_ENDMARK));
    1843           4 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    1844             :         }
    1845           0 :         if (ndr_flags & NDR_BUFFERS) {
    1846             :         }
    1847           4 :         return NDR_ERR_SUCCESS;
    1848             : }
    1849             : 
    1850           4 : _PUBLIC_ enum ndr_err_code ndr_pull_clusapi_PROPERTY_LIST(struct ndr_pull *ndr, int ndr_flags, struct clusapi_PROPERTY_LIST *r)
    1851             : {
    1852           4 :         uint32_t size_propertyValues_0 = 0;
    1853             :         uint32_t cntr_propertyValues_0;
    1854           4 :         TALLOC_CTX *_mem_save_propertyValues_0 = NULL;
    1855           4 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1856           4 :         if (ndr_flags & NDR_SCALARS) {
    1857           4 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    1858           4 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->propertyCount));
    1859           4 :                 size_propertyValues_0 = r->propertyCount;
    1860           4 :                 NDR_PULL_ALLOC_N(ndr, r->propertyValues, size_propertyValues_0);
    1861           4 :                 _mem_save_propertyValues_0 = NDR_PULL_GET_MEM_CTX(ndr);
    1862           4 :                 NDR_PULL_SET_MEM_CTX(ndr, r->propertyValues, 0);
    1863          40 :                 for (cntr_propertyValues_0 = 0; cntr_propertyValues_0 < (size_propertyValues_0); cntr_propertyValues_0++) {
    1864          36 :                         NDR_CHECK(ndr_pull_clusapi_propertyValue(ndr, NDR_SCALARS, &r->propertyValues[cntr_propertyValues_0]));
    1865             :                 }
    1866           4 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_propertyValues_0, 0);
    1867           8 :                 NDR_CHECK(ndr_pull_CLUSTER_PROPERTY_SYNTAX(ndr, NDR_SCALARS, &r->end_mark));
    1868           4 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    1869             :         }
    1870           0 :         if (ndr_flags & NDR_BUFFERS) {
    1871             :         }
    1872           4 :         return NDR_ERR_SUCCESS;
    1873             : }
    1874             : 
    1875           0 : static void ndr_print_flags_clusapi_PROPERTY_LIST(struct ndr_print *ndr, const char *name, int unused, const struct clusapi_PROPERTY_LIST *r)
    1876             : {
    1877           0 :         ndr_print_clusapi_PROPERTY_LIST(ndr, name, r);
    1878           0 : }
    1879             : 
    1880           4 : _PUBLIC_ void ndr_print_clusapi_PROPERTY_LIST(struct ndr_print *ndr, const char *name, const struct clusapi_PROPERTY_LIST *r)
    1881             : {
    1882             :         uint32_t cntr_propertyValues_0;
    1883           4 :         ndr_print_struct(ndr, name, "clusapi_PROPERTY_LIST");
    1884           4 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1885           4 :         ndr->depth++;
    1886           4 :         ndr_print_uint32(ndr, "propertyCount", r->propertyCount);
    1887           4 :         ndr->print(ndr, "%s: ARRAY(%d)", "propertyValues", (int)r->propertyCount);
    1888           4 :         ndr->depth++;
    1889          40 :         for (cntr_propertyValues_0 = 0; cntr_propertyValues_0 < (r->propertyCount); cntr_propertyValues_0++) {
    1890          36 :                 ndr_print_clusapi_propertyValue(ndr, "propertyValues", &r->propertyValues[cntr_propertyValues_0]);
    1891             :         }
    1892           4 :         ndr->depth--;
    1893           4 :         ndr_print_CLUSTER_PROPERTY_SYNTAX(ndr, "end_mark", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?CLUSPROP_SYNTAX_ENDMARK:r->end_mark);
    1894           4 :         ndr->depth--;
    1895             : }
    1896             : 
    1897           0 : static enum ndr_err_code ndr_push_clusapi_DesiredAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
    1898             : {
    1899           0 :         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
    1900           0 :         return NDR_ERR_SUCCESS;
    1901             : }
    1902             : 
    1903           0 : static enum ndr_err_code ndr_pull_clusapi_DesiredAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
    1904             : {
    1905             :         uint32_t v;
    1906           0 :         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
    1907           0 :         *r = v;
    1908           0 :         return NDR_ERR_SUCCESS;
    1909             : }
    1910             : 
    1911           0 : _PUBLIC_ void ndr_print_clusapi_DesiredAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
    1912             : {
    1913           0 :         ndr_print_uint32(ndr, name, r);
    1914           0 :         ndr->depth++;
    1915           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSAPI_READ_ACCESS", CLUSAPI_READ_ACCESS, r);
    1916           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSAPI_CHANGE_ACCESS", CLUSAPI_CHANGE_ACCESS, r);
    1917           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSAPI_GENERIC_READ", CLUSAPI_GENERIC_READ, r);
    1918           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSAPI_GENERIC_WRITE", CLUSAPI_GENERIC_WRITE, r);
    1919           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSAPI_GENERIC_EXECUTE", CLUSAPI_GENERIC_EXECUTE, r);
    1920           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSAPI_GENERIC_ALL", CLUSAPI_GENERIC_ALL, r);
    1921           0 :         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "CLUSAPI_MAXIMUM_ALLOWED", CLUSAPI_MAXIMUM_ALLOWED, r);
    1922           0 :         ndr->depth--;
    1923           0 : }
    1924             : 
    1925           0 : static enum ndr_err_code ndr_push_NOTIFY_FILTER_AND_TYPE_RPC(struct ndr_push *ndr, int ndr_flags, const struct NOTIFY_FILTER_AND_TYPE_RPC *r)
    1926             : {
    1927           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1928           0 :         if (ndr_flags & NDR_SCALARS) {
    1929           0 :                 NDR_CHECK(ndr_push_align(ndr, 8));
    1930           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwObjectType));
    1931           0 :                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->FilterFlags));
    1932           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
    1933             :         }
    1934           0 :         if (ndr_flags & NDR_BUFFERS) {
    1935             :         }
    1936           0 :         return NDR_ERR_SUCCESS;
    1937             : }
    1938             : 
    1939           0 : static enum ndr_err_code ndr_pull_NOTIFY_FILTER_AND_TYPE_RPC(struct ndr_pull *ndr, int ndr_flags, struct NOTIFY_FILTER_AND_TYPE_RPC *r)
    1940             : {
    1941           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    1942           0 :         if (ndr_flags & NDR_SCALARS) {
    1943           0 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
    1944           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwObjectType));
    1945           0 :                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->FilterFlags));
    1946           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
    1947             :         }
    1948           0 :         if (ndr_flags & NDR_BUFFERS) {
    1949             :         }
    1950           0 :         return NDR_ERR_SUCCESS;
    1951             : }
    1952             : 
    1953           0 : _PUBLIC_ void ndr_print_NOTIFY_FILTER_AND_TYPE_RPC(struct ndr_print *ndr, const char *name, const struct NOTIFY_FILTER_AND_TYPE_RPC *r)
    1954             : {
    1955           0 :         ndr_print_struct(ndr, name, "NOTIFY_FILTER_AND_TYPE_RPC");
    1956           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    1957           0 :         ndr->depth++;
    1958           0 :         ndr_print_uint32(ndr, "dwObjectType", r->dwObjectType);
    1959           0 :         ndr_print_hyper(ndr, "FilterFlags", r->FilterFlags);
    1960           0 :         ndr->depth--;
    1961             : }
    1962             : 
    1963           0 : static enum ndr_err_code ndr_push_NOTIFICATION_DATA_RPC(struct ndr_push *ndr, int ndr_flags, const struct NOTIFICATION_DATA_RPC *r)
    1964             : {
    1965           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    1966           0 :         if (ndr_flags & NDR_SCALARS) {
    1967           0 :                 NDR_CHECK(ndr_push_align(ndr, 8));
    1968           0 :                 NDR_CHECK(ndr_push_NOTIFY_FILTER_AND_TYPE_RPC(ndr, NDR_SCALARS, &r->FilterAndType));
    1969           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->buffer));
    1970           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwBufferSize));
    1971           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ObjectId));
    1972           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ParentId));
    1973           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->Name));
    1974           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->Type));
    1975           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
    1976             :         }
    1977           0 :         if (ndr_flags & NDR_BUFFERS) {
    1978           0 :                 if (r->buffer) {
    1979           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->dwBufferSize));
    1980           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->buffer, r->dwBufferSize));
    1981             :                 }
    1982           0 :                 if (r->ObjectId) {
    1983           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ObjectId, CH_UTF16)));
    1984           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    1985           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ObjectId, CH_UTF16)));
    1986           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ObjectId, ndr_charset_length(r->ObjectId, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    1987             :                 }
    1988           0 :                 if (r->ParentId) {
    1989           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ParentId, CH_UTF16)));
    1990           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    1991           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ParentId, CH_UTF16)));
    1992           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ParentId, ndr_charset_length(r->ParentId, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    1993             :                 }
    1994           0 :                 if (r->Name) {
    1995           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Name, CH_UTF16)));
    1996           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    1997           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Name, CH_UTF16)));
    1998           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->Name, ndr_charset_length(r->Name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    1999             :                 }
    2000           0 :                 if (r->Type) {
    2001           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Type, CH_UTF16)));
    2002           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2003           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Type, CH_UTF16)));
    2004           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->Type, ndr_charset_length(r->Type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    2005             :                 }
    2006             :         }
    2007           0 :         return NDR_ERR_SUCCESS;
    2008             : }
    2009             : 
    2010           0 : static enum ndr_err_code ndr_pull_NOTIFICATION_DATA_RPC(struct ndr_pull *ndr, int ndr_flags, struct NOTIFICATION_DATA_RPC *r)
    2011             : {
    2012             :         uint32_t _ptr_buffer;
    2013           0 :         uint32_t size_buffer_1 = 0;
    2014           0 :         TALLOC_CTX *_mem_save_buffer_0 = NULL;
    2015             :         uint32_t _ptr_ObjectId;
    2016           0 :         uint32_t size_ObjectId_1 = 0;
    2017           0 :         uint32_t length_ObjectId_1 = 0;
    2018           0 :         TALLOC_CTX *_mem_save_ObjectId_0 = NULL;
    2019             :         uint32_t _ptr_ParentId;
    2020           0 :         uint32_t size_ParentId_1 = 0;
    2021           0 :         uint32_t length_ParentId_1 = 0;
    2022           0 :         TALLOC_CTX *_mem_save_ParentId_0 = NULL;
    2023             :         uint32_t _ptr_Name;
    2024           0 :         uint32_t size_Name_1 = 0;
    2025           0 :         uint32_t length_Name_1 = 0;
    2026           0 :         TALLOC_CTX *_mem_save_Name_0 = NULL;
    2027             :         uint32_t _ptr_Type;
    2028           0 :         uint32_t size_Type_1 = 0;
    2029           0 :         uint32_t length_Type_1 = 0;
    2030           0 :         TALLOC_CTX *_mem_save_Type_0 = NULL;
    2031           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2032           0 :         if (ndr_flags & NDR_SCALARS) {
    2033           0 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
    2034           0 :                 NDR_CHECK(ndr_pull_NOTIFY_FILTER_AND_TYPE_RPC(ndr, NDR_SCALARS, &r->FilterAndType));
    2035           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
    2036           0 :                 if (_ptr_buffer) {
    2037           0 :                         NDR_PULL_ALLOC(ndr, r->buffer);
    2038             :                 } else {
    2039           0 :                         r->buffer = NULL;
    2040             :                 }
    2041           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwBufferSize));
    2042           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ObjectId));
    2043           0 :                 if (_ptr_ObjectId) {
    2044           0 :                         NDR_PULL_ALLOC(ndr, r->ObjectId);
    2045             :                 } else {
    2046           0 :                         r->ObjectId = NULL;
    2047             :                 }
    2048           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ParentId));
    2049           0 :                 if (_ptr_ParentId) {
    2050           0 :                         NDR_PULL_ALLOC(ndr, r->ParentId);
    2051             :                 } else {
    2052           0 :                         r->ParentId = NULL;
    2053             :                 }
    2054           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Name));
    2055           0 :                 if (_ptr_Name) {
    2056           0 :                         NDR_PULL_ALLOC(ndr, r->Name);
    2057             :                 } else {
    2058           0 :                         r->Name = NULL;
    2059             :                 }
    2060           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Type));
    2061           0 :                 if (_ptr_Type) {
    2062           0 :                         NDR_PULL_ALLOC(ndr, r->Type);
    2063             :                 } else {
    2064           0 :                         r->Type = NULL;
    2065             :                 }
    2066           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
    2067             :         }
    2068           0 :         if (ndr_flags & NDR_BUFFERS) {
    2069           0 :                 if (r->buffer) {
    2070           0 :                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2071           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->buffer, 0);
    2072           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->buffer));
    2073           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->buffer, &size_buffer_1));
    2074           0 :                         NDR_PULL_ALLOC_N(ndr, r->buffer, size_buffer_1);
    2075           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->buffer, size_buffer_1));
    2076           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
    2077             :                 }
    2078           0 :                 if (r->ObjectId) {
    2079           0 :                         _mem_save_ObjectId_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2080           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->ObjectId, 0);
    2081           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ObjectId));
    2082           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ObjectId));
    2083           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->ObjectId, &size_ObjectId_1));
    2084           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->ObjectId, &length_ObjectId_1));
    2085           0 :                         if (length_ObjectId_1 > size_ObjectId_1) {
    2086           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ObjectId_1, length_ObjectId_1);
    2087             :                         }
    2088           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_ObjectId_1, sizeof(uint16_t)));
    2089           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ObjectId, length_ObjectId_1, sizeof(uint16_t), CH_UTF16));
    2090           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ObjectId_0, 0);
    2091             :                 }
    2092           0 :                 if (r->ParentId) {
    2093           0 :                         _mem_save_ParentId_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2094           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->ParentId, 0);
    2095           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ParentId));
    2096           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ParentId));
    2097           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->ParentId, &size_ParentId_1));
    2098           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->ParentId, &length_ParentId_1));
    2099           0 :                         if (length_ParentId_1 > size_ParentId_1) {
    2100           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ParentId_1, length_ParentId_1);
    2101             :                         }
    2102           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_ParentId_1, sizeof(uint16_t)));
    2103           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ParentId, length_ParentId_1, sizeof(uint16_t), CH_UTF16));
    2104           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ParentId_0, 0);
    2105             :                 }
    2106           0 :                 if (r->Name) {
    2107           0 :                         _mem_save_Name_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2108           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->Name, 0);
    2109           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->Name));
    2110           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->Name));
    2111           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->Name, &size_Name_1));
    2112           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->Name, &length_Name_1));
    2113           0 :                         if (length_Name_1 > size_Name_1) {
    2114           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_Name_1, length_Name_1);
    2115             :                         }
    2116           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_Name_1, sizeof(uint16_t)));
    2117           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Name, length_Name_1, sizeof(uint16_t), CH_UTF16));
    2118           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Name_0, 0);
    2119             :                 }
    2120           0 :                 if (r->Type) {
    2121           0 :                         _mem_save_Type_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2122           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->Type, 0);
    2123           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->Type));
    2124           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->Type));
    2125           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->Type, &size_Type_1));
    2126           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->Type, &length_Type_1));
    2127           0 :                         if (length_Type_1 > size_Type_1) {
    2128           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_Type_1, length_Type_1);
    2129             :                         }
    2130           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_Type_1, sizeof(uint16_t)));
    2131           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Type, length_Type_1, sizeof(uint16_t), CH_UTF16));
    2132           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Type_0, 0);
    2133             :                 }
    2134           0 :                 if (r->buffer) {
    2135           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->buffer, r->dwBufferSize));
    2136             :                 }
    2137             :         }
    2138           0 :         return NDR_ERR_SUCCESS;
    2139             : }
    2140             : 
    2141           0 : _PUBLIC_ void ndr_print_NOTIFICATION_DATA_RPC(struct ndr_print *ndr, const char *name, const struct NOTIFICATION_DATA_RPC *r)
    2142             : {
    2143           0 :         ndr_print_struct(ndr, name, "NOTIFICATION_DATA_RPC");
    2144           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2145           0 :         ndr->depth++;
    2146           0 :         ndr_print_NOTIFY_FILTER_AND_TYPE_RPC(ndr, "FilterAndType", &r->FilterAndType);
    2147           0 :         ndr_print_ptr(ndr, "buffer", r->buffer);
    2148           0 :         ndr->depth++;
    2149           0 :         if (r->buffer) {
    2150           0 :                 ndr_print_array_uint8(ndr, "buffer", r->buffer, r->dwBufferSize);
    2151             :         }
    2152           0 :         ndr->depth--;
    2153           0 :         ndr_print_uint32(ndr, "dwBufferSize", r->dwBufferSize);
    2154           0 :         ndr_print_ptr(ndr, "ObjectId", r->ObjectId);
    2155           0 :         ndr->depth++;
    2156           0 :         if (r->ObjectId) {
    2157           0 :                 ndr_print_string(ndr, "ObjectId", r->ObjectId);
    2158             :         }
    2159           0 :         ndr->depth--;
    2160           0 :         ndr_print_ptr(ndr, "ParentId", r->ParentId);
    2161           0 :         ndr->depth++;
    2162           0 :         if (r->ParentId) {
    2163           0 :                 ndr_print_string(ndr, "ParentId", r->ParentId);
    2164             :         }
    2165           0 :         ndr->depth--;
    2166           0 :         ndr_print_ptr(ndr, "Name", r->Name);
    2167           0 :         ndr->depth++;
    2168           0 :         if (r->Name) {
    2169           0 :                 ndr_print_string(ndr, "Name", r->Name);
    2170             :         }
    2171           0 :         ndr->depth--;
    2172           0 :         ndr_print_ptr(ndr, "Type", r->Type);
    2173           0 :         ndr->depth++;
    2174           0 :         if (r->Type) {
    2175           0 :                 ndr_print_string(ndr, "Type", r->Type);
    2176             :         }
    2177           0 :         ndr->depth--;
    2178           0 :         ndr->depth--;
    2179             : }
    2180             : 
    2181           0 : static enum ndr_err_code ndr_push_NOTIFICATION_RPC(struct ndr_push *ndr, int ndr_flags, const struct NOTIFICATION_RPC *r)
    2182             : {
    2183           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2184           0 :         if (ndr_flags & NDR_SCALARS) {
    2185           0 :                 NDR_CHECK(ndr_push_align(ndr, 8));
    2186           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dwNotifyKey));
    2187           0 :                 NDR_CHECK(ndr_push_NOTIFICATION_DATA_RPC(ndr, NDR_SCALARS, &r->NotificationData));
    2188           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
    2189             :         }
    2190           0 :         if (ndr_flags & NDR_BUFFERS) {
    2191           0 :                 if (r->dwNotifyKey) {
    2192           0 :                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->dwNotifyKey));
    2193             :                 }
    2194           0 :                 NDR_CHECK(ndr_push_NOTIFICATION_DATA_RPC(ndr, NDR_BUFFERS, &r->NotificationData));
    2195             :         }
    2196           0 :         return NDR_ERR_SUCCESS;
    2197             : }
    2198             : 
    2199           0 : static enum ndr_err_code ndr_pull_NOTIFICATION_RPC(struct ndr_pull *ndr, int ndr_flags, struct NOTIFICATION_RPC *r)
    2200             : {
    2201             :         uint32_t _ptr_dwNotifyKey;
    2202           0 :         TALLOC_CTX *_mem_save_dwNotifyKey_0 = NULL;
    2203           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2204           0 :         if (ndr_flags & NDR_SCALARS) {
    2205           0 :                 NDR_CHECK(ndr_pull_align(ndr, 8));
    2206           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dwNotifyKey));
    2207           0 :                 if (_ptr_dwNotifyKey) {
    2208           0 :                         NDR_PULL_ALLOC(ndr, r->dwNotifyKey);
    2209             :                 } else {
    2210           0 :                         r->dwNotifyKey = NULL;
    2211             :                 }
    2212           0 :                 NDR_CHECK(ndr_pull_NOTIFICATION_DATA_RPC(ndr, NDR_SCALARS, &r->NotificationData));
    2213           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
    2214             :         }
    2215           0 :         if (ndr_flags & NDR_BUFFERS) {
    2216           0 :                 if (r->dwNotifyKey) {
    2217           0 :                         _mem_save_dwNotifyKey_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2218           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->dwNotifyKey, 0);
    2219           0 :                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->dwNotifyKey));
    2220           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dwNotifyKey_0, 0);
    2221             :                 }
    2222           0 :                 NDR_CHECK(ndr_pull_NOTIFICATION_DATA_RPC(ndr, NDR_BUFFERS, &r->NotificationData));
    2223             :         }
    2224           0 :         return NDR_ERR_SUCCESS;
    2225             : }
    2226             : 
    2227           0 : _PUBLIC_ void ndr_print_NOTIFICATION_RPC(struct ndr_print *ndr, const char *name, const struct NOTIFICATION_RPC *r)
    2228             : {
    2229           0 :         ndr_print_struct(ndr, name, "NOTIFICATION_RPC");
    2230           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2231           0 :         ndr->depth++;
    2232           0 :         ndr_print_ptr(ndr, "dwNotifyKey", r->dwNotifyKey);
    2233           0 :         ndr->depth++;
    2234           0 :         if (r->dwNotifyKey) {
    2235           0 :                 ndr_print_uint32(ndr, "dwNotifyKey", *r->dwNotifyKey);
    2236             :         }
    2237           0 :         ndr->depth--;
    2238           0 :         ndr_print_NOTIFICATION_DATA_RPC(ndr, "NotificationData", &r->NotificationData);
    2239           0 :         ndr->depth--;
    2240             : }
    2241             : 
    2242           0 : static enum ndr_err_code ndr_push_CLUSTER_DISKID(struct ndr_push *ndr, int ndr_flags, const struct CLUSTER_DISKID *r)
    2243             : {
    2244           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2245           0 :         if (ndr_flags & NDR_SCALARS) {
    2246           0 :                 NDR_CHECK(ndr_push_align(ndr, 4));
    2247           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->DiskIdType));
    2248           0 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->DiskIdBlob, 16));
    2249           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
    2250             :         }
    2251           0 :         if (ndr_flags & NDR_BUFFERS) {
    2252             :         }
    2253           0 :         return NDR_ERR_SUCCESS;
    2254             : }
    2255             : 
    2256           0 : static enum ndr_err_code ndr_pull_CLUSTER_DISKID(struct ndr_pull *ndr, int ndr_flags, struct CLUSTER_DISKID *r)
    2257             : {
    2258           0 :         uint32_t size_DiskIdBlob_0 = 0;
    2259           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2260           0 :         if (ndr_flags & NDR_SCALARS) {
    2261           0 :                 NDR_CHECK(ndr_pull_align(ndr, 4));
    2262           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->DiskIdType));
    2263           0 :                 size_DiskIdBlob_0 = 16;
    2264           0 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->DiskIdBlob, size_DiskIdBlob_0));
    2265           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
    2266             :         }
    2267           0 :         if (ndr_flags & NDR_BUFFERS) {
    2268             :         }
    2269           0 :         return NDR_ERR_SUCCESS;
    2270             : }
    2271             : 
    2272           0 : _PUBLIC_ void ndr_print_CLUSTER_DISKID(struct ndr_print *ndr, const char *name, const struct CLUSTER_DISKID *r)
    2273             : {
    2274           0 :         ndr_print_struct(ndr, name, "CLUSTER_DISKID");
    2275           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2276           0 :         ndr->depth++;
    2277           0 :         ndr_print_uint32(ndr, "DiskIdType", r->DiskIdType);
    2278           0 :         ndr_print_array_uint8(ndr, "DiskIdBlob", r->DiskIdBlob, 16);
    2279           0 :         ndr->depth--;
    2280             : }
    2281             : 
    2282           0 : static enum ndr_err_code ndr_push_CLUSTER_MRR_NODE_RESPONSE(struct ndr_push *ndr, int ndr_flags, const struct CLUSTER_MRR_NODE_RESPONSE *r)
    2283             : {
    2284           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2285           0 :         if (ndr_flags & NDR_SCALARS) {
    2286           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    2287           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pszNodeName));
    2288           0 :                 NDR_CHECK(ndr_push_HRESULT(ndr, NDR_SCALARS, r->ResultCode));
    2289           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ResultSize));
    2290           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pResultData));
    2291           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    2292             :         }
    2293           0 :         if (ndr_flags & NDR_BUFFERS) {
    2294           0 :                 if (r->pszNodeName) {
    2295           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->pszNodeName, CH_UTF16)));
    2296           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2297           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->pszNodeName, CH_UTF16)));
    2298           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->pszNodeName, ndr_charset_length(r->pszNodeName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    2299             :                 }
    2300           0 :                 if (r->pResultData) {
    2301           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->ResultSize));
    2302           0 :                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->pResultData, r->ResultSize));
    2303             :                 }
    2304             :         }
    2305           0 :         return NDR_ERR_SUCCESS;
    2306             : }
    2307             : 
    2308           0 : static enum ndr_err_code ndr_pull_CLUSTER_MRR_NODE_RESPONSE(struct ndr_pull *ndr, int ndr_flags, struct CLUSTER_MRR_NODE_RESPONSE *r)
    2309             : {
    2310             :         uint32_t _ptr_pszNodeName;
    2311           0 :         uint32_t size_pszNodeName_1 = 0;
    2312           0 :         uint32_t length_pszNodeName_1 = 0;
    2313           0 :         TALLOC_CTX *_mem_save_pszNodeName_0 = NULL;
    2314             :         uint32_t _ptr_pResultData;
    2315           0 :         uint32_t size_pResultData_1 = 0;
    2316           0 :         TALLOC_CTX *_mem_save_pResultData_0 = NULL;
    2317           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2318           0 :         if (ndr_flags & NDR_SCALARS) {
    2319           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    2320           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pszNodeName));
    2321           0 :                 if (_ptr_pszNodeName) {
    2322           0 :                         NDR_PULL_ALLOC(ndr, r->pszNodeName);
    2323             :                 } else {
    2324           0 :                         r->pszNodeName = NULL;
    2325             :                 }
    2326           0 :                 NDR_CHECK(ndr_pull_HRESULT(ndr, NDR_SCALARS, &r->ResultCode));
    2327           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ResultSize));
    2328           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pResultData));
    2329           0 :                 if (_ptr_pResultData) {
    2330           0 :                         NDR_PULL_ALLOC(ndr, r->pResultData);
    2331             :                 } else {
    2332           0 :                         r->pResultData = NULL;
    2333             :                 }
    2334           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    2335             :         }
    2336           0 :         if (ndr_flags & NDR_BUFFERS) {
    2337           0 :                 if (r->pszNodeName) {
    2338           0 :                         _mem_save_pszNodeName_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2339           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pszNodeName, 0);
    2340           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pszNodeName));
    2341           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->pszNodeName));
    2342           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->pszNodeName, &size_pszNodeName_1));
    2343           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->pszNodeName, &length_pszNodeName_1));
    2344           0 :                         if (length_pszNodeName_1 > size_pszNodeName_1) {
    2345           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_pszNodeName_1, length_pszNodeName_1);
    2346             :                         }
    2347           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_pszNodeName_1, sizeof(uint16_t)));
    2348           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->pszNodeName, length_pszNodeName_1, sizeof(uint16_t), CH_UTF16));
    2349           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pszNodeName_0, 0);
    2350             :                 }
    2351           0 :                 if (r->pResultData) {
    2352           0 :                         _mem_save_pResultData_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2353           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pResultData, 0);
    2354           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pResultData));
    2355           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pResultData, &size_pResultData_1));
    2356           0 :                         NDR_PULL_ALLOC_N(ndr, r->pResultData, size_pResultData_1);
    2357           0 :                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->pResultData, size_pResultData_1));
    2358           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pResultData_0, 0);
    2359             :                 }
    2360           0 :                 if (r->pResultData) {
    2361           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->pResultData, r->ResultSize));
    2362             :                 }
    2363             :         }
    2364           0 :         return NDR_ERR_SUCCESS;
    2365             : }
    2366             : 
    2367           0 : _PUBLIC_ void ndr_print_CLUSTER_MRR_NODE_RESPONSE(struct ndr_print *ndr, const char *name, const struct CLUSTER_MRR_NODE_RESPONSE *r)
    2368             : {
    2369           0 :         ndr_print_struct(ndr, name, "CLUSTER_MRR_NODE_RESPONSE");
    2370           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2371           0 :         ndr->depth++;
    2372           0 :         ndr_print_ptr(ndr, "pszNodeName", r->pszNodeName);
    2373           0 :         ndr->depth++;
    2374           0 :         if (r->pszNodeName) {
    2375           0 :                 ndr_print_string(ndr, "pszNodeName", r->pszNodeName);
    2376             :         }
    2377           0 :         ndr->depth--;
    2378           0 :         ndr_print_HRESULT(ndr, "ResultCode", r->ResultCode);
    2379           0 :         ndr_print_uint32(ndr, "ResultSize", r->ResultSize);
    2380           0 :         ndr_print_ptr(ndr, "pResultData", r->pResultData);
    2381           0 :         ndr->depth++;
    2382           0 :         if (r->pResultData) {
    2383           0 :                 ndr_print_array_uint8(ndr, "pResultData", r->pResultData, r->ResultSize);
    2384             :         }
    2385           0 :         ndr->depth--;
    2386           0 :         ndr->depth--;
    2387             : }
    2388             : 
    2389           0 : static enum ndr_err_code ndr_push_CLUSTER_MRR_RESPONSE(struct ndr_push *ndr, int ndr_flags, const struct CLUSTER_MRR_RESPONSE *r)
    2390             : {
    2391             :         uint32_t cntr_pNodes_1;
    2392           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2393           0 :         if (ndr_flags & NDR_SCALARS) {
    2394           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    2395           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->NodeCount));
    2396           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pNodes));
    2397           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    2398             :         }
    2399           0 :         if (ndr_flags & NDR_BUFFERS) {
    2400           0 :                 if (r->pNodes) {
    2401           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->NodeCount));
    2402           0 :                         for (cntr_pNodes_1 = 0; cntr_pNodes_1 < (r->NodeCount); cntr_pNodes_1++) {
    2403           0 :                                 NDR_CHECK(ndr_push_CLUSTER_MRR_NODE_RESPONSE(ndr, NDR_SCALARS, &r->pNodes[cntr_pNodes_1]));
    2404             :                         }
    2405           0 :                         for (cntr_pNodes_1 = 0; cntr_pNodes_1 < (r->NodeCount); cntr_pNodes_1++) {
    2406           0 :                                 NDR_CHECK(ndr_push_CLUSTER_MRR_NODE_RESPONSE(ndr, NDR_BUFFERS, &r->pNodes[cntr_pNodes_1]));
    2407             :                         }
    2408             :                 }
    2409             :         }
    2410           0 :         return NDR_ERR_SUCCESS;
    2411             : }
    2412             : 
    2413           0 : static enum ndr_err_code ndr_pull_CLUSTER_MRR_RESPONSE(struct ndr_pull *ndr, int ndr_flags, struct CLUSTER_MRR_RESPONSE *r)
    2414             : {
    2415             :         uint32_t _ptr_pNodes;
    2416           0 :         uint32_t size_pNodes_1 = 0;
    2417             :         uint32_t cntr_pNodes_1;
    2418           0 :         TALLOC_CTX *_mem_save_pNodes_0 = NULL;
    2419           0 :         TALLOC_CTX *_mem_save_pNodes_1 = NULL;
    2420           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2421           0 :         if (ndr_flags & NDR_SCALARS) {
    2422           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    2423           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->NodeCount));
    2424           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pNodes));
    2425           0 :                 if (_ptr_pNodes) {
    2426           0 :                         NDR_PULL_ALLOC(ndr, r->pNodes);
    2427             :                 } else {
    2428           0 :                         r->pNodes = NULL;
    2429             :                 }
    2430           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    2431             :         }
    2432           0 :         if (ndr_flags & NDR_BUFFERS) {
    2433           0 :                 if (r->pNodes) {
    2434           0 :                         _mem_save_pNodes_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2435           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pNodes, 0);
    2436           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->pNodes));
    2437           0 :                         NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->pNodes, &size_pNodes_1));
    2438           0 :                         NDR_PULL_ALLOC_N(ndr, r->pNodes, size_pNodes_1);
    2439           0 :                         _mem_save_pNodes_1 = NDR_PULL_GET_MEM_CTX(ndr);
    2440           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->pNodes, 0);
    2441           0 :                         for (cntr_pNodes_1 = 0; cntr_pNodes_1 < (size_pNodes_1); cntr_pNodes_1++) {
    2442           0 :                                 NDR_CHECK(ndr_pull_CLUSTER_MRR_NODE_RESPONSE(ndr, NDR_SCALARS, &r->pNodes[cntr_pNodes_1]));
    2443             :                         }
    2444           0 :                         for (cntr_pNodes_1 = 0; cntr_pNodes_1 < (size_pNodes_1); cntr_pNodes_1++) {
    2445           0 :                                 NDR_CHECK(ndr_pull_CLUSTER_MRR_NODE_RESPONSE(ndr, NDR_BUFFERS, &r->pNodes[cntr_pNodes_1]));
    2446             :                         }
    2447           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pNodes_1, 0);
    2448           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pNodes_0, 0);
    2449             :                 }
    2450           0 :                 if (r->pNodes) {
    2451           0 :                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pNodes, r->NodeCount));
    2452             :                 }
    2453           0 :                 for (cntr_pNodes_1 = 0; cntr_pNodes_1 < (size_pNodes_1); cntr_pNodes_1++) {
    2454             :                 }
    2455             :         }
    2456           0 :         return NDR_ERR_SUCCESS;
    2457             : }
    2458             : 
    2459           0 : _PUBLIC_ void ndr_print_CLUSTER_MRR_RESPONSE(struct ndr_print *ndr, const char *name, const struct CLUSTER_MRR_RESPONSE *r)
    2460             : {
    2461             :         uint32_t cntr_pNodes_1;
    2462           0 :         ndr_print_struct(ndr, name, "CLUSTER_MRR_RESPONSE");
    2463           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2464           0 :         ndr->depth++;
    2465           0 :         ndr_print_uint32(ndr, "NodeCount", r->NodeCount);
    2466           0 :         ndr_print_ptr(ndr, "pNodes", r->pNodes);
    2467           0 :         ndr->depth++;
    2468           0 :         if (r->pNodes) {
    2469           0 :                 ndr->print(ndr, "%s: ARRAY(%d)", "pNodes", (int)r->NodeCount);
    2470           0 :                 ndr->depth++;
    2471           0 :                 for (cntr_pNodes_1 = 0; cntr_pNodes_1 < (r->NodeCount); cntr_pNodes_1++) {
    2472           0 :                         ndr_print_CLUSTER_MRR_NODE_RESPONSE(ndr, "pNodes", &r->pNodes[cntr_pNodes_1]);
    2473             :                 }
    2474           0 :                 ndr->depth--;
    2475             :         }
    2476           0 :         ndr->depth--;
    2477           0 :         ndr->depth--;
    2478             : }
    2479             : 
    2480           0 : static enum ndr_err_code ndr_push_NOTIFICATION_DATA_ASYNC_RPC(struct ndr_push *ndr, int ndr_flags, const struct NOTIFICATION_DATA_ASYNC_RPC *r)
    2481             : {
    2482           0 :         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    2483           0 :         if (ndr_flags & NDR_SCALARS) {
    2484           0 :                 NDR_CHECK(ndr_push_align(ndr, 5));
    2485           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwNotifyKey));
    2486           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwFilter));
    2487           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->Name));
    2488           0 :                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
    2489             :         }
    2490           0 :         if (ndr_flags & NDR_BUFFERS) {
    2491           0 :                 if (r->Name) {
    2492           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Name, CH_UTF16)));
    2493           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2494           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->Name, CH_UTF16)));
    2495           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->Name, ndr_charset_length(r->Name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    2496             :                 }
    2497             :         }
    2498           0 :         return NDR_ERR_SUCCESS;
    2499             : }
    2500             : 
    2501           0 : static enum ndr_err_code ndr_pull_NOTIFICATION_DATA_ASYNC_RPC(struct ndr_pull *ndr, int ndr_flags, struct NOTIFICATION_DATA_ASYNC_RPC *r)
    2502             : {
    2503             :         uint32_t _ptr_Name;
    2504           0 :         uint32_t size_Name_1 = 0;
    2505           0 :         uint32_t length_Name_1 = 0;
    2506           0 :         TALLOC_CTX *_mem_save_Name_0 = NULL;
    2507           0 :         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    2508           0 :         if (ndr_flags & NDR_SCALARS) {
    2509           0 :                 NDR_CHECK(ndr_pull_align(ndr, 5));
    2510           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwNotifyKey));
    2511           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwFilter));
    2512           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Name));
    2513           0 :                 if (_ptr_Name) {
    2514           0 :                         NDR_PULL_ALLOC(ndr, r->Name);
    2515             :                 } else {
    2516           0 :                         r->Name = NULL;
    2517             :                 }
    2518           0 :                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
    2519             :         }
    2520           0 :         if (ndr_flags & NDR_BUFFERS) {
    2521           0 :                 if (r->Name) {
    2522           0 :                         _mem_save_Name_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2523           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->Name, 0);
    2524           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, &r->Name));
    2525           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, &r->Name));
    2526           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->Name, &size_Name_1));
    2527           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->Name, &length_Name_1));
    2528           0 :                         if (length_Name_1 > size_Name_1) {
    2529           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_Name_1, length_Name_1);
    2530             :                         }
    2531           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_Name_1, sizeof(uint16_t)));
    2532           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Name, length_Name_1, sizeof(uint16_t), CH_UTF16));
    2533           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Name_0, 0);
    2534             :                 }
    2535             :         }
    2536           0 :         return NDR_ERR_SUCCESS;
    2537             : }
    2538             : 
    2539           0 : _PUBLIC_ void ndr_print_NOTIFICATION_DATA_ASYNC_RPC(struct ndr_print *ndr, const char *name, const struct NOTIFICATION_DATA_ASYNC_RPC *r)
    2540             : {
    2541           0 :         ndr_print_struct(ndr, name, "NOTIFICATION_DATA_ASYNC_RPC");
    2542           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2543           0 :         ndr->depth++;
    2544           0 :         ndr_print_uint32(ndr, "dwNotifyKey", r->dwNotifyKey);
    2545           0 :         ndr_print_uint32(ndr, "dwFilter", r->dwFilter);
    2546           0 :         ndr_print_ptr(ndr, "Name", r->Name);
    2547           0 :         ndr->depth++;
    2548           0 :         if (r->Name) {
    2549           0 :                 ndr_print_string(ndr, "Name", r->Name);
    2550             :         }
    2551           0 :         ndr->depth--;
    2552           0 :         ndr->depth--;
    2553             : }
    2554             : 
    2555           0 : static enum ndr_err_code ndr_push_clusapi_GroupSetControlCode(struct ndr_push *ndr, int ndr_flags, enum clusapi_GroupSetControlCode r)
    2556             : {
    2557           0 :         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
    2558           0 :         return NDR_ERR_SUCCESS;
    2559             : }
    2560             : 
    2561           0 : static enum ndr_err_code ndr_pull_clusapi_GroupSetControlCode(struct ndr_pull *ndr, int ndr_flags, enum clusapi_GroupSetControlCode *r)
    2562             : {
    2563             :         uint32_t v;
    2564           0 :         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
    2565           0 :         *r = v;
    2566           0 :         return NDR_ERR_SUCCESS;
    2567             : }
    2568             : 
    2569           0 : _PUBLIC_ void ndr_print_clusapi_GroupSetControlCode(struct ndr_print *ndr, const char *name, enum clusapi_GroupSetControlCode r)
    2570             : {
    2571           0 :         const char *val = NULL;
    2572             : 
    2573           0 :         switch (r) {
    2574           0 :                 case CLUSCTL_GROUPSET_GET_ID: val = "CLUSCTL_GROUPSET_GET_ID"; break;
    2575           0 :                 case CLUSCTL_GROUPSET_GET_RO_COMMON_PROPERTIES: val = "CLUSCTL_GROUPSET_GET_RO_COMMON_PROPERTIES"; break;
    2576           0 :                 case CLUSCTL_GROUPSET_GET_COMMON_PROPERTIES: val = "CLUSCTL_GROUPSET_GET_COMMON_PROPERTIES"; break;
    2577           0 :                 case CLUSCTL_GROUPSET_GET_GROUPS: val = "CLUSCTL_GROUPSET_GET_GROUPS"; break;
    2578           0 :                 case CLUSCTL_GROUPSET_GET_PROVIDER_GROUPS: val = "CLUSCTL_GROUPSET_GET_PROVIDER_GROUPS"; break;
    2579           0 :                 case CLUSCTL_GROUPSET_GET_PROVIDER_GROUPSETS: val = "CLUSCTL_GROUPSET_GET_PROVIDER_GROUPSETS"; break;
    2580           0 :                 case CLUSCTL_GROUPSET_SET_COMMON_PROPERTIES: val = "CLUSCTL_GROUPSET_SET_COMMON_PROPERTIES"; break;
    2581             :         }
    2582           0 :         ndr_print_enum(ndr, name, "ENUM", val, r);
    2583           0 : }
    2584             : 
    2585           0 : static enum ndr_err_code ndr_push_clusapi_OpenCluster(struct ndr_push *ndr, int flags, const struct clusapi_OpenCluster *r)
    2586             : {
    2587           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2588           0 :         if (flags & NDR_IN) {
    2589             :         }
    2590           0 :         if (flags & NDR_OUT) {
    2591           0 :                 if (r->out.Status == NULL) {
    2592           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2593             :                 }
    2594           0 :                 if (r->out.Cluster == NULL) {
    2595           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2596             :                 }
    2597           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.Status));
    2598           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.Cluster));
    2599             :         }
    2600           0 :         return NDR_ERR_SUCCESS;
    2601             : }
    2602             : 
    2603           0 : static enum ndr_err_code ndr_pull_clusapi_OpenCluster(struct ndr_pull *ndr, int flags, struct clusapi_OpenCluster *r)
    2604             : {
    2605           0 :         TALLOC_CTX *_mem_save_Status_0 = NULL;
    2606           0 :         TALLOC_CTX *_mem_save_Cluster_0 = NULL;
    2607           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2608           0 :         if (flags & NDR_IN) {
    2609           0 :                 NDR_ZERO_STRUCT(r->out);
    2610             : 
    2611           0 :                 NDR_PULL_ALLOC(ndr, r->out.Status);
    2612           0 :                 NDR_ZERO_STRUCTP(r->out.Status);
    2613           0 :                 NDR_PULL_ALLOC(ndr, r->out.Cluster);
    2614           0 :                 NDR_ZERO_STRUCTP(r->out.Cluster);
    2615             :         }
    2616           0 :         if (flags & NDR_OUT) {
    2617             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2618             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2619           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2620           0 :                         NDR_PULL_ALLOC(ndr, r->out.Status);
    2621             :                 }
    2622           0 :                 _mem_save_Status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2623           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.Status, LIBNDR_FLAG_REF_ALLOC);
    2624           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.Status));
    2625           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Status_0, LIBNDR_FLAG_REF_ALLOC);
    2626           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2627           0 :                         NDR_PULL_ALLOC(ndr, r->out.Cluster);
    2628             :                 }
    2629           0 :                 _mem_save_Cluster_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2630           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.Cluster, LIBNDR_FLAG_REF_ALLOC);
    2631           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.Cluster));
    2632           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Cluster_0, LIBNDR_FLAG_REF_ALLOC);
    2633             :         }
    2634           0 :         return NDR_ERR_SUCCESS;
    2635             : }
    2636             : 
    2637           0 : _PUBLIC_ void ndr_print_clusapi_OpenCluster(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_OpenCluster *r)
    2638             : {
    2639           0 :         ndr_print_struct(ndr, name, "clusapi_OpenCluster");
    2640           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2641           0 :         ndr->depth++;
    2642           0 :         if (flags & NDR_SET_VALUES) {
    2643           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2644             :         }
    2645           0 :         if (flags & NDR_IN) {
    2646           0 :                 ndr_print_struct(ndr, "in", "clusapi_OpenCluster");
    2647           0 :                 ndr->depth++;
    2648           0 :                 ndr->depth--;
    2649             :         }
    2650           0 :         if (flags & NDR_OUT) {
    2651           0 :                 ndr_print_struct(ndr, "out", "clusapi_OpenCluster");
    2652           0 :                 ndr->depth++;
    2653           0 :                 ndr_print_ptr(ndr, "Status", r->out.Status);
    2654           0 :                 ndr->depth++;
    2655           0 :                 ndr_print_WERROR(ndr, "Status", *r->out.Status);
    2656           0 :                 ndr->depth--;
    2657           0 :                 ndr_print_ptr(ndr, "Cluster", r->out.Cluster);
    2658           0 :                 ndr->depth++;
    2659           0 :                 ndr_print_policy_handle(ndr, "Cluster", r->out.Cluster);
    2660           0 :                 ndr->depth--;
    2661           0 :                 ndr->depth--;
    2662             :         }
    2663           0 :         ndr->depth--;
    2664             : }
    2665             : 
    2666           0 : static enum ndr_err_code ndr_push_clusapi_CloseCluster(struct ndr_push *ndr, int flags, const struct clusapi_CloseCluster *r)
    2667             : {
    2668           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2669           0 :         if (flags & NDR_IN) {
    2670           0 :                 if (r->in.Cluster == NULL) {
    2671           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2672             :                 }
    2673           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.Cluster));
    2674             :         }
    2675           0 :         if (flags & NDR_OUT) {
    2676           0 :                 if (r->out.Cluster == NULL) {
    2677           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2678             :                 }
    2679           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.Cluster));
    2680           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2681             :         }
    2682           0 :         return NDR_ERR_SUCCESS;
    2683             : }
    2684             : 
    2685           0 : static enum ndr_err_code ndr_pull_clusapi_CloseCluster(struct ndr_pull *ndr, int flags, struct clusapi_CloseCluster *r)
    2686             : {
    2687           0 :         TALLOC_CTX *_mem_save_Cluster_0 = NULL;
    2688           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2689           0 :         if (flags & NDR_IN) {
    2690           0 :                 NDR_ZERO_STRUCT(r->out);
    2691             : 
    2692           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2693           0 :                         NDR_PULL_ALLOC(ndr, r->in.Cluster);
    2694             :                 }
    2695           0 :                 _mem_save_Cluster_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2696           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.Cluster, LIBNDR_FLAG_REF_ALLOC);
    2697           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.Cluster));
    2698           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Cluster_0, LIBNDR_FLAG_REF_ALLOC);
    2699           0 :                 NDR_PULL_ALLOC(ndr, r->out.Cluster);
    2700           0 :                 *r->out.Cluster = *r->in.Cluster;
    2701             :         }
    2702           0 :         if (flags & NDR_OUT) {
    2703             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2704             :                 if (r->in.Cluster == NULL) {
    2705             :                         NDR_PULL_ALLOC(ndr, r->in.Cluster);
    2706             :                         NDR_ZERO_STRUCTP(r->in.Cluster);
    2707             :                 }
    2708             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2709           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2710           0 :                         NDR_PULL_ALLOC(ndr, r->out.Cluster);
    2711             :                 }
    2712           0 :                 _mem_save_Cluster_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2713           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.Cluster, LIBNDR_FLAG_REF_ALLOC);
    2714           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.Cluster));
    2715           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Cluster_0, LIBNDR_FLAG_REF_ALLOC);
    2716           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2717             :         }
    2718           0 :         return NDR_ERR_SUCCESS;
    2719             : }
    2720             : 
    2721           0 : _PUBLIC_ void ndr_print_clusapi_CloseCluster(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_CloseCluster *r)
    2722             : {
    2723           0 :         ndr_print_struct(ndr, name, "clusapi_CloseCluster");
    2724           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2725           0 :         ndr->depth++;
    2726           0 :         if (flags & NDR_SET_VALUES) {
    2727           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2728             :         }
    2729           0 :         if (flags & NDR_IN) {
    2730           0 :                 ndr_print_struct(ndr, "in", "clusapi_CloseCluster");
    2731           0 :                 ndr->depth++;
    2732           0 :                 ndr_print_ptr(ndr, "Cluster", r->in.Cluster);
    2733           0 :                 ndr->depth++;
    2734           0 :                 ndr_print_policy_handle(ndr, "Cluster", r->in.Cluster);
    2735           0 :                 ndr->depth--;
    2736           0 :                 ndr->depth--;
    2737             :         }
    2738           0 :         if (flags & NDR_OUT) {
    2739           0 :                 ndr_print_struct(ndr, "out", "clusapi_CloseCluster");
    2740           0 :                 ndr->depth++;
    2741           0 :                 ndr_print_ptr(ndr, "Cluster", r->out.Cluster);
    2742           0 :                 ndr->depth++;
    2743           0 :                 ndr_print_policy_handle(ndr, "Cluster", r->out.Cluster);
    2744           0 :                 ndr->depth--;
    2745           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2746           0 :                 ndr->depth--;
    2747             :         }
    2748           0 :         ndr->depth--;
    2749             : }
    2750             : 
    2751           0 : static enum ndr_err_code ndr_push_clusapi_SetClusterName(struct ndr_push *ndr, int flags, const struct clusapi_SetClusterName *r)
    2752             : {
    2753           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2754           0 :         if (flags & NDR_IN) {
    2755           0 :                 if (r->in.NewClusterName == NULL) {
    2756           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2757             :                 }
    2758           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewClusterName, CH_UTF16)));
    2759           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2760           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewClusterName, CH_UTF16)));
    2761           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewClusterName, ndr_charset_length(r->in.NewClusterName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    2762             :         }
    2763           0 :         if (flags & NDR_OUT) {
    2764           0 :                 if (r->out.rpc_status == NULL) {
    2765           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2766             :                 }
    2767           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    2768           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2769             :         }
    2770           0 :         return NDR_ERR_SUCCESS;
    2771             : }
    2772             : 
    2773           0 : static enum ndr_err_code ndr_pull_clusapi_SetClusterName(struct ndr_pull *ndr, int flags, struct clusapi_SetClusterName *r)
    2774             : {
    2775           0 :         uint32_t size_NewClusterName_1 = 0;
    2776           0 :         uint32_t length_NewClusterName_1 = 0;
    2777           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    2778           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2779           0 :         if (flags & NDR_IN) {
    2780           0 :                 NDR_ZERO_STRUCT(r->out);
    2781             : 
    2782           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewClusterName));
    2783           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewClusterName));
    2784           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.NewClusterName, &size_NewClusterName_1));
    2785           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.NewClusterName, &length_NewClusterName_1));
    2786           0 :                 if (length_NewClusterName_1 > size_NewClusterName_1) {
    2787           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_NewClusterName_1, length_NewClusterName_1);
    2788             :                 }
    2789           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_NewClusterName_1, sizeof(uint16_t)));
    2790           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewClusterName, length_NewClusterName_1, sizeof(uint16_t), CH_UTF16));
    2791           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    2792           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    2793             :         }
    2794           0 :         if (flags & NDR_OUT) {
    2795             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2796             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2797           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2798           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    2799             :                 }
    2800           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2801           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    2802           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    2803           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    2804           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2805             :         }
    2806           0 :         return NDR_ERR_SUCCESS;
    2807             : }
    2808             : 
    2809           0 : _PUBLIC_ void ndr_print_clusapi_SetClusterName(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_SetClusterName *r)
    2810             : {
    2811           0 :         ndr_print_struct(ndr, name, "clusapi_SetClusterName");
    2812           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2813           0 :         ndr->depth++;
    2814           0 :         if (flags & NDR_SET_VALUES) {
    2815           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2816             :         }
    2817           0 :         if (flags & NDR_IN) {
    2818           0 :                 ndr_print_struct(ndr, "in", "clusapi_SetClusterName");
    2819           0 :                 ndr->depth++;
    2820           0 :                 ndr_print_ptr(ndr, "NewClusterName", r->in.NewClusterName);
    2821           0 :                 ndr->depth++;
    2822           0 :                 ndr_print_string(ndr, "NewClusterName", r->in.NewClusterName);
    2823           0 :                 ndr->depth--;
    2824           0 :                 ndr->depth--;
    2825             :         }
    2826           0 :         if (flags & NDR_OUT) {
    2827           0 :                 ndr_print_struct(ndr, "out", "clusapi_SetClusterName");
    2828           0 :                 ndr->depth++;
    2829           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    2830           0 :                 ndr->depth++;
    2831           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    2832           0 :                 ndr->depth--;
    2833           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2834           0 :                 ndr->depth--;
    2835             :         }
    2836           0 :         ndr->depth--;
    2837             : }
    2838             : 
    2839           0 : static enum ndr_err_code ndr_push_clusapi_GetClusterName(struct ndr_push *ndr, int flags, const struct clusapi_GetClusterName *r)
    2840             : {
    2841           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2842           0 :         if (flags & NDR_IN) {
    2843             :         }
    2844           0 :         if (flags & NDR_OUT) {
    2845           0 :                 if (r->out.ClusterName == NULL) {
    2846           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2847             :                 }
    2848           0 :                 if (r->out.NodeName == NULL) {
    2849           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2850             :                 }
    2851           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ClusterName));
    2852           0 :                 if (*r->out.ClusterName) {
    2853           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.ClusterName, CH_UTF16)));
    2854           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2855           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.ClusterName, CH_UTF16)));
    2856           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.ClusterName, ndr_charset_length(*r->out.ClusterName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    2857             :                 }
    2858           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.NodeName));
    2859           0 :                 if (*r->out.NodeName) {
    2860           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.NodeName, CH_UTF16)));
    2861           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    2862           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.NodeName, CH_UTF16)));
    2863           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.NodeName, ndr_charset_length(*r->out.NodeName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    2864             :                 }
    2865           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    2866             :         }
    2867           0 :         return NDR_ERR_SUCCESS;
    2868             : }
    2869             : 
    2870           0 : static enum ndr_err_code ndr_pull_clusapi_GetClusterName(struct ndr_pull *ndr, int flags, struct clusapi_GetClusterName *r)
    2871             : {
    2872             :         uint32_t _ptr_ClusterName;
    2873           0 :         uint32_t size_ClusterName_2 = 0;
    2874           0 :         uint32_t length_ClusterName_2 = 0;
    2875             :         uint32_t _ptr_NodeName;
    2876           0 :         uint32_t size_NodeName_2 = 0;
    2877           0 :         uint32_t length_NodeName_2 = 0;
    2878           0 :         TALLOC_CTX *_mem_save_ClusterName_0 = NULL;
    2879           0 :         TALLOC_CTX *_mem_save_ClusterName_1 = NULL;
    2880           0 :         TALLOC_CTX *_mem_save_NodeName_0 = NULL;
    2881           0 :         TALLOC_CTX *_mem_save_NodeName_1 = NULL;
    2882           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    2883           0 :         if (flags & NDR_IN) {
    2884           0 :                 NDR_ZERO_STRUCT(r->out);
    2885             : 
    2886           0 :                 NDR_PULL_ALLOC(ndr, r->out.ClusterName);
    2887           0 :                 NDR_ZERO_STRUCTP(r->out.ClusterName);
    2888           0 :                 NDR_PULL_ALLOC(ndr, r->out.NodeName);
    2889           0 :                 NDR_ZERO_STRUCTP(r->out.NodeName);
    2890             :         }
    2891           0 :         if (flags & NDR_OUT) {
    2892             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    2893             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    2894           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2895           0 :                         NDR_PULL_ALLOC(ndr, r->out.ClusterName);
    2896             :                 }
    2897           0 :                 _mem_save_ClusterName_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2898           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ClusterName, LIBNDR_FLAG_REF_ALLOC);
    2899           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ClusterName));
    2900           0 :                 if (_ptr_ClusterName) {
    2901           0 :                         NDR_PULL_ALLOC(ndr, *r->out.ClusterName);
    2902             :                 } else {
    2903           0 :                         *r->out.ClusterName = NULL;
    2904             :                 }
    2905           0 :                 if (*r->out.ClusterName) {
    2906           0 :                         _mem_save_ClusterName_1 = NDR_PULL_GET_MEM_CTX(ndr);
    2907           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ClusterName, 0);
    2908           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.ClusterName));
    2909           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.ClusterName));
    2910           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)r->out.ClusterName, &size_ClusterName_2));
    2911           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)r->out.ClusterName, &length_ClusterName_2));
    2912           0 :                         if (length_ClusterName_2 > size_ClusterName_2) {
    2913           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ClusterName_2, length_ClusterName_2);
    2914             :                         }
    2915           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_ClusterName_2, sizeof(uint16_t)));
    2916           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.ClusterName, length_ClusterName_2, sizeof(uint16_t), CH_UTF16));
    2917           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ClusterName_1, 0);
    2918             :                 }
    2919           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ClusterName_0, LIBNDR_FLAG_REF_ALLOC);
    2920           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    2921           0 :                         NDR_PULL_ALLOC(ndr, r->out.NodeName);
    2922             :                 }
    2923           0 :                 _mem_save_NodeName_0 = NDR_PULL_GET_MEM_CTX(ndr);
    2924           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.NodeName, LIBNDR_FLAG_REF_ALLOC);
    2925           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NodeName));
    2926           0 :                 if (_ptr_NodeName) {
    2927           0 :                         NDR_PULL_ALLOC(ndr, *r->out.NodeName);
    2928             :                 } else {
    2929           0 :                         *r->out.NodeName = NULL;
    2930             :                 }
    2931           0 :                 if (*r->out.NodeName) {
    2932           0 :                         _mem_save_NodeName_1 = NDR_PULL_GET_MEM_CTX(ndr);
    2933           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.NodeName, 0);
    2934           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.NodeName));
    2935           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.NodeName));
    2936           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)r->out.NodeName, &size_NodeName_2));
    2937           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)r->out.NodeName, &length_NodeName_2));
    2938           0 :                         if (length_NodeName_2 > size_NodeName_2) {
    2939           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_NodeName_2, length_NodeName_2);
    2940             :                         }
    2941           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_NodeName_2, sizeof(uint16_t)));
    2942           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.NodeName, length_NodeName_2, sizeof(uint16_t), CH_UTF16));
    2943           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NodeName_1, 0);
    2944             :                 }
    2945           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NodeName_0, LIBNDR_FLAG_REF_ALLOC);
    2946           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    2947             :         }
    2948           0 :         return NDR_ERR_SUCCESS;
    2949             : }
    2950             : 
    2951           0 : _PUBLIC_ void ndr_print_clusapi_GetClusterName(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_GetClusterName *r)
    2952             : {
    2953           0 :         ndr_print_struct(ndr, name, "clusapi_GetClusterName");
    2954           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    2955           0 :         ndr->depth++;
    2956           0 :         if (flags & NDR_SET_VALUES) {
    2957           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    2958             :         }
    2959           0 :         if (flags & NDR_IN) {
    2960           0 :                 ndr_print_struct(ndr, "in", "clusapi_GetClusterName");
    2961           0 :                 ndr->depth++;
    2962           0 :                 ndr->depth--;
    2963             :         }
    2964           0 :         if (flags & NDR_OUT) {
    2965           0 :                 ndr_print_struct(ndr, "out", "clusapi_GetClusterName");
    2966           0 :                 ndr->depth++;
    2967           0 :                 ndr_print_ptr(ndr, "ClusterName", r->out.ClusterName);
    2968           0 :                 ndr->depth++;
    2969           0 :                 ndr_print_ptr(ndr, "ClusterName", *r->out.ClusterName);
    2970           0 :                 ndr->depth++;
    2971           0 :                 if (*r->out.ClusterName) {
    2972           0 :                         ndr_print_string(ndr, "ClusterName", *r->out.ClusterName);
    2973             :                 }
    2974           0 :                 ndr->depth--;
    2975           0 :                 ndr->depth--;
    2976           0 :                 ndr_print_ptr(ndr, "NodeName", r->out.NodeName);
    2977           0 :                 ndr->depth++;
    2978           0 :                 ndr_print_ptr(ndr, "NodeName", *r->out.NodeName);
    2979           0 :                 ndr->depth++;
    2980           0 :                 if (*r->out.NodeName) {
    2981           0 :                         ndr_print_string(ndr, "NodeName", *r->out.NodeName);
    2982             :                 }
    2983           0 :                 ndr->depth--;
    2984           0 :                 ndr->depth--;
    2985           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    2986           0 :                 ndr->depth--;
    2987             :         }
    2988           0 :         ndr->depth--;
    2989             : }
    2990             : 
    2991           0 : static enum ndr_err_code ndr_push_clusapi_GetClusterVersion(struct ndr_push *ndr, int flags, const struct clusapi_GetClusterVersion *r)
    2992             : {
    2993           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    2994           0 :         if (flags & NDR_IN) {
    2995             :         }
    2996           0 :         if (flags & NDR_OUT) {
    2997           0 :                 if (r->out.lpwMajorVersion == NULL) {
    2998           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    2999             :                 }
    3000           0 :                 if (r->out.lpwMinorVersion == NULL) {
    3001           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3002             :                 }
    3003           0 :                 if (r->out.lpwBuildNumber == NULL) {
    3004           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3005             :                 }
    3006           0 :                 if (r->out.lpszVendorId == NULL) {
    3007           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3008             :                 }
    3009           0 :                 if (r->out.lpszCSDVersion == NULL) {
    3010           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3011             :                 }
    3012           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->out.lpwMajorVersion));
    3013           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->out.lpwMinorVersion));
    3014           0 :                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->out.lpwBuildNumber));
    3015           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.lpszVendorId));
    3016           0 :                 if (*r->out.lpszVendorId) {
    3017           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.lpszVendorId, CH_UTF16)));
    3018           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    3019           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.lpszVendorId, CH_UTF16)));
    3020           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.lpszVendorId, ndr_charset_length(*r->out.lpszVendorId, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    3021             :                 }
    3022           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.lpszCSDVersion));
    3023           0 :                 if (*r->out.lpszCSDVersion) {
    3024           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.lpszCSDVersion, CH_UTF16)));
    3025           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    3026           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.lpszCSDVersion, CH_UTF16)));
    3027           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.lpszCSDVersion, ndr_charset_length(*r->out.lpszCSDVersion, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    3028             :                 }
    3029           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3030             :         }
    3031           0 :         return NDR_ERR_SUCCESS;
    3032             : }
    3033             : 
    3034           0 : static enum ndr_err_code ndr_pull_clusapi_GetClusterVersion(struct ndr_pull *ndr, int flags, struct clusapi_GetClusterVersion *r)
    3035             : {
    3036             :         uint32_t _ptr_lpszVendorId;
    3037           0 :         uint32_t size_lpszVendorId_2 = 0;
    3038           0 :         uint32_t length_lpszVendorId_2 = 0;
    3039             :         uint32_t _ptr_lpszCSDVersion;
    3040           0 :         uint32_t size_lpszCSDVersion_2 = 0;
    3041           0 :         uint32_t length_lpszCSDVersion_2 = 0;
    3042           0 :         TALLOC_CTX *_mem_save_lpwMajorVersion_0 = NULL;
    3043           0 :         TALLOC_CTX *_mem_save_lpwMinorVersion_0 = NULL;
    3044           0 :         TALLOC_CTX *_mem_save_lpwBuildNumber_0 = NULL;
    3045           0 :         TALLOC_CTX *_mem_save_lpszVendorId_0 = NULL;
    3046           0 :         TALLOC_CTX *_mem_save_lpszVendorId_1 = NULL;
    3047           0 :         TALLOC_CTX *_mem_save_lpszCSDVersion_0 = NULL;
    3048           0 :         TALLOC_CTX *_mem_save_lpszCSDVersion_1 = NULL;
    3049           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3050           0 :         if (flags & NDR_IN) {
    3051           0 :                 NDR_ZERO_STRUCT(r->out);
    3052             : 
    3053           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpwMajorVersion);
    3054           0 :                 NDR_ZERO_STRUCTP(r->out.lpwMajorVersion);
    3055           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpwMinorVersion);
    3056           0 :                 NDR_ZERO_STRUCTP(r->out.lpwMinorVersion);
    3057           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpwBuildNumber);
    3058           0 :                 NDR_ZERO_STRUCTP(r->out.lpwBuildNumber);
    3059           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpszVendorId);
    3060           0 :                 NDR_ZERO_STRUCTP(r->out.lpszVendorId);
    3061           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpszCSDVersion);
    3062           0 :                 NDR_ZERO_STRUCTP(r->out.lpszCSDVersion);
    3063             :         }
    3064           0 :         if (flags & NDR_OUT) {
    3065             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3066             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3067           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3068           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpwMajorVersion);
    3069             :                 }
    3070           0 :                 _mem_save_lpwMajorVersion_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3071           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpwMajorVersion, LIBNDR_FLAG_REF_ALLOC);
    3072           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->out.lpwMajorVersion));
    3073           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpwMajorVersion_0, LIBNDR_FLAG_REF_ALLOC);
    3074           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3075           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpwMinorVersion);
    3076             :                 }
    3077           0 :                 _mem_save_lpwMinorVersion_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3078           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpwMinorVersion, LIBNDR_FLAG_REF_ALLOC);
    3079           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->out.lpwMinorVersion));
    3080           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpwMinorVersion_0, LIBNDR_FLAG_REF_ALLOC);
    3081           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3082           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpwBuildNumber);
    3083             :                 }
    3084           0 :                 _mem_save_lpwBuildNumber_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3085           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpwBuildNumber, LIBNDR_FLAG_REF_ALLOC);
    3086           0 :                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->out.lpwBuildNumber));
    3087           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpwBuildNumber_0, LIBNDR_FLAG_REF_ALLOC);
    3088           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3089           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpszVendorId);
    3090             :                 }
    3091           0 :                 _mem_save_lpszVendorId_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3092           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpszVendorId, LIBNDR_FLAG_REF_ALLOC);
    3093           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpszVendorId));
    3094           0 :                 if (_ptr_lpszVendorId) {
    3095           0 :                         NDR_PULL_ALLOC(ndr, *r->out.lpszVendorId);
    3096             :                 } else {
    3097           0 :                         *r->out.lpszVendorId = NULL;
    3098             :                 }
    3099           0 :                 if (*r->out.lpszVendorId) {
    3100           0 :                         _mem_save_lpszVendorId_1 = NDR_PULL_GET_MEM_CTX(ndr);
    3101           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.lpszVendorId, 0);
    3102           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.lpszVendorId));
    3103           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.lpszVendorId));
    3104           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)r->out.lpszVendorId, &size_lpszVendorId_2));
    3105           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)r->out.lpszVendorId, &length_lpszVendorId_2));
    3106           0 :                         if (length_lpszVendorId_2 > size_lpszVendorId_2) {
    3107           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpszVendorId_2, length_lpszVendorId_2);
    3108             :                         }
    3109           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_lpszVendorId_2, sizeof(uint16_t)));
    3110           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.lpszVendorId, length_lpszVendorId_2, sizeof(uint16_t), CH_UTF16));
    3111           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpszVendorId_1, 0);
    3112             :                 }
    3113           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpszVendorId_0, LIBNDR_FLAG_REF_ALLOC);
    3114           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3115           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpszCSDVersion);
    3116             :                 }
    3117           0 :                 _mem_save_lpszCSDVersion_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3118           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpszCSDVersion, LIBNDR_FLAG_REF_ALLOC);
    3119           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpszCSDVersion));
    3120           0 :                 if (_ptr_lpszCSDVersion) {
    3121           0 :                         NDR_PULL_ALLOC(ndr, *r->out.lpszCSDVersion);
    3122             :                 } else {
    3123           0 :                         *r->out.lpszCSDVersion = NULL;
    3124             :                 }
    3125           0 :                 if (*r->out.lpszCSDVersion) {
    3126           0 :                         _mem_save_lpszCSDVersion_1 = NDR_PULL_GET_MEM_CTX(ndr);
    3127           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.lpszCSDVersion, 0);
    3128           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.lpszCSDVersion));
    3129           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.lpszCSDVersion));
    3130           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)r->out.lpszCSDVersion, &size_lpszCSDVersion_2));
    3131           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)r->out.lpszCSDVersion, &length_lpszCSDVersion_2));
    3132           0 :                         if (length_lpszCSDVersion_2 > size_lpszCSDVersion_2) {
    3133           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpszCSDVersion_2, length_lpszCSDVersion_2);
    3134             :                         }
    3135           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_lpszCSDVersion_2, sizeof(uint16_t)));
    3136           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.lpszCSDVersion, length_lpszCSDVersion_2, sizeof(uint16_t), CH_UTF16));
    3137           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpszCSDVersion_1, 0);
    3138             :                 }
    3139           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpszCSDVersion_0, LIBNDR_FLAG_REF_ALLOC);
    3140           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3141             :         }
    3142           0 :         return NDR_ERR_SUCCESS;
    3143             : }
    3144             : 
    3145           0 : _PUBLIC_ void ndr_print_clusapi_GetClusterVersion(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_GetClusterVersion *r)
    3146             : {
    3147           0 :         ndr_print_struct(ndr, name, "clusapi_GetClusterVersion");
    3148           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3149           0 :         ndr->depth++;
    3150           0 :         if (flags & NDR_SET_VALUES) {
    3151           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3152             :         }
    3153           0 :         if (flags & NDR_IN) {
    3154           0 :                 ndr_print_struct(ndr, "in", "clusapi_GetClusterVersion");
    3155           0 :                 ndr->depth++;
    3156           0 :                 ndr->depth--;
    3157             :         }
    3158           0 :         if (flags & NDR_OUT) {
    3159           0 :                 ndr_print_struct(ndr, "out", "clusapi_GetClusterVersion");
    3160           0 :                 ndr->depth++;
    3161           0 :                 ndr_print_ptr(ndr, "lpwMajorVersion", r->out.lpwMajorVersion);
    3162           0 :                 ndr->depth++;
    3163           0 :                 ndr_print_uint16(ndr, "lpwMajorVersion", *r->out.lpwMajorVersion);
    3164           0 :                 ndr->depth--;
    3165           0 :                 ndr_print_ptr(ndr, "lpwMinorVersion", r->out.lpwMinorVersion);
    3166           0 :                 ndr->depth++;
    3167           0 :                 ndr_print_uint16(ndr, "lpwMinorVersion", *r->out.lpwMinorVersion);
    3168           0 :                 ndr->depth--;
    3169           0 :                 ndr_print_ptr(ndr, "lpwBuildNumber", r->out.lpwBuildNumber);
    3170           0 :                 ndr->depth++;
    3171           0 :                 ndr_print_uint16(ndr, "lpwBuildNumber", *r->out.lpwBuildNumber);
    3172           0 :                 ndr->depth--;
    3173           0 :                 ndr_print_ptr(ndr, "lpszVendorId", r->out.lpszVendorId);
    3174           0 :                 ndr->depth++;
    3175           0 :                 ndr_print_ptr(ndr, "lpszVendorId", *r->out.lpszVendorId);
    3176           0 :                 ndr->depth++;
    3177           0 :                 if (*r->out.lpszVendorId) {
    3178           0 :                         ndr_print_string(ndr, "lpszVendorId", *r->out.lpszVendorId);
    3179             :                 }
    3180           0 :                 ndr->depth--;
    3181           0 :                 ndr->depth--;
    3182           0 :                 ndr_print_ptr(ndr, "lpszCSDVersion", r->out.lpszCSDVersion);
    3183           0 :                 ndr->depth++;
    3184           0 :                 ndr_print_ptr(ndr, "lpszCSDVersion", *r->out.lpszCSDVersion);
    3185           0 :                 ndr->depth++;
    3186           0 :                 if (*r->out.lpszCSDVersion) {
    3187           0 :                         ndr_print_string(ndr, "lpszCSDVersion", *r->out.lpszCSDVersion);
    3188             :                 }
    3189           0 :                 ndr->depth--;
    3190           0 :                 ndr->depth--;
    3191           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3192           0 :                 ndr->depth--;
    3193             :         }
    3194           0 :         ndr->depth--;
    3195             : }
    3196             : 
    3197           0 : static enum ndr_err_code ndr_push_clusapi_GetQuorumResource(struct ndr_push *ndr, int flags, const struct clusapi_GetQuorumResource *r)
    3198             : {
    3199           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3200           0 :         if (flags & NDR_IN) {
    3201             :         }
    3202           0 :         if (flags & NDR_OUT) {
    3203           0 :                 if (r->out.lpszResourceName == NULL) {
    3204           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3205             :                 }
    3206           0 :                 if (r->out.lpszDeviceName == NULL) {
    3207           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3208             :                 }
    3209           0 :                 if (r->out.pdwMaxQuorumLogSize == NULL) {
    3210           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3211             :                 }
    3212           0 :                 if (r->out.rpc_status == NULL) {
    3213           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3214             :                 }
    3215           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.lpszResourceName));
    3216           0 :                 if (*r->out.lpszResourceName) {
    3217           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.lpszResourceName, CH_UTF16)));
    3218           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    3219           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.lpszResourceName, CH_UTF16)));
    3220           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.lpszResourceName, ndr_charset_length(*r->out.lpszResourceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    3221             :                 }
    3222           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.lpszDeviceName));
    3223           0 :                 if (*r->out.lpszDeviceName) {
    3224           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.lpszDeviceName, CH_UTF16)));
    3225           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    3226           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.lpszDeviceName, CH_UTF16)));
    3227           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.lpszDeviceName, ndr_charset_length(*r->out.lpszDeviceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    3228             :                 }
    3229           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.pdwMaxQuorumLogSize));
    3230           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    3231           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3232             :         }
    3233           0 :         return NDR_ERR_SUCCESS;
    3234             : }
    3235             : 
    3236           0 : static enum ndr_err_code ndr_pull_clusapi_GetQuorumResource(struct ndr_pull *ndr, int flags, struct clusapi_GetQuorumResource *r)
    3237             : {
    3238             :         uint32_t _ptr_lpszResourceName;
    3239           0 :         uint32_t size_lpszResourceName_2 = 0;
    3240           0 :         uint32_t length_lpszResourceName_2 = 0;
    3241             :         uint32_t _ptr_lpszDeviceName;
    3242           0 :         uint32_t size_lpszDeviceName_2 = 0;
    3243           0 :         uint32_t length_lpszDeviceName_2 = 0;
    3244           0 :         TALLOC_CTX *_mem_save_lpszResourceName_0 = NULL;
    3245           0 :         TALLOC_CTX *_mem_save_lpszResourceName_1 = NULL;
    3246           0 :         TALLOC_CTX *_mem_save_lpszDeviceName_0 = NULL;
    3247           0 :         TALLOC_CTX *_mem_save_lpszDeviceName_1 = NULL;
    3248           0 :         TALLOC_CTX *_mem_save_pdwMaxQuorumLogSize_0 = NULL;
    3249           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    3250           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3251           0 :         if (flags & NDR_IN) {
    3252           0 :                 NDR_ZERO_STRUCT(r->out);
    3253             : 
    3254           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpszResourceName);
    3255           0 :                 NDR_ZERO_STRUCTP(r->out.lpszResourceName);
    3256           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpszDeviceName);
    3257           0 :                 NDR_ZERO_STRUCTP(r->out.lpszDeviceName);
    3258           0 :                 NDR_PULL_ALLOC(ndr, r->out.pdwMaxQuorumLogSize);
    3259           0 :                 NDR_ZERO_STRUCTP(r->out.pdwMaxQuorumLogSize);
    3260           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    3261           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    3262             :         }
    3263           0 :         if (flags & NDR_OUT) {
    3264             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3265             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3266           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3267           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpszResourceName);
    3268             :                 }
    3269           0 :                 _mem_save_lpszResourceName_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3270           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpszResourceName, LIBNDR_FLAG_REF_ALLOC);
    3271           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpszResourceName));
    3272           0 :                 if (_ptr_lpszResourceName) {
    3273           0 :                         NDR_PULL_ALLOC(ndr, *r->out.lpszResourceName);
    3274             :                 } else {
    3275           0 :                         *r->out.lpszResourceName = NULL;
    3276             :                 }
    3277           0 :                 if (*r->out.lpszResourceName) {
    3278           0 :                         _mem_save_lpszResourceName_1 = NDR_PULL_GET_MEM_CTX(ndr);
    3279           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.lpszResourceName, 0);
    3280           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.lpszResourceName));
    3281           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.lpszResourceName));
    3282           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)r->out.lpszResourceName, &size_lpszResourceName_2));
    3283           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)r->out.lpszResourceName, &length_lpszResourceName_2));
    3284           0 :                         if (length_lpszResourceName_2 > size_lpszResourceName_2) {
    3285           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpszResourceName_2, length_lpszResourceName_2);
    3286             :                         }
    3287           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_lpszResourceName_2, sizeof(uint16_t)));
    3288           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.lpszResourceName, length_lpszResourceName_2, sizeof(uint16_t), CH_UTF16));
    3289           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpszResourceName_1, 0);
    3290             :                 }
    3291           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpszResourceName_0, LIBNDR_FLAG_REF_ALLOC);
    3292           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3293           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpszDeviceName);
    3294             :                 }
    3295           0 :                 _mem_save_lpszDeviceName_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3296           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpszDeviceName, LIBNDR_FLAG_REF_ALLOC);
    3297           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpszDeviceName));
    3298           0 :                 if (_ptr_lpszDeviceName) {
    3299           0 :                         NDR_PULL_ALLOC(ndr, *r->out.lpszDeviceName);
    3300             :                 } else {
    3301           0 :                         *r->out.lpszDeviceName = NULL;
    3302             :                 }
    3303           0 :                 if (*r->out.lpszDeviceName) {
    3304           0 :                         _mem_save_lpszDeviceName_1 = NDR_PULL_GET_MEM_CTX(ndr);
    3305           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.lpszDeviceName, 0);
    3306           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.lpszDeviceName));
    3307           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.lpszDeviceName));
    3308           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)r->out.lpszDeviceName, &size_lpszDeviceName_2));
    3309           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)r->out.lpszDeviceName, &length_lpszDeviceName_2));
    3310           0 :                         if (length_lpszDeviceName_2 > size_lpszDeviceName_2) {
    3311           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpszDeviceName_2, length_lpszDeviceName_2);
    3312             :                         }
    3313           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_lpszDeviceName_2, sizeof(uint16_t)));
    3314           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.lpszDeviceName, length_lpszDeviceName_2, sizeof(uint16_t), CH_UTF16));
    3315           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpszDeviceName_1, 0);
    3316             :                 }
    3317           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpszDeviceName_0, LIBNDR_FLAG_REF_ALLOC);
    3318           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3319           0 :                         NDR_PULL_ALLOC(ndr, r->out.pdwMaxQuorumLogSize);
    3320             :                 }
    3321           0 :                 _mem_save_pdwMaxQuorumLogSize_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3322           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pdwMaxQuorumLogSize, LIBNDR_FLAG_REF_ALLOC);
    3323           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.pdwMaxQuorumLogSize));
    3324           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pdwMaxQuorumLogSize_0, LIBNDR_FLAG_REF_ALLOC);
    3325           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3326           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    3327             :                 }
    3328           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3329           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    3330           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    3331           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    3332           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3333             :         }
    3334           0 :         return NDR_ERR_SUCCESS;
    3335             : }
    3336             : 
    3337           0 : _PUBLIC_ void ndr_print_clusapi_GetQuorumResource(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_GetQuorumResource *r)
    3338             : {
    3339           0 :         ndr_print_struct(ndr, name, "clusapi_GetQuorumResource");
    3340           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3341           0 :         ndr->depth++;
    3342           0 :         if (flags & NDR_SET_VALUES) {
    3343           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3344             :         }
    3345           0 :         if (flags & NDR_IN) {
    3346           0 :                 ndr_print_struct(ndr, "in", "clusapi_GetQuorumResource");
    3347           0 :                 ndr->depth++;
    3348           0 :                 ndr->depth--;
    3349             :         }
    3350           0 :         if (flags & NDR_OUT) {
    3351           0 :                 ndr_print_struct(ndr, "out", "clusapi_GetQuorumResource");
    3352           0 :                 ndr->depth++;
    3353           0 :                 ndr_print_ptr(ndr, "lpszResourceName", r->out.lpszResourceName);
    3354           0 :                 ndr->depth++;
    3355           0 :                 ndr_print_ptr(ndr, "lpszResourceName", *r->out.lpszResourceName);
    3356           0 :                 ndr->depth++;
    3357           0 :                 if (*r->out.lpszResourceName) {
    3358           0 :                         ndr_print_string(ndr, "lpszResourceName", *r->out.lpszResourceName);
    3359             :                 }
    3360           0 :                 ndr->depth--;
    3361           0 :                 ndr->depth--;
    3362           0 :                 ndr_print_ptr(ndr, "lpszDeviceName", r->out.lpszDeviceName);
    3363           0 :                 ndr->depth++;
    3364           0 :                 ndr_print_ptr(ndr, "lpszDeviceName", *r->out.lpszDeviceName);
    3365           0 :                 ndr->depth++;
    3366           0 :                 if (*r->out.lpszDeviceName) {
    3367           0 :                         ndr_print_string(ndr, "lpszDeviceName", *r->out.lpszDeviceName);
    3368             :                 }
    3369           0 :                 ndr->depth--;
    3370           0 :                 ndr->depth--;
    3371           0 :                 ndr_print_ptr(ndr, "pdwMaxQuorumLogSize", r->out.pdwMaxQuorumLogSize);
    3372           0 :                 ndr->depth++;
    3373           0 :                 ndr_print_uint32(ndr, "pdwMaxQuorumLogSize", *r->out.pdwMaxQuorumLogSize);
    3374           0 :                 ndr->depth--;
    3375           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    3376           0 :                 ndr->depth++;
    3377           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    3378           0 :                 ndr->depth--;
    3379           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3380           0 :                 ndr->depth--;
    3381             :         }
    3382           0 :         ndr->depth--;
    3383             : }
    3384             : 
    3385           0 : static enum ndr_err_code ndr_push_clusapi_SetQuorumResource(struct ndr_push *ndr, int flags, const struct clusapi_SetQuorumResource *r)
    3386             : {
    3387           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3388           0 :         if (flags & NDR_IN) {
    3389           0 :                 if (r->in.lpszDeviceName == NULL) {
    3390           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3391             :                 }
    3392           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    3393           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszDeviceName, CH_UTF16)));
    3394           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    3395           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszDeviceName, CH_UTF16)));
    3396           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpszDeviceName, ndr_charset_length(r->in.lpszDeviceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    3397           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.dwMaxQuorumLogSize));
    3398             :         }
    3399           0 :         if (flags & NDR_OUT) {
    3400           0 :                 if (r->out.rpc_status == NULL) {
    3401           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3402             :                 }
    3403           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    3404           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3405             :         }
    3406           0 :         return NDR_ERR_SUCCESS;
    3407             : }
    3408             : 
    3409           0 : static enum ndr_err_code ndr_pull_clusapi_SetQuorumResource(struct ndr_pull *ndr, int flags, struct clusapi_SetQuorumResource *r)
    3410             : {
    3411           0 :         uint32_t size_lpszDeviceName_1 = 0;
    3412           0 :         uint32_t length_lpszDeviceName_1 = 0;
    3413           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    3414           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3415           0 :         if (flags & NDR_IN) {
    3416           0 :                 NDR_ZERO_STRUCT(r->out);
    3417             : 
    3418           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    3419           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpszDeviceName));
    3420           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpszDeviceName));
    3421           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpszDeviceName, &size_lpszDeviceName_1));
    3422           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpszDeviceName, &length_lpszDeviceName_1));
    3423           0 :                 if (length_lpszDeviceName_1 > size_lpszDeviceName_1) {
    3424           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpszDeviceName_1, length_lpszDeviceName_1);
    3425             :                 }
    3426           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpszDeviceName_1, sizeof(uint16_t)));
    3427           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpszDeviceName, length_lpszDeviceName_1, sizeof(uint16_t), CH_UTF16));
    3428           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.dwMaxQuorumLogSize));
    3429           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    3430           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    3431             :         }
    3432           0 :         if (flags & NDR_OUT) {
    3433             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3434             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3435           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3436           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    3437             :                 }
    3438           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3439           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    3440           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    3441           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    3442           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3443             :         }
    3444           0 :         return NDR_ERR_SUCCESS;
    3445             : }
    3446             : 
    3447           0 : _PUBLIC_ void ndr_print_clusapi_SetQuorumResource(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_SetQuorumResource *r)
    3448             : {
    3449           0 :         ndr_print_struct(ndr, name, "clusapi_SetQuorumResource");
    3450           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3451           0 :         ndr->depth++;
    3452           0 :         if (flags & NDR_SET_VALUES) {
    3453           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3454             :         }
    3455           0 :         if (flags & NDR_IN) {
    3456           0 :                 ndr_print_struct(ndr, "in", "clusapi_SetQuorumResource");
    3457           0 :                 ndr->depth++;
    3458           0 :                 ndr_print_policy_handle(ndr, "hResource", &r->in.hResource);
    3459           0 :                 ndr_print_ptr(ndr, "lpszDeviceName", r->in.lpszDeviceName);
    3460           0 :                 ndr->depth++;
    3461           0 :                 ndr_print_string(ndr, "lpszDeviceName", r->in.lpszDeviceName);
    3462           0 :                 ndr->depth--;
    3463           0 :                 ndr_print_uint32(ndr, "dwMaxQuorumLogSize", r->in.dwMaxQuorumLogSize);
    3464           0 :                 ndr->depth--;
    3465             :         }
    3466           0 :         if (flags & NDR_OUT) {
    3467           0 :                 ndr_print_struct(ndr, "out", "clusapi_SetQuorumResource");
    3468           0 :                 ndr->depth++;
    3469           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    3470           0 :                 ndr->depth++;
    3471           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    3472           0 :                 ndr->depth--;
    3473           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3474           0 :                 ndr->depth--;
    3475             :         }
    3476           0 :         ndr->depth--;
    3477             : }
    3478             : 
    3479           0 : static enum ndr_err_code ndr_push_clusapi_CreateEnum(struct ndr_push *ndr, int flags, const struct clusapi_CreateEnum *r)
    3480             : {
    3481           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3482           0 :         if (flags & NDR_IN) {
    3483           0 :                 NDR_CHECK(ndr_push_ClusterEnumType(ndr, NDR_SCALARS, r->in.dwType));
    3484             :         }
    3485           0 :         if (flags & NDR_OUT) {
    3486           0 :                 if (r->out.ReturnEnum == NULL) {
    3487           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3488             :                 }
    3489           0 :                 if (r->out.rpc_status == NULL) {
    3490           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3491             :                 }
    3492           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ReturnEnum));
    3493           0 :                 if (*r->out.ReturnEnum) {
    3494           0 :                         NDR_CHECK(ndr_push_ENUM_LIST(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.ReturnEnum));
    3495             :                 }
    3496           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    3497           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3498             :         }
    3499           0 :         return NDR_ERR_SUCCESS;
    3500             : }
    3501             : 
    3502           0 : static enum ndr_err_code ndr_pull_clusapi_CreateEnum(struct ndr_pull *ndr, int flags, struct clusapi_CreateEnum *r)
    3503             : {
    3504             :         uint32_t _ptr_ReturnEnum;
    3505           0 :         TALLOC_CTX *_mem_save_ReturnEnum_0 = NULL;
    3506           0 :         TALLOC_CTX *_mem_save_ReturnEnum_1 = NULL;
    3507           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    3508           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3509           0 :         if (flags & NDR_IN) {
    3510           0 :                 NDR_ZERO_STRUCT(r->out);
    3511             : 
    3512           0 :                 NDR_CHECK(ndr_pull_ClusterEnumType(ndr, NDR_SCALARS, &r->in.dwType));
    3513           0 :                 NDR_PULL_ALLOC(ndr, r->out.ReturnEnum);
    3514           0 :                 NDR_ZERO_STRUCTP(r->out.ReturnEnum);
    3515           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    3516           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    3517             :         }
    3518           0 :         if (flags & NDR_OUT) {
    3519             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3520             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3521           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3522           0 :                         NDR_PULL_ALLOC(ndr, r->out.ReturnEnum);
    3523             :                 }
    3524           0 :                 _mem_save_ReturnEnum_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3525           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ReturnEnum, LIBNDR_FLAG_REF_ALLOC);
    3526           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ReturnEnum));
    3527           0 :                 if (_ptr_ReturnEnum) {
    3528           0 :                         NDR_PULL_ALLOC(ndr, *r->out.ReturnEnum);
    3529             :                 } else {
    3530           0 :                         *r->out.ReturnEnum = NULL;
    3531             :                 }
    3532           0 :                 if (*r->out.ReturnEnum) {
    3533           0 :                         _mem_save_ReturnEnum_1 = NDR_PULL_GET_MEM_CTX(ndr);
    3534           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ReturnEnum, 0);
    3535           0 :                         NDR_CHECK(ndr_pull_ENUM_LIST(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.ReturnEnum));
    3536           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ReturnEnum_1, 0);
    3537             :                 }
    3538           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ReturnEnum_0, LIBNDR_FLAG_REF_ALLOC);
    3539           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3540           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    3541             :                 }
    3542           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3543           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    3544           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    3545           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    3546           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3547             :         }
    3548           0 :         return NDR_ERR_SUCCESS;
    3549             : }
    3550             : 
    3551           0 : _PUBLIC_ void ndr_print_clusapi_CreateEnum(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_CreateEnum *r)
    3552             : {
    3553           0 :         ndr_print_struct(ndr, name, "clusapi_CreateEnum");
    3554           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3555           0 :         ndr->depth++;
    3556           0 :         if (flags & NDR_SET_VALUES) {
    3557           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3558             :         }
    3559           0 :         if (flags & NDR_IN) {
    3560           0 :                 ndr_print_struct(ndr, "in", "clusapi_CreateEnum");
    3561           0 :                 ndr->depth++;
    3562           0 :                 ndr_print_ClusterEnumType(ndr, "dwType", r->in.dwType);
    3563           0 :                 ndr->depth--;
    3564             :         }
    3565           0 :         if (flags & NDR_OUT) {
    3566           0 :                 ndr_print_struct(ndr, "out", "clusapi_CreateEnum");
    3567           0 :                 ndr->depth++;
    3568           0 :                 ndr_print_ptr(ndr, "ReturnEnum", r->out.ReturnEnum);
    3569           0 :                 ndr->depth++;
    3570           0 :                 ndr_print_ptr(ndr, "ReturnEnum", *r->out.ReturnEnum);
    3571           0 :                 ndr->depth++;
    3572           0 :                 if (*r->out.ReturnEnum) {
    3573           0 :                         ndr_print_ENUM_LIST(ndr, "ReturnEnum", *r->out.ReturnEnum);
    3574             :                 }
    3575           0 :                 ndr->depth--;
    3576           0 :                 ndr->depth--;
    3577           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    3578           0 :                 ndr->depth++;
    3579           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    3580           0 :                 ndr->depth--;
    3581           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3582           0 :                 ndr->depth--;
    3583             :         }
    3584           0 :         ndr->depth--;
    3585             : }
    3586             : 
    3587           0 : static enum ndr_err_code ndr_push_clusapi_OpenResource(struct ndr_push *ndr, int flags, const struct clusapi_OpenResource *r)
    3588             : {
    3589           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3590           0 :         if (flags & NDR_IN) {
    3591           0 :                 if (r->in.lpszResourceName == NULL) {
    3592           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3593             :                 }
    3594           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszResourceName, CH_UTF16)));
    3595           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    3596           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszResourceName, CH_UTF16)));
    3597           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpszResourceName, ndr_charset_length(r->in.lpszResourceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    3598             :         }
    3599           0 :         if (flags & NDR_OUT) {
    3600           0 :                 if (r->out.Status == NULL) {
    3601           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3602             :                 }
    3603           0 :                 if (r->out.rpc_status == NULL) {
    3604           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3605             :                 }
    3606           0 :                 if (r->out.hResource == NULL) {
    3607           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3608             :                 }
    3609           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.Status));
    3610           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    3611           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.hResource));
    3612             :         }
    3613           0 :         return NDR_ERR_SUCCESS;
    3614             : }
    3615             : 
    3616           0 : static enum ndr_err_code ndr_pull_clusapi_OpenResource(struct ndr_pull *ndr, int flags, struct clusapi_OpenResource *r)
    3617             : {
    3618           0 :         uint32_t size_lpszResourceName_1 = 0;
    3619           0 :         uint32_t length_lpszResourceName_1 = 0;
    3620           0 :         TALLOC_CTX *_mem_save_Status_0 = NULL;
    3621           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    3622           0 :         TALLOC_CTX *_mem_save_hResource_0 = NULL;
    3623           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3624           0 :         if (flags & NDR_IN) {
    3625           0 :                 NDR_ZERO_STRUCT(r->out);
    3626             : 
    3627           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpszResourceName));
    3628           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpszResourceName));
    3629           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpszResourceName, &size_lpszResourceName_1));
    3630           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpszResourceName, &length_lpszResourceName_1));
    3631           0 :                 if (length_lpszResourceName_1 > size_lpszResourceName_1) {
    3632           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpszResourceName_1, length_lpszResourceName_1);
    3633             :                 }
    3634           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpszResourceName_1, sizeof(uint16_t)));
    3635           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpszResourceName, length_lpszResourceName_1, sizeof(uint16_t), CH_UTF16));
    3636           0 :                 NDR_PULL_ALLOC(ndr, r->out.Status);
    3637           0 :                 NDR_ZERO_STRUCTP(r->out.Status);
    3638           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    3639           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    3640           0 :                 NDR_PULL_ALLOC(ndr, r->out.hResource);
    3641           0 :                 NDR_ZERO_STRUCTP(r->out.hResource);
    3642             :         }
    3643           0 :         if (flags & NDR_OUT) {
    3644             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3645             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3646           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3647           0 :                         NDR_PULL_ALLOC(ndr, r->out.Status);
    3648             :                 }
    3649           0 :                 _mem_save_Status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3650           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.Status, LIBNDR_FLAG_REF_ALLOC);
    3651           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.Status));
    3652           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Status_0, LIBNDR_FLAG_REF_ALLOC);
    3653           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3654           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    3655             :                 }
    3656           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3657           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    3658           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    3659           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    3660           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3661           0 :                         NDR_PULL_ALLOC(ndr, r->out.hResource);
    3662             :                 }
    3663           0 :                 _mem_save_hResource_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3664           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.hResource, LIBNDR_FLAG_REF_ALLOC);
    3665           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.hResource));
    3666           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hResource_0, LIBNDR_FLAG_REF_ALLOC);
    3667             :         }
    3668           0 :         return NDR_ERR_SUCCESS;
    3669             : }
    3670             : 
    3671           0 : _PUBLIC_ void ndr_print_clusapi_OpenResource(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_OpenResource *r)
    3672             : {
    3673           0 :         ndr_print_struct(ndr, name, "clusapi_OpenResource");
    3674           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3675           0 :         ndr->depth++;
    3676           0 :         if (flags & NDR_SET_VALUES) {
    3677           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3678             :         }
    3679           0 :         if (flags & NDR_IN) {
    3680           0 :                 ndr_print_struct(ndr, "in", "clusapi_OpenResource");
    3681           0 :                 ndr->depth++;
    3682           0 :                 ndr_print_ptr(ndr, "lpszResourceName", r->in.lpszResourceName);
    3683           0 :                 ndr->depth++;
    3684           0 :                 ndr_print_string(ndr, "lpszResourceName", r->in.lpszResourceName);
    3685           0 :                 ndr->depth--;
    3686           0 :                 ndr->depth--;
    3687             :         }
    3688           0 :         if (flags & NDR_OUT) {
    3689           0 :                 ndr_print_struct(ndr, "out", "clusapi_OpenResource");
    3690           0 :                 ndr->depth++;
    3691           0 :                 ndr_print_ptr(ndr, "Status", r->out.Status);
    3692           0 :                 ndr->depth++;
    3693           0 :                 ndr_print_WERROR(ndr, "Status", *r->out.Status);
    3694           0 :                 ndr->depth--;
    3695           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    3696           0 :                 ndr->depth++;
    3697           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    3698           0 :                 ndr->depth--;
    3699           0 :                 ndr_print_ptr(ndr, "hResource", r->out.hResource);
    3700           0 :                 ndr->depth++;
    3701           0 :                 ndr_print_policy_handle(ndr, "hResource", r->out.hResource);
    3702           0 :                 ndr->depth--;
    3703           0 :                 ndr->depth--;
    3704             :         }
    3705           0 :         ndr->depth--;
    3706             : }
    3707             : 
    3708           0 : static enum ndr_err_code ndr_push_clusapi_CreateResource(struct ndr_push *ndr, int flags, const struct clusapi_CreateResource *r)
    3709             : {
    3710           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3711           0 :         if (flags & NDR_IN) {
    3712           0 :                 if (r->in.lpszResourceName == NULL) {
    3713           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3714             :                 }
    3715           0 :                 if (r->in.lpszResourceType == NULL) {
    3716           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3717             :                 }
    3718           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hGroup));
    3719           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszResourceName, CH_UTF16)));
    3720           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    3721           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszResourceName, CH_UTF16)));
    3722           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpszResourceName, ndr_charset_length(r->in.lpszResourceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    3723           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszResourceType, CH_UTF16)));
    3724           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    3725           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszResourceType, CH_UTF16)));
    3726           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpszResourceType, ndr_charset_length(r->in.lpszResourceType, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    3727           0 :                 NDR_CHECK(ndr_push_clusapi_CreateResourceFlags(ndr, NDR_SCALARS, r->in.dwFlags));
    3728             :         }
    3729           0 :         if (flags & NDR_OUT) {
    3730           0 :                 if (r->out.Status == NULL) {
    3731           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3732             :                 }
    3733           0 :                 if (r->out.rpc_status == NULL) {
    3734           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3735             :                 }
    3736           0 :                 if (r->out.hResource == NULL) {
    3737           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3738             :                 }
    3739           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.Status));
    3740           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    3741           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.hResource));
    3742             :         }
    3743           0 :         return NDR_ERR_SUCCESS;
    3744             : }
    3745             : 
    3746           0 : static enum ndr_err_code ndr_pull_clusapi_CreateResource(struct ndr_pull *ndr, int flags, struct clusapi_CreateResource *r)
    3747             : {
    3748           0 :         uint32_t size_lpszResourceName_1 = 0;
    3749           0 :         uint32_t length_lpszResourceName_1 = 0;
    3750           0 :         uint32_t size_lpszResourceType_1 = 0;
    3751           0 :         uint32_t length_lpszResourceType_1 = 0;
    3752           0 :         TALLOC_CTX *_mem_save_Status_0 = NULL;
    3753           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    3754           0 :         TALLOC_CTX *_mem_save_hResource_0 = NULL;
    3755           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3756           0 :         if (flags & NDR_IN) {
    3757           0 :                 NDR_ZERO_STRUCT(r->out);
    3758             : 
    3759           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hGroup));
    3760           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpszResourceName));
    3761           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpszResourceName));
    3762           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpszResourceName, &size_lpszResourceName_1));
    3763           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpszResourceName, &length_lpszResourceName_1));
    3764           0 :                 if (length_lpszResourceName_1 > size_lpszResourceName_1) {
    3765           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpszResourceName_1, length_lpszResourceName_1);
    3766             :                 }
    3767           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpszResourceName_1, sizeof(uint16_t)));
    3768           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpszResourceName, length_lpszResourceName_1, sizeof(uint16_t), CH_UTF16));
    3769           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpszResourceType));
    3770           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpszResourceType));
    3771           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpszResourceType, &size_lpszResourceType_1));
    3772           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpszResourceType, &length_lpszResourceType_1));
    3773           0 :                 if (length_lpszResourceType_1 > size_lpszResourceType_1) {
    3774           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpszResourceType_1, length_lpszResourceType_1);
    3775             :                 }
    3776           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpszResourceType_1, sizeof(uint16_t)));
    3777           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpszResourceType, length_lpszResourceType_1, sizeof(uint16_t), CH_UTF16));
    3778           0 :                 NDR_CHECK(ndr_pull_clusapi_CreateResourceFlags(ndr, NDR_SCALARS, &r->in.dwFlags));
    3779           0 :                 NDR_PULL_ALLOC(ndr, r->out.Status);
    3780           0 :                 NDR_ZERO_STRUCTP(r->out.Status);
    3781           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    3782           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    3783           0 :                 NDR_PULL_ALLOC(ndr, r->out.hResource);
    3784           0 :                 NDR_ZERO_STRUCTP(r->out.hResource);
    3785             :         }
    3786           0 :         if (flags & NDR_OUT) {
    3787             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3788             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3789           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3790           0 :                         NDR_PULL_ALLOC(ndr, r->out.Status);
    3791             :                 }
    3792           0 :                 _mem_save_Status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3793           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.Status, LIBNDR_FLAG_REF_ALLOC);
    3794           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.Status));
    3795           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Status_0, LIBNDR_FLAG_REF_ALLOC);
    3796           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3797           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    3798             :                 }
    3799           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3800           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    3801           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    3802           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    3803           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3804           0 :                         NDR_PULL_ALLOC(ndr, r->out.hResource);
    3805             :                 }
    3806           0 :                 _mem_save_hResource_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3807           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.hResource, LIBNDR_FLAG_REF_ALLOC);
    3808           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.hResource));
    3809           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hResource_0, LIBNDR_FLAG_REF_ALLOC);
    3810             :         }
    3811           0 :         return NDR_ERR_SUCCESS;
    3812             : }
    3813             : 
    3814           0 : _PUBLIC_ void ndr_print_clusapi_CreateResource(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_CreateResource *r)
    3815             : {
    3816           0 :         ndr_print_struct(ndr, name, "clusapi_CreateResource");
    3817           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3818           0 :         ndr->depth++;
    3819           0 :         if (flags & NDR_SET_VALUES) {
    3820           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3821             :         }
    3822           0 :         if (flags & NDR_IN) {
    3823           0 :                 ndr_print_struct(ndr, "in", "clusapi_CreateResource");
    3824           0 :                 ndr->depth++;
    3825           0 :                 ndr_print_policy_handle(ndr, "hGroup", &r->in.hGroup);
    3826           0 :                 ndr_print_ptr(ndr, "lpszResourceName", r->in.lpszResourceName);
    3827           0 :                 ndr->depth++;
    3828           0 :                 ndr_print_string(ndr, "lpszResourceName", r->in.lpszResourceName);
    3829           0 :                 ndr->depth--;
    3830           0 :                 ndr_print_ptr(ndr, "lpszResourceType", r->in.lpszResourceType);
    3831           0 :                 ndr->depth++;
    3832           0 :                 ndr_print_string(ndr, "lpszResourceType", r->in.lpszResourceType);
    3833           0 :                 ndr->depth--;
    3834           0 :                 ndr_print_clusapi_CreateResourceFlags(ndr, "dwFlags", r->in.dwFlags);
    3835           0 :                 ndr->depth--;
    3836             :         }
    3837           0 :         if (flags & NDR_OUT) {
    3838           0 :                 ndr_print_struct(ndr, "out", "clusapi_CreateResource");
    3839           0 :                 ndr->depth++;
    3840           0 :                 ndr_print_ptr(ndr, "Status", r->out.Status);
    3841           0 :                 ndr->depth++;
    3842           0 :                 ndr_print_WERROR(ndr, "Status", *r->out.Status);
    3843           0 :                 ndr->depth--;
    3844           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    3845           0 :                 ndr->depth++;
    3846           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    3847           0 :                 ndr->depth--;
    3848           0 :                 ndr_print_ptr(ndr, "hResource", r->out.hResource);
    3849           0 :                 ndr->depth++;
    3850           0 :                 ndr_print_policy_handle(ndr, "hResource", r->out.hResource);
    3851           0 :                 ndr->depth--;
    3852           0 :                 ndr->depth--;
    3853             :         }
    3854           0 :         ndr->depth--;
    3855             : }
    3856             : 
    3857           0 : static enum ndr_err_code ndr_push_clusapi_DeleteResource(struct ndr_push *ndr, int flags, const struct clusapi_DeleteResource *r)
    3858             : {
    3859           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3860           0 :         if (flags & NDR_IN) {
    3861           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    3862             :         }
    3863           0 :         if (flags & NDR_OUT) {
    3864           0 :                 if (r->out.rpc_status == NULL) {
    3865           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3866             :                 }
    3867           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    3868           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3869             :         }
    3870           0 :         return NDR_ERR_SUCCESS;
    3871             : }
    3872             : 
    3873           0 : static enum ndr_err_code ndr_pull_clusapi_DeleteResource(struct ndr_pull *ndr, int flags, struct clusapi_DeleteResource *r)
    3874             : {
    3875           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    3876           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3877           0 :         if (flags & NDR_IN) {
    3878           0 :                 NDR_ZERO_STRUCT(r->out);
    3879             : 
    3880           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    3881           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    3882           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    3883             :         }
    3884           0 :         if (flags & NDR_OUT) {
    3885             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3886             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3887           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3888           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    3889             :                 }
    3890           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3891           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    3892           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    3893           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    3894           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3895             :         }
    3896           0 :         return NDR_ERR_SUCCESS;
    3897             : }
    3898             : 
    3899           0 : _PUBLIC_ void ndr_print_clusapi_DeleteResource(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_DeleteResource *r)
    3900             : {
    3901           0 :         ndr_print_struct(ndr, name, "clusapi_DeleteResource");
    3902           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3903           0 :         ndr->depth++;
    3904           0 :         if (flags & NDR_SET_VALUES) {
    3905           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3906             :         }
    3907           0 :         if (flags & NDR_IN) {
    3908           0 :                 ndr_print_struct(ndr, "in", "clusapi_DeleteResource");
    3909           0 :                 ndr->depth++;
    3910           0 :                 ndr_print_policy_handle(ndr, "hResource", &r->in.hResource);
    3911           0 :                 ndr->depth--;
    3912             :         }
    3913           0 :         if (flags & NDR_OUT) {
    3914           0 :                 ndr_print_struct(ndr, "out", "clusapi_DeleteResource");
    3915           0 :                 ndr->depth++;
    3916           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    3917           0 :                 ndr->depth++;
    3918           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    3919           0 :                 ndr->depth--;
    3920           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    3921           0 :                 ndr->depth--;
    3922             :         }
    3923           0 :         ndr->depth--;
    3924             : }
    3925             : 
    3926           0 : static enum ndr_err_code ndr_push_clusapi_CloseResource(struct ndr_push *ndr, int flags, const struct clusapi_CloseResource *r)
    3927             : {
    3928           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    3929           0 :         if (flags & NDR_IN) {
    3930           0 :                 if (r->in.Resource == NULL) {
    3931           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3932             :                 }
    3933           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.Resource));
    3934             :         }
    3935           0 :         if (flags & NDR_OUT) {
    3936           0 :                 if (r->out.Resource == NULL) {
    3937           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    3938             :                 }
    3939           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.Resource));
    3940           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    3941             :         }
    3942           0 :         return NDR_ERR_SUCCESS;
    3943             : }
    3944             : 
    3945           0 : static enum ndr_err_code ndr_pull_clusapi_CloseResource(struct ndr_pull *ndr, int flags, struct clusapi_CloseResource *r)
    3946             : {
    3947           0 :         TALLOC_CTX *_mem_save_Resource_0 = NULL;
    3948           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    3949           0 :         if (flags & NDR_IN) {
    3950           0 :                 NDR_ZERO_STRUCT(r->out);
    3951             : 
    3952           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3953           0 :                         NDR_PULL_ALLOC(ndr, r->in.Resource);
    3954             :                 }
    3955           0 :                 _mem_save_Resource_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3956           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.Resource, LIBNDR_FLAG_REF_ALLOC);
    3957           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.Resource));
    3958           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Resource_0, LIBNDR_FLAG_REF_ALLOC);
    3959           0 :                 NDR_PULL_ALLOC(ndr, r->out.Resource);
    3960           0 :                 *r->out.Resource = *r->in.Resource;
    3961             :         }
    3962           0 :         if (flags & NDR_OUT) {
    3963             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    3964             :                 if (r->in.Resource == NULL) {
    3965             :                         NDR_PULL_ALLOC(ndr, r->in.Resource);
    3966             :                         NDR_ZERO_STRUCTP(r->in.Resource);
    3967             :                 }
    3968             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    3969           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    3970           0 :                         NDR_PULL_ALLOC(ndr, r->out.Resource);
    3971             :                 }
    3972           0 :                 _mem_save_Resource_0 = NDR_PULL_GET_MEM_CTX(ndr);
    3973           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.Resource, LIBNDR_FLAG_REF_ALLOC);
    3974           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.Resource));
    3975           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Resource_0, LIBNDR_FLAG_REF_ALLOC);
    3976           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    3977             :         }
    3978           0 :         return NDR_ERR_SUCCESS;
    3979             : }
    3980             : 
    3981           0 : _PUBLIC_ void ndr_print_clusapi_CloseResource(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_CloseResource *r)
    3982             : {
    3983           0 :         ndr_print_struct(ndr, name, "clusapi_CloseResource");
    3984           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    3985           0 :         ndr->depth++;
    3986           0 :         if (flags & NDR_SET_VALUES) {
    3987           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    3988             :         }
    3989           0 :         if (flags & NDR_IN) {
    3990           0 :                 ndr_print_struct(ndr, "in", "clusapi_CloseResource");
    3991           0 :                 ndr->depth++;
    3992           0 :                 ndr_print_ptr(ndr, "Resource", r->in.Resource);
    3993           0 :                 ndr->depth++;
    3994           0 :                 ndr_print_policy_handle(ndr, "Resource", r->in.Resource);
    3995           0 :                 ndr->depth--;
    3996           0 :                 ndr->depth--;
    3997             :         }
    3998           0 :         if (flags & NDR_OUT) {
    3999           0 :                 ndr_print_struct(ndr, "out", "clusapi_CloseResource");
    4000           0 :                 ndr->depth++;
    4001           0 :                 ndr_print_ptr(ndr, "Resource", r->out.Resource);
    4002           0 :                 ndr->depth++;
    4003           0 :                 ndr_print_policy_handle(ndr, "Resource", r->out.Resource);
    4004           0 :                 ndr->depth--;
    4005           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4006           0 :                 ndr->depth--;
    4007             :         }
    4008           0 :         ndr->depth--;
    4009             : }
    4010             : 
    4011           0 : static enum ndr_err_code ndr_push_clusapi_GetResourceState(struct ndr_push *ndr, int flags, const struct clusapi_GetResourceState *r)
    4012             : {
    4013           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4014           0 :         if (flags & NDR_IN) {
    4015           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4016             :         }
    4017           0 :         if (flags & NDR_OUT) {
    4018           0 :                 if (r->out.State == NULL) {
    4019           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4020             :                 }
    4021           0 :                 if (r->out.NodeName == NULL) {
    4022           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4023             :                 }
    4024           0 :                 if (r->out.GroupName == NULL) {
    4025           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4026             :                 }
    4027           0 :                 if (r->out.rpc_status == NULL) {
    4028           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4029             :                 }
    4030           0 :                 NDR_CHECK(ndr_push_clusapi_ClusterResourceState(ndr, NDR_SCALARS, *r->out.State));
    4031           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.NodeName));
    4032           0 :                 if (*r->out.NodeName) {
    4033           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.NodeName, CH_UTF16)));
    4034           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    4035           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.NodeName, CH_UTF16)));
    4036           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.NodeName, ndr_charset_length(*r->out.NodeName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    4037             :                 }
    4038           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.GroupName));
    4039           0 :                 if (*r->out.GroupName) {
    4040           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.GroupName, CH_UTF16)));
    4041           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    4042           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.GroupName, CH_UTF16)));
    4043           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.GroupName, ndr_charset_length(*r->out.GroupName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    4044             :                 }
    4045           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    4046           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4047             :         }
    4048           0 :         return NDR_ERR_SUCCESS;
    4049             : }
    4050             : 
    4051           0 : static enum ndr_err_code ndr_pull_clusapi_GetResourceState(struct ndr_pull *ndr, int flags, struct clusapi_GetResourceState *r)
    4052             : {
    4053             :         uint32_t _ptr_NodeName;
    4054           0 :         uint32_t size_NodeName_2 = 0;
    4055           0 :         uint32_t length_NodeName_2 = 0;
    4056             :         uint32_t _ptr_GroupName;
    4057           0 :         uint32_t size_GroupName_2 = 0;
    4058           0 :         uint32_t length_GroupName_2 = 0;
    4059           0 :         TALLOC_CTX *_mem_save_State_0 = NULL;
    4060           0 :         TALLOC_CTX *_mem_save_NodeName_0 = NULL;
    4061           0 :         TALLOC_CTX *_mem_save_NodeName_1 = NULL;
    4062           0 :         TALLOC_CTX *_mem_save_GroupName_0 = NULL;
    4063           0 :         TALLOC_CTX *_mem_save_GroupName_1 = NULL;
    4064           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    4065           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4066           0 :         if (flags & NDR_IN) {
    4067           0 :                 NDR_ZERO_STRUCT(r->out);
    4068             : 
    4069           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4070           0 :                 NDR_PULL_ALLOC(ndr, r->out.State);
    4071           0 :                 NDR_ZERO_STRUCTP(r->out.State);
    4072           0 :                 NDR_PULL_ALLOC(ndr, r->out.NodeName);
    4073           0 :                 NDR_ZERO_STRUCTP(r->out.NodeName);
    4074           0 :                 NDR_PULL_ALLOC(ndr, r->out.GroupName);
    4075           0 :                 NDR_ZERO_STRUCTP(r->out.GroupName);
    4076           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4077           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    4078             :         }
    4079           0 :         if (flags & NDR_OUT) {
    4080             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4081             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4082           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4083           0 :                         NDR_PULL_ALLOC(ndr, r->out.State);
    4084             :                 }
    4085           0 :                 _mem_save_State_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4086           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.State, LIBNDR_FLAG_REF_ALLOC);
    4087           0 :                 NDR_CHECK(ndr_pull_clusapi_ClusterResourceState(ndr, NDR_SCALARS, r->out.State));
    4088           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_State_0, LIBNDR_FLAG_REF_ALLOC);
    4089           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4090           0 :                         NDR_PULL_ALLOC(ndr, r->out.NodeName);
    4091             :                 }
    4092           0 :                 _mem_save_NodeName_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4093           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.NodeName, LIBNDR_FLAG_REF_ALLOC);
    4094           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NodeName));
    4095           0 :                 if (_ptr_NodeName) {
    4096           0 :                         NDR_PULL_ALLOC(ndr, *r->out.NodeName);
    4097             :                 } else {
    4098           0 :                         *r->out.NodeName = NULL;
    4099             :                 }
    4100           0 :                 if (*r->out.NodeName) {
    4101           0 :                         _mem_save_NodeName_1 = NDR_PULL_GET_MEM_CTX(ndr);
    4102           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.NodeName, 0);
    4103           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.NodeName));
    4104           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.NodeName));
    4105           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)r->out.NodeName, &size_NodeName_2));
    4106           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)r->out.NodeName, &length_NodeName_2));
    4107           0 :                         if (length_NodeName_2 > size_NodeName_2) {
    4108           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_NodeName_2, length_NodeName_2);
    4109             :                         }
    4110           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_NodeName_2, sizeof(uint16_t)));
    4111           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.NodeName, length_NodeName_2, sizeof(uint16_t), CH_UTF16));
    4112           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NodeName_1, 0);
    4113             :                 }
    4114           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NodeName_0, LIBNDR_FLAG_REF_ALLOC);
    4115           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4116           0 :                         NDR_PULL_ALLOC(ndr, r->out.GroupName);
    4117             :                 }
    4118           0 :                 _mem_save_GroupName_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4119           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.GroupName, LIBNDR_FLAG_REF_ALLOC);
    4120           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_GroupName));
    4121           0 :                 if (_ptr_GroupName) {
    4122           0 :                         NDR_PULL_ALLOC(ndr, *r->out.GroupName);
    4123             :                 } else {
    4124           0 :                         *r->out.GroupName = NULL;
    4125             :                 }
    4126           0 :                 if (*r->out.GroupName) {
    4127           0 :                         _mem_save_GroupName_1 = NDR_PULL_GET_MEM_CTX(ndr);
    4128           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.GroupName, 0);
    4129           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.GroupName));
    4130           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.GroupName));
    4131           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)r->out.GroupName, &size_GroupName_2));
    4132           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)r->out.GroupName, &length_GroupName_2));
    4133           0 :                         if (length_GroupName_2 > size_GroupName_2) {
    4134           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_GroupName_2, length_GroupName_2);
    4135             :                         }
    4136           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_GroupName_2, sizeof(uint16_t)));
    4137           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.GroupName, length_GroupName_2, sizeof(uint16_t), CH_UTF16));
    4138           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_GroupName_1, 0);
    4139             :                 }
    4140           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_GroupName_0, LIBNDR_FLAG_REF_ALLOC);
    4141           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4142           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4143             :                 }
    4144           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4145           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    4146           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    4147           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    4148           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    4149             :         }
    4150           0 :         return NDR_ERR_SUCCESS;
    4151             : }
    4152             : 
    4153           0 : _PUBLIC_ void ndr_print_clusapi_GetResourceState(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_GetResourceState *r)
    4154             : {
    4155           0 :         ndr_print_struct(ndr, name, "clusapi_GetResourceState");
    4156           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    4157           0 :         ndr->depth++;
    4158           0 :         if (flags & NDR_SET_VALUES) {
    4159           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    4160             :         }
    4161           0 :         if (flags & NDR_IN) {
    4162           0 :                 ndr_print_struct(ndr, "in", "clusapi_GetResourceState");
    4163           0 :                 ndr->depth++;
    4164           0 :                 ndr_print_policy_handle(ndr, "hResource", &r->in.hResource);
    4165           0 :                 ndr->depth--;
    4166             :         }
    4167           0 :         if (flags & NDR_OUT) {
    4168           0 :                 ndr_print_struct(ndr, "out", "clusapi_GetResourceState");
    4169           0 :                 ndr->depth++;
    4170           0 :                 ndr_print_ptr(ndr, "State", r->out.State);
    4171           0 :                 ndr->depth++;
    4172           0 :                 ndr_print_clusapi_ClusterResourceState(ndr, "State", *r->out.State);
    4173           0 :                 ndr->depth--;
    4174           0 :                 ndr_print_ptr(ndr, "NodeName", r->out.NodeName);
    4175           0 :                 ndr->depth++;
    4176           0 :                 ndr_print_ptr(ndr, "NodeName", *r->out.NodeName);
    4177           0 :                 ndr->depth++;
    4178           0 :                 if (*r->out.NodeName) {
    4179           0 :                         ndr_print_string(ndr, "NodeName", *r->out.NodeName);
    4180             :                 }
    4181           0 :                 ndr->depth--;
    4182           0 :                 ndr->depth--;
    4183           0 :                 ndr_print_ptr(ndr, "GroupName", r->out.GroupName);
    4184           0 :                 ndr->depth++;
    4185           0 :                 ndr_print_ptr(ndr, "GroupName", *r->out.GroupName);
    4186           0 :                 ndr->depth++;
    4187           0 :                 if (*r->out.GroupName) {
    4188           0 :                         ndr_print_string(ndr, "GroupName", *r->out.GroupName);
    4189             :                 }
    4190           0 :                 ndr->depth--;
    4191           0 :                 ndr->depth--;
    4192           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    4193           0 :                 ndr->depth++;
    4194           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    4195           0 :                 ndr->depth--;
    4196           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4197           0 :                 ndr->depth--;
    4198             :         }
    4199           0 :         ndr->depth--;
    4200             : }
    4201             : 
    4202           0 : static enum ndr_err_code ndr_push_clusapi_SetResourceName(struct ndr_push *ndr, int flags, const struct clusapi_SetResourceName *r)
    4203             : {
    4204           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4205           0 :         if (flags & NDR_IN) {
    4206           0 :                 if (r->in.lpszResourceName == NULL) {
    4207           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4208             :                 }
    4209           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4210           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszResourceName, CH_UTF16)));
    4211           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    4212           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszResourceName, CH_UTF16)));
    4213           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpszResourceName, ndr_charset_length(r->in.lpszResourceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    4214             :         }
    4215           0 :         if (flags & NDR_OUT) {
    4216           0 :                 if (r->out.rpc_status == NULL) {
    4217           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4218             :                 }
    4219           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    4220           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4221             :         }
    4222           0 :         return NDR_ERR_SUCCESS;
    4223             : }
    4224             : 
    4225           0 : static enum ndr_err_code ndr_pull_clusapi_SetResourceName(struct ndr_pull *ndr, int flags, struct clusapi_SetResourceName *r)
    4226             : {
    4227           0 :         uint32_t size_lpszResourceName_1 = 0;
    4228           0 :         uint32_t length_lpszResourceName_1 = 0;
    4229           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    4230           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4231           0 :         if (flags & NDR_IN) {
    4232           0 :                 NDR_ZERO_STRUCT(r->out);
    4233             : 
    4234           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4235           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpszResourceName));
    4236           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpszResourceName));
    4237           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpszResourceName, &size_lpszResourceName_1));
    4238           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpszResourceName, &length_lpszResourceName_1));
    4239           0 :                 if (length_lpszResourceName_1 > size_lpszResourceName_1) {
    4240           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpszResourceName_1, length_lpszResourceName_1);
    4241             :                 }
    4242           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpszResourceName_1, sizeof(uint16_t)));
    4243           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpszResourceName, length_lpszResourceName_1, sizeof(uint16_t), CH_UTF16));
    4244           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4245           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    4246             :         }
    4247           0 :         if (flags & NDR_OUT) {
    4248             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4249             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4250           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4251           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4252             :                 }
    4253           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4254           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    4255           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    4256           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    4257           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    4258             :         }
    4259           0 :         return NDR_ERR_SUCCESS;
    4260             : }
    4261             : 
    4262           0 : _PUBLIC_ void ndr_print_clusapi_SetResourceName(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_SetResourceName *r)
    4263             : {
    4264           0 :         ndr_print_struct(ndr, name, "clusapi_SetResourceName");
    4265           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    4266           0 :         ndr->depth++;
    4267           0 :         if (flags & NDR_SET_VALUES) {
    4268           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    4269             :         }
    4270           0 :         if (flags & NDR_IN) {
    4271           0 :                 ndr_print_struct(ndr, "in", "clusapi_SetResourceName");
    4272           0 :                 ndr->depth++;
    4273           0 :                 ndr_print_policy_handle(ndr, "hResource", &r->in.hResource);
    4274           0 :                 ndr_print_ptr(ndr, "lpszResourceName", r->in.lpszResourceName);
    4275           0 :                 ndr->depth++;
    4276           0 :                 ndr_print_string(ndr, "lpszResourceName", r->in.lpszResourceName);
    4277           0 :                 ndr->depth--;
    4278           0 :                 ndr->depth--;
    4279             :         }
    4280           0 :         if (flags & NDR_OUT) {
    4281           0 :                 ndr_print_struct(ndr, "out", "clusapi_SetResourceName");
    4282           0 :                 ndr->depth++;
    4283           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    4284           0 :                 ndr->depth++;
    4285           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    4286           0 :                 ndr->depth--;
    4287           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4288           0 :                 ndr->depth--;
    4289             :         }
    4290           0 :         ndr->depth--;
    4291             : }
    4292             : 
    4293           0 : static enum ndr_err_code ndr_push_clusapi_GetResourceId(struct ndr_push *ndr, int flags, const struct clusapi_GetResourceId *r)
    4294             : {
    4295           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4296           0 :         if (flags & NDR_IN) {
    4297           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4298             :         }
    4299           0 :         if (flags & NDR_OUT) {
    4300           0 :                 if (r->out.pGuid == NULL) {
    4301           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4302             :                 }
    4303           0 :                 if (r->out.rpc_status == NULL) {
    4304           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4305             :                 }
    4306           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.pGuid));
    4307           0 :                 if (*r->out.pGuid) {
    4308           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.pGuid, CH_UTF16)));
    4309           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    4310           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.pGuid, CH_UTF16)));
    4311           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.pGuid, ndr_charset_length(*r->out.pGuid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    4312             :                 }
    4313           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    4314           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4315             :         }
    4316           0 :         return NDR_ERR_SUCCESS;
    4317             : }
    4318             : 
    4319           0 : static enum ndr_err_code ndr_pull_clusapi_GetResourceId(struct ndr_pull *ndr, int flags, struct clusapi_GetResourceId *r)
    4320             : {
    4321             :         uint32_t _ptr_pGuid;
    4322           0 :         uint32_t size_pGuid_2 = 0;
    4323           0 :         uint32_t length_pGuid_2 = 0;
    4324           0 :         TALLOC_CTX *_mem_save_pGuid_0 = NULL;
    4325           0 :         TALLOC_CTX *_mem_save_pGuid_1 = NULL;
    4326           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    4327           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4328           0 :         if (flags & NDR_IN) {
    4329           0 :                 NDR_ZERO_STRUCT(r->out);
    4330             : 
    4331           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4332           0 :                 NDR_PULL_ALLOC(ndr, r->out.pGuid);
    4333           0 :                 NDR_ZERO_STRUCTP(r->out.pGuid);
    4334           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4335           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    4336             :         }
    4337           0 :         if (flags & NDR_OUT) {
    4338             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4339             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4340           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4341           0 :                         NDR_PULL_ALLOC(ndr, r->out.pGuid);
    4342             :                 }
    4343           0 :                 _mem_save_pGuid_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4344           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pGuid, LIBNDR_FLAG_REF_ALLOC);
    4345           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pGuid));
    4346           0 :                 if (_ptr_pGuid) {
    4347           0 :                         NDR_PULL_ALLOC(ndr, *r->out.pGuid);
    4348             :                 } else {
    4349           0 :                         *r->out.pGuid = NULL;
    4350             :                 }
    4351           0 :                 if (*r->out.pGuid) {
    4352           0 :                         _mem_save_pGuid_1 = NDR_PULL_GET_MEM_CTX(ndr);
    4353           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.pGuid, 0);
    4354           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.pGuid));
    4355           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.pGuid));
    4356           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)r->out.pGuid, &size_pGuid_2));
    4357           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)r->out.pGuid, &length_pGuid_2));
    4358           0 :                         if (length_pGuid_2 > size_pGuid_2) {
    4359           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_pGuid_2, length_pGuid_2);
    4360             :                         }
    4361           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_pGuid_2, sizeof(uint16_t)));
    4362           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.pGuid, length_pGuid_2, sizeof(uint16_t), CH_UTF16));
    4363           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pGuid_1, 0);
    4364             :                 }
    4365           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pGuid_0, LIBNDR_FLAG_REF_ALLOC);
    4366           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4367           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4368             :                 }
    4369           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4370           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    4371           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    4372           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    4373           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    4374             :         }
    4375           0 :         return NDR_ERR_SUCCESS;
    4376             : }
    4377             : 
    4378           0 : _PUBLIC_ void ndr_print_clusapi_GetResourceId(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_GetResourceId *r)
    4379             : {
    4380           0 :         ndr_print_struct(ndr, name, "clusapi_GetResourceId");
    4381           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    4382           0 :         ndr->depth++;
    4383           0 :         if (flags & NDR_SET_VALUES) {
    4384           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    4385             :         }
    4386           0 :         if (flags & NDR_IN) {
    4387           0 :                 ndr_print_struct(ndr, "in", "clusapi_GetResourceId");
    4388           0 :                 ndr->depth++;
    4389           0 :                 ndr_print_policy_handle(ndr, "hResource", &r->in.hResource);
    4390           0 :                 ndr->depth--;
    4391             :         }
    4392           0 :         if (flags & NDR_OUT) {
    4393           0 :                 ndr_print_struct(ndr, "out", "clusapi_GetResourceId");
    4394           0 :                 ndr->depth++;
    4395           0 :                 ndr_print_ptr(ndr, "pGuid", r->out.pGuid);
    4396           0 :                 ndr->depth++;
    4397           0 :                 ndr_print_ptr(ndr, "pGuid", *r->out.pGuid);
    4398           0 :                 ndr->depth++;
    4399           0 :                 if (*r->out.pGuid) {
    4400           0 :                         ndr_print_string(ndr, "pGuid", *r->out.pGuid);
    4401             :                 }
    4402           0 :                 ndr->depth--;
    4403           0 :                 ndr->depth--;
    4404           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    4405           0 :                 ndr->depth++;
    4406           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    4407           0 :                 ndr->depth--;
    4408           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4409           0 :                 ndr->depth--;
    4410             :         }
    4411           0 :         ndr->depth--;
    4412             : }
    4413             : 
    4414           0 : static enum ndr_err_code ndr_push_clusapi_GetResourceType(struct ndr_push *ndr, int flags, const struct clusapi_GetResourceType *r)
    4415             : {
    4416           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4417           0 :         if (flags & NDR_IN) {
    4418           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4419             :         }
    4420           0 :         if (flags & NDR_OUT) {
    4421           0 :                 if (r->out.lpszResourceType == NULL) {
    4422           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4423             :                 }
    4424           0 :                 if (r->out.rpc_status == NULL) {
    4425           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4426             :                 }
    4427           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.lpszResourceType));
    4428           0 :                 if (*r->out.lpszResourceType) {
    4429           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.lpszResourceType, CH_UTF16)));
    4430           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    4431           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.lpszResourceType, CH_UTF16)));
    4432           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.lpszResourceType, ndr_charset_length(*r->out.lpszResourceType, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    4433             :                 }
    4434           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    4435           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4436             :         }
    4437           0 :         return NDR_ERR_SUCCESS;
    4438             : }
    4439             : 
    4440           0 : static enum ndr_err_code ndr_pull_clusapi_GetResourceType(struct ndr_pull *ndr, int flags, struct clusapi_GetResourceType *r)
    4441             : {
    4442             :         uint32_t _ptr_lpszResourceType;
    4443           0 :         uint32_t size_lpszResourceType_2 = 0;
    4444           0 :         uint32_t length_lpszResourceType_2 = 0;
    4445           0 :         TALLOC_CTX *_mem_save_lpszResourceType_0 = NULL;
    4446           0 :         TALLOC_CTX *_mem_save_lpszResourceType_1 = NULL;
    4447           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    4448           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4449           0 :         if (flags & NDR_IN) {
    4450           0 :                 NDR_ZERO_STRUCT(r->out);
    4451             : 
    4452           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4453           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpszResourceType);
    4454           0 :                 NDR_ZERO_STRUCTP(r->out.lpszResourceType);
    4455           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4456           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    4457             :         }
    4458           0 :         if (flags & NDR_OUT) {
    4459             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4460             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4461           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4462           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpszResourceType);
    4463             :                 }
    4464           0 :                 _mem_save_lpszResourceType_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4465           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpszResourceType, LIBNDR_FLAG_REF_ALLOC);
    4466           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpszResourceType));
    4467           0 :                 if (_ptr_lpszResourceType) {
    4468           0 :                         NDR_PULL_ALLOC(ndr, *r->out.lpszResourceType);
    4469             :                 } else {
    4470           0 :                         *r->out.lpszResourceType = NULL;
    4471             :                 }
    4472           0 :                 if (*r->out.lpszResourceType) {
    4473           0 :                         _mem_save_lpszResourceType_1 = NDR_PULL_GET_MEM_CTX(ndr);
    4474           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.lpszResourceType, 0);
    4475           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.lpszResourceType));
    4476           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.lpszResourceType));
    4477           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)r->out.lpszResourceType, &size_lpszResourceType_2));
    4478           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)r->out.lpszResourceType, &length_lpszResourceType_2));
    4479           0 :                         if (length_lpszResourceType_2 > size_lpszResourceType_2) {
    4480           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpszResourceType_2, length_lpszResourceType_2);
    4481             :                         }
    4482           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_lpszResourceType_2, sizeof(uint16_t)));
    4483           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.lpszResourceType, length_lpszResourceType_2, sizeof(uint16_t), CH_UTF16));
    4484           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpszResourceType_1, 0);
    4485             :                 }
    4486           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpszResourceType_0, LIBNDR_FLAG_REF_ALLOC);
    4487           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4488           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4489             :                 }
    4490           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4491           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    4492           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    4493           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    4494           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    4495             :         }
    4496           0 :         return NDR_ERR_SUCCESS;
    4497             : }
    4498             : 
    4499           0 : _PUBLIC_ void ndr_print_clusapi_GetResourceType(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_GetResourceType *r)
    4500             : {
    4501           0 :         ndr_print_struct(ndr, name, "clusapi_GetResourceType");
    4502           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    4503           0 :         ndr->depth++;
    4504           0 :         if (flags & NDR_SET_VALUES) {
    4505           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    4506             :         }
    4507           0 :         if (flags & NDR_IN) {
    4508           0 :                 ndr_print_struct(ndr, "in", "clusapi_GetResourceType");
    4509           0 :                 ndr->depth++;
    4510           0 :                 ndr_print_policy_handle(ndr, "hResource", &r->in.hResource);
    4511           0 :                 ndr->depth--;
    4512             :         }
    4513           0 :         if (flags & NDR_OUT) {
    4514           0 :                 ndr_print_struct(ndr, "out", "clusapi_GetResourceType");
    4515           0 :                 ndr->depth++;
    4516           0 :                 ndr_print_ptr(ndr, "lpszResourceType", r->out.lpszResourceType);
    4517           0 :                 ndr->depth++;
    4518           0 :                 ndr_print_ptr(ndr, "lpszResourceType", *r->out.lpszResourceType);
    4519           0 :                 ndr->depth++;
    4520           0 :                 if (*r->out.lpszResourceType) {
    4521           0 :                         ndr_print_string(ndr, "lpszResourceType", *r->out.lpszResourceType);
    4522             :                 }
    4523           0 :                 ndr->depth--;
    4524           0 :                 ndr->depth--;
    4525           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    4526           0 :                 ndr->depth++;
    4527           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    4528           0 :                 ndr->depth--;
    4529           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4530           0 :                 ndr->depth--;
    4531             :         }
    4532           0 :         ndr->depth--;
    4533             : }
    4534             : 
    4535           0 : static enum ndr_err_code ndr_push_clusapi_FailResource(struct ndr_push *ndr, int flags, const struct clusapi_FailResource *r)
    4536             : {
    4537           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4538           0 :         if (flags & NDR_IN) {
    4539           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4540             :         }
    4541           0 :         if (flags & NDR_OUT) {
    4542           0 :                 if (r->out.rpc_status == NULL) {
    4543           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4544             :                 }
    4545           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    4546           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4547             :         }
    4548           0 :         return NDR_ERR_SUCCESS;
    4549             : }
    4550             : 
    4551           0 : static enum ndr_err_code ndr_pull_clusapi_FailResource(struct ndr_pull *ndr, int flags, struct clusapi_FailResource *r)
    4552             : {
    4553           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    4554           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4555           0 :         if (flags & NDR_IN) {
    4556           0 :                 NDR_ZERO_STRUCT(r->out);
    4557             : 
    4558           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4559           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4560           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    4561             :         }
    4562           0 :         if (flags & NDR_OUT) {
    4563             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4564             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4565           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4566           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4567             :                 }
    4568           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4569           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    4570           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    4571           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    4572           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    4573             :         }
    4574           0 :         return NDR_ERR_SUCCESS;
    4575             : }
    4576             : 
    4577           0 : _PUBLIC_ void ndr_print_clusapi_FailResource(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_FailResource *r)
    4578             : {
    4579           0 :         ndr_print_struct(ndr, name, "clusapi_FailResource");
    4580           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    4581           0 :         ndr->depth++;
    4582           0 :         if (flags & NDR_SET_VALUES) {
    4583           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    4584             :         }
    4585           0 :         if (flags & NDR_IN) {
    4586           0 :                 ndr_print_struct(ndr, "in", "clusapi_FailResource");
    4587           0 :                 ndr->depth++;
    4588           0 :                 ndr_print_policy_handle(ndr, "hResource", &r->in.hResource);
    4589           0 :                 ndr->depth--;
    4590             :         }
    4591           0 :         if (flags & NDR_OUT) {
    4592           0 :                 ndr_print_struct(ndr, "out", "clusapi_FailResource");
    4593           0 :                 ndr->depth++;
    4594           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    4595           0 :                 ndr->depth++;
    4596           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    4597           0 :                 ndr->depth--;
    4598           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4599           0 :                 ndr->depth--;
    4600             :         }
    4601           0 :         ndr->depth--;
    4602             : }
    4603             : 
    4604           0 : static enum ndr_err_code ndr_push_clusapi_OnlineResource(struct ndr_push *ndr, int flags, const struct clusapi_OnlineResource *r)
    4605             : {
    4606           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4607           0 :         if (flags & NDR_IN) {
    4608           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4609             :         }
    4610           0 :         if (flags & NDR_OUT) {
    4611           0 :                 if (r->out.rpc_status == NULL) {
    4612           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4613             :                 }
    4614           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    4615           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4616             :         }
    4617           0 :         return NDR_ERR_SUCCESS;
    4618             : }
    4619             : 
    4620           0 : static enum ndr_err_code ndr_pull_clusapi_OnlineResource(struct ndr_pull *ndr, int flags, struct clusapi_OnlineResource *r)
    4621             : {
    4622           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    4623           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4624           0 :         if (flags & NDR_IN) {
    4625           0 :                 NDR_ZERO_STRUCT(r->out);
    4626             : 
    4627           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4628           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4629           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    4630             :         }
    4631           0 :         if (flags & NDR_OUT) {
    4632             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4633             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4634           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4635           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4636             :                 }
    4637           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4638           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    4639           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    4640           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    4641           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    4642             :         }
    4643           0 :         return NDR_ERR_SUCCESS;
    4644             : }
    4645             : 
    4646           0 : _PUBLIC_ void ndr_print_clusapi_OnlineResource(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_OnlineResource *r)
    4647             : {
    4648           0 :         ndr_print_struct(ndr, name, "clusapi_OnlineResource");
    4649           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    4650           0 :         ndr->depth++;
    4651           0 :         if (flags & NDR_SET_VALUES) {
    4652           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    4653             :         }
    4654           0 :         if (flags & NDR_IN) {
    4655           0 :                 ndr_print_struct(ndr, "in", "clusapi_OnlineResource");
    4656           0 :                 ndr->depth++;
    4657           0 :                 ndr_print_policy_handle(ndr, "hResource", &r->in.hResource);
    4658           0 :                 ndr->depth--;
    4659             :         }
    4660           0 :         if (flags & NDR_OUT) {
    4661           0 :                 ndr_print_struct(ndr, "out", "clusapi_OnlineResource");
    4662           0 :                 ndr->depth++;
    4663           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    4664           0 :                 ndr->depth++;
    4665           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    4666           0 :                 ndr->depth--;
    4667           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4668           0 :                 ndr->depth--;
    4669             :         }
    4670           0 :         ndr->depth--;
    4671             : }
    4672             : 
    4673           0 : static enum ndr_err_code ndr_push_clusapi_OfflineResource(struct ndr_push *ndr, int flags, const struct clusapi_OfflineResource *r)
    4674             : {
    4675           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4676           0 :         if (flags & NDR_IN) {
    4677           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4678             :         }
    4679           0 :         if (flags & NDR_OUT) {
    4680           0 :                 if (r->out.rpc_status == NULL) {
    4681           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4682             :                 }
    4683           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    4684           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4685             :         }
    4686           0 :         return NDR_ERR_SUCCESS;
    4687             : }
    4688             : 
    4689           0 : static enum ndr_err_code ndr_pull_clusapi_OfflineResource(struct ndr_pull *ndr, int flags, struct clusapi_OfflineResource *r)
    4690             : {
    4691           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    4692           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4693           0 :         if (flags & NDR_IN) {
    4694           0 :                 NDR_ZERO_STRUCT(r->out);
    4695             : 
    4696           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4697           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4698           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    4699             :         }
    4700           0 :         if (flags & NDR_OUT) {
    4701             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4702             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4703           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4704           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4705             :                 }
    4706           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4707           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    4708           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    4709           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    4710           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    4711             :         }
    4712           0 :         return NDR_ERR_SUCCESS;
    4713             : }
    4714             : 
    4715           0 : _PUBLIC_ void ndr_print_clusapi_OfflineResource(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_OfflineResource *r)
    4716             : {
    4717           0 :         ndr_print_struct(ndr, name, "clusapi_OfflineResource");
    4718           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    4719           0 :         ndr->depth++;
    4720           0 :         if (flags & NDR_SET_VALUES) {
    4721           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    4722             :         }
    4723           0 :         if (flags & NDR_IN) {
    4724           0 :                 ndr_print_struct(ndr, "in", "clusapi_OfflineResource");
    4725           0 :                 ndr->depth++;
    4726           0 :                 ndr_print_policy_handle(ndr, "hResource", &r->in.hResource);
    4727           0 :                 ndr->depth--;
    4728             :         }
    4729           0 :         if (flags & NDR_OUT) {
    4730           0 :                 ndr_print_struct(ndr, "out", "clusapi_OfflineResource");
    4731           0 :                 ndr->depth++;
    4732           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    4733           0 :                 ndr->depth++;
    4734           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    4735           0 :                 ndr->depth--;
    4736           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4737           0 :                 ndr->depth--;
    4738             :         }
    4739           0 :         ndr->depth--;
    4740             : }
    4741             : 
    4742           0 : static enum ndr_err_code ndr_push_clusapi_AddResourceDependency(struct ndr_push *ndr, int flags, const struct clusapi_AddResourceDependency *r)
    4743             : {
    4744           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4745           0 :         if (flags & NDR_IN) {
    4746           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4747           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hDependsOn));
    4748             :         }
    4749           0 :         if (flags & NDR_OUT) {
    4750           0 :                 if (r->out.rpc_status == NULL) {
    4751           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4752             :                 }
    4753           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    4754           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4755             :         }
    4756           0 :         return NDR_ERR_SUCCESS;
    4757             : }
    4758             : 
    4759           0 : static enum ndr_err_code ndr_pull_clusapi_AddResourceDependency(struct ndr_pull *ndr, int flags, struct clusapi_AddResourceDependency *r)
    4760             : {
    4761           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    4762           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4763           0 :         if (flags & NDR_IN) {
    4764           0 :                 NDR_ZERO_STRUCT(r->out);
    4765             : 
    4766           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4767           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hDependsOn));
    4768           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4769           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    4770             :         }
    4771           0 :         if (flags & NDR_OUT) {
    4772             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4773             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4774           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4775           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4776             :                 }
    4777           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4778           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    4779           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    4780           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    4781           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    4782             :         }
    4783           0 :         return NDR_ERR_SUCCESS;
    4784             : }
    4785             : 
    4786           0 : _PUBLIC_ void ndr_print_clusapi_AddResourceDependency(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_AddResourceDependency *r)
    4787             : {
    4788           0 :         ndr_print_struct(ndr, name, "clusapi_AddResourceDependency");
    4789           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    4790           0 :         ndr->depth++;
    4791           0 :         if (flags & NDR_SET_VALUES) {
    4792           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    4793             :         }
    4794           0 :         if (flags & NDR_IN) {
    4795           0 :                 ndr_print_struct(ndr, "in", "clusapi_AddResourceDependency");
    4796           0 :                 ndr->depth++;
    4797           0 :                 ndr_print_policy_handle(ndr, "hResource", &r->in.hResource);
    4798           0 :                 ndr_print_policy_handle(ndr, "hDependsOn", &r->in.hDependsOn);
    4799           0 :                 ndr->depth--;
    4800             :         }
    4801           0 :         if (flags & NDR_OUT) {
    4802           0 :                 ndr_print_struct(ndr, "out", "clusapi_AddResourceDependency");
    4803           0 :                 ndr->depth++;
    4804           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    4805           0 :                 ndr->depth++;
    4806           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    4807           0 :                 ndr->depth--;
    4808           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4809           0 :                 ndr->depth--;
    4810             :         }
    4811           0 :         ndr->depth--;
    4812             : }
    4813             : 
    4814           0 : static enum ndr_err_code ndr_push_clusapi_RemoveResourceDependency(struct ndr_push *ndr, int flags, const struct clusapi_RemoveResourceDependency *r)
    4815             : {
    4816           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4817           0 :         if (flags & NDR_IN) {
    4818           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4819           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hDependsOn));
    4820             :         }
    4821           0 :         if (flags & NDR_OUT) {
    4822           0 :                 if (r->out.rpc_status == NULL) {
    4823           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4824             :                 }
    4825           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    4826           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4827             :         }
    4828           0 :         return NDR_ERR_SUCCESS;
    4829             : }
    4830             : 
    4831           0 : static enum ndr_err_code ndr_pull_clusapi_RemoveResourceDependency(struct ndr_pull *ndr, int flags, struct clusapi_RemoveResourceDependency *r)
    4832             : {
    4833           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    4834           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4835           0 :         if (flags & NDR_IN) {
    4836           0 :                 NDR_ZERO_STRUCT(r->out);
    4837             : 
    4838           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4839           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hDependsOn));
    4840           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4841           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    4842             :         }
    4843           0 :         if (flags & NDR_OUT) {
    4844             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4845             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4846           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4847           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4848             :                 }
    4849           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4850           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    4851           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    4852           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    4853           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    4854             :         }
    4855           0 :         return NDR_ERR_SUCCESS;
    4856             : }
    4857             : 
    4858           0 : _PUBLIC_ void ndr_print_clusapi_RemoveResourceDependency(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_RemoveResourceDependency *r)
    4859             : {
    4860           0 :         ndr_print_struct(ndr, name, "clusapi_RemoveResourceDependency");
    4861           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    4862           0 :         ndr->depth++;
    4863           0 :         if (flags & NDR_SET_VALUES) {
    4864           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    4865             :         }
    4866           0 :         if (flags & NDR_IN) {
    4867           0 :                 ndr_print_struct(ndr, "in", "clusapi_RemoveResourceDependency");
    4868           0 :                 ndr->depth++;
    4869           0 :                 ndr_print_policy_handle(ndr, "hResource", &r->in.hResource);
    4870           0 :                 ndr_print_policy_handle(ndr, "hDependsOn", &r->in.hDependsOn);
    4871           0 :                 ndr->depth--;
    4872             :         }
    4873           0 :         if (flags & NDR_OUT) {
    4874           0 :                 ndr_print_struct(ndr, "out", "clusapi_RemoveResourceDependency");
    4875           0 :                 ndr->depth++;
    4876           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    4877           0 :                 ndr->depth++;
    4878           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    4879           0 :                 ndr->depth--;
    4880           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4881           0 :                 ndr->depth--;
    4882             :         }
    4883           0 :         ndr->depth--;
    4884             : }
    4885             : 
    4886           0 : static enum ndr_err_code ndr_push_clusapi_CanResourceBeDependent(struct ndr_push *ndr, int flags, const struct clusapi_CanResourceBeDependent *r)
    4887             : {
    4888           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4889           0 :         if (flags & NDR_IN) {
    4890           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4891           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hResourceDependent));
    4892             :         }
    4893           0 :         if (flags & NDR_OUT) {
    4894           0 :                 if (r->out.rpc_status == NULL) {
    4895           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4896             :                 }
    4897           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    4898           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4899             :         }
    4900           0 :         return NDR_ERR_SUCCESS;
    4901             : }
    4902             : 
    4903           0 : static enum ndr_err_code ndr_pull_clusapi_CanResourceBeDependent(struct ndr_pull *ndr, int flags, struct clusapi_CanResourceBeDependent *r)
    4904             : {
    4905           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    4906           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4907           0 :         if (flags & NDR_IN) {
    4908           0 :                 NDR_ZERO_STRUCT(r->out);
    4909             : 
    4910           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4911           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hResourceDependent));
    4912           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4913           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    4914             :         }
    4915           0 :         if (flags & NDR_OUT) {
    4916             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    4917             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    4918           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    4919           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4920             :                 }
    4921           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    4922           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    4923           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    4924           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    4925           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    4926             :         }
    4927           0 :         return NDR_ERR_SUCCESS;
    4928             : }
    4929             : 
    4930           0 : _PUBLIC_ void ndr_print_clusapi_CanResourceBeDependent(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_CanResourceBeDependent *r)
    4931             : {
    4932           0 :         ndr_print_struct(ndr, name, "clusapi_CanResourceBeDependent");
    4933           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    4934           0 :         ndr->depth++;
    4935           0 :         if (flags & NDR_SET_VALUES) {
    4936           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    4937             :         }
    4938           0 :         if (flags & NDR_IN) {
    4939           0 :                 ndr_print_struct(ndr, "in", "clusapi_CanResourceBeDependent");
    4940           0 :                 ndr->depth++;
    4941           0 :                 ndr_print_policy_handle(ndr, "hResource", &r->in.hResource);
    4942           0 :                 ndr_print_policy_handle(ndr, "hResourceDependent", &r->in.hResourceDependent);
    4943           0 :                 ndr->depth--;
    4944             :         }
    4945           0 :         if (flags & NDR_OUT) {
    4946           0 :                 ndr_print_struct(ndr, "out", "clusapi_CanResourceBeDependent");
    4947           0 :                 ndr->depth++;
    4948           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    4949           0 :                 ndr->depth++;
    4950           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    4951           0 :                 ndr->depth--;
    4952           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    4953           0 :                 ndr->depth--;
    4954             :         }
    4955           0 :         ndr->depth--;
    4956             : }
    4957             : 
    4958           0 : static enum ndr_err_code ndr_push_clusapi_CreateResEnum(struct ndr_push *ndr, int flags, const struct clusapi_CreateResEnum *r)
    4959             : {
    4960           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    4961           0 :         if (flags & NDR_IN) {
    4962           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4963           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.dwType));
    4964             :         }
    4965           0 :         if (flags & NDR_OUT) {
    4966           0 :                 if (r->out.ReturnEnum == NULL) {
    4967           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4968             :                 }
    4969           0 :                 if (r->out.rpc_status == NULL) {
    4970           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    4971             :                 }
    4972           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ReturnEnum));
    4973           0 :                 if (*r->out.ReturnEnum) {
    4974           0 :                         NDR_CHECK(ndr_push_ENUM_LIST(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.ReturnEnum));
    4975             :                 }
    4976           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    4977           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    4978             :         }
    4979           0 :         return NDR_ERR_SUCCESS;
    4980             : }
    4981             : 
    4982           0 : static enum ndr_err_code ndr_pull_clusapi_CreateResEnum(struct ndr_pull *ndr, int flags, struct clusapi_CreateResEnum *r)
    4983             : {
    4984             :         uint32_t _ptr_ReturnEnum;
    4985           0 :         TALLOC_CTX *_mem_save_ReturnEnum_0 = NULL;
    4986           0 :         TALLOC_CTX *_mem_save_ReturnEnum_1 = NULL;
    4987           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    4988           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    4989           0 :         if (flags & NDR_IN) {
    4990           0 :                 NDR_ZERO_STRUCT(r->out);
    4991             : 
    4992           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    4993           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.dwType));
    4994           0 :                 NDR_PULL_ALLOC(ndr, r->out.ReturnEnum);
    4995           0 :                 NDR_ZERO_STRUCTP(r->out.ReturnEnum);
    4996           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    4997           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    4998             :         }
    4999           0 :         if (flags & NDR_OUT) {
    5000             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    5001             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    5002           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5003           0 :                         NDR_PULL_ALLOC(ndr, r->out.ReturnEnum);
    5004             :                 }
    5005           0 :                 _mem_save_ReturnEnum_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5006           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ReturnEnum, LIBNDR_FLAG_REF_ALLOC);
    5007           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ReturnEnum));
    5008           0 :                 if (_ptr_ReturnEnum) {
    5009           0 :                         NDR_PULL_ALLOC(ndr, *r->out.ReturnEnum);
    5010             :                 } else {
    5011           0 :                         *r->out.ReturnEnum = NULL;
    5012             :                 }
    5013           0 :                 if (*r->out.ReturnEnum) {
    5014           0 :                         _mem_save_ReturnEnum_1 = NDR_PULL_GET_MEM_CTX(ndr);
    5015           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.ReturnEnum, 0);
    5016           0 :                         NDR_CHECK(ndr_pull_ENUM_LIST(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.ReturnEnum));
    5017           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ReturnEnum_1, 0);
    5018             :                 }
    5019           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ReturnEnum_0, LIBNDR_FLAG_REF_ALLOC);
    5020           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5021           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5022             :                 }
    5023           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5024           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    5025           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    5026           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    5027           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    5028             :         }
    5029           0 :         return NDR_ERR_SUCCESS;
    5030             : }
    5031             : 
    5032           0 : _PUBLIC_ void ndr_print_clusapi_CreateResEnum(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_CreateResEnum *r)
    5033             : {
    5034           0 :         ndr_print_struct(ndr, name, "clusapi_CreateResEnum");
    5035           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    5036           0 :         ndr->depth++;
    5037           0 :         if (flags & NDR_SET_VALUES) {
    5038           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    5039             :         }
    5040           0 :         if (flags & NDR_IN) {
    5041           0 :                 ndr_print_struct(ndr, "in", "clusapi_CreateResEnum");
    5042           0 :                 ndr->depth++;
    5043           0 :                 ndr_print_policy_handle(ndr, "hResource", &r->in.hResource);
    5044           0 :                 ndr_print_uint32(ndr, "dwType", r->in.dwType);
    5045           0 :                 ndr->depth--;
    5046             :         }
    5047           0 :         if (flags & NDR_OUT) {
    5048           0 :                 ndr_print_struct(ndr, "out", "clusapi_CreateResEnum");
    5049           0 :                 ndr->depth++;
    5050           0 :                 ndr_print_ptr(ndr, "ReturnEnum", r->out.ReturnEnum);
    5051           0 :                 ndr->depth++;
    5052           0 :                 ndr_print_ptr(ndr, "ReturnEnum", *r->out.ReturnEnum);
    5053           0 :                 ndr->depth++;
    5054           0 :                 if (*r->out.ReturnEnum) {
    5055           0 :                         ndr_print_ENUM_LIST(ndr, "ReturnEnum", *r->out.ReturnEnum);
    5056             :                 }
    5057           0 :                 ndr->depth--;
    5058           0 :                 ndr->depth--;
    5059           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    5060           0 :                 ndr->depth++;
    5061           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    5062           0 :                 ndr->depth--;
    5063           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    5064           0 :                 ndr->depth--;
    5065             :         }
    5066           0 :         ndr->depth--;
    5067             : }
    5068             : 
    5069           0 : static enum ndr_err_code ndr_push_clusapi_AddResourceNode(struct ndr_push *ndr, int flags, const struct clusapi_AddResourceNode *r)
    5070             : {
    5071           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    5072           0 :         if (flags & NDR_IN) {
    5073           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    5074           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hNode));
    5075             :         }
    5076           0 :         if (flags & NDR_OUT) {
    5077           0 :                 if (r->out.rpc_status == NULL) {
    5078           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5079             :                 }
    5080           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    5081           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    5082             :         }
    5083           0 :         return NDR_ERR_SUCCESS;
    5084             : }
    5085             : 
    5086           0 : static enum ndr_err_code ndr_pull_clusapi_AddResourceNode(struct ndr_pull *ndr, int flags, struct clusapi_AddResourceNode *r)
    5087             : {
    5088           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    5089           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    5090           0 :         if (flags & NDR_IN) {
    5091           0 :                 NDR_ZERO_STRUCT(r->out);
    5092             : 
    5093           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    5094           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hNode));
    5095           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5096           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    5097             :         }
    5098           0 :         if (flags & NDR_OUT) {
    5099             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    5100             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    5101           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5102           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5103             :                 }
    5104           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5105           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    5106           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    5107           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    5108           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    5109             :         }
    5110           0 :         return NDR_ERR_SUCCESS;
    5111             : }
    5112             : 
    5113           0 : _PUBLIC_ void ndr_print_clusapi_AddResourceNode(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_AddResourceNode *r)
    5114             : {
    5115           0 :         ndr_print_struct(ndr, name, "clusapi_AddResourceNode");
    5116           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    5117           0 :         ndr->depth++;
    5118           0 :         if (flags & NDR_SET_VALUES) {
    5119           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    5120             :         }
    5121           0 :         if (flags & NDR_IN) {
    5122           0 :                 ndr_print_struct(ndr, "in", "clusapi_AddResourceNode");
    5123           0 :                 ndr->depth++;
    5124           0 :                 ndr_print_policy_handle(ndr, "hResource", &r->in.hResource);
    5125           0 :                 ndr_print_policy_handle(ndr, "hNode", &r->in.hNode);
    5126           0 :                 ndr->depth--;
    5127             :         }
    5128           0 :         if (flags & NDR_OUT) {
    5129           0 :                 ndr_print_struct(ndr, "out", "clusapi_AddResourceNode");
    5130           0 :                 ndr->depth++;
    5131           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    5132           0 :                 ndr->depth++;
    5133           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    5134           0 :                 ndr->depth--;
    5135           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    5136           0 :                 ndr->depth--;
    5137             :         }
    5138           0 :         ndr->depth--;
    5139             : }
    5140             : 
    5141           0 : static enum ndr_err_code ndr_push_clusapi_RemoveResourceNode(struct ndr_push *ndr, int flags, const struct clusapi_RemoveResourceNode *r)
    5142             : {
    5143           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    5144           0 :         if (flags & NDR_IN) {
    5145           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    5146           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hNode));
    5147             :         }
    5148           0 :         if (flags & NDR_OUT) {
    5149           0 :                 if (r->out.rpc_status == NULL) {
    5150           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5151             :                 }
    5152           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    5153           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    5154             :         }
    5155           0 :         return NDR_ERR_SUCCESS;
    5156             : }
    5157             : 
    5158           0 : static enum ndr_err_code ndr_pull_clusapi_RemoveResourceNode(struct ndr_pull *ndr, int flags, struct clusapi_RemoveResourceNode *r)
    5159             : {
    5160           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    5161           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    5162           0 :         if (flags & NDR_IN) {
    5163           0 :                 NDR_ZERO_STRUCT(r->out);
    5164             : 
    5165           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    5166           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hNode));
    5167           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5168           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    5169             :         }
    5170           0 :         if (flags & NDR_OUT) {
    5171             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    5172             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    5173           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5174           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5175             :                 }
    5176           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5177           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    5178           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    5179           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    5180           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    5181             :         }
    5182           0 :         return NDR_ERR_SUCCESS;
    5183             : }
    5184             : 
    5185           0 : _PUBLIC_ void ndr_print_clusapi_RemoveResourceNode(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_RemoveResourceNode *r)
    5186             : {
    5187           0 :         ndr_print_struct(ndr, name, "clusapi_RemoveResourceNode");
    5188           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    5189           0 :         ndr->depth++;
    5190           0 :         if (flags & NDR_SET_VALUES) {
    5191           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    5192             :         }
    5193           0 :         if (flags & NDR_IN) {
    5194           0 :                 ndr_print_struct(ndr, "in", "clusapi_RemoveResourceNode");
    5195           0 :                 ndr->depth++;
    5196           0 :                 ndr_print_policy_handle(ndr, "hResource", &r->in.hResource);
    5197           0 :                 ndr_print_policy_handle(ndr, "hNode", &r->in.hNode);
    5198           0 :                 ndr->depth--;
    5199             :         }
    5200           0 :         if (flags & NDR_OUT) {
    5201           0 :                 ndr_print_struct(ndr, "out", "clusapi_RemoveResourceNode");
    5202           0 :                 ndr->depth++;
    5203           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    5204           0 :                 ndr->depth++;
    5205           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    5206           0 :                 ndr->depth--;
    5207           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    5208           0 :                 ndr->depth--;
    5209             :         }
    5210           0 :         ndr->depth--;
    5211             : }
    5212             : 
    5213           0 : static enum ndr_err_code ndr_push_clusapi_ChangeResourceGroup(struct ndr_push *ndr, int flags, const struct clusapi_ChangeResourceGroup *r)
    5214             : {
    5215           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    5216           0 :         if (flags & NDR_IN) {
    5217           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    5218           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hGroup));
    5219             :         }
    5220           0 :         if (flags & NDR_OUT) {
    5221           0 :                 if (r->out.rpc_status == NULL) {
    5222           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5223             :                 }
    5224           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    5225           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    5226             :         }
    5227           0 :         return NDR_ERR_SUCCESS;
    5228             : }
    5229             : 
    5230           0 : static enum ndr_err_code ndr_pull_clusapi_ChangeResourceGroup(struct ndr_pull *ndr, int flags, struct clusapi_ChangeResourceGroup *r)
    5231             : {
    5232           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    5233           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    5234           0 :         if (flags & NDR_IN) {
    5235           0 :                 NDR_ZERO_STRUCT(r->out);
    5236             : 
    5237           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hResource));
    5238           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hGroup));
    5239           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5240           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    5241             :         }
    5242           0 :         if (flags & NDR_OUT) {
    5243             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    5244             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    5245           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5246           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5247             :                 }
    5248           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5249           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    5250           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    5251           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    5252           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    5253             :         }
    5254           0 :         return NDR_ERR_SUCCESS;
    5255             : }
    5256             : 
    5257           0 : _PUBLIC_ void ndr_print_clusapi_ChangeResourceGroup(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_ChangeResourceGroup *r)
    5258             : {
    5259           0 :         ndr_print_struct(ndr, name, "clusapi_ChangeResourceGroup");
    5260           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    5261           0 :         ndr->depth++;
    5262           0 :         if (flags & NDR_SET_VALUES) {
    5263           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    5264             :         }
    5265           0 :         if (flags & NDR_IN) {
    5266           0 :                 ndr_print_struct(ndr, "in", "clusapi_ChangeResourceGroup");
    5267           0 :                 ndr->depth++;
    5268           0 :                 ndr_print_policy_handle(ndr, "hResource", &r->in.hResource);
    5269           0 :                 ndr_print_policy_handle(ndr, "hGroup", &r->in.hGroup);
    5270           0 :                 ndr->depth--;
    5271             :         }
    5272           0 :         if (flags & NDR_OUT) {
    5273           0 :                 ndr_print_struct(ndr, "out", "clusapi_ChangeResourceGroup");
    5274           0 :                 ndr->depth++;
    5275           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    5276           0 :                 ndr->depth++;
    5277           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    5278           0 :                 ndr->depth--;
    5279           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    5280           0 :                 ndr->depth--;
    5281             :         }
    5282           0 :         ndr->depth--;
    5283             : }
    5284             : 
    5285           0 : static enum ndr_err_code ndr_push_clusapi_CreateResourceType(struct ndr_push *ndr, int flags, const struct clusapi_CreateResourceType *r)
    5286             : {
    5287           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    5288           0 :         if (flags & NDR_IN) {
    5289           0 :                 if (r->in.lpszTypeName == NULL) {
    5290           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5291             :                 }
    5292           0 :                 if (r->in.lpszDisplayName == NULL) {
    5293           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5294             :                 }
    5295           0 :                 if (r->in.lpszDllName == NULL) {
    5296           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5297             :                 }
    5298           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszTypeName, CH_UTF16)));
    5299           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    5300           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszTypeName, CH_UTF16)));
    5301           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpszTypeName, ndr_charset_length(r->in.lpszTypeName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    5302           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszDisplayName, CH_UTF16)));
    5303           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    5304           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszDisplayName, CH_UTF16)));
    5305           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpszDisplayName, ndr_charset_length(r->in.lpszDisplayName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    5306           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszDllName, CH_UTF16)));
    5307           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    5308           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszDllName, CH_UTF16)));
    5309           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpszDllName, ndr_charset_length(r->in.lpszDllName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    5310           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.dwLooksAlive));
    5311           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.dwIsAlive));
    5312             :         }
    5313           0 :         if (flags & NDR_OUT) {
    5314           0 :                 if (r->out.rpc_status == NULL) {
    5315           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5316             :                 }
    5317           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    5318           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    5319             :         }
    5320           0 :         return NDR_ERR_SUCCESS;
    5321             : }
    5322             : 
    5323           0 : static enum ndr_err_code ndr_pull_clusapi_CreateResourceType(struct ndr_pull *ndr, int flags, struct clusapi_CreateResourceType *r)
    5324             : {
    5325           0 :         uint32_t size_lpszTypeName_1 = 0;
    5326           0 :         uint32_t length_lpszTypeName_1 = 0;
    5327           0 :         uint32_t size_lpszDisplayName_1 = 0;
    5328           0 :         uint32_t length_lpszDisplayName_1 = 0;
    5329           0 :         uint32_t size_lpszDllName_1 = 0;
    5330           0 :         uint32_t length_lpszDllName_1 = 0;
    5331           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    5332           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    5333           0 :         if (flags & NDR_IN) {
    5334           0 :                 NDR_ZERO_STRUCT(r->out);
    5335             : 
    5336           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpszTypeName));
    5337           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpszTypeName));
    5338           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpszTypeName, &size_lpszTypeName_1));
    5339           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpszTypeName, &length_lpszTypeName_1));
    5340           0 :                 if (length_lpszTypeName_1 > size_lpszTypeName_1) {
    5341           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpszTypeName_1, length_lpszTypeName_1);
    5342             :                 }
    5343           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpszTypeName_1, sizeof(uint16_t)));
    5344           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpszTypeName, length_lpszTypeName_1, sizeof(uint16_t), CH_UTF16));
    5345           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpszDisplayName));
    5346           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpszDisplayName));
    5347           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpszDisplayName, &size_lpszDisplayName_1));
    5348           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpszDisplayName, &length_lpszDisplayName_1));
    5349           0 :                 if (length_lpszDisplayName_1 > size_lpszDisplayName_1) {
    5350           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpszDisplayName_1, length_lpszDisplayName_1);
    5351             :                 }
    5352           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpszDisplayName_1, sizeof(uint16_t)));
    5353           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpszDisplayName, length_lpszDisplayName_1, sizeof(uint16_t), CH_UTF16));
    5354           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpszDllName));
    5355           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpszDllName));
    5356           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpszDllName, &size_lpszDllName_1));
    5357           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpszDllName, &length_lpszDllName_1));
    5358           0 :                 if (length_lpszDllName_1 > size_lpszDllName_1) {
    5359           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpszDllName_1, length_lpszDllName_1);
    5360             :                 }
    5361           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpszDllName_1, sizeof(uint16_t)));
    5362           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpszDllName, length_lpszDllName_1, sizeof(uint16_t), CH_UTF16));
    5363           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.dwLooksAlive));
    5364           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.dwIsAlive));
    5365           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5366           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    5367             :         }
    5368           0 :         if (flags & NDR_OUT) {
    5369             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    5370             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    5371           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5372           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5373             :                 }
    5374           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5375           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    5376           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    5377           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    5378           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    5379             :         }
    5380           0 :         return NDR_ERR_SUCCESS;
    5381             : }
    5382             : 
    5383           0 : _PUBLIC_ void ndr_print_clusapi_CreateResourceType(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_CreateResourceType *r)
    5384             : {
    5385           0 :         ndr_print_struct(ndr, name, "clusapi_CreateResourceType");
    5386           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    5387           0 :         ndr->depth++;
    5388           0 :         if (flags & NDR_SET_VALUES) {
    5389           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    5390             :         }
    5391           0 :         if (flags & NDR_IN) {
    5392           0 :                 ndr_print_struct(ndr, "in", "clusapi_CreateResourceType");
    5393           0 :                 ndr->depth++;
    5394           0 :                 ndr_print_ptr(ndr, "lpszTypeName", r->in.lpszTypeName);
    5395           0 :                 ndr->depth++;
    5396           0 :                 ndr_print_string(ndr, "lpszTypeName", r->in.lpszTypeName);
    5397           0 :                 ndr->depth--;
    5398           0 :                 ndr_print_ptr(ndr, "lpszDisplayName", r->in.lpszDisplayName);
    5399           0 :                 ndr->depth++;
    5400           0 :                 ndr_print_string(ndr, "lpszDisplayName", r->in.lpszDisplayName);
    5401           0 :                 ndr->depth--;
    5402           0 :                 ndr_print_ptr(ndr, "lpszDllName", r->in.lpszDllName);
    5403           0 :                 ndr->depth++;
    5404           0 :                 ndr_print_string(ndr, "lpszDllName", r->in.lpszDllName);
    5405           0 :                 ndr->depth--;
    5406           0 :                 ndr_print_uint32(ndr, "dwLooksAlive", r->in.dwLooksAlive);
    5407           0 :                 ndr_print_uint32(ndr, "dwIsAlive", r->in.dwIsAlive);
    5408           0 :                 ndr->depth--;
    5409             :         }
    5410           0 :         if (flags & NDR_OUT) {
    5411           0 :                 ndr_print_struct(ndr, "out", "clusapi_CreateResourceType");
    5412           0 :                 ndr->depth++;
    5413           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    5414           0 :                 ndr->depth++;
    5415           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    5416           0 :                 ndr->depth--;
    5417           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    5418           0 :                 ndr->depth--;
    5419             :         }
    5420           0 :         ndr->depth--;
    5421             : }
    5422             : 
    5423           0 : static enum ndr_err_code ndr_push_clusapi_DeleteResourceType(struct ndr_push *ndr, int flags, const struct clusapi_DeleteResourceType *r)
    5424             : {
    5425           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    5426           0 :         if (flags & NDR_IN) {
    5427           0 :                 if (r->in.lpszTypeName == NULL) {
    5428           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5429             :                 }
    5430           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszTypeName, CH_UTF16)));
    5431           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    5432           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszTypeName, CH_UTF16)));
    5433           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpszTypeName, ndr_charset_length(r->in.lpszTypeName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    5434             :         }
    5435           0 :         if (flags & NDR_OUT) {
    5436           0 :                 if (r->out.rpc_status == NULL) {
    5437           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5438             :                 }
    5439           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    5440           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    5441             :         }
    5442           0 :         return NDR_ERR_SUCCESS;
    5443             : }
    5444             : 
    5445           0 : static enum ndr_err_code ndr_pull_clusapi_DeleteResourceType(struct ndr_pull *ndr, int flags, struct clusapi_DeleteResourceType *r)
    5446             : {
    5447           0 :         uint32_t size_lpszTypeName_1 = 0;
    5448           0 :         uint32_t length_lpszTypeName_1 = 0;
    5449           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    5450           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    5451           0 :         if (flags & NDR_IN) {
    5452           0 :                 NDR_ZERO_STRUCT(r->out);
    5453             : 
    5454           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpszTypeName));
    5455           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpszTypeName));
    5456           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpszTypeName, &size_lpszTypeName_1));
    5457           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpszTypeName, &length_lpszTypeName_1));
    5458           0 :                 if (length_lpszTypeName_1 > size_lpszTypeName_1) {
    5459           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpszTypeName_1, length_lpszTypeName_1);
    5460             :                 }
    5461           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpszTypeName_1, sizeof(uint16_t)));
    5462           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpszTypeName, length_lpszTypeName_1, sizeof(uint16_t), CH_UTF16));
    5463           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5464           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    5465             :         }
    5466           0 :         if (flags & NDR_OUT) {
    5467             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    5468             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    5469           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5470           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5471             :                 }
    5472           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5473           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    5474           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    5475           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    5476           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    5477             :         }
    5478           0 :         return NDR_ERR_SUCCESS;
    5479             : }
    5480             : 
    5481           0 : _PUBLIC_ void ndr_print_clusapi_DeleteResourceType(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_DeleteResourceType *r)
    5482             : {
    5483           0 :         ndr_print_struct(ndr, name, "clusapi_DeleteResourceType");
    5484           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    5485           0 :         ndr->depth++;
    5486           0 :         if (flags & NDR_SET_VALUES) {
    5487           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    5488             :         }
    5489           0 :         if (flags & NDR_IN) {
    5490           0 :                 ndr_print_struct(ndr, "in", "clusapi_DeleteResourceType");
    5491           0 :                 ndr->depth++;
    5492           0 :                 ndr_print_ptr(ndr, "lpszTypeName", r->in.lpszTypeName);
    5493           0 :                 ndr->depth++;
    5494           0 :                 ndr_print_string(ndr, "lpszTypeName", r->in.lpszTypeName);
    5495           0 :                 ndr->depth--;
    5496           0 :                 ndr->depth--;
    5497             :         }
    5498           0 :         if (flags & NDR_OUT) {
    5499           0 :                 ndr_print_struct(ndr, "out", "clusapi_DeleteResourceType");
    5500           0 :                 ndr->depth++;
    5501           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    5502           0 :                 ndr->depth++;
    5503           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    5504           0 :                 ndr->depth--;
    5505           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    5506           0 :                 ndr->depth--;
    5507             :         }
    5508           0 :         ndr->depth--;
    5509             : }
    5510             : 
    5511           0 : static enum ndr_err_code ndr_push_clusapi_GetRootKey(struct ndr_push *ndr, int flags, const struct clusapi_GetRootKey *r)
    5512             : {
    5513           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    5514           0 :         if (flags & NDR_IN) {
    5515           0 :                 NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.samDesired));
    5516             :         }
    5517           0 :         if (flags & NDR_OUT) {
    5518           0 :                 if (r->out.Status == NULL) {
    5519           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5520             :                 }
    5521           0 :                 if (r->out.rpc_status == NULL) {
    5522           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5523             :                 }
    5524           0 :                 if (r->out.phKey == NULL) {
    5525           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5526             :                 }
    5527           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.Status));
    5528           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    5529           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.phKey));
    5530             :         }
    5531           0 :         return NDR_ERR_SUCCESS;
    5532             : }
    5533             : 
    5534           0 : static enum ndr_err_code ndr_pull_clusapi_GetRootKey(struct ndr_pull *ndr, int flags, struct clusapi_GetRootKey *r)
    5535             : {
    5536           0 :         TALLOC_CTX *_mem_save_Status_0 = NULL;
    5537           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    5538           0 :         TALLOC_CTX *_mem_save_phKey_0 = NULL;
    5539           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    5540           0 :         if (flags & NDR_IN) {
    5541           0 :                 NDR_ZERO_STRUCT(r->out);
    5542             : 
    5543           0 :                 NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.samDesired));
    5544           0 :                 NDR_PULL_ALLOC(ndr, r->out.Status);
    5545           0 :                 NDR_ZERO_STRUCTP(r->out.Status);
    5546           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5547           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    5548           0 :                 NDR_PULL_ALLOC(ndr, r->out.phKey);
    5549           0 :                 NDR_ZERO_STRUCTP(r->out.phKey);
    5550             :         }
    5551           0 :         if (flags & NDR_OUT) {
    5552             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    5553             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    5554           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5555           0 :                         NDR_PULL_ALLOC(ndr, r->out.Status);
    5556             :                 }
    5557           0 :                 _mem_save_Status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5558           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.Status, LIBNDR_FLAG_REF_ALLOC);
    5559           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.Status));
    5560           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Status_0, LIBNDR_FLAG_REF_ALLOC);
    5561           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5562           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5563             :                 }
    5564           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5565           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    5566           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    5567           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    5568           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5569           0 :                         NDR_PULL_ALLOC(ndr, r->out.phKey);
    5570             :                 }
    5571           0 :                 _mem_save_phKey_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5572           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.phKey, LIBNDR_FLAG_REF_ALLOC);
    5573           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.phKey));
    5574           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_phKey_0, LIBNDR_FLAG_REF_ALLOC);
    5575             :         }
    5576           0 :         return NDR_ERR_SUCCESS;
    5577             : }
    5578             : 
    5579           0 : _PUBLIC_ void ndr_print_clusapi_GetRootKey(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_GetRootKey *r)
    5580             : {
    5581           0 :         ndr_print_struct(ndr, name, "clusapi_GetRootKey");
    5582           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    5583           0 :         ndr->depth++;
    5584           0 :         if (flags & NDR_SET_VALUES) {
    5585           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    5586             :         }
    5587           0 :         if (flags & NDR_IN) {
    5588           0 :                 ndr_print_struct(ndr, "in", "clusapi_GetRootKey");
    5589           0 :                 ndr->depth++;
    5590           0 :                 ndr_print_winreg_AccessMask(ndr, "samDesired", r->in.samDesired);
    5591           0 :                 ndr->depth--;
    5592             :         }
    5593           0 :         if (flags & NDR_OUT) {
    5594           0 :                 ndr_print_struct(ndr, "out", "clusapi_GetRootKey");
    5595           0 :                 ndr->depth++;
    5596           0 :                 ndr_print_ptr(ndr, "Status", r->out.Status);
    5597           0 :                 ndr->depth++;
    5598           0 :                 ndr_print_WERROR(ndr, "Status", *r->out.Status);
    5599           0 :                 ndr->depth--;
    5600           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    5601           0 :                 ndr->depth++;
    5602           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    5603           0 :                 ndr->depth--;
    5604           0 :                 ndr_print_ptr(ndr, "phKey", r->out.phKey);
    5605           0 :                 ndr->depth++;
    5606           0 :                 ndr_print_policy_handle(ndr, "phKey", r->out.phKey);
    5607           0 :                 ndr->depth--;
    5608           0 :                 ndr->depth--;
    5609             :         }
    5610           0 :         ndr->depth--;
    5611             : }
    5612             : 
    5613           0 : static enum ndr_err_code ndr_push_clusapi_CreateKey(struct ndr_push *ndr, int flags, const struct clusapi_CreateKey *r)
    5614             : {
    5615           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    5616           0 :         if (flags & NDR_IN) {
    5617           0 :                 if (r->in.lpSubKey == NULL) {
    5618           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5619             :                 }
    5620           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    5621           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpSubKey, CH_UTF16)));
    5622           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    5623           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpSubKey, CH_UTF16)));
    5624           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpSubKey, ndr_charset_length(r->in.lpSubKey, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    5625           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.dwOptions));
    5626           0 :                 NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.samDesired));
    5627           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lpSecurityAttributes));
    5628           0 :                 if (r->in.lpSecurityAttributes) {
    5629           0 :                         NDR_CHECK(ndr_push_RPC_SECURITY_ATTRIBUTES(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.lpSecurityAttributes));
    5630             :                 }
    5631             :         }
    5632           0 :         if (flags & NDR_OUT) {
    5633           0 :                 if (r->out.lpdwDisposition == NULL) {
    5634           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5635             :                 }
    5636           0 :                 if (r->out.Status == NULL) {
    5637           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5638             :                 }
    5639           0 :                 if (r->out.rpc_status == NULL) {
    5640           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5641             :                 }
    5642           0 :                 if (r->out.phKey == NULL) {
    5643           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5644             :                 }
    5645           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.lpdwDisposition));
    5646           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.Status));
    5647           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    5648           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.phKey));
    5649             :         }
    5650           0 :         return NDR_ERR_SUCCESS;
    5651             : }
    5652             : 
    5653           0 : static enum ndr_err_code ndr_pull_clusapi_CreateKey(struct ndr_pull *ndr, int flags, struct clusapi_CreateKey *r)
    5654             : {
    5655           0 :         uint32_t size_lpSubKey_1 = 0;
    5656           0 :         uint32_t length_lpSubKey_1 = 0;
    5657             :         uint32_t _ptr_lpSecurityAttributes;
    5658           0 :         TALLOC_CTX *_mem_save_lpSecurityAttributes_0 = NULL;
    5659           0 :         TALLOC_CTX *_mem_save_lpdwDisposition_0 = NULL;
    5660           0 :         TALLOC_CTX *_mem_save_Status_0 = NULL;
    5661           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    5662           0 :         TALLOC_CTX *_mem_save_phKey_0 = NULL;
    5663           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    5664           0 :         if (flags & NDR_IN) {
    5665           0 :                 NDR_ZERO_STRUCT(r->out);
    5666             : 
    5667           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    5668           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpSubKey));
    5669           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpSubKey));
    5670           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpSubKey, &size_lpSubKey_1));
    5671           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpSubKey, &length_lpSubKey_1));
    5672           0 :                 if (length_lpSubKey_1 > size_lpSubKey_1) {
    5673           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpSubKey_1, length_lpSubKey_1);
    5674             :                 }
    5675           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpSubKey_1, sizeof(uint16_t)));
    5676           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpSubKey, length_lpSubKey_1, sizeof(uint16_t), CH_UTF16));
    5677           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.dwOptions));
    5678           0 :                 NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.samDesired));
    5679           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpSecurityAttributes));
    5680           0 :                 if (_ptr_lpSecurityAttributes) {
    5681           0 :                         NDR_PULL_ALLOC(ndr, r->in.lpSecurityAttributes);
    5682             :                 } else {
    5683           0 :                         r->in.lpSecurityAttributes = NULL;
    5684             :                 }
    5685           0 :                 if (r->in.lpSecurityAttributes) {
    5686           0 :                         _mem_save_lpSecurityAttributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5687           0 :                         NDR_PULL_SET_MEM_CTX(ndr, r->in.lpSecurityAttributes, 0);
    5688           0 :                         NDR_CHECK(ndr_pull_RPC_SECURITY_ATTRIBUTES(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.lpSecurityAttributes));
    5689           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpSecurityAttributes_0, 0);
    5690             :                 }
    5691           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpdwDisposition);
    5692           0 :                 NDR_ZERO_STRUCTP(r->out.lpdwDisposition);
    5693           0 :                 NDR_PULL_ALLOC(ndr, r->out.Status);
    5694           0 :                 NDR_ZERO_STRUCTP(r->out.Status);
    5695           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5696           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    5697           0 :                 NDR_PULL_ALLOC(ndr, r->out.phKey);
    5698           0 :                 NDR_ZERO_STRUCTP(r->out.phKey);
    5699             :         }
    5700           0 :         if (flags & NDR_OUT) {
    5701             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    5702             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    5703           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5704           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpdwDisposition);
    5705             :                 }
    5706           0 :                 _mem_save_lpdwDisposition_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5707           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpdwDisposition, LIBNDR_FLAG_REF_ALLOC);
    5708           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.lpdwDisposition));
    5709           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpdwDisposition_0, LIBNDR_FLAG_REF_ALLOC);
    5710           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5711           0 :                         NDR_PULL_ALLOC(ndr, r->out.Status);
    5712             :                 }
    5713           0 :                 _mem_save_Status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5714           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.Status, LIBNDR_FLAG_REF_ALLOC);
    5715           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.Status));
    5716           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Status_0, LIBNDR_FLAG_REF_ALLOC);
    5717           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5718           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5719             :                 }
    5720           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5721           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    5722           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    5723           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    5724           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5725           0 :                         NDR_PULL_ALLOC(ndr, r->out.phKey);
    5726             :                 }
    5727           0 :                 _mem_save_phKey_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5728           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.phKey, LIBNDR_FLAG_REF_ALLOC);
    5729           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.phKey));
    5730           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_phKey_0, LIBNDR_FLAG_REF_ALLOC);
    5731             :         }
    5732           0 :         return NDR_ERR_SUCCESS;
    5733             : }
    5734             : 
    5735           0 : _PUBLIC_ void ndr_print_clusapi_CreateKey(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_CreateKey *r)
    5736             : {
    5737           0 :         ndr_print_struct(ndr, name, "clusapi_CreateKey");
    5738           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    5739           0 :         ndr->depth++;
    5740           0 :         if (flags & NDR_SET_VALUES) {
    5741           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    5742             :         }
    5743           0 :         if (flags & NDR_IN) {
    5744           0 :                 ndr_print_struct(ndr, "in", "clusapi_CreateKey");
    5745           0 :                 ndr->depth++;
    5746           0 :                 ndr_print_policy_handle(ndr, "hKey", &r->in.hKey);
    5747           0 :                 ndr_print_ptr(ndr, "lpSubKey", r->in.lpSubKey);
    5748           0 :                 ndr->depth++;
    5749           0 :                 ndr_print_string(ndr, "lpSubKey", r->in.lpSubKey);
    5750           0 :                 ndr->depth--;
    5751           0 :                 ndr_print_uint32(ndr, "dwOptions", r->in.dwOptions);
    5752           0 :                 ndr_print_winreg_AccessMask(ndr, "samDesired", r->in.samDesired);
    5753           0 :                 ndr_print_ptr(ndr, "lpSecurityAttributes", r->in.lpSecurityAttributes);
    5754           0 :                 ndr->depth++;
    5755           0 :                 if (r->in.lpSecurityAttributes) {
    5756           0 :                         ndr_print_RPC_SECURITY_ATTRIBUTES(ndr, "lpSecurityAttributes", r->in.lpSecurityAttributes);
    5757             :                 }
    5758           0 :                 ndr->depth--;
    5759           0 :                 ndr->depth--;
    5760             :         }
    5761           0 :         if (flags & NDR_OUT) {
    5762           0 :                 ndr_print_struct(ndr, "out", "clusapi_CreateKey");
    5763           0 :                 ndr->depth++;
    5764           0 :                 ndr_print_ptr(ndr, "lpdwDisposition", r->out.lpdwDisposition);
    5765           0 :                 ndr->depth++;
    5766           0 :                 ndr_print_uint32(ndr, "lpdwDisposition", *r->out.lpdwDisposition);
    5767           0 :                 ndr->depth--;
    5768           0 :                 ndr_print_ptr(ndr, "Status", r->out.Status);
    5769           0 :                 ndr->depth++;
    5770           0 :                 ndr_print_WERROR(ndr, "Status", *r->out.Status);
    5771           0 :                 ndr->depth--;
    5772           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    5773           0 :                 ndr->depth++;
    5774           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    5775           0 :                 ndr->depth--;
    5776           0 :                 ndr_print_ptr(ndr, "phKey", r->out.phKey);
    5777           0 :                 ndr->depth++;
    5778           0 :                 ndr_print_policy_handle(ndr, "phKey", r->out.phKey);
    5779           0 :                 ndr->depth--;
    5780           0 :                 ndr->depth--;
    5781             :         }
    5782           0 :         ndr->depth--;
    5783             : }
    5784             : 
    5785           0 : static enum ndr_err_code ndr_push_clusapi_OpenKey(struct ndr_push *ndr, int flags, const struct clusapi_OpenKey *r)
    5786             : {
    5787           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    5788           0 :         if (flags & NDR_IN) {
    5789           0 :                 if (r->in.lpSubKey == NULL) {
    5790           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5791             :                 }
    5792           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    5793           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpSubKey, CH_UTF16)));
    5794           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    5795           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpSubKey, CH_UTF16)));
    5796           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpSubKey, ndr_charset_length(r->in.lpSubKey, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    5797           0 :                 NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.samDesired));
    5798             :         }
    5799           0 :         if (flags & NDR_OUT) {
    5800           0 :                 if (r->out.Status == NULL) {
    5801           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5802             :                 }
    5803           0 :                 if (r->out.rpc_status == NULL) {
    5804           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5805             :                 }
    5806           0 :                 if (r->out.phKey == NULL) {
    5807           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5808             :                 }
    5809           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.Status));
    5810           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    5811           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.phKey));
    5812             :         }
    5813           0 :         return NDR_ERR_SUCCESS;
    5814             : }
    5815             : 
    5816           0 : static enum ndr_err_code ndr_pull_clusapi_OpenKey(struct ndr_pull *ndr, int flags, struct clusapi_OpenKey *r)
    5817             : {
    5818           0 :         uint32_t size_lpSubKey_1 = 0;
    5819           0 :         uint32_t length_lpSubKey_1 = 0;
    5820           0 :         TALLOC_CTX *_mem_save_Status_0 = NULL;
    5821           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    5822           0 :         TALLOC_CTX *_mem_save_phKey_0 = NULL;
    5823           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    5824           0 :         if (flags & NDR_IN) {
    5825           0 :                 NDR_ZERO_STRUCT(r->out);
    5826             : 
    5827           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    5828           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpSubKey));
    5829           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpSubKey));
    5830           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpSubKey, &size_lpSubKey_1));
    5831           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpSubKey, &length_lpSubKey_1));
    5832           0 :                 if (length_lpSubKey_1 > size_lpSubKey_1) {
    5833           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpSubKey_1, length_lpSubKey_1);
    5834             :                 }
    5835           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpSubKey_1, sizeof(uint16_t)));
    5836           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpSubKey, length_lpSubKey_1, sizeof(uint16_t), CH_UTF16));
    5837           0 :                 NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.samDesired));
    5838           0 :                 NDR_PULL_ALLOC(ndr, r->out.Status);
    5839           0 :                 NDR_ZERO_STRUCTP(r->out.Status);
    5840           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5841           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    5842           0 :                 NDR_PULL_ALLOC(ndr, r->out.phKey);
    5843           0 :                 NDR_ZERO_STRUCTP(r->out.phKey);
    5844             :         }
    5845           0 :         if (flags & NDR_OUT) {
    5846             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    5847             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    5848           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5849           0 :                         NDR_PULL_ALLOC(ndr, r->out.Status);
    5850             :                 }
    5851           0 :                 _mem_save_Status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5852           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.Status, LIBNDR_FLAG_REF_ALLOC);
    5853           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.Status));
    5854           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Status_0, LIBNDR_FLAG_REF_ALLOC);
    5855           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5856           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5857             :                 }
    5858           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5859           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    5860           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    5861           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    5862           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5863           0 :                         NDR_PULL_ALLOC(ndr, r->out.phKey);
    5864             :                 }
    5865           0 :                 _mem_save_phKey_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5866           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.phKey, LIBNDR_FLAG_REF_ALLOC);
    5867           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.phKey));
    5868           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_phKey_0, LIBNDR_FLAG_REF_ALLOC);
    5869             :         }
    5870           0 :         return NDR_ERR_SUCCESS;
    5871             : }
    5872             : 
    5873           0 : _PUBLIC_ void ndr_print_clusapi_OpenKey(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_OpenKey *r)
    5874             : {
    5875           0 :         ndr_print_struct(ndr, name, "clusapi_OpenKey");
    5876           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    5877           0 :         ndr->depth++;
    5878           0 :         if (flags & NDR_SET_VALUES) {
    5879           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    5880             :         }
    5881           0 :         if (flags & NDR_IN) {
    5882           0 :                 ndr_print_struct(ndr, "in", "clusapi_OpenKey");
    5883           0 :                 ndr->depth++;
    5884           0 :                 ndr_print_policy_handle(ndr, "hKey", &r->in.hKey);
    5885           0 :                 ndr_print_ptr(ndr, "lpSubKey", r->in.lpSubKey);
    5886           0 :                 ndr->depth++;
    5887           0 :                 ndr_print_string(ndr, "lpSubKey", r->in.lpSubKey);
    5888           0 :                 ndr->depth--;
    5889           0 :                 ndr_print_winreg_AccessMask(ndr, "samDesired", r->in.samDesired);
    5890           0 :                 ndr->depth--;
    5891             :         }
    5892           0 :         if (flags & NDR_OUT) {
    5893           0 :                 ndr_print_struct(ndr, "out", "clusapi_OpenKey");
    5894           0 :                 ndr->depth++;
    5895           0 :                 ndr_print_ptr(ndr, "Status", r->out.Status);
    5896           0 :                 ndr->depth++;
    5897           0 :                 ndr_print_WERROR(ndr, "Status", *r->out.Status);
    5898           0 :                 ndr->depth--;
    5899           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    5900           0 :                 ndr->depth++;
    5901           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    5902           0 :                 ndr->depth--;
    5903           0 :                 ndr_print_ptr(ndr, "phKey", r->out.phKey);
    5904           0 :                 ndr->depth++;
    5905           0 :                 ndr_print_policy_handle(ndr, "phKey", r->out.phKey);
    5906           0 :                 ndr->depth--;
    5907           0 :                 ndr->depth--;
    5908             :         }
    5909           0 :         ndr->depth--;
    5910             : }
    5911             : 
    5912           0 : static enum ndr_err_code ndr_push_clusapi_EnumKey(struct ndr_push *ndr, int flags, const struct clusapi_EnumKey *r)
    5913             : {
    5914           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    5915           0 :         if (flags & NDR_IN) {
    5916           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    5917           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.dwIndex));
    5918             :         }
    5919           0 :         if (flags & NDR_OUT) {
    5920           0 :                 if (r->out.KeyName == NULL) {
    5921           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5922             :                 }
    5923           0 :                 if (r->out.lpftLastWriteTime == NULL) {
    5924           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5925             :                 }
    5926           0 :                 if (r->out.rpc_status == NULL) {
    5927           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    5928             :                 }
    5929           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.KeyName));
    5930           0 :                 if (*r->out.KeyName) {
    5931           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.KeyName, CH_UTF16)));
    5932           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    5933           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.KeyName, CH_UTF16)));
    5934           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.KeyName, ndr_charset_length(*r->out.KeyName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    5935             :                 }
    5936           0 :                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, *r->out.lpftLastWriteTime));
    5937           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    5938           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    5939             :         }
    5940           0 :         return NDR_ERR_SUCCESS;
    5941             : }
    5942             : 
    5943           0 : static enum ndr_err_code ndr_pull_clusapi_EnumKey(struct ndr_pull *ndr, int flags, struct clusapi_EnumKey *r)
    5944             : {
    5945             :         uint32_t _ptr_KeyName;
    5946           0 :         uint32_t size_KeyName_2 = 0;
    5947           0 :         uint32_t length_KeyName_2 = 0;
    5948           0 :         TALLOC_CTX *_mem_save_KeyName_0 = NULL;
    5949           0 :         TALLOC_CTX *_mem_save_KeyName_1 = NULL;
    5950           0 :         TALLOC_CTX *_mem_save_lpftLastWriteTime_0 = NULL;
    5951           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    5952           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    5953           0 :         if (flags & NDR_IN) {
    5954           0 :                 NDR_ZERO_STRUCT(r->out);
    5955             : 
    5956           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    5957           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.dwIndex));
    5958           0 :                 NDR_PULL_ALLOC(ndr, r->out.KeyName);
    5959           0 :                 NDR_ZERO_STRUCTP(r->out.KeyName);
    5960           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpftLastWriteTime);
    5961           0 :                 NDR_ZERO_STRUCTP(r->out.lpftLastWriteTime);
    5962           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    5963           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    5964             :         }
    5965           0 :         if (flags & NDR_OUT) {
    5966             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    5967             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    5968           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5969           0 :                         NDR_PULL_ALLOC(ndr, r->out.KeyName);
    5970             :                 }
    5971           0 :                 _mem_save_KeyName_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5972           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.KeyName, LIBNDR_FLAG_REF_ALLOC);
    5973           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_KeyName));
    5974           0 :                 if (_ptr_KeyName) {
    5975           0 :                         NDR_PULL_ALLOC(ndr, *r->out.KeyName);
    5976             :                 } else {
    5977           0 :                         *r->out.KeyName = NULL;
    5978             :                 }
    5979           0 :                 if (*r->out.KeyName) {
    5980           0 :                         _mem_save_KeyName_1 = NDR_PULL_GET_MEM_CTX(ndr);
    5981           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.KeyName, 0);
    5982           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.KeyName));
    5983           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.KeyName));
    5984           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)r->out.KeyName, &size_KeyName_2));
    5985           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)r->out.KeyName, &length_KeyName_2));
    5986           0 :                         if (length_KeyName_2 > size_KeyName_2) {
    5987           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_KeyName_2, length_KeyName_2);
    5988             :                         }
    5989           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_KeyName_2, sizeof(uint16_t)));
    5990           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.KeyName, length_KeyName_2, sizeof(uint16_t), CH_UTF16));
    5991           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_KeyName_1, 0);
    5992             :                 }
    5993           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_KeyName_0, LIBNDR_FLAG_REF_ALLOC);
    5994           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    5995           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpftLastWriteTime);
    5996             :                 }
    5997           0 :                 _mem_save_lpftLastWriteTime_0 = NDR_PULL_GET_MEM_CTX(ndr);
    5998           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpftLastWriteTime, LIBNDR_FLAG_REF_ALLOC);
    5999           0 :                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, r->out.lpftLastWriteTime));
    6000           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpftLastWriteTime_0, LIBNDR_FLAG_REF_ALLOC);
    6001           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6002           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    6003             :                 }
    6004           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6005           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    6006           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    6007           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    6008           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    6009             :         }
    6010           0 :         return NDR_ERR_SUCCESS;
    6011             : }
    6012             : 
    6013           0 : _PUBLIC_ void ndr_print_clusapi_EnumKey(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_EnumKey *r)
    6014             : {
    6015           0 :         ndr_print_struct(ndr, name, "clusapi_EnumKey");
    6016           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    6017           0 :         ndr->depth++;
    6018           0 :         if (flags & NDR_SET_VALUES) {
    6019           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    6020             :         }
    6021           0 :         if (flags & NDR_IN) {
    6022           0 :                 ndr_print_struct(ndr, "in", "clusapi_EnumKey");
    6023           0 :                 ndr->depth++;
    6024           0 :                 ndr_print_policy_handle(ndr, "hKey", &r->in.hKey);
    6025           0 :                 ndr_print_uint32(ndr, "dwIndex", r->in.dwIndex);
    6026           0 :                 ndr->depth--;
    6027             :         }
    6028           0 :         if (flags & NDR_OUT) {
    6029           0 :                 ndr_print_struct(ndr, "out", "clusapi_EnumKey");
    6030           0 :                 ndr->depth++;
    6031           0 :                 ndr_print_ptr(ndr, "KeyName", r->out.KeyName);
    6032           0 :                 ndr->depth++;
    6033           0 :                 ndr_print_ptr(ndr, "KeyName", *r->out.KeyName);
    6034           0 :                 ndr->depth++;
    6035           0 :                 if (*r->out.KeyName) {
    6036           0 :                         ndr_print_string(ndr, "KeyName", *r->out.KeyName);
    6037             :                 }
    6038           0 :                 ndr->depth--;
    6039           0 :                 ndr->depth--;
    6040           0 :                 ndr_print_ptr(ndr, "lpftLastWriteTime", r->out.lpftLastWriteTime);
    6041           0 :                 ndr->depth++;
    6042           0 :                 ndr_print_NTTIME(ndr, "lpftLastWriteTime", *r->out.lpftLastWriteTime);
    6043           0 :                 ndr->depth--;
    6044           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    6045           0 :                 ndr->depth++;
    6046           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    6047           0 :                 ndr->depth--;
    6048           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    6049           0 :                 ndr->depth--;
    6050             :         }
    6051           0 :         ndr->depth--;
    6052             : }
    6053             : 
    6054           0 : static enum ndr_err_code ndr_push_clusapi_SetValue(struct ndr_push *ndr, int flags, const struct clusapi_SetValue *r)
    6055             : {
    6056           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    6057           0 :         if (flags & NDR_IN) {
    6058           0 :                 if (r->in.lpValueName == NULL) {
    6059           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6060             :                 }
    6061           0 :                 if (r->in.lpData == NULL) {
    6062           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6063             :                 }
    6064           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    6065           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpValueName, CH_UTF16)));
    6066           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    6067           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpValueName, CH_UTF16)));
    6068           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpValueName, ndr_charset_length(r->in.lpValueName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    6069           0 :                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.dwType));
    6070           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.cbData));
    6071           0 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.lpData, r->in.cbData));
    6072           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.cbData));
    6073             :         }
    6074           0 :         if (flags & NDR_OUT) {
    6075           0 :                 if (r->out.rpc_status == NULL) {
    6076           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6077             :                 }
    6078           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    6079           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    6080             :         }
    6081           0 :         return NDR_ERR_SUCCESS;
    6082             : }
    6083             : 
    6084           0 : static enum ndr_err_code ndr_pull_clusapi_SetValue(struct ndr_pull *ndr, int flags, struct clusapi_SetValue *r)
    6085             : {
    6086           0 :         uint32_t size_lpValueName_1 = 0;
    6087           0 :         uint32_t length_lpValueName_1 = 0;
    6088           0 :         uint32_t size_lpData_1 = 0;
    6089           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    6090           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    6091           0 :         if (flags & NDR_IN) {
    6092           0 :                 NDR_ZERO_STRUCT(r->out);
    6093             : 
    6094           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    6095           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpValueName));
    6096           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpValueName));
    6097           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpValueName, &size_lpValueName_1));
    6098           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpValueName, &length_lpValueName_1));
    6099           0 :                 if (length_lpValueName_1 > size_lpValueName_1) {
    6100           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpValueName_1, length_lpValueName_1);
    6101             :                 }
    6102           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpValueName_1, sizeof(uint16_t)));
    6103           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpValueName, length_lpValueName_1, sizeof(uint16_t), CH_UTF16));
    6104           0 :                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.dwType));
    6105           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpData));
    6106           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->in.lpData, &size_lpData_1));
    6107           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6108           0 :                         NDR_PULL_ALLOC_N(ndr, r->in.lpData, size_lpData_1);
    6109             :                 }
    6110           0 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.lpData, size_lpData_1));
    6111           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.cbData));
    6112           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    6113           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    6114           0 :                 if (r->in.lpData) {
    6115           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->in.lpData, r->in.cbData));
    6116             :                 }
    6117             :         }
    6118           0 :         if (flags & NDR_OUT) {
    6119             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    6120             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    6121           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6122           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    6123             :                 }
    6124           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6125           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    6126           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    6127           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    6128           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    6129             :         }
    6130           0 :         return NDR_ERR_SUCCESS;
    6131             : }
    6132             : 
    6133           0 : _PUBLIC_ void ndr_print_clusapi_SetValue(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_SetValue *r)
    6134             : {
    6135           0 :         ndr_print_struct(ndr, name, "clusapi_SetValue");
    6136           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    6137           0 :         ndr->depth++;
    6138           0 :         if (flags & NDR_SET_VALUES) {
    6139           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    6140             :         }
    6141           0 :         if (flags & NDR_IN) {
    6142           0 :                 ndr_print_struct(ndr, "in", "clusapi_SetValue");
    6143           0 :                 ndr->depth++;
    6144           0 :                 ndr_print_policy_handle(ndr, "hKey", &r->in.hKey);
    6145           0 :                 ndr_print_ptr(ndr, "lpValueName", r->in.lpValueName);
    6146           0 :                 ndr->depth++;
    6147           0 :                 ndr_print_string(ndr, "lpValueName", r->in.lpValueName);
    6148           0 :                 ndr->depth--;
    6149           0 :                 ndr_print_winreg_Type(ndr, "dwType", r->in.dwType);
    6150           0 :                 ndr_print_ptr(ndr, "lpData", r->in.lpData);
    6151           0 :                 ndr->depth++;
    6152           0 :                 ndr_print_array_uint8(ndr, "lpData", r->in.lpData, r->in.cbData);
    6153           0 :                 ndr->depth--;
    6154           0 :                 ndr_print_uint32(ndr, "cbData", r->in.cbData);
    6155           0 :                 ndr->depth--;
    6156             :         }
    6157           0 :         if (flags & NDR_OUT) {
    6158           0 :                 ndr_print_struct(ndr, "out", "clusapi_SetValue");
    6159           0 :                 ndr->depth++;
    6160           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    6161           0 :                 ndr->depth++;
    6162           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    6163           0 :                 ndr->depth--;
    6164           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    6165           0 :                 ndr->depth--;
    6166             :         }
    6167           0 :         ndr->depth--;
    6168             : }
    6169             : 
    6170           0 : static enum ndr_err_code ndr_push_clusapi_DeleteValue(struct ndr_push *ndr, int flags, const struct clusapi_DeleteValue *r)
    6171             : {
    6172           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    6173           0 :         if (flags & NDR_IN) {
    6174           0 :                 if (r->in.lpValueName == NULL) {
    6175           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6176             :                 }
    6177           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    6178           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpValueName, CH_UTF16)));
    6179           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    6180           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpValueName, CH_UTF16)));
    6181           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpValueName, ndr_charset_length(r->in.lpValueName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    6182             :         }
    6183           0 :         if (flags & NDR_OUT) {
    6184           0 :                 if (r->out.rpc_status == NULL) {
    6185           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6186             :                 }
    6187           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    6188           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    6189             :         }
    6190           0 :         return NDR_ERR_SUCCESS;
    6191             : }
    6192             : 
    6193           0 : static enum ndr_err_code ndr_pull_clusapi_DeleteValue(struct ndr_pull *ndr, int flags, struct clusapi_DeleteValue *r)
    6194             : {
    6195           0 :         uint32_t size_lpValueName_1 = 0;
    6196           0 :         uint32_t length_lpValueName_1 = 0;
    6197           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    6198           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    6199           0 :         if (flags & NDR_IN) {
    6200           0 :                 NDR_ZERO_STRUCT(r->out);
    6201             : 
    6202           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    6203           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpValueName));
    6204           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpValueName));
    6205           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpValueName, &size_lpValueName_1));
    6206           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpValueName, &length_lpValueName_1));
    6207           0 :                 if (length_lpValueName_1 > size_lpValueName_1) {
    6208           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpValueName_1, length_lpValueName_1);
    6209             :                 }
    6210           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpValueName_1, sizeof(uint16_t)));
    6211           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpValueName, length_lpValueName_1, sizeof(uint16_t), CH_UTF16));
    6212           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    6213           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    6214             :         }
    6215           0 :         if (flags & NDR_OUT) {
    6216             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    6217             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    6218           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6219           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    6220             :                 }
    6221           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6222           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    6223           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    6224           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    6225           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    6226             :         }
    6227           0 :         return NDR_ERR_SUCCESS;
    6228             : }
    6229             : 
    6230           0 : _PUBLIC_ void ndr_print_clusapi_DeleteValue(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_DeleteValue *r)
    6231             : {
    6232           0 :         ndr_print_struct(ndr, name, "clusapi_DeleteValue");
    6233           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    6234           0 :         ndr->depth++;
    6235           0 :         if (flags & NDR_SET_VALUES) {
    6236           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    6237             :         }
    6238           0 :         if (flags & NDR_IN) {
    6239           0 :                 ndr_print_struct(ndr, "in", "clusapi_DeleteValue");
    6240           0 :                 ndr->depth++;
    6241           0 :                 ndr_print_policy_handle(ndr, "hKey", &r->in.hKey);
    6242           0 :                 ndr_print_ptr(ndr, "lpValueName", r->in.lpValueName);
    6243           0 :                 ndr->depth++;
    6244           0 :                 ndr_print_string(ndr, "lpValueName", r->in.lpValueName);
    6245           0 :                 ndr->depth--;
    6246           0 :                 ndr->depth--;
    6247             :         }
    6248           0 :         if (flags & NDR_OUT) {
    6249           0 :                 ndr_print_struct(ndr, "out", "clusapi_DeleteValue");
    6250           0 :                 ndr->depth++;
    6251           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    6252           0 :                 ndr->depth++;
    6253           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    6254           0 :                 ndr->depth--;
    6255           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    6256           0 :                 ndr->depth--;
    6257             :         }
    6258           0 :         ndr->depth--;
    6259             : }
    6260             : 
    6261           0 : static enum ndr_err_code ndr_push_clusapi_QueryValue(struct ndr_push *ndr, int flags, const struct clusapi_QueryValue *r)
    6262             : {
    6263           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    6264           0 :         if (flags & NDR_IN) {
    6265           0 :                 if (r->in.lpValueName == NULL) {
    6266           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6267             :                 }
    6268           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    6269           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpValueName, CH_UTF16)));
    6270           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    6271           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpValueName, CH_UTF16)));
    6272           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpValueName, ndr_charset_length(r->in.lpValueName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    6273           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.cbData));
    6274             :         }
    6275           0 :         if (flags & NDR_OUT) {
    6276           0 :                 if (r->out.lpValueType == NULL) {
    6277           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6278             :                 }
    6279           0 :                 if (r->out.lpData == NULL) {
    6280           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6281             :                 }
    6282           0 :                 if (r->out.lpcbRequired == NULL) {
    6283           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6284             :                 }
    6285           0 :                 if (r->out.rpc_status == NULL) {
    6286           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6287             :                 }
    6288           0 :                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.lpValueType));
    6289           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.cbData));
    6290           0 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.lpData, r->in.cbData));
    6291           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.lpcbRequired));
    6292           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    6293           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    6294             :         }
    6295           0 :         return NDR_ERR_SUCCESS;
    6296             : }
    6297             : 
    6298           0 : static enum ndr_err_code ndr_pull_clusapi_QueryValue(struct ndr_pull *ndr, int flags, struct clusapi_QueryValue *r)
    6299             : {
    6300           0 :         uint32_t size_lpValueName_1 = 0;
    6301           0 :         uint32_t length_lpValueName_1 = 0;
    6302           0 :         uint32_t size_lpData_1 = 0;
    6303           0 :         TALLOC_CTX *_mem_save_lpValueType_0 = NULL;
    6304           0 :         TALLOC_CTX *_mem_save_lpcbRequired_0 = NULL;
    6305           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    6306           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    6307           0 :         if (flags & NDR_IN) {
    6308           0 :                 NDR_ZERO_STRUCT(r->out);
    6309             : 
    6310           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    6311           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpValueName));
    6312           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpValueName));
    6313           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpValueName, &size_lpValueName_1));
    6314           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpValueName, &length_lpValueName_1));
    6315           0 :                 if (length_lpValueName_1 > size_lpValueName_1) {
    6316           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpValueName_1, length_lpValueName_1);
    6317             :                 }
    6318           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpValueName_1, sizeof(uint16_t)));
    6319           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpValueName, length_lpValueName_1, sizeof(uint16_t), CH_UTF16));
    6320           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.cbData));
    6321           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpValueType);
    6322           0 :                 NDR_ZERO_STRUCTP(r->out.lpValueType);
    6323           0 :                 NDR_PULL_ALLOC_N(ndr, r->out.lpData, r->in.cbData);
    6324           0 :                 memset(r->out.lpData, 0, (r->in.cbData) * sizeof(*r->out.lpData));
    6325           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpcbRequired);
    6326           0 :                 NDR_ZERO_STRUCTP(r->out.lpcbRequired);
    6327           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    6328           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    6329             :         }
    6330           0 :         if (flags & NDR_OUT) {
    6331             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    6332             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    6333           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6334           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpValueType);
    6335             :                 }
    6336           0 :                 _mem_save_lpValueType_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6337           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpValueType, LIBNDR_FLAG_REF_ALLOC);
    6338           0 :                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.lpValueType));
    6339           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpValueType_0, LIBNDR_FLAG_REF_ALLOC);
    6340           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.lpData));
    6341           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->out.lpData, &size_lpData_1));
    6342           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6343           0 :                         NDR_PULL_ALLOC_N(ndr, r->out.lpData, size_lpData_1);
    6344             :                 }
    6345           0 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.lpData, size_lpData_1));
    6346           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6347           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpcbRequired);
    6348             :                 }
    6349           0 :                 _mem_save_lpcbRequired_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6350           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpcbRequired, LIBNDR_FLAG_REF_ALLOC);
    6351           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.lpcbRequired));
    6352           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpcbRequired_0, LIBNDR_FLAG_REF_ALLOC);
    6353           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6354           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    6355             :                 }
    6356           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6357           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    6358           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    6359           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    6360           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    6361           0 :                 if (r->out.lpData) {
    6362           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->out.lpData, r->in.cbData));
    6363             :                 }
    6364             :         }
    6365           0 :         return NDR_ERR_SUCCESS;
    6366             : }
    6367             : 
    6368           0 : _PUBLIC_ void ndr_print_clusapi_QueryValue(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_QueryValue *r)
    6369             : {
    6370           0 :         ndr_print_struct(ndr, name, "clusapi_QueryValue");
    6371           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    6372           0 :         ndr->depth++;
    6373           0 :         if (flags & NDR_SET_VALUES) {
    6374           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    6375             :         }
    6376           0 :         if (flags & NDR_IN) {
    6377           0 :                 ndr_print_struct(ndr, "in", "clusapi_QueryValue");
    6378           0 :                 ndr->depth++;
    6379           0 :                 ndr_print_policy_handle(ndr, "hKey", &r->in.hKey);
    6380           0 :                 ndr_print_ptr(ndr, "lpValueName", r->in.lpValueName);
    6381           0 :                 ndr->depth++;
    6382           0 :                 ndr_print_string(ndr, "lpValueName", r->in.lpValueName);
    6383           0 :                 ndr->depth--;
    6384           0 :                 ndr_print_uint32(ndr, "cbData", r->in.cbData);
    6385           0 :                 ndr->depth--;
    6386             :         }
    6387           0 :         if (flags & NDR_OUT) {
    6388           0 :                 ndr_print_struct(ndr, "out", "clusapi_QueryValue");
    6389           0 :                 ndr->depth++;
    6390           0 :                 ndr_print_ptr(ndr, "lpValueType", r->out.lpValueType);
    6391           0 :                 ndr->depth++;
    6392           0 :                 ndr_print_winreg_Type(ndr, "lpValueType", *r->out.lpValueType);
    6393           0 :                 ndr->depth--;
    6394           0 :                 ndr_print_ptr(ndr, "lpData", r->out.lpData);
    6395           0 :                 ndr->depth++;
    6396           0 :                 ndr_print_array_uint8(ndr, "lpData", r->out.lpData, r->in.cbData);
    6397           0 :                 ndr->depth--;
    6398           0 :                 ndr_print_ptr(ndr, "lpcbRequired", r->out.lpcbRequired);
    6399           0 :                 ndr->depth++;
    6400           0 :                 ndr_print_uint32(ndr, "lpcbRequired", *r->out.lpcbRequired);
    6401           0 :                 ndr->depth--;
    6402           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    6403           0 :                 ndr->depth++;
    6404           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    6405           0 :                 ndr->depth--;
    6406           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    6407           0 :                 ndr->depth--;
    6408             :         }
    6409           0 :         ndr->depth--;
    6410             : }
    6411             : 
    6412           0 : static enum ndr_err_code ndr_push_clusapi_DeleteKey(struct ndr_push *ndr, int flags, const struct clusapi_DeleteKey *r)
    6413             : {
    6414           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    6415           0 :         if (flags & NDR_IN) {
    6416           0 :                 if (r->in.lpSubKey == NULL) {
    6417           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6418             :                 }
    6419           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    6420           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpSubKey, CH_UTF16)));
    6421           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    6422           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpSubKey, CH_UTF16)));
    6423           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpSubKey, ndr_charset_length(r->in.lpSubKey, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    6424             :         }
    6425           0 :         if (flags & NDR_OUT) {
    6426           0 :                 if (r->out.rpc_status == NULL) {
    6427           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6428             :                 }
    6429           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    6430           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    6431             :         }
    6432           0 :         return NDR_ERR_SUCCESS;
    6433             : }
    6434             : 
    6435           0 : static enum ndr_err_code ndr_pull_clusapi_DeleteKey(struct ndr_pull *ndr, int flags, struct clusapi_DeleteKey *r)
    6436             : {
    6437           0 :         uint32_t size_lpSubKey_1 = 0;
    6438           0 :         uint32_t length_lpSubKey_1 = 0;
    6439           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    6440           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    6441           0 :         if (flags & NDR_IN) {
    6442           0 :                 NDR_ZERO_STRUCT(r->out);
    6443             : 
    6444           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    6445           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpSubKey));
    6446           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpSubKey));
    6447           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpSubKey, &size_lpSubKey_1));
    6448           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpSubKey, &length_lpSubKey_1));
    6449           0 :                 if (length_lpSubKey_1 > size_lpSubKey_1) {
    6450           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpSubKey_1, length_lpSubKey_1);
    6451             :                 }
    6452           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpSubKey_1, sizeof(uint16_t)));
    6453           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpSubKey, length_lpSubKey_1, sizeof(uint16_t), CH_UTF16));
    6454           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    6455           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    6456             :         }
    6457           0 :         if (flags & NDR_OUT) {
    6458             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    6459             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    6460           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6461           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    6462             :                 }
    6463           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6464           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    6465           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    6466           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    6467           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    6468             :         }
    6469           0 :         return NDR_ERR_SUCCESS;
    6470             : }
    6471             : 
    6472           0 : _PUBLIC_ void ndr_print_clusapi_DeleteKey(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_DeleteKey *r)
    6473             : {
    6474           0 :         ndr_print_struct(ndr, name, "clusapi_DeleteKey");
    6475           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    6476           0 :         ndr->depth++;
    6477           0 :         if (flags & NDR_SET_VALUES) {
    6478           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    6479             :         }
    6480           0 :         if (flags & NDR_IN) {
    6481           0 :                 ndr_print_struct(ndr, "in", "clusapi_DeleteKey");
    6482           0 :                 ndr->depth++;
    6483           0 :                 ndr_print_policy_handle(ndr, "hKey", &r->in.hKey);
    6484           0 :                 ndr_print_ptr(ndr, "lpSubKey", r->in.lpSubKey);
    6485           0 :                 ndr->depth++;
    6486           0 :                 ndr_print_string(ndr, "lpSubKey", r->in.lpSubKey);
    6487           0 :                 ndr->depth--;
    6488           0 :                 ndr->depth--;
    6489             :         }
    6490           0 :         if (flags & NDR_OUT) {
    6491           0 :                 ndr_print_struct(ndr, "out", "clusapi_DeleteKey");
    6492           0 :                 ndr->depth++;
    6493           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    6494           0 :                 ndr->depth++;
    6495           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    6496           0 :                 ndr->depth--;
    6497           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    6498           0 :                 ndr->depth--;
    6499             :         }
    6500           0 :         ndr->depth--;
    6501             : }
    6502             : 
    6503           0 : static enum ndr_err_code ndr_push_clusapi_EnumValue(struct ndr_push *ndr, int flags, const struct clusapi_EnumValue *r)
    6504             : {
    6505           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    6506           0 :         if (flags & NDR_IN) {
    6507           0 :                 if (r->in.lpcbData == NULL) {
    6508           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6509             :                 }
    6510           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    6511           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.dwIndex));
    6512           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.lpcbData));
    6513             :         }
    6514           0 :         if (flags & NDR_OUT) {
    6515           0 :                 if (r->out.lpValueName == NULL) {
    6516           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6517             :                 }
    6518           0 :                 if (r->out.lpType == NULL) {
    6519           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6520             :                 }
    6521           0 :                 if (r->out.lpData == NULL) {
    6522           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6523             :                 }
    6524           0 :                 if (r->out.lpcbData == NULL) {
    6525           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6526             :                 }
    6527           0 :                 if (r->out.TotalSize == NULL) {
    6528           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6529             :                 }
    6530           0 :                 if (r->out.rpc_status == NULL) {
    6531           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6532             :                 }
    6533           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.lpValueName));
    6534           0 :                 if (*r->out.lpValueName) {
    6535           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.lpValueName, CH_UTF16)));
    6536           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    6537           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.lpValueName, CH_UTF16)));
    6538           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.lpValueName, ndr_charset_length(*r->out.lpValueName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    6539             :                 }
    6540           0 :                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.lpType));
    6541           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.lpcbData));
    6542           0 :                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.lpData, *r->out.lpcbData));
    6543           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.lpcbData));
    6544           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.TotalSize));
    6545           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    6546           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    6547             :         }
    6548           0 :         return NDR_ERR_SUCCESS;
    6549             : }
    6550             : 
    6551           0 : static enum ndr_err_code ndr_pull_clusapi_EnumValue(struct ndr_pull *ndr, int flags, struct clusapi_EnumValue *r)
    6552             : {
    6553             :         uint32_t _ptr_lpValueName;
    6554           0 :         uint32_t size_lpValueName_2 = 0;
    6555           0 :         uint32_t length_lpValueName_2 = 0;
    6556           0 :         uint32_t size_lpData_1 = 0;
    6557           0 :         TALLOC_CTX *_mem_save_lpValueName_0 = NULL;
    6558           0 :         TALLOC_CTX *_mem_save_lpValueName_1 = NULL;
    6559           0 :         TALLOC_CTX *_mem_save_lpType_0 = NULL;
    6560           0 :         TALLOC_CTX *_mem_save_lpcbData_0 = NULL;
    6561           0 :         TALLOC_CTX *_mem_save_TotalSize_0 = NULL;
    6562           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    6563           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    6564           0 :         if (flags & NDR_IN) {
    6565           0 :                 NDR_ZERO_STRUCT(r->out);
    6566             : 
    6567           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    6568           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.dwIndex));
    6569           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6570           0 :                         NDR_PULL_ALLOC(ndr, r->in.lpcbData);
    6571             :                 }
    6572           0 :                 _mem_save_lpcbData_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6573           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.lpcbData, LIBNDR_FLAG_REF_ALLOC);
    6574           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.lpcbData));
    6575           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpcbData_0, LIBNDR_FLAG_REF_ALLOC);
    6576           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpValueName);
    6577           0 :                 NDR_ZERO_STRUCTP(r->out.lpValueName);
    6578           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpType);
    6579           0 :                 NDR_ZERO_STRUCTP(r->out.lpType);
    6580           0 :                 NDR_PULL_ALLOC_N(ndr, r->out.lpData, *r->in.lpcbData);
    6581           0 :                 memset(r->out.lpData, 0, (*r->in.lpcbData) * sizeof(*r->out.lpData));
    6582           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpcbData);
    6583           0 :                 *r->out.lpcbData = *r->in.lpcbData;
    6584           0 :                 NDR_PULL_ALLOC(ndr, r->out.TotalSize);
    6585           0 :                 NDR_ZERO_STRUCTP(r->out.TotalSize);
    6586           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    6587           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    6588             :         }
    6589           0 :         if (flags & NDR_OUT) {
    6590             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    6591             :                 if (r->in.lpcbData == NULL) {
    6592             :                         NDR_PULL_ALLOC(ndr, r->in.lpcbData);
    6593             :                         NDR_ZERO_STRUCTP(r->in.lpcbData);
    6594             :                 }
    6595             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    6596           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6597           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpValueName);
    6598             :                 }
    6599           0 :                 _mem_save_lpValueName_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6600           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpValueName, LIBNDR_FLAG_REF_ALLOC);
    6601           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lpValueName));
    6602           0 :                 if (_ptr_lpValueName) {
    6603           0 :                         NDR_PULL_ALLOC(ndr, *r->out.lpValueName);
    6604             :                 } else {
    6605           0 :                         *r->out.lpValueName = NULL;
    6606             :                 }
    6607           0 :                 if (*r->out.lpValueName) {
    6608           0 :                         _mem_save_lpValueName_1 = NDR_PULL_GET_MEM_CTX(ndr);
    6609           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.lpValueName, 0);
    6610           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.lpValueName));
    6611           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.lpValueName));
    6612           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)r->out.lpValueName, &size_lpValueName_2));
    6613           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)r->out.lpValueName, &length_lpValueName_2));
    6614           0 :                         if (length_lpValueName_2 > size_lpValueName_2) {
    6615           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpValueName_2, length_lpValueName_2);
    6616             :                         }
    6617           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_lpValueName_2, sizeof(uint16_t)));
    6618           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.lpValueName, length_lpValueName_2, sizeof(uint16_t), CH_UTF16));
    6619           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpValueName_1, 0);
    6620             :                 }
    6621           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpValueName_0, LIBNDR_FLAG_REF_ALLOC);
    6622           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6623           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpType);
    6624             :                 }
    6625           0 :                 _mem_save_lpType_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6626           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpType, LIBNDR_FLAG_REF_ALLOC);
    6627           0 :                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.lpType));
    6628           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpType_0, LIBNDR_FLAG_REF_ALLOC);
    6629           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.lpData));
    6630           0 :                 NDR_CHECK(ndr_get_array_size(ndr, (void*)&r->out.lpData, &size_lpData_1));
    6631           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6632           0 :                         NDR_PULL_ALLOC_N(ndr, r->out.lpData, size_lpData_1);
    6633             :                 }
    6634           0 :                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.lpData, size_lpData_1));
    6635           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6636           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpcbData);
    6637             :                 }
    6638           0 :                 _mem_save_lpcbData_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6639           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpcbData, LIBNDR_FLAG_REF_ALLOC);
    6640           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.lpcbData));
    6641           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpcbData_0, LIBNDR_FLAG_REF_ALLOC);
    6642           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6643           0 :                         NDR_PULL_ALLOC(ndr, r->out.TotalSize);
    6644             :                 }
    6645           0 :                 _mem_save_TotalSize_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6646           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.TotalSize, LIBNDR_FLAG_REF_ALLOC);
    6647           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.TotalSize));
    6648           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_TotalSize_0, LIBNDR_FLAG_REF_ALLOC);
    6649           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6650           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    6651             :                 }
    6652           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6653           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    6654           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    6655           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    6656           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    6657           0 :                 if (r->out.lpData) {
    6658           0 :                         NDR_CHECK(ndr_check_steal_array_size(ndr, (void*)&r->out.lpData, *r->out.lpcbData));
    6659             :                 }
    6660             :         }
    6661           0 :         return NDR_ERR_SUCCESS;
    6662             : }
    6663             : 
    6664           0 : _PUBLIC_ void ndr_print_clusapi_EnumValue(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_EnumValue *r)
    6665             : {
    6666           0 :         ndr_print_struct(ndr, name, "clusapi_EnumValue");
    6667           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    6668           0 :         ndr->depth++;
    6669           0 :         if (flags & NDR_SET_VALUES) {
    6670           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    6671             :         }
    6672           0 :         if (flags & NDR_IN) {
    6673           0 :                 ndr_print_struct(ndr, "in", "clusapi_EnumValue");
    6674           0 :                 ndr->depth++;
    6675           0 :                 ndr_print_policy_handle(ndr, "hKey", &r->in.hKey);
    6676           0 :                 ndr_print_uint32(ndr, "dwIndex", r->in.dwIndex);
    6677           0 :                 ndr_print_ptr(ndr, "lpcbData", r->in.lpcbData);
    6678           0 :                 ndr->depth++;
    6679           0 :                 ndr_print_uint32(ndr, "lpcbData", *r->in.lpcbData);
    6680           0 :                 ndr->depth--;
    6681           0 :                 ndr->depth--;
    6682             :         }
    6683           0 :         if (flags & NDR_OUT) {
    6684           0 :                 ndr_print_struct(ndr, "out", "clusapi_EnumValue");
    6685           0 :                 ndr->depth++;
    6686           0 :                 ndr_print_ptr(ndr, "lpValueName", r->out.lpValueName);
    6687           0 :                 ndr->depth++;
    6688           0 :                 ndr_print_ptr(ndr, "lpValueName", *r->out.lpValueName);
    6689           0 :                 ndr->depth++;
    6690           0 :                 if (*r->out.lpValueName) {
    6691           0 :                         ndr_print_string(ndr, "lpValueName", *r->out.lpValueName);
    6692             :                 }
    6693           0 :                 ndr->depth--;
    6694           0 :                 ndr->depth--;
    6695           0 :                 ndr_print_ptr(ndr, "lpType", r->out.lpType);
    6696           0 :                 ndr->depth++;
    6697           0 :                 ndr_print_winreg_Type(ndr, "lpType", *r->out.lpType);
    6698           0 :                 ndr->depth--;
    6699           0 :                 ndr_print_ptr(ndr, "lpData", r->out.lpData);
    6700           0 :                 ndr->depth++;
    6701           0 :                 ndr_print_array_uint8(ndr, "lpData", r->out.lpData, *r->out.lpcbData);
    6702           0 :                 ndr->depth--;
    6703           0 :                 ndr_print_ptr(ndr, "lpcbData", r->out.lpcbData);
    6704           0 :                 ndr->depth++;
    6705           0 :                 ndr_print_uint32(ndr, "lpcbData", *r->out.lpcbData);
    6706           0 :                 ndr->depth--;
    6707           0 :                 ndr_print_ptr(ndr, "TotalSize", r->out.TotalSize);
    6708           0 :                 ndr->depth++;
    6709           0 :                 ndr_print_uint32(ndr, "TotalSize", *r->out.TotalSize);
    6710           0 :                 ndr->depth--;
    6711           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    6712           0 :                 ndr->depth++;
    6713           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    6714           0 :                 ndr->depth--;
    6715           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    6716           0 :                 ndr->depth--;
    6717             :         }
    6718           0 :         ndr->depth--;
    6719             : }
    6720             : 
    6721           0 : static enum ndr_err_code ndr_push_clusapi_CloseKey(struct ndr_push *ndr, int flags, const struct clusapi_CloseKey *r)
    6722             : {
    6723           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    6724           0 :         if (flags & NDR_IN) {
    6725           0 :                 if (r->in.pKey == NULL) {
    6726           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6727             :                 }
    6728           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.pKey));
    6729             :         }
    6730           0 :         if (flags & NDR_OUT) {
    6731           0 :                 if (r->out.pKey == NULL) {
    6732           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6733             :                 }
    6734           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.pKey));
    6735           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    6736             :         }
    6737           0 :         return NDR_ERR_SUCCESS;
    6738             : }
    6739             : 
    6740           0 : static enum ndr_err_code ndr_pull_clusapi_CloseKey(struct ndr_pull *ndr, int flags, struct clusapi_CloseKey *r)
    6741             : {
    6742           0 :         TALLOC_CTX *_mem_save_pKey_0 = NULL;
    6743           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    6744           0 :         if (flags & NDR_IN) {
    6745           0 :                 NDR_ZERO_STRUCT(r->out);
    6746             : 
    6747           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6748           0 :                         NDR_PULL_ALLOC(ndr, r->in.pKey);
    6749             :                 }
    6750           0 :                 _mem_save_pKey_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6751           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.pKey, LIBNDR_FLAG_REF_ALLOC);
    6752           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.pKey));
    6753           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pKey_0, LIBNDR_FLAG_REF_ALLOC);
    6754           0 :                 NDR_PULL_ALLOC(ndr, r->out.pKey);
    6755           0 :                 *r->out.pKey = *r->in.pKey;
    6756             :         }
    6757           0 :         if (flags & NDR_OUT) {
    6758             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    6759             :                 if (r->in.pKey == NULL) {
    6760             :                         NDR_PULL_ALLOC(ndr, r->in.pKey);
    6761             :                         NDR_ZERO_STRUCTP(r->in.pKey);
    6762             :                 }
    6763             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    6764           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6765           0 :                         NDR_PULL_ALLOC(ndr, r->out.pKey);
    6766             :                 }
    6767           0 :                 _mem_save_pKey_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6768           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pKey, LIBNDR_FLAG_REF_ALLOC);
    6769           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.pKey));
    6770           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pKey_0, LIBNDR_FLAG_REF_ALLOC);
    6771           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    6772             :         }
    6773           0 :         return NDR_ERR_SUCCESS;
    6774             : }
    6775             : 
    6776           0 : _PUBLIC_ void ndr_print_clusapi_CloseKey(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_CloseKey *r)
    6777             : {
    6778           0 :         ndr_print_struct(ndr, name, "clusapi_CloseKey");
    6779           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    6780           0 :         ndr->depth++;
    6781           0 :         if (flags & NDR_SET_VALUES) {
    6782           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    6783             :         }
    6784           0 :         if (flags & NDR_IN) {
    6785           0 :                 ndr_print_struct(ndr, "in", "clusapi_CloseKey");
    6786           0 :                 ndr->depth++;
    6787           0 :                 ndr_print_ptr(ndr, "pKey", r->in.pKey);
    6788           0 :                 ndr->depth++;
    6789           0 :                 ndr_print_policy_handle(ndr, "pKey", r->in.pKey);
    6790           0 :                 ndr->depth--;
    6791           0 :                 ndr->depth--;
    6792             :         }
    6793           0 :         if (flags & NDR_OUT) {
    6794           0 :                 ndr_print_struct(ndr, "out", "clusapi_CloseKey");
    6795           0 :                 ndr->depth++;
    6796           0 :                 ndr_print_ptr(ndr, "pKey", r->out.pKey);
    6797           0 :                 ndr->depth++;
    6798           0 :                 ndr_print_policy_handle(ndr, "pKey", r->out.pKey);
    6799           0 :                 ndr->depth--;
    6800           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    6801           0 :                 ndr->depth--;
    6802             :         }
    6803           0 :         ndr->depth--;
    6804             : }
    6805             : 
    6806           0 : static enum ndr_err_code ndr_push_clusapi_QueryInfoKey(struct ndr_push *ndr, int flags, const struct clusapi_QueryInfoKey *r)
    6807             : {
    6808           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    6809           0 :         if (flags & NDR_IN) {
    6810           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    6811             :         }
    6812           0 :         if (flags & NDR_OUT) {
    6813           0 :                 if (r->out.lpcSubKeys == NULL) {
    6814           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6815             :                 }
    6816           0 :                 if (r->out.lpcbMaxSubKeyLen == NULL) {
    6817           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6818             :                 }
    6819           0 :                 if (r->out.lpcValues == NULL) {
    6820           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6821             :                 }
    6822           0 :                 if (r->out.lpcbMaxValueNameLen == NULL) {
    6823           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6824             :                 }
    6825           0 :                 if (r->out.lpcbMaxValueLen == NULL) {
    6826           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6827             :                 }
    6828           0 :                 if (r->out.lpcbSecurityDescriptor == NULL) {
    6829           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6830             :                 }
    6831           0 :                 if (r->out.lpftLastWriteTime == NULL) {
    6832           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6833             :                 }
    6834           0 :                 if (r->out.rpc_status == NULL) {
    6835           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    6836             :                 }
    6837           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.lpcSubKeys));
    6838           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.lpcbMaxSubKeyLen));
    6839           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.lpcValues));
    6840           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.lpcbMaxValueNameLen));
    6841           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.lpcbMaxValueLen));
    6842           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.lpcbSecurityDescriptor));
    6843           0 :                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, *r->out.lpftLastWriteTime));
    6844           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    6845           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    6846             :         }
    6847           0 :         return NDR_ERR_SUCCESS;
    6848             : }
    6849             : 
    6850           0 : static enum ndr_err_code ndr_pull_clusapi_QueryInfoKey(struct ndr_pull *ndr, int flags, struct clusapi_QueryInfoKey *r)
    6851             : {
    6852           0 :         TALLOC_CTX *_mem_save_lpcSubKeys_0 = NULL;
    6853           0 :         TALLOC_CTX *_mem_save_lpcbMaxSubKeyLen_0 = NULL;
    6854           0 :         TALLOC_CTX *_mem_save_lpcValues_0 = NULL;
    6855           0 :         TALLOC_CTX *_mem_save_lpcbMaxValueNameLen_0 = NULL;
    6856           0 :         TALLOC_CTX *_mem_save_lpcbMaxValueLen_0 = NULL;
    6857           0 :         TALLOC_CTX *_mem_save_lpcbSecurityDescriptor_0 = NULL;
    6858           0 :         TALLOC_CTX *_mem_save_lpftLastWriteTime_0 = NULL;
    6859           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    6860           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    6861           0 :         if (flags & NDR_IN) {
    6862           0 :                 NDR_ZERO_STRUCT(r->out);
    6863             : 
    6864           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    6865           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpcSubKeys);
    6866           0 :                 NDR_ZERO_STRUCTP(r->out.lpcSubKeys);
    6867           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpcbMaxSubKeyLen);
    6868           0 :                 NDR_ZERO_STRUCTP(r->out.lpcbMaxSubKeyLen);
    6869           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpcValues);
    6870           0 :                 NDR_ZERO_STRUCTP(r->out.lpcValues);
    6871           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpcbMaxValueNameLen);
    6872           0 :                 NDR_ZERO_STRUCTP(r->out.lpcbMaxValueNameLen);
    6873           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpcbMaxValueLen);
    6874           0 :                 NDR_ZERO_STRUCTP(r->out.lpcbMaxValueLen);
    6875           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpcbSecurityDescriptor);
    6876           0 :                 NDR_ZERO_STRUCTP(r->out.lpcbSecurityDescriptor);
    6877           0 :                 NDR_PULL_ALLOC(ndr, r->out.lpftLastWriteTime);
    6878           0 :                 NDR_ZERO_STRUCTP(r->out.lpftLastWriteTime);
    6879           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    6880           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    6881             :         }
    6882           0 :         if (flags & NDR_OUT) {
    6883             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    6884             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    6885           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6886           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpcSubKeys);
    6887             :                 }
    6888           0 :                 _mem_save_lpcSubKeys_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6889           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpcSubKeys, LIBNDR_FLAG_REF_ALLOC);
    6890           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.lpcSubKeys));
    6891           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpcSubKeys_0, LIBNDR_FLAG_REF_ALLOC);
    6892           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6893           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpcbMaxSubKeyLen);
    6894             :                 }
    6895           0 :                 _mem_save_lpcbMaxSubKeyLen_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6896           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpcbMaxSubKeyLen, LIBNDR_FLAG_REF_ALLOC);
    6897           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.lpcbMaxSubKeyLen));
    6898           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpcbMaxSubKeyLen_0, LIBNDR_FLAG_REF_ALLOC);
    6899           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6900           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpcValues);
    6901             :                 }
    6902           0 :                 _mem_save_lpcValues_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6903           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpcValues, LIBNDR_FLAG_REF_ALLOC);
    6904           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.lpcValues));
    6905           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpcValues_0, LIBNDR_FLAG_REF_ALLOC);
    6906           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6907           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpcbMaxValueNameLen);
    6908             :                 }
    6909           0 :                 _mem_save_lpcbMaxValueNameLen_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6910           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpcbMaxValueNameLen, LIBNDR_FLAG_REF_ALLOC);
    6911           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.lpcbMaxValueNameLen));
    6912           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpcbMaxValueNameLen_0, LIBNDR_FLAG_REF_ALLOC);
    6913           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6914           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpcbMaxValueLen);
    6915             :                 }
    6916           0 :                 _mem_save_lpcbMaxValueLen_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6917           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpcbMaxValueLen, LIBNDR_FLAG_REF_ALLOC);
    6918           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.lpcbMaxValueLen));
    6919           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpcbMaxValueLen_0, LIBNDR_FLAG_REF_ALLOC);
    6920           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6921           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpcbSecurityDescriptor);
    6922             :                 }
    6923           0 :                 _mem_save_lpcbSecurityDescriptor_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6924           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpcbSecurityDescriptor, LIBNDR_FLAG_REF_ALLOC);
    6925           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.lpcbSecurityDescriptor));
    6926           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpcbSecurityDescriptor_0, LIBNDR_FLAG_REF_ALLOC);
    6927           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6928           0 :                         NDR_PULL_ALLOC(ndr, r->out.lpftLastWriteTime);
    6929             :                 }
    6930           0 :                 _mem_save_lpftLastWriteTime_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6931           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lpftLastWriteTime, LIBNDR_FLAG_REF_ALLOC);
    6932           0 :                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, r->out.lpftLastWriteTime));
    6933           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lpftLastWriteTime_0, LIBNDR_FLAG_REF_ALLOC);
    6934           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    6935           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    6936             :                 }
    6937           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    6938           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    6939           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    6940           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    6941           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    6942             :         }
    6943           0 :         return NDR_ERR_SUCCESS;
    6944             : }
    6945             : 
    6946           0 : _PUBLIC_ void ndr_print_clusapi_QueryInfoKey(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_QueryInfoKey *r)
    6947             : {
    6948           0 :         ndr_print_struct(ndr, name, "clusapi_QueryInfoKey");
    6949           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    6950           0 :         ndr->depth++;
    6951           0 :         if (flags & NDR_SET_VALUES) {
    6952           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    6953             :         }
    6954           0 :         if (flags & NDR_IN) {
    6955           0 :                 ndr_print_struct(ndr, "in", "clusapi_QueryInfoKey");
    6956           0 :                 ndr->depth++;
    6957           0 :                 ndr_print_policy_handle(ndr, "hKey", &r->in.hKey);
    6958           0 :                 ndr->depth--;
    6959             :         }
    6960           0 :         if (flags & NDR_OUT) {
    6961           0 :                 ndr_print_struct(ndr, "out", "clusapi_QueryInfoKey");
    6962           0 :                 ndr->depth++;
    6963           0 :                 ndr_print_ptr(ndr, "lpcSubKeys", r->out.lpcSubKeys);
    6964           0 :                 ndr->depth++;
    6965           0 :                 ndr_print_uint32(ndr, "lpcSubKeys", *r->out.lpcSubKeys);
    6966           0 :                 ndr->depth--;
    6967           0 :                 ndr_print_ptr(ndr, "lpcbMaxSubKeyLen", r->out.lpcbMaxSubKeyLen);
    6968           0 :                 ndr->depth++;
    6969           0 :                 ndr_print_uint32(ndr, "lpcbMaxSubKeyLen", *r->out.lpcbMaxSubKeyLen);
    6970           0 :                 ndr->depth--;
    6971           0 :                 ndr_print_ptr(ndr, "lpcValues", r->out.lpcValues);
    6972           0 :                 ndr->depth++;
    6973           0 :                 ndr_print_uint32(ndr, "lpcValues", *r->out.lpcValues);
    6974           0 :                 ndr->depth--;
    6975           0 :                 ndr_print_ptr(ndr, "lpcbMaxValueNameLen", r->out.lpcbMaxValueNameLen);
    6976           0 :                 ndr->depth++;
    6977           0 :                 ndr_print_uint32(ndr, "lpcbMaxValueNameLen", *r->out.lpcbMaxValueNameLen);
    6978           0 :                 ndr->depth--;
    6979           0 :                 ndr_print_ptr(ndr, "lpcbMaxValueLen", r->out.lpcbMaxValueLen);
    6980           0 :                 ndr->depth++;
    6981           0 :                 ndr_print_uint32(ndr, "lpcbMaxValueLen", *r->out.lpcbMaxValueLen);
    6982           0 :                 ndr->depth--;
    6983           0 :                 ndr_print_ptr(ndr, "lpcbSecurityDescriptor", r->out.lpcbSecurityDescriptor);
    6984           0 :                 ndr->depth++;
    6985           0 :                 ndr_print_uint32(ndr, "lpcbSecurityDescriptor", *r->out.lpcbSecurityDescriptor);
    6986           0 :                 ndr->depth--;
    6987           0 :                 ndr_print_ptr(ndr, "lpftLastWriteTime", r->out.lpftLastWriteTime);
    6988           0 :                 ndr->depth++;
    6989           0 :                 ndr_print_NTTIME(ndr, "lpftLastWriteTime", *r->out.lpftLastWriteTime);
    6990           0 :                 ndr->depth--;
    6991           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    6992           0 :                 ndr->depth++;
    6993           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    6994           0 :                 ndr->depth--;
    6995           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    6996           0 :                 ndr->depth--;
    6997             :         }
    6998           0 :         ndr->depth--;
    6999             : }
    7000             : 
    7001           0 : static enum ndr_err_code ndr_push_clusapi_SetKeySecurity(struct ndr_push *ndr, int flags, const struct clusapi_SetKeySecurity *r)
    7002             : {
    7003           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    7004           0 :         if (flags & NDR_IN) {
    7005           0 :                 if (r->in.pRpcSecurityDescriptor == NULL) {
    7006           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7007             :                 }
    7008           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    7009           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.SecurityInformation));
    7010           0 :                 NDR_CHECK(ndr_push_RPC_SECURITY_DESCRIPTOR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.pRpcSecurityDescriptor));
    7011             :         }
    7012           0 :         if (flags & NDR_OUT) {
    7013           0 :                 if (r->out.rpc_status == NULL) {
    7014           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7015             :                 }
    7016           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    7017           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    7018             :         }
    7019           0 :         return NDR_ERR_SUCCESS;
    7020             : }
    7021             : 
    7022           0 : static enum ndr_err_code ndr_pull_clusapi_SetKeySecurity(struct ndr_pull *ndr, int flags, struct clusapi_SetKeySecurity *r)
    7023             : {
    7024           0 :         TALLOC_CTX *_mem_save_pRpcSecurityDescriptor_0 = NULL;
    7025           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    7026           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    7027           0 :         if (flags & NDR_IN) {
    7028           0 :                 NDR_ZERO_STRUCT(r->out);
    7029             : 
    7030           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    7031           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.SecurityInformation));
    7032           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7033           0 :                         NDR_PULL_ALLOC(ndr, r->in.pRpcSecurityDescriptor);
    7034             :                 }
    7035           0 :                 _mem_save_pRpcSecurityDescriptor_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7036           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.pRpcSecurityDescriptor, LIBNDR_FLAG_REF_ALLOC);
    7037           0 :                 NDR_CHECK(ndr_pull_RPC_SECURITY_DESCRIPTOR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.pRpcSecurityDescriptor));
    7038           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pRpcSecurityDescriptor_0, LIBNDR_FLAG_REF_ALLOC);
    7039           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    7040           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    7041             :         }
    7042           0 :         if (flags & NDR_OUT) {
    7043             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    7044             :                 if (r->in.pRpcSecurityDescriptor == NULL) {
    7045             :                         NDR_PULL_ALLOC(ndr, r->in.pRpcSecurityDescriptor);
    7046             :                         NDR_ZERO_STRUCTP(r->in.pRpcSecurityDescriptor);
    7047             :                 }
    7048             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    7049           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7050           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    7051             :                 }
    7052           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7053           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    7054           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    7055           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    7056           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    7057             :         }
    7058           0 :         return NDR_ERR_SUCCESS;
    7059             : }
    7060             : 
    7061           0 : _PUBLIC_ void ndr_print_clusapi_SetKeySecurity(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_SetKeySecurity *r)
    7062             : {
    7063           0 :         ndr_print_struct(ndr, name, "clusapi_SetKeySecurity");
    7064           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    7065           0 :         ndr->depth++;
    7066           0 :         if (flags & NDR_SET_VALUES) {
    7067           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    7068             :         }
    7069           0 :         if (flags & NDR_IN) {
    7070           0 :                 ndr_print_struct(ndr, "in", "clusapi_SetKeySecurity");
    7071           0 :                 ndr->depth++;
    7072           0 :                 ndr_print_policy_handle(ndr, "hKey", &r->in.hKey);
    7073           0 :                 ndr_print_uint32(ndr, "SecurityInformation", r->in.SecurityInformation);
    7074           0 :                 ndr_print_ptr(ndr, "pRpcSecurityDescriptor", r->in.pRpcSecurityDescriptor);
    7075           0 :                 ndr->depth++;
    7076           0 :                 ndr_print_RPC_SECURITY_DESCRIPTOR(ndr, "pRpcSecurityDescriptor", r->in.pRpcSecurityDescriptor);
    7077           0 :                 ndr->depth--;
    7078           0 :                 ndr->depth--;
    7079             :         }
    7080           0 :         if (flags & NDR_OUT) {
    7081           0 :                 ndr_print_struct(ndr, "out", "clusapi_SetKeySecurity");
    7082           0 :                 ndr->depth++;
    7083           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    7084           0 :                 ndr->depth++;
    7085           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    7086           0 :                 ndr->depth--;
    7087           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    7088           0 :                 ndr->depth--;
    7089             :         }
    7090           0 :         ndr->depth--;
    7091             : }
    7092             : 
    7093           0 : static enum ndr_err_code ndr_push_clusapi_GetKeySecurity(struct ndr_push *ndr, int flags, const struct clusapi_GetKeySecurity *r)
    7094             : {
    7095           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    7096           0 :         if (flags & NDR_IN) {
    7097           0 :                 if (r->in.pRpcSecurityDescriptor == NULL) {
    7098           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7099             :                 }
    7100           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    7101           0 :                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.SecurityInformation));
    7102           0 :                 NDR_CHECK(ndr_push_RPC_SECURITY_DESCRIPTOR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.pRpcSecurityDescriptor));
    7103             :         }
    7104           0 :         if (flags & NDR_OUT) {
    7105           0 :                 if (r->out.pRpcSecurityDescriptor == NULL) {
    7106           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7107             :                 }
    7108           0 :                 if (r->out.rpc_status == NULL) {
    7109           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7110             :                 }
    7111           0 :                 NDR_CHECK(ndr_push_RPC_SECURITY_DESCRIPTOR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.pRpcSecurityDescriptor));
    7112           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    7113           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    7114             :         }
    7115           0 :         return NDR_ERR_SUCCESS;
    7116             : }
    7117             : 
    7118           0 : static enum ndr_err_code ndr_pull_clusapi_GetKeySecurity(struct ndr_pull *ndr, int flags, struct clusapi_GetKeySecurity *r)
    7119             : {
    7120           0 :         TALLOC_CTX *_mem_save_pRpcSecurityDescriptor_0 = NULL;
    7121           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    7122           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    7123           0 :         if (flags & NDR_IN) {
    7124           0 :                 NDR_ZERO_STRUCT(r->out);
    7125             : 
    7126           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hKey));
    7127           0 :                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.SecurityInformation));
    7128           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7129           0 :                         NDR_PULL_ALLOC(ndr, r->in.pRpcSecurityDescriptor);
    7130             :                 }
    7131           0 :                 _mem_save_pRpcSecurityDescriptor_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7132           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.pRpcSecurityDescriptor, LIBNDR_FLAG_REF_ALLOC);
    7133           0 :                 NDR_CHECK(ndr_pull_RPC_SECURITY_DESCRIPTOR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.pRpcSecurityDescriptor));
    7134           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pRpcSecurityDescriptor_0, LIBNDR_FLAG_REF_ALLOC);
    7135           0 :                 NDR_PULL_ALLOC(ndr, r->out.pRpcSecurityDescriptor);
    7136           0 :                 *r->out.pRpcSecurityDescriptor = *r->in.pRpcSecurityDescriptor;
    7137           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    7138           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    7139             :         }
    7140           0 :         if (flags & NDR_OUT) {
    7141             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    7142             :                 if (r->in.pRpcSecurityDescriptor == NULL) {
    7143             :                         NDR_PULL_ALLOC(ndr, r->in.pRpcSecurityDescriptor);
    7144             :                         NDR_ZERO_STRUCTP(r->in.pRpcSecurityDescriptor);
    7145             :                 }
    7146             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    7147           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7148           0 :                         NDR_PULL_ALLOC(ndr, r->out.pRpcSecurityDescriptor);
    7149             :                 }
    7150           0 :                 _mem_save_pRpcSecurityDescriptor_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7151           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pRpcSecurityDescriptor, LIBNDR_FLAG_REF_ALLOC);
    7152           0 :                 NDR_CHECK(ndr_pull_RPC_SECURITY_DESCRIPTOR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.pRpcSecurityDescriptor));
    7153           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pRpcSecurityDescriptor_0, LIBNDR_FLAG_REF_ALLOC);
    7154           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7155           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    7156             :                 }
    7157           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7158           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    7159           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    7160           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    7161           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    7162             :         }
    7163           0 :         return NDR_ERR_SUCCESS;
    7164             : }
    7165             : 
    7166           0 : _PUBLIC_ void ndr_print_clusapi_GetKeySecurity(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_GetKeySecurity *r)
    7167             : {
    7168           0 :         ndr_print_struct(ndr, name, "clusapi_GetKeySecurity");
    7169           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    7170           0 :         ndr->depth++;
    7171           0 :         if (flags & NDR_SET_VALUES) {
    7172           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    7173             :         }
    7174           0 :         if (flags & NDR_IN) {
    7175           0 :                 ndr_print_struct(ndr, "in", "clusapi_GetKeySecurity");
    7176           0 :                 ndr->depth++;
    7177           0 :                 ndr_print_policy_handle(ndr, "hKey", &r->in.hKey);
    7178           0 :                 ndr_print_uint32(ndr, "SecurityInformation", r->in.SecurityInformation);
    7179           0 :                 ndr_print_ptr(ndr, "pRpcSecurityDescriptor", r->in.pRpcSecurityDescriptor);
    7180           0 :                 ndr->depth++;
    7181           0 :                 ndr_print_RPC_SECURITY_DESCRIPTOR(ndr, "pRpcSecurityDescriptor", r->in.pRpcSecurityDescriptor);
    7182           0 :                 ndr->depth--;
    7183           0 :                 ndr->depth--;
    7184             :         }
    7185           0 :         if (flags & NDR_OUT) {
    7186           0 :                 ndr_print_struct(ndr, "out", "clusapi_GetKeySecurity");
    7187           0 :                 ndr->depth++;
    7188           0 :                 ndr_print_ptr(ndr, "pRpcSecurityDescriptor", r->out.pRpcSecurityDescriptor);
    7189           0 :                 ndr->depth++;
    7190           0 :                 ndr_print_RPC_SECURITY_DESCRIPTOR(ndr, "pRpcSecurityDescriptor", r->out.pRpcSecurityDescriptor);
    7191           0 :                 ndr->depth--;
    7192           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    7193           0 :                 ndr->depth++;
    7194           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    7195           0 :                 ndr->depth--;
    7196           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    7197           0 :                 ndr->depth--;
    7198             :         }
    7199           0 :         ndr->depth--;
    7200             : }
    7201             : 
    7202           0 : static enum ndr_err_code ndr_push_clusapi_OpenGroup(struct ndr_push *ndr, int flags, const struct clusapi_OpenGroup *r)
    7203             : {
    7204           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    7205           0 :         if (flags & NDR_IN) {
    7206           0 :                 if (r->in.lpszGroupName == NULL) {
    7207           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7208             :                 }
    7209           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszGroupName, CH_UTF16)));
    7210           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    7211           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszGroupName, CH_UTF16)));
    7212           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpszGroupName, ndr_charset_length(r->in.lpszGroupName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    7213             :         }
    7214           0 :         if (flags & NDR_OUT) {
    7215           0 :                 if (r->out.Status == NULL) {
    7216           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7217             :                 }
    7218           0 :                 if (r->out.rpc_status == NULL) {
    7219           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7220             :                 }
    7221           0 :                 if (r->out.hGroup == NULL) {
    7222           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7223             :                 }
    7224           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.Status));
    7225           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    7226           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.hGroup));
    7227             :         }
    7228           0 :         return NDR_ERR_SUCCESS;
    7229             : }
    7230             : 
    7231           0 : static enum ndr_err_code ndr_pull_clusapi_OpenGroup(struct ndr_pull *ndr, int flags, struct clusapi_OpenGroup *r)
    7232             : {
    7233           0 :         uint32_t size_lpszGroupName_1 = 0;
    7234           0 :         uint32_t length_lpszGroupName_1 = 0;
    7235           0 :         TALLOC_CTX *_mem_save_Status_0 = NULL;
    7236           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    7237           0 :         TALLOC_CTX *_mem_save_hGroup_0 = NULL;
    7238           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    7239           0 :         if (flags & NDR_IN) {
    7240           0 :                 NDR_ZERO_STRUCT(r->out);
    7241             : 
    7242           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpszGroupName));
    7243           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpszGroupName));
    7244           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpszGroupName, &size_lpszGroupName_1));
    7245           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpszGroupName, &length_lpszGroupName_1));
    7246           0 :                 if (length_lpszGroupName_1 > size_lpszGroupName_1) {
    7247           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpszGroupName_1, length_lpszGroupName_1);
    7248             :                 }
    7249           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpszGroupName_1, sizeof(uint16_t)));
    7250           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpszGroupName, length_lpszGroupName_1, sizeof(uint16_t), CH_UTF16));
    7251           0 :                 NDR_PULL_ALLOC(ndr, r->out.Status);
    7252           0 :                 NDR_ZERO_STRUCTP(r->out.Status);
    7253           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    7254           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    7255           0 :                 NDR_PULL_ALLOC(ndr, r->out.hGroup);
    7256           0 :                 NDR_ZERO_STRUCTP(r->out.hGroup);
    7257             :         }
    7258           0 :         if (flags & NDR_OUT) {
    7259             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    7260             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    7261           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7262           0 :                         NDR_PULL_ALLOC(ndr, r->out.Status);
    7263             :                 }
    7264           0 :                 _mem_save_Status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7265           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.Status, LIBNDR_FLAG_REF_ALLOC);
    7266           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.Status));
    7267           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Status_0, LIBNDR_FLAG_REF_ALLOC);
    7268           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7269           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    7270             :                 }
    7271           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7272           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    7273           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    7274           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    7275           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7276           0 :                         NDR_PULL_ALLOC(ndr, r->out.hGroup);
    7277             :                 }
    7278           0 :                 _mem_save_hGroup_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7279           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.hGroup, LIBNDR_FLAG_REF_ALLOC);
    7280           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.hGroup));
    7281           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hGroup_0, LIBNDR_FLAG_REF_ALLOC);
    7282             :         }
    7283           0 :         return NDR_ERR_SUCCESS;
    7284             : }
    7285             : 
    7286           0 : _PUBLIC_ void ndr_print_clusapi_OpenGroup(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_OpenGroup *r)
    7287             : {
    7288           0 :         ndr_print_struct(ndr, name, "clusapi_OpenGroup");
    7289           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    7290           0 :         ndr->depth++;
    7291           0 :         if (flags & NDR_SET_VALUES) {
    7292           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    7293             :         }
    7294           0 :         if (flags & NDR_IN) {
    7295           0 :                 ndr_print_struct(ndr, "in", "clusapi_OpenGroup");
    7296           0 :                 ndr->depth++;
    7297           0 :                 ndr_print_ptr(ndr, "lpszGroupName", r->in.lpszGroupName);
    7298           0 :                 ndr->depth++;
    7299           0 :                 ndr_print_string(ndr, "lpszGroupName", r->in.lpszGroupName);
    7300           0 :                 ndr->depth--;
    7301           0 :                 ndr->depth--;
    7302             :         }
    7303           0 :         if (flags & NDR_OUT) {
    7304           0 :                 ndr_print_struct(ndr, "out", "clusapi_OpenGroup");
    7305           0 :                 ndr->depth++;
    7306           0 :                 ndr_print_ptr(ndr, "Status", r->out.Status);
    7307           0 :                 ndr->depth++;
    7308           0 :                 ndr_print_WERROR(ndr, "Status", *r->out.Status);
    7309           0 :                 ndr->depth--;
    7310           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    7311           0 :                 ndr->depth++;
    7312           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    7313           0 :                 ndr->depth--;
    7314           0 :                 ndr_print_ptr(ndr, "hGroup", r->out.hGroup);
    7315           0 :                 ndr->depth++;
    7316           0 :                 ndr_print_policy_handle(ndr, "hGroup", r->out.hGroup);
    7317           0 :                 ndr->depth--;
    7318           0 :                 ndr->depth--;
    7319             :         }
    7320           0 :         ndr->depth--;
    7321             : }
    7322             : 
    7323           0 : static enum ndr_err_code ndr_push_clusapi_CreateGroup(struct ndr_push *ndr, int flags, const struct clusapi_CreateGroup *r)
    7324             : {
    7325           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    7326           0 :         if (flags & NDR_IN) {
    7327           0 :                 if (r->in.lpszGroupName == NULL) {
    7328           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7329             :                 }
    7330           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszGroupName, CH_UTF16)));
    7331           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    7332           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszGroupName, CH_UTF16)));
    7333           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpszGroupName, ndr_charset_length(r->in.lpszGroupName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    7334             :         }
    7335           0 :         if (flags & NDR_OUT) {
    7336           0 :                 if (r->out.Status == NULL) {
    7337           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7338             :                 }
    7339           0 :                 if (r->out.rpc_status == NULL) {
    7340           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7341             :                 }
    7342           0 :                 if (r->out.hGroup == NULL) {
    7343           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7344             :                 }
    7345           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.Status));
    7346           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    7347           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.hGroup));
    7348             :         }
    7349           0 :         return NDR_ERR_SUCCESS;
    7350             : }
    7351             : 
    7352           0 : static enum ndr_err_code ndr_pull_clusapi_CreateGroup(struct ndr_pull *ndr, int flags, struct clusapi_CreateGroup *r)
    7353             : {
    7354           0 :         uint32_t size_lpszGroupName_1 = 0;
    7355           0 :         uint32_t length_lpszGroupName_1 = 0;
    7356           0 :         TALLOC_CTX *_mem_save_Status_0 = NULL;
    7357           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    7358           0 :         TALLOC_CTX *_mem_save_hGroup_0 = NULL;
    7359           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    7360           0 :         if (flags & NDR_IN) {
    7361           0 :                 NDR_ZERO_STRUCT(r->out);
    7362             : 
    7363           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpszGroupName));
    7364           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpszGroupName));
    7365           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpszGroupName, &size_lpszGroupName_1));
    7366           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpszGroupName, &length_lpszGroupName_1));
    7367           0 :                 if (length_lpszGroupName_1 > size_lpszGroupName_1) {
    7368           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpszGroupName_1, length_lpszGroupName_1);
    7369             :                 }
    7370           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpszGroupName_1, sizeof(uint16_t)));
    7371           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpszGroupName, length_lpszGroupName_1, sizeof(uint16_t), CH_UTF16));
    7372           0 :                 NDR_PULL_ALLOC(ndr, r->out.Status);
    7373           0 :                 NDR_ZERO_STRUCTP(r->out.Status);
    7374           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    7375           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    7376           0 :                 NDR_PULL_ALLOC(ndr, r->out.hGroup);
    7377           0 :                 NDR_ZERO_STRUCTP(r->out.hGroup);
    7378             :         }
    7379           0 :         if (flags & NDR_OUT) {
    7380             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    7381             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    7382           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7383           0 :                         NDR_PULL_ALLOC(ndr, r->out.Status);
    7384             :                 }
    7385           0 :                 _mem_save_Status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7386           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.Status, LIBNDR_FLAG_REF_ALLOC);
    7387           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.Status));
    7388           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Status_0, LIBNDR_FLAG_REF_ALLOC);
    7389           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7390           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    7391             :                 }
    7392           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7393           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    7394           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    7395           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    7396           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7397           0 :                         NDR_PULL_ALLOC(ndr, r->out.hGroup);
    7398             :                 }
    7399           0 :                 _mem_save_hGroup_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7400           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.hGroup, LIBNDR_FLAG_REF_ALLOC);
    7401           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.hGroup));
    7402           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hGroup_0, LIBNDR_FLAG_REF_ALLOC);
    7403             :         }
    7404           0 :         return NDR_ERR_SUCCESS;
    7405             : }
    7406             : 
    7407           0 : _PUBLIC_ void ndr_print_clusapi_CreateGroup(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_CreateGroup *r)
    7408             : {
    7409           0 :         ndr_print_struct(ndr, name, "clusapi_CreateGroup");
    7410           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    7411           0 :         ndr->depth++;
    7412           0 :         if (flags & NDR_SET_VALUES) {
    7413           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    7414             :         }
    7415           0 :         if (flags & NDR_IN) {
    7416           0 :                 ndr_print_struct(ndr, "in", "clusapi_CreateGroup");
    7417           0 :                 ndr->depth++;
    7418           0 :                 ndr_print_ptr(ndr, "lpszGroupName", r->in.lpszGroupName);
    7419           0 :                 ndr->depth++;
    7420           0 :                 ndr_print_string(ndr, "lpszGroupName", r->in.lpszGroupName);
    7421           0 :                 ndr->depth--;
    7422           0 :                 ndr->depth--;
    7423             :         }
    7424           0 :         if (flags & NDR_OUT) {
    7425           0 :                 ndr_print_struct(ndr, "out", "clusapi_CreateGroup");
    7426           0 :                 ndr->depth++;
    7427           0 :                 ndr_print_ptr(ndr, "Status", r->out.Status);
    7428           0 :                 ndr->depth++;
    7429           0 :                 ndr_print_WERROR(ndr, "Status", *r->out.Status);
    7430           0 :                 ndr->depth--;
    7431           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    7432           0 :                 ndr->depth++;
    7433           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    7434           0 :                 ndr->depth--;
    7435           0 :                 ndr_print_ptr(ndr, "hGroup", r->out.hGroup);
    7436           0 :                 ndr->depth++;
    7437           0 :                 ndr_print_policy_handle(ndr, "hGroup", r->out.hGroup);
    7438           0 :                 ndr->depth--;
    7439           0 :                 ndr->depth--;
    7440             :         }
    7441           0 :         ndr->depth--;
    7442             : }
    7443             : 
    7444           0 : static enum ndr_err_code ndr_push_clusapi_DeleteGroup(struct ndr_push *ndr, int flags, const struct clusapi_DeleteGroup *r)
    7445             : {
    7446           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    7447           0 :         if (flags & NDR_IN) {
    7448           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.Group));
    7449           0 :                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.force));
    7450             :         }
    7451           0 :         if (flags & NDR_OUT) {
    7452           0 :                 if (r->out.rpc_status == NULL) {
    7453           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7454             :                 }
    7455           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    7456           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    7457             :         }
    7458           0 :         return NDR_ERR_SUCCESS;
    7459             : }
    7460             : 
    7461           0 : static enum ndr_err_code ndr_pull_clusapi_DeleteGroup(struct ndr_pull *ndr, int flags, struct clusapi_DeleteGroup *r)
    7462             : {
    7463           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    7464           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    7465           0 :         if (flags & NDR_IN) {
    7466           0 :                 NDR_ZERO_STRUCT(r->out);
    7467             : 
    7468           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.Group));
    7469           0 :                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.force));
    7470           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    7471           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    7472             :         }
    7473           0 :         if (flags & NDR_OUT) {
    7474             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    7475             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    7476           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7477           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    7478             :                 }
    7479           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7480           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    7481           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    7482           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    7483           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    7484             :         }
    7485           0 :         return NDR_ERR_SUCCESS;
    7486             : }
    7487             : 
    7488           0 : _PUBLIC_ void ndr_print_clusapi_DeleteGroup(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_DeleteGroup *r)
    7489             : {
    7490           0 :         ndr_print_struct(ndr, name, "clusapi_DeleteGroup");
    7491           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    7492           0 :         ndr->depth++;
    7493           0 :         if (flags & NDR_SET_VALUES) {
    7494           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    7495             :         }
    7496           0 :         if (flags & NDR_IN) {
    7497           0 :                 ndr_print_struct(ndr, "in", "clusapi_DeleteGroup");
    7498           0 :                 ndr->depth++;
    7499           0 :                 ndr_print_policy_handle(ndr, "Group", &r->in.Group);
    7500           0 :                 ndr_print_uint8(ndr, "force", r->in.force);
    7501           0 :                 ndr->depth--;
    7502             :         }
    7503           0 :         if (flags & NDR_OUT) {
    7504           0 :                 ndr_print_struct(ndr, "out", "clusapi_DeleteGroup");
    7505           0 :                 ndr->depth++;
    7506           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    7507           0 :                 ndr->depth++;
    7508           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    7509           0 :                 ndr->depth--;
    7510           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    7511           0 :                 ndr->depth--;
    7512             :         }
    7513           0 :         ndr->depth--;
    7514             : }
    7515             : 
    7516           0 : static enum ndr_err_code ndr_push_clusapi_CloseGroup(struct ndr_push *ndr, int flags, const struct clusapi_CloseGroup *r)
    7517             : {
    7518           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    7519           0 :         if (flags & NDR_IN) {
    7520           0 :                 if (r->in.Group == NULL) {
    7521           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7522             :                 }
    7523           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.Group));
    7524             :         }
    7525           0 :         if (flags & NDR_OUT) {
    7526           0 :                 if (r->out.Group == NULL) {
    7527           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7528             :                 }
    7529           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.Group));
    7530           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    7531             :         }
    7532           0 :         return NDR_ERR_SUCCESS;
    7533             : }
    7534             : 
    7535           0 : static enum ndr_err_code ndr_pull_clusapi_CloseGroup(struct ndr_pull *ndr, int flags, struct clusapi_CloseGroup *r)
    7536             : {
    7537           0 :         TALLOC_CTX *_mem_save_Group_0 = NULL;
    7538           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    7539           0 :         if (flags & NDR_IN) {
    7540           0 :                 NDR_ZERO_STRUCT(r->out);
    7541             : 
    7542           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7543           0 :                         NDR_PULL_ALLOC(ndr, r->in.Group);
    7544             :                 }
    7545           0 :                 _mem_save_Group_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7546           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->in.Group, LIBNDR_FLAG_REF_ALLOC);
    7547           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.Group));
    7548           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Group_0, LIBNDR_FLAG_REF_ALLOC);
    7549           0 :                 NDR_PULL_ALLOC(ndr, r->out.Group);
    7550           0 :                 *r->out.Group = *r->in.Group;
    7551             :         }
    7552           0 :         if (flags & NDR_OUT) {
    7553             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    7554             :                 if (r->in.Group == NULL) {
    7555             :                         NDR_PULL_ALLOC(ndr, r->in.Group);
    7556             :                         NDR_ZERO_STRUCTP(r->in.Group);
    7557             :                 }
    7558             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    7559           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7560           0 :                         NDR_PULL_ALLOC(ndr, r->out.Group);
    7561             :                 }
    7562           0 :                 _mem_save_Group_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7563           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.Group, LIBNDR_FLAG_REF_ALLOC);
    7564           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.Group));
    7565           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Group_0, LIBNDR_FLAG_REF_ALLOC);
    7566           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    7567             :         }
    7568           0 :         return NDR_ERR_SUCCESS;
    7569             : }
    7570             : 
    7571           0 : _PUBLIC_ void ndr_print_clusapi_CloseGroup(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_CloseGroup *r)
    7572             : {
    7573           0 :         ndr_print_struct(ndr, name, "clusapi_CloseGroup");
    7574           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    7575           0 :         ndr->depth++;
    7576           0 :         if (flags & NDR_SET_VALUES) {
    7577           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    7578             :         }
    7579           0 :         if (flags & NDR_IN) {
    7580           0 :                 ndr_print_struct(ndr, "in", "clusapi_CloseGroup");
    7581           0 :                 ndr->depth++;
    7582           0 :                 ndr_print_ptr(ndr, "Group", r->in.Group);
    7583           0 :                 ndr->depth++;
    7584           0 :                 ndr_print_policy_handle(ndr, "Group", r->in.Group);
    7585           0 :                 ndr->depth--;
    7586           0 :                 ndr->depth--;
    7587             :         }
    7588           0 :         if (flags & NDR_OUT) {
    7589           0 :                 ndr_print_struct(ndr, "out", "clusapi_CloseGroup");
    7590           0 :                 ndr->depth++;
    7591           0 :                 ndr_print_ptr(ndr, "Group", r->out.Group);
    7592           0 :                 ndr->depth++;
    7593           0 :                 ndr_print_policy_handle(ndr, "Group", r->out.Group);
    7594           0 :                 ndr->depth--;
    7595           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    7596           0 :                 ndr->depth--;
    7597             :         }
    7598           0 :         ndr->depth--;
    7599             : }
    7600             : 
    7601           0 : static enum ndr_err_code ndr_push_clusapi_GetGroupState(struct ndr_push *ndr, int flags, const struct clusapi_GetGroupState *r)
    7602             : {
    7603           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    7604           0 :         if (flags & NDR_IN) {
    7605           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hGroup));
    7606             :         }
    7607           0 :         if (flags & NDR_OUT) {
    7608           0 :                 if (r->out.State == NULL) {
    7609           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7610             :                 }
    7611           0 :                 if (r->out.NodeName == NULL) {
    7612           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7613             :                 }
    7614           0 :                 if (r->out.rpc_status == NULL) {
    7615           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7616             :                 }
    7617           0 :                 NDR_CHECK(ndr_push_clusapi_ClusterGroupState(ndr, NDR_SCALARS, *r->out.State));
    7618           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.NodeName));
    7619           0 :                 if (*r->out.NodeName) {
    7620           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.NodeName, CH_UTF16)));
    7621           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    7622           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.NodeName, CH_UTF16)));
    7623           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.NodeName, ndr_charset_length(*r->out.NodeName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    7624             :                 }
    7625           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    7626           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    7627             :         }
    7628           0 :         return NDR_ERR_SUCCESS;
    7629             : }
    7630             : 
    7631           0 : static enum ndr_err_code ndr_pull_clusapi_GetGroupState(struct ndr_pull *ndr, int flags, struct clusapi_GetGroupState *r)
    7632             : {
    7633             :         uint32_t _ptr_NodeName;
    7634           0 :         uint32_t size_NodeName_2 = 0;
    7635           0 :         uint32_t length_NodeName_2 = 0;
    7636           0 :         TALLOC_CTX *_mem_save_State_0 = NULL;
    7637           0 :         TALLOC_CTX *_mem_save_NodeName_0 = NULL;
    7638           0 :         TALLOC_CTX *_mem_save_NodeName_1 = NULL;
    7639           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    7640           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    7641           0 :         if (flags & NDR_IN) {
    7642           0 :                 NDR_ZERO_STRUCT(r->out);
    7643             : 
    7644           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hGroup));
    7645           0 :                 NDR_PULL_ALLOC(ndr, r->out.State);
    7646           0 :                 NDR_ZERO_STRUCTP(r->out.State);
    7647           0 :                 NDR_PULL_ALLOC(ndr, r->out.NodeName);
    7648           0 :                 NDR_ZERO_STRUCTP(r->out.NodeName);
    7649           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    7650           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    7651             :         }
    7652           0 :         if (flags & NDR_OUT) {
    7653             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    7654             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    7655           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7656           0 :                         NDR_PULL_ALLOC(ndr, r->out.State);
    7657             :                 }
    7658           0 :                 _mem_save_State_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7659           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.State, LIBNDR_FLAG_REF_ALLOC);
    7660           0 :                 NDR_CHECK(ndr_pull_clusapi_ClusterGroupState(ndr, NDR_SCALARS, r->out.State));
    7661           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_State_0, LIBNDR_FLAG_REF_ALLOC);
    7662           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7663           0 :                         NDR_PULL_ALLOC(ndr, r->out.NodeName);
    7664             :                 }
    7665           0 :                 _mem_save_NodeName_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7666           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.NodeName, LIBNDR_FLAG_REF_ALLOC);
    7667           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NodeName));
    7668           0 :                 if (_ptr_NodeName) {
    7669           0 :                         NDR_PULL_ALLOC(ndr, *r->out.NodeName);
    7670             :                 } else {
    7671           0 :                         *r->out.NodeName = NULL;
    7672             :                 }
    7673           0 :                 if (*r->out.NodeName) {
    7674           0 :                         _mem_save_NodeName_1 = NDR_PULL_GET_MEM_CTX(ndr);
    7675           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.NodeName, 0);
    7676           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.NodeName));
    7677           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.NodeName));
    7678           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)r->out.NodeName, &size_NodeName_2));
    7679           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)r->out.NodeName, &length_NodeName_2));
    7680           0 :                         if (length_NodeName_2 > size_NodeName_2) {
    7681           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_NodeName_2, length_NodeName_2);
    7682             :                         }
    7683           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_NodeName_2, sizeof(uint16_t)));
    7684           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.NodeName, length_NodeName_2, sizeof(uint16_t), CH_UTF16));
    7685           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NodeName_1, 0);
    7686             :                 }
    7687           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NodeName_0, LIBNDR_FLAG_REF_ALLOC);
    7688           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7689           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    7690             :                 }
    7691           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7692           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    7693           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    7694           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    7695           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    7696             :         }
    7697           0 :         return NDR_ERR_SUCCESS;
    7698             : }
    7699             : 
    7700           0 : _PUBLIC_ void ndr_print_clusapi_GetGroupState(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_GetGroupState *r)
    7701             : {
    7702           0 :         ndr_print_struct(ndr, name, "clusapi_GetGroupState");
    7703           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    7704           0 :         ndr->depth++;
    7705           0 :         if (flags & NDR_SET_VALUES) {
    7706           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    7707             :         }
    7708           0 :         if (flags & NDR_IN) {
    7709           0 :                 ndr_print_struct(ndr, "in", "clusapi_GetGroupState");
    7710           0 :                 ndr->depth++;
    7711           0 :                 ndr_print_policy_handle(ndr, "hGroup", &r->in.hGroup);
    7712           0 :                 ndr->depth--;
    7713             :         }
    7714           0 :         if (flags & NDR_OUT) {
    7715           0 :                 ndr_print_struct(ndr, "out", "clusapi_GetGroupState");
    7716           0 :                 ndr->depth++;
    7717           0 :                 ndr_print_ptr(ndr, "State", r->out.State);
    7718           0 :                 ndr->depth++;
    7719           0 :                 ndr_print_clusapi_ClusterGroupState(ndr, "State", *r->out.State);
    7720           0 :                 ndr->depth--;
    7721           0 :                 ndr_print_ptr(ndr, "NodeName", r->out.NodeName);
    7722           0 :                 ndr->depth++;
    7723           0 :                 ndr_print_ptr(ndr, "NodeName", *r->out.NodeName);
    7724           0 :                 ndr->depth++;
    7725           0 :                 if (*r->out.NodeName) {
    7726           0 :                         ndr_print_string(ndr, "NodeName", *r->out.NodeName);
    7727             :                 }
    7728           0 :                 ndr->depth--;
    7729           0 :                 ndr->depth--;
    7730           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    7731           0 :                 ndr->depth++;
    7732           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    7733           0 :                 ndr->depth--;
    7734           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    7735           0 :                 ndr->depth--;
    7736             :         }
    7737           0 :         ndr->depth--;
    7738             : }
    7739             : 
    7740           0 : static enum ndr_err_code ndr_push_clusapi_SetGroupName(struct ndr_push *ndr, int flags, const struct clusapi_SetGroupName *r)
    7741             : {
    7742           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    7743           0 :         if (flags & NDR_IN) {
    7744           0 :                 if (r->in.lpszGroupName == NULL) {
    7745           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7746             :                 }
    7747           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hGroup));
    7748           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszGroupName, CH_UTF16)));
    7749           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    7750           0 :                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.lpszGroupName, CH_UTF16)));
    7751           0 :                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.lpszGroupName, ndr_charset_length(r->in.lpszGroupName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    7752             :         }
    7753           0 :         if (flags & NDR_OUT) {
    7754           0 :                 if (r->out.rpc_status == NULL) {
    7755           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7756             :                 }
    7757           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    7758           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    7759             :         }
    7760           0 :         return NDR_ERR_SUCCESS;
    7761             : }
    7762             : 
    7763           0 : static enum ndr_err_code ndr_pull_clusapi_SetGroupName(struct ndr_pull *ndr, int flags, struct clusapi_SetGroupName *r)
    7764             : {
    7765           0 :         uint32_t size_lpszGroupName_1 = 0;
    7766           0 :         uint32_t length_lpszGroupName_1 = 0;
    7767           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    7768           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    7769           0 :         if (flags & NDR_IN) {
    7770           0 :                 NDR_ZERO_STRUCT(r->out);
    7771             : 
    7772           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hGroup));
    7773           0 :                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.lpszGroupName));
    7774           0 :                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.lpszGroupName));
    7775           0 :                 NDR_CHECK(ndr_steal_array_size(ndr, (void*)&r->in.lpszGroupName, &size_lpszGroupName_1));
    7776           0 :                 NDR_CHECK(ndr_steal_array_length(ndr, (void*)&r->in.lpszGroupName, &length_lpszGroupName_1));
    7777           0 :                 if (length_lpszGroupName_1 > size_lpszGroupName_1) {
    7778           0 :                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lpszGroupName_1, length_lpszGroupName_1);
    7779             :                 }
    7780           0 :                 NDR_CHECK(ndr_check_string_terminator(ndr, length_lpszGroupName_1, sizeof(uint16_t)));
    7781           0 :                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.lpszGroupName, length_lpszGroupName_1, sizeof(uint16_t), CH_UTF16));
    7782           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    7783           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    7784             :         }
    7785           0 :         if (flags & NDR_OUT) {
    7786             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    7787             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    7788           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7789           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    7790             :                 }
    7791           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7792           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    7793           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    7794           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    7795           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    7796             :         }
    7797           0 :         return NDR_ERR_SUCCESS;
    7798             : }
    7799             : 
    7800           0 : _PUBLIC_ void ndr_print_clusapi_SetGroupName(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_SetGroupName *r)
    7801             : {
    7802           0 :         ndr_print_struct(ndr, name, "clusapi_SetGroupName");
    7803           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    7804           0 :         ndr->depth++;
    7805           0 :         if (flags & NDR_SET_VALUES) {
    7806           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    7807             :         }
    7808           0 :         if (flags & NDR_IN) {
    7809           0 :                 ndr_print_struct(ndr, "in", "clusapi_SetGroupName");
    7810           0 :                 ndr->depth++;
    7811           0 :                 ndr_print_policy_handle(ndr, "hGroup", &r->in.hGroup);
    7812           0 :                 ndr_print_ptr(ndr, "lpszGroupName", r->in.lpszGroupName);
    7813           0 :                 ndr->depth++;
    7814           0 :                 ndr_print_string(ndr, "lpszGroupName", r->in.lpszGroupName);
    7815           0 :                 ndr->depth--;
    7816           0 :                 ndr->depth--;
    7817             :         }
    7818           0 :         if (flags & NDR_OUT) {
    7819           0 :                 ndr_print_struct(ndr, "out", "clusapi_SetGroupName");
    7820           0 :                 ndr->depth++;
    7821           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    7822           0 :                 ndr->depth++;
    7823           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    7824           0 :                 ndr->depth--;
    7825           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    7826           0 :                 ndr->depth--;
    7827             :         }
    7828           0 :         ndr->depth--;
    7829             : }
    7830             : 
    7831           0 : static enum ndr_err_code ndr_push_clusapi_GetGroupId(struct ndr_push *ndr, int flags, const struct clusapi_GetGroupId *r)
    7832             : {
    7833           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
    7834           0 :         if (flags & NDR_IN) {
    7835           0 :                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, &r->in.hGroup));
    7836             :         }
    7837           0 :         if (flags & NDR_OUT) {
    7838           0 :                 if (r->out.pGuid == NULL) {
    7839           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7840             :                 }
    7841           0 :                 if (r->out.rpc_status == NULL) {
    7842           0 :                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
    7843             :                 }
    7844           0 :                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.pGuid));
    7845           0 :                 if (*r->out.pGuid) {
    7846           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.pGuid, CH_UTF16)));
    7847           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
    7848           0 :                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.pGuid, CH_UTF16)));
    7849           0 :                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.pGuid, ndr_charset_length(*r->out.pGuid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
    7850             :                 }
    7851           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.rpc_status));
    7852           0 :                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
    7853             :         }
    7854           0 :         return NDR_ERR_SUCCESS;
    7855             : }
    7856             : 
    7857           0 : static enum ndr_err_code ndr_pull_clusapi_GetGroupId(struct ndr_pull *ndr, int flags, struct clusapi_GetGroupId *r)
    7858             : {
    7859             :         uint32_t _ptr_pGuid;
    7860           0 :         uint32_t size_pGuid_2 = 0;
    7861           0 :         uint32_t length_pGuid_2 = 0;
    7862           0 :         TALLOC_CTX *_mem_save_pGuid_0 = NULL;
    7863           0 :         TALLOC_CTX *_mem_save_pGuid_1 = NULL;
    7864           0 :         TALLOC_CTX *_mem_save_rpc_status_0 = NULL;
    7865           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
    7866           0 :         if (flags & NDR_IN) {
    7867           0 :                 NDR_ZERO_STRUCT(r->out);
    7868             : 
    7869           0 :                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, &r->in.hGroup));
    7870           0 :                 NDR_PULL_ALLOC(ndr, r->out.pGuid);
    7871           0 :                 NDR_ZERO_STRUCTP(r->out.pGuid);
    7872           0 :                 NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    7873           0 :                 NDR_ZERO_STRUCTP(r->out.rpc_status);
    7874             :         }
    7875           0 :         if (flags & NDR_OUT) {
    7876             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    7877             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
    7878           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7879           0 :                         NDR_PULL_ALLOC(ndr, r->out.pGuid);
    7880             :                 }
    7881           0 :                 _mem_save_pGuid_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7882           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pGuid, LIBNDR_FLAG_REF_ALLOC);
    7883           0 :                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pGuid));
    7884           0 :                 if (_ptr_pGuid) {
    7885           0 :                         NDR_PULL_ALLOC(ndr, *r->out.pGuid);
    7886             :                 } else {
    7887           0 :                         *r->out.pGuid = NULL;
    7888             :                 }
    7889           0 :                 if (*r->out.pGuid) {
    7890           0 :                         _mem_save_pGuid_1 = NDR_PULL_GET_MEM_CTX(ndr);
    7891           0 :                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.pGuid, 0);
    7892           0 :                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.pGuid));
    7893           0 :                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.pGuid));
    7894           0 :                         NDR_CHECK(ndr_steal_array_size(ndr, (void*)r->out.pGuid, &size_pGuid_2));
    7895           0 :                         NDR_CHECK(ndr_steal_array_length(ndr, (void*)r->out.pGuid, &length_pGuid_2));
    7896           0 :                         if (length_pGuid_2 > size_pGuid_2) {
    7897           0 :                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_pGuid_2, length_pGuid_2);
    7898             :                         }
    7899           0 :                         NDR_CHECK(ndr_check_string_terminator(ndr, length_pGuid_2, sizeof(uint16_t)));
    7900           0 :                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.pGuid, length_pGuid_2, sizeof(uint16_t), CH_UTF16));
    7901           0 :                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pGuid_1, 0);
    7902             :                 }
    7903           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pGuid_0, LIBNDR_FLAG_REF_ALLOC);
    7904           0 :                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
    7905           0 :                         NDR_PULL_ALLOC(ndr, r->out.rpc_status);
    7906             :                 }
    7907           0 :                 _mem_save_rpc_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
    7908           0 :                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rpc_status, LIBNDR_FLAG_REF_ALLOC);
    7909           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, r->out.rpc_status));
    7910           0 :                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rpc_status_0, LIBNDR_FLAG_REF_ALLOC);
    7911           0 :                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
    7912             :         }
    7913           0 :         return NDR_ERR_SUCCESS;
    7914             : }
    7915             : 
    7916           0 : _PUBLIC_ void ndr_print_clusapi_GetGroupId(struct ndr_print *ndr, const char *name, int flags, const struct clusapi_GetGroupId *r)
    7917             : {
    7918           0 :         ndr_print_struct(ndr, name, "clusapi_GetGroupId");
    7919           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
    7920           0 :         ndr->depth++;
    7921           0 :         if (flags & NDR_SET_VALUES) {
    7922           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
    7923             :         }
    7924           0 :         if (flags & NDR_IN) {
    7925           0 :                 ndr_print_struct(ndr, "in", "clusapi_GetGroupId");
    7926           0 :                 ndr->depth++;
    7927           0 :                 ndr_print_policy_handle(ndr, "hGroup", &r->in.hGroup);
    7928           0 :                 ndr->depth--;
    7929             :         }
    7930           0 :         if (flags & NDR_OUT) {
    7931           0 :                 ndr_print_struct(ndr, "out", "clusapi_GetGroupId");
    7932           0 :                 ndr->depth++;
    7933           0 :                 ndr_print_ptr(ndr, "pGuid", r->out.pGuid);
    7934           0 :                 ndr->depth++;
    7935           0 :                 ndr_print_ptr(ndr, "pGuid", *r->out.pGuid);
    7936           0 :                 ndr->depth++;
    7937           0 :                 if (*r->out.pGuid) {
    7938           0 :                         ndr_print_string(ndr, "pGuid", *r->out.pGuid);
    7939             :                 }
    7940           0 :                 ndr->depth--;
    7941           0 :                 ndr->depth--;
    7942           0 :                 ndr_print_ptr(ndr, "rpc_status", r->out.rpc_status);
    7943           0 :                 ndr->depth++;
    7944           0 :                 ndr_print_WERROR(ndr, "rpc_status", *r->out.rpc_status);
    7945           0 :                 ndr->depth--;
    7946           0 :                 ndr_print_WERROR(ndr, "result", r->out.result);
    7947           0 :                 ndr->depth--;
    7948             :         }
    79